Unify Switch Pro packet counter across report types

Replace the separate full-state timer (incrementing by 3) with a single per-device counter shared by both subcommand replies (0x21) and full-state input reports (0x30). The counter now increments by 1 per report, matching native controller behavior. On Windows the counter is stored per-device in the VHF record and stamped at submission time. The shared `next_switch_pro_packet_timer` helper is moved to `switch_pro_protocol.hpp` and accepts an optional override so callers can inject a specific value.

Author: ReenigneArcher

docs/end-user-gamepad-guide.md

@@ -83,9 +83,9 @@ Switch Pro USB and subcommand initialization sequence and accepts the native
 `0x30` input layout, so descriptor-aware consumers can initialize those
 controllers before sending their native output reports. The Switch Pro profile
 uses the `0x0210` hardware revision reported by a physical Nintendo controller,
-and the Windows VHF device exposes that revision to HID consumers. Consecutive
-full-state reports also advance Nintendo's packet timer by their three packed
-IMU samples so consumers can distinguish new sensor batches.
+and the Windows VHF device exposes that revision to HID consumers. Full-state
+and subcommand-reply reports use the same per-device packet counter on Windows,
+matching the counter that a native controller advances for every input report.
 
 Windows VHF devices do not expose a Bluetooth transport identity to HIDAPI.
 The Windows backend therefore reports DualShock 4 and DualSense requests as

docs/platform-support.md

@@ -18,6 +18,8 @@
 #include <utility>
 
 // local includes
