Fix appstream metadata release date for v0.8.1

Version 0.8.1
Update macOS builds to FFmpeg 4.1
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 · 2019-01-07 20:34:56 -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
@@ -0,0 +1,251 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+/**
+ *  \file SDL_sensor.h
+ *
+ *  Include file for SDL sensor event handling
+ *
+ */
+
+#ifndef _SDL_sensor_h
+#define _SDL_sensor_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  \brief SDL_sensor.h
+ *
+ *  In order to use these functions, SDL_Init() must have been called
+ *  with the ::SDL_INIT_SENSOR flag.  This causes SDL to scan the system
+ *  for sensors, and load appropriate drivers.
+ */
+
+struct _SDL_Sensor;
+typedef struct _SDL_Sensor SDL_Sensor;
+
+/**
+ * This is a unique ID for a sensor for the time it is connected to the system,
+ * and is never reused for the lifetime of the application.
+ *
+ * The ID value starts at 0 and increments from there. The value -1 is an invalid ID.
+ */
+typedef Sint32 SDL_SensorID;
+
+/* The different sensors defined by SDL
+ *
+ * Additional sensors may be available, using platform dependent semantics.
+ *
+ * Hare are the additional Android sensors:
+ * https://developer.android.com/reference/android/hardware/SensorEvent.html#values
+ */
+typedef enum
+{
+    SDL_SENSOR_INVALID = -1,    /**< Returned for an invalid sensor */
+    SDL_SENSOR_UNKNOWN,         /**< Unknown sensor type */
+    SDL_SENSOR_ACCEL,           /**< Accelerometer */
+    SDL_SENSOR_GYRO             /**< Gyroscope */
+} SDL_SensorType;
+
+/**
+ * Accelerometer sensor
+ *
+ * The accelerometer returns the current acceleration in SI meters per
+ * second squared. This includes gravity, so a device at rest will have
+ * an acceleration of SDL_STANDARD_GRAVITY straight down.
+ *
+ * values[0]: Acceleration on the x axis
+ * values[1]: Acceleration on the y axis
+ * values[2]: Acceleration on the z axis
+ *
+ * For phones held in portrait mode, the axes are defined as follows:
+ * -X ... +X : left ... right
+ * -Y ... +Y : bottom ... top
+ * -Z ... +Z : farther ... closer
+ * 
+ * The axis data is not changed when the phone is rotated.
+ *
+ * \sa SDL_GetDisplayOrientation()
+ */
+#define SDL_STANDARD_GRAVITY    9.80665f
+
+/**
+ * Gyroscope sensor
+ *
+ * The gyroscope returns the current rate of rotation in radians per second.
+ * The rotation is positive in the counter-clockwise direction. That is,
+ * an observer looking from a positive location on one of the axes would
+ * see positive rotation on that axis when it appeared to be rotating
+ * counter-clockwise.
+ *
+ * values[0]: Angular speed around the x axis
+ * values[1]: Angular speed around the y axis
+ * values[2]: Angular speed around the z axis
+ *
+ * For phones held in portrait mode, the axes are defined as follows:
+ * -X ... +X : left ... right
+ * -Y ... +Y : bottom ... top
+ * -Z ... +Z : farther ... closer
+ * 
+ * The axis data is not changed when the phone is rotated.
+ *
+ * \sa SDL_GetDisplayOrientation()
+ */
+
+/* Function prototypes */
+
+/**
+ *  \brief Count the number of sensors attached to the system right now
+ */
+extern DECLSPEC int SDLCALL SDL_NumSensors(void);
+
+/**
+ *  \brief Get the implementation dependent name of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ * 
+ *  \return The sensor name, or NULL if device_index is out of range.
+ */
+extern DECLSPEC const char *SDLCALL SDL_SensorGetDeviceName(int device_index);
+
+/**
+ *  \brief Get the type of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ *
+ *  \return The sensor type, or SDL_SENSOR_INVALID if device_index is out of range.
+ */
+extern DECLSPEC SDL_SensorType SDLCALL SDL_SensorGetDeviceType(int device_index);
+
+/**
+ *  \brief Get the platform dependent type of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ *
+ *  \return The sensor platform dependent type, or -1 if device_index is out of range.
+ */
+extern DECLSPEC int SDLCALL SDL_SensorGetDeviceNonPortableType(int device_index);
+
+/**
+ *  \brief Get the instance ID of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ *
+ *  \return The sensor instance ID, or -1 if device_index is out of range.
+ */
+extern DECLSPEC SDL_SensorID SDLCALL SDL_SensorGetDeviceInstanceID(int device_index);
+
+/**
+ *  \brief Open a sensor for use.
+ *
+ *  The index passed as an argument refers to the N'th sensor on the system.
+ *
+ *  \return A sensor identifier, or NULL if an error occurred.
+ */
+extern DECLSPEC SDL_Sensor *SDLCALL SDL_SensorOpen(int device_index);
+
+/**
+ * Return the SDL_Sensor associated with an instance id.
+ */
+extern DECLSPEC SDL_Sensor *SDLCALL SDL_SensorFromInstanceID(SDL_SensorID instance_id);
+
+/**
+ *  \brief Get the implementation dependent name of a sensor.
+ *
+ *  \return The sensor name, or NULL if the sensor is NULL.
+ */
+extern DECLSPEC const char *SDLCALL SDL_SensorGetName(SDL_Sensor *sensor);
+
+/**
+ *  \brief Get the type of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ *
+ *  \return The sensor type, or SDL_SENSOR_INVALID if the sensor is NULL.
+ */
+extern DECLSPEC SDL_SensorType SDLCALL SDL_SensorGetType(SDL_Sensor *sensor);
+
+/**
+ *  \brief Get the platform dependent type of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ *
+ *  \return The sensor platform dependent type, or -1 if the sensor is NULL.
+ */
+extern DECLSPEC int SDLCALL SDL_SensorGetNonPortableType(SDL_Sensor *sensor);
+
+/**
+ *  \brief Get the instance ID of a sensor.
+ *
+ *  This can be called before any sensors are opened.
+ *
+ *  \return The sensor instance ID, or -1 if the sensor is NULL.
+ */
+extern DECLSPEC SDL_SensorID SDLCALL SDL_SensorGetInstanceID(SDL_Sensor *sensor);
+
+/**
+ *  Get the current state of an opened sensor.
+ *
+ *  The number of values and interpretation of the data is sensor dependent.
+ *
+ *  \param sensor The sensor to query
+ *  \param data A pointer filled with the current sensor state
+ *  \param num_values The number of values to write to data
+ *
+ *  \return 0 or -1 if an error occurred.
+ */
+extern DECLSPEC int SDLCALL SDL_SensorGetData(SDL_Sensor * sensor, float *data, int num_values);
+
+/**
+ *  Close a sensor previously opened with SDL_SensorOpen()
+ */
+extern DECLSPEC void SDLCALL SDL_SensorClose(SDL_Sensor * sensor);
+
+/**
+ *  Update the current state of the open sensors.
+ *
+ *  This is called automatically by the event loop if sensor events are enabled.
+ *
+ *  This needs to be called from the thread that initialized the sensor subsystem.
+ */
+extern DECLSPEC void SDLCALL SDL_SensorUpdate(void);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_sensor_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
@@ -86,6 +86,28 @@
 #ifdef HAVE_FLOAT_H
 # include <float.h>
 #endif
