feat(host): vendor PyroWave + minimal Granite subset as crates/pyrowave-sys
Phase 0 of design/pyrowave-codec-plan.md — the opt-in wired-LAN ultra-low- latency codec. Vendored at upstream 509e4f88 (API 0.4.0, Granite 44362775, volk + vulkan-headers pins in PUNKTFUNK-VENDOR.txt), pruned to the 6.6 MB the standalone no-renderer build needs; scripts/vendor-pyrowave.sh reproduces the tree (a pin bump is protocol-affecting, plan §4.2). build.rs drives the wrapper CMakeLists (static archives incl. a static C-API lib upstream only ships shared) + bindgen over pyrowave.h; Linux and Windows only, empty stub elsewhere (Apple gets a native Metal port, §4.7). Offline-safe by construction: no network, no system lib, vendored Vulkan headers — same model as the opus dep (flatpak builder has no network). Phase-0 validation on .21 (RTX 5070 Ti, driver 610.43.03): - upstream pyrowave-c-test + interop test (incl. dmabuf/DRM-modifier Vulkan<->Vulkan) pass, from the pristine AND the pruned tree - GPU kernel times at ~1.6 bpp noise: encode/decode 0.090/0.042 ms @800p, 0.146/0.067 @1080p, 0.226/0.103 @1440p, 0.477/0.201 @4K — order of magnitude under NVENC's 1-2 ms retrieve, CBR lands within ~100 B of target - cargo test -p pyrowave-sys green (static link + API-version pin check) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,576 @@
|
||||
/* Copyright (c) 2017-2026 Hans-Kristian Arntzen
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining
|
||||
* a copy of this software and associated documentation files (the
|
||||
* "Software"), to deal in the Software without restriction, including
|
||||
* without limitation the rights to use, copy, modify, merge, publish,
|
||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
||||
* permit persons to whom the Software is furnished to do so, subject to
|
||||
* the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be
|
||||
* included in all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "device.hpp"
|
||||
#include "semaphore_manager.hpp"
|
||||
#include "vulkan_headers.hpp"
|
||||
#include "wsi_pacer.hpp"
|
||||
#include "timer.hpp"
|
||||
#include <vector>
|
||||
#include <thread>
|
||||
#include <chrono>
|
||||
#include <memory>
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
#include "wsi_dxgi.hpp"
|
||||
#endif
|
||||
|
||||
namespace Granite
|
||||
{
|
||||
class InputTrackerHandler;
|
||||
}
|
||||
|
||||
namespace Vulkan
|
||||
{
|
||||
class WSI;
|
||||
|
||||
class WSIPlatform
|
||||
{
|
||||
public:
|
||||
virtual ~WSIPlatform() = default;
|
||||
|
||||
virtual VkSurfaceKHR create_surface(VkInstance instance, VkPhysicalDevice gpu) = 0;
|
||||
// This is virtual so that application can hold ownership over the surface handle, for e.g. Qt interop.
|
||||
virtual void destroy_surface(VkInstance instance, VkSurfaceKHR surface);
|
||||
virtual std::vector<const char *> get_instance_extensions() = 0;
|
||||
virtual std::vector<const char *> get_device_extensions()
|
||||
{
|
||||
return { "VK_KHR_swapchain" };
|
||||
}
|
||||
|
||||
virtual VkFormat get_preferred_format()
|
||||
{
|
||||
return VK_FORMAT_B8G8R8A8_SRGB;
|
||||
}
|
||||
|
||||
bool should_resize()
|
||||
{
|
||||
return resize;
|
||||
}
|
||||
|
||||
virtual void notify_current_swapchain_dimensions(unsigned width, unsigned height)
|
||||
{
|
||||
resize = false;
|
||||
current_swapchain_width = width;
|
||||
current_swapchain_height = height;
|
||||
}
|
||||
|
||||
virtual uint32_t get_surface_width() = 0;
|
||||
virtual uint32_t get_surface_height() = 0;
|
||||
|
||||
virtual float get_aspect_ratio()
|
||||
{
|
||||
return float(get_surface_width()) / float(get_surface_height());
|
||||
}
|
||||
|
||||
virtual bool alive(WSI &wsi) = 0;
|
||||
virtual void poll_input() = 0;
|
||||
virtual void poll_input_async(Granite::InputTrackerHandler *handler) = 0;
|
||||
virtual bool has_external_swapchain()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual void block_until_wsi_forward_progress(WSI &wsi)
|
||||
{
|
||||
get_frame_timer().enter_idle();
|
||||
while (!resize && alive(wsi))
|
||||
{
|
||||
poll_input();
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
||||
}
|
||||
get_frame_timer().leave_idle();
|
||||
}
|
||||
|
||||
Util::FrameTimer &get_frame_timer()
|
||||
{
|
||||
return timer;
|
||||
}
|
||||
|
||||
virtual void release_resources()
|
||||
{
|
||||
}
|
||||
|
||||
virtual void event_device_created(Device *device);
|
||||
virtual void event_device_destroyed();
|
||||
virtual void event_swapchain_created(Device *device, VkSwapchainKHR swapchain,
|
||||
unsigned width, unsigned height,
|
||||
float aspect_ratio, size_t num_swapchain_images,
|
||||
VkFormat format, VkColorSpaceKHR color_space,
|
||||
VkSurfaceTransformFlagBitsKHR pre_rotate);
|
||||
virtual void destroy_swapchain_resources(VkSwapchainKHR swapchain);
|
||||
virtual void event_swapchain_destroyed();
|
||||
virtual void event_frame_tick(double frame, double elapsed);
|
||||
virtual void event_swapchain_index(Device *device, unsigned index);
|
||||
|
||||
virtual void set_window_title(const std::string &title);
|
||||
|
||||
virtual uintptr_t get_fullscreen_monitor();
|
||||
virtual uintptr_t get_native_window();
|
||||
|
||||
virtual const VkApplicationInfo *get_application_info();
|
||||
|
||||
virtual void begin_drop_event();
|
||||
virtual void begin_soft_keyboard(const std::string &initial);
|
||||
virtual void end_soft_keyboard();
|
||||
|
||||
enum class MessageType { Error, Warning, Info };
|
||||
virtual void show_message_box(const std::string &str, MessageType type);
|
||||
|
||||
protected:
|
||||
unsigned current_swapchain_width = 0;
|
||||
unsigned current_swapchain_height = 0;
|
||||
bool resize = false;
|
||||
|
||||
private:
|
||||
Util::FrameTimer timer;
|
||||
};
|
||||
|
||||
enum class PresentMode
|
||||
{
|
||||
SyncToVBlank, // Force FIFO
|
||||
UnlockedMaybeTear, // MAILBOX or IMMEDIATE
|
||||
UnlockedForceTearing, // Force IMMEDIATE
|
||||
UnlockedNoTearing // Force MAILBOX
|
||||
};
|
||||
|
||||
enum class BackbufferFormat
|
||||
{
|
||||
UNORM,
|
||||
sRGB,
|
||||
HDR10,
|
||||
DisplayP3,
|
||||
UNORMPassthrough,
|
||||
scRGB,
|
||||
Custom
|
||||
};
|
||||
|
||||
struct PresentationStats
|
||||
{
|
||||
// Correlate with WSI::get_last_submitted_present_id() + 1.
|
||||
uint64_t feedback_present_id;
|
||||
|
||||
// QUEUE_COMPLETE query. May be 0 if implementation does not support it.
|
||||
// Application can trivially implement this on its own if needed.
|
||||
uint64_t gpu_done_ts;
|
||||
|
||||
// This is the latest stage that is reported.
|
||||
uint64_t present_done_ts;
|
||||
|
||||
// actual presented - intended target presentation.
|
||||
// Intended target presentation may be adjusted internally,
|
||||
// especially when emulating absolute over relative and vice versa.
|
||||
int64_t error;
|
||||
};
|
||||
|
||||
enum class RefreshMode { Unknown, FRR, VRR };
|
||||
|
||||
struct RefreshRateInfo
|
||||
{
|
||||
RefreshMode mode;
|
||||
uint64_t refresh_duration;
|
||||
uint64_t refresh_interval;
|
||||
};
|
||||
|
||||
class WSI
|
||||
{
|
||||
public:
|
||||
WSI();
|
||||
void set_platform(WSIPlatform *platform);
|
||||
void set_present_mode(PresentMode mode);
|
||||
void set_backbuffer_format(BackbufferFormat format);
|
||||
// This is mostly for debug/development, ignores exposed formats and forces it.
|
||||
void set_custom_backbuffer_format(VkSurfaceFormatKHR format);
|
||||
|
||||
struct ImageCompression
|
||||
{
|
||||
VkImageCompressionFlagBitsEXT type = VK_IMAGE_COMPRESSION_DEFAULT_EXT;
|
||||
VkImageCompressionFixedRateFlagsEXT fixed_rates = 0;
|
||||
};
|
||||
void set_image_compression_control(const ImageCompression &compression);
|
||||
|
||||
// Latency is normally pretty low, but this aims to target
|
||||
// really low latency. Only suitable for cases where rendering loads are extremely simple.
|
||||
void set_present_low_latency_mode(bool enable);
|
||||
// Engages NV_low_latency2 / AMD_anti_lag, etc, which aim to reduce CPU <-> GPU submit delays.
|
||||
void set_gpu_submit_low_latency_mode(bool enable);
|
||||
|
||||
inline BackbufferFormat get_backbuffer_format() const
|
||||
{
|
||||
return backbuffer_format;
|
||||
}
|
||||
|
||||
inline VkColorSpaceKHR get_backbuffer_color_space() const
|
||||
{
|
||||
return swapchain_surface_format.colorSpace;
|
||||
}
|
||||
|
||||
void set_support_prerotate(bool enable);
|
||||
void set_extra_usage_flags(VkImageUsageFlags usage);
|
||||
VkSurfaceTransformFlagBitsKHR get_current_prerotate() const;
|
||||
|
||||
inline PresentMode get_present_mode() const
|
||||
{
|
||||
return present_mode;
|
||||
}
|
||||
|
||||
// Deprecated, use set_backbuffer_format().
|
||||
void set_backbuffer_srgb(bool enable);
|
||||
inline bool get_backbuffer_srgb() const
|
||||
{
|
||||
return backbuffer_format == BackbufferFormat::sRGB;
|
||||
}
|
||||
|
||||
void set_hdr_metadata(const VkHdrMetadataEXT &metadata);
|
||||
inline const VkHdrMetadataEXT &get_hdr_metadata() const
|
||||
{
|
||||
return hdr_metadata;
|
||||
}
|
||||
|
||||
// First, we need a Util::IntrinsivePtr<Vulkan::Context>.
|
||||
// This holds the instance and device.
|
||||
|
||||
// The simple approach. WSI internally creates the context with instance + device.
|
||||
// Required information about extensions etc, is pulled from the platform.
|
||||
bool init_context_from_platform(unsigned num_thread_indices, const Context::SystemHandles &system_handles);
|
||||
|
||||
// If you have your own VkInstance and/or VkDevice, you must create your own Vulkan::Context with
|
||||
// the appropriate init() call. Based on the platform you use, you must make sure to enable the
|
||||
// required extensions.
|
||||
bool init_from_existing_context(ContextHandle context);
|
||||
|
||||
// Then we initialize the Vulkan::Device. Either lets WSI create its own device or reuse an existing handle.
|
||||
// A device provided here must have been bound to the context.
|
||||
bool init_device();
|
||||
bool init_device(DeviceHandle device);
|
||||
|
||||
// Called after we have a device and context.
|
||||
// Either we can use a swapchain based on VkSurfaceKHR, or we can supply our own images
|
||||
// to create a virtual swapchain.
|
||||
// init_surface_swapchain() is called once.
|
||||
// Here we create the surface and perform creation of the first swapchain.
|
||||
bool init_surface_swapchain();
|
||||
bool init_external_swapchain(std::vector<ImageHandle> external_images);
|
||||
|
||||
// Calls init_context_from_platform -> init_device -> init_surface_swapchain in succession.
|
||||
bool init_simple(unsigned num_thread_indices, const Context::SystemHandles &system_handles);
|
||||
|
||||
~WSI();
|
||||
|
||||
inline Context &get_context()
|
||||
{
|
||||
return *context;
|
||||
}
|
||||
|
||||
inline Device &get_device()
|
||||
{
|
||||
return *device;
|
||||
}
|
||||
|
||||
// Acquires a frame from swapchain, also calls poll_input() after acquire
|
||||
// since acquire tends to block.
|
||||
bool begin_frame();
|
||||
// Presents and iterates frame context.
|
||||
// Present is skipped if swapchain resource was not touched.
|
||||
// The normal app loop is something like begin_frame() -> submit work -> end_frame().
|
||||
bool end_frame();
|
||||
|
||||
// Signals that the next present is merely a dupe (or generated) of a previous one,
|
||||
// and that frame should not participate in present wait.
|
||||
void set_next_present_is_duplicated();
|
||||
|
||||
// If true, and present wait is supported, the implementation will use more swapchain images than normal,
|
||||
// and make it feasible to render duplicate frames without needlessly draining the GPU of work.
|
||||
// This is mostly just a thing for an emulator which may be outputting at 30 unique FPS, but at 60 VI/s,
|
||||
// meaning the same frames is duplicated.
|
||||
// With a large enough image count, can feasibly be used for multi-frame-gen or similar shenanigans.
|
||||
void set_frame_duplication_aware(bool enable, uint32_t target_swapchain_images = 5);
|
||||
|
||||
// Overrides the present wait latency.
|
||||
// 0 -> waits until last frame was presented before polling input. Hardest low-latency situation.
|
||||
// Forced when low-latency present is enabled.
|
||||
// 1 -> Normal ideal situation where we wait for previous frame's present to complete.
|
||||
// Allows 1 frame worth of work for CPU to keep GPU fed properly.
|
||||
// 2 -> Conservative, but useful when GPU bound to avoid pumping. Forced when using low gpu submit latency path.
|
||||
void set_present_wait_latency(uint32_t latency);
|
||||
|
||||
// For external swapchains we don't have a normal acquire -> present cycle.
|
||||
// - set_external_frame()
|
||||
// - index replaces the acquire next image index.
|
||||
// - acquire_semaphore replaces semaphore from acquire next image.
|
||||
// - frame_time controls the frame time passed down.
|
||||
// - begin_frame()
|
||||
// - submit work
|
||||
// - end_frame()
|
||||
// - consume_external_release_semaphore()
|
||||
// - Returns the release semaphore that can passed to the equivalent of QueuePresentKHR.
|
||||
void set_external_frame(unsigned index, Semaphore acquire_semaphore, double frame_time);
|
||||
Semaphore consume_external_release_semaphore();
|
||||
|
||||
CommandBuffer::Type get_current_present_queue_type() const;
|
||||
|
||||
// Equivalent to calling destructor.
|
||||
void teardown();
|
||||
|
||||
WSIPlatform &get_platform()
|
||||
{
|
||||
VK_ASSERT(platform);
|
||||
return *platform;
|
||||
}
|
||||
|
||||
// For Android. Used in response to APP_CMD_{INIT,TERM}_WINDOW once
|
||||
// we have a proper swapchain going.
|
||||
// We have to completely drain swapchain before the window is terminated on Android.
|
||||
void deinit_surface_and_swapchain();
|
||||
void reinit_surface_and_swapchain(VkSurfaceKHR new_surface);
|
||||
|
||||
void set_window_title(const std::string &title);
|
||||
|
||||
double get_smooth_frame_time() const;
|
||||
double get_smooth_elapsed_time() const;
|
||||
|
||||
bool get_presentation_stats(PresentationStats &stats) const;
|
||||
bool get_refresh_rate_info(RefreshRateInfo &info) const;
|
||||
uint64_t get_last_submitted_present_id() const;
|
||||
|
||||
// Absolute time is in terms of the Util::get_current_time_nsec() domain,
|
||||
// i.e., time reported in presentation stats.
|
||||
//
|
||||
// For absolute time, the image must not be presented before the time given.
|
||||
// For relative time, the time is intended to be abs_time = last_present + rel_time.
|
||||
//
|
||||
// If relative time is supported by implementation and relative_time_ns is not 0,
|
||||
// absolute time requests are ignored. If absolute time is supported by implementation,
|
||||
// a target absolute time will be computed based on absolute_time_ns and relative_time_ns.
|
||||
//
|
||||
// Rounding adjustments are allowed when the absolute time aligns closely
|
||||
// with a refresh cycle, up to half a refresh cycle for FRR. For VRR, no adjustments are made.
|
||||
//
|
||||
// If this returns true, the request is expected to work as intended.
|
||||
// If false, either it's unsupported, or we're not yet in a steady state where
|
||||
// presentation timing reliably work (the first few frames after a swapchain is created may hit this).
|
||||
// This state remains set until another request is made.
|
||||
// For relative timings, this will work as expected as a method to set absolute target automatically,
|
||||
// but absolute time obviously will not, since application is expected to set a new target time every frame.
|
||||
// If force_vrr is true, the relative or absolute times are passed down with no bias.
|
||||
bool set_target_presentation_time(uint64_t absolute_time_ns, uint64_t relative_time_ns, bool force_vrr);
|
||||
void set_enable_timing_feedback(bool enable);
|
||||
|
||||
FixedRefreshRatePacer &get_fixed_rate_pacer();
|
||||
void set_fixed_rate_low_latency_pacer(bool enable);
|
||||
|
||||
private:
|
||||
void update_framebuffer(unsigned width, unsigned height);
|
||||
|
||||
ContextHandle context;
|
||||
VkSurfaceKHR surface = VK_NULL_HANDLE;
|
||||
VkSwapchainKHR swapchain = VK_NULL_HANDLE;
|
||||
std::vector<VkImage> swapchain_images;
|
||||
std::vector<Semaphore> release_semaphores;
|
||||
DeviceHandle device;
|
||||
const VolkDeviceTable *table = nullptr;
|
||||
FixedRefreshRatePacer frr_pacer;
|
||||
bool frr_pacer_enable = false;
|
||||
|
||||
unsigned swapchain_width = 0;
|
||||
unsigned swapchain_height = 0;
|
||||
float swapchain_aspect_ratio = 1.0f;
|
||||
VkSurfaceFormatKHR swapchain_surface_format = { VK_FORMAT_UNDEFINED, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
|
||||
PresentMode current_present_mode = PresentMode::SyncToVBlank;
|
||||
PresentMode present_mode = PresentMode::SyncToVBlank;
|
||||
bool low_latency_mode_enable_present = false;
|
||||
bool low_latency_mode_enable_gpu_submit = false;
|
||||
bool low_latency_anti_lag_present_valid = false;
|
||||
|
||||
void emit_marker_pre_present();
|
||||
void emit_marker_post_present();
|
||||
void emit_end_of_frame_markers();
|
||||
|
||||
VkPresentModeKHR active_present_mode = VK_PRESENT_MODE_FIFO_KHR;
|
||||
std::vector<VkPresentModeKHR> present_mode_compat_group;
|
||||
bool update_active_presentation_mode(PresentMode mode);
|
||||
|
||||
VkImageUsageFlags current_extra_usage = 0;
|
||||
VkImageUsageFlags extra_usage = 0;
|
||||
bool swapchain_is_suboptimal = false;
|
||||
ImageCompression current_compression, compression;
|
||||
|
||||
enum class SwapchainError
|
||||
{
|
||||
None,
|
||||
NoSurface,
|
||||
Error
|
||||
};
|
||||
SwapchainError init_swapchain(unsigned width, unsigned height);
|
||||
bool blocking_init_swapchain(unsigned width, unsigned height);
|
||||
|
||||
uint32_t swapchain_index = 0;
|
||||
bool has_acquired_swapchain_index = false;
|
||||
|
||||
WSIPlatform *platform = nullptr;
|
||||
|
||||
std::vector<ImageHandle> external_swapchain_images;
|
||||
|
||||
unsigned external_frame_index = 0;
|
||||
Semaphore external_acquire;
|
||||
Semaphore external_release;
|
||||
bool frame_is_external = false;
|
||||
|
||||
BackbufferFormat backbuffer_format = BackbufferFormat::sRGB;
|
||||
BackbufferFormat current_backbuffer_format = BackbufferFormat::sRGB;
|
||||
VkSurfaceFormatKHR current_custom_backbuffer_format = {};
|
||||
VkSurfaceFormatKHR custom_backbuffer_format = {};
|
||||
|
||||
bool has_backbuffer_format_delta() const;
|
||||
|
||||
bool support_prerotate = false;
|
||||
VkSurfaceTransformFlagBitsKHR swapchain_current_prerotate = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
||||
|
||||
bool begin_frame_external();
|
||||
double external_frame_time = 0.0;
|
||||
|
||||
double smooth_frame_time = 0.0;
|
||||
double smooth_elapsed_time = 0.0;
|
||||
|
||||
uint64_t next_present_id = 1;
|
||||
uint64_t present_last_id = 0;
|
||||
unsigned present_frame_latency = 0;
|
||||
bool supports_present_wait2 = false;
|
||||
|
||||
struct
|
||||
{
|
||||
VkPresentStageFlagsEXT feedback;
|
||||
bool absolute;
|
||||
bool relative;
|
||||
} supports_present_timing = {};
|
||||
|
||||
struct CalibratedTimestamp
|
||||
{
|
||||
uint64_t host_time;
|
||||
uint64_t stage_times[4];
|
||||
};
|
||||
|
||||
struct ErrorStats
|
||||
{
|
||||
uint64_t present_id;
|
||||
uint64_t target_absolute;
|
||||
int64_t compensation;
|
||||
};
|
||||
|
||||
struct
|
||||
{
|
||||
// Used for setting target time.
|
||||
VkPresentStageFlagsEXT present_stage;
|
||||
uint64_t reference_time;
|
||||
VkTimeDomainKHR time_domain;
|
||||
uint64_t time_domain_id;
|
||||
|
||||
// Target
|
||||
uint64_t target_absolute_time;
|
||||
uint64_t target_relative_time;
|
||||
uint64_t last_absolute_target_time;
|
||||
bool force_vrr;
|
||||
|
||||
// Feedback.
|
||||
uint64_t gpu_done_host_time;
|
||||
uint64_t present_done_host_time;
|
||||
uint64_t present_id;
|
||||
|
||||
// Display refresh rate information.
|
||||
uint64_t refresh_duration;
|
||||
uint64_t refresh_interval;
|
||||
uint64_t refresh_counter;
|
||||
bool has_refresh_feedback;
|
||||
RefreshMode refresh_mode = RefreshMode::Unknown;
|
||||
|
||||
// Calibration information.
|
||||
uint64_t time_domain_counter;
|
||||
bool has_time_domain_props;
|
||||
Util::SmallVector<VkTimeDomainKHR> time_domains;
|
||||
Util::SmallVector<uint64_t> time_domain_ids;
|
||||
Util::SmallVector<CalibratedTimestamp> calibration;
|
||||
|
||||
bool need_recalibration;
|
||||
int64_t last_recalibration_time;
|
||||
|
||||
int64_t presentation_time_error;
|
||||
int64_t pending_compensation;
|
||||
Util::SmallVector<ErrorStats, 16> error_stats;
|
||||
} present_timing = {};
|
||||
|
||||
bool present_feedback_enable = false;
|
||||
|
||||
void update_present_timing_properties();
|
||||
void poll_present_timing_feedback();
|
||||
void recalibrate_present_timing_domains();
|
||||
void update_time_domain_properties();
|
||||
void set_present_timing_request(VkPresentTimingInfoEXT &timing);
|
||||
|
||||
Semaphore low_latency_semaphore;
|
||||
uint64_t low_latency_semaphore_value = 0;
|
||||
|
||||
bool next_present_is_dupe = false;
|
||||
bool frame_dupe_aware = false;
|
||||
bool current_frame_dupe_aware = false;
|
||||
unsigned frame_dupe_target_images = 5;
|
||||
unsigned current_frame_dupe_target_images = 5;
|
||||
unsigned duplicated_frames = 0;
|
||||
unsigned last_duplicated_frames = 0;
|
||||
|
||||
void tear_down_swapchain();
|
||||
void drain_swapchain(bool in_tear_down);
|
||||
void wait_swapchain_latency();
|
||||
|
||||
VkHdrMetadataEXT hdr_metadata = { VK_STRUCTURE_TYPE_HDR_METADATA_EXT };
|
||||
bool valid_hdr_metadata = false;
|
||||
|
||||
struct DeferredDeletionSwapchain
|
||||
{
|
||||
VkSwapchainKHR swapchain;
|
||||
Fence fence;
|
||||
};
|
||||
|
||||
struct DeferredDeletionSemaphore
|
||||
{
|
||||
Semaphore semaphore;
|
||||
Fence fence;
|
||||
};
|
||||
|
||||
Util::SmallVector<DeferredDeletionSwapchain> deferred_swapchains;
|
||||
Util::SmallVector<DeferredDeletionSemaphore> deferred_semaphore;
|
||||
Vulkan::Fence last_present_fence;
|
||||
void nonblock_delete_swapchain_resources();
|
||||
|
||||
VkSurfaceFormatKHR find_suitable_present_format(const std::vector<VkSurfaceFormatKHR> &formats, BackbufferFormat desired_format) const;
|
||||
|
||||
VkResult wait_for_present(uint64_t id, uint64_t timeout = UINT64_MAX);
|
||||
|
||||
#ifdef HAVE_WSI_DXGI_INTEROP
|
||||
std::unique_ptr<DXGIInteropSwapchain> dxgi;
|
||||
bool init_surface_swapchain_dxgi(unsigned width, unsigned height);
|
||||
bool begin_frame_dxgi();
|
||||
bool end_frame_dxgi();
|
||||
#endif
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user