Linux build

Author: XITRIX

README.md

@@ -172,6 +172,12 @@ make -C build/pc -j$(nproc)
 
 Also, please note that the `resources` folder must be available in the working directory, otherwise the program will fail to find the shaders.
 
+On Linux, enabling **Use hardware decoding** makes the FFmpeg decoder try
+VA-API, CUDA, and VDPAU in that order. The selected backend decodes into GPU
+surfaces and copies NV12, P010, or YUV420P frames back for the OpenGL renderer.
+If no compatible device or driver is available, Moonlight automatically falls
+back to software decoding.
+
 #### Windows (MSYS2)
 
 Windows desktop builds are supported through MSYS2 system packages for both x64 and ARM64.

app/src/settings_tab.cpp

@@ -340,7 +340,11 @@ SettingsTab::SettingsTab() {
     hwDecoding->init("settings/use_hw_decoding"_i18n, Settings::instance().use_hw_decoding(),
                      [](bool value) { Settings::instance().set_use_hw_decoding(value); });
 
+#if defined(__linux__) && defined(PLATFORM_DESKTOP)
+    hwDecoding->setEnabled(true);
+#else
     hwDecoding->setEnabled(false);
+#endif
 
 #if defined(__PSV__)
     const float mbpsMaxLimit = 20000;

app/src/streaming/InputManager.cpp

@@ -8,13 +8,18 @@
 #include "Settings.hpp"
 #include <borealis.hpp>
 #include <streaming_view.hpp>
+#include <algorithm>
 #include <chrono>
 #include <cmath>
+#include <limits>
 
 using namespace brls;
 
 namespace {
 constexpr float STICK_SCROLL_DEADZONE = 0.2f;
+constexpr float MOONLIGHT_WHEEL_DELTA = 120.0f;
+constexpr auto DESKTOP_SCROLL_GESTURE_TIMEOUT =
+    std::chrono::milliseconds(600);
 
 float applyStickScrollDeadzone(float axis, float configuredDeadzone) {
     float deadzone = std::fmax(STICK_SCROLL_DEADZONE, configuredDeadzone);
@@ -55,15 +60,7 @@ MoonlightInputManager::MoonlightInputManager() {
         ->getMouseScrollOffsetChanged()
         ->subscribe([this](brls::Point scroll) {
             if (!inputEnabled) return;
-
-            if (scroll.x != 0) {
-                brls::Logger::info("Mouse scroll X sended: {}", scroll.x);
-                LiSendHighResHScrollEvent( short(scroll.x));
-            }
-            if (scroll.y != 0) {
-                brls::Logger::info("Mouse scroll Y sended: {}", scroll.y);
-                LiSendHighResScrollEvent( short(scroll.y));
-            }
+            handleDesktopMouseScroll(scroll);
         });
 
     inputManager
@@ -98,6 +95,81 @@ MoonlightInputManager::MoonlightInputManager() {
         });
 }
 
+void MoonlightInputManager::handleDesktopMouseScroll(brls::Point scroll) {
+    const auto now = std::chrono::steady_clock::now();
+    if (lastDesktopScrollEvent.time_since_epoch().count() == 0 ||
+        now - lastDesktopScrollEvent > DESKTOP_SCROLL_GESTURE_TIMEOUT) {
+        desktopScrollAxis = DesktopScrollAxis::None;
+        pendingHorizontalScroll = 0;
+        pendingHorizontalScrollEvents = 0;
+    }
+    lastDesktopScrollEvent = now;
+
+    // Trackpads frequently emit a small perpendicular component. Some virtual
+    // mouse drivers quantize that component into a full wheel tick, so lock a
+    // gesture to one axis instead of forwarding diagonal jitter to the host.
+    if (scroll.y != 0 &&
+        (scroll.x == 0 || std::fabs(scroll.y) >= std::fabs(scroll.x))) {
+        desktopScrollAxis = DesktopScrollAxis::Vertical;
+        pendingHorizontalScroll = 0;
+        pendingHorizontalScrollEvents = 0;
+        sendDesktopMouseScroll({0, scroll.y});
+        return;
+    }
+
+    if (scroll.x == 0 || desktopScrollAxis == DesktopScrollAxis::Vertical)
+        return;
+
+    if (desktopScrollAxis == DesktopScrollAxis::None) {
+        pendingHorizontalScroll += scroll.x;
+        pendingHorizontalScrollEvents++;
+
+        // A single isolated horizontal tick is normally diagonal jitter.
+        // Buffer it until a second tick confirms an intentional gesture.
+        if (pendingHorizontalScrollEvents < 2)
+            return;
+
+        desktopScrollAxis = DesktopScrollAxis::Horizontal;
+        scroll.x = pendingHorizontalScroll;
+        pendingHorizontalScroll = 0;
+        pendingHorizontalScrollEvents = 0;
+    }
+
+    sendDesktopMouseScroll({scroll.x, 0});
+}
+
+void MoonlightInputManager::sendDesktopMouseScroll(brls::Point scroll) {
+    desktopScrollRemainder.x += scroll.x * MOONLIGHT_WHEEL_DELTA;
+    desktopScrollRemainder.y += scroll.y * MOONLIGHT_WHEEL_DELTA;
+
+    const int horizontal = std::clamp(
+        static_cast<int>(std::trunc(desktopScrollRemainder.x)),
+        static_cast<int>(std::numeric_limits<short>::min()),
+        static_cast<int>(std::numeric_limits<short>::max()));
+    const int vertical = std::clamp(
+        static_cast<int>(std::trunc(desktopScrollRemainder.y)),
+        static_cast<int>(std::numeric_limits<short>::min()),
+        static_cast<int>(std::numeric_limits<short>::max()));
+
+    if (horizontal != 0) {
+        desktopScrollRemainder.x -= horizontal;
+        const int result =
+            LiSendHighResHScrollEvent(static_cast<short>(horizontal));
+        if (result < 0)
+            brls::Logger::warning(
+                "Failed to queue horizontal mouse scroll: {}", result);
+    }
+
+    if (vertical != 0) {
+        desktopScrollRemainder.y -= vertical;
+        const int result =
+            LiSendHighResScrollEvent(static_cast<short>(vertical));
+        if (result < 0)
+            brls::Logger::warning(
+                "Failed to queue vertical mouse scroll: {}", result);
+    }
+}
+
 void MoonlightInputManager::sendRelativeMouseMove(brls::Point offset) {
     desktopMouseRemainder.x += offset.x;
     desktopMouseRemainder.y += offset.y;
@@ -181,6 +253,11 @@ void MoonlightInputManager::dropInput() {
         return;
 
     desktopMouseRemainder = {0, 0};
+    desktopScrollRemainder = {0, 0};
+    pendingHorizontalScroll = 0;
+    pendingHorizontalScrollEvents = 0;
+    desktopScrollAxis = DesktopScrollAxis::None;
+    lastDesktopScrollEvent = {};
 
     bool res = true;
     // Drop gamepad state

app/src/streaming/InputManager.hpp

@@ -10,6 +10,7 @@
 #include "Singleton.hpp"
 #include "keyboard_view.hpp"
 #include <borealis.hpp>
+#include <chrono>
 #include <optional>
 
 // Moonlight ready gamepad
@@ -61,18 +62,31 @@ class MoonlightInputManager : public Singleton<MoonlightInputManager> {
     static void rightMouseClick();
 
   private:
+    enum class DesktopScrollAxis {
+        None,
+        Horizontal,
+        Vertical,
+    };
+
     RumbleValues rumbleCache[GAMEPADS_MAX];
     GamepadState lastGamepadStates[GAMEPADS_MAX];
     brls::ControllerButton mappingButtons[brls::_BUTTON_MAX];
     std::optional<brls::PanGestureStatus> panStatus;
     std::map<uint32_t, bool> activeTouchIDs;
     brls::Point desktopMouseRemainder = {0, 0};
+    brls::Point desktopScrollRemainder = {0, 0};
+    float pendingHorizontalScroll = 0;
+    unsigned pendingHorizontalScrollEvents = 0;
+    DesktopScrollAxis desktopScrollAxis = DesktopScrollAxis::None;
+    std::chrono::steady_clock::time_point lastDesktopScrollEvent;
     bool inputDropped = false;
     bool inputEnabled = true;
 
     brls::ControllerState mapController(brls::ControllerState controller);
     static short glfwKeyToVKKey(brls::BrlsKeyboardScancode key);
     void sendRelativeMouseMove(brls::Point offset);
+    void handleDesktopMouseScroll(brls::Point scroll);
+    void sendDesktopMouseScroll(brls::Point scroll);
 
     GamepadState getControllerState(int controllerNum, bool specialKey);
     void handleControllers(bool specialKey);