+#if defined(HAVE_ALLOCA) && !defined(alloca)
+# if defined(HAVE_ALLOCA_H)
+#  include <alloca.h>
+# elif defined(__GNUC__)
+#  define alloca __builtin_alloca
+# elif defined(_MSC_VER)
+#  include <malloc.h>
+#  define alloca _alloca
+# elif defined(__WATCOMC__)
+#  include <malloc.h>
+# elif defined(__BORLANDC__)
+#  include <malloc.h>
+# elif defined(__DMC__)
+#  include <stdlib.h>
+# elif defined(__AIX__)
+#pragma alloca
+# elif defined(__MRC__)
+void *alloca(unsigned);
+# else
+char *alloca();
+# endif
+#endif

 /**
 *  The number of elements in an array.
@@ -328,28 +350,6 @@ SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
 extern "C" {
 #endif

-#if defined(HAVE_ALLOCA) && !defined(alloca)
-# if defined(HAVE_ALLOCA_H)
-#  include <alloca.h>
-# elif defined(__GNUC__)
-#  define alloca __builtin_alloca
-# elif defined(_MSC_VER)
-#  include <malloc.h>
-#  define alloca _alloca
-# elif defined(__WATCOMC__)
-#  include <malloc.h>
-# elif defined(__BORLANDC__)
-#  include <malloc.h>
-# elif defined(__DMC__)
-#  include <stdlib.h>
-# elif defined(__AIX__)
-#pragma alloca
-# elif defined(__MRC__)
-void *alloca(unsigned);
-# else
-char *alloca();
-# endif
-#endif
 #ifdef HAVE_ALLOCA
 #define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*(count))
 #define SDL_stack_free(data)
@@ -445,12 +445,12 @@ SDL_FORCE_INLINE void SDL_memset4(void *dst, Uint32 val, size_t dwords)
 #endif
 }

-
 extern DECLSPEC void *SDLCALL SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len);

 extern DECLSPEC void *SDLCALL SDL_memmove(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len);
 extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len);

+extern DECLSPEC wchar_t *SDLCALL SDL_wcsdup(const wchar_t *wstr);
 extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *wstr);
 extern DECLSPEC size_t SDLCALL SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen);
 extern DECLSPEC size_t SDLCALL SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen);
@@ -514,6 +514,8 @@ extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
 extern DECLSPEC float SDLCALL SDL_copysignf(float x, float y);
 extern DECLSPEC double SDLCALL SDL_cos(double x);
 extern DECLSPEC float SDLCALL SDL_cosf(float x);
+extern DECLSPEC double SDLCALL SDL_exp(double x);
+extern DECLSPEC float SDLCALL SDL_expf(float x);
 extern DECLSPEC double SDLCALL SDL_fabs(double x);
 extern DECLSPEC float SDLCALL SDL_fabsf(float x);
 extern DECLSPEC double SDLCALL SDL_floor(double x);
@@ -248,6 +248,13 @@ extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
 extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
                                            int flag, Uint32 key);

+/**
+ *  \brief Returns whether the surface has a color key
+ *
+ *  \return SDL_TRUE if the surface has a color key, or SDL_FALSE if the surface is NULL or has no color key
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface);
+
 /**
 *  \brief Gets the color key (transparent pixel) in a blittable surface.
 *
@@ -76,6 +76,18 @@ extern DECLSPEC SDL_bool SDLCALL SDL_DXGIGetOutputInfo( int displayIndex, int *a
 #endif /* __WIN32__ */


