Fix appstream metadata release date for v0.8.1

Version 0.8.1
Update macOS builds to FFmpeg 4.1
2026-10-18 14:35:11 +00:00 · 2019-01-29 18:52:01 -08:00 · 2019-01-08 00:48:49 -08:00 · 2019-01-07 21:43:18 -08:00 · 2019-01-07 21:39:59 -08:00 · 2019-01-07 21:08:08 -08:00
155 changed files with 3259 additions and 808 deletions
@@ -13,6 +13,9 @@ Any special steps that are required for the bug to appear.
 **Screenshots**
 If applicable, add screenshots to help explain your problem. If the issue is related to video glitching or poor quality, please include screenshots.

+**Affected games**
+List the games you've tried that exhibit the issue. To see if the issue is game-specific, try streaming Steam Big Picture with Moonlight and see if the issue persists there.
+
 **Moonlight settings (please complete the following information)**
 - Have any settings been adjusted from defaults?
 - If so, which settings have been changed?
@@ -22,10 +25,15 @@ If applicable, add screenshots to help explain your problem. If the issue is rel
 - OS: [e.g. Windows 10 1803]
 - Moonlight Version: [e.g. v0.2.0]

-**Logs (please attach)**
+**Server PC details (please complete the following information)**
+ - OS: [e.g. Windows 10 1803]
+ - GeForce Experience version: [e.g. 3.16.0.140]
+ - Nvidia GPU driver: [e.g. 417.35]
+
+**Moonlight Logs (please attach)**
 - On Windows, `Moonlight-###.log` files can be found in `%TEMP%`. Simply type that into the File Explorer path field to navigate there.
 - On macOS, `Moonlight-###.log` files can be found in `/tmp`. In Finder, press Cmd+Shift+G, then type `/tmp` to navigate there.
 - On Linux, logs print to the terminal when running via `flatpak run com.moonlight_stream.Moonlight`

 **Additional context**
-Add any other context about the problem here.
+Anything else you think may be relevant to the issue
@@ -2,4 +2,6 @@


 **/.vs/
-build/
+build/
+config.tests/*/.qmake.stash
+config.tests/*/Makefile
@@ -10,3 +10,6 @@
 [submodule "soundio/libsoundio"]
 	path = soundio/libsoundio
 	url = https://github.com/andrewrk/libsoundio.git
