fix: DualSense improvements

Author: ReenigneArcher

docs/platform-support.md

@@ -138,6 +138,16 @@ and control channels. Numbered control-channel output is normalized before
 parsing, whether the kernel includes the report number in the payload or
 provides it separately on the UHID event.
 
+The default DualSense profile uses Bluetooth framing, matching Inputtino's
+proven native-controller path and avoiding the parent-USB checks that can make
+virtual USB devices appear late in Steam. Explicit USB and Bluetooth factories
+remain available for consumers that require a particular transport. DualSense
+motion packing preserves the public meters-per-second-squared and
+degrees-per-second units while applying the same raw sensor calibration used by
+Inputtino. Periodic PlayStation reports are repacked at 100 Hz so their sequence
+number and sensor timestamp continue to advance even when controller state is
+unchanged.
+
 The backend opens `/dev/uhid` in nonblocking mode, matching the original
 asynchronous gamepad registration path. Its event reader is active before
 device registration begins, and creation does not report success until the

docs/usage.md

@@ -217,6 +217,10 @@ Consumers may replace `DeviceProfile::name` before creating a gamepad, for
 example, to prepend an application name while preserving the default controller
 identity across platform backends.
 
+`profiles::dualsense()` selects Bluetooth framing for reliable native-controller
+discovery. Consumers can select `profiles::dualsense_usb()` or
+`profiles::dualsense_bluetooth()` when the transport must be explicit.
+
 The platform-neutral Generic HID descriptor reports the D-pad as buttons 13
 through 16 in the input report. Linux may still route that profile through
 `uinput`, where the backend exposes those same logical directions through the

src/core/profiles.cpp