+/* Platform specific functions for Linux */
+#ifdef __LINUX__
+
+/**
+   \brief Sets the UNIX nice value for a thread, using setpriority() if possible, and RealtimeKit if available.
+
+   \return 0 on success, or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriority(Sint64 threadID, int priority);
+ 
+#endif /* __LINUX__ */
+	
 /* Platform specific functions for iOS */
 #if defined(__IPHONEOS__) && __IPHONEOS__

@@ -113,6 +125,21 @@ extern DECLSPEC void * SDLCALL SDL_AndroidGetActivity(void);
 */
 extern DECLSPEC SDL_bool SDLCALL SDL_IsAndroidTV(void);

+/**
+   \brief Return true if the application is running on a Chromebook
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_IsChromebook(void);
+
+/**
+  \brief Return true is the application is running on a Samsung DeX docking station
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_IsDeXMode(void);
+
+/**
+ \brief Trigger the Android system back button behavior.
+ */
+extern DECLSPEC void SDLCALL SDL_AndroidBackButton(void);
+
 /**
   See the official Android developer guide for more information:
   http://developer.android.com/guide/topics/data/data-storage.html
@@ -236,6 +263,11 @@ extern DECLSPEC SDL_WinRT_DeviceFamily SDLCALL SDL_WinRTGetDeviceFamily();

 #endif /* __WINRT__ */

+/**
+ \brief Return true if the current device is a tablet.
+ */
+extern DECLSPEC SDL_bool SDLCALL SDL_IsTablet(void);
+
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
@@ -33,12 +33,6 @@
 #include "SDL_video.h"
 #include "SDL_version.h"

-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /**
 *  \file SDL_syswm.h
 *
@@ -110,6 +104,12 @@ typedef void *EGLSurface;
 #include "SDL_egl.h"
 #endif

+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
 *  These are the various supported windowing subsystems
 */
@@ -54,12 +54,13 @@ typedef unsigned int SDL_TLSID;
 /**
 *  The SDL thread priority.
 *
- *  \note On many systems you require special privileges to set high priority.
+ *  \note On many systems you require special privileges to set high or time critical priority.
 */
 typedef enum {
    SDL_THREAD_PRIORITY_LOW,
    SDL_THREAD_PRIORITY_NORMAL,
-    SDL_THREAD_PRIORITY_HIGH
+    SDL_THREAD_PRIORITY_HIGH,
+    SDL_THREAD_PRIORITY_TIME_CRITICAL
 } SDL_ThreadPriority;

 /**
@@ -105,14 +106,24 @@ SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
                 pfnSDL_CurrentBeginThread pfnBeginThread,
                 pfnSDL_CurrentEndThread pfnEndThread);

+extern DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThreadWithStackSize(int (SDLCALL * fn) (void *),
+                 const char *name, const size_t stacksize, void *data,
+                 pfnSDL_CurrentBeginThread pfnBeginThread,
+                 pfnSDL_CurrentEndThread pfnEndThread);
+
+
 /**
 *  Create a thread.
 */
 #if defined(SDL_CreateThread) && SDL_DYNAMIC_API
 #undef SDL_CreateThread
 #define SDL_CreateThread(fn, name, data) SDL_CreateThread_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex)
