/* * WiVRn VR streaming * Copyright (C) 2025 Patrick Nicolas * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "video_encoder_pyrowave.h" #include "encoder/encoder_settings.h" #include "util/u_logging.h" #include "utils/wivrn_vk_bundle.h" #include namespace wivrn { video_encoder_pyrowave::video_encoder_pyrowave(wivrn_vk_bundle & vk, encoder_settings & settings, float fps, uint8_t stream_idx) : video_encoder(stream_idx, settings.channels, 1, true), enc(vk.physical_device, vk.device, settings.width, settings.height, PyroWave::ChromaSubsampling::Chroma420), encoded_size(settings.bitrate / (fps * 8)) { size_t meta_size = enc.get_meta_required_size(); meta_buf = buffer_allocation( vk.device, { .size = meta_size, .usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eTransferSrc, }, { .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT, .usage = VMA_MEMORY_USAGE_AUTO, }, "pyrowave encoder meta buffer"); data_buf = buffer_allocation( vk.device, { .size = encoded_size + 2 * meta_size, .usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eTransferSrc, }, { .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT, .usage = VMA_MEMORY_USAGE_AUTO, }, "pyrowave encoder data buffer"); if (not(meta_buf.properties() & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { meta_buf_staging = buffer_allocation( vk.device, { .size = meta_buf.info().size, .usage = vk::BufferUsageFlagBits::eTransferDst, }, { .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT, .usage = VMA_MEMORY_USAGE_AUTO, }, "pyrowave encoder meta staging buffer"); } if (not(data_buf.properties() & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { data_buf_staging = buffer_allocation( vk.device, { .size = data_buf.info().size, .usage = vk::BufferUsageFlagBits::eTransferDst, }, { .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT, .usage = VMA_MEMORY_USAGE_AUTO, }, "pyrowave encoder data staging buffer"); } } std::pair video_encoder_pyrowave::present_image(vk::Image y_cbcr, vk::raii::CommandBuffer & cmd_buf, uint8_t slot, uint64_t frame_index) { std::array image_view; if (auto it = image_views.find(y_cbcr); it != image_views.end()) { std::ranges::copy(it->second, image_view.begin()); } else { auto y = enc.device.createImageView( vk::ImageViewCreateInfo{ .image = y_cbcr, .viewType = vk::ImageViewType::e2D, .format = vk::Format::eR8Unorm, .subresourceRange = { .aspectMask = vk::ImageAspectFlagBits::ePlane0, .levelCount = 1, .baseArrayLayer = uint32_t(channels), .layerCount = 1, }}); auto cb = enc.device.createImageView( vk::ImageViewCreateInfo{ .image = y_cbcr, .viewType = vk::ImageViewType::e2D, .format = vk::Format::eR8G8Unorm, .subresourceRange = { .aspectMask = vk::ImageAspectFlagBits::ePlane1, .levelCount = 1, .baseArrayLayer = uint32_t(channels), .layerCount = 1, }}); auto cr = enc.device.createImageView( vk::ImageViewCreateInfo{ .image = y_cbcr, .viewType = vk::ImageViewType::e2D, .format = vk::Format::eR8G8Unorm, .components = { .r = vk::ComponentSwizzle::eG, }, .subresourceRange = { .aspectMask = vk::ImageAspectFlagBits::ePlane1, .levelCount = 1, .baseArrayLayer = uint32_t(channels), .layerCount = 1, }}); image_view = {y, cb, cr}; image_views.emplace(y_cbcr, std::array{std::move(y), std::move(cb), std::move(cr)}); } PyroWave::Encoder::BitstreamBuffers buffers{ .meta = { .buffer = meta_buf, .size = meta_buf.info().size, }, .bitstream = { .buffer = data_buf, .size = data_buf.info().size, }, .target_size = encoded_size, }; if (not enc.encode(cmd_buf, image_view, buffers)) U_LOG_W("pyrowave encode failed"); if (meta_buf_staging) cmd_buf.copyBuffer(meta_buf, meta_buf_staging, vk::BufferCopy{.size = buffers.meta.size}); if (data_buf_staging) cmd_buf.copyBuffer(data_buf, data_buf_staging, vk::BufferCopy{.size = buffers.bitstream.size}); return {false, nullptr}; } std::optional video_encoder_pyrowave::encode(bool idr, std::chrono::steady_clock::time_point pts, uint8_t slot) { reordered_packet_buffer.resize(8 * 1024 * 1024); packets.resize(enc.compute_num_packets(meta_buf_staging ? meta_buf_staging.map() : meta_buf.map(), 8 * 1024)); enc.packetize( packets.data(), 8 * 1024, reordered_packet_buffer.data(), reordered_packet_buffer.size(), meta_buf_staging ? meta_buf_staging.map() : meta_buf.map(), data_buf_staging ? data_buf_staging.map() : data_buf.map()); for (auto & p: packets) SendData({reordered_packet_buffer.data() + p.offset, p.size}, &p == &packets.back()); return {}; } video_encoder_pyrowave::~video_encoder_pyrowave() {} } // namespace wivrn