+[submodule "h264bitstream/h264bitstream"]
+	path = h264bitstream/h264bitstream
+	url = https://github.com/aizvorski/h264bitstream.git
@@ -0,0 +1,23 @@
+QT       -= core gui
+
+TARGET = AntiHooking
+TEMPLATE = lib
+
+# Support debug and release builds from command line for CI
+CONFIG += debug_and_release
+
+# Ensure symbols are always generated
+CONFIG += force_debug_info
+
+INCLUDEPATH += $$PWD/../libs/windows/include
+contains(QT_ARCH, i386) {
+    LIBS += -L$$PWD/../libs/windows/lib/x86
+}
+contains(QT_ARCH, x86_64) {
+    LIBS += -L$$PWD/../libs/windows/lib/x64
+}
+
+LIBS += -lNktHookLib
+DEFINES += ANTIHOOKING_LIBRARY
+SOURCES += antihookingprotection.cpp
+HEADERS += antihookingprotection.h
@@ -0,0 +1,161 @@
+#include "antihookingprotection.h"
+
+#include <NktHookLib.h>
+
+typedef HMODULE (WINAPI *LoadLibraryAFunc)(LPCSTR lpLibFileName);
+typedef HMODULE (WINAPI *LoadLibraryWFunc)(LPCWSTR lpLibFileName);
+typedef HMODULE (WINAPI *LoadLibraryExAFunc)(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
+typedef HMODULE (WINAPI *LoadLibraryExWFunc)(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
+
+class AntiHookingProtection
+{
+public:
+    static void enable()
+    {
+    #ifdef QT_DEBUG
+        s_HookManager.SetEnableDebugOutput(true);
+    #endif
+
+        HINSTANCE kernel32Handle = NktHookLibHelpers::GetModuleBaseAddress(L"kernel32.dll");
+        SIZE_T hookId;
+
+        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryA,
+                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryA"),
+                           (LPVOID)AntiHookingProtection::LoadLibraryAHook);
+        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryW,
+                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryW"),
+                           (LPVOID)AntiHookingProtection::LoadLibraryWHook);
+        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryExA,
+                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryExA"),
+                           (LPVOID)AntiHookingProtection::LoadLibraryExAHook);
+        s_HookManager.Hook(&hookId, (LPVOID*)&s_RealLoadLibraryExW,
+                           NktHookLibHelpers::GetProcedureAddress(kernel32Handle, "LoadLibraryExW"),
+                           (LPVOID)AntiHookingProtection::LoadLibraryExWHook);
+    }
+
+private:
+    static bool isImageBlacklistedW(LPCWSTR lpLibFileName)
+    {
+        LPCWSTR dllName;
+
+        // If the library has a path prefixed, remove it
+        dllName = wcsrchr(lpLibFileName, '\\');
+        if (!dllName) {
+            // No prefix, so use the full name
+            dllName = lpLibFileName;
+        }
+        else {
+            // Advance past the backslash
+            dllName++;
+        }
+
+        // FIXME: We don't currently handle LoadLibrary calls where the
+        // library name does not include a file extension and the loader
+        // automatically assumes .dll.
+
+        for (int i = 0; i < ARRAYSIZE(k_BlacklistedDlls); i++) {
+            if (_wcsicmp(dllName, k_BlacklistedDlls[i]) == 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    static bool isImageBlacklistedA(LPCSTR lpLibFileName)
+    {
+        int uniChars = MultiByteToWideChar(CP_THREAD_ACP, 0, lpLibFileName, -1, nullptr, 0);
+        if (uniChars > 0) {
+            PWCHAR wideBuffer = new WCHAR[uniChars];
+            uniChars = MultiByteToWideChar(CP_THREAD_ACP, 0,
+                                           lpLibFileName, -1,
+                                           wideBuffer, uniChars * sizeof(WCHAR));
+            if (uniChars > 0) {
+                bool ret = isImageBlacklistedW(wideBuffer);
+                delete[] wideBuffer;
+                return ret;
+            }
+            else {
+                delete[] wideBuffer;
+            }
+        }
+
+        // Error path
+        return false;
+    }
+
+    static HMODULE WINAPI LoadLibraryAHook(LPCSTR lpLibFileName)
+    {
+        if (lpLibFileName && isImageBlacklistedA(lpLibFileName)) {
+            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
+            return nullptr;
+        }
+
+        return s_RealLoadLibraryA(lpLibFileName);
+    }
+
+    static HMODULE WINAPI LoadLibraryWHook(LPCWSTR lpLibFileName)
+    {
+        if (lpLibFileName && isImageBlacklistedW(lpLibFileName)) {
+            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
+            return nullptr;
+        }
+
+        return s_RealLoadLibraryW(lpLibFileName);
+    }
+
+    static HMODULE WINAPI LoadLibraryExAHook(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
+    {
+        if (lpLibFileName && isImageBlacklistedA(lpLibFileName)) {
+            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
+            return nullptr;
+        }
+
+        return s_RealLoadLibraryExA(lpLibFileName, hFile, dwFlags);
+    }
+
+    static HMODULE WINAPI LoadLibraryExWHook(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
+    {
+        if (lpLibFileName && isImageBlacklistedW(lpLibFileName)) {
+            SetLastError(ERROR_ACCESS_DISABLED_BY_POLICY);
+            return nullptr;
+        }
+
+        return s_RealLoadLibraryExW(lpLibFileName, hFile, dwFlags);
+    }
+
+    static CNktHookLib s_HookManager;
+    static LoadLibraryAFunc s_RealLoadLibraryA;
+    static LoadLibraryWFunc s_RealLoadLibraryW;
+    static LoadLibraryExAFunc s_RealLoadLibraryExA;
+    static LoadLibraryExWFunc s_RealLoadLibraryExW;
+
+    static constexpr LPCWSTR k_BlacklistedDlls[] = {
+        // This DLL shipped with ASUS Sonic Radar 3 improperly handles
+        // D3D9 exclusive fullscreen in a way that causes CreateDeviceEx()
+        // to deadlock. https://github.com/moonlight-stream/moonlight-qt/issues/102
+        L"NahimicOSD.dll"
+    };
+};
+
+CNktHookLib AntiHookingProtection::s_HookManager;
+LoadLibraryAFunc AntiHookingProtection::s_RealLoadLibraryA;
+LoadLibraryWFunc AntiHookingProtection::s_RealLoadLibraryW;
+LoadLibraryExAFunc AntiHookingProtection::s_RealLoadLibraryExA;
+LoadLibraryExWFunc AntiHookingProtection::s_RealLoadLibraryExW;
+
+AH_EXPORT void AntiHookingDummyImport() {}
+
+extern "C"
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
+{
+    switch (fdwReason)
+    {
+    case DLL_PROCESS_ATTACH:
+        AntiHookingProtection::enable();
+        DisableThreadLibraryCalls(hinstDLL);
+        break;
+    }
+
+    return TRUE;
+};
@@ -0,0 +1,10 @@
+#pragma once
+
+#ifdef ANTIHOOKING_LIBRARY
+#define AH_EXPORT  extern "C" __declspec(dllexport)
+#else
+#define AH_EXPORT  extern "C" __declspec(dllimport)
+#endif
+
+AH_EXPORT void AntiHookingDummyImport();
+
@@ -1,11 +1,9 @@
 # Moonlight PC

-[Moonlight PC](http://moonlight-stream.com) is an open source implementation of NVIDIA's GameStream, as used by the NVIDIA Shield, but built to run on Windows, Mac, and Linux. This client is the successor to [Moonlight Chrome](https://github.com/moonlight-stream/moonlight-chrome) for streaming on PC.
+[Moonlight PC](https://moonlight-stream.org) is an open source implementation of NVIDIA's GameStream, as used by the NVIDIA Shield, but built to run on Windows, Mac, and Linux. This client is the successor to [Moonlight Chrome](https://github.com/moonlight-stream/moonlight-chrome) for streaming on PC.

 Moonlight also has mobile versions for [Android](https://github.com/moonlight-stream/moonlight-android) and  [iOS](https://github.com/moonlight-stream/moonlight-ios).

-See the [releases page](https://github.com/moonlight-stream/moonlight-qt/releases) for download links for Windows and Mac. For Linux, we're on [Flathub](https://flathub.org/apps/details/com.moonlight_stream.Moonlight).
-
 You can follow development on our [Discord server](https://discord.gg/6ERtzFY).

 [![Windows AppVeyor Status](https://ci.appveyor.com/api/projects/status/glj5cxqwy2w3bglv/branch/master?svg=true)](https://ci.appveyor.com/project/cgutman/moonlight-qt/branch/master)
@@ -19,6 +17,10 @@ You can follow development on our [Discord server](https://discord.gg/6ERtzFY).
 - HEVC support for better image quality at reduced bandwidth
 - Keyboard and mouse support
 - Gamepad support with SDL gamepad mappings
+ 
+## Downloads
+- [Windows and macOS](https://github.com/moonlight-stream/moonlight-qt/releases)
+- [Linux](https://flathub.org/apps/details/com.moonlight_stream.Moonlight)

 ## Building
 ### General Build Requirements
@@ -32,27 +34,29 @@ You can follow development on our [Discord server](https://discord.gg/6ERtzFY).
 * WiX Toolset v3.11 or later (only if building installers for non-development PCs)

 ### Mac-specific Requirements
-* macOS El Capitan (10.11) or later
-* Xcode with High Sierra (10.13) SDK (Mojave SDK not yet supported until Qt 5.12 later this year)
+* macOS Sierra (10.12) or later
+* Xcode 10
 * [create-dmg](https://github.com/sindresorhus/create-dmg) (only if building DMGs for use on non-development Macs)

 ### Linux-specific Requirements
 * GCC or Clang
-* Install your distro equivalents of: `openssl-devel qt5-devel SDL2-devel ffmpeg-devel qt5-qtquickcontrols2-devel libva-devel libvdpau-devel opus-devel`
+* Install your distro equivalents of: `openssl-devel qt5-devel SDL2-devel ffmpeg-devel qt5-qtquickcontrols2-devel libva-devel libvdpau-devel opus-devel pulseaudio-libs-devel alsa-lib-devel`
 * FFmpeg 4.0 is required to build. If your distro doesn't package FFmpeg 4.0, you can build and install it from source on http://ffmpeg.org/

 ### Build Setup Steps
 1. Install the latest Qt SDK (and optionally, the Qt Creator IDE) from https://www.qt.io/download
-    * You may also use Homebrew on macOS or your Linux distro's package manager for the Qt SDK as long as the packages are Qt 5.9 or later.
+    * You can install Qt via Homebrew on macOS, but you will need to use `brew install qt --with-debug` to be able to create debug builds of Moonlight.
+    * You may also use your Linux distro's package manager for the Qt SDK as long as the packages are Qt 5.9 or later.
 2. Run `git submodule update --init --recursive` from within `moonlight-qt/`
 3. Open the project in Qt Creator or build from qmake on the command line.
    * To build a binary for use on non-development machines, use the scripts in the `scripts` folder.
        * For Windows builds, use `scripts\generate-installers.bat`. Execute this script from the root of the repository within a Qt command prompt. Ensure WiX and 7-Zip binary directories are in your `%PATH%`.
        * For macOS builds, use `scripts/generate-dmg.sh`. Execute this script from the root of the repository and ensure Qt's `bin` folder is in your `$PATH`.
+    * To build from the command line for development use, run `qmake moonlight-qt.pro` then `make debug` or `make release`

 ## Contribute
 1. Fork us
 2. Write code
 3. Send Pull Requests

-Check out our [website](http://moonlight-stream.com) for project links and information.
+Check out our [website](https://moonlight-stream.org) for project links and information.
@@ -23,9 +23,9 @@
 	<key>NSSupportsAutomaticGraphicsSwitching</key>
 	<true/>
 	<key>CFBundleVersion</key>
-	<string>0.6.0</string>
+	<string>VERSION</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.6.0</string>
+	<string>VERSION</string>
 	<key>CFBundleDisplayName</key>
 	<string>Moonlight</string>
 </dict>
@@ -18,7 +18,9 @@ CONFIG += force_debug_info
 # Since this binds the app against the Qt runtime version, we will only
 # do this for Windows and Mac, since they ship with the Qt runtime.
 win32|macx {
-    CONFIG += qtquickcompiler
+    CONFIG(release, debug|release) {
+        CONFIG += qtquickcompiler
+    }
 }

 TEMPLATE = app
@@ -52,7 +54,7 @@ macx {
 }

 unix:!macx {
-    CONFIG += link_pkgconfig
+    CONFIG += link_pkgconfig soundio
    PKGCONFIG += openssl sdl2 opus

    # For libsoundio
@@ -98,6 +100,7 @@ macx {

 SOURCES += \
    main.cpp \
+    backend/computerseeker.cpp \
    backend/identitymanager.cpp \
    backend/nvcomputer.cpp \
    backend/nvhttp.cpp \
@@ -105,6 +108,7 @@ SOURCES += \
    backend/computermanager.cpp \
    backend/boxartmanager.cpp \
    cli/commandlineparser.cpp \
+    cli/quitstream.cpp \
    cli/startstream.cpp \
    settings/streamingpreferences.cpp \
    streaming/input.cpp \
@@ -121,6 +125,7 @@ SOURCES += \

 HEADERS += \
    utils.h \
+    backend/computerseeker.h \
    backend/identitymanager.h \
    backend/nvcomputer.h \
    backend/nvhttp.h \
@@ -128,6 +133,7 @@ HEADERS += \
    backend/computermanager.h \
    backend/boxartmanager.h \
    cli/commandlineparser.h \
+    cli/quitstream.h \
    cli/startstream.h \
    settings/streamingpreferences.h \
    streaming/input.h \
@@ -258,6 +264,19 @@ else:unix: LIBS += -L$$OUT_PWD/../soundio/ -lsoundio
 INCLUDEPATH += $$PWD/../soundio/libsoundio
 DEPENDPATH += $$PWD/../soundio/libsoundio

+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../h264bitstream/release/ -lh264bitstream
+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
+
+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../AntiHooking/release/ -lAntiHooking
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../AntiHooking/debug/ -lAntiHooking
+
+INCLUDEPATH += $$PWD/../AntiHooking
+DEPENDPATH += $$PWD/../AntiHooking
+
 unix:!macx: {
    isEmpty(PREFIX) {
        PREFIX = /usr/local
@@ -295,12 +314,22 @@ win32 {
    QMAKE_LFLAGS += /MANIFEST:embed /MANIFESTINPUT:$${PWD}/Moonlight.exe.manifest
 }
 macx {
-    QMAKE_INFO_PLIST = $$PWD/Info.plist
+    # Create Info.plist in object dir with the correct version string
+    system(cp $$PWD/Info.plist $$OUT_PWD/Info.plist)
+    system(sed -i -e 's/VERSION/$$cat(version.txt)/g' $$OUT_PWD/Info.plist)
+
+    QMAKE_INFO_PLIST = $$OUT_PWD/Info.plist

    APP_BUNDLE_RESOURCES.files = moonlight.icns SDL_GameControllerDB/gamecontrollerdb.txt
    APP_BUNDLE_RESOURCES.path = Contents/Resources
-    QMAKE_BUNDLE_DATA += APP_BUNDLE_RESOURCES
+
+    APP_BUNDLE_FRAMEWORKS.files = $$files(../libs/mac/Frameworks/*.framework, true)
+    APP_BUNDLE_FRAMEWORKS.path = Contents/Frameworks
+
+    QMAKE_BUNDLE_DATA += APP_BUNDLE_RESOURCES APP_BUNDLE_FRAMEWORKS
+
+    QMAKE_RPATHDIR += @executable_path/../Frameworks
 }

-VERSION = 0.6.0
-DEFINES += VERSION_STR=\\\"0.6.0\\\"
+VERSION = "$$cat(version.txt)"
+DEFINES += VERSION_STR=\\\"$$cat(version.txt)\\\"
@@ -12,6 +12,9 @@ AutoUpdateChecker::AutoUpdateChecker(QObject *parent) :
    // Never communicate over HTTP
    m_Nam.setStrictTransportSecurityEnabled(true);

+    // Allow HTTP redirects
+    m_Nam.setRedirectPolicy(QNetworkRequest::NoLessSafeRedirectPolicy);
+
    connect(&m_Nam, SIGNAL(finished(QNetworkReply*)),
            this, SLOT(handleUpdateCheckRequestFinished(QNetworkReply*)));

@@ -27,7 +30,7 @@ void AutoUpdateChecker::start()
 {
 #if defined(Q_OS_WIN32) || defined(Q_OS_DARWIN) // Only run update checker on platforms without auto-update
    // We'll get a callback when this is finished
-    QUrl url("https://moonlight-stream.com/updates/qt.json");
+    QUrl url("https://moonlight-stream.org/updates/qt.json");
    m_Nam.get(QNetworkRequest(url));
 #endif
 }
@@ -113,7 +116,8 @@ void AutoUpdateChecker::handleUpdateCheckRequestFinished(QNetworkReply* reply)
                        if (currentVer < latestVer) {
                            qDebug() << "Update available";

-                            emit onUpdateAvailable(updateObj["browser_url"].toString());
+                            emit onUpdateAvailable(updateObj["version"].toString(),
+                                                   updateObj["browser_url"].toString());
                            return;
                        }
                        else if (currentVer > latestVer) {
@@ -12,7 +12,7 @@ public:
    Q_INVOKABLE void start();

 signals:
-    void onUpdateAvailable(QString url);
+    void onUpdateAvailable(QString newVersion, QString url);

 private slots:
    void handleUpdateCheckRequestFinished(QNetworkReply* reply);
@@ -97,7 +97,7 @@ void BoxArtManager::handleBoxArtLoadComplete(NvComputer* computer, NvApp app, QU

 QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
 {
-    NvHTTP http(computer->activeAddress);
+    NvHTTP http(computer->activeAddress, computer->serverCert);

    QString cachePath = getFilePathForBoxArt(computer, appId);
    QImage image;
@@ -2,6 +2,9 @@
 #include "nvhttp.h"
 #include "settings/streamingpreferences.h"

+#include <Limelight.h>
+#include <QtEndian>
+
 #include <QThread>
 #include <QThreadPool>

@@ -24,7 +27,7 @@ public:
 private:
    bool tryPollComputer(QString address, bool& changed)
    {
-        NvHTTP http(address);
+        NvHTTP http(address, m_Computer->serverCert);

        QString serverInfo;
        try {
@@ -33,7 +36,7 @@ private:
            return false;
        }

-        NvComputer newState(address, serverInfo);
+        NvComputer newState(address, serverInfo, QSslCertificate());

        // Ensure the machine that responded is the one we intended to contact
        if (m_Computer->uuid != newState.uuid) {
@@ -49,7 +52,7 @@ private:
    {
        Q_ASSERT(m_Computer->activeAddress != nullptr);

-        NvHTTP http(m_Computer->activeAddress);
+        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);

        QVector<NvApp> appList;

@@ -215,7 +218,7 @@ void ComputerManager::saveHosts()
    settings.beginWriteArray(SER_HOSTS);
    for (int i = 0; i < m_KnownHosts.count(); i++) {
        settings.setArrayIndex(i);
-        m_KnownHosts[m_KnownHosts.keys()[i]]->serialize(settings);
+        m_KnownHosts.value(m_KnownHosts.keys()[i])->serialize(settings);
    }
    settings.endArray();
 }
@@ -263,7 +266,7 @@ void ComputerManager::startPollingComputer(NvComputer* computer)
    }

    if (m_PollThreads.contains(computer->uuid)) {
-        Q_ASSERT(m_PollThreads[computer->uuid]->isRunning());
+        Q_ASSERT(m_PollThreads.value(computer->uuid)->isRunning());
        return;
    }

@@ -321,9 +324,8 @@ public:
        {
            QWriteLocker lock(&m_ComputerManager->m_Lock);

-            pollingThread = m_ComputerManager->m_PollThreads[m_Computer->uuid];
+            pollingThread = m_ComputerManager->m_PollThreads.take(m_Computer->uuid);

-            m_ComputerManager->m_PollThreads.remove(m_Computer->uuid);
            m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
        }

@@ -382,7 +384,7 @@ private:
        NvPairingManager pairingManager(m_Computer->activeAddress);

        try {
-           NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin);
+           NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin, m_Computer->serverCert);
           switch (result)
           {
           case NvPairingManager::PairState::PIN_WRONG:
@@ -435,7 +437,7 @@ signals:
 private:
    void run()
    {
-        NvHTTP http(m_Computer->activeAddress);
+        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);

        try {
            if (m_Computer->currentGameId != 0) {
@@ -535,12 +537,8 @@ signals:
    void computerStateChanged(NvComputer* computer);

 private:
-    void run()
+    QString fetchServerInfo(NvHTTP& http)
    {
-        NvHTTP http(m_Address);
-
-        qInfo() << "Processing new PC at" << m_Address << "from" << (m_Mdns ? "mDNS" : "user");
-
        QString serverInfo;
        try {
            // There's a race condition between GameStream servers reporting presence over
@@ -561,63 +559,112 @@ private:
                    throw e;
                }
            }
+            return serverInfo;
        } catch (...) {
            if (!m_Mdns) {
                emit computerAddCompleted(false);
            }
+            return QString();
+        }
+    }
+
+    void run()
+    {
+        NvHTTP http(m_Address, QSslCertificate());
+
+        qInfo() << "Processing new PC at" << m_Address << "from" << (m_Mdns ? "mDNS" : "user");
+
+        // Perform initial serverinfo fetch over HTTP since we don't know which cert to use
+        QString serverInfo = fetchServerInfo(http);
+        if (serverInfo.isEmpty()) {
            return;
        }

-        NvComputer* newComputer = new NvComputer(m_Address, serverInfo);
+        // Create initial newComputer using HTTP serverinfo with no pinned cert
+        NvComputer* newComputer = new NvComputer(m_Address, serverInfo, QSslCertificate());
+
+        // Check if we have a record of this host UUID to pull the pinned cert
+        NvComputer* existingComputer;
+        {
+            QReadLocker lock(&m_ComputerManager->m_Lock);
+            existingComputer = m_ComputerManager->m_KnownHosts.value(newComputer->uuid);
+            if (existingComputer != nullptr) {
+                http.setServerCert(existingComputer->serverCert);
+            }
+        }
+
+        // Fetch serverinfo again over HTTPS with the pinned cert
+        if (existingComputer != nullptr) {
+            serverInfo = fetchServerInfo(http);
+            if (serverInfo.isEmpty()) {
+                return;
+            }
+
+            // Update the polled computer with the HTTPS information
+            NvComputer httpsComputer(m_Address, serverInfo, QSslCertificate());
+            newComputer->update(httpsComputer);
+        }

        // Update addresses depending on the context
        if (m_Mdns) {
            newComputer->localAddress = m_Address;
+
+            // Get the WAN IP address using STUN if we're on mDNS
+            quint32 addr;
+            int err = LiFindExternalAddressIP4("stun.moonlight-stream.org", 3478, &addr);
+            if (err == 0) {
+                newComputer->remoteAddress = QHostAddress(qFromBigEndian(addr)).toString();
+            }
+            else {
+                qWarning() << "STUN failed to get WAN address:" << err;
+            }
        }
        else {
            newComputer->manualAddress = m_Address;
        }

-        // Check if this PC already exists
-        QWriteLocker lock(&m_ComputerManager->m_Lock);
-        NvComputer* existingComputer = m_ComputerManager->m_KnownHosts[newComputer->uuid];
-        if (existingComputer != nullptr) {
-            // Fold it into the existing PC
-            bool changed = existingComputer->update(*newComputer);
-            delete newComputer;
+        {
+            // Check if this PC already exists
+            QWriteLocker lock(&m_ComputerManager->m_Lock);
+            NvComputer* existingComputer = m_ComputerManager->m_KnownHosts.value(newComputer->uuid);
+            if (existingComputer != nullptr) {
+                // Fold it into the existing PC
+                bool changed = existingComputer->update(*newComputer);
+                delete newComputer;

-            // Drop the lock before notifying
-            lock.unlock();
+                // Drop the lock before notifying
+                lock.unlock();

-            // For non-mDNS clients, let them know it succeeded
-            if (!m_Mdns) {
-                emit computerAddCompleted(true);
+                // For non-mDNS clients, let them know it succeeded
+                if (!m_Mdns) {
+                    emit computerAddCompleted(true);
+                }
+
+                // Tell our client if something changed
+                if (changed) {
+                    qInfo() << existingComputer->name << "is now at" << existingComputer->activeAddress;
+                    emit computerStateChanged(existingComputer);
+                }
            }
+            else {
+                // Store this in our active sets
+                m_ComputerManager->m_KnownHosts[newComputer->uuid] = newComputer;

-            // Tell our client if something changed
-            if (changed) {
-                qInfo() << existingComputer->name << "is now at" << existingComputer->activeAddress;
-                emit computerStateChanged(existingComputer);
+                // Start polling if enabled (write lock required)
+                m_ComputerManager->startPollingComputer(newComputer);
+
+                // Drop the lock before notifying
+                lock.unlock();
+
+                // For non-mDNS clients, let them know it succeeded
+                if (!m_Mdns) {
+                    emit computerAddCompleted(true);
+                }
+
+                // Tell our client about this new PC
+                emit computerStateChanged(newComputer);
            }
        }
-        else {
-            // Store this in our active sets
-            m_ComputerManager->m_KnownHosts[newComputer->uuid] = newComputer;
-
-            // Start polling if enabled (write lock required)
-            m_ComputerManager->startPollingComputer(newComputer);
-
-            // Drop the lock before notifying
-            lock.unlock();
-
-            // For non-mDNS clients, let them know it succeeded
-            if (!m_Mdns) {
-                emit computerAddCompleted(true);
-            }
-
-            // Tell our client about this new PC
-            emit computerStateChanged(newComputer);
-        }
    }

    ComputerManager* m_ComputerManager;
@@ -0,0 +1,59 @@
+#include "computerseeker.h"
+#include "computermanager.h"
+#include <QTimer>
+
+ComputerSeeker::ComputerSeeker(ComputerManager *manager, QString computerName, QObject *parent)
+    : QObject(parent), m_ComputerManager(manager), m_ComputerName(computerName),
+      m_TimeoutTimer(new QTimer(this))
+{
+    m_TimeoutTimer->setSingleShot(true);
+    connect(m_TimeoutTimer, &QTimer::timeout,
+            this, &ComputerSeeker::onTimeout);
+    connect(m_ComputerManager, &ComputerManager::computerStateChanged,
+            this, &ComputerSeeker::onComputerUpdated);
+}
+
+void ComputerSeeker::start(int timeout)
+{
+    m_TimeoutTimer->start(timeout);
+    // Seek desired computer by both connecting to it directly (this may fail
+    // if m_ComputerName is UUID, or the name that doesn't resolve to an IP
+    // address) and by polling it using mDNS, hopefully one of these methods
+    // would find the host
+    m_ComputerManager->addNewHost(m_ComputerName, false);
+    m_ComputerManager->startPolling();
+}
+
+void ComputerSeeker::onComputerUpdated(NvComputer *computer)
+{
+    if (!m_TimeoutTimer->isActive()) {
+        return;
+    }
+    if (matchComputer(computer) && isOnline(computer)) {
+        m_ComputerManager->stopPollingAsync();
+        m_TimeoutTimer->stop();
+        emit computerFound(computer);
+    }
+}
+
+bool ComputerSeeker::matchComputer(NvComputer *computer) const
+{
+    QString value = m_ComputerName.toLower();
+    return computer->name.toLower() == value ||
+           computer->localAddress.toLower() == value ||
+           computer->remoteAddress.toLower() == value ||
+           computer->manualAddress.toLower() == value ||
+           computer->uuid.toLower() == value;
+}
+
+bool ComputerSeeker::isOnline(NvComputer *computer) const
+{
+    return computer->state == NvComputer::CS_ONLINE;
+}
+
+void ComputerSeeker::onTimeout()
+{
+    m_TimeoutTimer->stop();
+    m_ComputerManager->stopPollingAsync();
+    emit errorTimeout();
+}
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <QObject>
+
+class ComputerManager;
+class NvComputer;
+class QTimer;
+
+class ComputerSeeker : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ComputerSeeker(ComputerManager *manager, QString computerName, QObject *parent = nullptr);
+
+    void start(int timeout);
+
+signals:
+    void computerFound(NvComputer *computer);
+    void errorTimeout();
+
+private slots:
+    void onComputerUpdated(NvComputer *computer);
+    void onTimeout();
+
+private:
+    bool matchComputer(NvComputer *computer) const;
+    bool isOnline(NvComputer *computer) const;
+
+private:
+    ComputerManager *m_ComputerManager;
+    QString m_ComputerName;
+    QTimer *m_TimeoutTimer;
+};
@@ -2,6 +2,7 @@

 #include <QUdpSocket>
 #include <QHostInfo>
+#include <QNetworkInterface>

 #define SER_NAME "hostname"
 #define SER_UUID "uuid"
@@ -10,6 +11,7 @@
 #define SER_REMOTEADDR "remoteaddress"
 #define SER_MANUALADDR "manualaddress"
 #define SER_APPLIST "apps"
+#define SER_SRVCERT "srvcert"

 #define SER_APPNAME "name"
 #define SER_APPID "id"
@@ -23,6 +25,7 @@ NvComputer::NvComputer(QSettings& settings)
    this->localAddress = settings.value(SER_LOCALADDR).toString();
    this->remoteAddress = settings.value(SER_REMOTEADDR).toString();
    this->manualAddress = settings.value(SER_MANUALADDR).toString();
+    this->serverCert = QSslCertificate(settings.value(SER_SRVCERT).toByteArray());

    int appCount = settings.beginReadArray(SER_APPLIST);
    for (int i = 0; i < appCount; i++) {
@@ -61,6 +64,7 @@ void NvComputer::serialize(QSettings& settings)
    settings.setValue(SER_LOCALADDR, localAddress);
    settings.setValue(SER_REMOTEADDR, remoteAddress);
    settings.setValue(SER_MANUALADDR, manualAddress);
+    settings.setValue(SER_SRVCERT, serverCert.toPem());

    // Avoid deleting an existing applist if we couldn't get one
    if (!appList.isEmpty()) {
@@ -84,8 +88,10 @@ void NvComputer::sortAppList()
    });
 }

-NvComputer::NvComputer(QString address, QString serverInfo)
+NvComputer::NvComputer(QString address, QString serverInfo, QSslCertificate serverCert)
 {
+    this->serverCert = serverCert;
+
    this->name = NvHTTP::getXmlString(serverInfo, "hostname");
    if (this->name.isEmpty()) {
        this->name = "UNKNOWN";
@@ -167,6 +173,32 @@ bool NvComputer::wake()
    QVector<QString> addressList = uniqueAddresses();
    addressList.append("255.255.255.255");

+    // Try to broadcast on all available NICs
+    for (const QNetworkInterface& nic : QNetworkInterface::allInterfaces()) {
+        // Ensure the interface is up and skip the loopback adapter
+        if ((nic.flags() & QNetworkInterface::IsUp) == 0 ||
+                (nic.flags() & QNetworkInterface::IsLoopBack) != 0) {
+            continue;
+        }
+
+        QHostAddress allNodesMulticast("FF02::1");
+        for (const QNetworkAddressEntry& addr : nic.addressEntries()) {
+            // Store the scope ID for this NIC if IPv6 is enabled
+            if (!addr.ip().scopeId().isEmpty()) {
+                allNodesMulticast.setScopeId(addr.ip().scopeId());
+            }
+
+            // Skip IPv6 which doesn't support broadcast
+            if (!addr.broadcast().isNull()) {
+                addressList.append(addr.broadcast().toString());
+            }
+        }
+
+        if (!allNodesMulticast.scopeId().isEmpty()) {
+            addressList.append(allNodesMulticast.toString());
+        }
+    }
+
    // Try all unique address strings or host names
    bool success = false;
    for (QString& addressString : addressList) {
@@ -181,16 +213,14 @@ bool NvComputer::wake()
        for (QHostAddress& address : hostInfo.addresses()) {
            QUdpSocket sock;

-            // Bind to any address on the correct protocol
-            if (sock.bind(address.protocol() == QUdpSocket::IPv4Protocol ?
-                          QHostAddress::AnyIPv4 : QHostAddress::AnyIPv6)) {
-
-                // Send to all ports
-                for (quint16 port : WOL_PORTS) {
-                    if (sock.writeDatagram(wolPayload, address, port)) {
-                        qInfo().nospace().noquote() << "Send WoL packet to " << name << " via " << address.toString() << ":" << port;
-                        success = true;
-                    }
+            // Send to all ports
+            for (quint16 port : WOL_PORTS) {
+                if (sock.writeDatagram(wolPayload, address, port)) {
+                    qInfo().nospace().noquote() << "Sent WoL packet to " << name << " via " << address.toString() << ":" << port;
+                    success = true;
+                }
+                else {
+                    qWarning() << "Send failed:" << sock.error();
                }
            }
        }
@@ -255,6 +285,13 @@ bool NvComputer::update(NvComputer& that)
        changed = true;                       \
    }

+#define ASSIGN_IF_CHANGED_AND_NONNULL(field)  \
+    if (!that.field.isNull() &&               \
+        this->field != that.field) {          \
+        this->field = that.field;             \
+        changed = true;                       \
+    }
+
    ASSIGN_IF_CHANGED(name);
    ASSIGN_IF_CHANGED_AND_NONEMPTY(macAddress);
    ASSIGN_IF_CHANGED_AND_NONEMPTY(localAddress);
@@ -269,6 +306,7 @@ bool NvComputer::update(NvComputer& that)
    ASSIGN_IF_CHANGED(appVersion);
    ASSIGN_IF_CHANGED(maxLumaPixelsHEVC);
    ASSIGN_IF_CHANGED(gpuModel);
+    ASSIGN_IF_CHANGED_AND_NONNULL(serverCert);
    ASSIGN_IF_CHANGED_AND_NONEMPTY(appList);
    ASSIGN_IF_CHANGED_AND_NONEMPTY(displayModes);
    return changed;
@@ -19,7 +19,7 @@ private:
    bool pendingQuit;

 public:
-    explicit NvComputer(QString address, QString serverInfo);
+    explicit NvComputer(QString address, QString serverInfo, QSslCertificate serverCert);

    explicit NvComputer(QSettings& settings);

@@ -68,6 +68,7 @@ public:
    QByteArray macAddress;
    QString name;
    QString uuid;
+    QSslCertificate serverCert;
    QVector<NvApp> appList;

    // Synchronization
@@ -10,11 +10,16 @@
 #include <QSslKey>
 #include <QImageReader>
 #include <QtEndian>
+#include <QNetworkProxy>

 #define REQUEST_TIMEOUT_MS 5000
+#define LAUNCH_TIMEOUT_MS 120000
+#define RESUME_TIMEOUT_MS 30000
+#define QUIT_TIMEOUT_MS 30000

-NvHTTP::NvHTTP(QString address) :
-    m_Address(address)
+NvHTTP::NvHTTP(QString address, QSslCertificate serverCert) :
+    m_Address(address),
+    m_ServerCert(serverCert)
 {
    Q_ASSERT(!address.isEmpty());

@@ -24,6 +29,15 @@ NvHTTP::NvHTTP(QString address) :
    m_BaseUrlHttps.setHost(address);
    m_BaseUrlHttp.setPort(47989);
    m_BaseUrlHttps.setPort(47984);
+
+    // Never use a proxy server
+    QNetworkProxy noProxy(QNetworkProxy::NoProxy);
+    m_Nam.setProxy(noProxy);
+}
+
+void NvHTTP::setServerCert(QSslCertificate serverCert)
+{
+    m_ServerCert = serverCert;
 }

 QVector<int>
@@ -68,36 +82,50 @@ NvHTTP::getServerInfo(NvLogLevel logLevel)
 {
    QString serverInfo;

-    try
+    // Check if we have a pinned cert for this host yet
+    if (!m_ServerCert.isNull())
    {
-        // Always try HTTPS first, since it properly reports
-        // pairing status (and a few other attributes).
-        serverInfo = openConnectionToString(m_BaseUrlHttps,
-                                            "serverinfo",
-                                            nullptr,
-                                            true,
-                                            logLevel);
-        // Throws if the request failed
-        verifyResponseStatus(serverInfo);
-    }
-    catch (const GfeHttpResponseException& e)
-    {
-        if (e.getStatusCode() == 401)
+        try
        {
-            // Certificate validation error, fallback to HTTP
-            serverInfo = openConnectionToString(m_BaseUrlHttp,
+            // Always try HTTPS first, since it properly reports
+            // pairing status (and a few other attributes).
+            serverInfo = openConnectionToString(m_BaseUrlHttps,
                                                "serverinfo",
                                                nullptr,
-                                                true,
+                                                REQUEST_TIMEOUT_MS,
                                                logLevel);
+            // Throws if the request failed
            verifyResponseStatus(serverInfo);
        }
-        else
+        catch (const GfeHttpResponseException& e)
        {
-            // Rethrow real errors
-            throw e;
+            if (e.getStatusCode() == 401)
+            {
+                // Certificate validation error, fallback to HTTP
+                serverInfo = openConnectionToString(m_BaseUrlHttp,
+                                                    "serverinfo",
+                                                    nullptr,
+                                                    REQUEST_TIMEOUT_MS,
+                                                    logLevel);
+                verifyResponseStatus(serverInfo);
+            }
+            else
+            {
+                // Rethrow real errors
+                throw e;
+            }
        }
    }
+    else
+    {
+        // Only use HTTP prior to pairing
+        serverInfo = openConnectionToString(m_BaseUrlHttp,
+                                            "serverinfo",
+                                            nullptr,
+                                            REQUEST_TIMEOUT_MS,
+                                            logLevel);
+        verifyResponseStatus(serverInfo);
+    }

    return serverInfo;
 }
@@ -155,7 +183,7 @@ NvHTTP::launchApp(int appId,
                                   "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration)+
                                   "&remoteControllersBitmap="+QString::number(gamepadMask)+
                                   "&gcmap="+QString::number(gamepadMask),
-                                   false);
+                                   LAUNCH_TIMEOUT_MS);

    // Throws if the request failed
    verifyResponseStatus(response);
@@ -175,7 +203,7 @@ NvHTTP::resumeApp(PSTREAM_CONFIGURATION streamConfig)
                                   "rikey="+QString(QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex())+
                                   "&rikeyid="+QString::number(riKeyId)+
                                   "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration),
-                                   false);
+                                   RESUME_TIMEOUT_MS);

    // Throws if the request failed
    verifyResponseStatus(response);
@@ -188,7 +216,7 @@ NvHTTP::quitApp()
            openConnectionToString(m_BaseUrlHttps,
                                   "cancel",
                                   nullptr,
-                                   false);
+                                   QUIT_TIMEOUT_MS);

    // Throws if the request failed
    verifyResponseStatus(response);
@@ -235,7 +263,7 @@ NvHTTP::getAppList()
    QString appxml = openConnectionToString(m_BaseUrlHttps,
                                            "applist",
                                            nullptr,
-                                            true,
+                                            REQUEST_TIMEOUT_MS,
                                            NvLogLevel::ERROR);
    verifyResponseStatus(appxml);

@@ -303,7 +331,7 @@ NvHTTP::getBoxArt(int appId)
                                          "appasset",
                                          "appid="+QString::number(appId)+
                                          "&AssetType=2&AssetIdx=0",
-                                          true,
+                                          REQUEST_TIMEOUT_MS,
                                          NvLogLevel::VERBOSE);
    QImage image = QImageReader(reply).read();
    delete reply;
@@ -350,10 +378,10 @@ QString
 NvHTTP::openConnectionToString(QUrl baseUrl,
                               QString command,
                               QString arguments,
-                               bool enableTimeout,
+                               int timeoutMs,
                               NvLogLevel logLevel)
 {
-    QNetworkReply* reply = openConnection(baseUrl, command, arguments, enableTimeout, logLevel);
+    QNetworkReply* reply = openConnection(baseUrl, command, arguments, timeoutMs, logLevel);
    QString ret;

    QTextStream stream(reply);
@@ -368,14 +396,18 @@ QNetworkReply*
 NvHTTP::openConnection(QUrl baseUrl,
                       QString command,
                       QString arguments,
-                       bool enableTimeout,
+                       int timeoutMs,
                       NvLogLevel logLevel)
 {
    // Build a URL for the request
    QUrl url(baseUrl);
    url.setPath("/" + command);
-    url.setQuery("uniqueid=" + IdentityManager::get()->getUniqueId() +
-                 "&uuid=" + QUuid::createUuid().toRfc4122().toHex() +
+
+    // Use a common UID for Moonlight clients to allow them to quit
+    // games for each other (otherwise GFE gets screwed up and it requires
+    // manual intervention to solve).
+    url.setQuery("uniqueid=0123456789ABCDEF&uuid=" +
+                 QUuid::createUuid().toRfc4122().toHex() +
                 ((arguments != nullptr) ? ("&" + arguments) : ""));

    QNetworkRequest request = QNetworkRequest(url);
@@ -385,15 +417,28 @@ NvHTTP::openConnection(QUrl baseUrl,

    QNetworkReply* reply = m_Nam.get(request);

-    // Ignore self-signed certificate errors (since GFE uses them)
-    reply->ignoreSslErrors();
+    // Assert that we always have a server cert for HTTPS, since
+    // the request will fail anyway if we do not.
+    Q_ASSERT(!m_ServerCert.isNull() || baseUrl == m_BaseUrlHttp);
+
+    if (!m_ServerCert.isNull()) {
+        // Pin the server certificate received during pairing
+        QList<QSslError> expectedSslErrors;
+        expectedSslErrors.append(QSslError(QSslError::HostNameMismatch, m_ServerCert));
+        expectedSslErrors.append(QSslError(QSslError::SelfSignedCertificate, m_ServerCert));
+
+        // The SecureTransport backend for Qt TLS on macOS throws CertificateUntrusted
+        // instead of SelfSignedCertificate, so we will need to allow that error too.
+        expectedSslErrors.append(QSslError(QSslError::CertificateUntrusted, m_ServerCert));
+
+        reply->ignoreSslErrors(expectedSslErrors);
+    }

    // Run the request with a timeout if requested
    QEventLoop loop;
    QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
-    if (enableTimeout)
-    {
-        QTimer::singleShot(REQUEST_TIMEOUT_MS, &loop, SLOT(quit()));
+    if (timeoutMs) {
+        QTimer::singleShot(timeoutMs, &loop, SLOT(quit()));
    }
    if (logLevel >= NvLogLevel::VERBOSE) {
        qInfo() << "Executing request:" << url.toString();
@@ -419,9 +464,24 @@ NvHTTP::openConnection(QUrl baseUrl,
        if (logLevel >= NvLogLevel::ERROR) {
            qWarning() << command << " request failed with error " << reply->error();
        }
-        QtNetworkReplyException exception(reply->error(), reply->errorString());
-        delete reply;
-        throw exception;
+
+        if (reply->error() == QNetworkReply::SslHandshakeFailedError) {
+            // This will trigger falling back to HTTP for the serverinfo query
+            // then pairing again to get the updated certificate.
+            GfeHttpResponseException exception(401, "Server certificate mismatch");
+            delete reply;
+            throw exception;
+        }
+        else if (reply->error() == QNetworkReply::OperationCanceledError) {
+            QtNetworkReplyException exception(QNetworkReply::TimeoutError, "Request timed out");
+            delete reply;
+            throw exception;
+        }
+        else {
+            QtNetworkReplyException exception(reply->error(), reply->errorString());
+            delete reply;
+            throw exception;
+        }
    }

    return reply;
@@ -122,7 +122,7 @@ public:
        VERBOSE
    };

-    explicit NvHTTP(QString address);
+    explicit NvHTTP(QString address, QSslCertificate serverCert);

    static
    int
@@ -149,9 +149,11 @@ public:
    openConnectionToString(QUrl baseUrl,
                           QString command,
                           QString arguments,
-                           bool enableTimeout,
+                           int timeoutMs,
                           NvLogLevel logLevel = NvLogLevel::VERBOSE);

+    void setServerCert(QSslCertificate serverCert);
+
    static
    QVector<int>
    parseQuad(QString quad);
@@ -186,9 +188,10 @@ private:
    openConnection(QUrl baseUrl,
                   QString command,
                   QString arguments,
-                   bool enableTimeout,
+                   int timeoutMs,
                   NvLogLevel logLevel);

    QString m_Address;
    QNetworkAccessManager m_Nam;
+    QSslCertificate m_ServerCert;
 };
@@ -8,8 +8,10 @@
 #include <openssl/x509.h>
 #include <openssl/evp.h>

+#define REQUEST_TIMEOUT_MS 5000
+
 NvPairingManager::NvPairingManager(QString address) :
-    m_Http(address)
+    m_Http(address, QSslCertificate())
 {
    QByteArray cert = IdentityManager::get()->getCertificate();
    BIO *bio = BIO_new_mem_buf(cert.data(), -1);
@@ -161,7 +163,7 @@ NvPairingManager::saltPin(QByteArray salt, QString pin)
 }

 NvPairingManager::PairState
-NvPairingManager::pair(QString appVersion, QString pin)
+NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverCert)
 {
    int serverMajorVersion = NvHTTP::parseQuad(appVersion).at(0);
    qInfo() << "Pairing with server generation:" << serverMajorVersion;
@@ -192,7 +194,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
                                                    "pair",
                                                    "devicename=roth&updateState=1&phrase=getservercert&salt=" +
                                                    salt.toHex() + "&clientcert=" + IdentityManager::get()->getCertificate().toHex(),
-                                                    false);
+                                                    0);
    NvHTTP::verifyResponseStatus(getCert);
    if (NvHTTP::getXmlString(getCert, "paired") != "1")
    {
@@ -200,26 +202,38 @@ NvPairingManager::pair(QString appVersion, QString pin)
        return PairState::FAILED;
    }

-    QByteArray serverCert = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
-    if (serverCert == nullptr)
+    QByteArray serverCertStr = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
+    if (serverCertStr == nullptr)
    {
        qCritical() << "Server likely already pairing";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::ALREADY_IN_PROGRESS;
    }

+    serverCert = QSslCertificate(serverCertStr);
+    if (serverCert.isNull()) {
+        Q_ASSERT(!serverCert.isNull());
+
+        qCritical() << "Failed to parse plaincert";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        return PairState::FAILED;
+    }
+
+    // Pin this cert for TLS
+    m_Http.setServerCert(serverCert);
+
    QByteArray randomChallenge = generateRandomBytes(16);
    QByteArray encryptedChallenge = encrypt(randomChallenge, &encKey);
    QString challengeXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttp,
                                                         "pair",
                                                         "devicename=roth&updateState=1&clientchallenge=" +
                                                         encryptedChallenge.toHex(),
-                                                         true);
+                                                         REQUEST_TIMEOUT_MS);
    NvHTTP::verifyResponseStatus(challengeXml);
    if (NvHTTP::getXmlString(challengeXml, "paired") != "1")
    {
        qCritical() << "Failed pairing at stage #2";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::FAILED;
    }

@@ -247,12 +261,12 @@ NvPairingManager::pair(QString appVersion, QString pin)
                                                    "pair",
                                                    "devicename=roth&updateState=1&serverchallengeresp=" +
                                                    encryptedChallengeResponseHash.toHex(),
-                                                    true);
+                                                    REQUEST_TIMEOUT_MS);
    NvHTTP::verifyResponseStatus(respXml);
    if (NvHTTP::getXmlString(respXml, "paired") != "1")
    {
        qCritical() << "Failed pairing at stage #3";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::FAILED;
    }

@@ -262,21 +276,21 @@ NvPairingManager::pair(QString appVersion, QString pin)

    if (!verifySignature(serverSecret,
                         serverSignature,
-                         serverCert))
+                         serverCertStr))
    {
        qCritical() << "MITM detected";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::FAILED;
    }

    QByteArray expectedResponseData;
    expectedResponseData.append(randomChallenge);
-    expectedResponseData.append(getSignatureFromPemCert(serverCert));
+    expectedResponseData.append(getSignatureFromPemCert(serverCertStr));
    expectedResponseData.append(serverSecret);
    if (QCryptographicHash::hash(expectedResponseData, hashAlgo) != serverResponse)
    {
        qCritical() << "Incorrect PIN";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::PIN_WRONG;
    }

@@ -288,24 +302,24 @@ NvPairingManager::pair(QString appVersion, QString pin)
                                                          "pair",
                                                          "devicename=roth&updateState=1&clientpairingsecret=" +
                                                          clientPairingSecret.toHex(),
-                                                          true);
+                                                          REQUEST_TIMEOUT_MS);
    NvHTTP::verifyResponseStatus(secretRespXml);
    if (NvHTTP::getXmlString(secretRespXml, "paired") != "1")
    {
        qCritical() << "Failed pairing at stage #4";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::FAILED;
    }

    QString pairChallengeXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttps,
                                                             "pair",
                                                             "devicename=roth&updateState=1&phrase=pairchallenge",
-                                                             true);
+                                                             REQUEST_TIMEOUT_MS);
    NvHTTP::verifyResponseStatus(pairChallengeXml);
    if (NvHTTP::getXmlString(pairChallengeXml, "paired") != "1")
    {
        qCritical() << "Failed pairing at stage #5";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
        return PairState::FAILED;
    }

@@ -23,7 +23,7 @@ public:
    ~NvPairingManager();

    PairState
-    pair(QString appVersion, QString pin);
+    pair(QString appVersion, QString pin, QSslCertificate& serverCert);

 private:
    QByteArray
@@ -164,6 +164,7 @@ GlobalCommandLineParser::ParseResult GlobalCommandLineParser::parse(const QStrin
        "Starts Moonlight normally if no arguments are given.\n"
        "\n"
        "Available actions:\n"
+        "  quit            Quit the currently running app\n"
        "  stream          Start streaming an app\n"
        "\n"
        "See 'moonlight <action> --help' for help of specific action."
@@ -179,6 +180,8 @@ GlobalCommandLineParser::ParseResult GlobalCommandLineParser::parse(const QStrin
        parser.handleHelpAndVersionOptions();
        parser.handleUnknownOptions();
        return NormalStartRequested;
+    } else if (action == "quit") {
+        return QuitRequested;
    } else if (action == "stream") {
        return StreamRequested;
    } else {
@@ -186,6 +189,48 @@ GlobalCommandLineParser::ParseResult GlobalCommandLineParser::parse(const QStrin
    }
 }

+QuitCommandLineParser::QuitCommandLineParser()
+{
+}
+
+QuitCommandLineParser::~QuitCommandLineParser()
+{
+}
+
+void QuitCommandLineParser::parse(const QStringList &args)
+{
+    CommandLineParser parser;
+    parser.setupCommonOptions();
+    parser.setApplicationDescription(
+        "\n"
+        "Quit the currently running app on the given host."
+    );
+    parser.addPositionalArgument("quit", "quit running app");
+    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
+
+    if (!parser.parse(args)) {
+        parser.showError(parser.errorText());
+    }
+
+    parser.handleUnknownOptions();
+
+    // This method will not return and terminates the process if --version or
+    // --help is specified
+    parser.handleHelpAndVersionOptions();
+
+    // Verify that host has been provided
+    auto posArgs = parser.positionalArguments();
+    if (posArgs.length() < 2) {
+        parser.showError("Host not provided");
+    }
+    m_Host = parser.positionalArguments().at(1);
+}
+
+QString QuitCommandLineParser::getHost() const
+{
+    return m_Host;
+}
+
 StreamCommandLineParser::StreamCommandLineParser()
 {
    m_WindowModeMap = {
@@ -238,9 +283,11 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    parser.addChoiceOption("display-mode", "display mode", m_WindowModeMap.keys());
    parser.addChoiceOption("audio-config", "audio config", m_AudioConfigMap.keys());
    parser.addToggleOption("multi-controller", "multiple controller support");
+    parser.addToggleOption("quit-after", "quit app after session");
    parser.addToggleOption("mouse-acceleration", "mouse acceleration");
    parser.addToggleOption("game-optimization", "game optimizations");
    parser.addToggleOption("audio-on-host", "audio on host PC");
+    parser.addToggleOption("frame-pacing", "frame pacing");
    parser.addChoiceOption("video-codec", "video codec", m_VideoCodecMap.keys());
    parser.addChoiceOption("video-decoder", "video decoder", m_VideoDecoderMap.keys());

@@ -314,6 +361,9 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    // Resolve --multi-controller and --no-multi-controller options
    preferences->multiController = parser.getToggleOptionValue("multi-controller", preferences->multiController);

+    // Resolve --quit-after and --no-quit-after options
+    preferences->quitAppAfter = parser.getToggleOptionValue("quit-after", preferences->quitAppAfter);
+
    // Resolve --mouse-acceleration and --no-mouse-acceleration options
    preferences->mouseAcceleration = parser.getToggleOptionValue("mouse-acceleration", preferences->mouseAcceleration);

@@ -323,6 +373,9 @@ void StreamCommandLineParser::parse(const QStringList &args, StreamingPreference
    // Resolve --audio-on-host and --no-audio-on-host options
    preferences->playAudioOnHost = parser.getToggleOptionValue("audio-on-host", preferences->playAudioOnHost);

+    // Resolve --frame-pacing and --no-frame-pacing options
+    preferences->framePacing = parser.getToggleOptionValue("frame-pacing", preferences->framePacing);
+
    // Resolve --video-codec option
    if (parser.isSet("video-codec")) {
        preferences->videoCodecConfig = mapValue(m_VideoCodecMap, parser.getChoiceOptionValue("video-codec"));
@@ -359,4 +412,3 @@ QString StreamCommandLineParser::getAppName() const
 {
    return m_AppName;
 }
-
@@ -11,6 +11,7 @@ public:
    enum ParseResult {
        NormalStartRequested,
        StreamRequested,
+        QuitRequested,
    };

    GlobalCommandLineParser();
@@ -20,6 +21,20 @@ public:

 };

+class QuitCommandLineParser
+{
+public:
+    QuitCommandLineParser();
+    virtual ~QuitCommandLineParser();
+
+    void parse(const QStringList &args);
+
+    QString getHost() const;
+
+private:
+    QString m_Host;
+};
+
 class StreamCommandLineParser
 {
 public:
@@ -0,0 +1,171 @@
+#include "quitstream.h"
+
+#include "backend/computermanager.h"
+#include "backend/computerseeker.h"
+#include "streaming/session.h"
+
+#include <QCoreApplication>
+#include <QTimer>
+
+#define COMPUTER_SEEK_TIMEOUT 10000
+
+namespace CliQuitStream
+{
+
+enum State {
+    StateInit,
+    StateSeekComputer,
+    StateQuitApp,
+    StateFailure,
+};
+
+class Event
+{
+public:
+    enum Type {
+        AppQuitCompleted,
+        ComputerFound,
+        ComputerSeekTimedout,
+        Executed,
+    };
+
+    Event(Type type)
+        : type(type), computerManager(nullptr), computer(nullptr) {}
+
+    Type type;
+    ComputerManager *computerManager;
+    NvComputer *computer;
+    QString errorMessage;
+};
+
+class LauncherPrivate
+{
+    Q_DECLARE_PUBLIC(Launcher)
+
+public:
+    LauncherPrivate(Launcher *q) : q_ptr(q) {}
+
+    void handleEvent(Event event)
+    {
+        Q_Q(Launcher);
+        NvApp app;
+
+        switch (event.type) {
+        // Occurs when CliQuitStreamSegue becomes visible and the UI calls launcher's execute()
+        case Event::Executed:
+            if (m_State == StateInit) {
+                m_State = StateSeekComputer;
+                m_ComputerManager = event.computerManager;
+                q->connect(m_ComputerManager, &ComputerManager::quitAppCompleted,
+                           q, &Launcher::onQuitAppCompleted);
+
+                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
+                           q, &Launcher::onComputerFound);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
+                           q, &Launcher::onComputerSeekTimeout);
+                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
+
+                emit q->searchingComputer();
+            }
+            break;
+        // Occurs when computer search timed out
+        case Event::ComputerSeekTimedout:
+            if (m_State == StateSeekComputer) {
+                m_State = StateFailure;
+                emit q->failed(QString("Failed to connect to %1").arg(m_ComputerName));
+            }
+            break;
+        // Occurs when searched computer is found
+        case Event::ComputerFound:
+            if (m_State == StateSeekComputer) {
+                if (event.computer->pairState == NvComputer::PS_PAIRED) {
+                    m_State = StateQuitApp;
+                    emit q->quittingApp();
+                    m_ComputerManager->quitRunningApp(event.computer);
+                } else {
+                    m_State = StateFailure;
+                    QString msg = QString("Computer %1 has not been paired. "
+                                          "Please open Moonlight to pair before streaming.")
+                            .arg(event.computer->name);
+                    emit q->failed(msg);
+                }
+            }
+            break;
+        // Occurs when app quit completed (error message is set if failed)
+        case Event::AppQuitCompleted:
+            if (m_State == StateQuitApp) {
+                if (event.errorMessage.isEmpty()) {
+                    QCoreApplication::exit(0);
+                } else {
+                    m_State = StateFailure;
+                    emit q->failed(QString("Quitting app failed, reason: %1").arg(event.errorMessage));
+                }
+            }
+            break;
+        }
+    }
+
+    Launcher *q_ptr;
+    ComputerManager *m_ComputerManager;
+    QString m_ComputerName;
+    ComputerSeeker *m_ComputerSeeker;
+    State m_State;
+    QTimer *m_TimeoutTimer;
+};
+
+Launcher::Launcher(QString computer, QObject *parent)
+    : QObject(parent),
+      m_DPtr(new LauncherPrivate(this))
+{
+    Q_D(Launcher);
+    d->m_ComputerName = computer;
+    d->m_State = StateInit;
+    d->m_TimeoutTimer = new QTimer(this);
+    d->m_TimeoutTimer->setSingleShot(true);
+    connect(d->m_TimeoutTimer, &QTimer::timeout,
+            this, &Launcher::onComputerSeekTimeout);
+}
+
+Launcher::~Launcher()
+{
+}
+
+void Launcher::execute(ComputerManager *manager)
+{
+    Q_D(Launcher);
+    Event event(Event::Executed);
+    event.computerManager = manager;
+    d->handleEvent(event);
+}
+
+bool Launcher::isExecuted() const
+{
+    Q_D(const Launcher);
+    return d->m_State != StateInit;
+}
+
+void Launcher::onComputerFound(NvComputer *computer)
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerFound);
+    event.computer = computer;
+    d->handleEvent(event);
+}
+
+void Launcher::onComputerSeekTimeout()
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerSeekTimedout);
+    d->handleEvent(event);
+}
+
+void Launcher::onQuitAppCompleted(QVariant error)
+{
+    Q_D(Launcher);
+    Event event(Event::AppQuitCompleted);
+    event.errorMessage = error.toString();
+    d->handleEvent(event);
+}
+
+}
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <QObject>
+#include <QVariant>
+
+class ComputerManager;
+class NvComputer;
+
+namespace CliQuitStream
+{
+
+class LauncherPrivate;
+
+class Launcher : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
+
+public:
+    explicit Launcher(QString computer, QObject *parent = nullptr);
+    ~Launcher();
+
+    Q_INVOKABLE void execute(ComputerManager *manager);
+    Q_INVOKABLE bool isExecuted() const;
+
+signals:
+    void searchingComputer();
+    void quittingApp();
+    void failed(QString text);
+
+private slots:
+    void onComputerFound(NvComputer *computer);
+    void onComputerSeekTimeout();
+    void onQuitAppCompleted(QVariant error);
+
+private:
+    QScopedPointer<LauncherPrivate> m_DPtr;
+};
+
+}
@@ -1,7 +1,9 @@
 #include "startstream.h"
 #include "backend/computermanager.h"
+#include "backend/computerseeker.h"
 #include "streaming/session.h"

+#include <QCoreApplication>
 #include <QTimer>

 #define COMPUTER_SEEK_TIMEOUT 10000
@@ -22,6 +24,9 @@ class Event
 {
 public:
    enum Type {
+        AppQuitCompleted,
+        AppQuitRequested,
+        ComputerFound,
        ComputerUpdated,
        Executed,
        Timedout,
@@ -33,6 +38,7 @@ public:
    Type type;
    ComputerManager *computerManager;
    NvComputer *computer;
+    QString errorMessage;
 };

 class LauncherPrivate
@@ -49,58 +55,78 @@ public:
        NvApp app;

        switch (event.type) {
+        // Occurs when CliStartStreamSegue becomes visible and the UI calls launcher's execute()
        case Event::Executed:
            if (m_State == StateInit) {
                m_State = StateSeekComputer;
-                m_TimeoutTimer->start(COMPUTER_SEEK_TIMEOUT);
                m_ComputerManager = event.computerManager;
+
+                m_ComputerSeeker = new ComputerSeeker(m_ComputerManager, m_ComputerName, q);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::computerFound,
+                           q, &Launcher::onComputerFound);
+                q->connect(m_ComputerSeeker, &ComputerSeeker::errorTimeout,
+                           q, &Launcher::onTimeout);
+                m_ComputerSeeker->start(COMPUTER_SEEK_TIMEOUT);
+
                q->connect(m_ComputerManager, &ComputerManager::computerStateChanged,
                           q, &Launcher::onComputerUpdated);
-                // Seek desired computer by both connecting to it directly (this may fail
-                // if m_ComputerName is UUID, or the name that doesn't resolve to an IP
-                // address) and by polling it using mDNS, hopefully one of these methods
-                // would find the host
-                m_ComputerManager->addNewHost(m_ComputerName, false);
-                m_ComputerManager->startPolling();
+                q->connect(m_ComputerManager, &ComputerManager::quitAppCompleted,
+                           q, &Launcher::onQuitAppCompleted);
+
                emit q->searchingComputer();
            }
            break;
-        case Event::ComputerUpdated:
+        // Occurs when searched computer is found
+        case Event::ComputerFound:
            if (m_State == StateSeekComputer) {
-                if (matchComputer(event.computer) && isOnline(event.computer)) {
-                    if (isPaired(event.computer)) {
-                        m_State = StateSeekApp;
-                        m_TimeoutTimer->start(APP_SEEK_TIMEOUT);
-                        m_Computer = event.computer;
-                        m_ComputerManager->stopPollingAsync();
-                        emit q->searchingApp();
-                    } else {
-                        m_State = StateFailure;
-                        QString msg = QString("Computer %1 has not been paired. "
-                                              "Please open Moonlight to pair before streaming.")
-                                .arg(event.computer->name);
-                        emit q->failed(msg);
-                    }
+                if (event.computer->pairState == NvComputer::PS_PAIRED) {
+                    m_State = StateSeekApp;
+                    m_Computer = event.computer;
+                    m_TimeoutTimer->start(APP_SEEK_TIMEOUT);
+                    emit q->searchingApp();
+                } else {
+                    m_State = StateFailure;
+                    QString msg = QString("Computer %1 has not been paired. "
+                                          "Please open Moonlight to pair before streaming.")
+                            .arg(event.computer->name);
+                    emit q->failed(msg);
                }
            }
+            break;
+        // Occurs when a computer is updated
+        case Event::ComputerUpdated:
            if (m_State == StateSeekApp) {
                int index = getAppIndex();
                if (-1 != index) {
                    app = m_Computer->appList[index];
+                    m_TimeoutTimer->stop();
                    if (isNotStreaming() || isStreamingApp(app)) {
                        m_State = StateStartSession;
-                        m_TimeoutTimer->stop();
                        session = new Session(m_Computer, app, m_Preferences);
                        emit q->sessionCreated(app.name, session);
                    } else {
-                        m_State = StateFailure;
-                        QString msg = QString("%1 is already running. Please quit %1 to stream %2.")
-                                .arg(getCurrentAppName(), app.name);
-                        emit q->failed(msg);
+                        emit q->appQuitRequired(getCurrentAppName());
                    }
                }
            }
            break;
+        // Occurs when there was another app running on computer and user accepted quit
+        // confirmation dialog
+        case Event::AppQuitRequested:
+            if (m_State == StateSeekApp) {
+                m_ComputerManager->quitRunningApp(m_Computer);
+            }
+            break;
+        // Occurs when the previous app quit has been completed, handles quitting errors if any
+        // happended. ComputerUpdated event's handler handles session start when previous app has
+        // quit.
+        case Event::AppQuitCompleted:
+            if (m_State == StateSeekApp && !event.errorMessage.isEmpty()) {
+                m_State = StateFailure;
+                emit q->failed(QString("Quitting app failed, reason: %1").arg(event.errorMessage));
+            }
+            break;
+        // Occurs when computer or app search timed out
        case Event::Timedout:
            if (m_State == StateSeekComputer) {
                m_State = StateFailure;
@@ -114,26 +140,6 @@ public:
        }
    }

-    bool matchComputer(NvComputer *computer) const
-    {
-        QString value = m_ComputerName.toLower();
-        return computer->name.toLower() == value ||
-               computer->localAddress.toLower() == value ||
-               computer->remoteAddress.toLower() == value ||
-               computer->manualAddress.toLower() == value ||
-               computer->uuid.toLower() == value;
-    }
-
-    bool isOnline(NvComputer *computer) const
-    {
-        return computer->state == NvComputer::CS_ONLINE;
-    }
-
-    bool isPaired(NvComputer *computer) const
-    {
-        return computer->pairState == NvComputer::PS_PAIRED;
-    }
-
    int getAppIndex() const
    {
        for (int i = 0; i < m_Computer->appList.length(); i++) {
@@ -169,6 +175,7 @@ public:
    QString m_AppName;
    StreamingPreferences *m_Preferences;
    ComputerManager *m_ComputerManager;
+    ComputerSeeker *m_ComputerSeeker;
    NvComputer *m_Computer;
    State m_State;
    QTimer *m_TimeoutTimer;
@@ -202,6 +209,27 @@ void Launcher::execute(ComputerManager *manager)
    d->handleEvent(event);
 }

+void Launcher::quitRunningApp()
+{
+    Q_D(Launcher);
+    Event event(Event::AppQuitRequested);
+    d->handleEvent(event);
+}
+
+bool Launcher::isExecuted() const
+{
+    Q_D(const Launcher);
+    return d->m_State != StateInit;
+}
+
+void Launcher::onComputerFound(NvComputer *computer)
+{
+    Q_D(Launcher);
+    Event event(Event::ComputerFound);
+    event.computer = computer;
+    d->handleEvent(event);
+}
+
 void Launcher::onComputerUpdated(NvComputer *computer)
 {
    Q_D(Launcher);
@@ -217,4 +245,12 @@ void Launcher::onTimeout()
    d->handleEvent(event);
 }

+void Launcher::onQuitAppCompleted(QVariant error)
+{
+    Q_D(Launcher);
+    Event event(Event::AppQuitCompleted);
+    event.errorMessage = error.toString();
+    d->handleEvent(event);
+}
+
 }
@@ -1,6 +1,7 @@
 #pragma once

 #include <QObject>
+#include <QVariant>

 class ComputerManager;
 class NvComputer;
@@ -24,16 +25,21 @@ public:
                      QObject *parent = nullptr);
    ~Launcher();
    Q_INVOKABLE void execute(ComputerManager *manager);
+    Q_INVOKABLE void quitRunningApp();
+    Q_INVOKABLE bool isExecuted() const;

 signals:
    void searchingComputer();
    void searchingApp();
    void sessionCreated(QString appName, Session *session);
    void failed(QString text);
+    void appQuitRequired(QString appName);

 private slots:
+    void onComputerFound(NvComputer *computer);
    void onComputerUpdated(NvComputer *computer);
    void onTimeout();
+    void onQuitAppCompleted(QVariant error);

 private:
    QScopedPointer<LauncherPrivate> m_DPtr;
@@ -4,7 +4,7 @@
 	<metadata_license>CC0-1.0</metadata_license>
 	<project_license>GPL-3.0+</project_license>
 	<name>Moonlight</name>
-	<summary>Stream games from your NVIDIA GameStream-enabled PC</summary>
+	<summary>Play games remotely from your NVIDIA GameStream-enabled PC</summary>

 	<description>
 		<p>Moonlight can stream games and other applications from a PC with an NVIDIA GeForce GTX 600-series or higher GPU and GeForce Experience installed.</p>
@@ -19,20 +19,129 @@
 		</ul>
 	</description>

-	<url type="homepage">https://moonlight-stream.com</url>
+	<url type="homepage">https://moonlight-stream.org</url>
 	<url type="bugtracker">https://github.com/moonlight-stream/moonlight-qt/issues</url>
 	<url type="help">https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide</url>

 	<screenshots>
 		<screenshot type="default">
-			<image>https://moonlight-stream.com/appstream_resources/moonlight_screenshot_1.png</image>
+			<image>https://moonlight-stream.org/appstream_resources/moonlight_screenshot_1.png</image>
 		</screenshot>
 		<screenshot>
-			<image>https://moonlight-stream.com/appstream_resources/moonlight_screenshot_2.png</image>
+			<image>https://moonlight-stream.org/appstream_resources/moonlight_screenshot_2.png</image>
 		</screenshot>
 	</screenshots>

 	<releases>
+		<release version="0.8.1" date="2019-01-08">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Stricter adherence to the specified bitrate when streaming over the Internet</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed audio crackling that impacted certain systems</li>
+					<li>Fixed Wake-on-LAN packets failing to send on some systems</li>
+					<li>Reduced audio latency when resuming a session where audio is already playing</li>
+					<li>Added option to enable the old SDL audio renderer by setting ML_AUDIO=SDL</li>
+					<li>Updated to use the new Qt 5.12 Flatpak runtime</li>
+					<li>Updated to FFmpeg 4.1</li>
+					<li>Minor UI tweaks</li>
+				</ul>
+			</description>
+		</release>
+		<release version="0.8.0" date="2018-12-25">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Improved security of pairing - After this update, you must re-pair with your PC!</li>
+					<li>Enabled quitting games started by other Moonlight clients also running this update</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed the video bitrate slider not working above certain values on GFE 3.16</li>
+					<li>Fixed broken Bluetooth audio with PulseAudio</li>
+					<li>Reduced audio latency</li>
+					<li>Fixed some non-gamepad devices triggering the unmapped gamepad dialog box</li>
+					<li>Minor UI tweaks</li>
+				</ul>
+			</description>
+		</release>
+		<release version="0.7.0" date="2018-12-05">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added option to quit the app after stopping the stream</li>
+					<li>Added CLI option to quit the running app</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Switched to libsoundio backend to address audio glitches and reduce latency</li>
+					<li>Fixed CLI version output</li>
+					<li>Fixed streaming error messages not showing up when launching from CLI</li>
+					<li>Updated included SDL gamepad mappings</li>
+					<li>Various minor UI tweaks</li>
+				</ul>
+			</description>
+		</release>
+		<release version="0.6.4" date="2018-11-20">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added an option to match client display refresh rate when FPS is unlocked</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed multiple gamepads not being detected on the host in some scenarios</li>
+					<li>Fixed an incorrect warning when trying to stream at 4K</li>
+				</ul>
+			</description>
+		</release>
+		<release version="0.6.3" date="2018-11-16">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added support for GeForce Experience 3.16</li>
+					<li>Added an option to force Moonlight to start in windowed mode</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed scrolling not working on the settings page</li>
+					<li>Skipped using proxy servers when attempting to stream</li>
+					<li>Fixed a couple possible crashes</li>
+					<li>Renamed the mouse acceleration option to be more clear</li>
+				</ul>
+			</description>
+		</release>
+		<release version="0.6.2" date="2018-10-28">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added automatic IP address detection for Internet streaming</li>
+					<li>Added a quit shortcut tip for gamepad users</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Fixed server state polling not being stopped while streaming</li>
+				</ul>
+			</description>
+		</release>
+		<release version="0.6.1" date="2018-10-14">
+			<description>
+				<p>New features:</p>
+				<ul>
+					<li>Added support for quitting Moonlight via gamepad</li>
+					<li>Added tooltips for games with very long names</li>
+				</ul>
+				<p>Bugfixes:</p>
+				<ul>
+					<li>Added a workaround for a memory leak in the VAAPI driver for AMD GPUs</li>
+					<li>Fixed combo boxes on the settings page being too small for certain DPI scaling</li>
+					<li>Reduced power usage when Moonlight is idling in the background for a while</li>
+				</ul>
+			</description>
+		</release>
 		<release version="0.6.0" date="2018-10-06">
 			<description>
 				<p>New features:</p>
@@ -157,7 +266,7 @@
 	</categories>

 	<developer_name>Moonlight Game Streaming Team</developer_name>
-	<update_contact>cameron@moonlight-stream.com</update_contact>
+	<update_contact>cameron@moonlight-stream.org</update_contact>

 	<launchable type="desktop-id">com.moonlight_stream.Moonlight.desktop</launchable>

@@ -89,10 +89,9 @@ GridView {
            }
        }

-        Text {
+        Label {
            id: appNameText
            text: model.name
-            color: "white"
            width: parent.width
            height: 125
            anchors.top: appIcon.bottom
@@ -100,6 +99,12 @@ GridView {
            horizontalAlignment: Text.AlignHCenter
            wrapMode: Text.Wrap
            elide: Text.ElideRight
+
+            // Display a tooltip with the full name if it's truncated
+            ToolTip.text: model.name
+            ToolTip.delay: 1000
+            ToolTip.timeout: 5000
+            ToolTip.visible: (parent.hovered || parent.highlighted) && truncated
        }

        function launchOrResumeSelectedApp()
@@ -129,7 +134,13 @@ GridView {
            acceptedButtons: Qt.RightButton
            onClicked: {
                // popup() ensures the menu appears under the mouse cursor
-                appContextMenu.popup()
+                if (appContextMenu.popup) {
+                    appContextMenu.popup()
+                }
+                else {
+                    // Qt 5.9 doesn't have popup()
+                    appContextMenu.open()
+                }
            }
        }

@@ -1,4 +1,4 @@
-import QtQuick 2.11
+import QtQuick 2.9
 import QtQuick.Controls 2.2

 // https://stackoverflow.com/questions/45029968/how-do-i-set-the-combobox-width-to-fit-the-largest-item
@@ -9,17 +9,17 @@ ComboBox {

    TextMetrics {
        id: popupMetrics
-        font: popup.font
    }

    TextMetrics {
        id: textMetrics
-        font: parent.font
    }

    // We call this every time the options change (and init)
    // so we can adjust the combo box width here too
    onActivated: {
+        textMetrics.font = font
+        popupMetrics.font = popup.font
        textWidth = 0
        for (var i = 0; i < count; i++){
            textMetrics.text = textAt(i)
@@ -0,0 +1,70 @@
+import QtQuick 2.0
+import QtQuick.Controls 2.2
+import QtQuick.Dialogs 1.2
+
+import ComputerManager 1.0
+import Session 1.0
+
+Item {
+    anchors.fill: parent
+
+    function onSearchingComputer() {
+        stageLabel.text = "Establishing connection to PC..."
+    }
+
+    function onQuittingApp() {
+        stageLabel.text = "Quitting app..."
+    }
+
+    function onFailure(message) {
+        errorDialog.text = message
+        errorDialog.open()
+    }
+
+    // The StackView will trigger a visibility change when
+    // we're pushed onto it, causing our onVisibleChanged
+    // routine to run, but only if we start as invisible
+    visible: false
+
+    onVisibleChanged: {
+        if (visible && !launcher.isExecuted()) {
+            toolBar.visible = false
+            launcher.searchingComputer.connect(onSearchingComputer)
+            launcher.quittingApp.connect(onQuittingApp)
+            launcher.failed.connect(onFailure)
+            launcher.execute(ComputerManager)
+        }
+    }
+
+    Row {
+        anchors.centerIn: parent
+        spacing: 5
+
+        BusyIndicator {
+            id: stageSpinner
+        }
+
+        Label {
+            id: stageLabel
+            height: stageSpinner.height
+            text: stageText
+            font.pointSize: 20
+            verticalAlignment: Text.AlignVCenter
+
+            wrapMode: Text.Wrap
+        }
+    }
+
+    MessageDialog {
+        id: errorDialog
+        modality:Qt.WindowModal
+        icon: StandardIcon.Critical
+        standardButtons: StandardButton.Ok
+
+        onVisibleChanged: {
+            if (!visible) {
+                Qt.quit()
+            }
+        }
+    }
+}
@@ -1,3 +1,4 @@
+import QtQml 2.2
 import QtQuick 2.0
 import QtQuick.Controls 2.2
 import QtQuick.Dialogs 1.2
@@ -30,13 +31,19 @@ Item {
        errorDialog.open()
    }

+    function onAppQuitRequired(appName) {
+        quitAppDialog.appName = appName
+        quitAppDialog.open()
+    }
+
    onVisibleChanged: {
-        if (visible) {
+        if (visible && !launcher.isExecuted()) {
            toolBar.visible = false
            launcher.searchingComputer.connect(onSearchingComputer)
            launcher.searchingApp.connect(onSearchingApp)
            launcher.sessionCreated.connect(onSessionCreated)
            launcher.failed.connect(onLaunchFailed)
+            launcher.appQuitRequired.connect(onAppQuitRequired)
            launcher.execute(ComputerManager)
        }
    }
@@ -56,7 +63,6 @@ Item {
            verticalAlignment: Text.AlignVCenter

            wrapMode: Text.Wrap
-            color: "white"
        }
    }

@@ -75,4 +81,44 @@ Item {
        }
    }

+    MessageDialog {
+        id: quitAppDialog
+        modality:Qt.WindowModal
+        text:"Are you sure you want to quit " + appName +"? Any unsaved progress will be lost."
+        standardButtons: StandardButton.Yes | StandardButton.No
+        property string appName : ""
+
+        function quitApp() {
+            var component = Qt.createComponent("QuitSegue.qml")
+            var params = {"appName": appName}
+            stackView.push(component.createObject(stackView, params))
+            // Trigger the quit after pushing the quit segue on screen
+            launcher.quitRunningApp()
+        }
+
+        onYes: quitApp()
+
+        // For keyboard/gamepad navigation
+        onAccepted: quitApp()
+
+        // Exit process if app quit is rejected (reacts also to closing of the
+        // dialog from title bar's close button).
+        // Note: this depends on undocumented behavior of visibleChanged()
+        // signal being emitted before yes() or accepted() has been emitted.
+        onVisibleChanged: {
+            if (!visible) {
+                quitTimer.start()
+            }
+        }
+        Component.onCompleted: {
+            yes.connect(quitTimer.stop)
+            accepted.connect(quitTimer.stop)
+        }
+    }
+
+    Timer {
+        id: quitTimer
+        interval: 100
+        onTriggered: Qt.quit()
+    }
 }
@@ -124,10 +124,9 @@ GridView {
            visible: !model.addPc && model.statusUnknown
        }

-        Text {
+        Label {
            id: pcNameText
            text: model.name
-            color: "white"

            width: parent.width
            anchors.top: pcIcon.bottom
@@ -193,7 +192,13 @@ GridView {
            onClicked: {
                if (!model.addPc) {
                    // popup() ensures the menu appears under the mouse cursor
-                    pcContextMenu.popup()
+                    if (pcContextMenu.popup) {
+                        pcContextMenu.popup()
+                    }
+                    else {
+                        // Qt 5.9 doesn't have popup()
+                        pcContextMenu.open()
+                    }
                }
            }
        }
@@ -65,7 +65,6 @@ Item {
            verticalAlignment: Text.AlignVCenter

            wrapMode: Text.Wrap
-            color: "white"
        }
    }

@@ -5,9 +5,24 @@ import StreamingPreferences 1.0
 import ComputerManager 1.0
 import SdlGamepadKeyNavigation 1.0

-ScrollView {
+Flickable {
    id: settingsPage
    objectName: "Settings"
+    anchors.fill: parent
+
+    contentWidth: settingsColumn1.width > settingsColumn2.width ? settingsColumn1.width : settingsColumn2.width
+    contentHeight: settingsColumn1.height > settingsColumn2.height ? settingsColumn1.height : settingsColumn2.height
+
+    ScrollBar.vertical: ScrollBar {
+        parent: settingsPage.parent
+        anchors {
+            top: settingsPage.top
+            left: settingsPage.right
+            bottom: settingsPage.bottom
+
+            leftMargin: -10
+        }
+    }

    StreamingPreferences {
        id: prefs
@@ -57,17 +72,15 @@ ScrollView {
                    id: resFPStitle
                    text: qsTr("Resolution and FPS")
                    font.pointSize: 12
-                    wrapMode: Text.Wrap                    
-                    color: "white"
+                    wrapMode: Text.Wrap
                }

                Label {
                    width: parent.width
                    id: resFPSdesc
-                    text: qsTr("Setting values too high for your PC may cause lag, stuttering, or errors.")
+                    text: qsTr("Setting values too high for your PC or network connection may cause lag, stuttering, or errors.")
                    font.pointSize: 9
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                Row {
@@ -211,7 +224,16 @@ ScrollView {
                            // Use 64 as the cutoff for adding a separate option to
                            // handle wonky displays that report just over 60 Hz.
                            if (max_fps > 64) {
-                                fpsListModel.append({"text": max_fps+" FPS", "video_fps": ""+max_fps})
+                                // Mark any FPS value greater than 120 as unsupported
+                                if (prefs.unsupportedFps && max_fps > 120) {
+                                    fpsListModel.append({"text": max_fps+" FPS (Unsupported)", "video_fps": ""+max_fps})
+                                }
+                                else if (max_fps > 120) {
+                                    fpsListModel.append({"text": "120 FPS", "video_fps": "120"})
+                                }
+                                else {
+                                    fpsListModel.append({"text": max_fps+" FPS", "video_fps": ""+max_fps})
+                                }
                            }

                            // Add unsupported FPS values that come after the display max FPS
@@ -273,21 +295,18 @@ ScrollView {
                    text: qsTr("Video bitrate: ")
                    font.pointSize: 12
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                Label {
                    width: parent.width
                    id: bitrateDesc
-                    text: qsTr("Lower bitrate to reduce lag and stuttering. Raise bitrate to increase image quality.")
+                    text: qsTr("Lower the bitrate on slower connections. Raise the bitrate to increase image quality.")
                    font.pointSize: 9
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                Slider {
                    id: slider
-                    wheelEnabled: true

                    value: prefs.bitrateKbps

@@ -310,7 +329,6 @@ ScrollView {
                    text: qsTr("Display mode")
                    font.pointSize: 12
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                AutoResizingComboBox {
@@ -329,6 +347,7 @@ ScrollView {
                    }

                    id: windowModeComboBox
+                    hoverEnabled: true
                    textRole: "text"
                    model: ListModel {
                        id: windowModeListModel
@@ -348,16 +367,43 @@ ScrollView {
                    onActivated: {
                        prefs.windowMode = windowModeListModel.get(currentIndex).val
                    }
+
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 5000
+                    ToolTip.visible: hovered
+                    ToolTip.text: "Full-screen generally provides the best performance, but borderless windowed may work better with features like macOS Spaces, Alt+Tab, screenshot tools, on-screen overlays, etc."
                }

                CheckBox {
                    id: vsyncCheck
-                    text: "<font color=\"white\">Enable V-Sync</font>"
+                    hoverEnabled: true
+                    text: "V-Sync"
                    font.pointSize:  12
                    checked: prefs.enableVsync
                    onCheckedChanged: {
                        prefs.enableVsync = checked
                    }
+
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 5000
+                    ToolTip.visible: hovered
+                    ToolTip.text: "Disabling V-Sync allows sub-frame rendering latency, but it can display visible tearing"
+                }
+
+                CheckBox {
+                    id: framePacingCheck
+                    hoverEnabled: true
+                    text: "Frame pacing"
+                    font.pointSize:  12
+                    enabled: prefs.enableVsync
+                    checked: prefs.enableVsync && prefs.framePacing
+                    onCheckedChanged: {
+                        prefs.framePacing = checked
+                    }
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 5000
+                    ToolTip.visible: hovered
+                    ToolTip.text: "Frame pacing reduces micro-stutter by delaying frames that come in too early"
                }
            }
        }
@@ -380,7 +426,6 @@ ScrollView {
                    text: qsTr("Audio configuration")
                    font.pointSize: 12
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                AutoResizingComboBox {
@@ -419,6 +464,29 @@ ScrollView {

            }
        }
+
+        GroupBox {
+            id: uiSettingsGroupBox
+            width: (parent.width - 2 * parent.padding)
+            padding: 12
+            title: "<font color=\"skyblue\">UI Settings</font>"
+            font.pointSize: 12
+
+            Column {
+                anchors.fill: parent
+                spacing: 5
+
+                CheckBox {
+                    id: startMaximizedCheck
+                    text: "Maximize Moonlight window on startup"
+                    font.pointSize: 12
+                    checked: !prefs.startWindowed
+                    onCheckedChanged: {
+                        prefs.startWindowed = !checked
+                    }
+                }
+            }
+        }
    }

    Column {
@@ -434,28 +502,40 @@ ScrollView {
            title: "<font color=\"skyblue\">Input Settings</font>"
            font.pointSize: 12

-            Row {
+            Column {
                anchors.fill: parent
                spacing: 5

                CheckBox {
-                    id: multiControllerCheck
-                    text: "<font color=\"white\">Multiple controller support</font>"
+                    id: singleControllerCheck
+                    text: "Force gamepad #1 always present"
                    font.pointSize:  12
-                    checked: prefs.multiController
+                    checked: !prefs.multiController
                    onCheckedChanged: {
-                        prefs.multiController = checked
+                        prefs.multiController = !checked
                    }
+
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 5000
+                    ToolTip.visible: hovered
+                    ToolTip.text: "Forces a single gamepad to always stay connected to the host, even if no gamepads are actually connected to this PC.\n" +
+                                  "Only enable this option when streaming a game that doesn't support gamepads being connected after startup."
                }

                CheckBox {
-                    id: mouseAccelerationCheck
-                    text: "<font color=\"white\">Enable mouse acceleration</font>"
+                    id: rawInputCheck
+                    hoverEnabled: true
+                    text: "Raw mouse input"
                    font.pointSize:  12
-                    checked: prefs.mouseAcceleration
+                    checked: !prefs.mouseAcceleration
                    onCheckedChanged: {
-                        prefs.mouseAcceleration = checked
+                        prefs.mouseAcceleration = !checked
                    }
+
+                    ToolTip.delay: 1000
+                    ToolTip.timeout: 3000
+                    ToolTip.visible: hovered
+                    ToolTip.text: "When checked, mouse input is not accelerated or scaled by the OS before passing to Moonlight"
                }
            }
        }
@@ -467,15 +547,13 @@ ScrollView {
            title: "<font color=\"skyblue\">Host Settings</font>"
            font.pointSize: 12

-            Row {
+            Column {
                anchors.fill: parent
                spacing: 5

                CheckBox {
                    id: optimizeGameSettingsCheck
-                    text: "<font color=\"white\">Optimize game settings</font>"
-                    // HACK: Match width of the other checkbox to make the UI not look bad
-                    width: multiControllerCheck.width
+                    text: "Optimize game settings"
                    font.pointSize:  12
                    checked: prefs.gameOptimizations
                    onCheckedChanged: {
@@ -485,7 +563,7 @@ ScrollView {

                CheckBox {
                    id: audioPcCheck
-                    text: "<font color=\"white\">Play audio on host PC</font>"
+                    text: "Play audio on host PC"
                    font.pointSize:  12
                    checked: prefs.playAudioOnHost
                    onCheckedChanged: {
@@ -512,7 +590,6 @@ ScrollView {
                    text: qsTr("Video decoder")
                    font.pointSize: 12
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                AutoResizingComboBox {
@@ -559,7 +636,6 @@ ScrollView {
                    text: qsTr("Video codec")
                    font.pointSize: 12
                    wrapMode: Text.Wrap
-                    color: "white"
                }

                AutoResizingComboBox {
@@ -609,7 +685,7 @@ ScrollView {

                CheckBox {
                    id: unlockUnsupportedFps
-                    text: "<font color=\"white\">Unlock unsupported FPS options</font>"
+                    text: "Unlock unsupported FPS options"
                    font.pointSize: 12
                    checked: prefs.unsupportedFps
                    onCheckedChanged: {
@@ -623,7 +699,7 @@ ScrollView {

                CheckBox {
                    id: enableMdns
-                    text: "<font color=\"white\">Automatically find PCs on the local network (Recommended)</font>"
+                    text: "Automatically find PCs on the local network (Recommended)"
                    font.pointSize: 12
                    checked: prefs.enableMdns
                    onCheckedChanged: {
@@ -640,6 +716,16 @@ ScrollView {
                        }
                    }
                }
+
+                CheckBox {
+                    id: quitAppAfter
+                    text: "Quit app after quitting session"
+                    font.pointSize: 12
+                    checked: prefs.quitAppAfter
+                    onCheckedChanged: {
+                        prefs.quitAppAfter = checked
+                    }
+                }
            }
        }
    }
@@ -3,6 +3,8 @@ import QtQuick.Controls 2.2
 import QtQuick.Dialogs 1.2
 import QtQuick.Window 2.2

+import ComputerManager 1.0
+import SdlGamepadKeyNavigation 1.0
 import Session 1.0

 Item {
@@ -58,40 +60,77 @@ Item {
        toast.visible = true
    }

+    function quitStarting()
+    {
+        // Avoid the push transition animation
+        var component = Qt.createComponent("QuitSegue.qml")
+        stackView.replace(stackView.currentItem, component.createObject(stackView, {"appName": appName}), StackView.Immediate)
+
+        // Show the Qt window again to show quit segue
+        window.visible = true
+    }
+
+    function sessionFinished()
+    {
+        if (quitAfter) {
+            if (errorDialog.text) {
+                // Quit when the error dialog is acknowledged
+                errorDialog.open()
+            }
+            else {
+                // Quit immediately
+                Qt.quit()
+            }
+        } else {
+            // Exit this view
+            stackView.pop()
+
+            // Show the Qt window again after streaming
+            window.visible = true
+
+            // Display any launch errors. We do this after
+            // the Qt UI is visible again to prevent losing
+            // focus on the dialog which would impact gamepad
+            // users.
+            if (errorDialog.text) {
+                errorDialog.open()
+            }
+        }
+    }
+
+    // It's important that we don't call enable() here
+    // or it may interfere with the Session instance
+    // getting notified of initial connected gamepads.
+    SdlGamepadKeyNavigation {
+        id: gamepadKeyNav
+    }
+
    onVisibleChanged: {
        if (visible) {
            // Hide the toolbar before we start loading
            toolBar.visible = false

+            // Set the hint text. We do this here rather than
+            // in the hintText control itself to synchronize
+            // with Session.exec() which requires no concurrent
+            // gamepad usage.
+            hintText.text = gamepadKeyNav.getConnectedGamepads() > 0 ?
+                      "Tip: Press Start+Select+L1+R1 to disconnect your session" :
+                      "Tip: Press Ctrl+Alt+Shift+Q to disconnect your session"
+
            // Hook up our signals
            session.stageStarting.connect(stageStarting)
            session.stageFailed.connect(stageFailed)
            session.connectionStarted.connect(connectionStarted)
            session.displayLaunchError.connect(displayLaunchError)
            session.displayLaunchWarning.connect(displayLaunchWarning)
+            session.quitStarting.connect(quitStarting)
+            session.sessionFinished.connect(sessionFinished)

            // Run the streaming session to completion
            session.exec(Screen.virtualX, Screen.virtualY)
-
-            if (quitAfter) {
-                Qt.quit()
-            } else {
-                // Show the Qt window again after streaming
-                window.visible = true
-
-                // Exit this view
-                stackView.pop()
-
-                // Display any launch errors. We do this after
-                // the Qt UI is visible again to prevent losing
-                // focus on the dialog which would impact gamepad
-                // users.
-                if (errorDialog.text) {
-                    errorDialog.open()
-                }
-            }
        }
-        else {
+        else if (!quitAfter) {
            // Show the toolbar again when we become hidden
            toolBar.visible = true
        }
@@ -113,12 +152,11 @@ Item {
            verticalAlignment: Text.AlignVCenter

            wrapMode: Text.Wrap
-            color: "white"
        }
    }

    Label {
-        text: "Tip: Press Ctrl+Alt+Shift+Q to disconnect your session"
+        id: hintText
        anchors.bottom: parent.bottom
        anchors.bottomMargin: 50
        anchors.horizontalCenter: parent.horizontalCenter
@@ -126,7 +164,6 @@ Item {
        verticalAlignment: Text.AlignVCenter

        wrapMode: Text.Wrap
-        color: "white"
    }

    MessageDialog {
@@ -134,8 +171,19 @@ Item {
        modality:Qt.WindowModal
        icon: StandardIcon.Critical
        standardButtons: StandardButton.Ok | StandardButton.Help
+
+        onAccepted: {
+            if (quitAfter) {
+                Qt.quit()
+            }
+        }
+
        onHelp: {
            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting");
+
+            if (quitAfter) {
+                Qt.quit()
+            }
        }
    }
 }
@@ -18,11 +18,7 @@ ApplicationWindow {
    width: 1280
    height: 600

-    // Maximize the window by default when the stream is configured
-    // for full-screen or borderless windowed. This is ideal for TV
-    // setups where the user doesn't want a tiny window in the middle
-    // of their screen when starting Moonlight.
-    visibility: prefs.windowMode != StreamingPreferences.WM_WINDOWED ? "Maximized" : "Windowed"
+    visibility: prefs.startWindowed ? "Windowed" : "Maximized"

    Material.theme: Material.Dark
    Material.accent: Material.Purple
@@ -48,12 +44,18 @@ ApplicationWindow {
            if (depth > 1) {
                stackView.pop()
            }
+            else {
+                quitConfirmationDialog.open()
+            }
        }

        Keys.onBackPressed: {
            if (depth > 1) {
                stackView.pop()
            }
+            else {
+                quitConfirmationDialog.open()
+            }
        }

        Keys.onMenuPressed: {
@@ -68,21 +70,59 @@ ApplicationWindow {
        }
    }

-    onVisibilityChanged: {
-        // We don't want to just use 'active' here because that will stop polling if
-        // we lose focus, which might be overzealous for users with multiple screens
-        // where we may be clearly visible on the other display. Ideally we'll poll
-        // only if the window is visible to the user (not if obscured by other windows),
-        // but it seems difficult to do this portably.
-        var shouldPoll = visibility !== Window.Minimized && visibility !== Window.Hidden
-
-        if (shouldPoll && !pollingActive) {
-            ComputerManager.startPolling()
-            pollingActive = true
+    // This timer keeps us polling for 5 minutes of inactivity
+    // to allow the user to work with Moonlight on a second display
+    // while dealing with configuration issues. This will ensure
+    // machines come online even if the input focus isn't on Moonlight.
+    Timer {
+        id: inactivityTimer
+        interval: 5 * 60000
+        onTriggered: {
+            if (!active && pollingActive) {
+                ComputerManager.stopPollingAsync()
+                pollingActive = false
+            }
        }
-        else if (!shouldPoll && pollingActive) {
-            ComputerManager.stopPollingAsync()
-            pollingActive = false
+    }
+
+    onVisibleChanged: {
+        // When we become invisible while streaming is going on,
+        // stop polling immediately.
+        if (!visible) {
+            inactivityTimer.stop()
+
+            if (pollingActive) {
+                ComputerManager.stopPollingAsync()
+                pollingActive = false
+            }
+        }
+        else if (active) {
+            // When we become visible and active again, start polling
+            inactivityTimer.stop()
+
+            // Restart polling if it was stopped
+            if (!pollingActive) {
+                ComputerManager.startPolling()
+                pollingActive = true
+            }
+        }
+    }
+
+    onActiveChanged: {
+        if (active) {
+            // Stop the inactivity timer
+            inactivityTimer.stop()
+
+            // Restart polling if it was stopped
+            if (!pollingActive) {
+                ComputerManager.startPolling()
+                pollingActive = true
+            }
+        }
+        else {
+            // Start the inactivity timer to stop polling
+            // if focus does not return within a few minutes.
+            inactivityTimer.restart()
        }
    }

@@ -97,6 +137,11 @@ ApplicationWindow {
        // Doing it earlier can lead to the dialog appearing behind
        // the window or otherwise without input focus.
        if (!initialized) {
+            // Set initialized before calling anything else, because
+            // pumping the event loop can cause us to get another
+            // onAfterRendering call and potentially reenter this code.
+            initialized = true;
+
            if (prefs.isRunningWayland()) {
                waylandDialog.open()
            }
@@ -112,8 +157,6 @@ ApplicationWindow {
                unmappedGamepadDialog.unmappedGamepads = unmappedGamepads
                unmappedGamepadDialog.open()
            }
-
-            initialized = true;
        }
    }

@@ -192,7 +235,6 @@ ApplicationWindow {
                ToolTip.delay: 1000
                ToolTip.timeout: 3000
                ToolTip.visible: hovered
-                ToolTip.text: "Update available for Moonlight"

                // Invisible until we get a callback notifying us that
                // an update is available
@@ -200,8 +242,9 @@ ApplicationWindow {

                onClicked: Qt.openUrlExternally(browserUrl);

-                function updateAvailable(url)
+                function updateAvailable(version, url)
                {
+                    ToolTip.text = "Update available for Moonlight: Version " + version
                    updateButton.browserUrl = url
                    updateButton.visible = true
                }
@@ -353,4 +396,18 @@ ApplicationWindow {
            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Gamepad-Mapping");
        }
    }
+
+    // This dialog appears when quitting via keyboard or gamepad button
+    MessageDialog {
+        id: quitConfirmationDialog
+        modality:Qt.WindowModal
+        icon: StandardIcon.Warning
+        standardButtons: StandardButton.Yes | StandardButton.No
+        text: "Are you sure you want to quit?"
+
+        onYes: Qt.quit()
+
+        // For keyboard/gamepad navigation
+        onAccepted: Qt.quit()
+    }
 }
@@ -244,3 +244,23 @@ void SdlGamepadKeyNavigation::setSettingsMode(bool settingsMode)
 {
    m_SettingsMode = settingsMode;
 }
+
+int SdlGamepadKeyNavigation::getConnectedGamepads()
+{
+    if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) failed: %s",
+                     SDL_GetError());
+        return 0;
+    }
+
+    int count = 0;
+    for (int i = 0; i < SDL_NumJoysticks(); i++) {
+        if (SDL_IsGameController(i)) {
+            count++;
+        }
+    }
+
+    SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
+    return count;
+}
@@ -20,6 +20,8 @@ public:

    Q_INVOKABLE void setSettingsMode(bool settingsMode);

+    Q_INVOKABLE int getConnectedGamepads();
+
 private:
    void sendKey(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers = Qt::NoModifier);

@@ -5,6 +5,7 @@
 #include <QQuickStyle>
 #include <QMutex>
 #include <QtDebug>
+#include <QNetworkProxyFactory>

 // Don't let SDL hook our main function, since Qt is already
 // doing the same thing. This needs to be before any headers
@@ -16,6 +17,11 @@
 #include "streaming/video/ffmpeg.h"
 #endif

+#ifdef Q_OS_WIN32
+#include "antihookingprotection.h"
+#endif
+
+#include "cli/quitstream.h"
 #include "cli/startstream.h"
 #include "cli/commandlineparser.h"
 #include "path.h"
@@ -130,6 +136,14 @@ void qtLogToDiskHandler(QtMsgType type, const QMessageLogContext&, const QString
        break;
    }

+    // HACK: Avoid printing this internal Qt warning which seems to print every time we
+    // start our event loop for the QNetworkReply. I have found this warning in many
+    // unrelated bug reports, but none actually tackle this warning itself. It seems to be
+    // new in Qt 5.12.
+    if (msg.startsWith("QNetworkReplyHttpImplPrivate::_q_startOperation was called more than once")) {
+        return;
+    }
+
    QTime logTime = QTime::fromMSecsSinceStartOfDay(s_LoggerTime.elapsed());
    QString txt = QString("%1 - Qt %2: %3\n").arg(logTime.toString()).arg(typeTxt).arg(msg);

@@ -217,6 +231,9 @@ LONG WINAPI UnhandledExceptionHandler(struct _EXCEPTION_POINTERS *ExceptionInfo)

 int main(int argc, char *argv[])
 {
+    // Set the app version for the QCommandLineParser's showVersion() command
+    QCoreApplication::setApplicationVersion(VERSION_STR);
+
    // Set these here to allow us to use the default QSettings constructor.
    // These also ensure that our cache directory is named correctly. As such,
    // it is critical that these be called before Path::initialize().
@@ -263,6 +280,12 @@ int main(int argc, char *argv[])
    SetUnhandledExceptionFilter(UnhandledExceptionHandler);
 #endif

+#ifdef Q_OS_WIN32
+    // Force AntiHooking.dll to be statically imported and loaded
+    // by ntdll by calling a dummy function.
+    AntiHookingDummyImport();
+#endif
+
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    // This avoids using the default keychain for SSL, which may cause
@@ -278,6 +301,13 @@ int main(int argc, char *argv[])
    }
 #endif

+    // We don't want system proxies to apply to us
+    QNetworkProxyFactory::setUseSystemConfiguration(false);
+
+    // Clear any default application proxy
+    QNetworkProxy noProxy(QNetworkProxy::NoProxy);
+    QNetworkProxy::setApplicationProxy(noProxy);
+
    // Register custom metatypes for use in signals
    qRegisterMetaType<NvApp>("NvApp");

@@ -324,6 +354,15 @@ int main(int argc, char *argv[])
            engine.rootContext()->setContextProperty("launcher", launcher);
            break;
        }
+    case GlobalCommandLineParser::QuitRequested:
+        {
+            initialView = "CliQuitStreamSegue.qml";
+            QuitCommandLineParser quitParser;
+            quitParser.parse(app.arguments());
+            auto launcher = new CliQuitStream::Launcher(quitParser.getHost(), &app);
+            engine.rootContext()->setContextProperty("launcher", launcher);
+            break;
+        }
    }

    engine.rootContext()->setContextProperty("initialView", initialView);
@@ -334,7 +373,7 @@ int main(int argc, char *argv[])
        return -1;

    SDL_SetMainReady();
-    if (SDL_Init(0) != 0) {
+    if (SDL_Init(SDL_INIT_TIMER) != 0) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                     "SDL_Init() failed: %s",
                     SDL_GetError());
@@ -351,5 +390,9 @@ int main(int argc, char *argv[])

    int err = app.exec();

+    // Give worker tasks time to properly exit. Fixes PendingQuitTask
+    // sometimes freezing and blocking process exit.
+    QThreadPool::globalInstance()->waitForDone(30000);
+
    return err;
 }
@@ -10,6 +10,7 @@
        <file>gui/NavigableToolButton.qml</file>
        <file>gui/NavigableItemDelegate.qml</file>
        <file>gui/NavigableMenuItem.qml</file>
+        <file>gui/CliQuitStreamSegue.qml</file>
        <file>gui/CliStartStreamSegue.qml</file>
        <file>gui/AutoResizingComboBox.qml</file>
    </qresource>
@@ -1,69 +1 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   id="svg3761"
-   viewBox="0 0 680 680"
-   height="680"
-   width="680"
-   version="1.0">
-  <metadata
-     id="metadata3767">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <defs
-     id="defs3765" />
-  <g
-     id="g3759"
-     transform="translate(-135,491) scale(0.100000,-0.100000)">
-    <circle
-       id="circle3741"
-       fill="#565C64"
-       r="3400"
-       cy="1505"
-       cx="4755" />
-    <path
-       id="path3743"
-       style="fill:#ffffff"
-       d="M4550 4230 c-582 -48 -1123 -271 -1568 -646 l-84 -70 869 -869 c477 -477 871 -868 876 -868 4 0 6 552 5 1228 l-3 1227 -25 1 c-14 0 -45 -1 -70 -3z" />
-    <path
-       id="path3745"
-       style="fill:#ffffff"
-       d="M4867 4230 c-10 -9 -9 -2453 1 -2453 4 0 398 391 875 868 l869 869 -84 70 c-344 290 -749 492 -1178 587 -166 36 -469 74 -483 59z" />
-    <path
-       id="path3747"
-       style="fill:#ffffff"
-       d="M2673 3275 c-241 -285 -412 -595 -526 -953 -63 -196 -111 -458 -119 -640 l-3 -70 1228 -3 c675 -1 1227 1 1227 5 0 5 -391 399 -868 876 l-869 869 -70 -84z" />
-    <path
-       id="path3749"
-       style="fill:#ffffff"
-       d="M5898 2490 c-478 -477 -868 -871 -868 -876 0 -4 552 -6 1228 -5 l1227 3 -3 70 c-14 326 -124 729 -287 1055 -91 182 -259 430 -387 573 l-43 48 -867 -868z" />
-    <path
-       id="path3751"
-       style="fill:#ffffff"
-       d="M2026 1388 c-7 -11 10 -198 30 -321 76 -486 291 -952 617 -1338 l70 -84 869 869 c477 477 868 871 868 875 0 11 -2448 10 -2454 -1z" />
-    <path
-       id="path3753"
-       style="fill:#ffffff"
-       d="M5030 1390 c0 -5 391 -399 868 -876 l869 -869 70 84 c241 285 412 595 526 953 63 196 111 458 119 640 l3 70 -1227 3 c-676 1 -1228 -1 -1228 -5z" />
-    <path
-       id="path3755"
-       style="fill:#ffffff"
-       d="M3767 359 l-869 -869 84 -70 c285 -241 595 -412 953 -526 196 -63 458 -111 640 -119 l70 -3 3 1228 c1 675 -1 1227 -5 1227 -5 0 -399 -391 -876 -868z" />
-    <path
-       id="path3757"
-       style="fill:#ffffff"
-       d="M4862 0 l3 -1228 70 3 c182 8 444 56 640 119 358 114 668 285 953 526 l84 70 -869 869 c-477 477 -871 868 -876 868 -4 0 -6 -552 -5 -1227z" />
-  </g>
-</svg>
+<?xml version="1.0" standalone="no"?><!-- Generator: Gravit.io --><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="isolation:isolate" viewBox="0 0 256 256" width="256" height="256"><g><circle vector-effect="non-scaling-stroke" cx="128" cy="128" r="128" fill="rgb(86,92,100)"/><circle vector-effect="non-scaling-stroke" cx="128.00000000000003" cy="128.00000000000003" r="96" fill="rgb(255,255,255)"/><path d=" M 137.66 132 L 224 132 L 224 124 L 137.66 124 L 198.71 62.95 L 193.05 57.29 L 132 118.34 L 132 32 L 124 32 L 124 118.34 L 62.95 57.29 L 57.29 62.95 L 118.34 124 L 32 124 L 32 132 L 118.34 132 L 57.29 193.05 L 62.95 198.71 L 124 137.66 L 124 224 L 132 224 L 132 137.66 L 193.05 198.71 L 198.71 193.05 L 137.66 132 Z " fill-rule="evenodd" fill="rgb(86,92,100)"/></g></svg>
@@ -1,3 +1,3 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24" fill="#0BF200">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="24" height="24" viewBox="0 0 24 24" fill="#FF0000">
    <path d="M21,10.12H14.22L16.96,7.3C14.23,4.6 9.81,4.5 7.08,7.2C4.35,9.91 4.35,14.28 7.08,17C9.81,19.7 14.23,19.7 16.96,17C18.32,15.65 19,14.08 19,12.1H21C21,14.08 20.12,16.65 18.36,18.39C14.85,21.87 9.15,21.87 5.64,18.39C2.14,14.92 2.11,9.28 5.62,5.81C9.13,2.34 14.76,2.34 18.27,5.81L21,3V10.12M12.5,8V12.25L16,14.33L15.28,15.54L11,13V8H12.5Z" />
 </svg>
@@ -20,7 +20,10 @@
 #define SER_WINDOWMODE "windowmode"
 #define SER_UNSUPPORTEDFPS "unsupportedfps"
 #define SER_MDNS "mdns"
+#define SER_QUITAPPAFTER "quitAppAfter"
 #define SER_MOUSEACCELERATION "mouseacceleration"
+#define SER_STARTWINDOWED "startwindowed"
+#define SER_FRAMEPACING "framepacing"

 StreamingPreferences::StreamingPreferences(QObject *parent)
    : QObject(parent)
@@ -42,7 +45,10 @@ void StreamingPreferences::reload()
    multiController = settings.value(SER_MULTICONT, true).toBool();
    unsupportedFps = settings.value(SER_UNSUPPORTEDFPS, false).toBool();
    enableMdns = settings.value(SER_MDNS, true).toBool();
+    quitAppAfter = settings.value(SER_QUITAPPAFTER, false).toBool();
    mouseAcceleration = settings.value(SER_MOUSEACCELERATION, false).toBool();
+    startWindowed = settings.value(SER_STARTWINDOWED, false).toBool();
+    framePacing = settings.value(SER_FRAMEPACING, false).toBool();
    audioConfig = static_cast<AudioConfig>(settings.value(SER_AUDIOCFG,
                                                  static_cast<int>(AudioConfig::AC_STEREO)).toInt());
    videoCodecConfig = static_cast<VideoCodecConfig>(settings.value(SER_VIDEOCFG,
@@ -69,7 +75,10 @@ void StreamingPreferences::save()
    settings.setValue(SER_MULTICONT, multiController);
    settings.setValue(SER_UNSUPPORTEDFPS, unsupportedFps);
    settings.setValue(SER_MDNS, enableMdns);
+    settings.setValue(SER_QUITAPPAFTER, quitAppAfter);
    settings.setValue(SER_MOUSEACCELERATION, mouseAcceleration);
+    settings.setValue(SER_STARTWINDOWED, startWindowed);
+    settings.setValue(SER_FRAMEPACING, framePacing);
    settings.setValue(SER_AUDIOCFG, static_cast<int>(audioConfig));
    settings.setValue(SER_VIDEOCFG, static_cast<int>(videoCodecConfig));
    settings.setValue(SER_VIDEODEC, static_cast<int>(videoDecoderSelection));
@@ -133,9 +142,7 @@ int StreamingPreferences::getMaximumStreamingFrameRate()
                }
            }

-            // Cap the frame rate at 120 FPS. Past this, the encoders start
-            // to max out and drop frames.
-            maxFrameRate = qMax(maxFrameRate, qMin(120, bestMode.refresh_rate));
+            maxFrameRate = qMax(maxFrameRate, bestMode.refresh_rate);
        }
    }

@@ -73,7 +73,10 @@ public:
    Q_PROPERTY(bool multiController MEMBER multiController NOTIFY multiControllerChanged)
    Q_PROPERTY(bool unsupportedFps MEMBER unsupportedFps NOTIFY unsupportedFpsChanged)
    Q_PROPERTY(bool enableMdns MEMBER enableMdns NOTIFY enableMdnsChanged)
+    Q_PROPERTY(bool quitAppAfter MEMBER quitAppAfter NOTIFY quitAppAfterChanged)
    Q_PROPERTY(bool mouseAcceleration MEMBER mouseAcceleration NOTIFY mouseAccelerationChanged)
+    Q_PROPERTY(bool startWindowed MEMBER startWindowed NOTIFY startWindowedChanged)
+    Q_PROPERTY(bool framePacing MEMBER framePacing NOTIFY framePacingChanged)
    Q_PROPERTY(AudioConfig audioConfig MEMBER audioConfig NOTIFY audioConfigChanged)
    Q_PROPERTY(VideoCodecConfig videoCodecConfig MEMBER videoCodecConfig NOTIFY videoCodecConfigChanged)
    Q_PROPERTY(VideoDecoderSelection videoDecoderSelection MEMBER videoDecoderSelection NOTIFY videoDecoderSelectionChanged)
@@ -90,7 +93,10 @@ public:
    bool multiController;
    bool unsupportedFps;
    bool enableMdns;
+    bool quitAppAfter;
    bool mouseAcceleration;
+    bool startWindowed;
+    bool framePacing;
    AudioConfig audioConfig;
    VideoCodecConfig videoCodecConfig;
    VideoDecoderSelection videoDecoderSelection;
@@ -105,10 +111,13 @@ signals:
    void multiControllerChanged();
    void unsupportedFpsChanged();
    void enableMdnsChanged();
+    void quitAppAfterChanged();
    void mouseAccelerationChanged();
    void audioConfigChanged();
    void videoCodecConfigChanged();
    void videoDecoderSelectionChanged();
    void windowModeChanged();
+    void startWindowedChanged();
+    void framePacingChanged();
 };

@@ -3,15 +3,19 @@

 #ifdef HAVE_SOUNDIO
 #include "renderers/soundioaudiorenderer.h"
-#else
-#include "renderers/sdl.h"
 #endif

+#include "renderers/sdl.h"
+
 #include <Limelight.h>

 IAudioRenderer* Session::createAudioRenderer()
 {
 #ifdef HAVE_SOUNDIO
+    if (qgetenv("ML_AUDIO") == "SDL") {
+        return new SdlAudioRenderer();
+    }
+
    return new SoundIoAudioRenderer();
 #else
    return new SdlAudioRenderer();
@@ -16,9 +16,4 @@ public:

 private:
    SDL_AudioDeviceID m_AudioDevice;
-    Uint32 m_ChannelCount;
-    Uint32 m_PendingDrops;
-    Uint32 m_PendingHardDrops;
-    Uint32 m_SampleIndex;
-    Uint32 m_BaselinePendingData;
 };
@@ -5,18 +5,8 @@

 #include <QtGlobal>

-#define MIN_QUEUED_FRAMES 2
-#define MAX_QUEUED_FRAMES 4
-#define STOP_THE_WORLD_LIMIT 20
-#define DROP_RATIO_DENOM 32
-
 SdlAudioRenderer::SdlAudioRenderer()
-    : m_AudioDevice(0),
-      m_ChannelCount(0),
-      m_PendingDrops(0),
-      m_PendingHardDrops(0),
-      m_SampleIndex(0),
-      m_BaselinePendingData(0)
+    : m_AudioDevice(0)
 {
    SDL_assert(!SDL_WasInit(SDL_INIT_AUDIO));
    if (SDL_InitSubSystem(SDL_INIT_AUDIO) != 0) {
@@ -61,27 +51,6 @@ bool SdlAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION*
                have.samples,
                have.size);

-    // SDL counts pending samples in the queued
-    // audio size using the WASAPI backend. This
-    // includes silence, which can throw off our
-    // pending data count. Get a baseline so we
-    // can exclude that data.
-    m_BaselinePendingData = 0;
-#ifdef Q_OS_WIN32
-    for (int i = 0; i < 100; i++) {
-        m_BaselinePendingData = qMax(m_BaselinePendingData, SDL_GetQueuedAudioSize(m_AudioDevice));
-        SDL_Delay(10);
-    }
-#endif
-    m_BaselinePendingData *= 2;
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Baseline pending audio data: %d bytes",
-                m_BaselinePendingData);
-
-    m_ChannelCount = opusConfig->channelCount;
-    m_SampleIndex = 0;
-    m_PendingDrops = m_PendingHardDrops = 0;
-
    // Start playback
    SDL_PauseAudioDevice(m_AudioDevice, 0);

@@ -102,53 +71,6 @@ SdlAudioRenderer::~SdlAudioRenderer()

 bool SdlAudioRenderer::submitAudio(short* audioBuffer, int audioSize)
 {
-    m_SampleIndex++;
-
-    Uint32 queuedAudio = SDL_GetQueuedAudioSize(m_AudioDevice);
-    if (queuedAudio > m_BaselinePendingData) {
-        queuedAudio -= m_BaselinePendingData;
-    }
-    else {
-        queuedAudio = 0;
-    }
-
-    Uint32 framesQueued = queuedAudio / (SAMPLES_PER_FRAME * m_ChannelCount * sizeof(short));
-
-    // We must check this prior to the below checks to ensure we don't
-    // underflow if framesQueued - m_PendingHardDrops < 0.
-    if (framesQueued <= MIN_QUEUED_FRAMES) {
-        m_PendingDrops = m_PendingHardDrops = 0;
-    }
-    // Pend enough drops to get us back to MIN_QUEUED_FRAMES, checking first
-    // to ensure we don't underflow.
-    else if (framesQueued > m_PendingHardDrops &&
-             framesQueued - m_PendingHardDrops > STOP_THE_WORLD_LIMIT) {
-        m_PendingHardDrops = framesQueued - MIN_QUEUED_FRAMES;
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Pending hard drop of %u audio frames",
-                    m_PendingHardDrops);
-    }
-    // If we're under the stop the world limit, we can drop samples
-    // gracefully over the next little while.
-    else if (framesQueued > m_PendingHardDrops + m_PendingDrops &&
-             framesQueued - m_PendingHardDrops - m_PendingDrops > MAX_QUEUED_FRAMES) {
-        m_PendingDrops = framesQueued - MIN_QUEUED_FRAMES;
-    }
-
-    // Determine if this frame should be dropped
-    if (m_PendingHardDrops != 0) {
-        // Hard drops happen all at once to forcefully
-        // resync with the source.
-        m_PendingHardDrops--;
-        return true;
-    }
-    else if (m_PendingDrops != 0 && m_SampleIndex % DROP_RATIO_DENOM == 0) {
-        // Normal drops are interspersed with the audio data
-        // to hide the glitches.
-        m_PendingDrops--;
-        return true;
-    }
-
    if (SDL_QueueAudio(m_AudioDevice, audioBuffer, audioSize) < 0) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                     "Failed to queue audio sample: %s",
@@ -4,12 +4,30 @@

 #include <QtGlobal>

+// GFE sends us packets in 5 ms chunks
+const double SoundIoAudioRenderer::k_RawSampleLengthSec = 0.005;
+
+#ifdef Q_OS_LINUX
+// PulseAudio and ALSA require more than just 5 ms samples
+// for some reason, so write a minimum of 25 ms each time to
+// prevent underruns on Bluetooth.
+// https://github.com/moonlight-stream/moonlight-qt/issues/147
+// https://github.com/moonlight-stream/moonlight-qt/issues/157
+const double SoundIoAudioRenderer::k_MinSampleLengthSec = 0.025;
+#else
+// This determines the size of the buffers we'll
+// get from CoreAudio. It is also the minimum
+// size that we will write when called to fill a buffer.
+const double SoundIoAudioRenderer::k_MinSampleLengthSec = k_RawSampleLengthSec;
+#endif
+
 SoundIoAudioRenderer::SoundIoAudioRenderer()
    : m_OpusChannelCount(0),
      m_SoundIo(nullptr),
      m_Device(nullptr),
      m_OutputStream(nullptr),
      m_RingBuffer(nullptr),
+      m_Latency(0),
      m_Errored(false)
 {

@@ -17,6 +35,10 @@ SoundIoAudioRenderer::SoundIoAudioRenderer()

 SoundIoAudioRenderer::~SoundIoAudioRenderer()
 {
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "Audio latency: %f",
+                m_Latency);
+
    if (m_OutputStream != nullptr) {
        soundio_outstream_destroy(m_OutputStream);
    }
@@ -152,17 +174,12 @@ bool SoundIoAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATI

    m_OutputStream->format = SoundIoFormatS16NE;
    m_OutputStream->sample_rate = opusConfig->sampleRate;
+    m_OutputStream->software_latency = k_MinSampleLengthSec;
    m_OutputStream->name = "Moonlight";
    m_OutputStream->userdata = this;
    m_OutputStream->error_callback = sioErrorCallback;
    m_OutputStream->write_callback = sioWriteCallback;

-    // This determines the size of the buffers we'll
-    // get from CoreAudio. Since GFE sends us packets
-    // in 5 ms chunks, we'll give them to the OS in
-    // buffers of the same size.
-    m_OutputStream->software_latency = 0.005;
-
    SoundIoChannelLayout bestLayout = m_Device->current_layout;
    for (int i = 0; i < m_Device->layout_count; i++) {
        if (scoreChannelLayout(&bestLayout, opusConfig) <
@@ -218,12 +235,33 @@ bool SoundIoAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATI
        }
    }

-    // Buffer up to 6 packets of audio (30 ms) to smooth
-    // out network packet delivery jitter
+    int packetsToBuffer;
+
+#ifdef Q_OS_LINUX
+    // PulseAudio and ALSA need the large buffer (see comment on k_MinSampleLengthSec),
+    // so we need a buffer at least double that size to allow packets to arrive
+    // while we're writing to the sink.
+    packetsToBuffer = (int)(k_MinSampleLengthSec / k_RawSampleLengthSec) * 2;
+#else
+    if (m_SoundIo->current_backend == SoundIoBackendWasapi) {
+        // 15 ms buffer seems to be fine for WASAPI
+        packetsToBuffer = 3;
+    }
+    else {
+        // 30 ms buffer on CoreAudio to avoid glitching on macOS
+        packetsToBuffer = 6;
+    }
+#endif
+
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "Audio buffer size: %d packets",
+                packetsToBuffer);
+
    m_RingBuffer = soundio_ring_buffer_create(m_SoundIo,
                                              m_OutputStream->bytes_per_sample *
                                              m_OpusChannelCount *
-                                              SAMPLES_PER_FRAME * 6);
+                                              SAMPLES_PER_FRAME *
+                                              packetsToBuffer);
    if (m_RingBuffer == nullptr) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                     "soundio_ring_buffer_create() failed");
@@ -238,6 +276,11 @@ bool SoundIoAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATI
        return false;
    }

+    // HACK: For some reason, a constant latency hangs around in the audio pipeline
+    // unless we wait for the audio stream to drain before actually submitting any samples.
+    // This is a gross hack, but it works remarkably well.
+    SDL_Delay(500);
+
    return true;
 }

@@ -331,31 +374,15 @@ void SoundIoAudioRenderer::sioWriteCallback(SoundIoOutStream* stream, int frameC
    // Clamp framesLeft to frameCountMax
    framesLeft = qMin(framesLeft, frameCountMax);

-    // Place an upper-bound on audio stream latency to
-    // avoid accumulating packets in queue-based backends
-    // like WASAPI. This bound was set by testing on several
-    // Windows machines. The highest latency was found on
-    // a XPS 9343 running Windows 7 in Steam Big Picture
-    // and the 5.1 audio test clip from Fraunhofer.
-    if (me->m_SoundIo->current_backend == SoundIoBackendWasapi) {
-        double latency;
-        if (soundio_outstream_get_latency(stream, &latency) == SoundIoErrorNone) {
-            if (latency > 0.050) {
-                // If our latency is higher than desired, drop these samples to gracefully lower
-                // the latency without glitching too much. Dropping the whole buffer causes
-                // a much more noticeable glitch. This approach also ensures that we don't
-                // accidentally underflow if the driver/kernel side is delayed and isn't
-                // consuming data fast enough. Dropping a frame at a time and re-evaluating
-                // each time ensures that we'll stop dropping if latency returns to normal.
-                readPtr += framesLeft * stream->bytes_per_sample * me->m_OpusChannelCount;
-                bytesRead += framesLeft * stream->bytes_per_sample * me->m_OpusChannelCount;
-                framesLeft = 0;
+    // Ensure we always write at least a buffer, even if it's silence, to avoid
+    // busy looping when no audio data is available while libsoundio tries to keep
+    // us from starving the output device.
+    frameCountMin = qMax(frameCountMin, (int)(stream->sample_rate * k_MinSampleLengthSec));
+    frameCountMin = qMin(frameCountMin, frameCountMax);

-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "Latency exceeded drop cap: %f",
-                            latency);
-            }
-        }
+    // Track latency on queueing-based backends
+    if (me->m_SoundIo->current_backend != SoundIoBackendCoreAudio && me->m_SoundIo->current_backend != SoundIoBackendJack) {
+        soundio_outstream_get_latency(stream, &me->m_Latency);
    }

    for (;;) {
@@ -32,5 +32,9 @@ private:
    struct SoundIoOutStream* m_OutputStream;
    struct SoundIoRingBuffer* m_RingBuffer;
    struct SoundIoChannelLayout m_EffectiveLayout;
+    double m_Latency;
    bool m_Errored;
+
+    static const double k_RawSampleLengthSec;
+    static const double k_MinSampleLengthSec;
 };
@@ -17,6 +17,8 @@
 #define VK_NUMPAD0 0x60
 #endif

+#define MOUSE_POLLING_INTERVAL 5
+
 // How long the mouse button will be pressed for a tap to click gesture
 #define TAP_BUTTON_RELEASE_DELAY 100

@@ -34,10 +36,9 @@ const int SdlInputHandler::k_ButtonMap[] = {
    UP_FLAG, DOWN_FLAG, LEFT_FLAG, RIGHT_FLAG
 };

-SdlInputHandler::SdlInputHandler(StreamingPreferences& prefs, NvComputer* computer, int streamWidth, int streamHeight)
-    : m_LastMouseMotionTime(0),
-      m_MultiController(prefs.multiController),
-      m_NeedsInputDelay(false),
+SdlInputHandler::SdlInputHandler(StreamingPreferences& prefs, NvComputer*, int streamWidth, int streamHeight)
+    : m_MultiController(prefs.multiController),
+      m_MouseMoveTimer(0),
      m_LeftButtonReleaseTimer(0),
      m_RightButtonReleaseTimer(0),
      m_DragTimer(0),
@@ -68,31 +69,19 @@ SdlInputHandler::SdlInputHandler(StreamingPreferences& prefs, NvComputer* comput
    MappingManager mappingManager;
    mappingManager.applyMappings();

-    if (!m_MultiController) {
-        // Player 1 is always present in non-MC mode
-        m_GamepadMask = 0x1;
-    }
-    else {
-        // Otherwise, detect gamepads on the fly
-        m_GamepadMask = 0;
-    }
-
-    // Prior to GFE 3.14.1, sending too many mouse motion events can cause
-    // GFE to choke and input latency to increase significantly. We will
-    // artificially throttle them to avoid this situation.
-    QVector<int> gfeVersion = NvHTTP::parseQuad(computer->gfeVersion);
-    if (gfeVersion.isEmpty() || // Very old versions don't have GfeVersion at all
-            gfeVersion[0] < 3 ||
-            (gfeVersion[0] == 3 && gfeVersion[1] < 14) ||
-            (gfeVersion[0] == 3 && gfeVersion[1] == 14 && gfeVersion[2] < 1)) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "This older version of GFE requires input delay hack");
-        m_NeedsInputDelay = true;
-    }
+    // Initialize the gamepad mask with currently attached gamepads to avoid
+    // causing gamepads to unexpectedly disappear and reappear on the host
+    // during stream startup as we detect currently attached gamepads one at a time.
+    m_GamepadMask = getAttachedGamepadMask();

    SDL_zero(m_GamepadState);
    SDL_zero(m_TouchDownEvent);
    SDL_zero(m_CumulativeDelta);
+
+    SDL_AtomicSet(&m_MouseDeltaX, 0);
+    SDL_AtomicSet(&m_MouseDeltaY, 0);
+
+    m_MouseMoveTimer = SDL_AddTimer(MOUSE_POLLING_INTERVAL, SdlInputHandler::mouseMoveTimerCallback, this);
 }

 SdlInputHandler::~SdlInputHandler()
@@ -103,6 +92,7 @@ SdlInputHandler::~SdlInputHandler()
        }
    }

+    SDL_RemoveTimer(m_MouseMoveTimer);
    SDL_RemoveTimer(m_LeftButtonReleaseTimer);
    SDL_RemoveTimer(m_RightButtonReleaseTimer);
    SDL_RemoveTimer(m_DragTimer);
@@ -459,40 +449,10 @@ void SdlInputHandler::handleMouseMotionEvent(SDL_MouseMotionEvent* event)
        return;
    }

-    short xdelta = (short)event->xrel;
-    short ydelta = (short)event->yrel;
-
-    // If we're sending more than one motion event per millisecond,
-    // delay for 1 ms to allow batching of mouse move events. On older
-    // versions of GFE, we will unconditionally wait this 1 ms to
-    // work around an input processing issue that causes massive mouse latency.
-    Uint32 currentTime = SDL_GetTicks();
-    if (m_NeedsInputDelay || !SDL_TICKS_PASSED(currentTime, m_LastMouseMotionTime + 1)) {
-        SDL_Delay(1);
-        currentTime = SDL_GetTicks();
-    }
-    m_LastMouseMotionTime = currentTime;
-
-    // Pump even if we didn't delay since we might get some extra events
-    SDL_PumpEvents();
-
-    // Batch all of the pending mouse motion events
-    SDL_Event nextEvent;
-    while (SDL_PeepEvents(&nextEvent,
-                          1,
-                          SDL_GETEVENT,
-                          SDL_MOUSEMOTION,
-                          SDL_MOUSEMOTION) == 1) {
-        // In theory, these can overflow but in practice
-        // it should be highly unlikely since it would require
-        // moving 64K pixels in 1 ms.
-        xdelta += nextEvent.motion.xrel;
-        ydelta += nextEvent.motion.yrel;
-    }
-
-    if (xdelta != 0 || ydelta != 0) {
-        LiSendMouseMoveEvent(xdelta, ydelta);
-    }
+    // Batch until the next mouse polling window or we'll get awful
+    // input lag everything except GFE 3.14 and 3.15.
+    SDL_AtomicAdd(&m_MouseDeltaX, event->xrel);
+    SDL_AtomicAdd(&m_MouseDeltaY, event->yrel);
 }

 void SdlInputHandler::handleMouseWheelEvent(SDL_MouseWheelEvent* event)
@@ -572,6 +532,20 @@ Uint32 SdlInputHandler::dragTimerCallback(Uint32, void *param)
    return 0;
 }

+Uint32 SdlInputHandler::mouseMoveTimerCallback(Uint32 interval, void *param)
+{
+    auto me = reinterpret_cast<SdlInputHandler*>(param);
+
+    short deltaX = (short)SDL_AtomicSet(&me->m_MouseDeltaX, 0);
+    short deltaY = (short)SDL_AtomicSet(&me->m_MouseDeltaY, 0);
+
+    if (deltaX != 0 || deltaY != 0) {
+        LiSendMouseMoveEvent(deltaX, deltaY);
+    }
+
+    return interval;
+}
+
 void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
 {
    GamepadState* state = findStateForGamepad(event->which);
@@ -655,8 +629,31 @@ void SdlInputHandler::handleControllerDeviceEvent(SDL_ControllerDeviceEvent* eve
    if (event->type == SDL_CONTROLLERDEVICEADDED) {
        int i;
        const char* name;
+        SDL_GameController* controller;
+        const char* mapping;
+        char guidStr[33];

-        for (i = 0; i < MAX_GAMEPADS; i++) {
+        controller = SDL_GameControllerOpen(event->which);
+        if (controller == NULL) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                         "Failed to open gamepad: %s",
+                         SDL_GetError());
+            return;
+        }
+
+#if SDL_VERSION_ATLEAST(2, 0, 9)
+        // Determine this player's preferred index
+        i = SDL_GameControllerGetPlayerIndex(controller);
+        if (i < 0 || i >= MAX_GAMEPADS || m_GamepadState[i].controller != NULL) {
+            // If the player index is unavailable or invalid, start searching from 0
+            i = 0;
+        }
+#else
+        // SDL 2.0.8 and earlier has no player number hints
+        i = 0;
+#endif
+
+        for (; i < MAX_GAMEPADS; i++) {
            if (m_GamepadState[i].controller == NULL) {
                // Found an empty slot
                break;
@@ -666,6 +663,7 @@ void SdlInputHandler::handleControllerDeviceEvent(SDL_ControllerDeviceEvent* eve
        if (i == MAX_GAMEPADS) {
            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                         "No open gamepad slots found!");
+            SDL_GameControllerClose(controller);
            return;
        }

@@ -677,26 +675,30 @@ void SdlInputHandler::handleControllerDeviceEvent(SDL_ControllerDeviceEvent* eve
            // Always player 1 in single controller mode
            state->index = 0;
        }
-        state->controller = SDL_GameControllerOpen(event->which);
-        if (state->controller == NULL) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "Failed to open gamepad: %s",
-                         SDL_GetError());
-            return;
-        }

+        state->controller = controller;
        state->jsId = SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(state->controller));

+        SDL_JoystickGetGUIDString(SDL_JoystickGetGUID(SDL_GameControllerGetJoystick(state->controller)),
+                                  guidStr, sizeof(guidStr));
+        mapping = SDL_GameControllerMapping(state->controller);
        name = SDL_GameControllerName(state->controller);
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Gamepad %d (player %d) is: %s",
+                    "Gamepad %d (player %d) is: %s (%s -> %s)",
                    i,
                    state->index,
-                    name != NULL ? name : "<null>");
+                    name != nullptr ? name : "<null>",
+                    guidStr,
+                    mapping != nullptr ? mapping : "<null>");
+        if (mapping != nullptr) {
+            SDL_free((void*)mapping);
+        }
        
        // Add this gamepad to the gamepad mask
        if (m_MultiController) {
-            SDL_assert(!(m_GamepadMask & (1 << state->index)));
+            // NB: Don't assert that it's unset here because we will already
+            // have the mask set for initially attached gamepads to avoid confusing
+            // apps running on the host.
            m_GamepadMask |= (1 << state->index);
        }
        else {
@@ -908,6 +910,7 @@ int SdlInputHandler::getAttachedGamepadMask()
        return 0x1;
    }

+    // TODO: Use SDL_GameControllerGetPlayerIndex() for accurate indexes?
    count = mask = 0;
    for (int i = 0; i < SDL_NumJoysticks(); i++) {
        if (SDL_IsGameController(i)) {
@@ -968,7 +971,7 @@ QString SdlInputHandler::getUnmappedGamepads()
                            "Number of axes: %d | Number of buttons: %d | Number of hats: %d",
                            numAxes, numButtons, numHats);

-                if (numAxes >= 4 && numButtons >= 8 && numHats <= 1) {
+                if ((numAxes >= 4 && numAxes <= 8) && numButtons >= 8 && numHats <= 1) {
                    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
                                "Joystick likely to be an unmapped game controller");
                    if (!ret.isEmpty()) {
@@ -67,9 +67,13 @@ private:
    static
    Uint32 dragTimerCallback(Uint32 interval, void* param);

-    Uint32 m_LastMouseMotionTime;
+    static
+    Uint32 mouseMoveTimerCallback(Uint32 interval, void* param);
+
    bool m_MultiController;
-    bool m_NeedsInputDelay;
+    SDL_TimerID m_MouseMoveTimer;
+    SDL_atomic_t m_MouseDeltaX;
+    SDL_atomic_t m_MouseDeltaY;
    int m_GamepadMask;
    GamepadState m_GamepadState[MAX_GAMEPADS];
    QSet<short> m_KeysDown;
@@ -6,12 +6,6 @@
 #include <SDL.h>
 #include "utils.h"

-// HACK: Need to call SetThreadExecutionState() because SDL doesn't
-#ifdef Q_OS_WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
-#endif
-
 #ifdef HAVE_FFMPEG
 #include "video/ffmpeg.h"
 #endif
@@ -79,6 +73,7 @@ void Session::clStageFailed(int stage, long errorCode)

 void Session::clConnectionTerminated(long errorCode)
 {
+    s_ActiveSession->m_UnexpectedTermination = true;
    emit s_ActiveSession->displayLaunchError("Connection terminated");

    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
@@ -104,12 +99,16 @@ void Session::clLogMessage(const char* format, ...)
    va_end(ap);
 }

-#define CALL_INITIALIZE(dec) (dec)->initialize(vds, window, videoFormat, width, height, frameRate, enableVsync)
+#define CALL_INITIALIZE(dec) (dec)->initialize(vds, window, videoFormat, width, height, frameRate, enableVsync, enableFramePacing)

 bool Session::chooseDecoder(StreamingPreferences::VideoDecoderSelection vds,
                            SDL_Window* window, int videoFormat, int width, int height,
-                            int frameRate, bool enableVsync, IVideoDecoder*& chosenDecoder)
+                            int frameRate, bool enableVsync, bool enableFramePacing, IVideoDecoder*& chosenDecoder)
 {
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "V-sync %s",
+                enableVsync ? "enabled" : "disabled");
+
 #ifdef HAVE_SLVIDEO
    chosenDecoder = new SLVideoDecoder();
    if (CALL_INITIALIZE(chosenDecoder)) {
@@ -222,17 +221,20 @@ bool Session::isHardwareDecodeAvailable(StreamingPreferences::VideoDecoderSelect
        return false;
    }

-    if (!chooseDecoder(vds, window, videoFormat, width, height, frameRate, true, decoder)) {
+    if (!chooseDecoder(vds, window, videoFormat, width, height, frameRate, true, false, decoder)) {
        SDL_DestroyWindow(window);
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
        return false;
    }

-    SDL_DestroyWindow(window);
-
    bool ret = decoder->isHardwareAccelerated();

    delete decoder;
+
+    // This must be called after the decoder is deleted, because
+    // the renderer may want to interact with the window
+    SDL_DestroyWindow(window);
+
    SDL_QuitSubSystem(SDL_INIT_VIDEO);

    return ret;
@@ -259,17 +261,20 @@ int Session::getDecoderCapabilities(StreamingPreferences::VideoDecoderSelection
        return false;
    }

-    if (!chooseDecoder(vds, window, videoFormat, width, height, frameRate, true, decoder)) {
+    if (!chooseDecoder(vds, window, videoFormat, width, height, frameRate, true, false, decoder)) {
        SDL_DestroyWindow(window);
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
        return false;
    }

-    SDL_DestroyWindow(window);
-
    int caps = decoder->getDecoderCapabilities();

    delete decoder;
+
+    // This must be called after the decoder is deleted, because
+    // the renderer may want to interact with the window
+    SDL_DestroyWindow(window);
+
    SDL_QuitSubSystem(SDL_INIT_VIDEO);

    return caps;
@@ -287,12 +292,21 @@ Session::Session(NvComputer* computer, NvApp& app, StreamingPreferences *prefere
      m_DisplayOriginX(0),
      m_DisplayOriginY(0),
      m_PendingWindowedTransition(false),
+      m_UnexpectedTermination(true), // Failure prior to streaming is unexpected
      m_OpusDecoder(nullptr),
      m_AudioRenderer(nullptr),
      m_AudioSampleCount(0)
 {
 }

+Session::~Session()
+{
+    // Acquire session semaphore to ensure all cleanup is done before the destructor returns
+    // and the object is deallocated.
+    s_ActiveSessionSemaphore.acquire();
+    s_ActiveSessionSemaphore.release();
+}
+
 void Session::initialize()
 {
    qInfo() << "Server GPU:" << m_Computer->gpuModel;
@@ -315,6 +329,8 @@ void Session::initialize()
    m_StreamConfig.fps = m_Preferences->fps;
    m_StreamConfig.bitrate = m_Preferences->bitrateKbps;
    m_StreamConfig.hevcBitratePercentageMultiplier = 75;
+    m_StreamConfig.streamingRemotely = STREAM_CFG_AUTO;
+    m_StreamConfig.packetSize = 1392;

    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                "Video bitrate: %d kbps",
@@ -350,6 +366,22 @@ void Session::initialize()
                                          m_StreamConfig.width,
                                          m_StreamConfig.height,
                                          m_StreamConfig.fps);
+#ifdef Q_OS_DARWIN
+        {
+            // Prior to GFE 3.11, GFE did not allow us to constrain
+            // the number of reference frames, so we have to fixup the SPS
+            // to allow decoding via VideoToolbox on macOS. Since we don't
+            // have fixup code for HEVC, just avoid it if GFE is too old.
+            QVector<int> gfeVersion = NvHTTP::parseQuad(m_Computer->gfeVersion);
+            if (gfeVersion.isEmpty() || // Very old versions don't have GfeVersion at all
+                    gfeVersion[0] < 3 ||
+                    (gfeVersion[0] == 3 && gfeVersion[1] < 11)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "Disabling HEVC on macOS due to old GFE version");
+                m_StreamConfig.supportsHevc = false;
+            }
+        }
+#endif
        m_StreamConfig.enableHdr = false;
        break;
    case StreamingPreferences::VCC_FORCE_H264:
@@ -366,20 +398,6 @@ void Session::initialize()
        break;
    }

-    if (m_Computer->activeAddress == m_Computer->remoteAddress) {
-        m_StreamConfig.streamingRemotely = 1;
-    }
-    else {
-        m_StreamConfig.streamingRemotely = 0;
-    }
-
-    if (m_Computer->activeAddress == m_Computer->localAddress) {
-        m_StreamConfig.packetSize = 1392;
-    }
-    else {
-        m_StreamConfig.packetSize = 1024;
-    }
-
    switch (m_Preferences->windowMode)
    {
    case StreamingPreferences::WM_FULLSCREEN_DESKTOP:
@@ -489,15 +507,6 @@ bool Session::validateLaunch()
        if (m_Computer->gfeVersion.isEmpty() || m_Computer->gfeVersion.startsWith("2.")) {
            emitLaunchWarning("GeForce Experience 3.0 or higher is required for 4K streaming.");

-            m_StreamConfig.width = 1920;
-            m_StreamConfig.height = 1080;
-        }
-        // This list is sorted from least to greatest
-        else if (m_Computer->displayModes.last().width < 3840 ||
-                 (m_Computer->displayModes.last().refreshRate < 60 && m_StreamConfig.fps >= 60)) {
-            emitLaunchWarning("Your host PC GPU doesn't support 4K streaming. "
-                              "A GeForce GTX 900-series (Maxwell) or later GPU is required for 4K streaming.");
-
            m_StreamConfig.width = 1920;
            m_StreamConfig.height = 1080;
        }
@@ -556,25 +565,65 @@ bool Session::validateLaunch()

 class DeferredSessionCleanupTask : public QRunnable
 {
-    void run() override
-    {
-        // Finish cleanup of the connection state
-        LiStopConnection();
+public:
+    DeferredSessionCleanupTask(Session* session) :
+        m_Session(session) {}

+private:
+    virtual ~DeferredSessionCleanupTask() override
+    {
        // Allow another session to start now that we're cleaned up
        Session::s_ActiveSession = nullptr;
        Session::s_ActiveSessionSemaphore.release();
    }
+
+    void run() override
+    {
+        // Only quit the running app if our session terminated gracefully
+        bool shouldQuit =
+                !m_Session->m_UnexpectedTermination &&
+                m_Session->m_Preferences->quitAppAfter;
+
+        // Notify the UI
+        if (shouldQuit) {
+            emit m_Session->quitStarting();
+        }
+        else {
+            emit m_Session->sessionFinished();
+        }
+
+        // Finish cleanup of the connection state
+        LiStopConnection();
+
+        // Perform a best-effort app quit
+        if (shouldQuit) {
+            NvHTTP http(m_Session->m_Computer->activeAddress, m_Session->m_Computer->serverCert);
+
+            // Logging is already done inside NvHTTP
+            try {
+                http.quitApp();
+            } catch (const GfeHttpResponseException&) {
+            } catch (const QtNetworkReplyException&) {
+            }
+
+            // Session is finished now
+            emit m_Session->sessionFinished();
+        }
+    }
+
+    Session* m_Session;
 };

 void Session::getWindowDimensions(int& x, int& y,
                                  int& width, int& height)
 {
    int displayIndex = 0;
+    bool fullScreen;

    if (m_Window != nullptr) {
        displayIndex = SDL_GetWindowDisplayIndex(m_Window);
        SDL_assert(displayIndex >= 0);
+        fullScreen = (SDL_GetWindowFlags(m_Window) & SDL_WINDOW_FULLSCREEN);
    }
    // Create our window on the same display that Qt's UI
    // was being displayed on.
@@ -601,10 +650,16 @@ void Session::getWindowDimensions(int& x, int& y,
                            i, SDL_GetError());
            }
        }
+
+        fullScreen = (m_Preferences->windowMode != StreamingPreferences::WM_WINDOWED);
    }

    SDL_Rect usableBounds;
-    if (SDL_GetDisplayUsableBounds(displayIndex, &usableBounds) == 0) {
+    if (fullScreen && SDL_GetDisplayBounds(displayIndex, &usableBounds) == 0) {
+        width = usableBounds.w;
+        height = usableBounds.h;
+    }
+    else if (SDL_GetDisplayUsableBounds(displayIndex, &usableBounds) == 0) {
        width = usableBounds.w;
        height = usableBounds.h;

@@ -689,9 +744,13 @@ void Session::updateOptimalWindowDisplayMode()
        bestMode = desktopMode;
    }

-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Chosen best display mode: %dx%dx%d",
-                bestMode.w, bestMode.h, bestMode.refresh_rate);
+    if ((SDL_GetWindowFlags(m_Window) & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN) {
+        // Only print when the window is actually in full-screen exclusive mode,
+        // otherwise we're not actually using the mode we've set here
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                    "Chosen best display mode: %dx%dx%d",
+                    bestMode.w, bestMode.h, bestMode.refresh_rate);
+    }

    SDL_SetWindowDisplayMode(m_Window, &bestMode);
 }
@@ -726,6 +785,7 @@ void Session::exec(int displayOriginX, int displayOriginY)
    // Check for validation errors/warnings and emit
    // signals for them, if appropriate
    if (!validateLaunch()) {
+        emit sessionFinished();
        return;
    }

@@ -755,36 +815,24 @@ void Session::exec(int displayOriginX, int displayOriginY)
    Q_ASSERT(m_Computer->currentGameId == 0 ||
             m_Computer->currentGameId == m_App.id);

-    bool enableGameOptimizations = false;
-    for (const NvDisplayMode &mode : m_Computer->displayModes) {
-        if (mode.width == m_StreamConfig.width &&
-                mode.height == m_StreamConfig.height) {
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Found host supported resolution: %dx%d",
-                        mode.width, mode.height);
-            enableGameOptimizations = prefs.gameOptimizations;
-            break;
-        }
-    }
-
    try {
-        NvHTTP http(m_Computer->activeAddress);
+        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
        if (m_Computer->currentGameId != 0) {
            http.resumeApp(&m_StreamConfig);
        }
        else {
            http.launchApp(m_App.id, &m_StreamConfig,
-                           enableGameOptimizations,
+                           prefs.gameOptimizations,
                           prefs.playAudioOnHost,
                           inputHandler.getAttachedGamepadMask());
        }
    } catch (const GfeHttpResponseException& e) {
        emit displayLaunchError(e.toQString());
-        s_ActiveSessionSemaphore.release();
+        QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask(this));
        return;
    } catch (const QtNetworkReplyException& e) {
        emit displayLaunchError(e.toQString());
-        s_ActiveSessionSemaphore.release();
+        QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask(this));
        return;
    }

@@ -794,7 +842,7 @@ void Session::exec(int displayOriginX, int displayOriginY)
                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
                     SDL_GetError());
        emit displayLaunchError(QString::fromLocal8Bit(SDL_GetError()));
-        s_ActiveSessionSemaphore.release();
+        QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask(this));
        return;
    }

@@ -822,7 +870,7 @@ void Session::exec(int displayOriginX, int displayOriginY)
        // We already displayed an error dialog in the stage failure
        // listener.
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        s_ActiveSessionSemaphore.release();
+        QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask(this));
        return;
    }

@@ -844,10 +892,31 @@ void Session::exec(int displayOriginX, int displayOriginY)
                     "SDL_CreateWindow() failed: %s",
                     SDL_GetError());
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        s_ActiveSessionSemaphore.release();
+        QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask(this));
        return;
    }

+    QSvgRenderer svgIconRenderer(QString(":/res/moonlight.svg"));
+    QImage svgImage(ICON_SIZE, ICON_SIZE, QImage::Format_RGBA8888);
+    svgImage.fill(0);
+
+    QPainter svgPainter(&svgImage);
+    svgIconRenderer.render(&svgPainter);
+    SDL_Surface* iconSurface = SDL_CreateRGBSurfaceWithFormatFrom((void*)svgImage.constBits(),
+                                                                  svgImage.width(),
+                                                                  svgImage.height(),
+                                                                  32,
+                                                                  4 * svgImage.width(),
+                                                                  SDL_PIXELFORMAT_RGBA32);
+#ifndef Q_OS_DARWIN
+    // Other platforms seem to preserve our Qt icon when creating a new window.
+    if (iconSurface != nullptr) {
+        // This must be called before entering full-screen mode on Windows
+        // or our icon will not persist when toggling to windowed mode
+        SDL_SetWindowIcon(m_Window, iconSurface);
+    }
+#endif
+
    // For non-full screen windows, call getWindowDimensions()
    // again after creating a window to allow it to account
    // for window chrome size.
@@ -871,25 +940,6 @@ void Session::exec(int displayOriginX, int displayOriginY)
        SDL_SetWindowFullscreen(m_Window, m_FullScreenFlag);
    }

-    QSvgRenderer svgIconRenderer(QString(":/res/moonlight.svg"));
-    QImage svgImage(ICON_SIZE, ICON_SIZE, QImage::Format_RGBA8888);
-    svgImage.fill(0);
-
-    QPainter svgPainter(&svgImage);
-    svgIconRenderer.render(&svgPainter);
-    SDL_Surface* iconSurface = SDL_CreateRGBSurfaceWithFormatFrom((void*)svgImage.constBits(),
-                                                                  svgImage.width(),
-                                                                  svgImage.height(),
-                                                                  32,
-                                                                  4 * svgImage.width(),
-                                                                  SDL_PIXELFORMAT_RGBA32);
-#ifndef Q_OS_DARWIN
-    // Other platforms seem to preserve our Qt icon when creating a new window
-    if (iconSurface != nullptr) {
-        SDL_SetWindowIcon(m_Window, iconSurface);
-    }
-#endif
-
 #ifndef QT_DEBUG
    // Capture the mouse by default on release builds only.
    // This prevents the mouse from becoming trapped inside
@@ -908,13 +958,6 @@ void Session::exec(int displayOriginX, int displayOriginY)
    // Disable the screen saver
    SDL_DisableScreenSaver();

-#ifdef Q_OS_WIN32
-    // HACK: SDL doesn't call this, so we must do so to disable the
-    // screensaver when we're in windowed mode. DirectX will disable
-    // it for us when we're in full-screen exclusive mode.
-    SetThreadExecutionState(ES_CONTINUOUS | ES_DISPLAY_REQUIRED);
-#endif
-
    // Set timer resolution to 1 ms on Windows for greater
    // sleep precision and more accurate callback timing.
    SDL_SetHint(SDL_HINT_TIMER_RESOLUTION, "1");
@@ -929,6 +972,11 @@ void Session::exec(int displayOriginX, int displayOriginY)

    int currentDisplayIndex = SDL_GetWindowDisplayIndex(m_Window);

+    // Now that we're about to stream, any SDL_QUIT event is expected
+    // unless it comes from the connection termination callback where
+    // (m_UnexpectedTermination is set back to true).
+    m_UnexpectedTermination = false;
+
    // Hijack this thread to be the SDL main thread. We have to do this
    // because we want to suspend all Qt processing until the stream is over.
    SDL_Event event;
@@ -1076,6 +1124,7 @@ void Session::exec(int displayOriginX, int displayOriginY)
                                   m_Window, m_ActiveVideoFormat, m_ActiveVideoWidth,
                                   m_ActiveVideoHeight, m_ActiveVideoFrameRate,
                                   enableVsync,
+                                   enableVsync && m_Preferences->framePacing,
                                   s_ActiveSession->m_VideoDecoder)) {
                    SDL_AtomicUnlock(&m_DecoderLock);
                    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
@@ -1134,11 +1183,6 @@ void Session::exec(int displayOriginX, int displayOriginY)
    }

 DispatchDeferredCleanup:
-#ifdef Q_OS_WIN32
-    // HACK: See comment above
-    SetThreadExecutionState(ES_CONTINUOUS);
-#endif
-
    // Uncapture the mouse and hide the window immediately,
    // so we can return to the Qt GUI ASAP.
    SDL_SetRelativeMouseMode(SDL_FALSE);
@@ -1154,7 +1198,10 @@ DispatchDeferredCleanup:
    m_VideoDecoder = nullptr;
    SDL_AtomicUnlock(&m_DecoderLock);

+    // This must be called after the decoder is deleted, because
+    // the renderer may want to interact with the window
    SDL_DestroyWindow(m_Window);
+
    if (iconSurface != nullptr) {
        SDL_FreeSurface(iconSurface);
    }
@@ -1164,6 +1211,6 @@ DispatchDeferredCleanup:
    // Cleanup can take a while, so dispatch it to a worker thread.
    // When it is complete, it will release our s_ActiveSessionSemaphore
    // reference.
-    QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask());
+    QThreadPool::globalInstance()->start(new DeferredSessionCleanupTask(this));
 }

@@ -20,6 +20,8 @@ class Session : public QObject
 public:
    explicit Session(NvComputer* computer, NvApp& app, StreamingPreferences *preferences = nullptr);

+    virtual ~Session();
+
    Q_INVOKABLE void exec(int displayOriginX, int displayOriginY);

    static
@@ -41,6 +43,10 @@ signals:

    void displayLaunchWarning(QString text);

+    void quitStarting();
+
+    void sessionFinished();
+
 private:
    void initialize();

@@ -66,7 +72,8 @@ private:
    static
    bool chooseDecoder(StreamingPreferences::VideoDecoderSelection vds,
                       SDL_Window* window, int videoFormat, int width, int height,
-                       int frameRate, bool enableVsync, IVideoDecoder*& chosenDecoder);
+                       int frameRate, bool enableVsync, bool enableFramePacing,
+                       IVideoDecoder*& chosenDecoder);

    static
    void clStageStarting(int stage);
@@ -114,6 +121,7 @@ private:
    int m_DisplayOriginX;
    int m_DisplayOriginY;
    bool m_PendingWindowedTransition;
+    bool m_UnexpectedTermination;

    int m_ActiveVideoFormat;
    int m_ActiveVideoWidth;
@@ -16,6 +16,7 @@ typedef struct _VIDEO_STATS {
    uint32_t pacerDroppedFrames;
    uint32_t totalReassemblyTime;
    uint32_t totalDecodeTime;
+    uint32_t totalPacerTime;
    uint32_t totalRenderTime;
    float receivedFps;
    float decodedFps;
@@ -32,7 +33,8 @@ public:
                            int width,
                            int height,
                            int frameRate,
-                            bool enableVsync) = 0;
+                            bool enableVsync,
+                            bool enableFramePacing) = 0;
    virtual bool isHardwareAccelerated() = 0;
    virtual int getDecoderCapabilities() = 0;
    virtual int submitDecodeUnit(PDECODE_UNIT du) = 0;
@@ -644,9 +644,9 @@ int DXVA2Renderer::getDecoderCapabilities()
    return 0;
 }

-IFFmpegRenderer::VSyncConstraint DXVA2Renderer::getVsyncConstraint()
+IFFmpegRenderer::FramePacingConstraint DXVA2Renderer::getFramePacingConstraint()
 {
-    return VSYNC_ANY;
+    return PACING_ANY;
 }

 void DXVA2Renderer::renderFrameAtVsync(AVFrame *frame)
@@ -25,7 +25,7 @@ public:
    virtual void renderFrameAtVsync(AVFrame* frame);
    virtual bool needsTestFrame();
    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
+    virtual FramePacingConstraint getFramePacingConstraint();

 private:
    bool initializeDecoder();
@@ -87,7 +87,6 @@ void Pacer::vsyncCallback(int timeUntilNextVsyncMillis)
        av_frame_free(&frame);
    }

-
    if (m_FrameQueue.isEmpty()) {
        SDL_AtomicUnlock(&m_FrameQueueLock);

@@ -112,8 +111,11 @@ RenderNextFrame:
    AVFrame* frame = m_FrameQueue.dequeue();
    SDL_AtomicUnlock(&m_FrameQueueLock);

-    // Render it
+    // Count time spent in Pacer's queues
    Uint32 beforeRender = SDL_GetTicks();
+    m_VideoStats->totalPacerTime += beforeRender - frame->pts;
+
+    // Render it
    m_VsyncRenderer->renderFrameAtVsync(frame);
    m_VideoStats->totalRenderTime += SDL_GetTicks() - beforeRender;
    m_VideoStats->renderedFrames++;
@@ -122,15 +124,14 @@ RenderNextFrame:
    av_frame_free(&frame);
 }

-bool Pacer::initialize(SDL_Window* window, int maxVideoFps, bool enableVsync)
+bool Pacer::initialize(SDL_Window* window, int maxVideoFps, bool enablePacing)
 {
    m_MaxVideoFps = maxVideoFps;
-    m_EnableVsync = enableVsync;
    m_DisplayFps = StreamUtils::getDisplayRefreshRate(window);

-    if (m_EnableVsync) {
+    if (enablePacing) {
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Frame pacing in tear-free mode: target %d Hz with %d FPS stream",
+                    "Frame pacing active: target %d Hz with %d FPS stream",
                    m_DisplayFps, m_MaxVideoFps);

    #if defined(Q_OS_DARWIN)
@@ -148,7 +149,7 @@ bool Pacer::initialize(SDL_Window* window, int maxVideoFps, bool enableVsync)
    }
    else {
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Minimal latency tearing mode: target %d Hz with %d FPS stream",
+                    "Frame pacing disabled: target %d Hz with %d FPS stream",
                    m_DisplayFps, m_MaxVideoFps);
    }

@@ -20,7 +20,7 @@ public:

    void submitFrame(AVFrame* frame);

-    bool initialize(SDL_Window* window, int maxVideoFps, bool enableVsync);
+    bool initialize(SDL_Window* window, int maxVideoFps, bool enablePacing);

    void vsyncCallback(int timeUntilNextVsyncMillis);

@@ -35,6 +35,5 @@ private:
    IFFmpegRenderer* m_VsyncRenderer;
    int m_MaxVideoFps;
    int m_DisplayFps;
-    bool m_EnableVsync;
    PVIDEO_STATS m_VideoStats;
 };
@@ -8,10 +8,10 @@ extern "C" {

 class IFFmpegRenderer {
 public:
-    enum VSyncConstraint {
-        VSYNC_FORCE_OFF,
-        VSYNC_FORCE_ON,
-        VSYNC_ANY
+    enum FramePacingConstraint {
+        PACING_FORCE_OFF,
+        PACING_FORCE_ON,
+        PACING_ANY
    };

    virtual ~IFFmpegRenderer() {}
@@ -25,7 +25,7 @@ public:
    virtual void renderFrameAtVsync(AVFrame* frame) = 0;
    virtual bool needsTestFrame() = 0;
    virtual int getDecoderCapabilities() = 0;
-    virtual VSyncConstraint getVsyncConstraint() = 0;
+    virtual FramePacingConstraint getFramePacingConstraint() = 0;
 };

 class SdlRenderer : public IFFmpegRenderer {
@@ -42,7 +42,7 @@ public:
    virtual void renderFrameAtVsync(AVFrame* frame);
    virtual bool needsTestFrame();
    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
+    virtual FramePacingConstraint getFramePacingConstraint();

 private:
    SDL_Renderer* m_Renderer;
@@ -43,9 +43,9 @@ int SdlRenderer::getDecoderCapabilities()
    return CAPABILITY_REFERENCE_FRAME_INVALIDATION_AVC;
 }

-IFFmpegRenderer::VSyncConstraint SdlRenderer::getVsyncConstraint()
+IFFmpegRenderer::FramePacingConstraint SdlRenderer::getFramePacingConstraint()
 {
-    return VSYNC_ANY;
+    return PACING_ANY;
 }

 bool SdlRenderer::initialize(SDL_Window* window,
@@ -1,3 +1,5 @@
+#include <QString>
+
 #include "vaapi.h"
 #include <streaming/streamutils.h>

@@ -114,6 +116,21 @@ VAAPIRenderer::initialize(SDL_Window* window, int, int width, int height, int, b
                "Driver: %s",
                vendorString ? vendorString : "<unknown>");

+    // AMD's Gallium VAAPI driver has a nasty memory leak
+    // that causes memory to be leaked for each submitted frame.
+    // The Flatpak runtime has a VDPAU driver in place that works
+    // well, so use that instead on AMD systems.
+    if (vendorString && qgetenv("FORCE_VAAPI") != "1") {
+        QString vendorStr(vendorString);
+        if (vendorStr.contains("AMD", Qt::CaseInsensitive) ||
+                vendorStr.contains("Radeon", Qt::CaseInsensitive)) {
+            // Fail and let VDPAU pick this up
+            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                        "Avoiding VAAPI on AMD driver");
+            return false;
+        }
+    }
+
    // This will populate the driver_quirks
    err = av_hwdevice_ctx_init(m_HwContext);
    if (err < 0) {
@@ -160,9 +177,9 @@ VAAPIRenderer::getDecoderCapabilities()
    return 0;
 }

-IFFmpegRenderer::VSyncConstraint VAAPIRenderer::getVsyncConstraint()
+IFFmpegRenderer::FramePacingConstraint VAAPIRenderer::getFramePacingConstraint()
 {
-    return VSYNC_ANY;
+    return PACING_ANY;
 }

 void
@@ -40,7 +40,7 @@ public:
    virtual void renderFrameAtVsync(AVFrame* frame);
    virtual bool needsTestFrame();
    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
+    virtual FramePacingConstraint getFramePacingConstraint();

 private:
    int m_WindowSystem;
@@ -246,9 +246,9 @@ int VDPAURenderer::getDecoderCapabilities()
    return 0;
 }

-IFFmpegRenderer::VSyncConstraint VDPAURenderer::getVsyncConstraint()
+IFFmpegRenderer::FramePacingConstraint VDPAURenderer::getFramePacingConstraint()
 {
-    return VSYNC_ANY;
+    return PACING_ANY;
 }

 void VDPAURenderer::renderFrameAtVsync(AVFrame* frame)
@@ -23,7 +23,7 @@ public:
    virtual void renderFrameAtVsync(AVFrame* frame);
    virtual bool needsTestFrame();
    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
+    virtual FramePacingConstraint getFramePacingConstraint();

 private:
    uint32_t m_VideoWidth, m_VideoHeight;
@@ -211,12 +211,12 @@ public:
        return 0;
    }

-    virtual IFFmpegRenderer::VSyncConstraint getVsyncConstraint() override
+    virtual IFFmpegRenderer::FramePacingConstraint getFramePacingConstraint() override
    {
        // This renderer is inherently tied to V-sync due how we're
        // rendering with AVSampleBufferDisplay layer. Running without
        // the V-Sync source leads to massive stuttering.
-        return VSYNC_FORCE_ON;
+        return PACING_FORCE_ON;
    }

 private:
@@ -1,6 +1,7 @@
 #include <Limelight.h>
 #include "ffmpeg.h"
 #include "streaming/streamutils.h"
+#include <h264_stream.h>

 #ifdef Q_OS_WIN32
 #include "ffmpeg-renderers/dxva2.h"
@@ -21,6 +22,8 @@
 // This is gross but it allows us to use sizeof()
 #include "ffmpeg_videosamples.cpp"

+#define MAX_SPS_EXTRA_SIZE 16
+
 #define FAILED_DECODES_RESET_THRESHOLD 20

 bool FFmpegVideoDecoder::isHardwareAccelerated()
@@ -62,7 +65,8 @@ FFmpegVideoDecoder::FFmpegVideoDecoder()
      m_ConsecutiveFailedDecodes(0),
      m_Pacer(nullptr),
      m_LastFrameNumber(0),
-      m_StreamFps(0)
+      m_StreamFps(0),
+      m_NeedsSpsFixup(false)
 {
    av_init_packet(&m_Pkt);
    SDL_AtomicSet(&m_QueuedFrames, 0);
@@ -127,27 +131,27 @@ void FFmpegVideoDecoder::reset()

 bool FFmpegVideoDecoder::completeInitialization(AVCodec* decoder, SDL_Window* window,
                                                int videoFormat, int width, int height,
-                                                int maxFps, bool enableVsync, bool testOnly)
+                                                int maxFps, bool enableFramePacing, bool testOnly)
 {
-    auto vsyncConstraint = m_Renderer->getVsyncConstraint();
-    if (vsyncConstraint == IFFmpegRenderer::VSYNC_FORCE_OFF && enableVsync) {
+    auto vsyncConstraint = m_Renderer->getFramePacingConstraint();
+    if (vsyncConstraint == IFFmpegRenderer::PACING_FORCE_OFF && enableFramePacing) {
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "V-sync is forcefully disabled by the active renderer");
-        enableVsync = false;
+                    "Frame pacing is forcefully disabled by the active renderer");
+        enableFramePacing = false;
    }
-    else if (vsyncConstraint == IFFmpegRenderer::VSYNC_FORCE_ON && !enableVsync) {
+    else if (vsyncConstraint == IFFmpegRenderer::PACING_FORCE_ON && !enableFramePacing) {
        // FIXME: This duplicates logic in Session.cpp
        int displayHz = StreamUtils::getDisplayRefreshRate(window);
        if (displayHz + 5 >= maxFps) {
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "V-sync is forcefully enabled by the active renderer");
-            enableVsync = true;
+                        "Frame pacing is forcefully enabled by the active renderer");
+            enableFramePacing = true;
        }
    }

    m_StreamFps = maxFps;
    m_Pacer = new Pacer(m_Renderer, &m_ActiveWndVideoStats);
-    if (!m_Pacer->initialize(window, maxFps, enableVsync)) {
+    if (!m_Pacer->initialize(window, maxFps, enableFramePacing)) {
        return false;
    }

@@ -225,6 +229,17 @@ bool FFmpegVideoDecoder::completeInitialization(AVCodec* decoder, SDL_Window* wi
            return false;
        }
    }
+    else {
+        if ((videoFormat & VIDEO_FORMAT_MASK_H264) &&
+                !(m_Renderer->getDecoderCapabilities() & CAPABILITY_REFERENCE_FRAME_INVALIDATION_AVC)) {
+            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                        "Using H.264 SPS fixup");
+            m_NeedsSpsFixup = true;
+        }
+        else {
+            m_NeedsSpsFixup = false;
+        }
+    }

 #ifdef QT_DEBUG
    // Restore default log level before streaming
@@ -243,6 +258,7 @@ void FFmpegVideoDecoder::addVideoStats(VIDEO_STATS& src, VIDEO_STATS& dst)
    dst.pacerDroppedFrames += src.pacerDroppedFrames;
    dst.totalReassemblyTime += src.totalReassemblyTime;
    dst.totalDecodeTime += src.totalDecodeTime;
+    dst.totalPacerTime += src.totalPacerTime;
    dst.totalRenderTime += src.totalRenderTime;

    Uint32 now = SDL_GetTicks();
@@ -296,6 +312,9 @@ void FFmpegVideoDecoder::logVideoStats(VIDEO_STATS& stats, const char* title)
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                    "Average decode time: %.2f ms",
                    (float)stats.totalDecodeTime / stats.decodedFrames);
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                    "Average frame pacing delay: %.2f ms",
+                    (float)stats.totalPacerTime / stats.renderedFrames);
        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                    "Average render time: %.2f ms",
                    (float)stats.totalRenderTime / stats.renderedFrames);
@@ -344,7 +363,8 @@ bool FFmpegVideoDecoder::initialize(
        int width,
        int height,
        int maxFps,
-        bool enableVsync)
+        bool enableVsync,
+        bool enableFramePacing)
 {
    AVCodec* decoder;

@@ -380,7 +400,7 @@ bool FFmpegVideoDecoder::initialize(
            m_Renderer = new SdlRenderer();
            if (vds != StreamingPreferences::VDS_FORCE_HARDWARE &&
                    m_Renderer->initialize(window, videoFormat, width, height, maxFps, enableVsync) &&
-                    completeInitialization(decoder, window, videoFormat, width, height, maxFps, enableVsync, false)) {
+                    completeInitialization(decoder, window, videoFormat, width, height, maxFps, enableFramePacing, false)) {
                return true;
            }
            else {
@@ -397,13 +417,13 @@ bool FFmpegVideoDecoder::initialize(
        m_HwDecodeCfg = config;
        // Initialize the hardware codec and submit a test frame if the renderer needs it
        if (m_Renderer->initialize(window, videoFormat, width, height, maxFps, enableVsync) &&
-                completeInitialization(decoder, window, videoFormat, width, height, maxFps, enableVsync, m_Renderer->needsTestFrame())) {
+                completeInitialization(decoder, window, videoFormat, width, height, maxFps, enableFramePacing, m_Renderer->needsTestFrame())) {
            if (m_Renderer->needsTestFrame()) {
                // The test worked, so now let's initialize it for real
                reset();
                if ((m_Renderer = createAcceleratedRenderer(config)) != nullptr &&
                        m_Renderer->initialize(window, videoFormat, width, height, maxFps, enableVsync) &&
-                        completeInitialization(decoder, window, videoFormat, width, height, maxFps, enableVsync, false)) {
+                        completeInitialization(decoder, window, videoFormat, width, height, maxFps, enableFramePacing, false)) {
                    return true;
                }
                else {
@@ -424,6 +444,49 @@ bool FFmpegVideoDecoder::initialize(
    }
 }

+void FFmpegVideoDecoder::writeBuffer(PLENTRY entry, int& offset)
+{
+    if (m_NeedsSpsFixup && entry->bufferType == BUFFER_TYPE_SPS) {
+        const char naluHeader[] = {0x00, 0x00, 0x00, 0x01};
+        h264_stream_t* stream = h264_new();
+        int nalStart, nalEnd;
+
+        // Read the old NALU
+        find_nal_unit((uint8_t*)entry->data, entry->length, &nalStart, &nalEnd);
+        read_nal_unit(stream,
+                      (unsigned char *)&entry->data[nalStart],
+                      nalEnd - nalStart);
+
+        SDL_assert(nalStart == sizeof(naluHeader));
+        SDL_assert(nalEnd == entry->length);
+
+        // Fixup the SPS to what OS X needs to use hardware acceleration
+        stream->sps->num_ref_frames = 1;
+        stream->sps->vui.max_dec_frame_buffering = 1;
+
+        int initialOffset = offset;
+
+        // Copy the modified NALU data. This assumes a 3 byte prefix and
+        // begins writing from the 2nd byte, so we must write the data
+        // first, then go back and write the Annex B prefix.
+        offset += write_nal_unit(stream, (uint8_t*)&m_DecodeBuffer.data()[initialOffset + 3],
+                                 MAX_SPS_EXTRA_SIZE + entry->length - sizeof(naluHeader));
+
+        // Copy the NALU prefix over from the original SPS
+        memcpy(&m_DecodeBuffer.data()[initialOffset], naluHeader, sizeof(naluHeader));
+        offset += sizeof(naluHeader);
+
+        h264_free(stream);
+    }
+    else {
+        // Write the buffer as-is
+        memcpy(&m_DecodeBuffer.data()[offset],
+               entry->data,
+               entry->length);
+        offset += entry->length;
+    }
+}
+
 int FFmpegVideoDecoder::submitDecodeUnit(PDECODE_UNIT du)
 {
    PLENTRY entry = du->bufferList;
@@ -461,23 +524,23 @@ int FFmpegVideoDecoder::submitDecodeUnit(PDECODE_UNIT du)
        m_LastFrameNumber = du->frameNumber;
    }

-    if (du->fullLength + AV_INPUT_BUFFER_PADDING_SIZE > m_DecodeBuffer.length()) {
-        m_DecodeBuffer = QByteArray(du->fullLength + AV_INPUT_BUFFER_PADDING_SIZE, 0);
+    int requiredBufferSize = du->fullLength;
+    if (du->frameType == FRAME_TYPE_IDR) {
+        // Add some extra space in case we need to do an SPS fixup
+        requiredBufferSize += MAX_SPS_EXTRA_SIZE;
+    }
+    if (requiredBufferSize + AV_INPUT_BUFFER_PADDING_SIZE > m_DecodeBuffer.length()) {
+        m_DecodeBuffer = QByteArray(requiredBufferSize + AV_INPUT_BUFFER_PADDING_SIZE, 0);
    }

    int offset = 0;
    while (entry != nullptr) {
-        memcpy(&m_DecodeBuffer.data()[offset],
-               entry->data,
-               entry->length);
-        offset += entry->length;
+        writeBuffer(entry, offset);
        entry = entry->next;
    }

-    SDL_assert(offset == du->fullLength);
-
    m_Pkt.data = reinterpret_cast<uint8_t*>(m_DecodeBuffer.data());
-    m_Pkt.size = du->fullLength;
+    m_Pkt.size = offset;

    m_ActiveWndVideoStats.totalReassemblyTime += LiGetMillis() - du->receiveTimeMs;

@@ -519,6 +582,9 @@ int FFmpegVideoDecoder::submitDecodeUnit(PDECODE_UNIT du)
        // Reset failed decodes count if we reached this far
        m_ConsecutiveFailedDecodes = 0;

+        // Capture a frame timestamp to measuring pacing delay
+        frame->pts = SDL_GetTicks();
+
        // Queue the frame for rendering from the main thread
        SDL_AtomicIncRef(&m_QueuedFrames);
        queueFrame(frame);
@@ -18,7 +18,8 @@ public:
                            int width,
                            int height,
                            int maxFps,
-                            bool enableVsync) override;
+                            bool enableVsync,
+                            bool enableFramePacing) override;
    virtual bool isHardwareAccelerated() override;
    virtual int getDecoderCapabilities() override;
    virtual int submitDecodeUnit(PDECODE_UNIT du) override;
@@ -30,7 +31,7 @@ public:
 private:
    bool completeInitialization(AVCodec* decoder, SDL_Window* window,
                                int videoFormat, int width, int height,
-                                int maxFps, bool enableVsync, bool testOnly);
+                                int maxFps, bool enableFramePacing, bool testOnly);

    void logVideoStats(VIDEO_STATS& stats, const char* title);

@@ -40,6 +41,8 @@ private:

    void reset();

+    void writeBuffer(PLENTRY entry, int& offset);
+
    static
    enum AVPixelFormat ffGetFormat(AVCodecContext* context,
                                   const enum AVPixelFormat* pixFmts);
@@ -57,6 +60,7 @@ private:
    VIDEO_STATS m_GlobalVideoStats;
    int m_LastFrameNumber;
    int m_StreamFps;
+    bool m_NeedsSpsFixup;

    static const uint8_t k_H264TestFrame[];
    static const uint8_t k_HEVCTestFrame[];
@@ -34,7 +34,7 @@ SLVideoDecoder::getDecoderCapabilities()
 bool
 SLVideoDecoder::initialize(StreamingPreferences::VideoDecoderSelection vds,
                           SDL_Window*,
-                           int videoFormat, int, int, int frameRate, bool)
+                           int videoFormat, int, int, int frameRate, bool, bool)
 {
    // SLVideo only supports hardware decoding
    if (vds == StreamingPreferences::VDS_FORCE_SOFTWARE) {
@@ -15,7 +15,8 @@ public:
                            int width,
                            int height,
                            int frameRate,
-                            bool enableVsync);
+                            bool enableVsync,
+                            bool enableFramePacing);
    virtual bool isHardwareAccelerated();
    virtual int getDecoderCapabilities();
    virtual int submitDecodeUnit(PDECODE_UNIT du);
@@ -0,0 +1 @@
+0.8.1
@@ -0,0 +1,46 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2018-10-12T15:50:59
+#
+#-------------------------------------------------
+
+
+QT       -= core gui
+
+TARGET = h264bitstream
+TEMPLATE = lib
+
+# Support debug and release builds from command line for CI
+CONFIG += debug_and_release
+
+# Ensure symbols are always generated
+CONFIG += force_debug_info
+
+# Build a static library
+CONFIG += staticlib
+
+# Disable warnings
+CONFIG += warn_off
+
+# Older GCC versions defaulted to GNU89
+*-g++ {
+    QMAKE_CFLAGS += -std=gnu99
+}
+
+SRC_DIR = $$PWD/h264bitstream
+
+SOURCES += \
+    $$SRC_DIR/h264_avcc.c           \
+    $$SRC_DIR/h264_nal.c            \
+    $$SRC_DIR/h264_sei.c            \
+    $$SRC_DIR/h264_slice_data.c     \
+    $$SRC_DIR/h264_stream.c
+
+HEADERS += \
+    $$SRC_DIR/bs.h              \
+    $$SRC_DIR/h264_avcc.h       \
+    $$SRC_DIR/h264_sei.h        \
+    $$SRC_DIR/h264_slice_data.h \
+    $$SRC_DIR/h264_stream.h
+
+INCLUDEPATH += $$INC_DIR
@@ -409,6 +409,7 @@ enum AVCodecID {
    AV_CODEC_ID_DXV,
    AV_CODEC_ID_SCREENPRESSO,
    AV_CODEC_ID_RSCC,
+    AV_CODEC_ID_AVS2,

    AV_CODEC_ID_Y41P = 0x8000,
    AV_CODEC_ID_AVRP,
@@ -446,6 +447,11 @@ enum AVCodecID {
    AV_CODEC_ID_SVG,
    AV_CODEC_ID_GDV,
    AV_CODEC_ID_FITS,
+    AV_CODEC_ID_IMM4,
+    AV_CODEC_ID_PROSUMER,
+    AV_CODEC_ID_MWSC,
+    AV_CODEC_ID_WCMV,
+    AV_CODEC_ID_RASC,

    /* various PCM "codecs" */
    AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
@@ -485,6 +491,7 @@ enum AVCodecID {
    AV_CODEC_ID_PCM_S64BE,
    AV_CODEC_ID_PCM_F16LE,
    AV_CODEC_ID_PCM_F24LE,
+    AV_CODEC_ID_PCM_VIDC,

    /* various ADPCM codecs */
    AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
@@ -1359,6 +1366,12 @@ enum AVPacketSideDataType {
     */
    AV_PKT_DATA_ENCRYPTION_INFO,

+    /**
+     * Active Format Description data consisting of a single byte as specified
+     * in ETSI TS 101 154 using AVActiveFormatDescription enum.
+     */
+    AV_PKT_DATA_AFD,
+
    /**
     * The number of side data types.
     * This is not part of the public API/ABI in the sense that it may
@@ -1614,6 +1627,7 @@ typedef struct AVCodecContext {
     * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger
     * than extradata_size to avoid problems if it is read with the bitstream reader.
     * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
+     * Must be allocated with the av_malloc() family of functions.
     * - encoding: Set/allocated/freed by libavcodec.
     * - decoding: Set/allocated/freed by user.
     */
@@ -5768,6 +5782,7 @@ typedef struct AVBitStreamFilter {
    int (*init)(AVBSFContext *ctx);
    int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
    void (*close)(AVBSFContext *ctx);
+    void (*flush)(AVBSFContext *ctx);
 } AVBitStreamFilter;

 #if FF_API_OLD_BSF
@@ -5894,6 +5909,11 @@ int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
 */
 int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);

+/**
+ * Reset the internal bitstream filter state / flush internal buffers.
+ */
+void av_bsf_flush(AVBSFContext *ctx);
+
 /**
 * Free a bitstream filter context and everything associated with it; write NULL
 * into the supplied pointer.
@@ -85,4 +85,17 @@ typedef struct MediaCodecBuffer AVMediaCodecBuffer;
 */
 int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render);

+/**
+ * Release a MediaCodec buffer and render it at the given time to the surface
+ * that is associated with the decoder. The timestamp must be within one second
+ * of the current java/lang/System#nanoTime() (which is implemented using
+ * CLOCK_MONOTONIC on Android). See the Android MediaCodec documentation
+ * of android/media/MediaCodec#releaseOutputBuffer(int,long) for more details.
+ *
+ * @param buffer the buffer to render
+ * @param time timestamp in nanoseconds of when to render the buffer
+ * @return 0 on success, < 0 otherwise
+ */
+int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time);
+
 #endif /* AVCODEC_MEDIACODEC_H */
@@ -28,8 +28,8 @@
 #include "libavutil/version.h"

 #define LIBAVCODEC_VERSION_MAJOR  58
-#define LIBAVCODEC_VERSION_MINOR  21
-#define LIBAVCODEC_VERSION_MICRO 104
+#define LIBAVCODEC_VERSION_MINOR  35
+#define LIBAVCODEC_VERSION_MICRO 100

 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                               LIBAVCODEC_VERSION_MINOR, \
@@ -66,7 +66,7 @@
 #endif

 /**
- * Assert that floating point opperations can be executed.
+ * Assert that floating point operations can be executed.
 *
 * This will av_assert0() that the cpu is not in MMX state on X86
 */
@@ -1,5 +1,5 @@
 /* Automatically generated by version.sh, do not manually edit! */
 #ifndef AVUTIL_FFVERSION_H
 #define AVUTIL_FFVERSION_H
-#define FFMPEG_VERSION "N-91434-gcced03dd66"
+#define FFMPEG_VERSION "4.1"
 #endif /* AVUTIL_FFVERSION_H */
@@ -33,6 +33,8 @@
 * allocated buffer or map it with mmap() when available.
 * In case of success set *bufptr to the read or mmapped buffer, and
 * *size to the size in bytes of the buffer in *bufptr.
+ * Unlike mmap this function succeeds with zero sized files, in this
+ * case *bufptr will be set to NULL and *size will be set to 0.
 * The returned buffer must be released with av_file_unmap().
 *
 * @param log_offset loglevel offset used for logging
@@ -158,6 +158,14 @@ enum AVFrameSideDataType {
     */
    AV_FRAME_DATA_QP_TABLE_DATA,
 #endif
+
+    /**
+     * Timecode which conforms to SMPTE ST 12-1. The data is an array of 4 uint32_t
+     * where the first uint32_t describes how many (1-3) of the other timecodes are used.
+     * The timecode format is described in the av_timecode_get_smpte_from_framenum()
+     * function in libavutil/timecode.c.
+     */
+    AV_FRAME_DATA_S12M_TIMECODE,
 };

 enum AVActiveFormatDescription {
@@ -343,7 +343,13 @@ char *av_get_pix_fmt_string(char *buf, int buf_size,
 * format writes the values corresponding to the palette
 * component c in data[1] to dst, rather than the palette indexes in
 * data[0]. The behavior is undefined if the format is not paletted.
+ * @param dst_element_size size of elements in dst array (2 or 4 byte)
 */
+void av_read_image_line2(void *dst, const uint8_t *data[4],
+                        const int linesize[4], const AVPixFmtDescriptor *desc,
+                        int x, int y, int c, int w, int read_pal_component,
+                        int dst_element_size);
+
 void av_read_image_line(uint16_t *dst, const uint8_t *data[4],
                        const int linesize[4], const AVPixFmtDescriptor *desc,
                        int x, int y, int c, int w, int read_pal_component);
@@ -361,7 +367,12 @@ void av_read_image_line(uint16_t *dst, const uint8_t *data[4],
 * @param y the vertical coordinate of the first pixel to write
 * @param w the width of the line to write, that is the number of
 * values to write to the image line
+ * @param src_element_size size of elements in src array (2 or 4 byte)
 */
+void av_write_image_line2(const void *src, uint8_t *data[4],
+                         const int linesize[4], const AVPixFmtDescriptor *desc,
+                         int x, int y, int c, int w, int src_element_size);
+
 void av_write_image_line(const uint16_t *src, uint8_t *data[4],
                         const int linesize[4], const AVPixFmtDescriptor *desc,
                         int x, int y, int c, int w);
@@ -42,6 +42,10 @@
 * This is stored as BGRA on little-endian CPU architectures and ARGB on
 * big-endian CPUs.
 *
+ * @note
+ * If the resolution is not a multiple of the chroma subsampling factor
+ * then the chroma plane resolution must be rounded up.
+ *
 * @par
 * When the pixel format is palettized RGB32 (AV_PIX_FMT_PAL8), the palettized
 * image data is stored in AVFrame.data[0]. The palette is transported in
@@ -333,6 +337,9 @@ enum AVPixelFormat {
    AV_PIX_FMT_GRAY14BE,   ///<        Y        , 14bpp, big-endian
    AV_PIX_FMT_GRAY14LE,   ///<        Y        , 14bpp, little-endian

+    AV_PIX_FMT_GRAYF32BE,  ///< IEEE-754 single precision Y, 32bpp, big-endian
+    AV_PIX_FMT_GRAYF32LE,  ///< IEEE-754 single precision Y, 32bpp, little-endian
+
    AV_PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
 };

@@ -401,6 +408,8 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_GBRPF32    AV_PIX_FMT_NE(GBRPF32BE,  GBRPF32LE)
 #define AV_PIX_FMT_GBRAPF32   AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)

+#define AV_PIX_FMT_GRAYF32    AV_PIX_FMT_NE(GRAYF32BE, GRAYF32LE)
+
 #define AV_PIX_FMT_YUVA420P9  AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
 #define AV_PIX_FMT_YUVA422P9  AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
 #define AV_PIX_FMT_YUVA444P9  AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE)
@@ -79,8 +79,8 @@
 */

 #define LIBAVUTIL_VERSION_MAJOR  56
-#define LIBAVUTIL_VERSION_MINOR  18
-#define LIBAVUTIL_VERSION_MICRO 102
+#define LIBAVUTIL_VERSION_MINOR  22
+#define LIBAVUTIL_VERSION_MICRO 100

 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                               LIBAVUTIL_VERSION_MINOR, \
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2010-2013 Nektra S.A., Buenos Aires, Argentina.
+ * All rights reserved. Contact: http://www.nektra.com
+ *
+ *
+ * This file is part of Deviare In-Proc
+ *
+ *
+ * Commercial License Usage
+ * ------------------------
+ * Licensees holding valid commercial Deviare In-Proc licenses may use this
+ * file in accordance with the commercial license agreement provided with the
+ * Software or, alternatively, in accordance with the terms contained in
+ * a written agreement between you and Nektra.  For licensing terms and
+ * conditions see http://www.nektra.com/licensing/.  For further information
+ * use the contact form at http://www.nektra.com/contact/.
+ *
+ *
+ * GNU General Public License Usage
+ * --------------------------------
+ * Alternatively, this file may be used under the terms of the GNU
+ * General Public License version 3.0 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.  Please review the following information to
+ * ensure the GNU General Public License version 3.0 requirements will be
+ * met: http://www.gnu.org/copyleft/gpl.html.
+ *
+ **/
+
+#ifndef _NKTHOOKLIB
+#define _NKTHOOKLIB
+
+#include <windows.h>
+
+//-----------------------------------------------------------
+
+#define NKTHOOKLIB_DontSkipInitialJumps               0x0001
+#define NKTHOOKLIB_DontRemoveOnUnhook                 0x0002
+#define NKTHOOKLIB_DontSkipAnyJumps                   0x0004
+#define NKTHOOKLIB_SkipNullProcsToHook                0x0008
+#define NKTHOOKLIB_UseAbsoluteIndirectJumps           0x0010
+#define NKTHOOKLIB_DisallowReentrancy                 0x0020
+#define NKTHOOKLIB_DontEnableHooks                    0x0040
+
+#define NKTHOOKLIB_ProcessPlatformX86                      1
+#define NKTHOOKLIB_ProcessPlatformX64                      2
+
+#define NKTHOOKLIB_CurrentProcess     ((HANDLE)(LONG_PTR)-1)
+#define NKTHOOKLIB_CurrentThread      ((HANDLE)(LONG_PTR)-2)
+
+//-----------------------------------------------------------
+
+class CNktHookLib
+{
+public:
+  typedef struct tagHOOK_INFO {
+    SIZE_T nHookId;
+    LPVOID lpProcToHook;
+    LPVOID lpNewProcAddr;
+    //----
+    LPVOID lpCallOriginal;
+  } HOOK_INFO, *LPHOOK_INFO;
+
+  CNktHookLib();
+  ~CNktHookLib();
+
+  DWORD Hook(__out SIZE_T *lpnHookId, __out LPVOID *lplpCallOriginal, __in LPVOID lpProcToHook,
+             __in LPVOID lpNewProcAddr, __in DWORD dwFlags=0);
+  DWORD Hook(__inout HOOK_INFO aHookInfo[], __in SIZE_T nCount, __in DWORD dwFlags=0);
+  DWORD Hook(__inout LPHOOK_INFO aHookInfo[], __in SIZE_T nCount, __in DWORD dwFlags = 0);
+
+  DWORD RemoteHook(__out SIZE_T *lpnHookId, __out LPVOID *lplpCallOriginal, __in DWORD dwPid,
+                   __in LPVOID lpProcToHook, __in LPVOID lpNewProcAddr, __in DWORD dwFlags);
+  DWORD RemoteHook(__inout HOOK_INFO aHookInfo[], __in SIZE_T nCount, __in DWORD dwPid, __in DWORD dwFlags);
+  DWORD RemoteHook(__inout LPHOOK_INFO aHookInfo[], __in SIZE_T nCount, __in DWORD dwPid, __in DWORD dwFlags);
+
+  DWORD RemoteHook(__out SIZE_T *lpnHookId, __out LPVOID *lplpCallOriginal, __in HANDLE hProcess,
+                   __in LPVOID lpProcToHook, __in LPVOID lpNewProcAddr, __in DWORD dwFlags);
+  DWORD RemoteHook(__inout HOOK_INFO aHookInfo[], __in SIZE_T nCount, __in HANDLE hProcess, __in DWORD dwFlags);
+  DWORD RemoteHook(__inout LPHOOK_INFO aHookInfo[], __in SIZE_T nCount, __in HANDLE hProcess, __in DWORD dwFlags);
+
+  DWORD Unhook(__in SIZE_T nHookId);
+  DWORD Unhook(__in HOOK_INFO aHookInfo[], __in SIZE_T nCount);
+  DWORD Unhook(__in LPHOOK_INFO aHookInfo[], __in SIZE_T nCount);
+  VOID UnhookProcess(__in DWORD dwPid);
+  VOID UnhookAll();
+
+  //NOTE: The following 2 (two) methods will remove the hooks from the internal list of hooks but the original
+  //      hook(s) will remain active.
+  DWORD RemoveHook(__in SIZE_T nHookId, BOOL bDisable);
+  DWORD RemoveHook(__in HOOK_INFO aHookInfo[], __in SIZE_T nCount, __in BOOL bDisable);
+  DWORD RemoveHook(__in LPHOOK_INFO aHookInfo[], __in SIZE_T nCount, __in BOOL bDisable);
+
+  DWORD EnableHook(__in SIZE_T nHookId, __in BOOL bEnable);
+  DWORD EnableHook(__in HOOK_INFO aHookInfo[], __in SIZE_T nCount, __in BOOL bEnable);
+  DWORD EnableHook(__in LPHOOK_INFO aHookInfo[], __in SIZE_T nCount, __in BOOL bEnable);
+
+  DWORD SetSuspendThreadsWhileHooking(__in BOOL bEnable);
+  BOOL GetSuspendThreadsWhileHooking();
+
+  DWORD SetEnableDebugOutput(__in BOOL bEnable);
+  BOOL GetEnableDebugOutput();
+
+  void* __cdecl operator new(__in size_t nSize);
+  void* __cdecl operator new[](__in size_t nSize);
+  void* __cdecl operator new(__in size_t nSize, __inout void* lpInPlace);
+  void __cdecl operator delete(__inout void* p);
+  void __cdecl operator delete[](__inout void* p);
+#if _MSC_VER >= 1200
+  void __cdecl operator delete(__inout void* p, __inout void* lpPlace);
+#endif //_MSC_VER >= 1200
+
+private:
+  DWORD HookCommon(__in LPVOID lpInfo, __in SIZE_T nCount, __in DWORD dwPid, __in DWORD dwFlags);
+  DWORD UnhookCommon(__in LPVOID lpInfo, __in SIZE_T nCount, __in DWORD dwFlags);
+  DWORD RemoveHookCommon(__in LPVOID lpInfo, __in SIZE_T nCount, __in BOOL bDisable, __in DWORD dwFlags);
+  DWORD EnableHookCommon(__in LPVOID lpInfo, __in SIZE_T nCount, __in BOOL bEnable, __in DWORD dwFlags);
+
+private:
+  LPVOID lpInternals;
+};
+
+//-----------------------------------------------------------
+
+namespace NktHookLibHelpers {
+
+//NOTE: See "BuildNtSysCalls" below
+typedef struct tagSYSCALLDEF {
+  LPSTR szNtApiNameA;
+  SIZE_T nOffset;
+} SYSCALLDEF, *LPSYSCALLDEF;
+
+//--------------------------------
+
+//NOTE: See "SetApiResolverCallback" below
+typedef LPVOID (__stdcall *lpfnInternalApiResolver)(__in_z LPCSTR szApiNameA, __in LPVOID lpUserParam);
+
+//--------------------------------
+
+HINSTANCE GetModuleBaseAddress(__in_z LPCWSTR szDllNameW);
+LPVOID GetProcedureAddress(__in HINSTANCE hDll, __in LPCSTR szProcNameA);
+
+HINSTANCE GetRemoteModuleBaseAddress(__in HANDLE hProcess, __in_z LPCWSTR szDllNameW, __in BOOL bScanMappedImages);
+LPVOID GetRemoteProcedureAddress(__in HANDLE hProcess, __in HINSTANCE hDll, __in_z LPCSTR szProcNameA);
+
+//--------------------------------
+
+int sprintf_s(__out_z char *lpDest, __in size_t nMaxCount, __in_z const char *szFormatA, ...);
+int vsnprintf(__out_z char *lpDest, __in size_t nMaxCount, __in_z const char *szFormatA, __in va_list lpArgList);
+
+//only on XP or later
+int swprintf_s(__out_z wchar_t *lpDest, __in size_t nMaxCount, __in_z const wchar_t *szFormatW, ...);
+int vsnwprintf(__out_z wchar_t *lpDest, __in size_t nMaxCount, __in_z const wchar_t *szFormatW, __in va_list lpArgList);
+
+//--------------------------------
+
+//Returns a PROCESSOR_ARCHITECTURE_xxx value or -1 on error.
+LONG GetProcessorArchitecture();
+
+HANDLE OpenProcess(__in DWORD dwDesiredAccess, __in BOOL bInheritHandle, __in DWORD dwProcessId);
+HANDLE OpenThread(__in DWORD dwDesiredAccess, __in BOOL bInheritHandle, __in DWORD dwThreadId);
+
+LONG GetProcessPlatform(__in HANDLE hProcess);
+
+SIZE_T ReadMem(__in HANDLE hProcess, __out LPVOID lpDest, __in LPVOID lpSrc, __in SIZE_T nBytesCount);
+BOOL WriteMem(__in HANDLE hProcess, __out LPVOID lpDest, __in LPVOID lpSrc, __in SIZE_T nBytesCount);
+
+LONG GetThreadPriority(__in HANDLE hThread, __out int *lpnPriority);
+LONG SetThreadPriority(__in HANDLE hThread, __in int nPriority);
+
+DWORD GetCurrentThreadId();
+DWORD GetCurrentProcessId();
+
+HANDLE GetProcessHeap();
+LPVOID MemAlloc(__in SIZE_T nSize);
+VOID MemFree(__in LPVOID lpPtr);
+
+VOID MemSet(__out void *lpDest, __in int nVal, __in SIZE_T nCount);
+VOID MemCopy(__out void *lpDest, __in const void *lpSrc, __in SIZE_T nCount);
+SIZE_T TryMemCopy(__out void *lpDest, __in const void *lpSrc, __in SIZE_T nCount);
+VOID MemMove(__out void *lpDest, __in const void *lpSrc, __in SIZE_T nCount);
+int MemCompare(__in const void *lpBuf1, __in const void *lpBuf2, __in SIZE_T nCount);
+
+//--------------------------------
+
+VOID DebugPrint(__in LPCSTR szFormatA, ...);
+VOID DebugVPrint(__in LPCSTR szFormatA, __in va_list argptr);
+
+//--------------------------------
+
+SIZE_T GetInstructionLength(__in LPVOID lpAddr, __in SIZE_T nSize, __in BYTE nPlatformBits,
+                            __out_opt BOOL *lpbIsMemOp=NULL, __out_z_opt LPSTR szBufA=NULL, __in SIZE_T nBufLen=0);
+
+//NOTE: When NktHookLib is initialized, it tries to locate needed ntdll's apis by scanning process' modules.
+//      If you want to override an api call, use this method to set the resolver address. LPVOID returned by
+//      the callback must have the same definition and calling convention than the one in ntdll. Return NULL
+//      if you want NktHookLib to use the real ntdll api.
+VOID SetInternalApiResolverCallback(__in lpfnInternalApiResolver fnInternalApiResolver, __in LPVOID lpUserParam);
+
+//This function generates a relocatable byte code with a copy of the original SysCall routine for each passes
+//ntdll api. The code is created based on the original ntdll.dll image file on disk located on System32 or SysWow64,
+//depending on the target platform.
+//
+//Useful for doing direct calls to low level apis bypassing third party hooks (like Chrome navigator does). Also, you
+//can pass the generated code to another process. You can generate the code with this method, pass it to another
+//process and then use SetApiResolverCallback above.
+//
+//NOTE: Not all NtXXX apis are SysCalls. Trying to generate code for a non-syscall api may generate an unexpected
+//      behavior.
+//      If 'lpCode' is NULL, the needed space is returned. Although syscalls uses less than 32 bytes, a maximum of 256
+//      bytes are supported for each requested api. You can safety allocate a block of 256*nDefsCount bytes to hold
+//      the generated code.
+DWORD BuildNtSysCalls(__in LPSYSCALLDEF lpDefs, __in SIZE_T nDefsCount, __in SIZE_T nPlatform,
+                      __out_opt LPVOID lpCode, __out SIZE_T *lpnCodeSize);
+
+//--------------------------------
+
+//NOTE: Return 0xFFFFFFFF if remote thread is not accessible
+DWORD GetWin32LastError(__in_opt HANDLE hThread=NULL);
+BOOL SetWin32LastError(__in DWORD dwErrorCode, __in_opt HANDLE hThread=NULL);
+
+//--------------------------------
+
+BOOL GetOsVersion(__out_opt LPDWORD lpdwVerMajor=NULL, __out_opt LPDWORD lpdwVerMinor=NULL,
+                  __out_opt LPDWORD lpdwBuildNumber=NULL);
+
+//--------------------------------
+
+//NOTE: CreateProcessWithDllW and related functions returns the Win32 error code directly. NOERROR => Success.
+//
+//      If "szDllNameW" string ends with 'x86.dll', 'x64.dll', '32.dll', '64.dll', the dll name will be adjusted
+//      in order to match the process platform. I.e.: "mydll_x86.dll" will become "mydll_x64.dll" on 64-bit processes.
+DWORD CreateProcessWithDllW(__in_z_opt LPCWSTR lpApplicationName, __inout_z_opt LPWSTR lpCommandLine,
+                            __in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes,
+                            __in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, __in BOOL bInheritHandles,
+                            __in DWORD dwCreationFlags, __in_z_opt LPCWSTR lpEnvironment,
+                            __in_z_opt LPCWSTR lpCurrentDirectory, __in LPSTARTUPINFOW lpStartupInfo,
+                            __out LPPROCESS_INFORMATION lpProcessInformation, __in_z LPCWSTR szDllNameW,
+                            __in_opt HANDLE hSignalCompleted=NULL, __in_z_opt LPCSTR szInitFunctionA=NULL,
+                            __in_opt LPVOID lpInitFuncParams=NULL, __in_opt ULONG nInitFuncParamsSize=0);
+
+DWORD CreateProcessWithLogonAndDllW(__in_z LPCWSTR lpUsername, __in_z_opt LPCWSTR lpDomain, __in_z LPCWSTR lpPassword,
+                                    __in DWORD dwLogonFlags, __in_opt LPCWSTR lpApplicationName,
+                                    __inout_opt LPWSTR lpCommandLine, __in DWORD dwCreationFlags,
+                                    __in_z_opt LPCWSTR lpEnvironment, __in_z_opt LPCWSTR lpCurrentDirectory,
+                                    __in LPSTARTUPINFOW lpStartupInfo, __out LPPROCESS_INFORMATION lpProcessInformation,
+                                    __in_z LPCWSTR szDllNameW, __in_opt HANDLE hSignalCompleted=NULL,
+                                    __in_z_opt LPCSTR szInitFunctionA=NULL, __in_opt LPVOID lpInitFuncParams=NULL,
+                                    __in_opt ULONG nInitFuncParamsSize=0);
+
+DWORD CreateProcessWithTokenAndDllW(__in HANDLE hToken, __in DWORD dwLogonFlags, __in_z_opt LPCWSTR lpApplicationName,
+                                    __inout_opt LPWSTR lpCommandLine, __in DWORD dwCreationFlags,
+                                    __in_z_opt LPCWSTR lpEnvironment, __in_z_opt LPCWSTR lpCurrentDirectory,
+                                    __in LPSTARTUPINFOW lpStartupInfo, __out LPPROCESS_INFORMATION lpProcessInformation,
+                                    __in_z LPCWSTR szDllNameW, __in_opt HANDLE hSignalCompleted=NULL,
+                                    __in_z_opt LPCSTR szInitFunctionA=NULL, __in_opt LPVOID lpInitFuncParams=NULL,
+                                    __in_opt ULONG nInitFuncParamsSize=0);
+
+DWORD InjectDllByPidW(__in DWORD dwPid, __in_z LPCWSTR szDllNameW, __in_z_opt LPCSTR szInitFunctionA=NULL,
+                      __in_opt DWORD dwProcessInitWaitTimeoutMs=5000, __out_opt LPHANDLE lphInjectorThread=NULL,
+                      __in_opt LPVOID lpInitFuncParams=NULL, __in_opt ULONG nInitFuncParamsSize=0);
+
+DWORD InjectDllByHandleW(__in HANDLE hProcess, __in_z LPCWSTR szDllNameW, __in_z_opt LPCSTR szInitFunctionA=NULL,
+                         __in_opt DWORD dwProcessInitWaitTimeoutMs=5000, __out_opt LPHANDLE lphInjectorThread=NULL,
+                         __in_opt LPVOID lpInitFuncParams=NULL, __in_opt ULONG nInitFuncParamsSize=0);
+
+} //NktHookLibHelpers
+
+//-----------------------------------------------------------
+
+#endif //_NKTHOOKLIB
@@ -51,6 +51,7 @@
 #include "SDL_power.h"
 #include "SDL_render.h"
 #include "SDL_rwops.h"
+#include "SDL_sensor.h"
 #include "SDL_shape.h"
 #include "SDL_system.h"
 #include "SDL_thread.h"
@@ -80,10 +81,11 @@ extern "C" {
 #define SDL_INIT_HAPTIC         0x00001000u
 #define SDL_INIT_GAMECONTROLLER 0x00002000u  /**< SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */
 #define SDL_INIT_EVENTS         0x00004000u
+#define SDL_INIT_SENSOR         0x00008000u
 #define SDL_INIT_NOPARACHUTE    0x00100000u  /**< compatibility; this flag is ignored. */
 #define SDL_INIT_EVERYTHING ( \
                SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \
-                SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER \
+                SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER | SDL_INIT_SENSOR \
            )
 /* @} */

@@ -140,7 +140,8 @@ typedef Uint16 SDL_AudioFormat;
 #define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE    0x00000001
 #define SDL_AUDIO_ALLOW_FORMAT_CHANGE       0x00000002
 #define SDL_AUDIO_ALLOW_CHANNELS_CHANGE     0x00000004
-#define SDL_AUDIO_ALLOW_ANY_CHANGE          (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE|SDL_AUDIO_ALLOW_FORMAT_CHANGE|SDL_AUDIO_ALLOW_CHANNELS_CHANGE)
+#define SDL_AUDIO_ALLOW_SAMPLES_CHANGE      0x00000008
+#define SDL_AUDIO_ALLOW_ANY_CHANGE          (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE|SDL_AUDIO_ALLOW_FORMAT_CHANGE|SDL_AUDIO_ALLOW_CHANNELS_CHANGE|SDL_AUDIO_ALLOW_SAMPLES_CHANGE)
 /* @} */

 /* @} *//* Audio flags */
@@ -82,6 +82,9 @@ typedef unsigned int uintptr_t;
 #define HAVE_DSOUND_H 1
 #define HAVE_DXGI_H 1
 #define HAVE_XINPUT_H 1
+#define HAVE_MMDEVICEAPI_H 1
+#define HAVE_AUDIOCLIENT_H 1
+#define HAVE_ENDPOINTVOLUME_H 1

 /* This is disabled by default to avoid C runtime dependencies and manifest requirements */
 #ifdef HAVE_LIBC
@@ -139,6 +142,8 @@ typedef unsigned int uintptr_t;
 #define HAVE__COPYSIGN  1
 #define HAVE_COS    1
 #define HAVE_COSF   1
+#define HAVE_EXP    1
+#define HAVE_EXPF   1
 #define HAVE_FABS   1
 #define HAVE_FABSF  1
 #define HAVE_FLOOR  1
@@ -188,9 +193,13 @@ typedef unsigned int uintptr_t;
 /* Enable various input drivers */
 #define SDL_JOYSTICK_DINPUT 1
 #define SDL_JOYSTICK_XINPUT 1
+#define SDL_JOYSTICK_HIDAPI 1
 #define SDL_HAPTIC_DINPUT   1
 #define SDL_HAPTIC_XINPUT   1

+/* Enable the dummy sensor driver */
+#define SDL_SENSOR_DUMMY  1
+
 /* Enable various shared object loading systems */
 #define SDL_LOADSO_WINDOWS  1

@@ -51,16 +51,19 @@
 #include <intrin.h>
 #else
 #ifdef __ALTIVEC__
-#if HAVE_ALTIVEC_H && !defined(__APPLE_ALTIVEC__) && !defined(SDL_DISABLE_ALTIVEC_H)
+#if defined(HAVE_ALTIVEC_H) && !defined(__APPLE_ALTIVEC__) && !defined(SDL_DISABLE_ALTIVEC_H)
 #include <altivec.h>
 #undef pixel
 #undef bool
 #endif
 #endif
+#if defined(__ARM_NEON__) && !defined(SDL_DISABLE_ARM_NEON_H)
+#include <arm_neon.h>
+#endif
 #if defined(__3dNOW__) && !defined(SDL_DISABLE_MM3DNOW_H)
 #include <mm3dnow.h>
 #endif
-#if HAVE_IMMINTRIN_H && !defined(SDL_DISABLE_IMMINTRIN_H)
+#if defined(HAVE_IMMINTRIN_H) && !defined(SDL_DISABLE_IMMINTRIN_H)
 #include <immintrin.h>
 #else
 #if defined(__MMX__) && !defined(SDL_DISABLE_MMINTRIN_H)
@@ -159,6 +162,11 @@ extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX(void);
 */
 extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX2(void);

+/**
+ *  This function returns true if the CPU has AVX-512F (foundation) features.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX512F(void);
+
 /**
 *  This function returns true if the CPU has NEON (ARM SIMD) features.
 */
@@ -169,7 +177,6 @@ extern DECLSPEC SDL_bool SDLCALL SDL_HasNEON(void);
 */
 extern DECLSPEC int SDLCALL SDL_GetSystemRAM(void);

-
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
@@ -85,6 +85,9 @@ typedef enum
                                     Called on Android in onResume()
                                */

+    /* Display events */
+    SDL_DISPLAYEVENT   = 0x150,  /**< Display state change */
+
    /* Window events */
    SDL_WINDOWEVENT    = 0x200, /**< Window state change */
    SDL_SYSWMEVENT,             /**< System specific event */
@@ -144,6 +147,9 @@ typedef enum
    SDL_AUDIODEVICEADDED = 0x1100, /**< A new audio device is available */
    SDL_AUDIODEVICEREMOVED,        /**< An audio device has been removed. */

+    /* Sensor events */
+    SDL_SENSORUPDATE = 0x1200,     /**< A sensor was updated */
+
    /* Render events */
    SDL_RENDER_TARGETS_RESET = 0x2000, /**< The render targets have been reset and their contents need to be updated */
    SDL_RENDER_DEVICE_RESET, /**< The device has been reset and all textures need to be recreated */
@@ -168,6 +174,21 @@ typedef struct SDL_CommonEvent
    Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
 } SDL_CommonEvent;

+/**
+ *  \brief Display state change event data (event.display.*)
+ */
+typedef struct SDL_DisplayEvent
+{
+    Uint32 type;        /**< ::SDL_DISPLAYEVENT */
+    Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
+    Uint32 display;     /**< The associated display index */
+    Uint8 event;        /**< ::SDL_DisplayEventID */
+    Uint8 padding1;
+    Uint8 padding2;
+    Uint8 padding3;
+    Sint32 data1;       /**< event dependent data */
+} SDL_DisplayEvent;
+
 /**
 *  \brief Window state change event data (event.window.*)
 */
@@ -471,6 +492,17 @@ typedef struct SDL_DropEvent
 } SDL_DropEvent;


+/**
+ *  \brief Sensor event structure (event.sensor.*)
+ */
+typedef struct SDL_SensorEvent
+{
+    Uint32 type;        /**< ::SDL_SENSORUPDATE */
+    Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
+    Sint32 which;       /**< The instance ID of the sensor */
+    float data[6];      /**< Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData() */
+} SDL_SensorEvent;
+
 /**
 *  \brief The "quit requested" event
 */
@@ -526,6 +558,7 @@ typedef union SDL_Event
 {
    Uint32 type;                    /**< Event type, shared with all events */
    SDL_CommonEvent common;         /**< Common event data */
+    SDL_DisplayEvent display;       /**< Window event data */
    SDL_WindowEvent window;         /**< Window event data */
    SDL_KeyboardEvent key;          /**< Keyboard event data */
    SDL_TextEditingEvent edit;      /**< Text editing event data */
@@ -542,6 +575,7 @@ typedef union SDL_Event
    SDL_ControllerButtonEvent cbutton;  /**< Game Controller button event data */
    SDL_ControllerDeviceEvent cdevice;  /**< Game Controller device event data */
    SDL_AudioDeviceEvent adevice;   /**< Audio device event data */
+    SDL_SensorEvent sensor;         /**< Sensor event data */
    SDL_QuitEvent quit;             /**< Quit request event data */
    SDL_UserEvent user;             /**< Custom event data */
    SDL_SysWMEvent syswm;           /**< System dependent window event data */
@@ -175,6 +175,14 @@ extern DECLSPEC SDL_bool SDLCALL SDL_IsGameController(int joystick_index);
 */
 extern DECLSPEC const char *SDLCALL SDL_GameControllerNameForIndex(int joystick_index);

+/**
+ *  Get the mapping of a game controller.
+ *  This can be called before any controllers are opened.
+ *
+ *  \return the mapping string.  Must be freed with SDL_free().  Returns NULL if no mapping is available
+ */
+extern DECLSPEC char *SDLCALL SDL_GameControllerMappingForDeviceIndex(int joystick_index);
+
 /**
 *  Open a game controller for use.
 *  The index passed as an argument refers to the N'th game controller on the system.
@@ -196,6 +204,13 @@ extern DECLSPEC SDL_GameController *SDLCALL SDL_GameControllerFromInstanceID(SDL
 */
 extern DECLSPEC const char *SDLCALL SDL_GameControllerName(SDL_GameController *gamecontroller);

+/**
+ *  Get the player index of an opened game controller, or -1 if it's not available
+ *
+ *  For XInput controllers this returns the XInput user index.
+ */
+extern DECLSPEC int SDLCALL SDL_GameControllerGetPlayerIndex(SDL_GameController *gamecontroller);
+
 /**
 *  Get the USB vendor ID of an opened controller, if available.
 *  If the vendor ID isn't available this function returns 0.
@@ -345,6 +360,19 @@ SDL_GameControllerGetBindForButton(SDL_GameController *gamecontroller,
 extern DECLSPEC Uint8 SDLCALL SDL_GameControllerGetButton(SDL_GameController *gamecontroller,
                                                          SDL_GameControllerButton button);

+/**
+ *  Trigger a rumble effect
+ *  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+ *
+ *  \param gamecontroller The controller to vibrate
+ *  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+ *  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+ *  \param duration_ms The duration of the rumble effect, in milliseconds
+ *
+ *  \return 0, or -1 if rumble isn't supported on this joystick
+ */
+extern DECLSPEC int SDLCALL SDL_GameControllerRumble(SDL_GameController *gamecontroller, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms);
+
 /**
 *  Close a controller previously opened with SDL_GameControllerOpen().
 */
@@ -117,6 +117,17 @@
 extern "C" {
 #endif /* __cplusplus */

+/* FIXME: For SDL 2.1, adjust all the magnitude variables to be Uint16 (0xFFFF).
+ *
+ * At the moment the magnitude variables are mixed between signed/unsigned, and
+ * it is also not made clear that ALL of those variables expect a max of 0x7FFF.
+ *
+ * Some platforms may have higher precision than that (Linux FF, Windows XInput)
+ * so we should fix the inconsistency in favor of higher possible precision,
+ * adjusting for platforms that use different scales.
+ * -flibit
+ */
+
 /**
 *  \typedef SDL_Haptic
 *
@@ -656,8 +667,8 @@ typedef struct SDL_HapticRamp
 * This struct is exclusively for the ::SDL_HAPTIC_LEFTRIGHT effect.
 *
 * The Left/Right effect is used to explicitly control the large and small
- * motors, commonly found in modern game controllers. One motor is high
- * frequency, the other is low frequency.
+ * motors, commonly found in modern game controllers. The small (right) motor
+ * is high frequency, and the large (left) motor is low frequency.
 *
 * \sa SDL_HAPTIC_LEFTRIGHT
 * \sa SDL_HapticEffect
@@ -668,7 +679,7 @@ typedef struct SDL_HapticLeftRight
    Uint16 type;            /**< ::SDL_HAPTIC_LEFTRIGHT */

    /* Replay */
-    Uint32 length;          /**< Duration of the effect. */
+    Uint32 length;          /**< Duration of the effect in milliseconds. */

    /* Rumble */
    Uint16 large_magnitude; /**< Control of the large controller motor. */
@@ -262,6 +262,16 @@ extern "C" {
 */
 #define SDL_HINT_GRAB_KEYBOARD              "SDL_GRAB_KEYBOARD"

+/**
+ *  \brief  A variable setting the double click time, in milliseconds.
+ */
+#define SDL_HINT_MOUSE_DOUBLE_CLICK_TIME    "SDL_MOUSE_DOUBLE_CLICK_TIME"
+
+/**
+ *  \brief  A variable setting the double click radius, in pixels.
+ */
+#define SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS    "SDL_MOUSE_DOUBLE_CLICK_RADIUS"
+
 /**
 *  \brief  A variable setting the speed scale for mouse motion, in floating point, when the mouse is not in relative mode
 */
@@ -329,7 +339,7 @@ extern "C" {
 #define SDL_HINT_IDLE_TIMER_DISABLED "SDL_IOS_IDLE_TIMER_DISABLED"

 /**
- *  \brief  A variable controlling which orientations are allowed on iOS.
+ *  \brief  A variable controlling which orientations are allowed on iOS/Android.
 *
 *  In some circumstances it is necessary to be able to explicitly control
 *  which UI orientations are allowed.
@@ -465,6 +475,88 @@ extern "C" {
 */
 #define SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS"

+/**
+ *  \brief  A variable controlling whether the HIDAPI joystick drivers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI drivers are not used
+ *    "1"       - HIDAPI drivers are used (the default)
+ *
+ *  This variable is the default for all drivers, but can be overridden by the hints for specific drivers below.
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI "SDL_JOYSTICK_HIDAPI"
+
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for PS4 controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used
+ *
+ *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_PS4 "SDL_JOYSTICK_HIDAPI_PS4"
+
+/**
+ *  \brief  A variable controlling whether extended input reports should be used for PS4 controllers when using the HIDAPI driver.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - extended reports are not enabled (the default)
+ *    "1"       - extended reports
+ *
+ *  Extended input reports allow rumble on Bluetooth PS4 controllers, but
+ *  break DirectInput handling for applications that don't use SDL.
+ *
+ *  Once extended reports are enabled, they can not be disabled without
+ *  power cycling the controller.
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE"
+
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for Steam Controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used
+ *
+ *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_STEAM "SDL_JOYSTICK_HIDAPI_STEAM"
+
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for Nintendo Switch controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used
+ *
+ *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_SWITCH "SDL_JOYSTICK_HIDAPI_SWITCH"
+
+/**
+ *  \brief  A variable controlling whether the HIDAPI driver for XBox controllers should be used.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - HIDAPI driver is not used
+ *    "1"       - HIDAPI driver is used
+ *
+ *  The default is the value of SDL_HINT_JOYSTICK_HIDAPI
+ */
+#define SDL_HINT_JOYSTICK_HIDAPI_XBOX   "SDL_JOYSTICK_HIDAPI_XBOX"
+
+/**
+ *  \brief  A variable that controls whether Steam Controllers should be exposed using the SDL joystick and game controller APIs
+ *
+ *  The variable can be set to the following values:
+ *    "0"       - Do not scan for Steam Controllers
+ *    "1"       - Scan for Steam Controllers (the default)
+ *
+ *  The default value is "1".  This hint must be set before initializing the joystick subsystem.
+ */
+#define SDL_HINT_ENABLE_STEAM_CONTROLLERS "SDL_ENABLE_STEAM_CONTROLLERS"
+
+
 /**
 *  \brief If set to "0" then never set the top most bit on a SDL Window, even if the video mode expects it.
 *      This is a debugging aid for developers and not expected to be used by end users. The default is "1"
@@ -527,6 +619,10 @@ extern "C" {
 *  This is specially useful if you build SDL against a non glibc libc library (such as musl) which
 *  provides a relatively small default thread stack size (a few kilobytes versus the default 8MB glibc uses).
 *  Support for this hint is currently available only in the pthread, Windows, and PSP backend.
+*
+*  Instead of this hint, in 2.0.9 and later, you can use
+*  SDL_CreateThreadWithStackSize(). This hint only works with the classic
+*  SDL_CreateThread().
 */
 #define SDL_HINT_THREAD_STACK_SIZE              "SDL_THREAD_STACK_SIZE"

@@ -752,6 +848,23 @@ extern "C" {
 */
 #define SDL_HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH "SDL_ANDROID_SEPARATE_MOUSE_AND_TOUCH"

+ /**
+ * \brief A variable to control whether we trap the Android back button to handle it manually.
+ *        This is necessary for the right mouse button to work on some Android devices, or
+ *        to be able to trap the back button for use in your code reliably.  If set to true,
+ *        the back button will show up as an SDL_KEYDOWN / SDL_KEYUP pair with a keycode of 
+ *        SDL_SCANCODE_AC_BACK.
+ *
+ * The variable can be set to the following values:
+ *   "0"       - Back button will be handled as usual for system. (default)
+ *   "1"       - Back button will be trapped, allowing you to handle the key press
+ *               manually.  (This will also let right mouse click work on systems 
+ *               where the right mouse button functions as back.)
+ *
+ * The value of this hint is used at runtime, so it can be changed at any time.
+ */
+#define SDL_HINT_ANDROID_TRAP_BACK_BUTTON "SDL_ANDROID_TRAP_BACK_BUTTON"
+
 /**
 * \brief A variable to control whether the return key on the soft keyboard
 *        should hide the soft keyboard on Android and iOS.
@@ -97,10 +97,10 @@ typedef enum
 typedef enum
 {
    SDL_JOYSTICK_POWER_UNKNOWN = -1,
-    SDL_JOYSTICK_POWER_EMPTY,
-    SDL_JOYSTICK_POWER_LOW,
-    SDL_JOYSTICK_POWER_MEDIUM,
-    SDL_JOYSTICK_POWER_FULL,
+    SDL_JOYSTICK_POWER_EMPTY,   /* <= 5% */
+    SDL_JOYSTICK_POWER_LOW,     /* <= 20% */
+    SDL_JOYSTICK_POWER_MEDIUM,  /* <= 70% */
+    SDL_JOYSTICK_POWER_FULL,    /* <= 100% */
    SDL_JOYSTICK_POWER_WIRED,
    SDL_JOYSTICK_POWER_MAX
 } SDL_JoystickPowerLevel;
@@ -132,6 +132,12 @@ extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
 */
 extern DECLSPEC const char *SDLCALL SDL_JoystickNameForIndex(int device_index);

+/**
+ *  Get the player index of a joystick, or -1 if it's not available
+ *  This can be called before any joysticks are opened.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickGetDevicePlayerIndex(int device_index);
+
 /**
 *  Return the GUID for the joystick at this index
 *  This can be called before any joysticks are opened.
@@ -194,6 +200,13 @@ extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickFromInstanceID(SDL_JoystickID
 */
 extern DECLSPEC const char *SDLCALL SDL_JoystickName(SDL_Joystick * joystick);

+/**
+ *  Get the player index of an opened joystick, or -1 if it's not available
+ *
+ *  For XInput controllers this returns the XInput user index.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickGetPlayerIndex(SDL_Joystick * joystick);
+
 /**
 *  Return the GUID for this opened joystick
 */
@@ -361,6 +374,19 @@ extern DECLSPEC int SDLCALL SDL_JoystickGetBall(SDL_Joystick * joystick,
 extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetButton(SDL_Joystick * joystick,
                                                    int button);

+/**
+ *  Trigger a rumble effect
+ *  Each call to this function cancels any previous rumble effect, and calling it with 0 intensity stops any rumbling.
+ *
+ *  \param joystick The joystick to vibrate
+ *  \param low_frequency_rumble The intensity of the low frequency (left) rumble motor, from 0 to 0xFFFF
+ *  \param high_frequency_rumble The intensity of the high frequency (right) rumble motor, from 0 to 0xFFFF
+ *  \param duration_ms The duration of the rumble effect, in milliseconds
+ *
+ *  \return 0, or -1 if rumble isn't supported on this joystick
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickRumble(SDL_Joystick * joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms);
+
 /**
 *  Close a joystick previously opened with SDL_JoystickOpen().
 */
@@ -1,2 +1,2 @@
-#define SDL_REVISION "hg-11914:f1084c419f33"
-#define SDL_REVISION_NUMBER 11914
+#define SDL_REVISION "hg-12373:8feb5da6f2fb"
+#define SDL_REVISION_NUMBER 12373
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Cameron Gutman	12b7f6b7a3	Fix appstream metadata release date for v0.8.1	2019-01-29 18:52:01 -08:00
Cameron Gutman	32e7ddf272	Version 0.8.1	2019-01-08 00:48:49 -08:00
Cameron Gutman	7091e0324e	Update macOS builds to FFmpeg 4.1	2019-01-07 21:43:18 -08:00
Cameron Gutman	8f8532921c	Update FFmpeg build script for Mac to avoid manual steps	2019-01-07 21:39:59 -08:00
Cameron Gutman	e9936992ec	Update Windows builds to FFmpeg 4.1	2019-01-07 21:08:08 -08:00
Cameron Gutman	6375055b3e	Set scripts executable	2019-01-07 20:34:56 -08:00
Cameron Gutman	88b1ea296c	Remove video bitrate tooltip since audio is accounted for during remote streaming	2019-01-06 15:41:00 -08:00
Cameron Gutman	2a13a869f3	Don't allow the scroll wheel to move the bitrate slider	2019-01-06 15:39:54 -08:00
Cameron Gutman	89c342bb6f	Introduce more granular HTTP timeouts	2019-01-06 14:35:33 -08:00
Cameron Gutman	067f5e33aa	Increase audio buffer on Linux to 25 ms. Fixes #147 . Fixes #157 .	2019-01-06 13:49:20 -08:00
Cameron Gutman	33695f1c6b	Update common-c to reduce audio latency	2019-01-06 13:29:06 -08:00
Cameron Gutman	52ef84873e	Remove excess latency control logic from SDL renderer, since it doesn't appear to work very well anyway	2019-01-06 13:28:43 -08:00
Cameron Gutman	c21ba5c808	Allow the audio renderer to be overriden by the ML_AUDIO environment variable	2019-01-06 13:28:05 -08:00
Cameron Gutman	6cf408f12b	Update macOS build steps	2019-01-05 19:23:01 -08:00
Cameron Gutman	8bdc2d285d	Rename macOS build output to match final release name	2019-01-05 19:06:00 -08:00
Cameron Gutman	a66fbcd6be	Use version.txt for Info.plist too	2019-01-05 18:53:17 -08:00
Cameron Gutman	93402a62fc	Archive symbol ZIP to ML_SYMBOL_ARCHIVE folder	2019-01-05 18:20:53 -08:00
Cameron Gutman	2a56fb6c70	Add config.test generated files to gitignore	2019-01-05 18:10:20 -08:00
Cameron Gutman	8276c031e9	Name the Windows output binaries to match their final names on GitHub	2019-01-05 18:09:52 -08:00
Cameron Gutman	102e5f6de9	Move the version string into version.txt	2019-01-05 18:08:34 -08:00
Cameron Gutman	1f7bdbfbcb	Fail signed release builds if unstaged changes exist	2019-01-05 17:25:40 -08:00
Cameron Gutman	f2fdd048c7	Use stun.moonlight-stream.org for STUN	2019-01-04 20:16:27 -08:00
Cameron Gutman	5a2cfc15a6	Ensure WoL works properly on multi-homed hosts. Fixes #135	2019-01-04 20:05:31 -08:00
Cameron Gutman	11c7131875	Replace forgotten clamp to frameCountMax removed by `e75dce2543`	2019-01-03 18:49:18 -08:00
Cameron Gutman	34aacc90d7	Include version string in update tooltip	2019-01-03 18:00:54 -08:00
Cameron Gutman	e75dce2543	Remove one-sample-per-callback write logic to fix crackling at 44.1 KHz. Fixes #152	2019-01-03 17:23:29 -08:00
Cameron Gutman	e2774309fb	Fix context menus on Qt 5.9	2019-01-02 19:49:06 -08:00
Cameron Gutman	dfefdc93c5	Update macOS icns	2019-01-01 19:33:08 -08:00
Cameron Gutman	d46ea28bba	Merge pull request #151 from Jorys-Paulin/feature/icon-tweaks Updated Moonlight icon	2019-01-01 19:32:21 -08:00
Cameron Gutman	d35c5bcaba	Print socket errors when sending WoL packets	2019-01-01 19:20:09 -08:00
Cameron Gutman	2b14856d7f	Update common-c for strict remote bitrate logic	2019-01-01 19:03:52 -08:00
Jorys Paulin	3316fdb80e	Updated Moonlight icon	2018-12-26 13:29:49 +01:00
Cameron Gutman	c5d70c48c9	Fix QMap usage where insertion on read of missing value was not intended	2018-12-26 00:59:30 -08:00
Cameron Gutman	82230ef2f5	Version 0.8.0	2018-12-25 22:29:27 -08:00
Cameron Gutman	dcfd3d3e48	Add a debug print for V-sync	2018-12-25 22:19:23 -08:00
Cameron Gutman	cb1e2ac32e	Avoid filling our client logs with QNetworkReplyHttpImplPrivate warnings	2018-12-25 21:54:20 -08:00
Cameron Gutman	ec2c15946a	Update audio buffering parameters based on local testing	2018-12-25 21:45:15 -08:00
Cameron Gutman	8be73142f8	Fix cert pinning on macOS	2018-12-25 21:15:59 -08:00
Cameron Gutman	d1640e3bb8	Audio latency tweaks and fix for PulseAudio with A2DP	2018-12-25 17:54:18 -08:00
Cameron Gutman	8612e6726d	Remove accidentally enabled debug prints	2018-12-25 14:05:55 -08:00
Cameron Gutman	3b4694e9f8	Add libraries required by libsoundio	2018-12-25 14:05:35 -08:00
Cameron Gutman	14cb2e1999	Remove latency drop logic and replace by single frame writes	2018-12-25 14:05:17 -08:00
Cameron Gutman	cfabaf334e	Add frame pacing toggle	2018-12-25 12:57:00 -08:00
Cameron Gutman	c054536fab	Count Pacer delay in frame stats	2018-12-25 12:09:45 -08:00
Cameron Gutman	35aac18b4e	Improve bitrate slider label and add tooltip	2018-12-25 11:48:34 -08:00
Cameron Gutman	de3928cb4d	Reduce FPs on the unmapped gamepad dialog	2018-12-25 11:41:48 -08:00
Cameron Gutman	9bf612b800	Update common-c with bitrate fix	2018-12-24 20:10:37 -08:00
Cameron Gutman	d9a8d67e3d	Use a shared UID for all Moonlight clients	2018-12-22 21:04:44 -08:00
Cameron Gutman	99b0a56a6a	Add additional cert pinning assert	2018-12-22 20:05:45 -08:00
Cameron Gutman	61d7aa0400	Require cert pinning for HTTPS	2018-12-22 19:55:28 -08:00
Cameron Gutman	1e98594972	Handle server cert change by pairing again	2018-12-21 19:17:32 -08:00
Cameron Gutman	c6383f042c	Pin server cert to host during pairing	2018-12-21 18:08:07 -08:00
Cameron Gutman	b4d8e0e551	Update bug_report.md	2018-12-19 23:11:15 +04:00
Cameron Gutman	d696536486	Version 0.7.0	2018-12-05 22:49:42 -08:00
Cameron Gutman	b46a3cf759	Show stream error dialog when launching from the CLI	2018-12-05 22:22:30 -08:00
Cameron Gutman	8a5e3cdb76	Fix returning to app page when start fails	2018-12-05 22:17:26 -08:00
Cameron Gutman	4fb39226ef	Fix 'moonlight -v' output on Linux	2018-12-05 22:01:22 -08:00
Cameron Gutman	c40174034c	Don't kill the app on the host when the session terminates unexpectedly	2018-12-05 20:17:00 -08:00
Cameron Gutman	5029c855f0	Simplify app quitting implementation a bit	2018-12-05 19:49:06 -08:00
Cameron Gutman	2eee839eaa	Update moonlight-common-c	2018-12-05 18:47:56 -08:00
Cameron Gutman	f42c7fec1e	Update SDL GC DB	2018-12-05 18:47:44 -08:00
Janne Hakonen	0ab07303c9	Add quit cli command and app quit option after stream session. Fixes #92 (#138 ) * Add quit cli command and app quit option after stream session. Fixes #92 * Code review fixes.	2018-12-05 18:45:28 -08:00
Cameron Gutman	ad47990a87	Make update icon more obnoxious so people actually update	2018-12-05 18:40:21 -08:00
Cameron Gutman	1968461ce9	Allow HTTP redirects when checking for updates	2018-12-03 23:29:49 -08:00
Cameron Gutman	8aa3b5d3da	Switch to new hostname	2018-12-03 21:48:49 -08:00
Cameron Gutman	23e77eefb0	Rename multi-controller checkbox to be more descriptive	2018-11-29 20:10:47 -08:00
Cameron Gutman	094443cf26	Rename start in windowed mode option to be more accurate	2018-11-28 21:46:14 -08:00
Cameron Gutman	b97758ef46	Switch to libsoundio on Linux now that PA works reliably after `d1fe752028`	2018-11-28 00:13:04 -08:00
Cameron Gutman	d1fe752028	Fix busy looping in libsoundio audio renderer when no audio is playing	2018-11-27 23:43:31 -08:00
Cameron Gutman	b26df787cd	Update to upstream libsoundio	2018-11-27 23:26:15 -08:00
Cameron Gutman	4c5b254730	Add larger downloads section	2018-11-23 02:09:54 -08:00
Cameron Gutman	9a153b7170	Remove unneccessary hardcoded text color for better style support	2018-11-22 02:35:25 -08:00
Cameron Gutman	065a6caee5	Use automatic remote streaming detection	2018-11-21 20:55:25 -08:00
Cameron Gutman	9c7df02941	Avoid duplicate framework copy now that it's handle in the project file	2018-11-20 22:43:10 -08:00
Cameron Gutman	c63c5100e2	Version 0.6.4	2018-11-20 22:23:03 -08:00
Cameron Gutman	bf05088d70	Remove checks that rely on display modes because they can be inaccurate on machines when the monitor is off	2018-11-20 22:02:43 -08:00
Cameron Gutman	e7bb146f92	Allow streaming to match the refresh rate in unsupported mode	2018-11-20 21:47:08 -08:00
Cameron Gutman	688c4a90d9	Use the raw display bounds not the usable display bounds for full-screen calculations	2018-11-18 23:10:30 -08:00
Cameron Gutman	165ad96be1	Fix stack overflow if SDL gamepad initialization fails	2018-11-18 22:04:44 -08:00
Cameron Gutman	115ced7ab4	Only precompile QML files on release builds	2018-11-18 22:04:11 -08:00
Cameron Gutman	ef15b5641a	Fix accidental dependency on system SDL2.framework when building in the IDE	2018-11-18 21:23:46 -08:00
Cameron Gutman	be50464619	Revert "Update SDL2.framework to 2.0.9" This reverts commit `7254224347`.	2018-11-18 16:04:52 -08:00
Cameron Gutman	d847b71c86	Fix host virtual gamepads being reconnected during stream startup and causing issues with multiple controllers. Fixes #108	2018-11-18 12:05:17 -08:00
Cameron Gutman	dfcc1ff899	Also print gamepad mapping on gamepad attach	2018-11-17 17:23:20 -08:00
Cameron Gutman	65562937f3	Print gamepad GUID string in logs	2018-11-17 17:10:52 -08:00
Cameron Gutman	7b5dc33a21	Version 0.6.3	2018-11-16 01:17:57 -08:00
Cameron Gutman	f64c13b9ec	Ujpdate common-c with NAT64 fixes	2018-11-16 00:40:42 -08:00
Cameron Gutman	25f70e570e	Add timer-based input batching for GFE 3.16	2018-11-15 20:52:07 -08:00
Cameron Gutman	b27b64c25c	Initialize the SDL timer subsystem	2018-11-15 20:45:32 -08:00
Cameron Gutman	bfc64c926a	Reorganize settings page now that vertical scrolling works	2018-11-15 16:41:02 -08:00
Cameron Gutman	88ad983aa4	Update common-c for GFE 3.16	2018-11-15 13:11:01 -08:00
Cameron Gutman	a95d2e76f5	Fix settings page scrolling. Fixes #106	2018-11-13 18:03:53 -08:00
Cameron Gutman	037886ba5b	Add tooltips and update help text	2018-11-04 14:36:12 -08:00
Cameron Gutman	011edfe2a0	Disable any usage of proxy servers	2018-11-04 14:15:53 -08:00
Cameron Gutman	1a5a6773ce	Add option to determine if Moonlight launches in full-screen. Fixes #103	2018-11-04 13:57:33 -08:00
Cameron Gutman	dda22fd387	Rename mouse acceleration toggle to raw mouse input	2018-11-04 13:31:28 -08:00
Cameron Gutman	7254224347	Update SDL2.framework to 2.0.9	2018-11-03 14:18:17 -07:00
Cameron Gutman	789e52af57	Use SDL_GameControllerGetPlayerIndex() as a hint for picking player indexes	2018-11-03 13:04:34 -07:00
Cameron Gutman	b2fcd6c084	Update Windows SDL headers to 2.0.9	2018-11-03 13:01:35 -07:00
Cameron Gutman	76e5794203	Remove SetThreadExecutionState() call now that SDL_DisableScreenSaver() works on Windows	2018-11-03 12:44:14 -07:00
Cameron Gutman	a81332dd23	Update SDL2 for Windows to MSVC build of 5dc13016cf34b2c503a7599fabdd4f62d1811fdb	2018-11-03 12:25:38 -07:00
Cameron Gutman	e1fab22d98	Fix accidental removal of decoder deletion in previous commit	2018-10-31 18:49:37 -07:00
Cameron Gutman	cb5e58d465	Fix use-after-free caught by debug build of SDL2	2018-10-31 18:20:39 -07:00
Cameron Gutman	eaeb9ec6f7	Version 0.6.2	2018-10-28 19:57:38 -07:00
Cameron Gutman	88bb17fca8	Change Manufacturer string to "Moonlight Game Streaming Project"	2018-10-28 18:11:07 -07:00
Cameron Gutman	f672b8534f	Change quit tip based on whether gamepads are attached	2018-10-28 17:59:07 -07:00
Cameron Gutman	839c0a45a0	Avoid polling server status while streaming	2018-10-28 17:53:49 -07:00
Cameron Gutman	974e44ba4c	Update common-c for more unique STUN error codes	2018-10-28 17:20:34 -07:00
Cameron Gutman	9461ebec2d	Log an error if STUN fails	2018-10-26 20:54:17 -07:00
Cameron Gutman	48d8a53cd6	Resolve WAN address using STUN if the PC is discovered over mDNS	2018-10-26 20:44:51 -07:00
Cameron Gutman	2a8dfd63da	Update common-c to include STUN code	2018-10-26 20:22:38 -07:00
Cameron Gutman	49ac431792	Fix calling convention of LoadLibrary hooks which caused x86 builds to crash	2018-10-15 07:41:50 -07:00
Cameron Gutman	8a7c463c52	Version 0.6.1	2018-10-14 23:08:58 -07:00
Cameron Gutman	eab77fba7a	Fix inability to play audio on sound cards set to 192 KHz sample rate	2018-10-14 22:52:24 -07:00
Cameron Gutman	61d90a5a88	Also display a tooltip when the item is highlighted by gamepad/keyboard	2018-10-14 22:23:08 -07:00
Cameron Gutman	ef99f02bc7	Display the tooltip over the text itself and only if it's truncated	2018-10-14 21:39:37 -07:00
Cameron Gutman	9166a604d6	Rename NktHookLib.pdb back to its original name to avoid a link-time warning	2018-10-14 21:14:32 -07:00
Cameron Gutman	d5a1189053	Avoid VAAPI on AMD drivers due to a bad memory leak	2018-10-14 20:37:13 -07:00
Cameron Gutman	cb52a53922	Remove accidentally committed debugging code	2018-10-14 12:59:13 -07:00
Cameron Gutman	1aff2ff0c3	Fix CoreAudio failure to open device when it contains certain UTF-8 characters. Fixes #104	2018-10-14 11:33:13 -07:00
Cameron Gutman	fd63aad3b8	Only avoid HEVC on GFE 3.10 and lower on macOS	2018-10-14 11:28:52 -07:00
Cameron Gutman	9a807a0685	Prevent asserts from being compiled into moonlight-common-c and soundio in release builds	2018-10-14 11:26:29 -07:00
Cameron Gutman	40fc9fa26f	Fix Qt 5.9 incompatibility in AutoResizingComboBox. Fixes #107	2018-10-13 20:16:18 -07:00
Cameron Gutman	cf0d29d452	Add AntiHooking helper DLL to prevent NahimicOSD.dll from loading into Moonlight and causing us to hang in full-screen mode. Fixes #102	2018-10-13 19:35:21 -07:00
Cameron Gutman	e411c207ae	Implement quitting Moonlight via gamepad or keyboard. Fixes #100	2018-10-13 00:41:22 -07:00
Cameron Gutman	5df2704ccc	Compile h264bitstream as GNU99 on GCC	2018-10-12 21:45:41 -07:00
Cameron Gutman	36f468a599	Fix window icon disappearing when toggling out of full-screen mode on Windows	2018-10-12 20:34:58 -07:00
Cameron Gutman	dfae69834a	Fix misleading debug print	2018-10-12 20:02:54 -07:00
Cameron Gutman	e53b32fa57	Stop polling machines after 5 minutes of inactivity to conserve power	2018-10-12 19:58:29 -07:00
Cameron Gutman	969afac696	Add tool tips to app grid	2018-10-12 19:41:20 -07:00
Cameron Gutman	50d4f267ba	Fix font setting in TextMetrics. Fixes #99	2018-10-12 19:19:33 -07:00
Cameron Gutman	33b9caaca9	Compile libsoundio as GNU99 on GCC	2018-10-12 18:02:12 -07:00
Cameron Gutman	4f84843b00	Fixup H.264 SPS for VideoToolbox compatibility. Fixes #98	2018-10-12 17:59:53 -07:00
Cameron Gutman	44f415f94d	Sign all deployed binaries in one signtool invocation	2018-10-11 18:45:29 -07:00