+#undef SDL_CreateThreadWithStackSize
+#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize_REAL(fn, name, stacksize, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex)
 #else
 #define SDL_CreateThread(fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex)
+#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)_endthreadex)
 #endif

 #elif defined(__OS2__)
@@ -132,15 +143,31 @@ extern DECLSPEC SDL_Thread *SDLCALL
 SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
                 pfnSDL_CurrentBeginThread pfnBeginThread,
                 pfnSDL_CurrentEndThread pfnEndThread);
+extern DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const size_t stacksize, void *data,
+                 pfnSDL_CurrentBeginThread pfnBeginThread,
+                 pfnSDL_CurrentEndThread pfnEndThread);
 #if defined(SDL_CreateThread) && SDL_DYNAMIC_API
 #undef SDL_CreateThread
 #define SDL_CreateThread(fn, name, data) SDL_CreateThread_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthread, (pfnSDL_CurrentEndThread)_endthread)
+#undef SDL_CreateThreadWithStackSize
+#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthread, (pfnSDL_CurrentEndThread)_endthread)
 #else
 #define SDL_CreateThread(fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthread, (pfnSDL_CurrentEndThread)_endthread)
+#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize(fn, name, stacksize, data, (pfnSDL_CurrentBeginThread)_beginthread, (pfnSDL_CurrentEndThread)_endthread)
 #endif

 #else

+/**
+ *  Create a thread with a default stack size.
+ *
+ *  This is equivalent to calling:
+ *  SDL_CreateThreadWithStackSize(fn, name, 0, data);
+ */
+extern DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data);
+
 /**
 *  Create a thread.
 *
@@ -158,9 +185,17 @@ SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
 *   If a system imposes requirements, SDL will try to munge the string for
 *    it (truncate, etc), but the original string contents will be available
 *    from SDL_GetThreadName().
+ *
+ *   The size (in bytes) of the new stack can be specified. Zero means "use
+ *    the system default" which might be wildly different between platforms
+ *    (x86 Linux generally defaults to eight megabytes, an embedded device
+ *    might be a few kilobytes instead).
+ *
+ *   In SDL 2.1, stacksize will be folded into the original SDL_CreateThread
+ *    function.
 */
 extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data);
+SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const size_t stacksize, void *data);

 #endif

@@ -59,7 +59,7 @@ typedef struct SDL_version
 */
 #define SDL_MAJOR_VERSION   2
 #define SDL_MINOR_VERSION   0
-#define SDL_PATCHLEVEL      8
+#define SDL_PATCHLEVEL      9

 /**
 *  \brief Macro to determine SDL version program was compiled against.
@@ -169,6 +169,24 @@ typedef enum
    SDL_WINDOWEVENT_HIT_TEST        /**< Window had a hit test that wasn't SDL_HITTEST_NORMAL. */
 } SDL_WindowEventID;

+/**
+ *  \brief Event subtype for display events
+ */
+typedef enum
+{
+    SDL_DISPLAYEVENT_NONE,          /**< Never used */
+    SDL_DISPLAYEVENT_ORIENTATION    /**< Display orientation has changed to data1 */
+} SDL_DisplayEventID;
+
+typedef enum
+{
+    SDL_ORIENTATION_UNKNOWN,            /**< The display orientation can't be determined */
+    SDL_ORIENTATION_LANDSCAPE,          /**< The display is in landscape mode, with the right side up, relative to portrait mode */
+    SDL_ORIENTATION_LANDSCAPE_FLIPPED,  /**< The display is in landscape mode, with the left side up, relative to portrait mode */
+    SDL_ORIENTATION_PORTRAIT,           /**< The display is in portrait mode */
+    SDL_ORIENTATION_PORTRAIT_FLIPPED    /**< The display is in portrait mode, upside down */
+} SDL_DisplayOrientation;
+
 /**
 *  \brief An opaque handle to an OpenGL context.
 */
@@ -316,18 +334,6 @@ extern DECLSPEC const char * SDLCALL SDL_GetDisplayName(int displayIndex);
 */
 extern DECLSPEC int SDLCALL SDL_GetDisplayBounds(int displayIndex, SDL_Rect * rect);