@@ -2107,7 +2107,7 @@ namespace lvh::profiles {
   }
 
   DeviceProfile dualsense() {
-    return dualsense_usb();
+    return dualsense_bluetooth();
   }
 
   DeviceProfile dualsense_usb() {

src/core/report.cpp

@@ -6,11 +6,13 @@
 // standard includes
 #include <algorithm>
 #include <array>
+#include <atomic>
 #include <chrono>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
+#include <numbers>
 #include <optional>
 #include <span>
 #include <utility>
@@ -61,6 +63,10 @@ namespace lvh::reports {
 
     constexpr auto dualsense_flag2_compatible_vibration = std::byte {0x04};
 
+    constexpr auto dualsense_acceleration_scale = 9.80665F * 100.0F;
+
+    constexpr auto dualsense_gyroscope_scale = 1145.0F * std::numbers::pi_v<float> / 180.0F;
+
     constexpr std::uint8_t switch_rumble_and_subcommand_output_report_id = 0x01;
 
     constexpr std::uint8_t switch_rumble_only_output_report_id = 0x10;
@@ -613,6 +619,19 @@ namespace lvh::reports {
       return static_cast<std::uint16_t>((static_cast<std::uint64_t>(elapsed) * 3U) / 16U);
     }
 
+    std::uint8_t dualsense_sequence_number() {
+      static std::atomic_uint32_t sequence_number = 0;
+      return static_cast<std::uint8_t>((sequence_number.fetch_add(1U, std::memory_order_relaxed) + 1U) % 255U);
+    }
+
+    std::uint32_t dualsense_sensor_timestamp() {
+      const auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                             std::chrono::steady_clock::now().time_since_epoch()
+      )
+                             .count();
+      return static_cast<std::uint32_t>(static_cast<std::uint64_t>(elapsed) / 333U);
+    }
+
     std::vector<std::uint8_t> pack_dualshock4_input_report(const DeviceProfile &profile, const GamepadState &state) {
       const auto is_bluetooth = profile.bus_type == BusType::bluetooth;
       const auto payload_offset = is_bluetooth ? 3U : 1U;
@@ -722,6 +741,7 @@ namespace lvh::reports {
       report[payload_offset + 3U] = to_byte(normalize_u8_axis(-normalized.right_stick.y));
       report[payload_offset + 4U] = to_byte(normalize_trigger(normalized.left_trigger));
       report[payload_offset + 5U] = to_byte(normalize_trigger(normalized.right_trigger));
+      report[payload_offset + 6U] = to_byte(dualsense_sequence_number());
       report[payload_offset + 7U] = to_byte(hat_from_buttons(normalized.buttons));
 
       if (normalized.buttons.test(GamepadButton::x)) {
@@ -773,15 +793,16 @@ namespace lvh::reports {
       }
 
       if (normalized.gyroscope) {
-        write_i16(report, payload_offset + 15U, scale_i16(normalized.gyroscope->x, 1145.0F));
-        write_i16(report, payload_offset + 17U, scale_i16(normalized.gyroscope->y, 1145.0F));
-        write_i16(report, payload_offset + 19U, scale_i16(normalized.gyroscope->z, 1145.0F));
+        write_i16(report, payload_offset + 15U, scale_i16(normalized.gyroscope->x, dualsense_gyroscope_scale));
+        write_i16(report, payload_offset + 17U, scale_i16(normalized.gyroscope->y, dualsense_gyroscope_scale));
+        write_i16(report, payload_offset + 19U, scale_i16(normalized.gyroscope->z, dualsense_gyroscope_scale));
       }
       if (normalized.acceleration) {
-        write_i16(report, payload_offset + 21U, scale_i16(normalized.acceleration->x, 100.0F));
-        write_i16(report, payload_offset + 23U, scale_i16(normalized.acceleration->y, 100.0F));
-        write_i16(report, payload_offset + 25U, scale_i16(normalized.acceleration->z, 100.0F));
+        write_i16(report, payload_offset + 21U, scale_i16(normalized.acceleration->x, dualsense_acceleration_scale));
+        write_i16(report, payload_offset + 23U, scale_i16(normalized.acceleration->y, dualsense_acceleration_scale));
+        write_i16(report, payload_offset + 25U, scale_i16(normalized.acceleration->z, dualsense_acceleration_scale));
       }
+      write_u32(report, payload_offset + 27U, dualsense_sensor_timestamp());
 
       write_dualsense_touch_contact(report, payload_offset + 32U, normalized.touchpad_contacts[0]);
       write_dualsense_touch_contact(report, payload_offset + 36U, normalized.touchpad_contacts[1]);

src/include/libvirtualhid/profiles.hpp

@@ -65,7 +65,11 @@ namespace lvh::profiles {
   /**
    * @brief Create the PlayStation DualSense-compatible gamepad profile.
    *
-   * @return Default DualSense-compatible device profile.
+   * The default uses Bluetooth framing because Linux native-controller
+   * consumers discover virtual DualSense devices more reliably through that
+   * transport. Use `dualsense_usb()` when USB framing is explicitly required.
+   *
+   * @return Bluetooth DualSense-compatible device profile.
    */
   DeviceProfile dualsense();
 

src/platform/linux/uhid_backend.cpp

@@ -2815,8 +2815,8 @@ namespace lvh::detail {
         std::memcpy(request.rd_data, options.profile.report_descriptor.data(), options.profile.report_descriptor.size());
         profile_ = options.profile;
         {
-          std::lock_guard lock {report_mutex_};
-          last_report_ = reports::pack_input_report(profile_, {});
+          std::lock_guard lock {state_mutex_};
+          last_state_ = {};
         }
 
         {
@@ -2848,7 +2848,7 @@ namespace lvh::detail {
       }
 
       OperationStatus submit(
-        const GamepadState & /*state*/,
+        const GamepadState &state,
         const std::vector<std::uint8_t> &report
       ) override {
         if (!open_) {
@@ -2865,8 +2865,8 @@ namespace lvh::detail {
         std::memcpy(event.u.input2.data, report.data(), report.size());
         auto status = write_event(event);
         if (status.ok()) {
-          std::lock_guard lock {report_mutex_};
-          last_report_ = report;
+          std::lock_guard lock {state_mutex_};
+          last_state_ = state;
         }
         return status;
       }
@@ -3042,13 +3042,14 @@ namespace lvh::detail {
             break;
           }
 
-          std::vector<std::uint8_t> report;
+          GamepadState state;
           {
-            std::lock_guard lock {report_mutex_};
-            report = last_report_;
+            std::lock_guard lock {state_mutex_};
+            state = last_state_;
           }
+          const auto report = reports::pack_input_report(profile_, state);
           if (!report.empty()) {
-            static_cast<void>(submit({}, report));
+            static_cast<void>(submit(state, report));
           }
         }
       }
@@ -3173,7 +3174,7 @@ namespace lvh::detail {
       std::string physical_id_;
       std::string unique_id_;
       std::array<std::uint8_t, 6> playstation_mac_address_ {};
-      std::vector<std::uint8_t> last_report_;
+      GamepadState last_state_;
       std::atomic_bool open_ = true;
       std::atomic_bool running_ = false;
       std::jthread reader_;
@@ -3183,7 +3184,7 @@ namespace lvh::detail {
       bool started_ = false;
       bool reader_exited_ = false;
       std::mutex write_mutex_;
-      std::mutex report_mutex_;
+      std::mutex state_mutex_;
       std::mutex callback_mutex_;
       OutputCallback output_callback_;
     };

tests/fixtures/include/fixtures/linux_backend_test_hooks.hpp

@@ -212,9 +212,9 @@ namespace lvh::detail::test {
     bool saw_dualshock4_feature_crc = false;
 
     /**
-     * @brief Whether the peer observed a Bluetooth-framed DualSense input report.
+     * @brief Whether valid periodic Bluetooth DualSense reports advanced their sensor metadata.
      */
-    bool saw_dualsense_bluetooth_input = false;
+    bool saw_dualsense_bluetooth_input_with_live_sensor_metadata = false;
 
     /**
      * @brief Whether the peer observed a Bluetooth-framed DualShock 4 input report.

tests/fixtures/linux_backend_test_hooks.cpp

@@ -1698,13 +1698,30 @@ namespace lvh::detail::test {
     UhidGamepad gamepad {descriptors[0]};
     auto event = create_started_profile_uhid_gamepad(gamepad, 9, options, descriptors[1], BUS_BLUETOOTH, result);
 
+    bool first_input_report_valid = false;
+    std::uint8_t first_sequence = 0;
+    std::uint32_t first_sensor_timestamp = 0;
     if (read_uhid_event_type(descriptors[1], UHID_INPUT2, event)) {
       const auto report_size = static_cast<std::size_t>(event.u.input2.size);
       if (report_size == options.profile.input_report_size && event.u.input2.data[0] == 0x31) {
         const auto crc_offset = report_size - 4U;
         const auto expected_crc = crc32(std::span<const std::uint8_t> {event.u.input2.data, crc_offset}, playstation_crc_seed(0xA1));
         const auto actual_crc = read_u32_le(event.u.input2.data + crc_offset);
-        result.saw_dualsense_bluetooth_input = expected_crc == actual_crc;
+        first_input_report_valid = expected_crc == actual_crc;
+        first_sequence = event.u.input2.data[8];
+        first_sensor_timestamp = read_u32_le(event.u.input2.data + 29U);
+      }
+    }
+
+    if (read_uhid_event_type(descriptors[1], UHID_INPUT2, event)) {
+      const auto report_size = static_cast<std::size_t>(event.u.input2.size);
+      if (report_size == options.profile.input_report_size && event.u.input2.data[0] == 0x31) {
+        const auto crc_offset = report_size - 4U;
+        const auto expected_crc = crc32(std::span<const std::uint8_t> {event.u.input2.data, crc_offset}, playstation_crc_seed(0xA1));
+        const auto actual_crc = read_u32_le(event.u.input2.data + crc_offset);
+        result.saw_dualsense_bluetooth_input_with_live_sensor_metadata =
+          first_input_report_valid && expected_crc == actual_crc && event.u.input2.data[8] != first_sequence &&
+          read_u32_le(event.u.input2.data + 29U) != first_sensor_timestamp;
       }
     }
 

tests/unit/test_linux_backend.cpp

@@ -826,7 +826,7 @@ TEST_F(LinuxBackendTest, SocketpairBackedDualSenseBluetoothFramesReports) {
   EXPECT_TRUE(result.creation.saw_create);
   EXPECT_TRUE(result.creation.waited_for_start);
   EXPECT_EQ(result.creation.name, "Wireless Controller");
-  EXPECT_TRUE(result.saw_dualsense_bluetooth_input);
+  EXPECT_TRUE(result.saw_dualsense_bluetooth_input_with_live_sensor_metadata);
   EXPECT_TRUE(result.saw_dualsense_pairing);
   EXPECT_TRUE(result.saw_dualsense_feature_crc);
 }

tests/unit/test_profiles.cpp

@@ -196,6 +196,10 @@ TEST(ProfileTest, StreamingControllerProfilesArePresent) {
   EXPECT_NE(dualshock4_bluetooth.report_descriptor, dualshock4.report_descriptor);
 
   EXPECT_EQ(dualsense.vendor_id, 0x054C);
+  EXPECT_EQ(dualsense.bus_type, lvh::BusType::bluetooth);
+  EXPECT_EQ(dualsense.report_id, 0x31);
+  EXPECT_EQ(dualsense.input_report_size, 78U);
+  EXPECT_EQ(dualsense.output_report_size, 78U);
   EXPECT_TRUE(dualsense.capabilities.supports_motion);
   EXPECT_TRUE(dualsense.capabilities.supports_touchpad);
   EXPECT_TRUE(dualsense.capabilities.supports_rgb_led);
@@ -210,7 +214,14 @@ TEST(ProfileTest, StreamingControllerProfilesArePresent) {
   EXPECT_EQ(dualsense_bluetooth.report_id, 0x31);
   EXPECT_EQ(dualsense_bluetooth.input_report_size, 78U);
   EXPECT_EQ(dualsense_bluetooth.output_report_size, 78U);
-  EXPECT_NE(dualsense_bluetooth.report_descriptor, dualsense.report_descriptor);
+  EXPECT_EQ(dualsense_bluetooth.report_descriptor, dualsense.report_descriptor);
+
+  const auto dualsense_usb = lvh::profiles::dualsense_usb();
+  EXPECT_EQ(dualsense_usb.bus_type, lvh::BusType::usb);
+  EXPECT_EQ(dualsense_usb.report_id, 0x01);
+  EXPECT_EQ(dualsense_usb.input_report_size, 64U);
+  EXPECT_EQ(dualsense_usb.output_report_size, 48U);
+  EXPECT_NE(dualsense_usb.report_descriptor, dualsense.report_descriptor);
 
   EXPECT_EQ(switch_pro.vendor_id, 0x057E);
   EXPECT_EQ(switch_pro.product_id, 0x2009);