Add player LED feedback and extension capability

Introduce a new gamepad feedback path for player indicator LEDs, including a new feedback message type, control-stream packet encoding (0x5504), and virtual HID output handling with deduplication of repeated LED states. Broaden controller extension capability detection from touchpad-only to touchpad-or-motion and use it consistently across Linux, macOS, and Windows capability reporting. Update unit tests to cover both touchpad support and controller extension advertising, plus player LED routing/dedup behavior, and bump the libvirtualhid submodule.

Author: ReenigneArcher

src/platform/common.h

@@ -116,6 +116,7 @@ namespace platf {
     rumble_triggers,  ///< Rumble triggers
     set_motion_event_state,  ///< Set motion event state
     set_rgb_led,  ///< Set RGB LED
+    set_player_leds,  ///< Set player indicator LEDs
     set_adaptive_triggers,  ///< Set adaptive triggers
   };
 
@@ -189,6 +190,22 @@ namespace platf {
       return msg;
     }
 
+    /**
+     * @brief Create player indicator LED state.
+     *
+     * @param id Identifier for the controller, session, display, or resource.
+     * @param solid Four-bit mask of solid player indicators.
+     * @param flashing Four-bit mask of flashing player indicators.
+     * @return Constructed player indicator LED object.
+     */
+    static gamepad_feedback_msg_t make_player_leds(std::uint16_t id, std::uint8_t solid, std::uint8_t flashing) {
+      gamepad_feedback_msg_t msg;
+      msg.type = gamepad_feedback_e::set_player_leds;
+      msg.id = id;
+      msg.data.player_leds = {solid, flashing};
+      return msg;
+    }
+
     /**
      * @brief Create adaptive triggers.
      *
@@ -233,6 +250,11 @@ namespace platf {
         std::uint8_t b;
       } rgb_led;
 
+      struct {
+        std::uint8_t solid;
+        std::uint8_t flashing;
+      } player_leds;
+
       struct {
         uint16_t controllerNumber;
         uint8_t event_flags;
@@ -380,9 +402,9 @@ namespace platf {
      */
     constexpr caps_t pen_touch = 0x01;  // Pen and touch events
     /**
-     * @brief Capability bit indicating controller touchpad support.
+     * @brief Capability bit indicating controller touchpad and motion support.
      */
