Remove confinement handshake expectations now that Wayland advertises
functional warp support. Verify immediate viewport transitions and cursor
alignment when capture is released.
Previously, we only aligned the mouse in the client when the cursor is
visible. This wasn't a problem because the cursor position in the guest
took precedence and we only used relative input.
Since we now have absolute input, the absolute position of the cursor in
the client matters at all times when we exit capture, so we always call
`core_alignToGuest` now.
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.
Expose a Consumer Control HID report for the system volume usages that
Windows does not handle through the Keyboard/Keypad usage page.
Translate the existing mute and volume keyboard usages at the LGInput
boundary, preserve normal keyboard state, and force a neutral consumer
report across resets and HID device reactivation.
Move named pipe writes off the LGMP input worker so a stalled LGInput
endpoint cannot block queue draining or lease maintenance.
Coalesce motion only under queue pressure while preserving mode, button,
wheel, and keyboard transitions. Reset HID state after discontinuities
and carry all 32 mouse button bits through the pipe and HID reports.
Add an optional input transport and a dedicated LGMP receiver that
validates source ownership, generations, ordered sequences, and leases.
Poll input outside the 10 ms control timer. Forward mouse and keyboard
state through the LGInput pipe, and neutralize the endpoint before
ownership changes or transport failures can leave input held.
Reserve a dedicated LGMP queue for low-latency input reports and
endpoint status. Bump KVMFR for the new feature and define ordered
ownership messages with full-state mouse and keyboard payloads.
Use a 32-bit physical button mask so future HID buttons do not require
another wire format change.
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.
Replace raw HID report forwarding with typed absolute mouse, relative
mouse, and keyboard messages.
Expose absolute and relative modes as separate Mouse collections because
Windows MouHID requires one X/Y motion mode per mouse device.
Move the reusable named-pipe endpoint and shared support code into
the LGCommon static library.
Run a dedicated server in LGIdd and a reconnecting client in
LGInput, with device-lifecycle handling and report framing.
Refactor the helper pipe to use the same endpoint implementation.
Build LGInput as an independent UMDF driver with its own entry point,
service, tracing, and binary.
Expose absolute pointer, relative mouse, and keyboard collections with a
guarded report queue.
Keep LGIdd as the startup and deployment project. Give it a non-linking
build/package dependency on LGInput so F5 stages both driver stacks and
installs them together through LGIddInstall, while the two UMDF binaries
remain independent for future IPC.
Stage both DLLs for the NSIS installer, retain the WDK UMDF remote-debug
startup attachment, and move CSRWLock into LGCommon for the input
driver's report queue.
Run CTest directly in every client matrix job so each build is tested
without waiting for the full matrix to complete.
Install the Mesa runtime in the build job, preserve failure artifacts,
and remove the archive transfer and duplicate test job.
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.
Use an explicit placed buffer for software frame copies so the D3D copy
uses the same row pitch published through KVMFR.
GetCopyableFootprints describes buffer copies and cannot be used to infer
the physical layout of a placed row-major texture. This caused padded
resolutions to use the wrong row starts in every consumer.
Keep the copy direct to IVSHMEM without a staging or CPU copy.
Move cadence and pipeline declarations under capture, and move local
named-pipe handling under ipc.
Flatten display contexts and rename files after their contained classes.
Keep transport headers limited to transport contracts and capabilities.
Consolidate CSwapChainProcessor definitions so each source file matches
the class it implements.
Introduce transport, frame, and control interfaces with an LGMP factory
backend.
Move LGMP and IVSHMEM implementation details under transport/lgmp and
expose direct frame-buffer memory through a neutral capability.
Group the IDD sources and Visual Studio filters by subsystem.
Split the device and swap-chain implementations into focused units,
rename the context classes, and reduce header coupling.
Move cadence-aware hardware capture and immediate software capture
behind a common frame processor interface.
Keep shared damage tracking and frame-buffer ownership in the base
processor, and move stateless format, resource, and rectangle helpers
into CFrameProcessorUtil.
Decouple frame-buffer resources from CSwapChainProcessor by passing the
device dependencies they use directly.
Bypass cadence retention when the software render adapter is active.
Publish each available source frame immediately with one damage-aware
D3D copy into its final IVSHMEM resource.
Keep only one software copy in flight so newer frames are dropped
instead of queued behind stale work. Retain accumulated damage for the
next frame and skip static re-encodes when no image update is pending.
Use a row-major IVSHMEM texture when the shared heap supports it and
fall back to a direct IVSHMEM buffer copy otherwise. In indirect mode,
copy only damaged rows from readback memory into IVSHMEM.
Store refresh rates in millihertz and preserve three decimal places.
Advertise exact rational rates while accepting legacy integer values.
Accept rates from 23.900 through 1000.000 Hz.
Rebuild the driver's cached mode list before replugging the monitor so
Windows enumerates the settings saved by the helper.
Keep saved mode refresh rates intact and update only ExtraMode to the
configured default refresh.
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.
