Re-add the h264bitstream file headers mistakenly removed during vendoring

macOS remains on Qt 6.11.2 for v6.x to retain Ventura support

.github/workflows/build-appimage.yml

@@ -42,7 +42,7 @@ jobs:
         uses: actions/checkout@v5
         with:
           repository: libsdl-org/SDL
-          ref: release-3.4.12
+          ref: release-3.4.18
           path: deps/SDL
 
       - name: Build SDL3
@@ -56,7 +56,7 @@ jobs:
         uses: actions/checkout@v5
         with:
           repository: libsdl-org/sdl2-compat
-          ref: release-2.32.70
+          ref: release-2.32.74
           path: deps/sdl2-compat
 
       - name: Build sdl2-compat
@@ -93,7 +93,7 @@ jobs:
         working-directory: deps/libva
         run: |
           ./autogen.sh
-          ./configure --enable-x11
+          ./configure --enable-x11=yes --enable-glx=no --enable-drm=no --enable-wayland=no
           make -j$(nproc)
           sudo make install
 
@@ -101,13 +101,14 @@ jobs:
         uses: actions/checkout@v5
         with:
           repository: haasn/libplacebo
-          ref: 2d0979fb54e025e904c7372666fffbf5dae40f66
+          ref: 92b5ac6db79f4d680eb656692f7bf51e9606f42a
           path: deps/libplacebo
           submodules: 'recursive'
 
       - name: Build libplacebo
         working-directory: deps/libplacebo
         run: |
+          git apply ../../app/deploy/linux/appimage/*.patch
           meson setup build -Dvulkan=enabled -Dopengl=disabled -Ddemos=false
           ninja -C build
           sudo ninja install -C build
@@ -115,7 +116,7 @@ jobs:
       - name: Build dav1d
         working-directory: deps
         env:
-          DAV1D_VER: 1.5.3
+          DAV1D_VER: 1.5.4
         run: |
           git clone --branch $DAV1D_VER --depth 1 https://code.videolan.org/videolan/dav1d.git
           pushd dav1d
@@ -128,7 +129,7 @@ jobs:
         uses: actions/checkout@v5
         with:
           repository: FFmpeg/FFmpeg
-          ref: n8.1.1
+          ref: n9.0.2
           path: deps/FFmpeg
 
       - name: Build FFmpeg

.github/workflows/build-win-mac.yml

@@ -20,10 +20,10 @@ jobs:
         include:
           # Windows
           - os: windows-2025
-            qt_version: 6.11.1
+            qt_version: 6.12.0
           # macOS
           - os: macos-26
-            qt_version: 6.11.1
+            qt_version: 6.11.2
 
     runs-on: ${{ matrix.os }}
 
@@ -50,6 +50,7 @@ jobs:
           cache: true
           set-env: ${{ runner.os != 'Windows' }}
           add-tools-to-path: ${{ runner.os != 'Windows' }}
+          tools: ${{ runner.os == 'Windows' && 'tools_qtcreator_gui' || '' }}
           version: ${{ matrix.qt_version }}
           aqtsource: 'git+https://github.com/miurahr/aqtinstall.git@073e34d7c2ab4ae6961ed7cca690b3abd5ba5a7e'
 

.gitmodules

@@ -7,6 +7,3 @@
 [submodule "app/SDL_GameControllerDB"]
 	path = app/SDL_GameControllerDB
 	url = https://github.com/gabomdq/SDL_GameControllerDB.git
-[submodule "h264bitstream/h264bitstream"]
-	path = h264bitstream/h264bitstream
-	url = https://github.com/aizvorski/h264bitstream.git

README.md

@@ -43,8 +43,8 @@ Hosting for Moonlight's Debian and L4T package repositories is graciously provid
 ## Building
 
 ### Windows Build Requirements
-* Qt 6.7 SDK or later (earlier versions may work but are not officially supported)
-* [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) (Community edition is fine)
+* Qt 6.11 SDK or later (earlier versions may work but are not officially supported)
+* [Visual Studio 2026](https://visualstudio.microsoft.com/downloads/) (Community edition is fine)
 * Select **MSVC** option during Qt installation. MinGW is not supported.
 * [7-Zip](https://www.7-zip.org/) (only if building installers for non-development PCs)
 * Graphics Tools (only if running debug builds)
@@ -52,8 +52,8 @@ Hosting for Moonlight's Debian and L4T package repositories is graciously provid
   * Alternatively, run `dism /online /add-capability /capabilityname:Tools.Graphics.DirectX~~~~0.0.1.0` and reboot.
 
 ### macOS Build Requirements
-* Qt 6.7 SDK or later (earlier versions may work but are not officially supported)
-* Xcode 14 or later (earlier versions may work but are not officially supported)
+* Qt 6.11 SDK or later (earlier versions may work but are not officially supported)
+* Xcode 15 or later (earlier versions may work but are not officially supported)
 * [create-dmg](https://github.com/sindresorhus/create-dmg) (only if building DMGs for use on non-development Macs)
 
 ### Linux/Unix Build Requirements

app/Info.plist

@@ -21,7 +21,7 @@
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>LSMinimumSystemVersion</key>
-	<string>11.0.0</string>
+	<string>13.0.0</string>
 	<key>NSPrincipalClass</key>
 	<string>NSApplication</string>
 	<key>NSSupportsAutomaticGraphicsSwitching</key>
@@ -42,6 +42,10 @@
 	</dict>
 	<key>NSLocalNetworkUsageDescription</key>
 	<string>Moonlight uses the local network to connect to your gaming PC for streaming.</string>
+	<key>NSBonjourServices</key>
+	<array>
+		<string>_nvstream._tcp</string>
+	</array>
 	<key>CFBundleVersion</key>
 	<string>VERSION</string>
 	<key>CFBundleShortVersionString</key>

app/app.pro

@@ -157,7 +157,7 @@ win32:!winrt {
 }
 macx {
     !disable-prebuilts {
-        LIBS += -lssl.3 -lcrypto.3 -lavcodec.62 -lavutil.60 -lswscale.9 -lopus.0 -lSDL2 -lSDL2_ttf -lplacebo
+        LIBS += -lssl.3 -lcrypto.3 -lavcodec.63 -lavutil.61 -lswscale.10 -lopus.0 -lSDL2 -lSDL2_ttf -lplacebo
         CONFIG += discord-rpc libplacebo
     }
 
@@ -509,8 +509,8 @@ win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../h264bitstream/relea
 else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../h264bitstream/debug/ -lh264bitstream
 else:unix: LIBS += -L$$OUT_PWD/../h264bitstream/ -lh264bitstream
 
-INCLUDEPATH += $$PWD/../h264bitstream/h264bitstream
-DEPENDPATH += $$PWD/../h264bitstream/h264bitstream
+INCLUDEPATH += $$PWD/../h264bitstream
+DEPENDPATH += $$PWD/../h264bitstream
 
 !winrt {
     win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../AntiHooking/release/ -lAntiHooking

app/backend/systemproperties.cpp

@@ -51,6 +51,13 @@ SystemProperties::SystemProperties()
     isRunningWayland = WMUtils::isRunningWayland();
     isRunningXWayland = isRunningWayland && QGuiApplication::platformName() == "xcb";
     usesMaterial3Theme = QLibraryInfo::version() >= QVersionNumber(6, 5, 0);
+
+#ifdef Q_OS_DARWIN
+    isDarwin = true;
+#else
+    isDarwin = false;
+#endif
+
     QString nativeArch = QSysInfo::currentCpuArchitecture();
 
 #ifdef Q_OS_WIN32
@@ -141,21 +148,18 @@ void SystemProperties::updateDecoderProperties(bool hasHardwareAcceleration, boo
 QRect SystemProperties::getNativeResolution(int displayIndex)
 {
     // Returns default constructed QRect if out of bounds
-    Q_ASSERT(!monitorNativeResolutions.isEmpty());
     return monitorNativeResolutions.value(displayIndex);
 }
 
 QRect SystemProperties::getSafeAreaResolution(int displayIndex)
 {
     // Returns default constructed QRect if out of bounds
-    Q_ASSERT(!monitorSafeAreaResolutions.isEmpty());
     return monitorSafeAreaResolutions.value(displayIndex);
 }
 
 int SystemProperties::getRefreshRate(int displayIndex)
 {
     // Returns 0 if out of bounds
-    Q_ASSERT(!monitorRefreshRates.isEmpty());
     return monitorRefreshRates.value(displayIndex);
 }
 
@@ -221,6 +225,8 @@ void SystemProperties::refreshDisplays()
     }
 
     monitorNativeResolutions.clear();
+    monitorSafeAreaResolutions.clear();
+    monitorRefreshRates.clear();
 
     SDL_DisplayMode bestMode;
     for (int displayIndex = 0; displayIndex < SDL_GetNumVideoDisplays(); displayIndex++) {
@@ -229,8 +235,11 @@ void SystemProperties::refreshDisplays()
 
         if (StreamUtils::getNativeDesktopMode(displayIndex, &desktopMode, &safeArea)) {
             if (desktopMode.w <= 8192 && desktopMode.h <= 8192) {
-                monitorNativeResolutions.insert(displayIndex, QRect(0, 0, desktopMode.w, desktopMode.h));
-                monitorSafeAreaResolutions.insert(displayIndex, QRect(0, 0, safeArea.w, safeArea.h));
+                // Keep these lists compact because their QML consumers iterate until
+                // the first empty entry. Inserting by SDL display index is invalid if
+                // an earlier display was skipped (for example, a >8K virtual display).
+                monitorNativeResolutions.append(QRect(0, 0, desktopMode.w, desktopMode.h));
+                monitorSafeAreaResolutions.append(QRect(0, 0, safeArea.w, safeArea.h));
             }
             else {
                 SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,

app/backend/systemproperties.h

@@ -19,6 +19,7 @@ public:
     Q_PROPERTY(bool isRunningWayland MEMBER isRunningWayland CONSTANT)
     Q_PROPERTY(bool isRunningXWayland MEMBER isRunningXWayland CONSTANT)
     Q_PROPERTY(bool isWow64 MEMBER isWow64 CONSTANT)
+    Q_PROPERTY(bool isDarwin MEMBER isDarwin CONSTANT)
     Q_PROPERTY(QString friendlyNativeArchName MEMBER friendlyNativeArchName CONSTANT)
     Q_PROPERTY(bool hasDesktopEnvironment MEMBER hasDesktopEnvironment CONSTANT)
     Q_PROPERTY(bool hasBrowser MEMBER hasBrowser CONSTANT)
@@ -66,6 +67,7 @@ private:
     bool hasDiscordIntegration;
     QString versionString;
     bool usesMaterial3Theme;
+    bool isDarwin;
 
     // Properties only set if startAsyncLoad() is called
     bool hasHardwareAcceleration;

app/deploy/linux/appimage/libplacebo-disable-internally-synchronized-queues.patch

@@ -0,0 +1,13 @@
+diff --git a/src/vulkan/context.c b/src/vulkan/context.c
+index bc9084ad..52290154 100644
+--- a/src/vulkan/context.c
++++ b/src/vulkan/context.c
+@@ -265,7 +265,7 @@ static_assert(PL_ARRAY_SIZE(pl_vulkan_recommended_extensions) + 1 ==
+ #ifdef VK_KHR_internally_synchronized_queues
+ static const VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR synchronized_queues = {
+     .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR,
+-    .internallySynchronizedQueues = true,
++    .internallySynchronizedQueues = false,
+ };
+ #endif
+ 

app/deploy/linux/com.moonlight_stream.Moonlight.appdata.xml

@@ -51,6 +51,68 @@
 	</screenshots>
 
 	<releases>
+		<release version="6.2.0" date="2026-10-03">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Ctrl+Alt+Shift+K has been added to toggle system keyboard grab</li>
+					<li>Added support for DualSense adaptive triggers (requires a compatible host)</li>
+					<li>Gamepads with a second trackpad can now be passed to the host (requires host support)</li>
+					<li>Client identifiers are now provided to the host to allow client-specific session management</li>
+					<li>Added an option to disable pre-launch warnings</li>
+				</ul>
+				<p>Behavior Changes:</p>
+				<ul>
+					<li>Most video renderers now use full range color instead of limited range</li>
+					<li>The cursor is now also locked to the video area in single display borderless windowed scenarios. This was previously only done in true full-screen mode.</li>
+					<li>The cursor is no longer captured by default in windowed mode. Clicking on the streaming window or pressing Ctrl+Alt+Shift+Z will capture the cursor.</li>
+					<li>GPUs on non-x86 Linux platforms are now assumed to be slow by default, which enables a number of optimizations for improved performance. GL_IS_SLOW=0/VULKAN_IS_SLOW=0 can be set at runtime to override this.</li>
+					<li>The default streaming resolution for new installs is now 1080p instead of 720p.</li>
+					<li>Video bitrate no longer resets when adjusting resolution or frame rate if it's already been manually adjusted</li>
+				</ul>
+				<p>Security:</p>
+				<ul>
+					<li>CVE-2026-33546, CVE-2026-33547, and CVE-2026-41210 have been fixed</li>
+					<li>These vulnerabilities could allow a malicious host to crash Moonlight when connecting</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Reduced background CPU usage</li>
+					<li>Improved startup, settings page, and stream load times</li>
+					<li>Optimized the EGL/GLES renderer to improve performance on low end GPUs and embedded devices</li>
+					<li>Fixed EGL/GLES renderer failures under X11 when GLX was used for the UI</li>
+					<li>Improved readability of the statistics overlay by adding an outline</li>
+					<li>Improved timing accuracy in the statistics overlay</li>
+					<li>Improved performance when multiple gamepads are sending input simultaneously</li>
+					<li>Improved performance when recovering from dropped network packets</li>
+					<li>Fixed black or green padding being rendered on the bottom or right side of the video stream when streaming from certain hosts</li>
+					<li>Fixed horizontal scroll direction not being correctly inverted when requested</li>
+					<li>Fixed Moonlight not exiting after an abnormal stream termination when launched via the CLI</li>
+					<li>Fixed failure to start on Linux systems where desktop OpenGL is not available</li>
+					<li>Fixed broken overlay rendering on PowerVR systems using the proprietary driver</li>
+					<li>Fixed automatic selection of AV1 on systems where HEVC is not available</li>
+					<li>Fixed instability when using VAAPI decoding under X11</li>
+					<li>Fixed small deviations in chroma co-siting and color conversion</li>
+					<li>Fixed suboptimal format selection on some V4L2 decoders</li>
+					<li>Fixed handling of some non-US keyboard layouts</li>
+					<li>Fixed stale app list being displayed when using CLI commands</li>
+					<li>Fixed handling of IPv6 literals that are not URL-escaped</li>
+					<li>Fixed AV1 Vulkan Video decoding on newer versions of FFmpeg</li>
+					<li>Fixed Ctrl+C/SIGTERM when running from the console</li>
+					<li>Fixed several GUI interoperability issues with Qt 6.9 and later</li>
+					<li>Fixed the IME or software keyboard being unexpectedly displayed in various situations</li>
+					<li>Fixed launching in a new VT while a Wayland compositor is running</li>
+					<li>Fixed moving focus from the app grid into the toolbar via the gamepad or keyboard</li>
+					<li>Fixed a possible crash in the Vulkan renderer when disabling an overlay</li>
+					<li>Fixed keyboard grab not working under sdl2-compat on Wayland compositors that lack support for keyboard-shortcuts-inhibit-unstable-v1</li>
+					<li>Fixed CLI stream launch causing the saved manual address to be overwritten</li>
+					<li>Fixed distinguishing between Enter and Numpad Enter keys (requires updated host software)</li>
+					<li>Fixed mDNS discovering unexpected devices after running for a period of time</li>
+					<li>Fixed libdecor-gtk window decorations not being displayed on the streaming window</li>
+					<li>Updated community-contributed translations from Weblate</li>
+				</ul>
+			</description>
+		</release>
 		<release version="6.1.0" date="2024-09-16">
 			<description>
 				<p>New features:</p>

app/deploy/linux/libva-probe.c

@@ -0,0 +1,36 @@
+/*
+ * libva-probe: loadability oracle for the AppImage AppRun.
+ *
+ * Moonlight and the bundled FFmpeg import libva through symbols carrying
+ * VA_API_* ELF version nodes. Whether the libva installed on the host can
+ * satisfy those requirements cannot be inferred portably from file names or
+ * loader caches, so this program embeds the same DT_NEEDED entries and
+ * versioned symbol references as those binaries without ever calling into
+ * them: either the dynamic loader resolves everything and main() runs (the
+ * host libva is usable), or the exec itself fails and AppRun must fall back
+ * to the build-environment libva staged next to this binary.
+ *
+ * scripts/build-appimage.sh verifies at build time that this file references
+ * every VA_API_* node required by the binaries shipped in the AppImage, so
+ * it stays automatically in sync with the libva usage there.
+ */
+
+#include <stddef.h>
+
+#include <va/va.h>
+#include <va/va_x11.h>
+
+/* Address references are enough: they produce relocations against the
+ * versioned symbols, which is what makes the loader check the host's
+ * VA_API_* version nodes. The functions must never actually be called.
+ * volatile keeps the table (and its relocations) alive through -O2. */
+static void *volatile requirements[] = {
+    (void *)vaCreateSurfaces, /* libva.so.2, VA_API_0.33.0 */
+    (void *)vaMapBuffer2,     /* libva.so.2, 2.21+ */
+    (void *)vaGetDisplay,     /* libva-x11.so.2 */
+};
+
+int main(void)
+{
+    return requirements[0] == NULL;
+}

app/deploy/steamlink/moonlight.sh

@@ -9,6 +9,11 @@ HOME=/usr/local/moonlight
 # https://github.com/moonlight-stream/moonlight-qt/issues/697
 export SDL_ENABLE_STEAM_CONTROLLERS=1
 
+# Disable gamepad sensors by default to avoid excessive CPU
+# usage that can cause audio glitches. Remove the following
+# line to enable gamepad sensors.
+export SENSOR_REPORT_RATE_LIMIT_HZ=0
+
 # Renice PE_Single_CPU which seems to host A/V stuff
 renice -10 -p $(pidof PE_Single_CPU)
 

app/gui/SettingsView.qml

@@ -1656,6 +1656,62 @@ Flickable {
                     }
                 }
 
