fix(ds5): resolve phantom touchpoint on virtual DualSense

src/haptics/authored_ir.cpp

@@ -245,6 +245,8 @@ namespace haptics {
       _active_since = {};
       _last_nonzero_low = 0;
       _last_nonzero_high = 0;
+      _short_release_low = false;
+      _short_release_high = false;
     }
 
     const bool must_stop = (frame->flags & AH_AUTHORED_FRAME_STREAM_END) != 0;
@@ -270,12 +272,33 @@ namespace haptics {
     if (must_stop) {
       _low_gate = {};
       _high_gate = {};
+      _short_release_low = false;
+      _short_release_high = false;
     }
     const auto low_target = must_stop ? 0.0f : shaped(
       low_energy, legacy_low_makeup_gain, _low_gate, duration_seconds);
     const auto high_target = must_stop ? 0.0f : shaped(
       high_energy, legacy_high_makeup_gain, _high_gate, duration_seconds);
 
+    // A force clear is only appropriate when a target drops out during the
+    // minimum hold window. Effects that were already active beyond that
+    // window must use the configured release tail instead.
+    const bool within_min_hold =
+      _active_since != std::chrono::steady_clock::time_point {} &&
+      now - _active_since < legacy_min_active_hold;
+    if (must_stop || low_target > 0.0f) {
+      _short_release_low = false;
+    }
+    else if (within_min_hold) {
+      _short_release_low = true;
+    }
+    if (must_stop || high_target > 0.0f) {
+      _short_release_high = false;
+    }
+    else if (within_min_hold) {
+      _short_release_high = true;
+    }
+
     const auto smooth = [duration_seconds](float previous, float target,
                                            float attack, float release) {
       const auto tau = target > previous ? attack : release;
@@ -286,14 +309,11 @@ namespace haptics {
       _smoothed_low, low_target, legacy_low_attack_seconds, legacy_low_release_seconds);
     _smoothed_high = must_stop ? 0.0f : smooth(
       _smoothed_high, high_target, legacy_high_attack_seconds, legacy_high_release_seconds);
-    // Once the short-pulse hold has elapsed, do not let the release tail keep
-    // the motors active indefinitely. The hold is for dispatch reliability,
-    // not an extension of the authored signal.
-    if (!must_stop && _active_since != std::chrono::steady_clock::time_point {} &&
-        now - _active_since >= legacy_min_active_hold) {
-      if (low_target <= 0.0f) _smoothed_low = 0.0f;
-      if (high_target <= 0.0f) _smoothed_high = 0.0f;
-    }
+    const bool hold_expired =
+      _active_since != std::chrono::steady_clock::time_point {} &&
+      now - _active_since >= legacy_min_active_hold;
+    if (hold_expired && _short_release_low && low_target <= 0.0f) _smoothed_low = 0.0f;
+    if (hold_expired && _short_release_high && high_target <= 0.0f) _smoothed_high = 0.0f;
     if (low_target <= 0.0f && _smoothed_low < legacy_output_floor) _smoothed_low = 0.0f;
     if (high_target <= 0.0f && _smoothed_high < legacy_output_floor) _smoothed_high = 0.0f;
 
@@ -313,6 +333,8 @@ namespace haptics {
       _active_since = {};
       _last_nonzero_low = 0;
       _last_nonzero_high = 0;
+      _short_release_low = false;
+      _short_release_high = false;
     }
     // The 20 ms rate limit is the only emission gate. Held silence additionally
     // stays quiet instead of re-sending zero rumble at 50 Hz.
@@ -345,6 +367,8 @@ namespace haptics {
     _active_since = {};
     _last_nonzero_low = 0;
     _last_nonzero_high = 0;
+    _short_release_low = false;
+    _short_release_high = false;
     if (!had_output) return std::nullopt;
     _last_emit = now;
     return legacy_rumble_t {_controller_id, 0, 0};

src/haptics/authored_ir.h

@@ -111,6 +111,11 @@ namespace haptics {
     float _smoothed_high = 0.0f;
     gate_state_t _low_gate;
     gate_state_t _high_gate;
+    // Set only when a motor starts releasing before the short-pulse hold
+    // expires. Such pulses are force-cleared at the boundary; long effects
+    // retain their normal release tail.
+    bool _short_release_low = false;
+    bool _short_release_high = false;
     bool _have_input = false;
   };
 }  // namespace haptics

tests/unit/test_authored_ir.cpp

@@ -216,6 +216,46 @@ TEST(AuthoredDualSenseIr, LegacyFallbackClearsFloorAfterRelease) {
   EXPECT_EQ(latest->high_frequency, 0u);
 }
 
+TEST(AuthoredDualSenseIr, LegacyFallbackKeepsReleaseTailForLongEffect) {
+  using namespace std::chrono_literals;
+  haptics::legacy_rumble_session_t session;
+  ASSERT_TRUE(session.ready());
+  const auto start = std::chrono::steady_clock::time_point {1s};
+  const auto burst = sine_pcm(120.0, 32000.0);
+  const std::vector<std::uint8_t> silence(240 * 4);
+
+  // Keep the authored signal active beyond the short-pulse hold window.
+  bool saw_output = false;
+  for (std::uint32_t chunk = 0; chunk <= 20; ++chunk) {
+    const auto output = session.process(
+      0, chunk == 0 ? 0x01 : 0, 240, chunk, chunk * 5000,
+      burst, start + std::chrono::milliseconds(chunk * 5));
+    saw_output = saw_output || output.has_value();
+  }
+  ASSERT_TRUE(saw_output);
+
+  std::optional<haptics::legacy_rumble_t> release_start;
+  std::optional<haptics::legacy_rumble_t> latest;
+  for (std::uint32_t chunk = 21; chunk <= 80; ++chunk) {
+    const auto output = session.process(
+      0, 0, 240, chunk, chunk * 5000, silence,
+      start + std::chrono::milliseconds(chunk * 5));
+    if (output) {
+      if (!release_start) release_start = output;
+      latest = output;
+    }
+  }
+
+  ASSERT_TRUE(release_start.has_value());
+  // A long effect releases through the configured tail instead of being hard
+  // cut at the 80 ms short-pulse boundary.
+  EXPECT_GT(release_start->low_frequency, 0u);
+  EXPECT_GT(release_start->high_frequency, 0u);
+  ASSERT_TRUE(latest.has_value());
+  EXPECT_EQ(latest->low_frequency, 0u);
+  EXPECT_EQ(latest->high_frequency, 0u);
+}
+
 TEST(AuthoredDualSenseIr, LegacyFallbackDiscontinuityDoesNotReuseHold) {
   using namespace std::chrono_literals;
   haptics::legacy_rumble_session_t session;

tools/sunshine-ds5-sidecar/ControllerSession.cs

@@ -68,6 +68,10 @@ internal ControllerSession(byte deviceId,
             _controller.UsbAudio.Output.FramesReceived += OnAudioFrames;
             _controller.UsbAudio.Output.StreamingChanged += OnAudioStreamingChanged;
         }
+        // Emit a centered, untouched idle frame immediately: without it the
+        // device reports an all-zero buffer until the first client input,
+        // which raw consumers decode as a down touch contact at (0,0).
+        _controller.SubmitState(in _state);
     }
 
     internal byte DeviceId { get; }
@@ -165,12 +169,23 @@ internal void SubmitMotion(ReadOnlySpan<byte> payload)
                 _state.AccelGX = x / 9.80665f;
                 _state.AccelGY = y / 9.80665f;
                 _state.AccelGZ = z / 9.80665f;
+                // The alwaysArmed extendedReport encodes sensors from the raw
+                // Sony firmware fields, not the calibrated ones. Scales follow
+                // SDL's hidapi_ps5: 8192 LSB per g, HID gyro units are 1/64 of
+                // 1024 LSB per deg/s (= 16 LSB per deg/s), pitch/yaw/roll map
+                // to SDL gyro X/Y/Z one-to-one.
+                _state.AccelX = RawAccel(_state.AccelGX);
+                _state.AccelY = RawAccel(_state.AccelGY);
+                _state.AccelZ = RawAccel(_state.AccelGZ);
             }
             else if (type == 2)
             {
                 _state.GyroDpsX = x;
                 _state.GyroDpsY = y;
                 _state.GyroDpsZ = z;
+                _state.GyroPitch = RawGyro(x);
+                _state.GyroYaw = RawGyro(y);
+                _state.GyroRoll = RawGyro(z);
             }
             else
             {
@@ -346,6 +361,12 @@ private void SetTouch(int slot, bool active, uint pointerId, float x, float y)
         }
     }
 
