mirror of
https://github.com/WiVRn/WiVRn.git
synced 2026-11-20 09:01:39 -08:00
177 lines
6.6 KiB
C++
177 lines
6.6 KiB
C++
/*
|
|
* WiVRn VR streaming
|
|
* Copyright (C) 2025 Patrick Nicolas <[email protected]>
|
|
*
|
|
* 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 <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "video_encoder_pyrowave.h"
|
|
#include "encoder/encoder_settings.h"
|
|
#include "util/u_logging.h"
|
|
#include "utils/wivrn_vk_bundle.h"
|
|
|
|
#include <ranges>
|
|
|
|
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<bool, vk::Semaphore> video_encoder_pyrowave::present_image(vk::Image y_cbcr, vk::raii::CommandBuffer & cmd_buf, uint8_t slot, uint64_t frame_index)
|
|
{
|
|
std::array<vk::ImageView, 3> 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::data> 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
|