linux/input: optionally emulate absolute mouse as relative motion

Some compositors implement assistive features that only track relative
pointer motion; Wayland's PointerMotionAbsolute moves the cursor but such
features do not follow it (e.g. the COSMIC screen magnifier focal point,
pop-os/cosmic-comp#2760). Add an absolute_mouse_as_relative option
(disabled by default) that converts absolute client coordinates into
relative deltas.

The first absolute event still anchors the cursor absolutely. Subsequent
events are turned into relative deltas driven by dead reckoning. The KMS
capture path publishes the real cursor-plane position every frame; the
estimate snaps to it while the client is idle, and a coordinate saturated
at the client's own surface edge targets the matching host edge so
movement cannot stall mid-screen. On backends without cursor feedback
the conversion still works from dead reckoning alone.

Author: danalec

docs/configuration.md

@@ -691,6 +691,35 @@ editing the `conf` file in a text editor. Use the examples as reference.
     </tr>
 </table>
 
+### absolute_mouse_as_relative
+
+<table>
+    <tr>
+        <td>Description</td>
+        <td colspan="2">
+            When enabled, absolute mouse positions from Moonlight clients are converted to relative motion.
+            <br>
+            The first event still places the cursor absolutely; subsequent events are emitted as relative deltas,
+            using the cursor position captured from the KMS cursor plane (when available) to stay in sync.
+            <br>
+            This can be useful on compositors whose assistive features (e.g. screen magnifiers) only track relative
+            pointer motion.
+        </td>
+    </tr>
+    <tr>
+        <td>Default</td>
+        <td colspan="2">@code{}
+            disabled
+            @endcode</td>
+    </tr>
+    <tr>
+        <td>Example</td>
+        <td colspan="2">@code{}
+            absolute_mouse_as_relative = enabled
+            @endcode</td>
+    </tr>
+</table>
+
 ### keybindings
 
 <table>

src/config.cpp

@@ -861,6 +861,7 @@ namespace config {
     true,  // always send scancodes
     true,  // high resolution scrolling
     true,  // native pen/touch support
+    false,  // absolute mouse as relative (opt-in)
   };
 
   /**
@@ -1803,6 +1804,7 @@ namespace config {
 
     bool_f(vars, "high_resolution_scrolling", input.high_resolution_scrolling);
     bool_f(vars, "native_pen_touch", input.native_pen_touch);
+    bool_f(vars, "absolute_mouse_as_relative", input.absolute_mouse_as_relative);
 
     bool_f(vars, "notify_pre_releases", sunshine.notify_pre_releases);
     bool_f(vars, "system_tray", sunshine.system_tray);

src/config.h

@@ -290,6 +290,7 @@ namespace config {
 
     bool high_resolution_scrolling;  ///< Enable high-resolution mouse-wheel events.
     bool native_pen_touch;  ///< Enable native pen and touch injection.
+    bool absolute_mouse_as_relative;  ///< Emulate absolute client mouse input as relative motion (for compositors whose assistive features only track relative motion).
   };
 
   namespace flag {

src/input.cpp

@@ -42,6 +42,18 @@ constexpr int WHEEL_DELTA = 120;  ///< Standard Windows wheel delta used to norm
 
 using namespace std::literals;
 
+// Definitions for the cursor-position feedback published by the capture
+// pipeline (declarations in platform/common.h; stores in linux/kmsgrab.cpp).
+namespace platf {
+  std::atomic<std::int32_t> kms_cursor_x { -1 };
+  std::atomic<std::int32_t> kms_cursor_y { -1 };
+  std::atomic<std::int32_t> kms_desktop_w { 0 };
+  std::atomic<std::int32_t> kms_desktop_h { 0 };
+  std::atomic<std::int32_t> kms_logical_w { 0 };
+  std::atomic<std::int32_t> kms_logical_h { 0 };
+  std::atomic<std::uint64_t> kms_cursor_seq { 0 };
+}
+
 namespace input {
 
   constexpr auto MAX_GAMEPADS = std::min((std::size_t) platf::MAX_GAMEPADS, sizeof(std::int16_t) * 8);  ///< Maximum gamepads representable by the active gamepad mask.
@@ -271,6 +283,17 @@ namespace input {
 
     input::touch_port_t touch_port;  ///< Touch coordinate bounds for the current stream.
 
+    bool abs_mouse_initialized = false;  ///< Whether the absolute mouse baseline is set.
+    float abs_mouse_frac_x = 0;          ///< Accumulated fractional X delta.
+    float abs_mouse_frac_y = 0;          ///< Accumulated fractional Y delta.
+    float host_cursor_x = 0;             ///< Dead-reckoning estimate of the host cursor X, touch-port pixels.
+    float host_cursor_y = 0;             ///< Dead-reckoning estimate of the host cursor Y, touch-port pixels.
+    std::uint64_t cursor_seq_last = 0;   ///< Cursor-feedback sequence seen by the previous event.
+    float last_raw_x = 0;                ///< Previous raw client X (idle detection).
+    float last_raw_y = 0;                ///< Previous raw client Y (idle detection).
+    std::chrono::steady_clock::time_point last_client_move {};  ///< Last time the client target changed.
+    std::chrono::steady_clock::time_point abs_dbg_last {};  ///< Rate limit for debug logging.
+
     int32_t accumulated_vscroll_delta;  ///< Accumulated vscroll delta.
     int32_t accumulated_hscroll_delta;  ///< Accumulated hscroll delta.
   };
@@ -831,7 +854,140 @@ namespace input {
       touch_port_dim_y
     };
 
-    platf::abs_mouse(platf_input, abs_port, tpcoords->first, tpcoords->second);
+    // Optional (absolute_mouse_as_relative): emulate relative mouse movement
+    // from absolute coordinates. Absolute motion arrives as
+    // PointerMotionAbsolute in the compositor, which moves the cursor but does
+    // NOT update assistive features that track relative motion only, e.g. the
+    // COSMIC screen magnifier focal point (pop-os/cosmic-comp #2760). The
+    // first event anchors the cursor absolutely; subsequent events are
+    // converted to relative deltas so such features track the cursor.
+    //
+    if (!config::input.absolute_mouse_as_relative) {
+      platf::abs_mouse(platf_input, abs_port, tpcoords->first, tpcoords->second);
+      return;
+    }
+    //
+    // v6: dead reckoning is the ONLY thing in the smooth motion path (1:1, no
+    // latency). The real cursor position published by the KMS capture path
+    // (platf::kms_cursor_*) is consumed only when trustworthy: (a) while the
+    // client is IDLE (>kIdleMs without raw coordinate change) the estimate is
+    // snapped to reality — by then every in-flight move has landed; (b) while
+    // an axis is SATURATED in the client's RAW coordinate domain, that axis
+    // gets fresh feedback as its source of truth and its target becomes the
+    // matching host edge. Acting on lagged feedback during free motion was
+    // wrong twice over: v3 jumped (full-strength corrections), v4 accelerated
+    // (partial corrections added distance proportional to speed).
+    //
+    // Phantom "walls" (movement blocked in one direction until you push back)
+    // happen when the client saturates in its own coordinate space while the
+    // host cursor sits mid-screen, and v5's one-shot wall fix could compute a
+    // zero slide from a mis-anchored estimate. v6 removes the separate wall
+    // fix entirely: a saturated axis simply TARGETS the host edge, so the
+    // primary loop itself drives the cursor there, continuously and
+    // idempotently — resting in the edge band cannot buzz, and re-entering
+    // the band after a desync retries the slide using fresh feedback.
+    // Set SUNSHINE_DEBUG_ABSMOUSE=1 for rate-limited diagnostics.
+    const float port_w = (float) touch_port_dim_x;
+    const float port_h = (float) touch_port_dim_y;
+
+    constexpr float kRawEdge = 8.0f;
+    const bool at_left = x <= kRawEdge;
+    const bool at_right = x >= width - kRawEdge;
+    const bool at_top = y <= kRawEdge;
+    const bool at_bottom = y >= height - kRawEdge;
+
+    // Client target in touch-port units; a saturated axis targets the host edge.
+    auto target_x = std::clamp(tpcoords->first, 0.0f, port_w - 1.0f);
+    auto target_y = std::clamp(tpcoords->second, 0.0f, port_h - 1.0f);
+    if (at_left) target_x = 0.0f;
+    else if (at_right) target_x = port_w - 1.0f;
+    if (at_top) target_y = 0.0f;
+    else if (at_bottom) target_y = port_h - 1.0f;
+
+    auto move_estimated = [&](int delta_x, int delta_y) {
+      platf::move_mouse(platf_input, delta_x, delta_y);
+      input->host_cursor_x = std::clamp(input->host_cursor_x + delta_x, 0.0f, port_w - 1.0f);
+      input->host_cursor_y = std::clamp(input->host_cursor_y + delta_y, 0.0f, port_h - 1.0f);
+    };
+
+    // Idle detection watches the client's OWN motion (raw coordinates), so a
+    // cursor pinned against its edge still counts as idle once it stops.
+    const auto now = std::chrono::steady_clock::now();
+    if (std::fabs(x - input->last_raw_x) > 0.01f ||
+        std::fabs(y - input->last_raw_y) > 0.01f) {
+      input->last_client_move = now;
+    }
+    input->last_raw_x = x;
+    input->last_raw_y = y;
+
+    if (!input->abs_mouse_initialized) {
+      platf::abs_mouse(platf_input, abs_port, tpcoords->first, tpcoords->second);
+      input->abs_mouse_initialized = true;
+      input->host_cursor_x = target_x;
+      input->host_cursor_y = target_y;
+    }
+    else {
+      const auto seq = platf::kms_cursor_seq.load(std::memory_order_acquire);
+      const bool feedback_fresh = seq != 0 && seq != input->cursor_seq_last;
+
+      if (feedback_fresh) {
+        input->cursor_seq_last = seq;
+
+        const auto phys_w = (float) platf::kms_desktop_w.load(std::memory_order_relaxed);
+        const auto phys_h = (float) platf::kms_desktop_h.load(std::memory_order_relaxed);
+        const auto logical_w = (float) platf::kms_logical_w.load(std::memory_order_relaxed);
+        const auto logical_h = (float) platf::kms_logical_h.load(std::memory_order_relaxed);
+
+        if (phys_w > 0 && phys_h > 0 && logical_w > 0 && logical_h > 0) {
+          // Desktop physical pixels -> compositor logical pixels.
+          const auto real_x = (float) platf::kms_cursor_x.load(std::memory_order_relaxed) * (logical_w / phys_w);
+          const auto real_y = (float) platf::kms_cursor_y.load(std::memory_order_relaxed) * (logical_h / phys_h);
+
+          constexpr auto kIdleMs = std::chrono::milliseconds(150);
+          const bool client_idle = now - input->last_client_move > kIdleMs;
+
+          // Idle: snap both axes (all in-flight moves have landed).
+          // Saturated axis: fresh feedback is authoritative — the estimate may
+          // be mis-anchored (the very cause of the wall), and any feedback lag
+          // only overshoots toward the edge, where the compositor clamps.
+          if (client_idle) {
+            input->host_cursor_x = std::clamp(real_x, 0.0f, port_w - 1.0f);
+            input->host_cursor_y = std::clamp(real_y, 0.0f, port_h - 1.0f);
+          }
+          else {
+            if (at_left || at_right) input->host_cursor_x = std::clamp(real_x, 0.0f, port_w - 1.0f);
+            if (at_top || at_bottom) input->host_cursor_y = std::clamp(real_y, 0.0f, port_h - 1.0f);
+          }
+
+          static const bool dbg = ::getenv("SUNSHINE_DEBUG_ABSMOUSE") != nullptr;
+          if (dbg) {
+            if (now - input->abs_dbg_last > std::chrono::milliseconds(200)) {
+              input->abs_dbg_last = now;
+              BOOST_LOG(info) << "absmouse: raw=" << x << "," << y << "/" << width << "x" << height
+                              << " sat=" << (at_left ? "L" : "") << (at_right ? "R" : "")
+                              << (at_top ? "T" : "") << (at_bottom ? "B" : "")
+                              << " target=" << target_x << "," << target_y
+                              << " est=" << input->host_cursor_x << "," << input->host_cursor_y
+                              << " real=" << real_x << "," << real_y;
+            }
+          }
+        }
+      }
+
+      // Primary loop: drive the estimate toward the (possibly edge-overridden)
+      // target. Idempotent while resting inside the edge band.
+      input->abs_mouse_frac_x += target_x - input->host_cursor_x;
+      input->abs_mouse_frac_y += target_y - input->host_cursor_y;
+
+      auto delta_x = (int) input->abs_mouse_frac_x;
+      auto delta_y = (int) input->abs_mouse_frac_y;
+      input->abs_mouse_frac_x -= delta_x;
+      input->abs_mouse_frac_y -= delta_y;
+
+      if (delta_x || delta_y) {
+        move_estimated(delta_x, delta_y);
+      }
+    }
   }
 
   /**

src/platform/common.h

@@ -5,6 +5,7 @@
 #pragma once
 
 // standard includes
+#include <atomic>
 #include <bitset>
 #include <filesystem>
 #include <functional>
@@ -74,6 +75,21 @@ namespace nvenc {
 }
 
 namespace platf {
+  // Real cursor position feedback published by the capture pipeline.
+  // The KMS backend reads the cursor plane position once per captured frame and
+  // publishes it here so the input path can close the loop of the abs->rel
+  // mouse conversion (see patches/abs-mouse-relative.patch). Coordinates are in
+  // desktop physical pixels; the logical extents allow rescaling to the
+  // compositor's logical space. kms_cursor_seq starts at 0 and is bumped on
+  // every update, so consumers can tell fresh values from stale ones.
+  extern std::atomic<std::int32_t> kms_cursor_x;
+  extern std::atomic<std::int32_t> kms_cursor_y;
+  extern std::atomic<std::int32_t> kms_desktop_w;  ///< Physical width of the streamed output.
+  extern std::atomic<std::int32_t> kms_desktop_h;  ///< Physical height of the streamed output.
+  extern std::atomic<std::int32_t> kms_logical_w;  ///< Logical width of the streamed output.
+  extern std::atomic<std::int32_t> kms_logical_h;  ///< Logical height of the streamed output.
+  extern std::atomic<std::uint64_t> kms_cursor_seq;
+
   // Limited by bits in activeGamepadMask
   constexpr auto MAX_GAMEPADS = 16;  ///< Maximum number of simultaneously tracked gamepads.
 

src/platform/linux/kmsgrab.cpp

@@ -1251,6 +1251,19 @@ namespace platf {
         captured_cursor.dst_w = *prop_crtc_w;
         captured_cursor.dst_h = *prop_crtc_h;
 
+        // Publish the real cursor position for the abs->rel input conversion
+        // (see config: absolute_mouse_as_relative). Cursor-plane CRTC
+        // coordinates are CRTC-local physical pixels; add the output's desktop
+        // offset and publish the output extents so the consumer can rescale
+        // to logical units.
+        platf::kms_cursor_x.store(offset_x + *prop_crtc_x, std::memory_order_relaxed);
+        platf::kms_cursor_y.store(offset_y + *prop_crtc_y, std::memory_order_relaxed);
+        platf::kms_desktop_w.store(width, std::memory_order_relaxed);
+        platf::kms_desktop_h.store(height, std::memory_order_relaxed);
+        platf::kms_logical_w.store(logical_width, std::memory_order_relaxed);
+        platf::kms_logical_h.store(logical_height, std::memory_order_relaxed);
+        platf::kms_cursor_seq.fetch_add(1, std::memory_order_release);
+
         // We're technically cheating a bit here by assuming that we can detect
         // changes to the cursor plane via property adjustments. If this isn't
         // true, we'll really have to mmap() the dmabuf and draw that every time.