Add player LED gamepad feedback handling

Introduces a new `set_player_leds` gamepad feedback message and wires it through virtualhid and control-stream encoding. Player LED output is converted to solid/flashing bitmasks, deduplicated like other feedback signals, reset on reconnect, and sent with a new Sunshine extension packet type (`0x5504`). Unit tests were expanded to verify routing and deduplication behavior for player LED updates, and the libvirtualhid submodule was bumped to a version that provides player LED output events.

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;

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));

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

@@ -406,6 +406,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;