+    private static short RawAccel(float g) =>
+        (short)Math.Clamp((int)Math.Round(g * 8192f), short.MinValue, short.MaxValue);
+
+    private static short RawGyro(float degreesPerSecond) =>
+        (short)Math.Clamp((int)Math.Round(degreesPerSecond * 16f), short.MinValue, short.MaxValue);
+
     private static HMButton MapButtons(uint flags)
     {
         var result = HMButton.None;

tools/sunshine-ds5-sidecar/SidecarServer.cs

@@ -20,6 +20,7 @@ internal sealed class SidecarServer : IAsyncDisposable
     internal SidecarServer(string pipeName)
     {
         _pipeName = pipeName;
+        LoadPatchedProfiles();
         _context.LoadDefaultProfiles();
         _authoredHapticsAvailable = _context.GetProfile("dualsense-composite") is not null &&
                                     HMContext.IsUsbipBackendAvailable;
@@ -240,6 +241,39 @@ private void Detach(uint requestId, ReadOnlySpan<byte> payload)
         Emit(new Protocol.Message(Protocol.MessageType.DetachReply, requestId, new[] { payload[0] }));
     }
 
+    private void LoadPatchedProfiles()
+    {
+        // Upstream v1.6.1 USB DualSense profiles leave extendedReport unarmed,
+        // so the vendor-blob encoder never runs and the Sony tail of report
+        // 0x01 (touch fingers at bytes 33/37, rolling counter, sensors,
+        // battery) idles at 0x00. Windows and raw HID consumers decode byte
+        // 33 == 0x00 as a touch contact that is permanently down at (0,0),
+        // which the PTP stack turns into a held drag (menus auto-focus and
+        // inertia-scroll). Register our alwaysArmed copies before the stock
+        // catalog: profile loads skip duplicate IDs, so the first
+        // registration wins.
+        try
+        {
+            var assembly = typeof(SidecarServer).Assembly;
+            var directory = Path.Combine(Path.GetTempPath(), "sunshine-ds5-profiles");
+            Directory.CreateDirectory(directory);
+            foreach (var id in new[] { "dualsense", "dualsense-composite" })
+            {
+                var resourceName = $"Sunshine.Ds5Sidecar.profiles.{id}.json";
+                using var stream = assembly.GetManifestResourceStream(resourceName)
+                    ?? throw new InvalidOperationException($"Embedded profile '{resourceName}' is missing");
+                using var file = File.Create(Path.Combine(directory, id + ".json"));
+                stream.CopyTo(file);
+            }
+            if (_context.LoadProfilesFromDirectory(directory) < 2)
+                Console.Error.WriteLine("Patched DualSense profiles did not fully register");
+        }
+        catch (Exception error)
+        {
+            Console.Error.WriteLine($"Unable to load patched DualSense profiles: {error.Message}");
+        }
+    }
+
     private ControllerSession GetController(ReadOnlySpan<byte> payload)
     {
         if (payload.IsEmpty || !_controllers.TryGetValue(payload[0], out var controller))

tools/sunshine-ds5-sidecar/Sunshine.Ds5Sidecar.csproj

@@ -18,4 +18,15 @@
       <Private>true</Private>
     </Reference>
   </ItemGroup>
+  <ItemGroup>
+    <!-- Upstream v1.6.1 USB DualSense profiles with extendedReport.alwaysArmed
+         added. The stock profiles never arm the vendor-blob encoder, so the
+         Sony-specific tail of report 0x01 (touch fingers at bytes 33/37 among
+         others) is never written and idles at 0x00, which every raw consumer
+         decodes as a permanently down touch at (0,0). Real USB DualSense pads
+         stream the full 64-byte report from power-on, so alwaysArmed matches
+         hardware behaviour. -->
+    <EmbeddedResource Include="profiles\dualsense.json" LogicalName="Sunshine.Ds5Sidecar.profiles.dualsense.json" />
+    <EmbeddedResource Include="profiles\dualsense-composite.json" LogicalName="Sunshine.Ds5Sidecar.profiles.dualsense-composite.json" />
+  </ItemGroup>
 </Project>