Hide the startup splash immediately after overlay initialization when a
render-pipeline capture is requested. This occurs before the frame
thread is released, so no EGL surface buffer can contain splash pixels.
Keep the tracked Wayland hardware position sourced only from absolute
wl_pointer events. Relative motion remains unclipped at output edges,
so accumulating it made the client believe the hardware cursor had
reached the guest position and caused the corrective warp to be
skipped.
Keep cursor coordinates in shape-origin form after absolute
realignment. Preserve the logical hotspot when a shape-only update
changes its hotspot, preventing either path from leaving a permanent
offset.
Center the Wayland diagnostic cursor on its actual pointer hotspot and
preserve it while cursor themes are reloaded for output-scale changes.
Round fractional guest positions to the nearest logical pixel instead of
biasing synchronization toward the top-left corner.
Resynchronize the hardware pointer when a cursor shape changes its
hotspot. Only perform the extra synchronization when the hotspot
actually changes, and update the basic-mode projection at the same time.
Keep guest-to-host pointer synchronization active while an attempted
surface exit is blocked by the edge of a Wayland output. Continue
forwarding relative motion and wait for wl_pointer.leave before marking
the cursor outside the window.
Distinguish whole-surface releases from exits into letterbox space so
the expected asynchronous release callback cannot disable the feedback
loop before the pointer is confined again.
Treat Wayland pointer capability loss as a real leave so an unrelated
inactive callback cannot be mistaken for the intentional release.
Coalesce pointer updates to the nominal output cadence instead of
waking the renderer for every transport packet. Keep request and
presented generations separate so updates racing a render receive a
trailing swap.
Let JIT consume cursor changes on display callbacks to preserve VRR
cadence, and use a deadline worker for non-JIT rendering. Give normal
source frames a short grace period so an on-rate feed absorbs the
cursor update instead of producing an extra swap.
Repaint visibility and cursor-content changes even when movement
redraws are disabled, including the transition that hides the cursor.
Pointer updates bypassed the paced overlay render and woke the renderer
for every cursor packet. On the default single-buffer EGL surface,
each full fade redraw could expose the desktop before the splash was
blended again.
Coalesce pointer redraws into the existing fade cadence while keeping
the latest cursor state. Immediate cursor redraw resumes when the fade
ends.
Restore client and test files that were already staged when the OBS
cadence commit was created. Keep that work out of the scheduler series
while leaving its working-tree contents untouched.
Track the LGMP serial for each accepted frame-schedule message and wait
for its acknowledgement before sending another. Preserve pending RESET,
IMMEDIATE, and feedback state after definite enqueue failures.
Use bounded retry polling and request one fresh immediate frame after an
ambiguous pointer-queue fault recovers.
Keep one accepted frame-schedule control in flight until LGMP reports
that its serial has been consumed. Retain ambiguous tokens across pointer
queue recovery instead of retransmitting RESET or IMMEDIATE messages.
Back off acknowledgement polling and definite enqueue failures. Use modular
serial comparison so acknowledgement remains correct across rollover.
Renew the frame-schedule lease only while the display server is
producing real cadence callbacks. Release ownership after the cadence
stalls, and reacquire with an immediate reset when it resumes.
For non-JIT rendering, treat only a successful presentation as live
cadence.
Track cadence, interruption, and calibration wake reasons independently
across X11 and Wayland. Feed phase correction back only when a pure
cadence wake renders the exact frame that was queued at that wake.
Propagate EGL swap results through the display-server boundary. Reject
failed presentations and keep pending Wayland HDR descriptions inactive
until the preceding surface commit succeeds.
Bump KVMFR to version 28 and attach generation, epoch, and deadline
identities to cadence deliveries and their timing records.
Accept phase corrections only for the exact completed publication. Keep
VM and client clocks independent by exchanging relative phase errors.
Make submission, completion, and work-estimate accounting best effort
so scheduler state cannot delay GPU submission or frame publication.
Copy imported IVSHMEM frames into renderer-owned textures before
acknowledging their LGMP messages. Hold each lease until its copy fence
signals, and protect selected snapshots until rendering completes.
Track independent delivery lanes, drain acknowledgements on the frame
thread, and recover stale queue subscriptions after host timeouts.
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.
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.
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.
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.
Add an optional EGL framebuffer capture path for the test transport.
Capture the fully composed frame before presentation and retain its
surface format and HDR state for validation.
Add GoogleTest integration tests which run the production client
under a headless Weston compositor and compare every output pixel
against an independent reference implementation.
The matrix covers BGRA, RGBA, BGR32, RGB24, PQ RGBA10 and scRGB
RGBA16F with full, moving, overlapping, maximum-count, invalid, null
and zero-area damage rectangles. Validate HDR-to-SDR conversion and
native HDR output metadata when supported by the compositor.
Keep tests opt-in through ENABLE_RENDER_TESTS and document how to run
the software and native HDR tiers.
