mirror of
https://github.com/WiVRn/WiVRn.git
synced 2026-11-20 09:01:39 -08:00
826 lines
26 KiB
C++
826 lines
26 KiB
C++
/*
|
|
* WiVRn VR streaming
|
|
* Copyright (C) 2026 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/>.
|
|
*/
|
|
|
|
// Copyright 2019-2024, Collabora, Ltd.
|
|
// Copyright 2025-2026, NVIDIA CORPORATION.
|
|
|
|
#include "compositor.h"
|
|
|
|
// Monado includes
|
|
#include "driver/xrt_cast.h"
|
|
#include "main/comp_frame.h"
|
|
#include "util/comp_render_helpers.h"
|
|
#include "util/comp_vulkan.h"
|
|
#include "util/u_debug.h"
|
|
#include "util/u_handles.h"
|
|
#include "util/u_time.h"
|
|
#include "vk/vk_helpers.h"
|
|
|
|
#include "driver/wivrn_session.h"
|
|
#include "encoder/video_encoder.h"
|
|
#include "inplace_vector.hpp"
|
|
#include "utils/method.h"
|
|
|
|
#include "xrt/xrt_config_build.h" // IWYU pragma: keep
|
|
#ifdef XRT_FEATURE_RENDERDOC
|
|
#include "renderdoc_app.h"
|
|
|
|
static auto renderdoc()
|
|
{
|
|
auto x = []() {
|
|
RENDERDOC_API_1_5_0 * rdoc_api = nullptr;
|
|
const char * env = std::getenv("ENABLE_VULKAN_RENDERDOC_CAPTURE");
|
|
if (not env or env != std::string_view("1"))
|
|
return rdoc_api;
|
|
void * mod = dlopen("librenderdoc.so", RTLD_NOW | RTLD_NOLOAD);
|
|
if (mod)
|
|
{
|
|
pRENDERDOC_GetAPI RENDERDOC_GetAPI = (pRENDERDOC_GetAPI)dlsym(mod, "RENDERDOC_GetAPI");
|
|
XRT_MAYBE_UNUSED int ret = RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_5_0, (void **)&rdoc_api);
|
|
assert(ret == 1);
|
|
}
|
|
return rdoc_api;
|
|
};
|
|
static auto res = x();
|
|
return res;
|
|
}
|
|
#endif
|
|
|
|
DEBUG_GET_ONCE_LOG_OPTION(log, "XRT_COMPOSITOR_LOG", U_LOGGING_INFO)
|
|
|
|
namespace details
|
|
{
|
|
template <auto Method, typename Result, typename... Args>
|
|
struct method_trait<Method, Result (wivrn::compositor::*)(Args...)>
|
|
{
|
|
static Result magic(xrt_compositor * arg, Args... args)
|
|
{
|
|
return std::invoke(
|
|
Method,
|
|
static_cast<wivrn::compositor *>(reinterpret_cast<struct comp_base *>(arg)),
|
|
args...);
|
|
}
|
|
};
|
|
|
|
} // namespace details
|
|
|
|
namespace
|
|
{
|
|
os_mutex copy_mutex(std::mutex & m)
|
|
{
|
|
return {
|
|
.mutex = *m.native_handle(),
|
|
#ifndef NDEBUG
|
|
.initialized = true,
|
|
.recursive = false,
|
|
#endif
|
|
};
|
|
}
|
|
|
|
const comp_swapchain_image & get_layer_image(const comp_layer & layer, uint32_t swapchain_index, uint32_t image_index)
|
|
{
|
|
return reinterpret_cast<struct comp_swapchain *>(comp_layer_get_swapchain(&layer, swapchain_index))->images[image_index];
|
|
}
|
|
|
|
std::array<vk::Format, 3> image_formats(int bit_depth)
|
|
{
|
|
switch (bit_depth)
|
|
{
|
|
case 8:
|
|
return {
|
|
vk::Format::eR8Unorm,
|
|
vk::Format::eR8G8Unorm,
|
|
vk::Format::eG8B8R82Plane420Unorm,
|
|
};
|
|
case 10:
|
|
return {
|
|
vk::Format::eR16Unorm,
|
|
vk::Format::eR16G16Unorm,
|
|
vk::Format::eG10X6B10X6R10X62Plane420Unorm3Pack16,
|
|
};
|
|
}
|
|
throw std::runtime_error(std::format("Unsupported bit depth {}", bit_depth));
|
|
}
|
|
|
|
std::array<wivrn::compositor::image, 2> make_images(wivrn::vk_bundle & vk, vk::CommandPool command_pool, std::span<wivrn::encoder_settings> encoders)
|
|
{
|
|
auto formats = image_formats(encoders[0].bit_depth);
|
|
|
|
vk::StructureChain image_info{
|
|
vk::ImageCreateInfo{
|
|
.flags = vk::ImageCreateFlagBits::eExtendedUsage | vk::ImageCreateFlagBits::eMutableFormat,
|
|
.imageType = vk::ImageType::e2D,
|
|
.format = formats.back(),
|
|
.extent = {
|
|
.width = encoders[0].width,
|
|
.height = encoders[0].height,
|
|
.depth = 1,
|
|
},
|
|
.mipLevels = 1,
|
|
.arrayLayers = 3, // left, right then alpha
|
|
.samples = vk::SampleCountFlagBits::e1,
|
|
.usage = vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc,
|
|
},
|
|
vk::ImageFormatListCreateInfo{
|
|
.viewFormatCount = formats.size(),
|
|
.pViewFormats = formats.data(),
|
|
},
|
|
};
|
|
#if WIVRN_USE_VULKAN_ENCODE
|
|
if (
|
|
std::get<vk::PhysicalDeviceVideoMaintenance1FeaturesKHR>(vk.feat).videoMaintenance1 and
|
|
std::ranges::contains(
|
|
encoders,
|
|
wivrn::encoder_vulkan,
|
|
&wivrn::encoder_settings::encoder_name))
|
|
{
|
|
image_info.get().flags |= vk::ImageCreateFlagBits::eVideoProfileIndependentKHR;
|
|
image_info.get().usage |= vk::ImageUsageFlagBits::eVideoEncodeSrcKHR;
|
|
}
|
|
#endif
|
|
|
|
auto make_image = [&](int i) {
|
|
vk::ImageViewUsageCreateInfo usage{
|
|
.usage = vk::ImageUsageFlagBits::eStorage,
|
|
};
|
|
image_allocation image{
|
|
vk.device,
|
|
image_info.get(),
|
|
VmaAllocationCreateInfo{.usage = VMA_MEMORY_USAGE_AUTO},
|
|
std::format("compositor YCbCr image {}", i),
|
|
};
|
|
vk::Image vk_image{image};
|
|
return wivrn::compositor::image{
|
|
.image{std::move(image)},
|
|
.view_y{
|
|
vk.device,
|
|
{
|
|
.pNext = &usage,
|
|
.image = vk_image,
|
|
.viewType = vk::ImageViewType::e2DArray,
|
|
.format = formats[0],
|
|
.subresourceRange = {
|
|
.aspectMask = vk::ImageAspectFlagBits::ePlane0,
|
|
.levelCount = 1,
|
|
.layerCount = image_info.get().arrayLayers,
|
|
},
|
|
},
|
|
},
|
|
.view_cbcr{
|
|
vk.device,
|
|
{
|
|
.pNext = &usage,
|
|
.image = vk_image,
|
|
.viewType = vk::ImageViewType::e2DArray,
|
|
.format = formats[1],
|
|
.subresourceRange = {
|
|
.aspectMask = vk::ImageAspectFlagBits::ePlane1,
|
|
.levelCount = 1,
|
|
.layerCount = image_info.get().arrayLayers,
|
|
},
|
|
},
|
|
}};
|
|
};
|
|
|
|
return {make_image(0), make_image(1)};
|
|
}
|
|
|
|
vk::raii::Semaphore make_semaphore(wivrn::vk_bundle & vk)
|
|
{
|
|
vk::raii::Semaphore res{
|
|
vk.device,
|
|
vk::StructureChain{
|
|
vk::SemaphoreCreateInfo{},
|
|
vk::SemaphoreTypeCreateInfo{
|
|
.semaphoreType = vk::SemaphoreType::eTimeline,
|
|
},
|
|
}
|
|
.get(),
|
|
};
|
|
vk.name(res, "compositor semaphore");
|
|
return res;
|
|
}
|
|
|
|
vk::Extent3D render_extent(const wivrn::from_headset::headset_info_packet & info)
|
|
{
|
|
return {
|
|
.width = info.render_eye_width,
|
|
.height = info.render_eye_height,
|
|
.depth = 1,
|
|
};
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace wivrn
|
|
{
|
|
|
|
void compositor::timings::add(float us)
|
|
{
|
|
int index = this->index;
|
|
this->index = (this->index + 1) % values.size();
|
|
values[index] = us;
|
|
}
|
|
|
|
xrt_result_t compositor::predict_frame(int64_t * out_frame_id,
|
|
int64_t * out_wake_time_ns,
|
|
int64_t * out_predicted_gpu_time_ns,
|
|
int64_t * out_predicted_display_time_ns,
|
|
int64_t * out_predicted_display_period_ns)
|
|
{
|
|
int64_t frame_id = -1;
|
|
int64_t wake_up_time_ns = 0;
|
|
int64_t present_slop_ns = 0;
|
|
int64_t desired_present_time_ns = 0;
|
|
int64_t predicted_display_time_ns = 0;
|
|
pacer.predict(
|
|
frame_id,
|
|
wake_up_time_ns,
|
|
desired_present_time_ns,
|
|
present_slop_ns,
|
|
predicted_display_time_ns);
|
|
|
|
frame.waited.id = frame_id;
|
|
frame.waited.desired_present_time_ns = desired_present_time_ns;
|
|
frame.waited.present_slop_ns = present_slop_ns;
|
|
frame.waited.predicted_display_time_ns = predicted_display_time_ns;
|
|
|
|
*out_frame_id = frame_id;
|
|
*out_wake_time_ns = wake_up_time_ns;
|
|
*out_predicted_gpu_time_ns = desired_present_time_ns; // Not quite right but close enough.
|
|
*out_predicted_display_time_ns = predicted_display_time_ns;
|
|
*out_predicted_display_period_ns = pacer.get_frame_duration();
|
|
return XRT_SUCCESS;
|
|
}
|
|
|
|
xrt_result_t compositor::mark_frame(int64_t frame_id,
|
|
xrt_compositor_frame_point point,
|
|
int64_t when_ns)
|
|
{
|
|
switch (point)
|
|
{
|
|
case XRT_COMPOSITOR_FRAME_POINT_WOKE:
|
|
session.dump_time("wake_up", frame_id, when_ns);
|
|
return XRT_SUCCESS;
|
|
default:
|
|
assert(false);
|
|
}
|
|
return XRT_ERROR_VULKAN;
|
|
}
|
|
|
|
xrt_result_t compositor::layer_commit(xrt_graphics_sync_handle_t sync_handle)
|
|
{
|
|
u_graphics_sync_unref(&sync_handle);
|
|
|
|
// Move waited frame to rendering frame, clear waited.
|
|
comp_frame_move_and_clear_locked(&frame.rendering, &frame.waited);
|
|
|
|
U_LOG_IFL_D(log_level, "frame %ld commit %d layers", frame.rendering.id, layer_accum.layer_count);
|
|
|
|
if (encode_request >= 0 // encoders have not picked up the previous frame
|
|
or layer_accum.layer_count == 0 or not session.connected() or not session.get_offset())
|
|
{
|
|
comp_frame_clear_locked(&frame.rendering);
|
|
return XRT_SUCCESS;
|
|
}
|
|
|
|
int i = acquire_image();
|
|
if (i < 0)
|
|
{
|
|
comp_frame_clear_locked(&frame.rendering);
|
|
return XRT_SUCCESS;
|
|
}
|
|
|
|
#ifdef XRT_FEATURE_RENDERDOC
|
|
if (auto r = renderdoc())
|
|
r->StartFrameCapture(NULL, NULL);
|
|
#endif
|
|
|
|
auto & view_info = images[i].view_info;
|
|
images[i].frame_index = frame.rendering.id;
|
|
view_info = {
|
|
.display_time = session.get_offset().to_headset(frame.rendering.predicted_display_time_ns),
|
|
.alpha = layer_accum.data.env_blend_mode == XRT_BLEND_MODE_ALPHA_BLEND,
|
|
};
|
|
|
|
session.dump_time("begin", frame.rendering.id, os_monotonic_get_ns());
|
|
|
|
cmd_pool.reset();
|
|
cmd.begin({.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
|
|
|
|
cmd.resetQueryPool(*query_pool, 0, 3);
|
|
cmd.writeTimestamp(vk::PipelineStageFlagBits::eTopOfPipe, *query_pool, 0);
|
|
|
|
bool flip_y = false;
|
|
std::array<vk::ImageView, 2> src;
|
|
std::array<xrt_rect, 2> src_rect;
|
|
std::array<xrt_fov, 2> src_fov;
|
|
|
|
beman::inplace_vector::inplace_vector<vk::ImageMemoryBarrier2, 3> image_barriers;
|
|
|
|
// Check if we can pass a layer directly to foveation
|
|
if (layer_accum.layer_count == 1 and
|
|
(layer_accum.layers[0].data.type == XRT_LAYER_PROJECTION or
|
|
layer_accum.layers[0].data.type == XRT_LAYER_PROJECTION_DEPTH))
|
|
{
|
|
const auto & layer = layer_accum.layers[0];
|
|
for (int view = 0; view < 2; ++view)
|
|
{
|
|
const auto & data = (layer.data.type == XRT_LAYER_PROJECTION ? layer.data.proj.v : layer.data.depth.v)[view];
|
|
src[view] = get_image_view(
|
|
&get_layer_image(layer, view, data.sub.image_index),
|
|
layer.data.flags,
|
|
data.sub.array_index);
|
|
src_rect[view] = data.sub.rect;
|
|
src_fov[view] = data.fov;
|
|
flip_y = layer.data.flip_y;
|
|
view_info.pose[view] = xrt_cast(data.pose);
|
|
view_info.fov[view] = xrt_cast(data.fov);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no fast-path, squash layers
|
|
std::array<xrt_pose, 2> poses;
|
|
const auto extent = images[0].image.info().extent;
|
|
std::tie(poses, src_fov, src_rect) = squasher.do_layers(
|
|
vk.device,
|
|
cmd,
|
|
session.get_hmd(),
|
|
pacer.get_frame_duration(),
|
|
frame.rendering,
|
|
layer_accum,
|
|
xrt_rect{.extent{.w = int(extent.width), .h = int(extent.height)}});
|
|
|
|
src = squasher.get_views();
|
|
|
|
for (int view = 0; view < 2; ++view)
|
|
{
|
|
view_info.pose[view] = xrt_cast(poses[view]);
|
|
view_info.fov[view] = xrt_cast(src_fov[view]);
|
|
}
|
|
|
|
image_barriers.push_back(
|
|
vk::ImageMemoryBarrier2{
|
|
.srcStageMask = vk::PipelineStageFlagBits2::eComputeShader,
|
|
.srcAccessMask = vk::AccessFlagBits2::eShaderStorageWrite,
|
|
.dstStageMask = vk::PipelineStageFlagBits2::eComputeShader,
|
|
.dstAccessMask = vk::AccessFlagBits2::eShaderSampledRead,
|
|
.oldLayout = vk::ImageLayout::eGeneral,
|
|
.newLayout = vk::ImageLayout::eShaderReadOnlyOptimal,
|
|
.image = squasher.get_image(),
|
|
.subresourceRange = {
|
|
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
|
.levelCount = 1,
|
|
.layerCount = 2,
|
|
},
|
|
});
|
|
}
|
|
|
|
image_barriers.push_back(
|
|
vk::ImageMemoryBarrier2{
|
|
.dstStageMask = vk::PipelineStageFlagBits2::eComputeShader,
|
|
.dstAccessMask = vk::AccessFlagBits2::eShaderStorageWrite,
|
|
.oldLayout = vk::ImageLayout::eUndefined,
|
|
.newLayout = vk::ImageLayout::eGeneral,
|
|
.image = images[i].image,
|
|
.subresourceRange = {
|
|
.aspectMask = vk::ImageAspectFlagBits::eColor,
|
|
.levelCount = 1,
|
|
.layerCount = images[i].image.info().arrayLayers,
|
|
},
|
|
});
|
|
|
|
cmd.pipelineBarrier2({
|
|
.imageMemoryBarrierCount = uint32_t(image_barriers.size()),
|
|
.pImageMemoryBarriers = image_barriers.data(),
|
|
});
|
|
image_barriers.clear();
|
|
|
|
cmd.writeTimestamp(vk::PipelineStageFlagBits::eBottomOfPipe, *query_pool, 1);
|
|
|
|
if (session.get_info().eye_gaze)
|
|
{
|
|
auto now = os_monotonic_get_ns();
|
|
session.add_tracking_request(device_id::EYE_GAZE, frame.rendering.desired_present_time_ns, now, now);
|
|
}
|
|
view_info.foveation = foveation.foveate(
|
|
vk.device,
|
|
cmd,
|
|
images[i].view_y,
|
|
images[i].view_cbcr,
|
|
flip_y,
|
|
src,
|
|
src_rect,
|
|
src_fov,
|
|
view_info.alpha);
|
|
|
|
for (auto & encoder: encoders)
|
|
{
|
|
if (encoder->stream_idx == 2 and not view_info.alpha)
|
|
continue;
|
|
else if (encoder->need_transfer or encoder->target_queue == vk.queue_family_index)
|
|
{
|
|
image_barriers.push_back(
|
|
vk::ImageMemoryBarrier2{
|
|
.srcStageMask = vk::PipelineStageFlagBits2KHR::eComputeShader,
|
|
.srcAccessMask = vk::AccessFlagBits2::eShaderStorageWrite,
|
|
.dstStageMask = vk::PipelineStageFlagBits2::eAllCommands,
|
|
.dstAccessMask = vk::AccessFlagBits2::eMemoryRead,
|
|
.srcQueueFamilyIndex = vk.queue_family_index,
|
|
.dstQueueFamilyIndex = encoder->target_queue,
|
|
.image = images[i].image,
|
|
.subresourceRange = {.aspectMask = vk::ImageAspectFlagBits::eColor,
|
|
.baseMipLevel = 0,
|
|
.levelCount = 1,
|
|
.baseArrayLayer = encoder->stream_idx,
|
|
.layerCount = 1},
|
|
});
|
|
}
|
|
}
|
|
|
|
cmd.pipelineBarrier2({
|
|
.imageMemoryBarrierCount = uint32_t(image_barriers.size()),
|
|
.pImageMemoryBarriers = image_barriers.data(),
|
|
});
|
|
cmd.writeTimestamp(vk::PipelineStageFlagBits::eBottomOfPipe, *query_pool, 2);
|
|
|
|
cmd.end();
|
|
|
|
const vk::SemaphoreSubmitInfo sem_info{
|
|
.semaphore = *sem,
|
|
.value = ++sem_value,
|
|
.stageMask = vk::PipelineStageFlagBits2::eComputeShader,
|
|
};
|
|
|
|
{
|
|
vk::CommandBufferSubmitInfo cmd_info{
|
|
.commandBuffer = cmd,
|
|
};
|
|
std::unique_lock lock{vk.queue_mutex};
|
|
vk.queue.submit2(vk::SubmitInfo2{
|
|
.commandBufferInfoCount = 1,
|
|
.pCommandBufferInfos = &cmd_info,
|
|
.signalSemaphoreInfoCount = 1,
|
|
.pSignalSemaphoreInfos = &sem_info,
|
|
});
|
|
}
|
|
|
|
pacer.mark_timing_point(COMP_TARGET_TIMING_POINT_SUBMIT_END, frame.rendering.id, os_monotonic_get_ns());
|
|
auto info = pacer.present_to_info(frame.rendering.desired_present_time_ns);
|
|
|
|
for (auto & encoder: encoders)
|
|
{
|
|
if (encoder->stream_idx == 2 and not view_info.alpha)
|
|
continue;
|
|
encoder->present_image(
|
|
images[i].image,
|
|
sem_info,
|
|
info.frame_id);
|
|
}
|
|
|
|
auto j = encode_request.exchange(i);
|
|
encode_request.notify_all();
|
|
assert(j == -1);
|
|
|
|
#ifdef XRT_FEATURE_RENDERDOC
|
|
if (auto r = renderdoc())
|
|
r->EndFrameCapture(NULL, NULL);
|
|
#endif
|
|
|
|
comp_frame_clear_locked(&frame.rendering);
|
|
|
|
if (vk.device.waitSemaphores(vk::SemaphoreWaitInfo{
|
|
.semaphoreCount = 1,
|
|
.pSemaphores = &*sem,
|
|
.pValues = &sem_info.value,
|
|
},
|
|
U_TIME_1S_IN_NS) == vk::Result::eTimeout)
|
|
{
|
|
U_LOG_IFL_W(log_level, "compositor timeout");
|
|
}
|
|
else
|
|
{
|
|
auto [res, ts] = query_pool.getResults<uint64_t>(
|
|
0,
|
|
3,
|
|
3 * sizeof(uint64_t),
|
|
sizeof(uint64_t),
|
|
vk::QueryResultFlagBits::e64 | vk::QueryResultFlagBits::eWait);
|
|
|
|
if (res == vk::Result::eSuccess)
|
|
{
|
|
static const auto period = vk.physical_device.getProperties().limits.timestampPeriod;
|
|
squasher_times.add((ts[1] - ts[0]) * period / 1e3);
|
|
foveation_times.add((ts[2] - ts[1]) * period / 1e3);
|
|
}
|
|
}
|
|
|
|
// Now is a good point to garbage collect.
|
|
comp_swapchain_shared_garbage_collect(&cscs);
|
|
|
|
return XRT_SUCCESS;
|
|
}
|
|
|
|
xrt_result_t compositor::get_display_refresh_rate(float * hz)
|
|
{
|
|
auto settings = session.get_settings();
|
|
// there should not be rounding errors, hz must be one of the available refresh rates
|
|
*hz = frame_rate * settings->fps_divider;
|
|
assert(std::ranges::contains(session.get_info().available_refresh_rates, *hz));
|
|
return XRT_SUCCESS;
|
|
}
|
|
|
|
xrt_result_t compositor::request_display_refresh_rate(float hz)
|
|
{
|
|
try
|
|
{
|
|
requested_refresh_rate = hz;
|
|
session.send_control(to_headset::refresh_rate_change{.hz = hz});
|
|
}
|
|
catch (std::exception & e)
|
|
{
|
|
U_LOG_W("refresh rate change failed: %s", e.what());
|
|
}
|
|
return XRT_SUCCESS;
|
|
}
|
|
|
|
xrt_result_t compositor::get_view_config(
|
|
xrt_compositor_native * self,
|
|
xrt_view_type view_type,
|
|
xrt_view_config * out_view_config)
|
|
{
|
|
const auto & session = reinterpret_cast<compositor *>(self)->session;
|
|
const auto extent = render_extent(session.get_info());
|
|
switch (view_type)
|
|
{
|
|
case XRT_VIEW_TYPE_MONO:
|
|
return XRT_ERROR_UNSUPPORTED_VIEW_TYPE;
|
|
case XRT_VIEW_TYPE_STEREO:
|
|
*out_view_config = {
|
|
.view_type = XRT_VIEW_TYPE_STEREO,
|
|
.view_count = 2,
|
|
.views = {}};
|
|
for (auto & view: std::span(out_view_config->views, out_view_config->view_count))
|
|
{
|
|
view = {
|
|
.recommended = {
|
|
.width_pixels = extent.width,
|
|
.height_pixels = extent.height,
|
|
.sample_count = 1,
|
|
},
|
|
.max = {
|
|
.width_pixels = extent.width * 2u,
|
|
.height_pixels = extent.height * 2u,
|
|
.sample_count = 1,
|
|
},
|
|
};
|
|
}
|
|
return XRT_SUCCESS;
|
|
}
|
|
return XRT_ERROR_UNSUPPORTED_VIEW_TYPE;
|
|
}
|
|
|
|
int compositor::acquire_image()
|
|
{
|
|
for (auto [i, image]: std::ranges::enumerate_view(images))
|
|
{
|
|
if (not image.busy.exchange(true))
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void compositor::encoder_work(std::stop_token tok)
|
|
{
|
|
while (not tok.stop_requested())
|
|
{
|
|
auto req = encode_request.exchange(-1);
|
|
if (req < 0)
|
|
{
|
|
encode_request.wait(req);
|
|
continue;
|
|
}
|
|
|
|
assert(req < images.size());
|
|
auto & image = images[req];
|
|
|
|
try
|
|
{
|
|
for (auto & encoder: encoders)
|
|
{
|
|
if (encoder->stream_idx < 2 or image.view_info.alpha)
|
|
encoder->encode(session, image.view_info, image.frame_index);
|
|
}
|
|
}
|
|
catch (std::exception & e)
|
|
{
|
|
U_LOG_W("encode error: %s", e.what());
|
|
}
|
|
image.busy = false;
|
|
}
|
|
}
|
|
|
|
void compositor::send_video_stream_description()
|
|
|
|
{
|
|
to_headset::video_stream_description desc{
|
|
.width = uint16_t(images[0].image.info().extent.width),
|
|
.height = uint16_t(images[0].image.info().extent.height),
|
|
.frame_rate = settings[0].fps,
|
|
};
|
|
get_display_refresh_rate(&desc.refresh_rate);
|
|
static_assert(std::tuple_size_v<decltype(settings)> == std::tuple_size_v<decltype(desc.codec)>);
|
|
std::ranges::transform(settings, desc.codec.begin(), &encoder_settings::codec);
|
|
session.send_control(std::move(desc));
|
|
}
|
|
|
|
compositor::compositor(wivrn_session & session) :
|
|
comp_base{
|
|
.base = {
|
|
.base = {
|
|
.info{},
|
|
.begin_session = method_pointer<&compositor::begin_session>,
|
|
.end_session = method_pointer<&compositor::end_session>,
|
|
.predict_frame = method_pointer<&compositor::predict_frame>,
|
|
.mark_frame = method_pointer<&compositor::mark_frame>,
|
|
.begin_frame = method_pointer<&compositor::begin_frame>,
|
|
.discard_frame = method_pointer<&compositor::discard_frame>,
|
|
.layer_commit = method_pointer<&compositor::layer_commit>,
|
|
.get_display_refresh_rate = method_pointer<&compositor::get_display_refresh_rate>,
|
|
.request_display_refresh_rate = method_pointer<&compositor::request_display_refresh_rate>,
|
|
.destroy = method_pointer<&compositor::destroy>,
|
|
},
|
|
},
|
|
},
|
|
log_level(debug_get_log_option_log()),
|
|
session(session),
|
|
cmd_pool(vk.device, vk::CommandPoolCreateInfo{
|
|
.flags = vk::CommandPoolCreateFlagBits::eTransient,
|
|
.queueFamilyIndex = vk.queue_family_index,
|
|
}),
|
|
query_pool(vk.device, vk::QueryPoolCreateInfo{
|
|
.queryType = vk::QueryType::eTimestamp,
|
|
.queryCount = 3,
|
|
}),
|
|
settings(get_encoder_settings(vk, session)),
|
|
images{make_images(vk, cmd_pool, settings)},
|
|
cmd{std::move(vk.device.allocateCommandBuffers({.commandPool = *cmd_pool, .commandBufferCount = 1})[0])},
|
|
sem{make_semaphore(vk)},
|
|
frame_rate(settings[0].fps),
|
|
pacer(U_TIME_1S_IN_NS / frame_rate),
|
|
squasher(vk, render_extent(session.get_info())),
|
|
foveation(vk, images[0].image.info().extent)
|
|
{
|
|
comp_base * c_base = this;
|
|
// Ensure we can safely cast pointers
|
|
assert(intptr_t(&base) == intptr_t(this));
|
|
auto res = vk_init_from_given(
|
|
&c_base->vk,
|
|
(PFN_vkGetInstanceProcAddr)vk.instance.getProcAddr("vkGetInstanceProcAddr"),
|
|
*vk.instance,
|
|
*vk.physical_device,
|
|
*vk.device,
|
|
vk.queue_family_index,
|
|
0,
|
|
vk.has_device_ext(VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME),
|
|
vk.has_device_ext(VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME),
|
|
std::get<vk::PhysicalDeviceVulkan12Features>(vk.feat).timelineSemaphore,
|
|
true, // in Vulkan 1.2
|
|
vk.has_instance_ext(VK_EXT_DEBUG_UTILS_EXTENSION_NAME),
|
|
log_level);
|
|
vk::detail::resultCheck(vk::Result(res), "vk_init_from_given");
|
|
|
|
// vk_init_from_given assumes a graphics queue was provided
|
|
c_base->vk.graphics_queue = nullptr;
|
|
|
|
if (c_base->vk.main_queue)
|
|
c_base->vk.main_queue->mutex = copy_mutex(vk.queue_mutex);
|
|
if (c_base->vk.encode_queue)
|
|
c_base->vk.encode_queue->mutex = copy_mutex(vk.encode_queue_mutex);
|
|
|
|
{
|
|
comp_vulkan_formats formats{};
|
|
comp_vulkan_formats_check(&c_base->vk, &formats);
|
|
comp_vulkan_formats_copy_to_info(&formats, &base.base.info);
|
|
comp_vulkan_formats_log(log_level, &formats);
|
|
}
|
|
|
|
comp_base_init(this);
|
|
|
|
// Tie the lifetimes of swapchains to Vulkan.
|
|
xrt_result_t xret = comp_swapchain_shared_init(&cscs, &c_base->vk);
|
|
if (xret != XRT_SUCCESS)
|
|
throw std::runtime_error("comp_swapchain_shared_init failed");
|
|
|
|
print_encoders(settings);
|
|
for (auto [i, settings]: std::ranges::enumerate_view(settings))
|
|
encoders[i] = video_encoder::create(vk, settings, i);
|
|
send_video_stream_description();
|
|
|
|
u_var_add_root(this, "Compositor", false);
|
|
u_var_add_f32_timing(this, &squasher_times.var, "layers processing");
|
|
u_var_add_f32_timing(this, &foveation_times.var, "foveation");
|
|
|
|
// Start the thread after everything is initialized
|
|
encoder_thread = std::jthread{[&](std::stop_token t) { encoder_work(t); }};
|
|
}
|
|
|
|
compositor::~compositor()
|
|
{
|
|
u_var_remove_root(this);
|
|
encoder_thread.request_stop();
|
|
encode_request = -2;
|
|
encode_request.notify_all();
|
|
comp_base * c_base = this;
|
|
comp_swapchain_shared_garbage_collect(&cscs);
|
|
comp_swapchain_shared_destroy(&cscs, &c_base->vk);
|
|
comp_base_fini(this);
|
|
}
|
|
|
|
xrt_system_compositor_info compositor::sys_info() const
|
|
{
|
|
const auto & info = session.get_info();
|
|
auto [prop, dev_id] = vk.physical_device.getProperties2<vk::PhysicalDeviceProperties2, vk::PhysicalDeviceIDProperties>();
|
|
xrt_system_compositor_info res{
|
|
.view_type_count = 1,
|
|
.view_types = {
|
|
XRT_VIEW_TYPE_STEREO,
|
|
},
|
|
.max_layers = squasher.max_layers(prop.properties),
|
|
.supported_blend_modes = {
|
|
XRT_BLEND_MODE_OPAQUE,
|
|
XRT_BLEND_MODE_ALPHA_BLEND,
|
|
},
|
|
.supported_blend_mode_count = uint8_t(1 + info.passthrough),
|
|
.refresh_rate_count = std::min<uint32_t>(info.available_refresh_rates.size(), std::size(res.refresh_rates_hz)),
|
|
.supports_fov_mutable = true,
|
|
};
|
|
|
|
std::ranges::copy(dev_id.deviceUUID, res.compositor_vk_deviceUUID.data);
|
|
std::ranges::copy(dev_id.deviceUUID, res.client_vk_deviceUUID.data);
|
|
std::ranges::copy(std::span(info.available_refresh_rates).subspan(0, res.refresh_rate_count), res.refresh_rates_hz);
|
|
return res;
|
|
}
|
|
|
|
void compositor::set_bitrate(uint32_t bitrate)
|
|
{
|
|
for (auto & encoder: encoders)
|
|
encoder->set_bitrate(bitrate);
|
|
}
|
|
|
|
void compositor::set_framerate(float hz)
|
|
{
|
|
if (frame_rate.exchange(hz) == hz)
|
|
return;
|
|
U_LOG_IFL_D(log_level, "Framerate change from %.0f to %.0f", frame_rate.load(), hz);
|
|
pacer.set_frame_duration(U_TIME_1S_IN_NS / hz);
|
|
for (auto & encoder: encoders)
|
|
encoder->set_framerate(hz);
|
|
}
|
|
|
|
void compositor::update_tracking(const from_headset::tracking & tracking)
|
|
{
|
|
foveation.update_tracking(tracking);
|
|
}
|
|
|
|
void compositor::update_foveation_center_override(const from_headset::override_foveation_center & center)
|
|
{
|
|
foveation.update_foveation_center_override(center);
|
|
}
|
|
|
|
void compositor::resume()
|
|
{
|
|
for (auto & encoder: encoders)
|
|
encoder->reset();
|
|
send_video_stream_description();
|
|
}
|
|
|
|
void compositor::on_feedback(const from_headset::feedback & feedback, const clock_offset & o)
|
|
{
|
|
uint8_t stream = feedback.stream_index;
|
|
if (stream >= encoders.size())
|
|
return;
|
|
encoders[stream]->on_feedback(feedback);
|
|
if (not o)
|
|
return;
|
|
pacer.on_feedback(feedback, o);
|
|
}
|
|
|
|
} // namespace wivrn
|