We don't need any of that weird grabPointer stuff now that we have absolute
input. Deleting this will allow Wayland to advertise warp support without
doing any of the nasty confining stuff on grab/release.
Remove the persistent confined-pointer workaround that emulated cursor
warping on Wayland. Normal pointer motion now uses absolute input only.
Create relative and locked pointer objects only during capture. Preserve
the request across pointer capability changes, and suppress relative
events until the compositor confirms the lock.
On uncapture, publish the current absolute position instead of trying to
warp the host cursor.
Map the remaining Linux mouse buttons through Wayland and evdev.
Use one X11 translation for cooked and raw press and release events.
Ignore unsupported horizontal scrolling and extended SPICE buttons.
Use the LGMP input queue when the host advertises transport input,
while preserving SPICE fallback through the existing input abstraction.
Claim input lazily, publish ordered full-state keyboard and mouse
reports without blocking rendering, and keep the owner lease alive.
Reserve queue capacity for discrete transitions, coalesce only motion
under pressure, and release ownership safely during idle and disconnect.
Keep the Linux-to-HID map in the client and update LGMP to the
nonblocking data-send API required by the input worker.
Introduce LG_InputOps and route keyboard and mouse input through the
active video transport when it provides an input backend.
Keep SPICE as the fallback and force it while the SPICE display is
active. Add atomic shared/exclusive locking for safe backend changes.
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.
Add a configurable stride to the synthetic transport and poison row
padding so incorrect row addressing is visible in captured output.
Cover full-frame and moving-damage BGRA uploads with 512-byte and
5120-byte pitches, and verify the advertised layout in the log.
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.
Reseed the synthetic Present target window when compositor MSC advances
outside the queued range. This prevents a long compositor stall from
permanently exhausting JIT cadence callbacks.
Mark the recovery sample as discontinuous so calibration does not treat the
MSC jump or completion burst as renderer skipping.
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.
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.
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.