+#include "shared/switch_pro_protocol.hpp"
+
 #include <libvirtualhid/report.hpp>
 
 namespace lvh::reports {
@@ -83,13 +85,6 @@ namespace lvh::reports {
 
     constexpr float switch_gyroscope_scale = 14.2842F;
 
-    std::uint8_t switch_pro_packet_timer() {
-      // Native full-state reports carry three IMU samples spaced five
-      // milliseconds apart, so the controller timer advances by three.
-      static std::atomic_uint32_t packet_timer = 0;
-      return static_cast<std::uint8_t>(packet_timer.fetch_add(3U, std::memory_order_relaxed));
-    }
-
     std::uint8_t decode_switch_home_light_intensity(std::byte encoded_intensity) {
       const auto intensity = std::to_integer<std::uint8_t>(encoded_intensity >> 4U);
       if (intensity == 0U) {
@@ -1239,7 +1234,7 @@ namespace lvh::reports {
 
     ByteReport report(profile.input_report_size, zero_byte);
     report[0] = to_byte(profile.report_id);
-    report[1] = to_byte(switch_pro_packet_timer());
+    report[1] = to_byte(detail::switch_pro_protocol::next_switch_pro_packet_timer());
     report[2] = switch_battery_and_connection(normalized.battery);
 
     if (normalized.buttons.test(x)) {

src/core/report.cpp

@@ -122,6 +122,7 @@ namespace {
     lvh::detail::windows::VhfInputReportQueue pending_input_reports;
     std::shared_ptr<std::vector<std::uint8_t>> in_flight_input_report;
     std::size_t active_input_submissions {};
+    std::uint8_t switch_pro_packet_timer {};
     bool vhf_ready_for_input_report {};
     bool shutting_down {};
   };
@@ -254,6 +255,12 @@ namespace {
     }
 
     auto report = std::make_shared<std::vector<std::uint8_t>>(std::move(*pending));
+    if (
+      record.request.gamepad_kind == LVH_WINDOWS_GAMEPAD_SWITCH_PRO && report->size() > 1U &&
+      (report->at(0) == 0x21U || report->at(0) == 0x30U)
+    ) {
+      report->at(1) = record.switch_pro_packet_timer++;
+    }
     const auto configured_report_id = record.request.hardware_ids.report_id;
     const auto report_id = configured_report_id == 0U || report->empty() ? configured_report_id : report->front();
 

src/platform/windows/driver/libvirtualhid_umdf.cpp

@@ -7,6 +7,7 @@
 // standard includes
 #include <algorithm>
 #include <array>
+#include <atomic>
 #include <cstddef>
 #include <cstdint>
 #include <optional>
@@ -17,6 +18,11 @@ namespace lvh::detail::switch_pro_protocol {
   inline constexpr std::size_t switch_pro_report_size = 64U;
   using SwitchProReport = std::array<std::uint8_t, switch_pro_report_size>;
 
+  inline std::uint8_t next_switch_pro_packet_timer() {
+    static std::atomic_uint32_t packet_timer {0};
+    return static_cast<std::uint8_t>(packet_timer.fetch_add(1U, std::memory_order_relaxed));
+  }
+
   namespace switch_pro_protocol_detail {
 
     inline constexpr std::array<std::uint8_t, 6> controller_mac {0x02, 0x00, 0x00, 0x00, 0x00, 0x01};
@@ -149,7 +155,10 @@ namespace lvh::detail::switch_pro_protocol {
 
   }  // namespace switch_pro_protocol_detail
 
-  inline std::optional<SwitchProReport> make_switch_pro_reply(std::span<const std::uint8_t> output_report) {
+  inline std::optional<SwitchProReport> make_switch_pro_reply(
+    std::span<const std::uint8_t> output_report,
+    std::optional<std::uint8_t> packet_timer = std::nullopt
+  ) {
     if (output_report.empty()) {
       return std::nullopt;
     }
@@ -184,7 +193,10 @@ namespace lvh::detail::switch_pro_protocol {
 
     SwitchProReport reply {};
     reply[0] = 0x21;
-    switch_pro_protocol_detail::set_neutral_controller_state(reply, output_report[1]);
+    switch_pro_protocol_detail::set_neutral_controller_state(
+      reply,
+      packet_timer.has_value() ? *packet_timer : next_switch_pro_packet_timer()
+    );
     auto acknowledgement = std::uint8_t {0x80};
     if (subcommand == 0x10U) {
       acknowledgement = 0x90;

src/shared/switch_pro_protocol.hpp

@@ -205,15 +205,15 @@ TEST(ReportTest, PacksSwitchProReport) {
   }
 }
 
-TEST(ReportTest, AdvancesSwitchProPacketTimerForEachImuBatch) {
+TEST(ReportTest, AdvancesSwitchProPacketTimerForEachInputReport) {
   const auto profile = lvh::profiles::switch_pro();
 
   const auto first = lvh::reports::pack_input_report(profile, {});
   const auto second = lvh::reports::pack_input_report(profile, {});
 
   ASSERT_EQ(first.size(), profile.input_report_size);
   ASSERT_EQ(second.size(), profile.input_report_size);
-  EXPECT_EQ(second[1], static_cast<std::uint8_t>(first[1] + 3U));
+  EXPECT_EQ(second[1], static_cast<std::uint8_t>(first[1] + 1U));
 }
 
 TEST(ReportTest, PacksSwitchProMotionInEveryImuSample) {

tests/unit/test_report.cpp

@@ -858,7 +858,7 @@ TEST_F(WindowsConsumerTest, NativeSwitchHandshakeAndInputReportReachHidClient) {
   ASSERT_TRUE(player_lights_reply.has_value()) << "No Switch player-light acknowledgement reached the HID client";
   ASSERT_GE(player_lights_reply->size(), 15U);
   EXPECT_EQ(player_lights_reply->at(0), 0x21U);
-  EXPECT_EQ(player_lights_reply->at(1), 0x08U);
+  EXPECT_EQ(player_lights_reply->at(1), 0x00U);
   EXPECT_EQ(player_lights_reply->at(13), 0x80U);
   EXPECT_EQ(player_lights_reply->at(14), 0x30U);
 
@@ -885,6 +885,7 @@ TEST_F(WindowsConsumerTest, NativeSwitchHandshakeAndInputReportReachHidClient) {
   ASSERT_TRUE(input.has_value()) << "No native Switch 0x30 input report reached the HID client";
   ASSERT_EQ(input->size(), profile.input_report_size);
   EXPECT_EQ(input->at(0), 0x30U);
+  EXPECT_EQ(input->at(1), static_cast<std::uint8_t>(player_lights_reply->at(1) + 1U));
   EXPECT_EQ(input->at(3), 0x08U);  // Nintendo A in the native right-button byte.
   EXPECT_EQ(input->at(4), 0x14U);  // R3 and Home.
   EXPECT_EQ(input->at(5), 0x08U);  // D-pad left.
@@ -914,7 +915,7 @@ TEST_F(WindowsConsumerTest, NativeSwitchHandshakeAndInputReportReachHidClient) {
   const auto next_input = read_hid_report_with_timeout(reader.get(), hid_interface->input_report_size, 5s);
   ASSERT_TRUE(next_input.has_value()) << "No second native Switch motion report reached the HID client";
   ASSERT_EQ(next_input->size(), profile.input_report_size);
-  EXPECT_EQ(next_input->at(1), static_cast<std::uint8_t>(input->at(1) + 3U));
+  EXPECT_EQ(next_input->at(1), static_cast<std::uint8_t>(input->at(1) + 1U));
   EXPECT_NE(next_input->at(19), input->at(19));
   ASSERT_TRUE(created.adapter->close().ok());
 }

tests/unit/test_windows_consumers.cpp

@@ -140,10 +140,10 @@ TEST_F(WindowsDriverProtocolTest, SwitchProRepliesToUsbStatusAndHandshakeCommand
 TEST_F(WindowsDriverProtocolTest, SwitchProAcknowledgesInitializationSubcommands) {
   for (const auto subcommand : {0x03U, 0x30U, 0x38U, 0x40U, 0x41U, 0x48U}) {
     const auto report = switch_output_report(0x01, static_cast<std::uint8_t>(subcommand));
-    const auto reply = lvh::detail::switch_pro_protocol::make_switch_pro_reply(report);
+    const auto reply = lvh::detail::switch_pro_protocol::make_switch_pro_reply(report, 0x42U);
     ASSERT_TRUE(reply.has_value());
     EXPECT_EQ(reply->at(0), 0x21);
-    EXPECT_EQ(reply->at(1), 0x07);
+    EXPECT_EQ(reply->at(1), 0x42);
     EXPECT_EQ(reply->at(2), 0x81);
     EXPECT_EQ(reply->at(13), 0x80);
     EXPECT_EQ(reply->at(14), subcommand);