-/**
- *  \brief Get the dots/pixels-per-inch for a display
- *
- *  \note Diagonal, horizontal and vertical DPI can all be optionally
- *        returned if the parameter is non-NULL.
- *
- *  \return 0 on success, or -1 if no DPI information is available or the index is out of range.
- *
- *  \sa SDL_GetNumVideoDisplays()
- */
-extern DECLSPEC int SDLCALL SDL_GetDisplayDPI(int displayIndex, float * ddpi, float * hdpi, float * vdpi);
-
 /**
 *  \brief Get the usable desktop area represented by a display, with the
 *         primary display located at 0,0
@@ -347,6 +353,27 @@ extern DECLSPEC int SDLCALL SDL_GetDisplayDPI(int displayIndex, float * ddpi, fl
 */
 extern DECLSPEC int SDLCALL SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect * rect);

+/**
+ *  \brief Get the dots/pixels-per-inch for a display
+ *
+ *  \note Diagonal, horizontal and vertical DPI can all be optionally
+ *        returned if the parameter is non-NULL.
+ *
+ *  \return 0 on success, or -1 if no DPI information is available or the index is out of range.
+ *
+ *  \sa SDL_GetNumVideoDisplays()
+ */
+extern DECLSPEC int SDLCALL SDL_GetDisplayDPI(int displayIndex, float * ddpi, float * hdpi, float * vdpi);
+
+/**
+ *  \brief Get the orientation of a display
+ *
+ *  \return The orientation of the display, or SDL_ORIENTATION_UNKNOWN if it isn't available.
+ *
+ *  \sa SDL_GetNumVideoDisplays()
+ */
+extern DECLSPEC SDL_DisplayOrientation SDLCALL SDL_GetDisplayOrientation(int displayIndex);
+
 /**
 *  \brief Returns the number of available display modes.
 *
@@ -135,11 +135,11 @@ extern DECLSPEC void SDLCALL SDL_Vulkan_UnloadLibrary(void);
 *  \brief Get the names of the Vulkan instance extensions needed to create
 *         a surface with \c SDL_Vulkan_CreateSurface().
 *
- *  \param [in]     window Window for which the required Vulkan instance
+ *  \param [in]     \c NULL or window Window for which the required Vulkan instance
 *                  extensions should be retrieved
- *  \param [in,out] count pointer to an \c unsigned related to the number of
+ *  \param [in,out] pCount pointer to an \c unsigned related to the number of
 *                  required Vulkan instance extensions
- *  \param [out]    names \c NULL or a pointer to an array to be filled with the
+ *  \param [out]    pNames \c NULL or a pointer to an array to be filled with the
 *                  required Vulkan instance extensions
 *
 *  \return \c SDL_TRUE on success, \c SDL_FALSE on error.
@@ -153,6 +153,10 @@ extern DECLSPEC void SDLCALL SDL_Vulkan_UnloadLibrary(void);
 *  is smaller than the number of required extensions, \c SDL_FALSE will be
 *  returned instead of \c SDL_TRUE, to indicate that not all the required
 *  extensions were returned.
+ * 
+ *  \note If \c window is not NULL, it will be checked against its creation
+ *        flags to ensure that the Vulkan flag is present. This parameter
+ *        will be removed in a future major release.
 *
 *  \note The returned list of extensions will contain \c VK_KHR_surface
 *        and zero or more platform specific extensions
@@ -160,12 +164,13 @@ extern DECLSPEC void SDLCALL SDL_Vulkan_UnloadLibrary(void);
 *  \note The extension names queried here must be enabled when calling
 *        VkCreateInstance, otherwise surface creation will fail.
 *
- *  \note \c window should have been created with the \c SDL_WINDOW_VULKAN flag.
+ *  \note \c window should have been created with the \c SDL_WINDOW_VULKAN flag
+ *        or be \c NULL
 *
 *  \code
 *  unsigned int count;
 *  // get count of required extensions
- *  if(!SDL_Vulkan_GetInstanceExtensions(window, &count, NULL))
+ *  if(!SDL_Vulkan_GetInstanceExtensions(NULL, &count, NULL))
 *      handle_error();
 *
 *  static const char *const additionalExtensions[] =
@@ -179,7 +184,7 @@ extern DECLSPEC void SDLCALL SDL_Vulkan_UnloadLibrary(void);
 *      handle_error();
 *
 *  // get names of required extensions
- *  if(!SDL_Vulkan_GetInstanceExtensions(window, &count, names))
+ *  if(!SDL_Vulkan_GetInstanceExtensions(NULL, &count, names))
 *      handle_error();
 *
 *  // copy additional extensions after required extensions
@@ -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, \
@@ -56,6 +56,7 @@ SOURCES += \
    $$COMMON_C_DIR/src/RtspConnection.c \
    $$COMMON_C_DIR/src/RtspParser.c \
    $$COMMON_C_DIR/src/SdpGenerator.c \
+    $$COMMON_C_DIR/src/SimpleStun.c \
    $$COMMON_C_DIR/src/VideoDepacketizer.c \
    $$COMMON_C_DIR/src/VideoStream.c
 HEADERS += \
@@ -67,7 +68,7 @@ INCLUDEPATH += \
 CONFIG += warn_off staticlib
 DEFINES += HAS_SOCKLEN_T

-debug {
+CONFIG(debug, debug|release) {
    # Enable asserts on debug builds
    DEFINES += LC_DEBUG
 }
@@ -3,10 +3,15 @@ SUBDIRS = \
    moonlight-common-c \
    qmdnsengine \
    app \
-    soundio
+    soundio \
+    h264bitstream

 # Build the dependencies in parallel before the final app
-app.depends = qmdnsengine moonlight-common-c soundio
+app.depends = qmdnsengine moonlight-common-c soundio h264bitstream
+win32 {
+    SUBDIRS += AntiHooking
+    app.depends += AntiHooking
+}

 # Support debug and release builds from command line for CI
 CONFIG += debug_and_release
@@ -1,3 +1,7 @@
-./configure --extra-cflags="-mmacosx-version-min=10.10" --enable-pic --enable-shared --disable-static --disable-all --enable-avcodec --enable-decoder=h264 --enable-decoder=hevc --enable-hwaccel=h264_videotoolbox --enable-hwaccel=hevc_videotoolbox
+./configure --extra-cflags="-mmacosx-version-min=10.11" --install-name-dir=@loader_path/../lib --enable-pic --enable-shared --disable-static --disable-all --enable-avcodec --enable-decoder=h264 --enable-decoder=hevc --enable-hwaccel=h264_videotoolbox --enable-hwaccel=hevc_videotoolbox
 make clean
-make -j4
+make -j4
+codesign -s 45U78722YL libavcodec/libavcodec.dylib
+codesign -s 45U78722YL libavutil/libavutil.dylib
+codesign -vv libavcodec/libavcodec.dylib
+codesign -vv libavutil/libavutil.dylib
@@ -11,10 +11,13 @@ if [ "$BUILD_CONFIG" != "Debug" ] && [ "$BUILD_CONFIG" != "Release" ]; then
  fail "Invalid build configuration"
 fi

+[ "$SIGNING_KEY" == "" ] || git diff-index --quiet HEAD -- || fail "Signed release builds must not have unstaged changes!"
+
 BUILD_ROOT=$PWD/build
 SOURCE_ROOT=$PWD
 BUILD_FOLDER=$BUILD_ROOT/build-$BUILD_CONFIG
 INSTALLER_FOLDER=$BUILD_ROOT/installer-$BUILD_CONFIG
+VERSION=`cat $SOURCE_ROOT/app/version.txt`

 echo Cleaning output directories
 rm -rf $BUILD_FOLDER
@@ -35,18 +38,14 @@ popd

 echo Saving dSYM file
 pushd $BUILD_FOLDER
-dsymutil app/Moonlight.app/Contents/MacOS/Moonlight -o Moonlight.dsym || fail "dSYM creation failed!"
-cp -R Moonlight.dsym $INSTALLER_FOLDER || fail "dSYM copy failed!"
+dsymutil app/Moonlight.app/Contents/MacOS/Moonlight -o Moonlight-$VERSION.dsym || fail "dSYM creation failed!"
+cp -R Moonlight-$VERSION.dsym $INSTALLER_FOLDER || fail "dSYM copy failed!"
 popd

 echo Copying dylib dependencies
 mkdir $BUILD_FOLDER/app/Moonlight.app/Contents/lib
 cp $SOURCE_ROOT/libs/mac/lib/*.dylib $BUILD_FOLDER/app/Moonlight.app/Contents/lib/ || fail "Dylib copy failed!"

-echo Copying frameworks dependencies
-mkdir $BUILD_FOLDER/app/Moonlight.app/Contents/Frameworks
-cp -R $SOURCE_ROOT/libs/mac/Frameworks/ $BUILD_FOLDER/app/Moonlight.app/Contents/Frameworks/ || fail "Framework copy failed!"
-
 echo Creating app bundle
 EXTRA_ARGS=
 if [ "$BUILD_CONFIG" == "Debug" ]; then EXTRA_ARGS="$EXTRA_ARGS -use-debug-libs"; fi
@@ -56,3 +55,4 @@ macdeployqt $BUILD_FOLDER/app/Moonlight.app $EXTRA_ARGS -qmldir=$SOURCE_ROOT/app

 echo Creating DMG
 create-dmg $BUILD_FOLDER/app/Moonlight.app $INSTALLER_FOLDER || fail "create-dmg failed!"
+mv $INSTALLER_FOLDER/Moonlight\ $VERSION.dmg $INSTALLER_FOLDER/Moonlight-$VERSION.dmg
@@ -17,6 +17,13 @@ if /I "%BUILD_CONFIG%"=="debug" (
            set BUILD_CONFIG=release
            set SIGN=1
            set MUST_DEPLOY_SYMBOLS=1
+
+            rem Fail if there are unstaged changes
+            git diff-index --quiet HEAD --
+            if !ERRORLEVEL! NEQ 0 (
+                echo Signed release builds must not have unstaged changes!
+                exit /b 1
+            )
        ) else (
            echo Invalid build configuration
            exit /b 1
@@ -43,6 +50,7 @@ set BUILD_FOLDER=%BUILD_ROOT%\build-%ARCH%-%BUILD_CONFIG%
 set DEPLOY_FOLDER=%BUILD_ROOT%\deploy-%ARCH%-%BUILD_CONFIG%
 set INSTALLER_FOLDER=%BUILD_ROOT%\installer-%ARCH%-%BUILD_CONFIG%
 set SYMBOLS_FOLDER=%BUILD_ROOT%\symbols-%ARCH%-%BUILD_CONFIG%
+set /p VERSION=<%SOURCE_ROOT%\app\version.txt

 echo Cleaning output directories
 rmdir /s /q %DEPLOY_FOLDER%
@@ -74,7 +82,7 @@ for /r "%BUILD_FOLDER%" %%f in (*.pdb) do (
 )
 copy %SOURCE_ROOT%\libs\windows\lib\%ARCH%\*.pdb %SYMBOLS_FOLDER%
 if !ERRORLEVEL! NEQ 0 goto Error
-7z a %SYMBOLS_FOLDER%\MoonlightDebuggingSymbols.zip %SYMBOLS_FOLDER%\*.pdb
+7z a %SYMBOLS_FOLDER%\MoonlightDebuggingSymbols-%ARCH%-%VERSION%.zip %SYMBOLS_FOLDER%\*.pdb
 if !ERRORLEVEL! NEQ 0 goto Error

 if "%ML_SYMBOL_STORE%" NEQ "" (
@@ -88,10 +96,25 @@ if "%ML_SYMBOL_STORE%" NEQ "" (
    )
 )

+if "%ML_SYMBOL_ARCHIVE%" NEQ "" (
+    echo Copying PDB ZIP to symbol archive: %ML_SYMBOL_ARCHIVE%
+    copy %SYMBOLS_FOLDER%\MoonlightDebuggingSymbols-%ARCH%-%VERSION%.zip %ML_SYMBOL_ARCHIVE%
+    if !ERRORLEVEL! NEQ 0 goto Error
+) else (
+    if "%MUST_DEPLOY_SYMBOLS%"=="1" (
+        echo "A symbol archive directory must be specified in ML_SYMBOL_ARCHIVE for signed release builds"
+        exit /b 1
+    )
+)
+
 echo Copying DLL dependencies
 copy %SOURCE_ROOT%\libs\windows\lib\%ARCH%\*.dll %DEPLOY_FOLDER%
 if !ERRORLEVEL! NEQ 0 goto Error

+echo Copying AntiHooking.dll
+copy %BUILD_FOLDER%\AntiHooking\%BUILD_CONFIG%\AntiHooking.dll %DEPLOY_FOLDER%
+if !ERRORLEVEL! NEQ 0 goto Error
+
 echo Copying GC mapping list
 copy %SOURCE_ROOT%\app\SDL_GameControllerDB\gamecontrollerdb.txt %DEPLOY_FOLDER%
 if !ERRORLEVEL! NEQ 0 goto Error
@@ -110,10 +133,12 @@ if !ERRORLEVEL! NEQ 0 goto Error

 if "%SIGN%"=="1" (
    echo Signing deployed binaries
+    set FILES_TO_SIGN=
    for /r "%DEPLOY_FOLDER%" %%f in (*.dll *.exe) do (
-        signtool %SIGNTOOL_PARAMS% %%f
-        if !ERRORLEVEL! NEQ 0 goto Error
+        set FILES_TO_SIGN=!FILES_TO_SIGN! %%f
    )
+    signtool %SIGNTOOL_PARAMS% !FILES_TO_SIGN!
+    if !ERRORLEVEL! NEQ 0 goto Error
 )

 echo Building MSI
@@ -144,6 +169,9 @@ if "%SIGN%"=="1" (
    if !ERRORLEVEL! NEQ 0 goto Error
 )

+rem Rename the installer to match the publishing convention
+ren %INSTALLER_FOLDER%\MoonlightSetup.exe MoonlightSetup-%ARCH%-%VERSION%.exe
+
 echo Building portable package
 rem This must be done after WiX harvesting and signing, since the VCRT dlls are MS signed
 rem and should not be harvested for inclusion in the full installer
@@ -151,19 +179,19 @@ copy "%VCToolsRedistDir%%ARCH%\Microsoft.VC141.CRT\*.dll" %DEPLOY_FOLDER%
 rem This file tells Moonlight that it's a portable installation
 echo. > %DEPLOY_FOLDER%\portable.dat
 if !ERRORLEVEL! NEQ 0 goto Error
-7z a %INSTALLER_FOLDER%\MoonlightPortable.zip %DEPLOY_FOLDER%\*
+7z a %INSTALLER_FOLDER%\MoonlightPortable-%ARCH%-%VERSION%.zip %DEPLOY_FOLDER%\*
 if !ERRORLEVEL! NEQ 0 goto Error

 if /i "%APPVEYOR%"=="true" (
    echo Pushing artifacts
-    appveyor PushArtifact %INSTALLER_FOLDER%\MoonlightSetup.exe -FileName MoonlightSetup-%ARCH%-%BUILD_CONFIG%.exe
+    appveyor PushArtifact %INSTALLER_FOLDER%\MoonlightSetup-%ARCH%-%VERSION%.exe -FileName MoonlightSetup-%ARCH%-%BUILD_CONFIG%.exe
    if !ERRORLEVEL! NEQ 0 goto Error
-    appveyor PushArtifact %INSTALLER_FOLDER%\MoonlightPortable.zip -FileName MoonlightPortable-%ARCH%-%BUILD_CONFIG%.zip
+    appveyor PushArtifact %INSTALLER_FOLDER%\MoonlightPortable-%ARCH%-%VERSION%.zip -FileName MoonlightPortable-%ARCH%-%BUILD_CONFIG%.zip
    if !ERRORLEVEL! NEQ 0 goto Error
-    appveyor PushArtifact %SYMBOLS_FOLDER%\MoonlightDebuggingSymbols.zip -FileName MoonlightDebuggingSymbols-%ARCH%-%BUILD_CONFIG%.zip
+    appveyor PushArtifact %SYMBOLS_FOLDER%\MoonlightDebuggingSymbols-%ARCH%-%VERSION%.zip -FileName MoonlightDebuggingSymbols-%ARCH%-%BUILD_CONFIG%.zip
 )

-echo Build successful!
+echo Build successful for Moonlight v%VERSION%!
 exit /b 0

 :Error
@@ -23,6 +23,11 @@ CONFIG += staticlib
    QMAKE_CFLAGS += /TP
 }

+# Older GCC versions defaulted to GNU89
+*-g++ {
+    QMAKE_CFLAGS += -std=gnu99
+}
+
 # Disable warnings
 CONFIG += warn_off

@@ -39,6 +44,11 @@ unix:!macx {
    }
 }

+CONFIG(release, debug|release) {
+    # Disable asserts on release builds
+    DEFINES += NDEBUG
+}
+
 DEFINES += \
    SOUNDIO_STATIC_LIBRARY               \
    SOUNDIO_VERSION_MAJOR=1              \
@@ -15,7 +15,7 @@
           Name="$(var.FullName)"
           Language="1033"
           Version="!(bind.fileVersion.MoonlightExe)"
-           Manufacturer="Moonlight Game Streaming Team"
+           Manufacturer="Moonlight Game Streaming Project"
           UpgradeCode="5c09f94e-f809-4c6a-9b7b-597c99f041fe">

    <Package InstallerVersion="500" Compressed="yes" InstallScope="perMachine" />
@@ -6,7 +6,7 @@

  <Bundle Name="Moonlight Game Streaming Client"
          Version="!(bind.PackageVersion.Moonlight)"
-          Manufacturer="Moonlight Game Streaming Team"
+          Manufacturer="Moonlight Game Streaming Project"
          UpgradeCode="466fa35d-4be4-40ef-9ce5-afadc3b63bc5"
          HelpUrl="https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide"
          UpdateUrl="https://github.com/moonlight-stream/moonlight-qt/releases"
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