+                Label {
+                    width: parent.width
+                    id: rendererTitle
+                    text: qsTr("Renderer")
+                    font.pointSize: 12
+                    wrapMode: Text.Wrap
+                    visible: SystemProperties.isDarwin
+                }
+
+                AutoResizingComboBox {
+                    // ignore setting the index at first, and actually set it when the component is loaded
+                    Component.onCompleted: {
+                        var saved_rs = StreamingPreferences.rendererSelection
+
+                        // Default to Automatic
+                        currentIndex = 0
+
+                        for(var i = 0; i < rendererListModel.count; i++) {
+                            var el_rs = rendererListModel.get(i).val;
+                            if (saved_rs === el_rs) {
+                                currentIndex = i
+                                break
+                            }
+                        }
+
+                        activated(currentIndex)
+                    }
+
+                    id: rendererComboBox
+                    visible: SystemProperties.isDarwin
+                    textRole: "text"
+                    model: ListModel {
+                        id: rendererListModel
+                        ListElement {
+                            text: qsTr("Automatic (Recommended)")
+                            val: StreamingPreferences.RS_AUTO
+                        }
+                        ListElement {
+                            text: "Vulkan"
+                            val: StreamingPreferences.RS_VULKAN
+                        }
+                        ListElement {
+                            text: "Metal"
+                            val: StreamingPreferences.RS_METAL
+                        }
+                        ListElement {
+                            text: "AVSampleBufferDisplayLayer"
+                            val: StreamingPreferences.RS_AVSBDL
+                        }
+                    }
+                    // ::onActivated must be used, as it only listens for when the index is changed by a human
+                    onActivated : {
+                        StreamingPreferences.rendererSelection = rendererListModel.get(currentIndex).val
+                    }
+                }
+
                 CheckBox {
                     id: enableYUV444
                     width: parent.width

app/gui/StreamSegue.qml

@@ -126,22 +126,9 @@ Item {
         SystemProperties.waitForAsyncLoad()
 
         // Kick off the stream
-        spinnerTimer.start()
         streamLoader.active = true
     }
 
-    Timer {
-        id: spinnerTimer
-
-        // Display the spinner appearance a bit to allow us to reach
-        // the code in Session.exec() that pumps the event loop.
-        // If we display it immediately, it will briefly hang in the
-        // middle of the animation on Windows, which looks very
-        // obviously broken.
-        interval: 100
-        onTriggered: stageSpinner.visible = true
-    }
-
     Timer {
         id: startSessionTimer
         onTriggered: {
@@ -178,6 +165,11 @@ Item {
                 return;
             }
 
+            // This spinner is shown only after session.initialize() has completed
+            // to prevent active animations from running during decoder probing,
+            // which causes re-entrant event loop livelocks with libdecor-gtk.
+            stageSpinner.visible = true
+
             // Don't wait unless we have toasts to display
             startSessionTimer.interval = 0
 

app/main.cpp

@@ -718,10 +718,6 @@ int main(int argc, char *argv[])
     SDL_SetHint(SDL_HINT_AUDIO_DEVICE_APP_NAME, "Moonlight");
     SDL_SetHint(SDL_HINT_APP_NAME, "Moonlight");
 
-    // We handle capturing the mouse ourselves when it leaves the window, so we don't need
-    // SDL doing it for us behind our backs.
-    SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0");
-
     // SDL will try to lock the mouse cursor on Wayland if it's not visible in order to
     // support applications that assume they can warp the cursor (which isn't possible
     // on Wayland). We don't want this behavior because it interferes with seamless mouse
@@ -753,7 +749,7 @@ int main(int argc, char *argv[])
     // NB: We do not force SDL_VIDEO_WAYLAND_MODE_SCALING to "stretch" on KDE,
     // because SDL 3.6 has a workaround for KDE and switches the default to
     // "aspect" for all desktops.
-    if (qgetenv("XDG_CURRENT_DESKTOP") != "KDE") {
+    if (!qgetenv("XDG_CURRENT_DESKTOP").contains("KDE")) {
         SDL_SetHint("SDL_VIDEO_WAYLAND_MODE_SCALING", "aspect");
     }
 

app/settings/streamingpreferences.cpp

@@ -51,6 +51,7 @@
 #define SER_CAPTURESYSKEYS "capturesyskeys"
 #define SER_KEEPAWAKE "keepawake"
 #define SER_LANGUAGE "language"
+#define SER_RENDERER "renderer"
 
 #define CURRENT_DEFAULT_VER 2
 
@@ -121,8 +122,8 @@ void StreamingPreferences::reload()
     }
 #endif
 
-    width = settings.value(SER_WIDTH, 1280).toInt();
-    height = settings.value(SER_HEIGHT, 720).toInt();
+    width = settings.value(SER_WIDTH, 1920).toInt();
+    height = settings.value(SER_HEIGHT, 1080).toInt();
     fps = settings.value(SER_FPS, 60).toInt();
     enableYUV444 = settings.value(SER_YUV444, false).toBool();
     bitrateKbps = settings.value(SER_BITRATE, getDefaultBitrate(width, height, fps, enableYUV444)).toInt();
@@ -159,6 +160,8 @@ void StreamingPreferences::reload()
                                                   static_cast<int>(VideoCodecConfig::VCC_AUTO)).toInt());
     videoDecoderSelection = static_cast<VideoDecoderSelection>(settings.value(SER_VIDEODEC,
                                                   static_cast<int>(VideoDecoderSelection::VDS_AUTO)).toInt());
+    rendererSelection = static_cast<RendererSelection>(settings.value(SER_RENDERER,
+                                                  static_cast<int>(RendererSelection::RS_AUTO)).toInt());
     windowMode = static_cast<WindowMode>(settings.value(SER_WINDOWMODE,
                                                         // Try to load from the old preference value too
                                                         static_cast<int>(settings.value(SER_FULLSCREEN, true).toBool() ?
@@ -347,6 +350,7 @@ void StreamingPreferences::save()
     settings.setValue(SER_YUV444, enableYUV444);
     settings.setValue(SER_VIDEOCFG, static_cast<int>(videoCodecConfig));
     settings.setValue(SER_VIDEODEC, static_cast<int>(videoDecoderSelection));
+    settings.setValue(SER_RENDERER, static_cast<int>(rendererSelection));
     settings.setValue(SER_WINDOWMODE, static_cast<int>(windowMode));
     settings.setValue(SER_UIDISPLAYMODE, static_cast<int>(uiDisplayMode));
     settings.setValue(SER_LANGUAGE, static_cast<int>(language));

app/settings/streamingpreferences.h

@@ -44,6 +44,17 @@ public:
     };
     Q_ENUM(VideoDecoderSelection)
 
+    // Mac only (for now)
+    enum RendererSelection
+    {
+        RS_PROBE_ONLY = -1, // Only valid for probing decoder properties
+        RS_AUTO,
+        RS_VULKAN,
+        RS_METAL,
+        RS_AVSBDL
+    };
+    Q_ENUM(RendererSelection)
+
     enum WindowMode
     {
         WM_FULLSCREEN,
@@ -134,6 +145,7 @@ public:
     Q_PROPERTY(bool enableHdr MEMBER enableHdr NOTIFY enableHdrChanged)
     Q_PROPERTY(bool enableYUV444 MEMBER enableYUV444 NOTIFY enableYUV444Changed)
     Q_PROPERTY(VideoDecoderSelection videoDecoderSelection MEMBER videoDecoderSelection NOTIFY videoDecoderSelectionChanged)
+    Q_PROPERTY(RendererSelection rendererSelection MEMBER rendererSelection NOTIFY rendererSelectionChanged)
     Q_PROPERTY(WindowMode windowMode MEMBER windowMode NOTIFY windowModeChanged)
     Q_PROPERTY(WindowMode recommendedFullScreenMode MEMBER recommendedFullScreenMode CONSTANT)
     Q_PROPERTY(UIDisplayMode uiDisplayMode MEMBER uiDisplayMode NOTIFY uiDisplayModeChanged)
@@ -187,6 +199,7 @@ public:
     UIDisplayMode uiDisplayMode;
     Language language;
     CaptureSysKeysMode captureSysKeysMode;
+    RendererSelection rendererSelection;
 
 signals:
     void displayModeChanged();
@@ -224,6 +237,7 @@ signals:
     void captureSysKeysModeChanged();
     void keepAwakeChanged();
     void languageChanged();
+    void rendererSelectionChanged();
 
 private:
     explicit StreamingPreferences(QQmlEngine *qmlEngine);

app/streaming/input/gamepad.cpp

@@ -3,6 +3,7 @@
 #include <Limelight.h>
 #include "SDL_compat.h"
 #include "settings/mappingmanager.h"
+#include "utils.h"
 
 #include <QtMath>
 
@@ -188,6 +189,26 @@ Uint32 SdlInputHandler::mouseEmulationTimerCallback(Uint32 interval, void *param
     return interval;
 }
 
+static void updateAnalogStickAxis(short& value, short newValue, bool& dirty)
+{
+#ifdef STEAM_LINK
+    // Use a deadzone on Steam Link to reduce CPU usage from idle joysticks
+    newValue = abs(newValue) < 1500 ? 0 : newValue;
+#endif
+    dirty |= (newValue != value);
+    value = newValue;
+}
+
+static void updateTriggerAxis(unsigned char& value, unsigned char newValue, bool& dirty)
+{
+#ifdef STEAM_LINK
+    // Use a deadzone on Steam Link to reduce CPU usage from idle joysticks
+    newValue = newValue < 10 ? 0 : newValue;
+#endif
+    dirty |= (newValue != value);
+    value = newValue;
+}
+
 void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
 {
     SDL_JoystickID gameControllerId = event->which;
@@ -198,11 +219,12 @@ void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
 
     // Batch all pending axis motion events for this gamepad to save CPU time
     SDL_Event nextEvent;
+    bool dirty = false;
     for (;;) {
         switch (event->axis)
         {
             case SDL_CONTROLLER_AXIS_LEFTX:
-                state->lsX = event->value;
+                updateAnalogStickAxis(state->lsX, event->value, dirty);
                 break;
             case SDL_CONTROLLER_AXIS_LEFTY:
                 // Signed values have one more negative value than
@@ -210,19 +232,19 @@ void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
                 // could actually cause the value to overflow and
                 // wrap around to be negative again. Avoid that by
                 // capping the value at 32767.
-                state->lsY = -qMax(event->value, (short)-32767);
+                updateAnalogStickAxis(state->lsY, -qMax(event->value, (short)-32767), dirty);
                 break;
             case SDL_CONTROLLER_AXIS_RIGHTX:
-                state->rsX = event->value;
+                updateAnalogStickAxis(state->rsX, event->value, dirty);
                 break;
             case SDL_CONTROLLER_AXIS_RIGHTY:
-                state->rsY = -qMax(event->value, (short)-32767);
+                updateAnalogStickAxis(state->rsY, -qMax(event->value, (short)-32767), dirty);
                 break;
             case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
-                state->lt = (unsigned char)(event->value * 255UL / 32767);
+                updateTriggerAxis(state->lt, (unsigned char)(event->value * 255UL / 32767), dirty);
                 break;
             case SDL_CONTROLLER_AXIS_TRIGGERRIGHT:
-                state->rt = (unsigned char)(event->value * 255UL / 32767);
+                updateTriggerAxis(state->rt, (unsigned char)(event->value * 255UL / 32767), dirty);
                 break;
             default:
                 SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
@@ -247,7 +269,7 @@ void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
     }
 
     // Only send the gamepad state to the host if it's not in mouse emulation mode
-    if (state->mouseEmulationTimer == 0) {
+    if (state->mouseEmulationTimer == 0 && dirty) {
         sendGamepadState(state);
     }
 }
@@ -701,7 +723,32 @@ void SdlInputHandler::handleControllerDeviceEvent(SDL_ControllerDeviceEvent* eve
             type = LI_CTYPE_NINTENDO;
             break;
         default:
-            type = LI_CTYPE_UNKNOWN;
+            // These Steam Controller VID/PID combos come from SDL's controller_list.h
+            // TODO: Use SDL_GAMEPAD_TYPE_STEAM on SDL 3.6+
+            if (vendorId == 0x28de) {
+                switch (productId) {
+                case 0x1101:
+                case 0x1102:
+                case 0x1105:
+                case 0x1106:
+                case 0x1142:
+                case 0x1201:
+                case 0x1202:
+                case 0x1205:
+                case 0x1302:
+                case 0x1303:
+                case 0x1304:
+                case 0x1305:
+                    type = LI_CTYPE_STEAM;
+                    break;
+                default:
+                    type = LI_CTYPE_UNKNOWN;
+                    break;
+                }
+            }
+            else {
+                type = LI_CTYPE_UNKNOWN;
+            }
             break;
         }
 
@@ -872,6 +919,15 @@ void SdlInputHandler::setMotionEventState(uint16_t controllerNumber, uint8_t mot
         return;
     }
 
+    uint16_t reportRateHzLimit;
+    if (Utils::getEnvironmentVariableOverride("SENSOR_REPORT_RATE_LIMIT_HZ", &reportRateHzLimit) &&
+        reportRateHz > reportRateHzLimit) {
+        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                    "Sensor report rate limited to %u Hz by environment variable",
+                    reportRateHzLimit);
+        reportRateHz = reportRateHzLimit;
+    }
+
 #if SDL_VERSION_ATLEAST(2, 0, 14)
     if (m_GamepadState[controllerNumber].controller != nullptr) {
         uint8_t reportPeriodMs = reportRateHz ? (1000 / reportRateHz) : 0;

app/streaming/input/input.cpp

@@ -40,6 +40,19 @@ SdlInputHandler::SdlInputHandler(StreamingPreferences& prefs, int streamWidth, i
         m_CaptureSystemKeysMode = StreamingPreferences::CSK_ALWAYS;
     }
 
+    // SDL3 breaks our auto-capture-on-leave logic because the mouse focus has already
+    // been lost by the time we attempt to call SDL_CaptureMouse(). Fortunately, SDL3's
+    // own auto-capture logic seems to be stable now (unlike SDL2), so we can rely on
+    // that instead of our own hack when running on sdl2-compat.
+    // https://github.com/libsdl-org/SDL/commit/e54001b02809dcebbb822bd0297919c8c76976a1
+    SDL_version ver;
+    SDL_GetVersion(&ver);
+    m_NeedsManualCaptureOnLeave = !(ver.major == 2 && ver.minor >= 30 && ver.patch >= 50) && !SDL_GetHint("SDL3_VERSION");
+    if (m_NeedsManualCaptureOnLeave) {
+        // Disable the buggy auto-capture on earlier SDL2 builds
+        SDL_SetHint(SDL_HINT_MOUSE_AUTO_CAPTURE, "0");
+    }
+
     // Allow gamepad input when the app doesn't have focus if requested
     SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, prefs.backgroundGamepad ? "1" : "0");
 
@@ -257,43 +270,6 @@ void SdlInputHandler::setWindow(SDL_Window *window)
     m_Window = window;
 }
 
-void SdlInputHandler::raiseAllKeys()
-{
-    if (m_KeysDown.isEmpty()) {
-        return;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Raising %d keys",
-                (int)m_KeysDown.count());
-
-    for (auto keyDown : std::as_const(m_KeysDown)) {
-        LiSendKeyboardEvent(keyDown, KEY_ACTION_UP, 0);
-    }
-
-    m_KeysDown.clear();
-}
-
-void SdlInputHandler::notifyMouseLeave()
-{
-    // SDL on Windows doesn't send the mouse button up until the mouse re-enters the window
-    // after leaving it. This breaks some of the Aero snap gestures, so we'll capture it to
-    // allow us to receive the mouse button up events later.
-    //
-    // On macOS and X11, capturing the mouse allows us to receive mouse motion outside the
-    // window (button up already worked without capture).
-    if (m_AbsoluteMouseMode && isCaptureActive()) {
-        // NB: Not using SDL_GetGlobalMouseState() because we want our state not the system's
-        Uint32 mouseState = SDL_GetMouseState(nullptr, nullptr);
-        for (Uint32 button = SDL_BUTTON_LEFT; button <= SDL_BUTTON_X2; button++) {
-            if (mouseState & SDL_BUTTON(button)) {
-                SDL_CaptureMouse(SDL_TRUE);
-                break;
-            }
-        }
-    }
-}
-
 void SdlInputHandler::notifyFocusLost()
 {
     // Release mouse cursor when another window is activated (e.g. by using ALT+TAB).

app/streaming/input/input.h

@@ -210,6 +210,7 @@ private:
     bool m_ReverseScrollDirection;
     bool m_SwapFaceButtons;
 
+    bool m_NeedsManualCaptureOnLeave;
     bool m_MouseWasInVideoRegion;
     bool m_PendingMouseButtonsAllUpOnVideoRegionLeave;
     bool m_PointerRegionLockActive;
@@ -217,7 +218,7 @@ private:
 
     int m_GamepadMask;
     GamepadState m_GamepadState[MAX_GAMEPADS];
-    QSet<short> m_KeysDown;
+    QSet<uint32_t> m_KeysDown;
     bool m_FakeMouseCaptureActive;
     bool m_KeyboardCaptureActive;
     QString m_OldIgnoreDevices;

app/streaming/input/keyboard.cpp

@@ -13,6 +13,15 @@
 #define VK_NUMPAD0 0x60
 #endif
 
+#define MAKE_KEYPRESS_STATE(code, modifiers, flags) \
+    ((uint32_t)(uint16_t)(code) | \
+    ((uint32_t)(uint8_t)((modifiers) & MODIFIER_EXTENDED) << 16) | \
+    ((uint32_t)(uint8_t)(flags) << 24))
+
+#define GET_KEYPRESS_CODE(x) ((short)((x) & 0xFFFF))
+#define GET_KEYPRESS_EXTENDED_MODIFIER(x) ((char)(((x) >> 16) & 0xFF))
+#define GET_KEYPRESS_FLAGS(x) ((char)(((x) >> 24) & 0xFF))
+
 void SdlInputHandler::performSpecialKeyCombo(KeyCombo combo)
 {
     switch (combo) {
@@ -177,6 +186,7 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
 {
     short keyCode;
     char modifiers;
+    char flags;
     bool shouldNotConvertToScanCodeOnServer = false;
 
     if (event->repeat) {
@@ -264,7 +274,9 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
             case SDL_SCANCODE_CLEAR:
                 keyCode = 0x0C;
                 break;
-            case SDL_SCANCODE_KP_ENTER: // FIXME: Is this correct?
+            case SDL_SCANCODE_KP_ENTER:
+                modifiers |= MODIFIER_EXTENDED;
+                Q_FALLTHROUGH();
             case SDL_SCANCODE_RETURN:
                 keyCode = 0x0D;
                 break;
@@ -282,27 +294,35 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
                 break;
             case SDL_SCANCODE_PAGEUP:
                 keyCode = 0x21;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_PAGEDOWN:
                 keyCode = 0x22;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_END:
                 keyCode = 0x23;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_HOME:
                 keyCode = 0x24;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_LEFT:
                 keyCode = 0x25;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_UP:
                 keyCode = 0x26;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_RIGHT:
                 keyCode = 0x27;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_DOWN:
                 keyCode = 0x28;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_SELECT:
                 keyCode = 0x29;
@@ -312,12 +332,15 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
                 break;
             case SDL_SCANCODE_PRINTSCREEN:
                 keyCode = 0x2C;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_INSERT:
                 keyCode = 0x2D;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_DELETE:
                 keyCode = 0x2E;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_HELP:
                 keyCode = 0x2F;
@@ -347,6 +370,7 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
                 break;
             case SDL_SCANCODE_KP_DIVIDE:
                 keyCode = 0x6F;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_NUMLOCKCLEAR:
                 keyCode = 0x90;
@@ -365,48 +389,60 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
                 break;
             case SDL_SCANCODE_RCTRL:
                 keyCode = 0xA3;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_LALT:
                 keyCode = 0xA4;
                 break;
             case SDL_SCANCODE_RALT:
                 keyCode = 0xA5;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_LGUI:
                 if (!isSystemKeyCaptureActive()) {
                     return;
                 }
                 keyCode = 0x5B;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_RGUI:
                 if (!isSystemKeyCaptureActive()) {
                     return;
                 }
                 keyCode = 0x5C;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_APPLICATION:
                 keyCode = 0x5D;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_BACK:
                 keyCode = 0xA6;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_FORWARD:
                 keyCode = 0xA7;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_REFRESH:
                 keyCode = 0xA8;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_STOP:
                 keyCode = 0xA9;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_SEARCH:
                 keyCode = 0xAA;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_BOOKMARKS:
                 keyCode = 0xAB;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_AC_HOME:
                 keyCode = 0xAC;
+                modifiers |= MODIFIER_EXTENDED;
                 break;
             case SDL_SCANCODE_SEMICOLON:
                 keyCode = 0xBA;
@@ -464,17 +500,40 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
         }
     }
 
+    keyCode |= 0x8000;
+    flags = shouldNotConvertToScanCodeOnServer ? SS_KBE_FLAG_NON_NORMALIZED : 0;
+
     // Track the key state so we always know which keys are down
     if (event->state == SDL_PRESSED) {
-        m_KeysDown.insert(keyCode);
+        m_KeysDown.insert(MAKE_KEYPRESS_STATE(keyCode, modifiers, flags));
     }
     else {
-        m_KeysDown.remove(keyCode);
+        m_KeysDown.remove(MAKE_KEYPRESS_STATE(keyCode, modifiers, flags));
     }
 
-    LiSendKeyboardEvent2(0x8000 | keyCode,
-                        event->state == SDL_PRESSED ?
-                            KEY_ACTION_DOWN : KEY_ACTION_UP,
-                        modifiers,
-                        shouldNotConvertToScanCodeOnServer ? SS_KBE_FLAG_NON_NORMALIZED : 0);
+    LiSendKeyboardEvent2(keyCode,
+                         event->state == SDL_PRESSED ?
+                             KEY_ACTION_DOWN : KEY_ACTION_UP,
+                         modifiers,
+                         flags);
+}
+
+void SdlInputHandler::raiseAllKeys()
+{
+    if (m_KeysDown.isEmpty()) {
+        return;
+    }
+
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "Raising %d keys",
+                (int)m_KeysDown.count());
+
+    for (auto keyDown : std::as_const(m_KeysDown)) {
+        LiSendKeyboardEvent2(GET_KEYPRESS_CODE(keyDown),
+                             KEY_ACTION_UP,
+                             GET_KEYPRESS_EXTENDED_MODIFIER(keyDown),
+                             GET_KEYPRESS_FLAGS(keyDown));
+    }
+
+    m_KeysDown.clear();
 }

app/streaming/input/mouse.cpp

@@ -4,6 +4,28 @@
 #include "SDL_compat.h"
 #include "streaming/streamutils.h"
 
+void SdlInputHandler::notifyMouseLeave()
+{
+    if (m_NeedsManualCaptureOnLeave) {
+        // SDL on Windows doesn't send the mouse button up until the mouse re-enters the window
+        // after leaving it. This breaks some of the Aero snap gestures, so we'll capture it to
+        // allow us to receive the mouse button up events later.
+        //
+        // On macOS and X11, capturing the mouse allows us to receive mouse motion outside the
+        // window (button up already worked without capture).
+        if (m_AbsoluteMouseMode && isCaptureActive()) {
+            // NB: Not using SDL_GetGlobalMouseState() because we want our state not the system's
+            Uint32 mouseState = SDL_GetMouseState(nullptr, nullptr);
+            for (Uint32 button = SDL_BUTTON_LEFT; button <= SDL_BUTTON_X2; button++) {
+                if (mouseState & SDL_BUTTON(button)) {
+                    SDL_CaptureMouse(SDL_TRUE);
+                    break;
+                }
+            }
+        }
+    }
+}
+
 void SdlInputHandler::handleMouseButtonEvent(SDL_MouseButtonEvent* event)
 {
     int button;
@@ -128,8 +150,10 @@ void SdlInputHandler::handleMouseMotionEvent(SDL_MouseMotionEvent* event)
         Uint32 buttonState = SDL_GetMouseState(nullptr, nullptr);
         if (buttonState == 0) {
             if (m_PendingMouseButtonsAllUpOnVideoRegionLeave) {
-                // Stop capturing the mouse now
-                SDL_CaptureMouse(SDL_FALSE);
+                if (m_NeedsManualCaptureOnLeave) {
+                    // Stop capturing the mouse now
+                    SDL_CaptureMouse(SDL_FALSE);
+                }
                 m_PendingMouseButtonsAllUpOnVideoRegionLeave = false;
             }
         }

app/streaming/session.cpp

@@ -276,6 +276,7 @@ void Session::clSetAdaptiveTriggers(uint16_t controllerNumber, uint8_t eventFlag
 
 
 bool Session::chooseDecoder(StreamingPreferences::VideoDecoderSelection vds,
+                            StreamingPreferences::RendererSelection renderer,
                             SDL_Window* window, int videoFormat, int width, int height,
                             int frameRate, bool enableVsync, bool enableFramePacing, bool testOnly, IVideoDecoder*& chosenDecoder)
 {
@@ -295,6 +296,7 @@ bool Session::chooseDecoder(StreamingPreferences::VideoDecoderSelection vds,
     params.enableFramePacing = enableFramePacing;
     params.testOnly = testOnly;
     params.vds = vds;
+    params.renderer = renderer;
 
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                 "V-sync %s",
@@ -396,6 +398,7 @@ void Session::getDecoderInfo(SDL_Window* window,
 
     // Try an HEVC Main10 decoder first to see if we have HDR support
     if (chooseDecoder(StreamingPreferences::VDS_FORCE_HARDWARE,
+                      StreamingPreferences::RS_PROBE_ONLY,
                       window, VIDEO_FORMAT_H265_MAIN10, 1920, 1080, 60,
                       false, false, true, decoder)) {
         isHardwareAccelerated = decoder->isHardwareAccelerated();
@@ -409,6 +412,7 @@ void Session::getDecoderInfo(SDL_Window* window,
 
     // Try an AV1 Main10 decoder next to see if we have HDR support
     if (chooseDecoder(StreamingPreferences::VDS_FORCE_HARDWARE,
+                      StreamingPreferences::RS_PROBE_ONLY,
                       window, VIDEO_FORMAT_AV1_MAIN10, 1920, 1080, 60,
                       false, false, true, decoder)) {
         // If we've got a working AV1 Main 10-bit decoder, we'll enable the HDR checkbox
@@ -421,9 +425,11 @@ void Session::getDecoderInfo(SDL_Window* window,
         // If we found no hardware decoders with HDR, check for a renderer
         // that supports HDR rendering with software decoded frames.
         if (chooseDecoder(StreamingPreferences::VDS_FORCE_SOFTWARE,
+                          StreamingPreferences::RS_PROBE_ONLY,
                           window, VIDEO_FORMAT_H265_MAIN10, 1920, 1080, 60,
                           false, false, true, decoder) ||
             chooseDecoder(StreamingPreferences::VDS_FORCE_SOFTWARE,
+                          StreamingPreferences::RS_PROBE_ONLY,
                           window, VIDEO_FORMAT_AV1_MAIN10, 1920, 1080, 60,
                           false, false, true, decoder)) {
             isHdrSupported = decoder->isHdrSupported();
@@ -438,6 +444,7 @@ void Session::getDecoderInfo(SDL_Window* window,
 
     // Try a regular hardware accelerated HEVC decoder now
     if (chooseDecoder(StreamingPreferences::VDS_FORCE_HARDWARE,
+                      StreamingPreferences::RS_PROBE_ONLY,
                       window, VIDEO_FORMAT_H265, 1920, 1080, 60,
                       false, false, true, decoder)) {
         isHardwareAccelerated = decoder->isHardwareAccelerated();
@@ -451,6 +458,7 @@ void Session::getDecoderInfo(SDL_Window* window,
 
 #if 0 // See AV1 comment at the top of this function
     if (chooseDecoder(StreamingPreferences::VDS_FORCE_HARDWARE,
+                      StreamingPreferences::RS_PROBE_ONLY,
                       window, VIDEO_FORMAT_AV1_MAIN8, 1920, 1080, 60,
                       false, false, true, decoder)) {
         isHardwareAccelerated = decoder->isHardwareAccelerated();
@@ -465,6 +473,7 @@ void Session::getDecoderInfo(SDL_Window* window,
     // If we still didn't find a hardware decoder, try H.264 now.
     // This will fall back to software decoding, so it should always work.
     if (chooseDecoder(StreamingPreferences::VDS_AUTO,
+                      StreamingPreferences::RS_PROBE_ONLY,
                       window, VIDEO_FORMAT_H264, 1920, 1080, 60,
                       false, false, true, decoder)) {
         isHardwareAccelerated = decoder->isHardwareAccelerated();
@@ -486,7 +495,10 @@ Session::getDecoderAvailability(SDL_Window* window,
 {
     IVideoDecoder* decoder;
 
-    if (!chooseDecoder(vds, window, videoFormat, width, height, frameRate, false, false, true, decoder)) {
+    if (!chooseDecoder(vds,
+                       StreamingPreferences::RS_PROBE_ONLY,
+                       window, videoFormat, width, height, frameRate,
+                       false, false, true, decoder)) {
         return DecoderAvailability::None;
     }
 
@@ -501,7 +513,12 @@ bool Session::populateDecoderProperties(SDL_Window* window)
 {
     IVideoDecoder* decoder;
 
+    // NB: We pass the real renderer selection rather than RS_PROBE_ONLY
+    // here because this is operating on the real streaming window, and
+    // instantiating Metal or AVSBDL renderers can interfere with MoltenVK's
+    // attempt to change the window's colorspace, causing washed out colors.
     if (!chooseDecoder(m_Preferences->videoDecoderSelection,
+                       m_Preferences->rendererSelection,
                        window,
                        m_SupportedVideoFormats.first(),
                        m_StreamConfig.width,
@@ -2192,6 +2209,7 @@ void Session::exec()
                 // Choose a new decoder (hopefully the same one, but possibly
                 // not if a GPU was removed or something).
                 if (!chooseDecoder(m_Preferences->videoDecoderSelection,
+                                   m_Preferences->rendererSelection,
                                    m_Window, m_ActiveVideoFormat, m_ActiveVideoWidth,
                                    m_ActiveVideoHeight, m_ActiveVideoFrameRate,
                                    enableVsync,

app/streaming/session.h

@@ -184,6 +184,7 @@ private:
 
     static
     bool chooseDecoder(StreamingPreferences::VideoDecoderSelection vds,
+                       StreamingPreferences::RendererSelection renderer,
                        SDL_Window* window, int videoFormat, int width, int height,
                        int frameRate, bool enableVsync, bool enableFramePacing,
                        bool testOnly,

app/streaming/streamutils.cpp

@@ -222,12 +222,14 @@ bool StreamUtils::hasFastAes()
     // Everything that runs Catalina and later has AES-NI or ARMv8 crypto instructions
     return true;
 #elif (defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)) && defined(Q_PROCESSOR_ARM) && QT_POINTER_SIZE == 4
-    unsigned long hwcap2 = 0;
-    elf_aux_info(AT_HWCAP2, &hwcap2, sizeof(hwcap2));
+    unsigned long hwcap2;
+    if (elf_aux_info(AT_HWCAP2, &hwcap2, sizeof(hwcap2)) != 0)
+        hwcap2 = 0;
     return (hwcap2 & HWCAP2_AES);
 #elif (defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)) && defined(Q_PROCESSOR_ARM) && QT_POINTER_SIZE == 8
-    unsigned long hwcap = 0;
-    elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap));
+    unsigned long hwcap;
+    if (elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap)) != 0)
+        hwcap = 0;
     return (hwcap & HWCAP_AES);
 #elif defined(Q_OS_LINUX) && defined(Q_PROCESSOR_ARM) && QT_POINTER_SIZE == 4
     return getauxval(AT_HWCAP2) & HWCAP2_AES;

app/streaming/video/decoder.h

@@ -36,6 +36,7 @@ typedef struct _VIDEO_STATS {
 typedef struct _DECODER_PARAMETERS {
     SDL_Window* window;
     StreamingPreferences::VideoDecoderSelection vds;
+    StreamingPreferences::RendererSelection renderer;
 
     int videoFormat;
     int width;

app/streaming/video/ffmpeg-renderers/d3d11va.cpp

@@ -256,6 +256,7 @@ bool D3D11VARenderer::createDeviceByAdapterIndex(int adapterIndex, bool* adapter
     HRESULT hr;
     ComPtr<ID3D11Device> device;
     ComPtr<ID3D11DeviceContext> deviceContext;
+    LARGE_INTEGER umdVersion;
 
     SDL_assert(!m_RenderDevice);
     SDL_assert(!m_RenderDeviceContext);
@@ -287,12 +288,25 @@ bool D3D11VARenderer::createDeviceByAdapterIndex(int adapterIndex, bool* adapter
         goto Exit;
     }
 
+    // Query the GPU driver version
+    hr = adapter->CheckInterfaceSupport(__uuidof(IDXGIDevice), &umdVersion);
+    if (FAILED(hr)) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "IDXGIAdapter::CheckInterfaceSupport() failed: %x",
+                     hr);
+        goto Exit;
+    }
+
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Detected GPU %d: %S (%x:%x)",
+                "Detected GPU %d: %S (%x:%x) (driver: %u.%u.%u.%u)",
                 adapterIndex,
                 adapterDesc.Description,
                 adapterDesc.VendorId,
-                adapterDesc.DeviceId);
+                adapterDesc.DeviceId,
+                HIWORD(umdVersion.HighPart),
+                LOWORD(umdVersion.HighPart),
+                HIWORD(umdVersion.LowPart),
+                LOWORD(umdVersion.LowPart));
 
     hr = D3D11CreateDevice(adapter.Get(),
                            D3D_DRIVER_TYPE_UNKNOWN,
@@ -371,22 +385,29 @@ bool D3D11VARenderer::createDeviceByAdapterIndex(int adapterIndex, bool* adapter
         separateDevices = SUCCEEDED(hr) && d3d11Options.ExtendedResourceSharing && m_FenceType != SupportedFenceType::None;
 
         if (separateDevices) {
-            // The Radon HD 5570 GPU drivers deadlock when decoding into shared texture arrays, so let's
-            // limit usage of separate devices to FL 11.1+ GPUs to try to exclude old GPU drivers. We'll
-            // exempt Intel GPUs because those have been confirmed to work properly (and the extra fence
-            // that this device separation uses acts as a workaround for a bug in their old drivers where
-            // they don't properly synchronize between decoder output usage and SRV usage).
-            if (featureLevel < D3D_FEATURE_LEVEL_11_1 && adapterDesc.VendorId != 0x8086) {
-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "Avoiding texture sharing for old pre-FL11.1 GPU");
-                separateDevices = false;
-            }
-            else if (adapterDesc.VendorId == 0x1ED5 || // Moore Threads (texture is all zero/green)
-                     adapterDesc.VendorId == 0x4D4F4351) { // Qualcomm (decoding is unstable/slow on QC710)
-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "Avoiding texture sharing on known broken GPU vendor");
-                separateDevices = false;
+            // Use minimum precision support to differentiate Vega and later from Polaris and earlier
+            D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT minPrecSupport;
+            hr = m_RenderDevice->CheckFeatureSupport(D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT, &minPrecSupport, sizeof(minPrecSupport));
+            if (FAILED(hr)) {
+                minPrecSupport = {};
             }
+
+            // This texture array sharing codepath is quite prone to driver bugs.
+            //
+            // Broken GPU vendors/cards/drivers include:
+            // - Moore Threads (texture is all zero/green)
+            // - Qualcomm (decoding is unstable/slow on QC710)
+            // - AMD prior to Vega (Polaris cards display corrupt output - see #2003,
+            //                      HD 5570 drivers deadlock with shared texture arrays)
+            // - Nvidia drivers prior to ~471.11 (Earlier drivers display all zero/green,
+            //                                    We approximate by requiring WDDM 3.0+)
+            //
+            // Due to all these issues, we will only use this path for Intel/AMD and NVIDIA where we know it
+            // provides tangible benefits (performance for the former and VRR support for the latter).
+            separateDevices = adapterDesc.VendorId == 0x8086 || // Intel
+                              (adapterDesc.VendorId == 0x10DE && HIWORD(umdVersion.HighPart) >= 30) || // NVIDIA WDDM 3.0+ (PCI ID)
+                              adapterDesc.VendorId == 'ADVN' || // NVIDIA (WoA)
+                              (adapterDesc.VendorId == 0x1002 && (minPrecSupport.PixelShaderMinPrecision & D3D11_SHADER_MIN_PRECISION_16_BIT)); // AMD Vega+
         }
     }
 
@@ -406,12 +427,10 @@ bool D3D11VARenderer::createDeviceByAdapterIndex(int adapterIndex, bool* adapter
         // significant performance impact of the extra copy. See:
         // https://github.com/moonlight-stream/moonlight-qt/issues/1304
         //
-        // Also bind SRVs when using separate decoding and rendering
-        // devices as this improves render times by about 2x on my
-        // Ryzen 3300U system. The fences we use between decoding
-        // and rendering contexts should hopefully avoid any of the
-        // synchronization issues we've seen between decoder and SRVs.
-        m_BindDecoderOutputTextures = adapterDesc.VendorId == 0x8086 || separateDevices;
+        // Also bind SRVs as this improves render times by about 2x on
+        // my Ryzen 3300U system.
+        m_BindDecoderOutputTextures = adapterDesc.VendorId == 0x8086 ||
+                                      separateDevices;
     }
 
     SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,

app/streaming/video/ffmpeg-renderers/drm.cpp

@@ -74,6 +74,7 @@ extern "C" {
 #include <Limelight.h>
 
 #include <map>
+#include <unordered_set>
 
 #ifdef HAVE_DRM_MASTER_HOOKS
 extern "C" {
@@ -162,9 +163,6 @@ DrmRenderer::DrmRenderer(AVHWDeviceType hwDeviceType, IFFmpegRenderer *backendRe
       m_OutputRect{},
       m_SwFrameMapper(this),
       m_CurrentSwFrameIdx(0)
-#ifdef HAVE_EGL
-    , m_EglImageFactory(this)
-#endif
 {
     SDL_zero(m_SwFrame);
 }
@@ -1750,6 +1748,7 @@ bool DrmRenderer::addFbForFrame(AVFrame *frame, uint32_t* newFbId, bool testMode
     uint32_t offsets[4] = {};
     uint64_t modifiers[4] = {};
     uint32_t flags = 0;
+    std::unordered_set<uint32_t> handleSet;
 
     // DRM requires composed layers rather than separate layers per plane
     SDL_assert(drmFrame->nb_layers == 1);
@@ -1763,9 +1762,16 @@ bool DrmRenderer::addFbForFrame(AVFrame *frame, uint32_t* newFbId, bool testMode
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                          "drmPrimeFDToHandle() failed: %d",
                          errno);
+            for (uint32_t handle : handleSet) {
+                drmCloseBufferHandle(m_DrmFd, handle);
+            }
             return false;
         }
 
+        // Handles aren't unique for calls with the same FD, so we need to
+        // keep track of only the unique handles to avoid double-closing.
+        handleSet.emplace(handles[i]);
+
         pitches[i] = layer.planes[i].pitch;
         offsets[i] = layer.planes[i].offset;
         modifiers[i] = object.format_modifier;
@@ -1784,6 +1790,12 @@ bool DrmRenderer::addFbForFrame(AVFrame *frame, uint32_t* newFbId, bool testMode
                                      handles, pitches, offsets,
                                      (flags & DRM_MODE_FB_MODIFIERS) ? modifiers : NULL,
                                      newFbId, flags);
+
+    // Handles can be closed immediately after drmModeAddFB2WithModifiers()
+    for (uint32_t handle : handleSet) {
+        drmCloseBufferHandle(m_DrmFd, handle);
+    }
+
     if (err < 0) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "drmModeAddFB2[WithModifiers]() failed: %d",
@@ -2004,6 +2016,22 @@ int DrmRenderer::getDecoderColorspace()
     return COLORSPACE_REC_601;
 }
 
+int DrmRenderer::getDecoderColorRange()
+{
+    if (auto prop = m_VideoPlane.property("COLOR_RANGE")) {
+        // Prefer full range if the video plane supports it
+        if (prop->containsValue("YCbCr full range")) {
+            return COLOR_RANGE_FULL;
+        }
+        else if (prop->containsValue("YCbCr limited range")) {
+            return COLOR_RANGE_LIMITED;
+        }
+    }
+
+    // Default to limited if we couldn't find a valid COLOR_RANGE property
+    return COLOR_RANGE_LIMITED;
+}
+
 const char* DrmRenderer::getDrmColorEncodingValue(AVFrame* frame)
 {
     switch (getFrameColorspace(frame)) {
@@ -2069,9 +2097,10 @@ AVPixelFormat DrmRenderer::getEGLImagePixelFormat() {
     return AV_PIX_FMT_DRM_PRIME;
 }
 
-bool DrmRenderer::initializeEGL(EGLDisplay display,
+bool DrmRenderer::initializeEGL(IFFmpegRenderer* eglRenderer,
+                                EGLDisplay display,
                                 const EGLExtensions &ext) {
-    return m_EglImageFactory.initializeEGL(display, ext);
+    return m_EglImageFactory.initializeEGL(eglRenderer, display, ext);
 }
 
 ssize_t DrmRenderer::exportEGLImages(AVFrame *frame, EGLDisplay dpy,

app/streaming/video/ffmpeg-renderers/drm.h

@@ -770,12 +770,13 @@ public:
     virtual bool testRenderFrame(AVFrame* frame) override;
     virtual bool isDirectRenderingSupported() override;
     virtual int getDecoderColorspace() override;
+    virtual int getDecoderColorRange() override;
     virtual void setHdrMode(bool enabled) override;
     virtual void notifyOverlayUpdated(Overlay::OverlayType type) override;
 #ifdef HAVE_EGL
     virtual bool canExportEGL() override;
     virtual AVPixelFormat getEGLImagePixelFormat() override;
-    virtual bool initializeEGL(EGLDisplay dpy, const EGLExtensions &ext) override;
+    virtual bool initializeEGL(IFFmpegRenderer* eglRenderer, EGLDisplay dpy, const EGLExtensions &ext) override;
     virtual ssize_t exportEGLImages(AVFrame *frame, EGLDisplay dpy, EGLImage images[EGL_MAX_PLANES]) override;
 #endif
 

app/streaming/video/ffmpeg-renderers/dxva2.cpp

@@ -784,6 +784,14 @@ int DXVA2Renderer::getDecoderColorspace()
     }
 }
 
+int DXVA2Renderer::getDecoderColorRange()
+{
+    // StretchRect() assumes limited range on Intel and Qualcomm GPUs.
+    // VideoProcessBlt() should handle either fine, but let's not take
+    // chances on potentially broken DXVA2 GPU drivers for little gain.
+    return COLOR_RANGE_LIMITED;
+}
+
 int DXVA2Renderer::getDecoderCapabilities()
 {
     return CAPABILITY_REFERENCE_FRAME_INVALIDATION_HEVC |

app/streaming/video/ffmpeg-renderers/dxva2.h

@@ -18,6 +18,7 @@ public:
     virtual void renderFrame(AVFrame* frame) override;
     virtual void notifyOverlayUpdated(Overlay::OverlayType type) override;
     virtual int getDecoderColorspace() override;
+    virtual int getDecoderColorRange() override;
     virtual int getDecoderCapabilities() override;
 
 private:

app/streaming/video/ffmpeg-renderers/eglimagefactory.cpp

@@ -24,8 +24,8 @@
 #define DRM_FORMAT_GR88 fourcc_code('G', 'R', '8', '8')
 #endif
 
-EglImageFactory::EglImageFactory(IFFmpegRenderer* renderer) :
-    m_Renderer(renderer),
+EglImageFactory::EglImageFactory() :
+    m_Renderer(nullptr),
     m_EGLExtDmaBuf(false),
     m_eglCreateImage(nullptr),
     m_eglDestroyImage(nullptr),
@@ -36,9 +36,16 @@ EglImageFactory::EglImageFactory(IFFmpegRenderer* renderer) :
 {
 }
 
-bool EglImageFactory::initializeEGL(EGLDisplay,
+bool EglImageFactory::initializeEGL(IFFmpegRenderer* eglRenderer,
+                                    EGLDisplay,
                                     const EGLExtensions &ext)
 {
+    // The EGL renderer is guaranteed to be alive for any calls to this factory,
+    // since it's the one that calls exportEGLImages() on the backend renderer.
+    SDL_assert(eglRenderer->getRendererType() == IFFmpegRenderer::RendererType::EGL);
+    SDL_assert(!m_Renderer);
+    m_Renderer = eglRenderer;
+
     if (!ext.isSupported("EGL_EXT_image_dma_buf_import")) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                      "DRM-EGL: DMABUF unsupported");
@@ -75,6 +82,8 @@ void EglImageFactory::resetCache()
 
 ssize_t EglImageFactory::exportDRMImages(AVFrame* frame, EGLDisplay dpy, EGLImage images[EGL_MAX_PLANES])
 {
+    SDL_assert(m_Renderer);
+
     SDL_assert(frame->format == AV_PIX_FMT_DRM_PRIME);
     AVDRMFrameDescriptor* drmFrame = (AVDRMFrameDescriptor*)frame->data[0];
 
@@ -264,6 +273,8 @@ ssize_t EglImageFactory::exportDRMImages(AVFrame* frame, EGLDisplay dpy, EGLImag
 
 ssize_t EglImageFactory::exportVAImages(AVFrame *frame, uint32_t exportFlags, EGLDisplay dpy, EGLImage images[EGL_MAX_PLANES])
 {
+    SDL_assert(m_Renderer);
+
     SDL_assert(frame->format == AV_PIX_FMT_VAAPI);
     auto hwFrameCtx = (AVHWFramesContext*)frame->hw_frames_ctx->data;
     AVVAAPIDeviceContext* vaDeviceContext = (AVVAAPIDeviceContext*)hwFrameCtx->device_ctx->hwctx;

app/streaming/video/ffmpeg-renderers/eglimagefactory.h

@@ -41,8 +41,8 @@ class EglImageFactory
     };
 
 public:
-    EglImageFactory(IFFmpegRenderer* renderer);
-    bool initializeEGL(EGLDisplay, const EGLExtensions &ext);
+    EglImageFactory();
+    bool initializeEGL(IFFmpegRenderer* eglRenderer, EGLDisplay, const EGLExtensions &ext);
     void resetCache();
 
 #ifdef HAVE_DRM

app/streaming/video/ffmpeg-renderers/eglvid.cpp

@@ -523,7 +523,7 @@ bool EGLRenderer::initialize(PDECODER_PARAMETERS params)
         return false;
     }
 
-    if (!m_Backend->initializeEGL(m_EGLDisplay, eglExtensions))
+    if (!m_Backend->initializeEGL(this, m_EGLDisplay, eglExtensions))
         return false;
 
     if (!(m_glEGLImageTargetTexture2DOES = (typeof(m_glEGLImageTargetTexture2DOES))eglGetProcAddress("glEGLImageTargetTexture2DOES"))) {

app/streaming/video/ffmpeg-renderers/mmal.cpp

@@ -242,6 +242,12 @@ int MmalRenderer::getDecoderColorspace()
     return COLORSPACE_REC_709;
 }
 
+int MmalRenderer::getDecoderColorRange()
+{
+    // MMAL_COLOR_SPACE_ITUR_BT709 assumes limited range content
+    return COLOR_RANGE_LIMITED;
+}
+
 void MmalRenderer::InputPortCallback(MMAL_PORT_T*, MMAL_BUFFER_HEADER_T* buffer)
 {
     mmal_buffer_header_release(buffer);

app/streaming/video/ffmpeg-renderers/mmal.h

@@ -18,6 +18,7 @@ public:
     virtual enum AVPixelFormat getPreferredPixelFormat(int videoFormat) override;
     virtual int getRendererAttributes() override;
     virtual int getDecoderColorspace() override;
+    virtual int getDecoderColorRange() override;
 
 private:
     static void InputPortCallback(MMAL_PORT_T* port, MMAL_BUFFER_HEADER_T* buffer);

app/streaming/video/ffmpeg-renderers/renderer.h

@@ -224,8 +224,8 @@ public:
     }
 
     virtual int getDecoderColorRange() {
-        // Limited is the default
-        return COLOR_RANGE_LIMITED;
+        // Full is the default
+        return COLOR_RANGE_FULL;
     }
 
     virtual int getFrameColorspace(const AVFrame* frame) {
@@ -247,10 +247,16 @@ public:
     }
 
     virtual bool isFrameFullRange(const AVFrame* frame) {
-        // This handles the case where the color range is unknown,
-        // so that we use Limited color range which is the default
-        // behavior for Moonlight.
-        return frame->color_range == AVCOL_RANGE_JPEG;
+        switch (frame->color_range) {
+        case AVCOL_RANGE_JPEG:
+            return true;
+        case AVCOL_RANGE_MPEG:
+            return false;
+        default:
+            // If the color range is not populated, assume the encoder
+            // is sending the color range that we requested.
+            return getDecoderColorRange() == COLOR_RANGE_FULL;
+        }
     }
 
     virtual bool isRenderThreadSupported() {
@@ -502,7 +508,8 @@ public:
         return AV_PIX_FMT_NONE;
     }
 
-    virtual bool initializeEGL(EGLDisplay,
+    virtual bool initializeEGL(IFFmpegRenderer*,
+                               EGLDisplay,
                                const EGLExtensions &) {
         return false;
     }

app/streaming/video/ffmpeg-renderers/sdlvid.cpp

@@ -352,9 +352,11 @@ ReadbackRetry:
             av_dict_set_int(&options, "srcw", frame->width, 0);
             av_dict_set_int(&options, "srch", frame->height, 0);
             av_dict_set_int(&options, "src_format", frame->format, 0);
+            av_dict_set_int(&options, "src_range", isFrameFullRange(frame) ? 1 : 0, 0);
             av_dict_set_int(&options, "dstw", m_RgbFrame->width, 0);
             av_dict_set_int(&options, "dsth", m_RgbFrame->height, 0);
             av_dict_set_int(&options, "dst_format", m_RgbFrame->format, 0);
+            av_dict_set_int(&options, "dst_range", 1, 0);
             av_dict_set_int(&options, "threads", std::min(SDL_GetCPUCount(), 4), 0); // Up to 4 threads
 
             err = av_opt_set_dict(m_SwsContext, &options);
@@ -638,3 +640,21 @@ bool SdlRenderer::notifyWindowChanged(PWINDOW_STATE_CHANGE_INFO info)
     // We can transparently handle size and display changes
     return !(info->stateChangeFlags & ~(WINDOW_STATE_CHANGE_SIZE | WINDOW_STATE_CHANGE_DISPLAY));
 }
+
+int SdlRenderer::getDecoderColorspace()
+{
+    // SDL2 only supports both full and limited range for BT.601. Additionally, libswscale
+    // assumes content is in the BT.601 color space when performing YUV to RGB conversion.
+    return COLORSPACE_REC_601;
+}
+
+int SdlRenderer::getDecoderColorRange()
+{
+    // Prefer full range only on FFmpeg 5.0 or later, since we don't implement
+    // color range handling in the legacy FFmpeg 4.x codepath.
+#if LIBSWSCALE_VERSION_INT >= AV_VERSION_INT(6, 1, 100)
+    return COLOR_RANGE_FULL;
+#else
+    return COLOR_RANGE_LIMITED;
+#endif
+}

app/streaming/video/ffmpeg-renderers/sdlvid.h

@@ -23,6 +23,8 @@ public:
     virtual bool isPixelFormatSupported(int videoFormat, enum AVPixelFormat pixelFormat) override;
     virtual bool testRenderFrame(AVFrame* frame) override;
     virtual bool notifyWindowChanged(PWINDOW_STATE_CHANGE_INFO) override;
+    virtual int getDecoderColorspace() override;
+    virtual int getDecoderColorRange() override;
 
 private:
     void renderOverlay(Overlay::OverlayType type);

app/streaming/video/ffmpeg-renderers/vaapi.cpp

@@ -26,8 +26,7 @@ VAAPIRenderer::VAAPIRenderer(int decoderSelectionPass)
       m_RequiresExplicitPixelFormat(false),
       m_OverlayMutex(nullptr)
 #ifdef HAVE_EGL
-    , m_EglExportType(EglExportType::Unknown),
-      m_EglImageFactory(this)
+    , m_EglExportType(EglExportType::Unknown)
 #endif
 {
 #ifdef HAVE_LIBVA_X11
@@ -342,14 +341,13 @@ VAAPIRenderer::initialize(PDECODER_PARAMETERS params)
             break;
         }
 
-#if defined(APP_IMAGE) || defined(USE_FALLBACK_DRIVER_PATHS)
-        // AppImages will be running with our libva.so which means they don't know about
+        // AppImages may be running with our libva.so which means they don't know about
         // distro-specific driver paths. To avoid failing in this scenario, we'll hardcode
         // some such paths here for common distros. Non-AppImage packaging mechanisms won't
         // need this fallback because either:
         // a) They are using both distro libva.so and distro libva drivers (native packages)
         // b) They are using both runtime libva.so and runtime libva drivers (Flatpak/Snap)
-        if (qEnvironmentVariableIsEmpty("LIBVA_DRIVERS_PATH")) {
+        if (qEnvironmentVariableIsEmpty("LIBVA_DRIVERS_PATH") && qgetenv("VAAPI_USE_FALLBACK_PATHS") == "1") {
             SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                         "Trying fallback VAAPI driver paths");
 
@@ -371,7 +369,6 @@ VAAPIRenderer::initialize(PDECODER_PARAMETERS params)
            setPathVar = true;
         }
         else
-#endif
         {
             if (setPathVar) {
                 // Unset LIBVA_DRIVERS_PATH if we set it ourselves
@@ -648,6 +645,12 @@ int VAAPIRenderer::getDecoderColorspace()
     return COLORSPACE_REC_601;
 }
 
+int VAAPIRenderer::getDecoderColorRange()
+{
+    // vaPutSurface() assumes limited range
+    return COLOR_RANGE_LIMITED;
+}
+
 int VAAPIRenderer::getDecoderCapabilities()
 {
     int caps = 0;
@@ -1076,11 +1079,12 @@ AVPixelFormat VAAPIRenderer::getEGLImagePixelFormat() {
 }
 
 bool
-VAAPIRenderer::initializeEGL(EGLDisplay dpy,
+VAAPIRenderer::initializeEGL(IFFmpegRenderer* eglRenderer,
+                             EGLDisplay dpy,
                              const EGLExtensions &ext) {
     VADRMPRIMESurfaceDescriptor descriptor;
 
-    if (!m_EglImageFactory.initializeEGL(dpy, ext)) {
+    if (!m_EglImageFactory.initializeEGL(eglRenderer, dpy, ext)) {
         return false;
     }
 

app/streaming/video/ffmpeg-renderers/vaapi.h

@@ -64,6 +64,7 @@ public:
     virtual void renderFrame(AVFrame* frame) override;
     virtual bool isDirectRenderingSupported() override;
     virtual int getDecoderColorspace() override;
+    virtual int getDecoderColorRange() override;
     virtual int getDecoderCapabilities() override;
     virtual void notifyOverlayUpdated(Overlay::OverlayType) override;
     virtual bool notifyWindowChanged(PWINDOW_STATE_CHANGE_INFO) override;
@@ -71,7 +72,7 @@ public:
 #ifdef HAVE_EGL
     virtual bool canExportEGL() override;
     virtual AVPixelFormat getEGLImagePixelFormat() override;
-    virtual bool initializeEGL(EGLDisplay dpy, const EGLExtensions &ext) override;
+    virtual bool initializeEGL(IFFmpegRenderer* eglRenderer, EGLDisplay dpy, const EGLExtensions &ext) override;
     virtual ssize_t exportEGLImages(AVFrame *frame, EGLDisplay dpy, EGLImage images[EGL_MAX_PLANES]) override;
 #endif
 

app/streaming/video/ffmpeg-renderers/vdpau.cpp

@@ -470,6 +470,12 @@ int VDPAURenderer::getDecoderColorspace()
     return COLORSPACE_REC_601;
 }
 
+int VDPAURenderer::getDecoderColorRange()
+{
+    // The default VdpVideoMixer CSC matrix assumes limited range
+    return COLOR_RANGE_LIMITED;
+}
+
 int VDPAURenderer::getDecoderCapabilities()
 {
     return CAPABILITY_REFERENCE_FRAME_INVALIDATION_HEVC |

app/streaming/video/ffmpeg-renderers/vdpau.h

@@ -19,6 +19,7 @@ public:
     virtual void waitToRender() override;
     virtual void renderFrame(AVFrame* frame) override;
     virtual int getDecoderColorspace() override;
+    virtual int getDecoderColorRange() override;
     virtual int getDecoderCapabilities() override;
 
 private:

app/streaming/video/ffmpeg-renderers/vt_avsamplelayer.mm

@@ -457,6 +457,11 @@ public:
         return COLORSPACE_REC_601;
     }
 
+    int getDecoderColorRange() override
+    {
+        return COLOR_RANGE_LIMITED;
+    }
+
     int getDecoderCapabilities() override
     {
         return CAPABILITY_REFERENCE_FRAME_INVALIDATION_HEVC |

app/streaming/video/ffmpeg.cpp

@@ -988,8 +988,10 @@ void FFmpegVideoDecoder::logVideoStats(VIDEO_STATS& stats, const char* title)
     }
 }
 
-IFFmpegRenderer* FFmpegVideoDecoder::createHwAccelRenderer(const AVCodecHWConfig* hwDecodeCfg, int pass)
+IFFmpegRenderer* FFmpegVideoDecoder::createHwAccelRenderer(const AVCodecHWConfig* hwDecodeCfg, PDECODER_PARAMETERS params, int pass)
 {
+    Q_UNUSED(params);
+
     if (!(hwDecodeCfg->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)) {
         return nullptr;
     }
@@ -1007,11 +1009,17 @@ IFFmpegRenderer* FFmpegVideoDecoder::createHwAccelRenderer(const AVCodecHWConfig
         case AV_HWDEVICE_TYPE_VIDEOTOOLBOX:
             // Prefer the libplacebo (on MoltenVK) renderer unless explicitly opted out
 #ifdef HAVE_LIBPLACEBO_VULKAN
-            if (qgetenv("PREFER_VULKAN") != "0") {
+            if (params->renderer == StreamingPreferences::RS_AUTO || params->renderer == StreamingPreferences::RS_VULKAN) {
                 return new PlVkRenderer(hwDecodeCfg->device_type);
             }
 #endif
-            return VTMetalRendererFactory::createRenderer(true);
+            if (params->renderer == StreamingPreferences::RS_AVSBDL) {
+                return VTRendererFactory::createRenderer();
+            }
+            else {
+                // This covers both Metal explicitly selected and probe-only (since Metal is cheap to instantiate)
+                return VTMetalRendererFactory::createRenderer(true);
+            }
 #endif
 #ifdef HAVE_LIBVA
         case AV_HWDEVICE_TYPE_VAAPI:
@@ -1334,7 +1342,7 @@ bool FFmpegVideoDecoder::tryInitializeRendererForUnknownDecoder(const AVCodec* d
                 // Initialize the hardware codec and submit a test frame if the renderer needs it
                 IFFmpegRenderer::InitFailureReason failureReason;
                 if (tryInitializeRenderer(decoder, AV_PIX_FMT_NONE, params, config, &failureReason,
-                                          [config, pass]() -> IFFmpegRenderer* { return createHwAccelRenderer(config, pass); })) {
+                                          [config, params, pass]() -> IFFmpegRenderer* { return createHwAccelRenderer(config, params, pass); })) {
                     return true;
                 }
                 else if (failureReason == IFFmpegRenderer::InitFailureReason::NoHardwareSupport) {
@@ -1534,7 +1542,7 @@ bool FFmpegVideoDecoder::tryInitializeHwAccelDecoder(PDECODER_PARAMETERS params,
             // Initialize the hardware codec and submit a test frame if the renderer needs it
             IFFmpegRenderer::InitFailureReason failureReason;
             if (tryInitializeRenderer(decoder, AV_PIX_FMT_NONE, params, config, &failureReason,
-                                      [config, pass]() -> IFFmpegRenderer* { return createHwAccelRenderer(config, pass); })) {
+                                      [config, params, pass]() -> IFFmpegRenderer* { return createHwAccelRenderer(config, params, pass); })) {
                 return true;
             }
             else if (failureReason == IFFmpegRenderer::InitFailureReason::NoHardwareSupport) {
@@ -1755,6 +1763,7 @@ void FFmpegVideoDecoder::writeBuffer(PLENTRY entry, int& offset)
     if (m_NeedsSpsFixup && entry->bufferType == BUFFER_TYPE_SPS) {
         h264_stream_t* stream = h264_new();
         int nalStart, nalEnd;
+        bool needsFixup;
 
         // Read the old NALU
         find_nal_unit((uint8_t*)entry->data, entry->length, &nalStart, &nalEnd);
@@ -1767,33 +1776,60 @@ void FFmpegVideoDecoder::writeBuffer(PLENTRY entry, int& offset)
 
         // Fixup the SPS to what OS X needs to use hardware acceleration
         // This is also critical for decoding latency on the Pi 2.
-        stream->sps->num_ref_frames = 1;
-        stream->sps->vui.max_dec_frame_buffering = 1;
+        needsFixup = (stream->sps->num_ref_frames != 1 || stream->sps->vui.max_dec_frame_buffering != 1);
+#ifndef QT_DEBUG
+        if (needsFixup)
+#endif
+        {
+            stream->sps->num_ref_frames = 1;
+            stream->sps->vui.max_dec_frame_buffering = 1;
 
-        // NVENC doesn't seem to add bitstream restrictions anymore (591.59),
-        // so we need to add them ourselves if not present to ensure that
-        // the max_dec_frame_buffering option actually takes effect.
-        // We use the defaults for everything except max_dec_frame_buffering.
-        if (!stream->sps->vui.bitstream_restriction_flag) {
-            stream->sps->vui.bitstream_restriction_flag = 1;
-            stream->sps->vui.motion_vectors_over_pic_boundaries_flag = 1;
-            stream->sps->vui.max_bytes_per_pic_denom = 2;
-            stream->sps->vui.max_bits_per_mb_denom = 1;
-            stream->sps->vui.log2_max_mv_length_horizontal = 16;
-            stream->sps->vui.log2_max_mv_length_vertical = 16;
-            stream->sps->vui.num_reorder_frames = 0;
+            // NVENC doesn't seem to add bitstream restrictions anymore (591.59),
+            // so we need to add them ourselves if not present to ensure that
+            // the max_dec_frame_buffering option actually takes effect.
+            // We use the defaults for everything except max_dec_frame_buffering.
+            if (!stream->sps->vui.bitstream_restriction_flag) {
+                stream->sps->vui.bitstream_restriction_flag = 1;
+                stream->sps->vui.motion_vectors_over_pic_boundaries_flag = 1;
+                stream->sps->vui.max_bytes_per_pic_denom = 2;
+                stream->sps->vui.max_bits_per_mb_denom = 1;
+                stream->sps->vui.log2_max_mv_length_horizontal = 16;
+                stream->sps->vui.log2_max_mv_length_vertical = 16;
+                stream->sps->vui.num_reorder_frames = 0;
+            }
+
+            int initialOffset = offset;
+
+            // Copy the modified NALU data. This clobbers byte 0 and starts NALU data at byte 1.
+            // Since it prepended one extra byte, subtract one from the returned length.
+            offset += write_nal_unit(stream, (uint8_t*)&m_DecodeBuffer.data()[initialOffset + nalStart - 1],
+                                     MAX_SPS_EXTRA_SIZE + entry->length - nalStart) - 1;
+
+            // Copy the NALU prefix over from the original SPS
+            memcpy(&m_DecodeBuffer.data()[initialOffset], entry->data, nalStart);
+            offset += nalStart;
+
+#ifdef QT_DEBUG
+            // If we didn't need a fixup, the SPS should have stayed the exact same
+            if (!needsFixup) {
+                SDL_assert(offset - initialOffset == entry->length);
+                SDL_assert(memcmp(&m_DecodeBuffer.data()[initialOffset], entry->data, entry->length) == 0);
+            }
+            else {
+                // The SPS should never get smaller with a fixup
+                SDL_assert(offset - initialOffset >= entry->length);
+            }
+#endif
         }
-
-        int initialOffset = offset;
-
-        // Copy the modified NALU data. This clobbers byte 0 and starts NALU data at byte 1.
-        // Since it prepended one extra byte, subtract one from the returned length.
-        offset += write_nal_unit(stream, (uint8_t*)&m_DecodeBuffer.data()[initialOffset + nalStart - 1],
-                                 MAX_SPS_EXTRA_SIZE + entry->length - nalStart) - 1;
-
-        // Copy the NALU prefix over from the original SPS
-        memcpy(&m_DecodeBuffer.data()[initialOffset], entry->data, nalStart);
-        offset += nalStart;
+#ifndef QT_DEBUG
+        else {
+            // Write the SPS as-is if it required no modification
+            memcpy(&m_DecodeBuffer.data()[offset],
+                   entry->data,
+                   entry->length);
+            offset += entry->length;
+        }
+#endif
 
         h264_free(stream);
     }
@@ -1910,6 +1946,74 @@ void FFmpegVideoDecoder::decoderThreadProc()
                         }
                     }
 
+                    // Some decoders don't propagate color metadata from the bitstream,
+                    // so we will try to guess it here if it was unset.
+                    if (frame->color_range == AVCOL_RANGE_UNSPECIFIED) {
+                        switch (getDecoderColorRange()) {
+                        case COLOR_RANGE_LIMITED:
+                            frame->color_range = AVCOL_RANGE_MPEG;
+                            break;
+                        case COLOR_RANGE_FULL:
+                            frame->color_range = AVCOL_RANGE_JPEG;
+                            break;
+                        }
+                    }
+                    if (frame->colorspace == AVCOL_SPC_UNSPECIFIED) {
+                        switch (getDecoderColorspace()) {
+                        case COLORSPACE_REC_601:
+                            frame->colorspace = AVCOL_SPC_SMPTE170M;
+                            break;
+                        case COLORSPACE_REC_709:
+                            frame->colorspace = AVCOL_SPC_BT709;
+                            break;
+                        case COLORSPACE_REC_2020:
+                            frame->colorspace = AVCOL_SPC_BT2020_NCL;
+                            break;
+                        }
+
+                        // HDR forces BT.2020 regardless of decoder preference
+                        if (LiGetCurrentHostDisplayHdrMode()) {
+                            frame->colorspace = AVCOL_SPC_BT2020_NCL;
+                        }
+                    }
+                    if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED) {
+                        switch (frame->colorspace) {
+                        case AVCOL_SPC_BT709:
+                            frame->color_primaries = AVCOL_PRI_BT709;
+                            break;
+                        case AVCOL_SPC_SMPTE170M:
+                            frame->color_primaries = AVCOL_PRI_SMPTE170M;
+                            break;
+                        case AVCOL_SPC_BT2020_NCL:
+                        case AVCOL_SPC_BT2020_CL:
+                            frame->color_primaries = AVCOL_PRI_BT2020;
+                            break;
+                        default:
+                            break;
+                        }
+                    }
+                    if (frame->color_trc == AVCOL_TRC_UNSPECIFIED) {
+                        switch (frame->colorspace) {
+                        case AVCOL_SPC_BT709:
+                            frame->color_trc = AVCOL_TRC_BT709;
+                            break;
+                        case AVCOL_SPC_SMPTE170M:
+                            frame->color_trc = AVCOL_TRC_SMPTE170M;
+                            break;
+                        case AVCOL_SPC_BT2020_NCL:
+                        case AVCOL_SPC_BT2020_CL:
+                            frame->color_trc = AVCOL_TRC_BT2020_10;
+                            break;
+                        default:
+                            break;
+                        }
+
+                        // HDR forces SMPTE 2084 PQ regardless of decoder preference
+                        if (LiGetCurrentHostDisplayHdrMode()) {
+                            frame->color_trc = AVCOL_TRC_SMPTE2084;
+                        }
+                    }
+
                     // Reset failed decodes count if we reached this far
                     m_ConsecutiveFailedDecodes = 0;
 

app/streaming/video/ffmpeg.h

@@ -86,7 +86,7 @@ private:
                                IFFmpegRenderer::InitFailureReason* failureReason,
                                std::function<IFFmpegRenderer*()> createRendererFunc);
 
-    static IFFmpegRenderer* createHwAccelRenderer(const AVCodecHWConfig* hwDecodeCfg, int pass);
+    static IFFmpegRenderer* createHwAccelRenderer(const AVCodecHWConfig* hwDecodeCfg, PDECODER_PARAMETERS params, int pass);
 
     bool initializeRendererInternal(IFFmpegRenderer* renderer, PDECODER_PARAMETERS params);
 

app/version.txt

@@ -1 +1 @@
-6.1.0
+6.2.0

h264bitstream/LICENSE

@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+

h264bitstream/bs.h

@@ -0,0 +1,301 @@
+/*
+ * h264bitstream - a library for reading and writing H.264 video
+ * Copyright (C) 2005-2007 Auroras Entertainment, LLC
+ * Copyright (C) 2008-2011 Avail-TVN
+ *
+ * Written by Alex Izvorski <aizvorski@gmail.com> and Alex Giladi <alex.giladi@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef _H264_BS_H
+#define _H264_BS_H        1
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+	uint8_t* start;
+	uint8_t* p;
+	uint8_t* end;
+	int bits_left;
+} bs_t;
+
+#define _OPTIMIZE_BS_ 1
+
+#if ( _OPTIMIZE_BS_ > 0 )
+#ifndef FAST_U8
+#define FAST_U8
+#endif
+#endif
+
+static bs_t* bs_new(uint8_t* buf, size_t size);
+static void bs_free(bs_t* b);
+static bs_t*  bs_init(bs_t* b, uint8_t* buf, size_t size);
+static uint32_t bs_byte_aligned(bs_t* b);
+static int bs_eof(bs_t* b);
+static int bs_overrun(bs_t* b);
+static int bs_pos(bs_t* b);
+
+static uint32_t bs_read_u1(bs_t* b);
+static void bs_skip_u1(bs_t* b);
+static uint32_t bs_read_u(bs_t* b, int n);
+static void bs_skip_u(bs_t* b, int n);
+static uint32_t bs_read_u8(bs_t* b);
+static uint32_t bs_read_ue(bs_t* b);
+static int32_t  bs_read_se(bs_t* b);
+
+static void bs_write_u1(bs_t* b, uint32_t v);
+static void bs_write_u(bs_t* b, int n, uint32_t v);
+static void bs_write_u8(bs_t* b, uint32_t v);
+static void bs_write_ue(bs_t* b, uint32_t v);
+static void bs_write_se(bs_t* b, int32_t v);
+
+// IMPLEMENTATION
+
+static inline bs_t* bs_init(bs_t* b, uint8_t* buf, size_t size)
+{
+    b->start = buf;
+    b->p = buf;
+    b->end = buf + size;
+    b->bits_left = 8;
+    return b;
+}
+
+static inline bs_t* bs_new(uint8_t* buf, size_t size)
+{
+    bs_t* b = (bs_t*)malloc(sizeof(bs_t));
+    bs_init(b, buf, size);
+    return b;
+}
+
+static inline void bs_free(bs_t* b)
+{
+    free(b);
+}
+
+static inline uint32_t bs_byte_aligned(bs_t* b)
+{
+    return (b->bits_left == 8);
+}
+
+static inline int bs_eof(bs_t* b) { if (b->p >= b->end) { return 1; } else { return 0; } }
+
+static inline int bs_overrun(bs_t* b) { if (b->p > b->end) { return 1; } else { return 0; } }
+
+static inline int bs_pos(bs_t* b) { if (b->p > b->end) { return (b->end - b->start); } else { return (b->p - b->start); } }
+
+static inline uint32_t bs_read_u1(bs_t* b)
+{
+    uint32_t r = 0;
+
+    b->bits_left--;
+
+    if (! bs_eof(b))
+    {
+        r = ((*(b->p)) >> b->bits_left) & 0x01;
+    }
+
+    if (b->bits_left == 0) { b->p ++; b->bits_left = 8; }
+
+    return r;
+}
+
+static inline void bs_skip_u1(bs_t* b)
+{
+    b->bits_left--;
+    if (b->bits_left == 0) { b->p ++; b->bits_left = 8; }
+}
+
+static inline uint32_t bs_read_u(bs_t* b, int n)
+{
+    uint32_t r = 0;
+    int i;
+    for (i = 0; i < n; i++)
+    {
+        r |= ( bs_read_u1(b) << ( n - i - 1 ) );
+    }
+    return r;
+}
+
+static inline void bs_skip_u(bs_t* b, int n)
+{
+    int i;
+    for ( i = 0; i < n; i++ )
+    {
+        bs_skip_u1( b );
+    }
+}
+
+static inline uint32_t bs_read_u8(bs_t* b)
+{
+#ifdef FAST_U8
+    if (b->bits_left == 8 && ! bs_eof(b)) // can do fast read
+    {
+        uint32_t r = b->p[0];
+        b->p++;
+        return r;
+    }
+#endif
+    return bs_read_u(b, 8);
+}
+
+static inline uint32_t bs_read_ue(bs_t* b)
+{
+    uint32_t r = 0;
+    int i = 0;
+
+    while (!bs_eof(b) && (i < 32) && (bs_read_u1(b) == 0))
+    {
+        i++;
+    }
+    if (i >= 32)
+    {
+        return 0;
+    }
+    r = bs_read_u(b, i);
+    r += (1U << i) - 1U;
+    return r;
+}
+
+static inline int32_t bs_read_se(bs_t* b)
+{
+    int32_t r = bs_read_ue(b);
+    if (r & 0x01)
+    {
+        r = (r+1)/2;
+    }
+    else
+    {
+        r = -(r/2);
+    }
+    return r;
+}
+
+static inline void bs_write_u1(bs_t* b, uint32_t v)
+{
+    b->bits_left--;
+
+    if (! bs_eof(b))
+    {
+        (*(b->p)) &= ~(0x01 << b->bits_left);
+        (*(b->p)) |= ((v & 0x01) << b->bits_left);
+    }
+
+    if (b->bits_left == 0) { b->p ++; b->bits_left = 8; }
+}
+
+static inline void bs_write_u(bs_t* b, int n, uint32_t v)
+{
+    int i;
+    for (i = 0; i < n; i++)
+    {
+        bs_write_u1(b, (v >> ( n - i - 1 ))&0x01 );
+    }
+}
+
+static inline void bs_write_u8(bs_t* b, uint32_t v)
+{
+#ifdef FAST_U8
+    if (b->bits_left == 8 && ! bs_eof(b)) // can do fast write
+    {
+        b->p[0] = v;
+        b->p++;
+        return;
+    }
+#endif
+    bs_write_u(b, 8, v);
+}
+
+static inline void bs_write_ue(bs_t* b, uint32_t v)
+{
+    static const int len_table[256] =
+    {
+        1,
+        1,
+        2,2,
+        3,3,3,3,
+        4,4,4,4,4,4,4,4,
+        5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+        6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+        6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+    };
+
+    int len;
+
+    if (v == 0)
+    {
+        bs_write_u1(b, 1);
+    }
+    else
+    {
+        v++;
+
+        if (v >= 0x01000000)
+        {
+            len = 24 + len_table[ v >> 24 ];
+        }
+        else if(v >= 0x00010000)
+        {
+            len = 16 + len_table[ v >> 16 ];
+        }
+        else if(v >= 0x00000100)
+        {
+            len =  8 + len_table[ v >>  8 ];
+        }
+        else
+        {
+            len = len_table[ v ];
+        }
+
+        bs_write_u(b, 2*len-1, v);
+    }
+}
+
+static inline void bs_write_se(bs_t* b, int32_t v)
+{
+    if (v <= 0)
+    {
+        bs_write_ue(b, (~(uint32_t)v + 1) * 2);
+    }
+    else
+    {
+        bs_write_ue(b, ((uint32_t)v) * 2 - 1);
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

h264bitstream/h264_nal.c

@@ -0,0 +1,173 @@
+/*
+ * h264bitstream - a library for reading and writing H.264 video
+ * Copyright (C) 2005-2007 Auroras Entertainment, LLC
+ * Copyright (C) 2008-2011 Avail-TVN
+ *
+ * Written by Alex Izvorski <aizvorski@gmail.com> and Alex Giladi <alex.giladi@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "h264_stream.h"
+
+h264_stream_t* h264_new()
+{
+    h264_stream_t* h = (h264_stream_t*)calloc(1, sizeof(h264_stream_t));
+    h->nal = (nal_t*)calloc(1, sizeof(nal_t));
+    h->sps = (sps_t*)calloc(1, sizeof(sps_t));
+    return h;
+}
+
+void h264_free(h264_stream_t* h)
+{
+    free(h->nal);
+    free(h->sps);
+    free(h);
+}
+
+int find_nal_unit(uint8_t* buf, int size, int* nal_start, int* nal_end)
+{
+    int i;
+    *nal_start = 0;
+    *nal_end = 0;
+
+    i = 0;
+    while (
+        (i + 2 < size) &&
+        (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01) &&
+        (i + 3 >= size || buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0 || buf[i+3] != 0x01)
+        )
+    {
+        i++;
+    }
+
+    if (i + 2 >= size) { return 0; }
+
+    if (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01)
+    {
+        i++;
+    }
+
+    if (i + 2 >= size || buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01) { return 0; }
+    i += 3;
+    *nal_start = i;
+
+    while (
+        (i + 2 < size) &&
+        (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0) &&
+        (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01)
+        )
+    {
+        i++;
+    }
+
+    if (i + 2 >= size) { *nal_end = size; return (*nal_end - *nal_start); }
+
+    *nal_end = i;
+    return (*nal_end - *nal_start);
+}
+
+int rbsp_to_nal(const uint8_t* rbsp_buf, const int* rbsp_size, uint8_t* nal_buf, int* nal_size)
+{
+    int i;
+    int j     = 1;
+    int count = 0;
+
+    if (*nal_size > 0) { nal_buf[0] = 0x00; }
+
+    for ( i = 0; i < *rbsp_size ; )
+    {
+        if ( j >= *nal_size )
+        {
+            return -1;
+        }
+
+        if ( ( count == 2 ) && !(rbsp_buf[i] & 0xFC) )
+        {
+            nal_buf[j] = 0x03;
+            j++;
+            count = 0;
+            continue;
+        }
+        nal_buf[j] = rbsp_buf[i];
+        if ( rbsp_buf[i] == 0x00 )
+        {
+            count++;
+        }
+        else
+        {
+            count = 0;
+        }
+        i++;
+        j++;
+    }
+
+    *nal_size = j;
+    return j;
+}
+
+int nal_to_rbsp(const uint8_t* nal_buf, int* nal_size, uint8_t* rbsp_buf, int* rbsp_size)
+{
+    int i;
+    int j     = 0;
+    int count = 0;
+
+    for( i = 0; i < *nal_size; i++ )
+    {
+        if( ( count == 2 ) && ( nal_buf[i] < 0x03) )
+        {
+            return -1;
+        }
+
+        if( ( count == 2 ) && ( nal_buf[i] == 0x03) )
+        {
+            if((i < *nal_size - 1) && (nal_buf[i+1] > 0x03))
+            {
+                return -1;
+            }
+
+            if(i == *nal_size - 1)
+            {
+                break;
+            }
+
+            i++;
+            count = 0;
+        }
+
+        if ( j >= *rbsp_size )
+        {
+            return -1;
+        }
+
+        rbsp_buf[j] = nal_buf[i];
+        if(nal_buf[i] == 0x00)
+        {
+            count++;
+        }
+        else
+        {
+            count = 0;
+        }
+        j++;
+    }
+
+    *nal_size = i;
+    *rbsp_size = j;
+    return j;
+}

h264bitstream/h264_stream.c

@@ -0,0 +1,555 @@
+/*
+ * h264bitstream - a library for reading and writing H.264 video
+ * Copyright (C) 2005-2007 Auroras Entertainment, LLC
+ * Copyright (C) 2008-2011 Avail-TVN
+ * Copyright (C) 2012 Alex Izvorski
+ *
+ * Written by Alex Izvorski <aizvorski@gmail.com> and Alex Giladi <alex.giladi@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "bs.h"
+#include "h264_stream.h"
+
+int read_nal_unit(h264_stream_t* h, uint8_t* buf, int size)
+{
+    nal_t* nal = h->nal;
+
+    int nal_size = size;
+    int rbsp_size = size;
+    uint8_t* rbsp_buf = (uint8_t*)calloc(1, rbsp_size);
+
+    int rc = nal_to_rbsp(buf, &nal_size, rbsp_buf, &rbsp_size);
+    if (rc < 0) { free(rbsp_buf); return -1; }
+
+    bs_t* b = bs_new(rbsp_buf, rbsp_size);
+    bs_skip_u(b, 1);
+    nal->nal_ref_idc = bs_read_u(b, 2);
+    nal->nal_unit_type = bs_read_u(b, 5);
+
+    if (nal->nal_unit_type == NAL_UNIT_TYPE_SPS)
+    {
+        read_seq_parameter_set_rbsp(h->sps, b);
+        read_rbsp_trailing_bits(b);
+    }
+    else
+    {
+        bs_free(b);
+        free(rbsp_buf);
+        return -1;
+    }
+
+    if (bs_overrun(b)) { bs_free(b); free(rbsp_buf); return -1; }
+
+    bs_free(b);
+    free(rbsp_buf);
+
+    return nal_size;
+}
+
+void read_seq_parameter_set_rbsp(sps_t* sps, bs_t* b)
+{
+    int i;
+
+    memset(sps, 0, sizeof(sps_t));
+    sps->chroma_format_idc = 1;
+
+    sps->profile_idc = bs_read_u8(b);
+    sps->constraint_set0_flag = bs_read_u1(b);
+    sps->constraint_set1_flag = bs_read_u1(b);
+    sps->constraint_set2_flag = bs_read_u1(b);
+    sps->constraint_set3_flag = bs_read_u1(b);
+    sps->constraint_set4_flag = bs_read_u1(b);
+    sps->constraint_set5_flag = bs_read_u1(b);
+    bs_skip_u(b, 2);
+    sps->level_idc = bs_read_u8(b);
+    sps->seq_parameter_set_id = bs_read_ue(b);
+
+    if( sps->profile_idc == 100 || sps->profile_idc == 110 ||
+        sps->profile_idc == 122 || sps->profile_idc == 244 ||
+        sps->profile_idc == 44 || sps->profile_idc == 83 ||
+        sps->profile_idc == 86 || sps->profile_idc == 118 ||
+        sps->profile_idc == 128 || sps->profile_idc == 138 ||
+        sps->profile_idc == 139 || sps->profile_idc == 134
+       )
+    {
+        sps->chroma_format_idc = bs_read_ue(b);
+        if( sps->chroma_format_idc == 3 )
+        {
+            sps->residual_colour_transform_flag = bs_read_u1(b);
+        }
+        sps->bit_depth_luma_minus8 = bs_read_ue(b);
+        sps->bit_depth_chroma_minus8 = bs_read_ue(b);
+        sps->qpprime_y_zero_transform_bypass_flag = bs_read_u1(b);
+        sps->seq_scaling_matrix_present_flag = bs_read_u1(b);
+        if( sps->seq_scaling_matrix_present_flag )
+        {
+            for( i = 0; i < ((sps->chroma_format_idc != 3) ? 8 : 12); i++ )
+            {
+                sps->seq_scaling_list_present_flag[ i ] = bs_read_u1(b);
+                if( sps->seq_scaling_list_present_flag[ i ] )
+                {
+                    if( i < 6 )
+                    {
+                        read_scaling_list( b, sps->ScalingList4x4[ i ], 16,
+                                                 &( sps->UseDefaultScalingMatrix4x4Flag[ i ] ) );
+                    }
+                    else
+                    {
+                        read_scaling_list( b, sps->ScalingList8x8[ i - 6 ], 64,
+                                                 &( sps->UseDefaultScalingMatrix8x8Flag[ i - 6 ] ) );
+                    }
+                }
+            }
+        }
+    }
+    sps->log2_max_frame_num_minus4 = bs_read_ue(b);
+    sps->pic_order_cnt_type = bs_read_ue(b);
+    if( sps->pic_order_cnt_type == 0 )
+    {
+        sps->log2_max_pic_order_cnt_lsb_minus4 = bs_read_ue(b);
+    }
+    else if( sps->pic_order_cnt_type == 1 )
+    {
+        sps->delta_pic_order_always_zero_flag = bs_read_u1(b);
+        sps->offset_for_non_ref_pic = bs_read_se(b);
+        sps->offset_for_top_to_bottom_field = bs_read_se(b);
+        sps->num_ref_frames_in_pic_order_cnt_cycle = bs_read_ue(b);
+        if (sps->num_ref_frames_in_pic_order_cnt_cycle > 256)
+        {
+            sps->num_ref_frames_in_pic_order_cnt_cycle = 256;
+        }
+        for( i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; i++ )
+        {
+            sps->offset_for_ref_frame[ i ] = bs_read_se(b);
+        }
+    }
+    sps->num_ref_frames = bs_read_ue(b);
+    sps->gaps_in_frame_num_value_allowed_flag = bs_read_u1(b);
+    sps->pic_width_in_mbs_minus1 = bs_read_ue(b);
+    sps->pic_height_in_map_units_minus1 = bs_read_ue(b);
+    sps->frame_mbs_only_flag = bs_read_u1(b);
+    if( !sps->frame_mbs_only_flag )
+    {
+        sps->mb_adaptive_frame_field_flag = bs_read_u1(b);
+    }
+    sps->direct_8x8_inference_flag = bs_read_u1(b);
+    sps->frame_cropping_flag = bs_read_u1(b);
+    if( sps->frame_cropping_flag )
+    {
+        sps->frame_crop_left_offset = bs_read_ue(b);
+        sps->frame_crop_right_offset = bs_read_ue(b);
+        sps->frame_crop_top_offset = bs_read_ue(b);
+        sps->frame_crop_bottom_offset = bs_read_ue(b);
+    }
+    sps->vui_parameters_present_flag = bs_read_u1(b);
+    if( sps->vui_parameters_present_flag )
+    {
+        read_vui_parameters(sps, b);
+    }
+}
+
+void read_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int* useDefaultScalingMatrixFlag )
+{
+    int lastScale = 8;
+    int nextScale = 8;
+    int delta_scale;
+    for( int j = 0; j < sizeOfScalingList; j++ )
+    {
+        if( nextScale != 0 )
+        {
+            delta_scale = bs_read_se(b);
+            nextScale = ( lastScale + delta_scale + 256 ) % 256;
+            useDefaultScalingMatrixFlag[0] = ( j == 0 && nextScale == 0 );
+        }
+        scalingList[ j ] = ( nextScale == 0 ) ? lastScale : nextScale;
+        lastScale = scalingList[ j ];
+    }
+}
+
+void read_vui_parameters(sps_t* sps, bs_t* b)
+{
+    sps->vui.aspect_ratio_info_present_flag = bs_read_u1(b);
+    if( sps->vui.aspect_ratio_info_present_flag )
+    {
+        sps->vui.aspect_ratio_idc = bs_read_u8(b);
+        if( sps->vui.aspect_ratio_idc == SAR_Extended )
+        {
+            sps->vui.sar_width = bs_read_u(b, 16);
+            sps->vui.sar_height = bs_read_u(b, 16);
+        }
+    }
+    sps->vui.overscan_info_present_flag = bs_read_u1(b);
+    if( sps->vui.overscan_info_present_flag )
+    {
+        sps->vui.overscan_appropriate_flag = bs_read_u1(b);
+    }
+    sps->vui.video_signal_type_present_flag = bs_read_u1(b);
+    if( sps->vui.video_signal_type_present_flag )
+    {
+        sps->vui.video_format = bs_read_u(b, 3);
+        sps->vui.video_full_range_flag = bs_read_u1(b);
+        sps->vui.colour_description_present_flag = bs_read_u1(b);
+        if( sps->vui.colour_description_present_flag )
+        {
+            sps->vui.colour_primaries = bs_read_u8(b);
+            sps->vui.transfer_characteristics = bs_read_u8(b);
+            sps->vui.matrix_coefficients = bs_read_u8(b);
+        }
+    }
+    sps->vui.chroma_loc_info_present_flag = bs_read_u1(b);
+    if( sps->vui.chroma_loc_info_present_flag )
+    {
+        sps->vui.chroma_sample_loc_type_top_field = bs_read_ue(b);
+        sps->vui.chroma_sample_loc_type_bottom_field = bs_read_ue(b);
+    }
+    sps->vui.timing_info_present_flag = bs_read_u1(b);
+    if( sps->vui.timing_info_present_flag )
+    {
+        sps->vui.num_units_in_tick = bs_read_u(b, 32);
+        sps->vui.time_scale = bs_read_u(b, 32);
+        sps->vui.fixed_frame_rate_flag = bs_read_u1(b);
+    }
+    sps->vui.nal_hrd_parameters_present_flag = bs_read_u1(b);
+    if( sps->vui.nal_hrd_parameters_present_flag )
+    {
+        read_hrd_parameters(&sps->hrd_nal, b);
+    }
+    sps->vui.vcl_hrd_parameters_present_flag = bs_read_u1(b);
+    if( sps->vui.vcl_hrd_parameters_present_flag )
+    {
+        read_hrd_parameters(&sps->hrd_vcl, b);
+    }
+    if( sps->vui.nal_hrd_parameters_present_flag || sps->vui.vcl_hrd_parameters_present_flag )
+    {
+        sps->vui.low_delay_hrd_flag = bs_read_u1(b);
+    }
+    sps->vui.pic_struct_present_flag = bs_read_u1(b);
+    sps->vui.bitstream_restriction_flag = bs_read_u1(b);
+    if( sps->vui.bitstream_restriction_flag )
+    {
+        sps->vui.motion_vectors_over_pic_boundaries_flag = bs_read_u1(b);
+        sps->vui.max_bytes_per_pic_denom = bs_read_ue(b);
+        sps->vui.max_bits_per_mb_denom = bs_read_ue(b);
+        sps->vui.log2_max_mv_length_horizontal = bs_read_ue(b);
+        sps->vui.log2_max_mv_length_vertical = bs_read_ue(b);
+        sps->vui.num_reorder_frames = bs_read_ue(b);
+        sps->vui.max_dec_frame_buffering = bs_read_ue(b);
+    }
+}
+
+void read_hrd_parameters(hrd_t* hrd, bs_t* b)
+{
+    hrd->cpb_cnt_minus1 = bs_read_ue(b);
+    if (hrd->cpb_cnt_minus1 > 31)
+    {
+        hrd->cpb_cnt_minus1 = 31;
+    }
+    hrd->bit_rate_scale = bs_read_u(b, 4);
+    hrd->cpb_size_scale = bs_read_u(b, 4);
+    for( int SchedSelIdx = 0; SchedSelIdx <= hrd->cpb_cnt_minus1; SchedSelIdx++ )
+    {
+        hrd->bit_rate_value_minus1[ SchedSelIdx ] = bs_read_ue(b);
+        hrd->cpb_size_value_minus1[ SchedSelIdx ] = bs_read_ue(b);
+        hrd->cbr_flag[ SchedSelIdx ] = bs_read_u1(b);
+    }
+    hrd->initial_cpb_removal_delay_length_minus1 = bs_read_u(b, 5);
+    hrd->cpb_removal_delay_length_minus1 = bs_read_u(b, 5);
+    hrd->dpb_output_delay_length_minus1 = bs_read_u(b, 5);
+    hrd->time_offset_length = bs_read_u(b, 5);
+}
+
+void read_rbsp_trailing_bits(bs_t* b)
+{
+    bs_skip_u(b, 1);
+
+    while( !bs_byte_aligned(b) )
+    {
+        bs_skip_u(b, 1);
+    }
+}
+
+int write_nal_unit(h264_stream_t* h, uint8_t* buf, int size)
+{
+    nal_t* nal = h->nal;
+
+    int nal_size = size;
+    int rbsp_size = size;
+    uint8_t* rbsp_buf = (uint8_t*)calloc(1, rbsp_size);
+
+    bs_t* b = bs_new(rbsp_buf, rbsp_size);
+    bs_write_u(b, 1, 0);
+    bs_write_u(b, 2, nal->nal_ref_idc);
+    bs_write_u(b, 5, nal->nal_unit_type);
+
+    if( nal->nal_unit_type == NAL_UNIT_TYPE_SPS )
+    {
+        write_seq_parameter_set_rbsp(h->sps, b);
+        write_rbsp_trailing_bits(b);
+    }
+    else
+    {
+        bs_free(b);
+        free(rbsp_buf);
+        return -1;
+    }
+
+    if (bs_overrun(b)) { bs_free(b); free(rbsp_buf); return -1; }
+
+    rbsp_size = bs_pos(b);
+    int rc = rbsp_to_nal(rbsp_buf, &rbsp_size, buf, &nal_size);
+    if (rc < 0) { bs_free(b); free(rbsp_buf); return -1; }
+
+    bs_free(b);
+    free(rbsp_buf);
+
+    return nal_size;
+}
+
+void write_seq_parameter_set_rbsp(sps_t* sps, bs_t* b)
+{
+    int i;
+
+    bs_write_u8(b, sps->profile_idc);
+    bs_write_u1(b, sps->constraint_set0_flag);
+    bs_write_u1(b, sps->constraint_set1_flag);
+    bs_write_u1(b, sps->constraint_set2_flag);
+    bs_write_u1(b, sps->constraint_set3_flag);
+    bs_write_u1(b, sps->constraint_set4_flag);
+    bs_write_u1(b, sps->constraint_set5_flag);
+    bs_write_u(b, 2, 0);
+    bs_write_u8(b, sps->level_idc);
+    bs_write_ue(b, sps->seq_parameter_set_id);
+
+    if( sps->profile_idc == 100 || sps->profile_idc == 110 ||
+        sps->profile_idc == 122 || sps->profile_idc == 244 ||
+        sps->profile_idc == 44 || sps->profile_idc == 83 ||
+        sps->profile_idc == 86 || sps->profile_idc == 118 ||
+        sps->profile_idc == 128 || sps->profile_idc == 138 ||
+        sps->profile_idc == 139 || sps->profile_idc == 134
+       )
+    {
+        bs_write_ue(b, sps->chroma_format_idc);
+        if( sps->chroma_format_idc == 3 )
+        {
+            bs_write_u1(b, sps->residual_colour_transform_flag);
+        }
+        bs_write_ue(b, sps->bit_depth_luma_minus8);
+        bs_write_ue(b, sps->bit_depth_chroma_minus8);
+        bs_write_u1(b, sps->qpprime_y_zero_transform_bypass_flag);
+        bs_write_u1(b, sps->seq_scaling_matrix_present_flag);
+        if( sps->seq_scaling_matrix_present_flag )
+        {
+            for( i = 0; i < ((sps->chroma_format_idc != 3) ? 8 : 12); i++ )
+            {
+                bs_write_u1(b, sps->seq_scaling_list_present_flag[ i ]);
+                if( sps->seq_scaling_list_present_flag[ i ] )
+                {
+                    if( i < 6 )
+                    {
+                        write_scaling_list( b, sps->ScalingList4x4[ i ], 16,
+                                                 &( sps->UseDefaultScalingMatrix4x4Flag[ i ] ) );
+                    }
+                    else
+                    {
+                        write_scaling_list( b, sps->ScalingList8x8[ i - 6 ], 64,
+                                                 &( sps->UseDefaultScalingMatrix8x8Flag[ i - 6 ] ) );
+                    }
+                }
+            }
+        }
+    }
+    bs_write_ue(b, sps->log2_max_frame_num_minus4);
+    bs_write_ue(b, sps->pic_order_cnt_type);
+    if( sps->pic_order_cnt_type == 0 )
+    {
+        bs_write_ue(b, sps->log2_max_pic_order_cnt_lsb_minus4);
+    }
+    else if( sps->pic_order_cnt_type == 1 )
+    {
+        bs_write_u1(b, sps->delta_pic_order_always_zero_flag);
+        bs_write_se(b, sps->offset_for_non_ref_pic);
+        bs_write_se(b, sps->offset_for_top_to_bottom_field);
+        bs_write_ue(b, sps->num_ref_frames_in_pic_order_cnt_cycle);
+        for( i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; i++ )
+        {
+            bs_write_se(b, sps->offset_for_ref_frame[ i ]);
+        }
+    }
+    bs_write_ue(b, sps->num_ref_frames);
+    bs_write_u1(b, sps->gaps_in_frame_num_value_allowed_flag);
+    bs_write_ue(b, sps->pic_width_in_mbs_minus1);
+    bs_write_ue(b, sps->pic_height_in_map_units_minus1);
+    bs_write_u1(b, sps->frame_mbs_only_flag);
+    if( !sps->frame_mbs_only_flag )
+    {
+        bs_write_u1(b, sps->mb_adaptive_frame_field_flag);
+    }
+    bs_write_u1(b, sps->direct_8x8_inference_flag);
+    bs_write_u1(b, sps->frame_cropping_flag);
+    if( sps->frame_cropping_flag )
+    {
+        bs_write_ue(b, sps->frame_crop_left_offset);
+        bs_write_ue(b, sps->frame_crop_right_offset);
+        bs_write_ue(b, sps->frame_crop_top_offset);
+        bs_write_ue(b, sps->frame_crop_bottom_offset);
+    }
+    bs_write_u1(b, sps->vui_parameters_present_flag);
+    if( sps->vui_parameters_present_flag )
+    {
+        write_vui_parameters(sps, b);
+    }
+}
+
+void write_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int* useDefaultScalingMatrixFlag )
+{
+    int lastScale = 8;
+    int nextScale = 8;
+    int delta_scale;
+    for( int j = 0; j < sizeOfScalingList; j++ )
+    {
+        if( nextScale != 0 )
+        {
+            if (useDefaultScalingMatrixFlag[0]) {
+                nextScale = 0;
+            } else {
+                nextScale = scalingList[ j ];
+                if (j > 0 && nextScale == lastScale) {
+                    int all_same = 1;
+                    for (int k = j + 1; k < sizeOfScalingList; k++) {
+                        if (scalingList[k] != lastScale) {
+                            all_same = 0;
+                            break;
+                        }
+                    }
+                    if (all_same) {
+                        nextScale = 0;
+                    }
+                }
+            }
+            delta_scale = nextScale - lastScale;
+            if (delta_scale < -128) {
+                delta_scale += 256;
+            } else if (delta_scale > 127) {
+                delta_scale -= 256;
+            }
+            bs_write_se(b, delta_scale);
+        }
+        lastScale = scalingList[ j ];
+    }
+}
+
+void write_vui_parameters(sps_t* sps, bs_t* b)
+{
+    bs_write_u1(b, sps->vui.aspect_ratio_info_present_flag);
+    if( sps->vui.aspect_ratio_info_present_flag )
+    {
+        bs_write_u8(b, sps->vui.aspect_ratio_idc);
+        if( sps->vui.aspect_ratio_idc == SAR_Extended )
+        {
+            bs_write_u(b, 16, sps->vui.sar_width);
+            bs_write_u(b, 16, sps->vui.sar_height);
+        }
+    }
+    bs_write_u1(b, sps->vui.overscan_info_present_flag);
+    if( sps->vui.overscan_info_present_flag )
+    {
+        bs_write_u1(b, sps->vui.overscan_appropriate_flag);
+    }
+    bs_write_u1(b, sps->vui.video_signal_type_present_flag);
+    if( sps->vui.video_signal_type_present_flag )
+    {
+        bs_write_u(b, 3, sps->vui.video_format);
+        bs_write_u1(b, sps->vui.video_full_range_flag);
+        bs_write_u1(b, sps->vui.colour_description_present_flag);
+        if( sps->vui.colour_description_present_flag )
+        {
+            bs_write_u8(b, sps->vui.colour_primaries);
+            bs_write_u8(b, sps->vui.transfer_characteristics);
+            bs_write_u8(b, sps->vui.matrix_coefficients);
+        }
+    }
+    bs_write_u1(b, sps->vui.chroma_loc_info_present_flag);
+    if( sps->vui.chroma_loc_info_present_flag )
+    {
+        bs_write_ue(b, sps->vui.chroma_sample_loc_type_top_field);
+        bs_write_ue(b, sps->vui.chroma_sample_loc_type_bottom_field);
+    }
+    bs_write_u1(b, sps->vui.timing_info_present_flag);
+    if( sps->vui.timing_info_present_flag )
+    {
+        bs_write_u(b, 32, sps->vui.num_units_in_tick);
+        bs_write_u(b, 32, sps->vui.time_scale);
+        bs_write_u1(b, sps->vui.fixed_frame_rate_flag);
+    }
+    bs_write_u1(b, sps->vui.nal_hrd_parameters_present_flag);
+    if( sps->vui.nal_hrd_parameters_present_flag )
+    {
+        write_hrd_parameters(&sps->hrd_nal, b);
+    }
+    bs_write_u1(b, sps->vui.vcl_hrd_parameters_present_flag);
+    if( sps->vui.vcl_hrd_parameters_present_flag )
+    {
+        write_hrd_parameters(&sps->hrd_vcl, b);
+    }
+    if( sps->vui.nal_hrd_parameters_present_flag || sps->vui.vcl_hrd_parameters_present_flag )
+    {
+        bs_write_u1(b, sps->vui.low_delay_hrd_flag);
+    }
+    bs_write_u1(b, sps->vui.pic_struct_present_flag);
+    bs_write_u1(b, sps->vui.bitstream_restriction_flag);
+    if( sps->vui.bitstream_restriction_flag )
+    {
+        bs_write_u1(b, sps->vui.motion_vectors_over_pic_boundaries_flag);
+        bs_write_ue(b, sps->vui.max_bytes_per_pic_denom);
+        bs_write_ue(b, sps->vui.max_bits_per_mb_denom);
+        bs_write_ue(b, sps->vui.log2_max_mv_length_horizontal);
+        bs_write_ue(b, sps->vui.log2_max_mv_length_vertical);
+        bs_write_ue(b, sps->vui.num_reorder_frames);
+        bs_write_ue(b, sps->vui.max_dec_frame_buffering);
+    }
+}
+
+void write_hrd_parameters(hrd_t* hrd, bs_t* b)
+{
+    bs_write_ue(b, hrd->cpb_cnt_minus1);
+    bs_write_u(b, 4, hrd->bit_rate_scale);
+    bs_write_u(b, 4, hrd->cpb_size_scale);
+    for( int SchedSelIdx = 0; SchedSelIdx <= hrd->cpb_cnt_minus1; SchedSelIdx++ )
+    {
+        bs_write_ue(b, hrd->bit_rate_value_minus1[ SchedSelIdx ]);
+        bs_write_ue(b, hrd->cpb_size_value_minus1[ SchedSelIdx ]);
+        bs_write_u1(b, hrd->cbr_flag[ SchedSelIdx ]);
+    }
+    bs_write_u(b, 5, hrd->initial_cpb_removal_delay_length_minus1);
+    bs_write_u(b, 5, hrd->cpb_removal_delay_length_minus1);
+    bs_write_u(b, 5, hrd->dpb_output_delay_length_minus1);
+    bs_write_u(b, 5, hrd->time_offset_length);
+}
+
+void write_rbsp_trailing_bits(bs_t* b)
+{
+    bs_write_u(b, 1, 1);
+
+    while( !bs_byte_aligned(b) )
+    {
+        bs_write_u(b, 1, 0);
+    }
+}

h264bitstream/h264_stream.h

@@ -0,0 +1,176 @@
+/*
+ * h264bitstream - a library for reading and writing H.264 video
+ * Copyright (C) 2005-2007 Auroras Entertainment, LLC
+ * Copyright (C) 2008-2011 Avail-TVN
+ *
+ * Written by Alex Izvorski <aizvorski@gmail.com> and Alex Giladi <alex.giladi@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef _H264_STREAM_H
+#define _H264_STREAM_H        1
+
+#include <stdint.h>
+
+#include "bs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+    int cpb_cnt_minus1;
+    int bit_rate_scale;
+    int cpb_size_scale;
+    int bit_rate_value_minus1[32];
+    int cpb_size_value_minus1[32];
+    int cbr_flag[32];
+    int initial_cpb_removal_delay_length_minus1;
+    int cpb_removal_delay_length_minus1;
+    int dpb_output_delay_length_minus1;
+    int time_offset_length;
+} hrd_t;
+
+typedef struct
+{
+    int profile_idc;
+    int constraint_set0_flag;
+    int constraint_set1_flag;
+    int constraint_set2_flag;
+    int constraint_set3_flag;
+    int constraint_set4_flag;
+    int constraint_set5_flag;
+    int reserved_zero_2bits;
+    int level_idc;
+    int seq_parameter_set_id;
+    int chroma_format_idc;
+    int residual_colour_transform_flag;
+    int bit_depth_luma_minus8;
+    int bit_depth_chroma_minus8;
+    int qpprime_y_zero_transform_bypass_flag;
+    int seq_scaling_matrix_present_flag;
+      int seq_scaling_list_present_flag[12];
+      int ScalingList4x4[6][16];
+      int UseDefaultScalingMatrix4x4Flag[6];
+      int ScalingList8x8[6][64];
+      int UseDefaultScalingMatrix8x8Flag[6];
+    int log2_max_frame_num_minus4;
+    int pic_order_cnt_type;
+    int log2_max_pic_order_cnt_lsb_minus4;
+    int delta_pic_order_always_zero_flag;
+    int offset_for_non_ref_pic;
+    int offset_for_top_to_bottom_field;
+    int num_ref_frames_in_pic_order_cnt_cycle;
+    int offset_for_ref_frame[256];
+    int num_ref_frames;
+    int gaps_in_frame_num_value_allowed_flag;
+    int pic_width_in_mbs_minus1;
+    int pic_height_in_map_units_minus1;
+    int frame_mbs_only_flag;
+    int mb_adaptive_frame_field_flag;
+    int direct_8x8_inference_flag;
+    int frame_cropping_flag;
+    int frame_crop_left_offset;
+    int frame_crop_right_offset;
+    int frame_crop_top_offset;
+    int frame_crop_bottom_offset;
+    int vui_parameters_present_flag;
+
+    struct
+    {
+        int aspect_ratio_info_present_flag;
+        int aspect_ratio_idc;
+        int sar_width;
+        int sar_height;
+        int overscan_info_present_flag;
+        int overscan_appropriate_flag;
+        int video_signal_type_present_flag;
+        int video_format;
+        int video_full_range_flag;
+        int colour_description_present_flag;
+        int colour_primaries;
+        int transfer_characteristics;
+        int matrix_coefficients;
+        int chroma_loc_info_present_flag;
+        int chroma_sample_loc_type_top_field;
+        int chroma_sample_loc_type_bottom_field;
+        int timing_info_present_flag;
+        int num_units_in_tick;
+        int time_scale;
+        int fixed_frame_rate_flag;
+        int nal_hrd_parameters_present_flag;
+        int vcl_hrd_parameters_present_flag;
+        int low_delay_hrd_flag;
+        int pic_struct_present_flag;
+        int bitstream_restriction_flag;
+        int motion_vectors_over_pic_boundaries_flag;
+        int max_bytes_per_pic_denom;
+        int max_bits_per_mb_denom;
+        int log2_max_mv_length_horizontal;
+        int log2_max_mv_length_vertical;
+        int num_reorder_frames;
+        int max_dec_frame_buffering;
+    } vui;
+
+    hrd_t hrd_nal;
+    hrd_t hrd_vcl;
+
+} sps_t;
+
+typedef struct
+{
+    int nal_ref_idc;
+    int nal_unit_type;
+} nal_t;
+
+typedef struct
+{
+    nal_t* nal;
+    sps_t* sps;
+} h264_stream_t;
+
+h264_stream_t* h264_new();
+void h264_free(h264_stream_t* h);
+
+int find_nal_unit(uint8_t* buf, int size, int* nal_start, int* nal_end);
+
+int rbsp_to_nal(const uint8_t* rbsp_buf, const int* rbsp_size, uint8_t* nal_buf, int* nal_size);
+int nal_to_rbsp(const uint8_t* nal_buf, int* nal_size, uint8_t* rbsp_buf, int* rbsp_size);
+
+int read_nal_unit(h264_stream_t* h, uint8_t* buf, int size);
+int write_nal_unit(h264_stream_t* h, uint8_t* buf, int size);
+
+void read_seq_parameter_set_rbsp(sps_t* sps, bs_t* b);
+void read_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int* useDefaultScalingMatrixFlag);
+void read_vui_parameters(sps_t* sps, bs_t* b);
+void read_hrd_parameters(hrd_t* hrd, bs_t* b);
+void read_rbsp_trailing_bits(bs_t* b);
+
+void write_seq_parameter_set_rbsp(sps_t* sps, bs_t* b);
+void write_scaling_list(bs_t* b, int* scalingList, int sizeOfScalingList, int* useDefaultScalingMatrixFlag);
+void write_vui_parameters(sps_t* sps, bs_t* b);
+void write_hrd_parameters(hrd_t* hrd, bs_t* b);
+void write_rbsp_trailing_bits(bs_t* b);
+
+#define NAL_UNIT_TYPE_SPS 7
+#define SAR_Extended 255
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

h264bitstream/h264bitstream.pro

@@ -24,16 +24,10 @@ include(../globaldefs.pri)
     QMAKE_CFLAGS += -std=gnu99
 }
 
-SRC_DIR = $$PWD/h264bitstream
-
 SOURCES += \
-    $$SRC_DIR/h264_nal.c            \
-    $$SRC_DIR/h264_sei.c            \
-    $$SRC_DIR/h264_stream.c
+    h264_nal.c \
+    h264_stream.c
 
 HEADERS += \
-    $$SRC_DIR/bs.h              \
-    $$SRC_DIR/h264_sei.h        \
-    $$SRC_DIR/h264_stream.h
-
-INCLUDEPATH += $$INC_DIR
+    bs.h \
+    h264_stream.h

scripts/build-appimage.sh

@@ -62,11 +62,81 @@ popd
 export QML_SOURCES_PATHS=$SOURCE_ROOT/app/gui
 export QMAKE=qmake6
 
+# Stage the build-environment libva in opt/libva-fallback (outside usr/, so linuxdeploy
+# does not scan it, and outside every loader search path), together with a small probe
+# binary that carries the same libva ELF requirements as Moonlight. The AppRun below
+# uses the probe to decide, via the dynamic loader itself, whether the host libva can
+# satisfy Moonlight; when it cannot, the fallback copy is made visible. opt/ is a
+# standard linuxdeploy location for application data that must not be processed.
+LIBVA_FALLBACK_DIR=$DEPLOY_FOLDER/opt/libva-fallback
+SYSTEM_LIBVA=$(ldconfig -p 2>/dev/null | awk '/libva\.so\.2/{print $NF; exit}')
+mkdir -p $LIBVA_FALLBACK_DIR
+if [ -n "$SYSTEM_LIBVA" ]; then
+  cp -a "$(dirname "$SYSTEM_LIBVA")"/libva*.so* $LIBVA_FALLBACK_DIR/ || fail "Unable to stage libva fallback copy!"
+
+  echo Compiling libva-probe
+  cc -O2 -L"$(dirname "$SYSTEM_LIBVA")" -Wl,--no-as-needed -o $LIBVA_FALLBACK_DIR/libva-probe \
+    $SOURCE_ROOT/app/deploy/linux/libva-probe.c -lva -lva-x11 || fail "Unable to compile libva-probe!"
+
+  # Keep the probe honest: it must reference every VA_API_* version node that the
+  # binaries shipped in the AppImage require, otherwise a host libva could pass the
+  # probe and still fail to load Moonlight or the bundled FFmpeg.
+  va_nodes() { LC_ALL=C readelf -V "$1" 2>/dev/null | grep -oE 'VA_API_[0-9]+\.[0-9]+\.[0-9]+' | sort -u; }
+  NEEDED_NODES=$(for b in $DEPLOY_FOLDER/usr/bin/moonlight \
+                          /usr/local/lib*/libav*.so* /usr/local/lib*/libsw*.so* \
+                          /usr/lib/x86_64-linux-gnu/libav*.so* /usr/lib/x86_64-linux-gnu/libsw*.so*; do
+                   [ -f "$b" ] && va_nodes "$b"; done | sort -u)
+  PROBE_NODES=$(va_nodes $LIBVA_FALLBACK_DIR/libva-probe)
+  [ -z "$(comm -13 <(echo "$PROBE_NODES") <(echo "$NEEDED_NODES"))" ] || \
+    fail "libva-probe is missing version node(s): $(comm -13 <(echo "$PROBE_NODES") <(echo "$NEEDED_NODES")) - update app/deploy/linux/libva-probe.c!"
+fi
+
+APP_RUN=$BUILD_ROOT/AppRun-libva
+cat > $APP_RUN <<'APPRUN_EOF'
+#!/bin/bash
+# AppRun: prefer the host libva; use the staged copy only if the host cannot run us.
+#
+# VA-API driver modules on the host are loaded by libva and export an entrypoint
+# named after the libva version they were built against (__vaDriverInit_1_XX).
+# A libva can only load drivers that are not newer than itself, so bundling our
+# own (older) libva silently breaks hardware decoding on up-to-date distros.
+# Distros keep host libva and host drivers in step, so whenever the host libva
+# can satisfy Moonlight's own ELF version requirements it is the right choice.
+#
+# "Can satisfy" is answered here by libva-probe, a tiny program linked against
+# the same versioned libva symbols as Moonlight and the bundled FFmpeg: if the
+# dynamic loader can start it, the host libva works; if not (no libva installed,
+# or one too old to link), we make the staged build-environment copy visible
+# via LD_LIBRARY_PATH, matching the pre-existing bundled behavior.
+APPDIR="${APPDIR:-$(dirname "$(readlink -f "$0")")}"
+LIBVA_FALLBACK="$APPDIR/opt/libva-fallback"
+
+if [ -d "$LIBVA_FALLBACK" ] && ! "$LIBVA_FALLBACK/libva-probe" 2>/dev/null; then
+    export LD_LIBRARY_PATH="$LIBVA_FALLBACK${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+    export VAAPI_USE_FALLBACK_PATHS=1
+fi
+
+exec "$APPDIR/usr/bin/moonlight" "$@"
+APPRUN_EOF
+chmod +x $APP_RUN
+
 echo Creating AppImage
 pushd $INSTALLER_FOLDER
+# Don't bundle libva: the bundled build-environment version (jammy: VA-API 1.20/1.22)
+# cannot dlopen GPU drivers compiled against newer libva on the host (which export
+# __vaDriverInit_1_23+), so va_openDriver() always fails and VAAPI falls back to
+# software decoding. The host always provides libva on systems where VA-API is
+# usable, so link against it at runtime instead (the AppRun shim above keeps a
+# bundled last-resort copy for hosts without libva).
 VERSION=$VERSION $LINUXDEPLOY --appdir $DEPLOY_FOLDER \
   --library=/usr/local/lib/libSDL3.so.0 \
-  --plugin qt --output appimage || fail "linuxdeploy failed!"
+  --plugin qt \
+  --custom-apprun $APP_RUN \
+  --exclude-library=libva.so* \
+  --exclude-library=libva-drm.so* \
+  --exclude-library=libva-wayland.so* \
+  --exclude-library=libva-x11.so* \
+  --output appimage || fail "linuxdeploy failed!"
 popd
 
 echo Build successful

scripts/build-arch.bat

@@ -26,6 +26,11 @@ if /I "%BUILD_CONFIG%"=="debug" (
                 exit /b 1
             )
 
+            if not defined SIGNTOOL_PARAMS (
+                echo A signtool parameter string must be specified in SIGNTOOL_PARAMS for signed release builds
+                exit /b 1
+            )
+
             echo Updating dependencies
             powershell %cd%\setup-deps.ps1
             if !ERRORLEVEL! NEQ 0 (
@@ -41,15 +46,15 @@ if /I "%BUILD_CONFIG%"=="debug" (
 
 rem Locate qmake and determine if we're using qmake.exe or (host-)qmake.bat
 rem (host-)qmake.bat is an ARM64 forwarder to the x64 version of qmake.exe
-where qmake.bat
+where /q qmake.bat
 if !ERRORLEVEL! EQU 0 (
     set QMAKE_CMD=call qmake.bat
 ) else (
-    where host-qmake.bat
+    where /q host-qmake.bat
     if !ERRORLEVEL! EQU 0 (
         set QMAKE_CMD=call host-qmake.bat
     ) else (
-        where qmake.exe
+        where /q qmake.exe
         if !ERRORLEVEL! EQU 0 (
             set QMAKE_CMD=qmake.exe
         ) else (
@@ -104,8 +109,6 @@ if not x%QT_PATH:_arm64=%==x%QT_PATH% (
 
 echo Detected target architecture: %ARCH%
 
-set SIGNTOOL_PARAMS=sign /tr http://timestamp.digicert.com /td sha256 /fd sha256 /sha1 8b9d0d682ad9459e54f05a79694bc10f9876e297 /v
-
 set BUILD_ROOT=%cd%\build
 set SOURCE_ROOT=%cd%
 set BUILD_FOLDER=%BUILD_ROOT%\build-%ARCH%-%BUILD_CONFIG%
@@ -134,7 +137,8 @@ if /I "%VC_ARCH%" NEQ "%PROCESSOR_ARCHITECTURE%" (
 )
 
 rem Find Visual Studio and run vcvarsall.bat
-set VSWHERE="%SOURCE_ROOT%\scripts\vswhere.exe"
+call "%SOURCE_ROOT%\scripts\find-vswhere.bat"
+if !ERRORLEVEL! NEQ 0 goto Error
 for /f "usebackq delims=" %%i in (`%VSWHERE% -latest -property installationPath`) do (
     call "%%i\VC\Auxiliary\Build\vcvarsall.bat" %VC_ARCH%
 )
@@ -142,6 +146,7 @@ if !ERRORLEVEL! NEQ 0 goto Error
 
 rem Find VC redistributable DLLs
 for /f "usebackq delims=" %%i in (`%VSWHERE% -latest -find VC\Redist\MSVC\*\%ARCH%\Microsoft.VC*.CRT`) do set VC_REDIST_DLL_PATH=%%i
+if !ERRORLEVEL! NEQ 0 goto Error
 
 echo Cleaning output directories
 rmdir /s /q %DEPLOY_FOLDER%
@@ -165,9 +170,30 @@ pushd %BUILD_FOLDER%
 if !ERRORLEVEL! NEQ 0 goto Error
 popd
 
+rem Locate jom.exe or fall back to nmake.exe
+where /q jom.exe
+if !ERRORLEVEL! EQU 0 (
+    set JOM_CMD=jom.exe
+) else if exist "%QT_PATH%\..\..\..\Tools\QtCreator\bin\jom\jom.exe" (
+    set JOM_CMD="%QT_PATH%\..\..\..\Tools\QtCreator\bin\jom\jom.exe"
+) else if exist "%QT_PATH%\..\..\..\Tools\QtCreator\bin\jom.exe" (
+    set JOM_CMD="%QT_PATH%\..\..\..\Tools\QtCreator\bin\jom.exe"
+) else if exist "%QT_PATH%\..\..\..\Tools\jom\jom.exe" (
+    set JOM_CMD="%QT_PATH%\..\..\..\Tools\jom\jom.exe"
+) else (
+    where /q nmake.exe
+    if !ERRORLEVEL! EQU 0 (
+        echo jom.exe not found. Falling back to nmake.exe.
+        set JOM_CMD=nmake.exe
+    ) else (
+        echo Unable to find jom.exe or nmake.exe!
+        goto Error
+    )
+)
+
 echo Compiling Moonlight in %BUILD_CONFIG% configuration
 pushd %BUILD_FOLDER%
-%SOURCE_ROOT%\scripts\jom.exe %BUILD_CONFIG%
+!JOM_CMD! %BUILD_CONFIG%
 if !ERRORLEVEL! NEQ 0 goto Error
 popd
 
@@ -254,7 +280,7 @@ if "%SIGN%"=="1" (
     for /r "%DEPLOY_FOLDER%" %%f in (*.dll *.exe) do (
         set FILES_TO_SIGN=!FILES_TO_SIGN! %%f
     )
-    signtool %SIGNTOOL_PARAMS% !FILES_TO_SIGN!
+    signtool sign %SIGNTOOL_PARAMS% !FILES_TO_SIGN!
     if !ERRORLEVEL! NEQ 0 goto Error
 )
 

scripts/find-vswhere.bat

@@ -0,0 +1,15 @@
+@echo off
+
+rem Search the PATH first, then well-known paths
+where /q vswhere.exe
+if %ERRORLEVEL% EQU 0 (
+    set VSWHERE=vswhere.exe
+) else if exist "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" (
+    set VSWHERE="%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe"
+) else if exist "%ProgramFiles%\Microsoft Visual Studio\Installer\vswhere.exe" (
+    set VSWHERE="%ProgramFiles%\Microsoft Visual Studio\Installer\vswhere.exe"
+) else (
+    exit /b 1
+)
+
+exit /b 0

scripts/generate-bundle.bat

@@ -25,6 +25,11 @@ if /I "%BUILD_CONFIG%"=="debug" (
                 echo Signed release builds must not have unstaged changes!
                 exit /b 1
             )
+
+            if not defined SIGNTOOL_PARAMS (
+                echo A signtool parameter string must be specified in SIGNTOOL_PARAMS for signed release builds
+                exit /b 1
+            )
         ) else (
             echo Invalid build configuration - expected 'debug' or 'release'
             exit /b 1
@@ -32,8 +37,6 @@ if /I "%BUILD_CONFIG%"=="debug" (
     )
 )
 
-set SIGNTOOL_PARAMS=sign /tr http://timestamp.digicert.com /td sha256 /fd sha256 /sha1 8b9d0d682ad9459e54f05a79694bc10f9876e297 /v
-
 set BUILD_ROOT=%cd%\build
 set SOURCE_ROOT=%cd%
 set BUILD_FOLDER=%BUILD_ROOT%\build-%BUILD_CONFIG%
@@ -65,7 +68,8 @@ mkdir %BUILD_FOLDER%
 mkdir %INSTALLER_FOLDER%
 
 rem Find Visual Studio and run vcvarsall.bat
-set VSWHERE="%SOURCE_ROOT%\scripts\vswhere.exe"
+call "%SOURCE_ROOT%\scripts\find-vswhere.bat"
+if !ERRORLEVEL! NEQ 0 goto Error
 for /f "usebackq delims=" %%i in (`%VSWHERE% -latest -property installationPath`) do (
     call "%%i\VC\Auxiliary\Build\vcvarsall.bat" x86
 )

setup-deps.ps1

@@ -4,7 +4,7 @@ $Organization = "moonlight-stream"
 $PrebuiltRepo = "moonlight-qt-deps"
 $TargetDir = Join-Path $PSScriptRoot "libs\windows"
 $Assets = @("windows-x64.zip", "windows-ARM64.zip")
-$Tag = "v8"
+$Tag = "v19"
 
 if (Test-Path $TargetDir) {
     Write-Host "Cleaning target directory..." -ForegroundColor Cyan

setup-deps.py

@@ -7,7 +7,7 @@ import shutil
 
 ORGANIZATION = "moonlight-stream"
 PREBUILT_REPO = "moonlight-qt-deps"
-TAG = "v8"
+TAG = "v19"
 
 def get_platform_config():
     system = platform.system()

wix/Moonlight/Moonlight.wixproj

@@ -16,7 +16,7 @@
     <SignOutput>true</SignOutput>
   </PropertyGroup>
   <Target Name="SignMsi">
-    <Exec Command='signtool.exe $(SIGNTOOL_PARAMS) %(SignMsi.FullPath)' />
+    <Exec Command='signtool.exe sign $(SIGNTOOL_PARAMS) %(SignMsi.FullPath)' />
   </Target>
   <ItemGroup>
     <PackageReference Include="WixToolset.Firewall.wixext" Version="7.0.0" />

wix/MoonlightSetup/Bundle.wxs

@@ -1,12 +1,12 @@
 <!-- This block is autogenerated using scripts\update-msvcredist.ps1 -->
-<?define VCREDIST_VER = "14.51.36231.0" ?>
-<?define VCREDIST_X64_SIZE = "18779992" ?>
-<?define VCREDIST_X64_SHA512 = "3DECE58F72DDCB2574C33BD4CC41FDE8B4304C5BC0A9E6A0CF9EB9E095A389F5659462475AB366A6D8A6820999FD5F03AB17F865C921C481632B236A05EE5B35" ?>
-<?define VCREDIST_X64_URL = "https://download.visualstudio.microsoft.com/download/pr/c1bd4f2c-3672-468e-8480-7ed419dbb641/90E48ADE404E4576D023ABFA374F323555F233982A8805EA9AC63DCA9491A16B/VC_redist.x64.exe" ?>
+<?define VCREDIST_VER = "14.51.36247.0" ?>
+<?define VCREDIST_X64_SIZE = "18731856" ?>
+<?define VCREDIST_X64_SHA512 = "C42C82CFD5EAA2165B600F6109CB14FF4308CDF4CFF656A1375B4A933F1630BFE54C99C4D0FB9ED3BEA4DC4E4FDAA3DB8E7C58356CCA07C2954F4C297757D62D" ?>
+<?define VCREDIST_X64_URL = "https://download.visualstudio.microsoft.com/download/pr/ebdab8e5-1d7b-4d9f-a11b-cbb1720c3b12/843068991DAAA1F73AD9F6239BCE4D0F6A07A51F18C37EA2A867E9BECA71295C/VC_redist.x64.exe" ?>
 <?define VCREDIST_X64_UPGRADE_CODE = "36F68A90-239C-34DF-B58C-64B30153CE35" ?>
-<?define VCREDIST_ARM64_SIZE = "11869640" ?>
-<?define VCREDIST_ARM64_SHA512 = "A24977481AF9481BF77FB746807C8B1166D5E091B097D135A51BE8A216872B5C78E6E8A37B131A6593BE93E561BD39DDC0580C57142D92B3FC95402D7760B1D3" ?>
-<?define VCREDIST_ARM64_URL = "https://download.visualstudio.microsoft.com/download/pr/0dd156af-82aa-4812-b524-49c2f894359a/E912E9E653A5295A382BF86521F9B852AEECA823F4A9BF10BB2FBA7DD9445288/VC_redist.arm64.exe" ?>
+<?define VCREDIST_ARM64_SIZE = "11870816" ?>
+<?define VCREDIST_ARM64_SHA512 = "1B6B606B92002C6F31C0DBE1AF412D313BF9D651ABB5A4C4457E4EC17E711BFF044506F8FDB9F29639FCA7742DF4775E4B1BEA1FB438DF456A8446DA5ED658AB" ?>
+<?define VCREDIST_ARM64_URL = "https://download.visualstudio.microsoft.com/download/pr/ddfd326a-05c1-4646-9cf7-9fbc5206a9e8/B70EF586669A620A0A30A1156969C05C6A3831DC8F8BC992DA75779D2A92F944/VC_redist.arm64.exe" ?>
 <?define VCREDIST_ARM64_UPGRADE_CODE = "DC9BAE42-810B-423A-9E25-E4073F1C7B00" ?>
 
 <Wix xmlns="http://wixtoolset.org/schemas/v4/wxs" xmlns:bal="http://wixtoolset.org/schemas/v4/wxs/bal" xmlns:util="http://wixtoolset.org/schemas/v4/wxs/util">

wix/MoonlightSetup/MoonlightSetup.wixproj

@@ -16,10 +16,10 @@
     <SignOutput>true</SignOutput>
   </PropertyGroup>
   <Target Name="SignBundleEngine">
-    <Exec Command='signtool.exe $(SIGNTOOL_PARAMS) %(SignBundleEngine.FullPath)' />
+    <Exec Command='signtool.exe sign $(SIGNTOOL_PARAMS) %(SignBundleEngine.FullPath)' />
   </Target>
   <Target Name="SignBundle">
-    <Exec Command='signtool.exe $(SIGNTOOL_PARAMS) %(SignBundle.FullPath)' />
+    <Exec Command='signtool.exe sign $(SIGNTOOL_PARAMS) %(SignBundle.FullPath)' />
   </Target>
   <ItemGroup>
     <PackageReference Include="WixToolset.Bal.wixext" Version="7.0.0" />