Allow the timing owner to keep one delivery pending on each independent
owner queue instead of waiting for the client to release every frame.
Count shared fallback deliveries against the same two-frame limit and
match republished frames across all active lanes. This hides the client
release round trip without allowing a third delivery for the owner.
Store retained frame candidates in the final linear transport layout.
Prepare texture output in local DEFAULT buffers before cadence holding.
Then publish full frames with a single buffer copy.
Keep partial damage on matching pitched layouts and leave effect-owned
buffer copies unchanged. This moves detiling out of the
deadline-critical IVSHMEM or readback transfer.
Ignore allocation alignment when matching retained candidate resources.
D3D12 may resolve automatic alignment requests in GetDesc.
Comparing that value recreated the candidate for every benchmark sample.
Measure native and packed over matching wall-clock intervals.
Use preparation and publication intervals, excluding the cadence hold.
This avoids mixing GPU timestamps with fallback timing. The CPU IVSHMEM
copy is included only on indirect systems.
Track damage received after each retained candidate snapshot. When a
candidate is submitted successfully, replace the global pending set
with its trailing damage instead of requiring the source generation
to remain unchanged.
This lets published full-frame damage retire while preserving newer
partial or full updates.
Run effect timing samples only when the retained candidate pipeline is idle
and force each completed sample to publish immediately. This prevents work
from superseded candidates from being charged to a surviving sample.
Include the indirect CPU copy to IVSHMEM in the measured copy stage while
preserving the wall-clock fallback when GPU timestamps are unavailable.
Treat a failed desktop texture bind as an incomplete render so full target
restoration remains latched until a frame can actually be drawn.
Carry retired damage into the pending record when the drawable texture does
not contain it, closing the publication gap between texture slots and their
matching damage metadata.
Prepare each acquired content frame into one of two private GPU
candidates so the IddCx frame can be released without copying it to
IVSHMEM immediately.
Wake a high-resolution publisher at the client deadline and send the
newest completed candidate. Preserve accumulated damage across
superseded candidates, include the scheduling hold in end-to-end timing,
and keep transport work on the existing physical copy queue.
Move splash transitions onto the render thread and derive opacity from
elapsed monotonic time. Pace active animation at a display-compatible
minimum of 60 Hz while allowing incoming frames to satisfy that demand.
Reset the splash cleanly across reconnects and latch state changes with
the full-frame restoration decision.
Only report the client queue lead when JIT rendering provides a valid
measurement. Clamp linear phase errors instead of wrapping them into the
opposite direction at half of a refresh period.
Timestamp OBS frames after the shared framebuffer becomes ready.
Always track Wayland surface outputs alongside fractional scaling and use
RandR modes for X11 cadence. Remove render-derived feedback so a
throttled client cannot teach the producer to remain throttled.
Release scheduling after nominal output timing remains unavailable.
Use the current wl_output mode for the requested producer cadence.
Presentation feedback can follow a slower VRR cadence, feeding that low
update rate back into the IDD. Select the fastest nominal mode when a
window spans multiple outputs.
Mark the active fade as requiring a fully restored render target.
This also covers guest-driven renders between animation ticks so they
cannot blend over stale splash content.
Fully invalidate the render target when the full-screen splash changes.
This restores the desktop before alpha blending and prevents stale fade
states from cycling between swapchain buffers when guest updates are
sparse.
Discard the learned guest arrival period when a frame follows a gap
much larger than expected. Force that frame through and relearn the
arrival rate so sparse updates are not held for a frame that never
arrives.
Disable fast-math for the timing graph translation unit because its
bucket arrays use NaN values to break plot lines across empty intervals.
Keep fast-math enabled for remaining client sources while allowing
Clang's strict floating-point diagnostics to remain fatal.
Keep warnings fatal for the GUI dependencies except for two known
issues in generated wrapper sources: an unused cimgui conversion helper
and cimplot's invalid internal FormatSpec conversion.
Scope the exceptions to their respective generated translation units so
warnings in ImGui, ImPlot, and the remaining wrappers stay fatal.
Treat every completed swap as satisfying the interactive overlay
refresh requirement. Only force a JIT overlay render after the 60 Hz
deadline, and rearm the timer-based deadline after frame-driven swaps.
This prevents interactive overlays from adding redundant swaps when
incoming frames already keep the client at or above the required rate.
Unbind the streamed desktop pixel upload buffer before ImGui processes
CPU-backed font atlas updates.
This prevents atlas pointers from being interpreted as PBO offsets when
DMA is disabled, which caused newly requested glyphs to be missing.
Expand ImGui window damage to include its border and round both logical
window bounds and framebuffer-scaled bounds outward.
This prevents a one-pixel strip of stale desktop content when an
overlay window is resized at fractional positions or display scales.
Correlate received frames with the texture update actually consumed by
the renderer and retain damage until its token becomes renderable.
Split client latency into dispatch, import, queue, preparation, setup,
effects, desktop, composition, and swap stages in FRAME LATENCY.
Exclude diagnostic overlay work from composition and preserve client
wait time when producer timing is unavailable.
Publish joined samples through a bounded token queue, avoid sleeping
while producer timing is finalized, and correct Wayland photon units.
Replace the texture-shaped RGB24 output with a linear raw buffer and
keep its packing, damage translation, and buffer copies inside the
RGB24 effect.
Benchmark full-frame native and packed processing and retain the faster
path for each source format. Preserve logical damage rectangles for
client updates and alternating framebuffer repair.
Return compute outputs to COMMON for COPY queue handoff and refresh
cached framebuffer sizes when switching packed and native layouts.
Give each in-flight framebuffer a complete post-processing chain and
its own COMPUTE recording slot while retaining one physical queue.
Claim framebuffer ownership before submitting compute work, and use
the frame index for both COMPUTE and COPY recording state. Drain
in-flight work before reconfiguring either chain so COPY never
references replaced effect resources.
Require both chains to contain the same effects, preserve pending
damage, and release ownership on every pre-copy failure path.
Replace the rotating D3D12 copy queues with two framebuffer-bound
recording slots on one physical COPY queue. Keep allocator, command
list, query range, callback state, and fence target independent per
slot.
Submit source waits, execution, and signaling on the shared timeline.
Track framebuffer ownership through completion and serialize LGMP
publication around the last successfully published frame.
Combine the previous and current frame damage before recording copy
commands. Remove contained regions, merge beneficial overlaps, and use
one full-frame copy when partial work reaches the full surface size.
This prevents a previous full-frame update from being copied again
alongside the current damage.
Use calibrated copy-queue timestamps to separate source and effect
waits from the actual framebuffer copy.
Exclude producer readiness waits from client import timing so the
same interval is not counted in both Copy and Import.
Treat IddCx's single empty dirty rectangle as no image update instead
of promoting it to full damage.
Preserve pending damage and format changes, and fall back to full damage
when legacy move regions are present.