-    constexpr caps_t controller_touch = 0x02;  // Controller touch events
+    constexpr caps_t controller_touch = 0x02;  // Controller touch and motion events
   };  // namespace platform_caps
 
   /**

src/platform/linux/input/virtualhid.cpp

@@ -28,7 +28,7 @@ namespace platf {
     if (const auto &capabilities = runtime->capabilities(); config::input.native_pen_touch && (capabilities.supports_touchscreen || capabilities.supports_pen_tablet)) {
       caps |= platform_caps::pen_touch;
     }
-    if (virtualhid::configured_gamepad_supports_touchpad()) {
+    if (virtualhid::configured_gamepad_supports_controller_extensions()) {
       caps |= platform_caps::controller_touch;
     }
 

src/platform/macos/input.cpp

@@ -37,7 +37,7 @@ namespace platf {
     }
 
     const auto &capabilities = runtime->capabilities();
-    if (capabilities.supports_gamepad && virtualhid::configured_gamepad_supports_touchpad()) {
+    if (capabilities.supports_gamepad && virtualhid::configured_gamepad_supports_controller_extensions()) {
       caps |= platform_caps::controller_touch;
     }
     if (config::input.native_pen_touch && (capabilities.supports_touchscreen || capabilities.supports_pen_tablet)) {

src/platform/virtualhid_input.cpp

@@ -45,6 +45,9 @@ namespace platf::virtualhid {
     std::uint8_t last_red = 0;  ///< Last red LED value.
     std::uint8_t last_green = 0;  ///< Last green LED value.
     std::uint8_t last_blue = 0;  ///< Last blue LED value.
+    bool has_last_player_leds = false;  ///< Whether last player indicator LED values are valid.
+    std::uint8_t last_solid_player_leds = 0;  ///< Last solid player indicator mask.
+    std::uint8_t last_flashing_player_leds = 0;  ///< Last flashing player indicator mask.
   };
 
   namespace {
@@ -316,6 +319,22 @@ namespace platf::virtualhid {
       return event;
     }
 
+    /**
+     * @brief Pack four player indicator states into a protocol bit mask.
+     *
+     * @param leds Player indicator states ordered from player one through four.
+     * @return Four-bit player indicator mask.
+     */
+    std::uint8_t player_led_mask(const std::array<bool, 4> &leds) {
+      std::byte mask {};
+      for (std::size_t index = 0; index < leds.size(); ++index) {
+        if (leds[index]) {
+          mask |= std::byte {1} << index;
+        }
+      }
+      return std::to_integer<std::uint8_t>(mask);
+    }
+
     lvh::PenToolType pen_tool(std::uint8_t tool) {
       using enum lvh::PenToolType;
 
@@ -390,6 +409,19 @@ namespace platf::virtualhid {
           gamepad->last_blue = output.blue;
           raise_feedback_unlocked(gamepad, gamepad_feedback_msg_t::make_rgb_led(gamepad->client_relative_index, output.red, output.green, output.blue));
           break;
+        case lvh::GamepadOutputKind::player_leds:
+          {
+            const auto solid = player_led_mask(output.player_leds);
+            const auto flashing = player_led_mask(output.flashing_player_leds);
+            if (gamepad->has_last_player_leds && gamepad->last_solid_player_leds == solid && gamepad->last_flashing_player_leds == flashing) {
+              return;
+            }
+            gamepad->has_last_player_leds = true;
+            gamepad->last_solid_player_leds = solid;
+            gamepad->last_flashing_player_leds = flashing;
+            raise_feedback_unlocked(gamepad, gamepad_feedback_msg_t::make_player_leds(gamepad->client_relative_index, solid, flashing));
+            break;
+          }
         case lvh::GamepadOutputKind::adaptive_triggers:
           raise_feedback_unlocked(gamepad, gamepad_feedback_msg_t::make_adaptive_triggers(gamepad->client_relative_index, output.adaptive_trigger_flags, output.left_trigger_effect_type, output.right_trigger_effect_type, output.left_trigger_effect, output.right_trigger_effect));
           break;
@@ -595,6 +627,7 @@ namespace platf::virtualhid {
     gamepad->has_last_rumble = false;
     gamepad->has_last_trigger_rumble = false;
     gamepad->has_last_rgb = false;
+    gamepad->has_last_player_leds = false;
 
     if (gamepad->adapter->support().supports_motion) {
       raise_feedback_unlocked(gamepad, gamepad_feedback_msg_t::make_motion_event_state(id.clientRelativeIndex, LI_MOTION_TYPE_ACCEL, 100));
@@ -913,6 +946,16 @@ namespace platf::virtualhid {
     return lvh::gamepad_profile_support(profile).supports_touchpad;
   }
 
+  bool configured_gamepad_supports_controller_extensions() {
+    if (config::input.gamepad == "auto"sv) {
+      return true;
+    }
+
+    const auto profile = profile_for_name(config::input.gamepad).profile();
+    const auto &support = lvh::gamepad_profile_support(profile);
+    return support.supports_touchpad || support.supports_motion;
+  }
+
 }  // namespace platf::virtualhid
 
 namespace platf {

src/platform/virtualhid_input.h

@@ -279,4 +279,14 @@ namespace platf::virtualhid {
    */
   bool configured_gamepad_supports_touchpad();
 
+  /**
+   * @brief Return whether the configured gamepad profile needs Moonlight controller extensions.
+   *
+   * Moonlight uses the controller-touch feature flag to authorize both controller
+   * touchpad and motion packets.
+   *
+   * @return True when controller touchpad or motion input should be advertised.
+   */
+  bool configured_gamepad_supports_controller_extensions();
+
 }  // namespace platf::virtualhid

src/platform/windows/input.cpp

@@ -1234,7 +1234,7 @@ namespace platf {
   platform_caps::caps_t get_capabilities() {
     platform_caps::caps_t caps = 0;
 
-    if (virtualhid::configured_gamepad_supports_touchpad()) {
+    if (virtualhid::configured_gamepad_supports_controller_extensions()) {
       caps |= platform_caps::controller_touch;
     }
 

src/stream.cpp

@@ -49,6 +49,7 @@ constexpr int IDX_RUMBLE_TRIGGER_DATA = 12;  ///< Control-stream message index f
 constexpr int IDX_SET_MOTION_EVENT = 13;  ///< Control-stream message index for set motion event.
 constexpr int IDX_SET_RGB_LED = 14;  ///< Control-stream message index for set rgb led.
 constexpr int IDX_SET_ADAPTIVE_TRIGGERS = 15;  ///< Control-stream message index for set adaptive triggers.
+constexpr int IDX_SET_PLAYER_LEDS = 16;  ///< Control-stream message index for set player indicator LEDs.
 
 static const short packetTypes[] = {
   0x0305,  // Start A
@@ -67,6 +68,7 @@ static const short packetTypes[] = {
   0x5501,  // Set motion event (Sunshine protocol extension)
   0x5502,  // Set RGB LED (Sunshine protocol extension)
   0x5503,  // Set Adaptive triggers (Sunshine protocol extension)
+  0x5504,  // Set player indicator LEDs (Sunshine protocol extension)
 };
 
 namespace asio = boost::asio;
@@ -239,6 +241,17 @@ namespace stream {
     std::uint8_t b;  ///< Blue LED channel.
   };
 
+  /**
+   * @brief Control payload that sets controller player indicator LEDs.
+   */
+  struct control_set_player_leds_t {
+    control_header_v2 header;  ///< Control message header preceding this payload.
+
+    std::uint16_t id;  ///< Controller identifier associated with this message.
+    std::uint8_t solid;  ///< Four-bit mask of solid player indicators.
+    std::uint8_t flashing;  ///< Four-bit mask of flashing player indicators.
+  };
+
   /**
    * @brief Control payload that configures DualSense adaptive triggers.
    */
@@ -1034,6 +1047,22 @@ namespace stream {
       std::array<std::uint8_t, sizeof(control_encrypted_t) + crypto::cipher::round_to_pkcs7_padded(sizeof(plaintext)) + crypto::cipher::tag_size>
         encrypted_payload;
 
+      payload = encode_control(session, util::view(plaintext), encrypted_payload);
+    } else if (msg.type == platf::gamepad_feedback_e::set_player_leds) {
+      control_set_player_leds_t plaintext;
+      plaintext.header.type = packetTypes[IDX_SET_PLAYER_LEDS];
+      plaintext.header.payloadLength = sizeof(plaintext) - sizeof(control_header_v2);
+
+      auto &data = msg.data.player_leds;
+
+      plaintext.id = util::endian::little(msg.id);
+      plaintext.solid = data.solid;
+      plaintext.flashing = data.flashing;
+
+      BOOST_LOG(verbose) << "Player LEDs: "sv << msg.id << " :: solid "sv << util::hex(data.solid).to_string_view() << " :: flashing "sv << util::hex(data.flashing).to_string_view();
+      std::array<std::uint8_t, sizeof(control_encrypted_t) + crypto::cipher::round_to_pkcs7_padded(sizeof(plaintext)) + crypto::cipher::tag_size>
+        encrypted_payload;
+
       payload = encode_control(session, util::view(plaintext), encrypted_payload);
     } else if (msg.type == platf::gamepad_feedback_e::set_adaptive_triggers) {
       control_adaptive_triggers_t plaintext;

tests/unit/platform/test_virtualhid_input.cpp

@@ -28,15 +28,16 @@ namespace {
   /**
    * @brief Expected touchpad support for a configured gamepad.
    */
-  struct gamepad_touchpad_case_t {
+  struct gamepad_capabilities_case_t {
     std::string_view gamepad;  ///< Configured gamepad name.
-    bool expected;  ///< Whether the configured gamepad supports touchpad input.
+    bool expected_touchpad;  ///< Whether the configured gamepad supports touchpad input.
+    bool expected_controller_extensions;  ///< Whether Moonlight controller extensions should be advertised.
   };
 
   /**
    * @brief Parameterized fixture that restores the configured gamepad after each test.
    */
-  class VirtualHidInputTest: public ::testing::TestWithParam<gamepad_touchpad_case_t> {
+  class VirtualHidInputTest: public ::testing::TestWithParam<gamepad_capabilities_case_t> {
   protected:
     /**
      * @brief Preserve the configured gamepad.
@@ -59,25 +60,34 @@ namespace {
 }  // namespace
 
 TEST_P(VirtualHidInputTest, ReportsExpectedTouchpadSupport) {
-  const auto &[gamepad, expected] = GetParam();
-  config::input.gamepad = gamepad;
-  EXPECT_EQ(platf::virtualhid::configured_gamepad_supports_touchpad(), expected) << gamepad;
+  const auto &test_case = GetParam();
+  config::input.gamepad = test_case.gamepad;
+  EXPECT_EQ(platf::virtualhid::configured_gamepad_supports_touchpad(), test_case.expected_touchpad) << test_case.gamepad;
+}
+
+TEST_P(VirtualHidInputTest, ReportsExpectedControllerExtensionSupport) {
+  const auto &test_case = GetParam();
+  config::input.gamepad = test_case.gamepad;
+  EXPECT_EQ(
+    platf::virtualhid::configured_gamepad_supports_controller_extensions(),
+    test_case.expected_controller_extensions
+  ) << test_case.gamepad;
 }
 
 INSTANTIATE_TEST_SUITE_P(
   ConfiguredGamepads,
   VirtualHidInputTest,
   ::testing::Values(
-    gamepad_touchpad_case_t {"auto"sv, true},
-    gamepad_touchpad_case_t {"generic"sv, false},
-    gamepad_touchpad_case_t {"x360"sv, false},
-    gamepad_touchpad_case_t {"xone"sv, false},
-    gamepad_touchpad_case_t {"xseries"sv, false},
-    gamepad_touchpad_case_t {"ds4"sv, true},
-    gamepad_touchpad_case_t {"ds5"sv, true},
-    gamepad_touchpad_case_t {"switch"sv, false}
+    gamepad_capabilities_case_t {"auto"sv, true, true},
+    gamepad_capabilities_case_t {"generic"sv, false, false},
+    gamepad_capabilities_case_t {"x360"sv, false, false},
+    gamepad_capabilities_case_t {"xone"sv, false, false},
+    gamepad_capabilities_case_t {"xseries"sv, false, false},
+    gamepad_capabilities_case_t {"ds4"sv, true, true},
+    gamepad_capabilities_case_t {"ds5"sv, true, true},
+    gamepad_capabilities_case_t {"switch"sv, false, true}
   ),
-  [](const ::testing::TestParamInfo<gamepad_touchpad_case_t> &info) {
+  [](const ::testing::TestParamInfo<gamepad_capabilities_case_t> &info) {
     return std::string {info.param.gamepad};
   }
 );
@@ -406,6 +416,23 @@ TEST_F(VirtualHidDeviceTest, RoutesAndDeduplicatesGamepadFeedback) {
   ASSERT_TRUE(adapter->dispatch_output(output).ok());
   EXPECT_TRUE(feedback_queue()->pop(10ms));
 
+  output.kind = lvh::GamepadOutputKind::player_leds;
+  output.player_leds = {true, false, true, false};
+  output.flashing_player_leds = {false, true, false, true};
+  ASSERT_TRUE(adapter->dispatch_output(output).ok());
+  feedback = feedback_queue()->pop(10ms);
+  ASSERT_TRUE(feedback);
+  EXPECT_EQ(feedback->type, platf::gamepad_feedback_e::set_player_leds);
+  EXPECT_EQ(feedback->data.player_leds.solid, 0x05);
+  EXPECT_EQ(feedback->data.player_leds.flashing, 0x0A);
+  ASSERT_TRUE(adapter->dispatch_output(output).ok());
+  EXPECT_FALSE(feedback_queue()->pop(0ms));
+  output.player_leds[3] = true;
+  ASSERT_TRUE(adapter->dispatch_output(output).ok());
+  feedback = feedback_queue()->pop(10ms);
+  ASSERT_TRUE(feedback);
+  EXPECT_EQ(feedback->data.player_leds.solid, 0x0D);
+
   output.kind = lvh::GamepadOutputKind::adaptive_triggers;
   output.adaptive_trigger_flags = 5;
   output.left_trigger_effect_type = 6;