Experimental AVFoundation renderer

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,40 +0,0 @@
----
-name: Bug report
-about: Create a report to help us address broken functionality
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Steps to reproduce**
-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?
-- Does the problem still occur after reverting settings back to default?
-
-**Client PC details (please complete the following information)**
- - OS: [e.g. Windows 10 1809]
- - Moonlight Version: [e.g. v0.9.0]
-
-**Server PC details (please complete the following information)**
- - OS: [e.g. Windows 10 1809]
- - 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 with the Flatpak, logs print to the terminal when running with the command: `flatpak run com.moonlight_stream.Moonlight`
-- On Linux with the Snap, logs print to the terminal when running with the command: `moonlight`
-
-**Additional context**
-Anything else you think may be relevant to the issue

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,17 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/no-response.yml

@@ -1,8 +0,0 @@
-# ProBot No Response (https://probot.github.io/apps/no-response/)
-
-daysUntilClose: 7
-responseRequiredLabel: 'need more info'
-closeComment: >
-  This issue has been automatically closed because there was no response to a
-  request for more information from the issue opener. Please leave a comment or
-  open a new issue if you have additional information related to this issue.

.github/stale.yml

@@ -1,14 +0,0 @@
-# ProBot Stale (https://probot.github.io/apps/stale/)
-
-daysUntilStale: 90
-daysUntilClose: 7
-exemptLabels:
-  - accepted
-  - bug
-  - enhancement
-  - meta
-staleLabel: stale
-markComment: >
-  This issue has been automatically marked as stale because it has not had
-  recent activity. It will be closed if no further activity occurs.
-closeComment: false

.gitignore

@@ -1,7 +1 @@
 *pro.user
-
-
-**/.vs/
-build/
-config.tests/*/.qmake.stash
-config.tests/*/Makefile

.gitmodules

@@ -1,15 +1,9 @@
 [submodule "moonlight-common-c/moonlight-common-c"]
 	path = moonlight-common-c/moonlight-common-c
 	url = https://github.com/moonlight-stream/moonlight-common-c.git
+[submodule "opus/opus"]
+	path = opus/opus
+	url = https://github.com/xiph/opus.git
 [submodule "qmdnsengine/qmdnsengine"]
 	path = qmdnsengine/qmdnsengine
 	url = https://github.com/cgutman/qmdnsengine.git
-[submodule "app/SDL_GameControllerDB"]
-	path = app/SDL_GameControllerDB
-	url = https://github.com/gabomdq/SDL_GameControllerDB.git
-[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

.travis.yml

@@ -1,53 +0,0 @@
-language: cpp
-
-git:
-  depth: 1
-
-env:
-  - NJOBS=2
-
-matrix:
-  include:
-    - os: osx
-      compiler: clang
-    - os: linux
-      sudo: required
-      dist: xenial
-      compiler: gcc
-      addons:
-        apt:
-          sources:
-            - sourceline: 'ppa:beineri/opt-qt597-xenial'
-            - sourceline: 'ppa:jonathonf/ffmpeg-4'
-          packages:
-            - qt59base
-            - qt59quickcontrols2
-            - qt59svg
-            - libesd0-dev
-            - libgl-dev
-            - libegl1-mesa-dev
-            - libxkbcommon-dev
-            - wayland-protocols
-            - libopus-dev
-            - libavcodec-dev
-            - libavutil-dev
-            - libva-dev
-            - libvdpau-dev
-
-install:
-    - '[ "$TRAVIS_OS_NAME" != osx ] || brew install qt5'
-    - '[ "$TRAVIS_OS_NAME" != osx ] || brew link --force qt5'
-    - if [[ "$TRAVIS_OS_NAME" = "linux" ]]; then export SDL2_VER=2.0.9 && wget https://www.libsdl.org/release/SDL2-$SDL2_VER.tar.gz && tar -xvf SDL2-$SDL2_VER.tar.gz && cd SDL2-$SDL2_VER && ./configure && make -j$NJOBS && sudo make install && cd ..; fi
-    - if [[ "$TRAVIS_OS_NAME" = "linux" ]]; then export SDL2_TTF_VER=2.0.15 && wget https://www.libsdl.org/projects/SDL_ttf/release/SDL2_ttf-$SDL2_TTF_VER.tar.gz && tar -xvf SDL2_ttf-$SDL2_TTF_VER.tar.gz && cd SDL2_ttf-$SDL2_TTF_VER && ./configure && make -j$NJOBS && sudo make install && cd ..; fi
-
-before_script:
-    - '[ "$TRAVIS_OS_NAME" != "linux" ] || source /opt/qt59/bin/qt59-env.sh'
-    - qmake -v
-    - '[[ "$TRAVIS_OS_NAME" != linux || "$CXX" != clang++ ]] || export QMAKESPEC=linux-clang'
-    - '[[ "$TRAVIS_OS_NAME" != linux || "$CXX" != g++     ]] || export QMAKESPEC=linux-g++'
-    - '[ "$TRAVIS_OS_NAME" != osx ]                          || export QMAKESPEC=macx-clang'
-
-script:
-    - qmake moonlight-qt.pro -spec $QMAKESPEC
-    - make -j$NJOBS debug
-    - make -j$NJOBS release

AntiHooking/AntiHooking.pro

@@ -1,19 +0,0 @@
-QT       -= core gui
-
-TARGET = AntiHooking
-TEMPLATE = lib
-
-include(../globaldefs.pri)
-
-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

AntiHooking/antihookingprotection.cpp

@@ -1,165 +0,0 @@
-#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",
-        // This DLL has been seen in several crash reports. Some Googling
-        // suggests it's highly unstable and causes issues in many games.
-        L"EZFRD32.dll",
-        L"EZFRD64.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;
-};

AntiHooking/antihookingprotection.h

@@ -1,10 +0,0 @@
-#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();
-

README.md

@@ -1,70 +1,22 @@
 # Moonlight 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 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.
 
 Moonlight also has mobile versions for [Android](https://github.com/moonlight-stream/moonlight-android) and  [iOS](https://github.com/moonlight-stream/moonlight-ios).
 
-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)
- [![Mac and Linux Travis CI Status](https://travis-ci.org/moonlight-stream/moonlight-qt.svg?branch=master)](https://travis-ci.org/moonlight-stream/moonlight-qt)
-
-## Features
- - Hardware accelerated video decoding on Windows, Mac, and Linux
- - Supports streaming at up to 120 FPS (high refresh rate monitor recommended)
- - Supports streaming at 720p, 1080p, 1440p, 4K, and the client PC's native screen resolution
- - 5.1 surround sound audio
- - HEVC support for better image quality at reduced bandwidth
- - Keyboard and mouse support
- - Gamepad support with force feedback for up to 4 players
- 
-## Downloads
-- [Windows, macOS, and Steam Link](https://github.com/moonlight-stream/moonlight-qt/releases)
-- [Snap (for Ubuntu-based Linux distros)](https://snapcraft.io/moonlight)
-- [Flatpak (for other Linux distros)](https://flathub.org/apps/details/com.moonlight_stream.Moonlight)
+This is a work-in-progress port and is only suitable for development use at this point.
 
 ## Building
-### General Build Requirements
-* Qt 5.9 SDK or later
-
-### Windows-specific Build Requirements
-* Windows 7 or later
-* [Visual Studio](https://visualstudio.microsoft.com/downloads/) 2017 (Community edition is fine)
-* Select MSVC Desktop toolchain during Qt installation
-* [DirectX SDK](https://www.microsoft.com/en-us/download/details.aspx?id=6812)
-* [7-Zip](https://www.7-zip.org/) (only if building installers for non-development PCs)
-* [WiX Toolset](http://wixtoolset.org/releases/) v3.11 or later (only if building installers for non-development PCs)
-
-### Mac-specific Build Requirements
-* 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 Build 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 pulseaudio-libs-devel alsa-lib-devel SDL2_ttf-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/
-
-### Steam Link-specific Build Requirements
-* [Steam Link SDK](https://github.com/ValveSoftware/steamlink-sdk) cloned on your build system
-* STEAMLINK_SDK_PATH environment variable set to the Steam Link SDK path
-
-### Build Setup Steps
 1. Install the latest Qt SDK (and optionally, the Qt Creator IDE) from https://www.qt.io/download
-    * 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.
-    * This step is not required for building on Steam Link, because the Steam Link SDK includes Qt 5.9.
-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`.
-        * For Steam Link builds, run `scripts/build-steamlink-app.sh` from the root of the repository.
-    * To build from the command line for development use, run `qmake moonlight-qt.pro` then `make debug` or `make release`
+3. Run `git submodule update --init --recursive` from within `moonlight-qt/`
+4. Open the project in Qt Creator or build from qmake on the command line
 
 ## Contribute
+
+This project is being actively developed at [XDA Developers](http://forum.xda-developers.com/showthread.php?t=2505510)
+
 1. Fork us
 2. Write code
 3. Send Pull Requests
 
-Check out our [website](https://moonlight-stream.org) for project links and information.
+Check out our [website](http://moonlight-stream.com) for project links and information.

app/Info.plist

@@ -3,30 +3,24 @@
 <plist version="1.0">
 <dict>
 	<key>CFBundleExecutable</key>
-	<string>Moonlight</string>
+	<string>moonlight-qt</string>
 	<key>CFBundleGetInfoString</key>
-	<string>Stream games from your NVIDIA GameStream-enabled PC</string>
+	<string>Created by Qt/QMake</string>
 	<key>CFBundleIconFile</key>
-	<string>moonlight</string>
+	<string>macos</string>
 	<key>CFBundleIdentifier</key>
-	<string>com.moonlight-stream.Moonlight</string>
-	<key>NSHighResolutionCapable</key>
-	<true/>
+	<string>com.yourcompany.moonlight-qt</string>
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>LSMinimumSystemVersion</key>
-	<string>10.11</string>
+	<string>10.10</string>
+	<key>NOTE</key>
+	<string>This file was generated by Qt/QMake.</string>
 	<key>NSPrincipalClass</key>
 	<string>NSApplication</string>
 	<key>NSSupportsAutomaticGraphicsSwitching</key>
 	<true/>
-	<key>CFBundleVersion</key>
-	<string>VERSION</string>
-	<key>CFBundleShortVersionString</key>
-	<string>VERSION</string>
-	<key>CFBundleDisplayName</key>
-	<string>Moonlight</string>
 </dict>
 </plist>

app/Moonlight.exe.manifest

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" manifestVersion="1.0">
-    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
-        <security>
-            <requestedPrivileges>
-                <requestedExecutionLevel level="asInvoker" uiAccess="false" />
-            </requestedPrivileges>
-        </security>
-    </trustInfo>
-    <description>Moonlight Game Streaming</description>
-    <asmv3:application>
-        <asmv3:windowsSettings>
-            <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
-            <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitor</dpiAwareness>
-        </asmv3:windowsSettings>
-    </asmv3:application>
-    <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-        <application>
-            <!-- Windows 10 -->
-            <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
-            <!-- Windows 8.1 -->
-            <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
-            <!-- Windows 8 -->
-            <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
-            <!-- Windows 7 -->
-            <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
-            <!-- Windows Vista -->
-            <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
-        </application> 
-    </compatibility>
-</assembly>

app/app.pro

@@ -1,24 +1,7 @@
-QT += core quick network quickcontrols2 svg
+QT += core quick network quickcontrols2
 CONFIG += c++11
 
-unix:!macx {
-    TARGET = moonlight
-} else {
-    # On macOS, this is the name displayed in the global menu bar
-    TARGET = Moonlight
-}
-
-include(../globaldefs.pri)
-
-# Precompile QML files to avoid writing qmlcache on portable versions.
-# 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(release, debug|release) {
-        CONFIG += qtquickcompiler
-    }
-}
-
+TARGET = moonlight-qt
 TEMPLATE = app
 
 # The following define makes your compiler emit warnings if you use
@@ -33,247 +16,78 @@ DEFINES += QT_DEPRECATED_WARNINGS
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
 win32 {
-    INCLUDEPATH += \
-        $$PWD/../libs/windows/include \
-        $$(DXSDK_DIR)/Include
+    INCLUDEPATH += $$PWD/../libs/windows/include
 
     contains(QT_ARCH, i386) {
         LIBS += -L$$PWD/../libs/windows/lib/x86
-        LIBS += -L$$(DXSDK_DIR)/Lib/x86
     }
     contains(QT_ARCH, x86_64) {
         LIBS += -L$$PWD/../libs/windows/lib/x64
-        LIBS += -L$$(DXSDK_DIR)/Lib/x64
     }
 
-    LIBS += ws2_32.lib winmm.lib dxva2.lib ole32.lib gdi32.lib user32.lib d3d9.lib dwmapi.lib dbghelp.lib
+    LIBS += ws2_32.lib winmm.lib dxva2.lib ole32.lib
 }
 macx {
     INCLUDEPATH += $$PWD/../libs/mac/include
-    INCLUDEPATH += $$PWD/../libs/mac/Frameworks/SDL2.framework/Versions/A/Headers
-    INCLUDEPATH += $$PWD/../libs/mac/Frameworks/SDL2_ttf.framework/Versions/A/Headers
-    LIBS += -L$$PWD/../libs/mac/lib -F$$PWD/../libs/mac/Frameworks
+    LIBS += -L$$PWD/../libs/mac/lib
 }
 
 unix:!macx {
     CONFIG += link_pkgconfig
-    PKGCONFIG += openssl sdl2 SDL2_ttf opus
-
-    # SLAudio is used on Steam Link
-    !config_SL {
-        CONFIG += soundio
-    }
-
-    soundio {
-        packagesExist(libpulse) {
-            PKGCONFIG += libpulse
-        }
-        packagesExist(alsa) {
-            PKGCONFIG += alsa
-        }
-    }
-
-    packagesExist(libavcodec) {
-        PKGCONFIG += libavcodec libavutil
-        CONFIG += ffmpeg
-
-        packagesExist(libva) {
-            packagesExist(libva-x11) {
-                CONFIG += libva-x11
-            }
-            packagesExist(libva-wayland) {
-                CONFIG += libva-wayland
-            }
-            CONFIG += libva
-        }
-
-        packagesExist(vdpau) {
-            CONFIG += libvdpau
-        }
-
-        packagesExist(mmal) {
-            PKGCONFIG += mmal
-            CONFIG += mmal
-        }
-
-        packagesExist(libdrm) {
-            PKGCONFIG += libdrm
-            CONFIG += libdrm
-        }
-    }
+    PKGCONFIG += openssl sdl2 libavcodec libavdevice libavformat libavutil
 }
 win32 {
-    LIBS += -llibssl -llibcrypto -lSDL2 -lSDL2_ttf -lavcodec -lavutil -lopus -ld3dx9
-    CONFIG += ffmpeg
-}
-win32:!winrt {
-    CONFIG += soundio
+    LIBS += -llibssl -llibcrypto -lSDL2 -lavcodec -lavdevice -lavformat -lavutil
 }
 macx {
-    LIBS += -lssl -lcrypto -lavcodec.58 -lavutil.56 -lopus -framework SDL2 -framework SDL2_ttf
-    LIBS += -lobjc -framework VideoToolbox -framework AVFoundation -framework CoreVideo -framework CoreGraphics -framework CoreMedia -framework AppKit
-
-    # For libsoundio
-    LIBS += -framework CoreAudio -framework AudioUnit
-
-    CONFIG += ffmpeg soundio
+    LIBS += -lssl -lcrypto -lSDL2 -lavcodec.58 -lavdevice.58 -lavformat.58 -lavutil.56
+    LIBS += -lobjc -framework VideoToolbox -framework AVFoundation -framework CoreVideo -framework CoreMedia -framework AppKit
 }
 
 SOURCES += \
     main.cpp \
-    backend/computerseeker.cpp \
     backend/identitymanager.cpp \
-    backend/nvcomputer.cpp \
     backend/nvhttp.cpp \
     backend/nvpairingmanager.cpp \
     backend/computermanager.cpp \
     backend/boxartmanager.cpp \
-    cli/commandlineparser.cpp \
-    cli/quitstream.cpp \
-    cli/startstream.cpp \
     settings/streamingpreferences.cpp \
     streaming/input.cpp \
     streaming/session.cpp \
-    streaming/audio/audio.cpp \
-    streaming/audio/renderers/sdlaud.cpp \
+    streaming/audio.cpp \
+    streaming/video/ffmpeg.cpp \
     gui/computermodel.cpp \
     gui/appmodel.cpp \
-    streaming/streamutils.cpp \
-    backend/autoupdatechecker.cpp \
-    path.cpp \
-    settings/mappingmanager.cpp \
-    gui/sdlgamepadkeynavigation.cpp \
-    streaming/video/overlaymanager.cpp \
-    backend/systemproperties.cpp
+    streaming/video/ffmpeg-renderers/sdl.cpp
+
+win32 {
+    SOURCES += streaming/video/ffmpeg-renderers/dxva2.cpp
+}
+macx {
+    SOURCES += streaming/video/avfoundation.mm
+}
 
 HEADERS += \
     utils.h \
-    backend/computerseeker.h \
     backend/identitymanager.h \
-    backend/nvcomputer.h \
     backend/nvhttp.h \
     backend/nvpairingmanager.h \
     backend/computermanager.h \
     backend/boxartmanager.h \
-    cli/commandlineparser.h \
-    cli/quitstream.h \
-    cli/startstream.h \
     settings/streamingpreferences.h \
-    streaming/input.h \
-    streaming/session.h \
-    streaming/audio/renderers/renderer.h \
-    streaming/audio/renderers/sdl.h \
+    streaming/input.hpp \
+    streaming/session.hpp \
     gui/computermodel.h \
     gui/appmodel.h \
     streaming/video/decoder.h \
-    streaming/streamutils.h \
-    backend/autoupdatechecker.h \
-    path.h \
-    settings/mappingmanager.h \
-    gui/sdlgamepadkeynavigation.h \
-    streaming/video/overlaymanager.h \
-    backend/systemproperties.h
+    streaming/video/ffmpeg.h \
+    streaming/video/ffmpeg-renderers/renderer.h
 
-# Platform-specific renderers and decoders
-ffmpeg {
-    message(FFmpeg decoder selected)
-
-    DEFINES += HAVE_FFMPEG
-    SOURCES += \
-        streaming/video/ffmpeg.cpp \
-        streaming/video/ffmpeg-renderers/sdlvid.cpp \
-        streaming/video/ffmpeg-renderers/pacer/pacer.cpp \
-        streaming/video/ffmpeg-renderers/pacer/nullthreadedvsyncsource.cpp
-
-    HEADERS += \
-        streaming/video/ffmpeg.h \
-        streaming/video/ffmpeg-renderers/renderer.h \
-        streaming/video/ffmpeg-renderers/sdlvid.h \
-        streaming/video/ffmpeg-renderers/pacer/pacer.h \
-        streaming/video/ffmpeg-renderers/pacer/nullthreadedvsyncsource.h
-}
-libva {
-    message(VAAPI renderer selected)
-
-    PKGCONFIG += libva
-    DEFINES += HAVE_LIBVA
-    SOURCES += streaming/video/ffmpeg-renderers/vaapi.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/vaapi.h
-}
-libva-x11 {
-    message(VAAPI X11 support enabled)
-
-    PKGCONFIG += libva-x11
-    DEFINES += HAVE_LIBVA_X11
-}
-libva-wayland {
-    message(VAAPI Wayland support enabled)
-
-    PKGCONFIG += libva-wayland
-    DEFINES += HAVE_LIBVA_WAYLAND
-}
-libvdpau {
-    message(VDPAU renderer selected)
-
-    DEFINES += HAVE_LIBVDPAU
-    SOURCES += streaming/video/ffmpeg-renderers/vdpau.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/vdpau.h
-}
-mmal {
-    message(MMAL renderer selected)
-
-    DEFINES += HAVE_MMAL
-    SOURCES += streaming/video/ffmpeg-renderers/mmal.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/mmal.h
-}
-libdrm {
-    message(DRM renderer selected)
-
-    DEFINES += HAVE_DRM
-    SOURCES += streaming/video/ffmpeg-renderers/drm.cpp
-    HEADERS += streaming/video/ffmpeg-renderers/drm.h
-}
-config_SL {
-    message(Steam Link build configuration selected)
-
-    DEFINES += STEAM_LINK HAVE_SLVIDEO HAVE_SLAUDIO
-    LIBS += -lSLVideo -lSLAudio
-
-    SOURCES += \
-        streaming/video/slvid.cpp \
-        streaming/audio/renderers/slaud.cpp
-    HEADERS += \
-        streaming/video/slvid.h \
-        streaming/audio/renderers/slaud.h
-}
-win32:!winrt {
-    message(DXVA2 renderer selected)
-
-    SOURCES += \
-        streaming/video/ffmpeg-renderers/dxva2.cpp \
-        streaming/video/ffmpeg-renderers/pacer/dxvsyncsource.cpp
-
-    HEADERS += \
-        streaming/video/ffmpeg-renderers/dxva2.h \
-        streaming/video/ffmpeg-renderers/pacer/dxvsyncsource.h
+win32 {
+    HEADERS += streaming/video/ffmpeg-renderers/dxva2.h
 }
 macx {
-    message(VideoToolbox renderer selected)
-
-    SOURCES += \
-        streaming/video/ffmpeg-renderers/vt.mm \
-        streaming/video/ffmpeg-renderers/pacer/displaylinkvsyncsource.mm
-
-    HEADERS += \
-        streaming/video/ffmpeg-renderers/vt.h \
-        streaming/video/ffmpeg-renderers/pacer/displaylinkvsyncsource.h
-}
-soundio {
-    message(libsoundio audio renderer selected)
-
-    DEFINES += HAVE_SOUNDIO SOUNDIO_STATIC_LIBRARY
-    SOURCES += streaming/audio/renderers/soundioaudiorenderer.cpp
-    HEADERS += streaming/audio/renderers/soundioaudiorenderer.h
+    HEADERS += streaming/video/avfoundation.h
 }
 
 RESOURCES += \
@@ -293,6 +107,13 @@ else:unix: LIBS += -L$$OUT_PWD/../moonlight-common-c/ -lmoonlight-common-c
 INCLUDEPATH += $$PWD/../moonlight-common-c/moonlight-common-c/src
 DEPENDPATH += $$PWD/../moonlight-common-c/moonlight-common-c/src
 
+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../opus/release/ -lopus
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../opus/debug/ -lopus
+else:unix: LIBS += -L$$OUT_PWD/../opus/ -lopus
+
+INCLUDEPATH += $$PWD/../opus/opus/include
+DEPENDPATH += $$PWD/../opus/opus/include
+
 win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../qmdnsengine/release/ -lqmdnsengine
 else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../qmdnsengine/debug/ -lqmdnsengine
 else:unix: LIBS += -L$$OUT_PWD/../qmdnsengine/ -lqmdnsengine
@@ -300,80 +121,14 @@ else:unix: LIBS += -L$$OUT_PWD/../qmdnsengine/ -lqmdnsengine
 INCLUDEPATH += $$PWD/../qmdnsengine/qmdnsengine/src/include $$PWD/../qmdnsengine
 DEPENDPATH += $$PWD/../qmdnsengine/qmdnsengine/src/include $$PWD/../qmdnsengine
 
-soundio {
-    win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../soundio/release/ -lsoundio
-    else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../soundio/debug/ -lsoundio
-    else:unix: LIBS += -L$$OUT_PWD/../soundio/ -lsoundio
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
 
-    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
-
-!winrt {
-    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
-    }
-    isEmpty(BINDIR) {
-        BINDIR = bin
-    }
-    isEmpty(DATADIR) {
-        DATADIR = share
-    }
-
-    target.path = $$PREFIX/$$BINDIR/
-
-    desktop.files = deploy/linux/com.moonlight_stream.Moonlight.desktop
-    desktop.path = $$PREFIX/$$DATADIR/applications/
-
-    icons.files = res/moonlight.svg
-    icons.path = $$PREFIX/$$DATADIR/icons/hicolor/scalable/apps/
-
-    appstream.files = deploy/linux/com.moonlight_stream.Moonlight.appdata.xml
-    appstream.path = $$PREFIX/$$DATADIR/metainfo/
-
-    INSTALLS += target desktop icons appstream
-}
-win32 {
-    RC_ICONS = moonlight.ico
-    QMAKE_TARGET_COMPANY = Moonlight Game Streaming Project
-    QMAKE_TARGET_DESCRIPTION = Moonlight Game Streaming Client
-    QMAKE_TARGET_PRODUCT = Moonlight
-
-    CONFIG -= embed_manifest_exe
-    QMAKE_LFLAGS += /MANIFEST:embed /MANIFESTINPUT:$${PWD}/Moonlight.exe.manifest
-}
 macx {
-    # 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
-    APP_BUNDLE_RESOURCES.path = Contents/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
+    QMAKE_INFO_PLIST = $$PWD/Info.plist
+    APP_QML_FILES.files = res/macos.icns
+    APP_QML_FILES.path = Contents/Resources
+    QMAKE_BUNDLE_DATA += APP_QML_FILES
 }
-
-VERSION = "$$cat(version.txt)"
-DEFINES += VERSION_STR=\\\"$$cat(version.txt)\\\"

app/backend/autoupdatechecker.cpp

@@ -1,146 +0,0 @@
-#include "autoupdatechecker.h"
-
-#include <QNetworkReply>
-#include <QJsonDocument>
-#include <QJsonArray>
-#include <QJsonObject>
-
-AutoUpdateChecker::AutoUpdateChecker(QObject *parent) :
-    QObject(parent),
-    m_Nam(this)
-{
-    // 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*)));
-
-    QString currentVersion(VERSION_STR);
-    qDebug() << "Current Moonlight version:" << currentVersion;
-    parseStringToVersionQuad(currentVersion, m_CurrentVersionQuad);
-
-    // Should at least have a 1.0-style version number
-    Q_ASSERT(m_CurrentVersionQuad.count() > 1);
-}
-
-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.org/updates/qt.json");
-    m_Nam.get(QNetworkRequest(url));
-#endif
-}
-
-void AutoUpdateChecker::parseStringToVersionQuad(QString& string, QVector<int>& version)
-{
-    QStringList list = string.split('.');
-    for (const QString& component : list) {
-        version.append(component.toInt());
-    }
-}
-
-void AutoUpdateChecker::handleUpdateCheckRequestFinished(QNetworkReply* reply)
-{
-    Q_ASSERT(reply->isFinished());
-
-    if (reply->error() == QNetworkReply::NoError) {
-        QTextStream stream(reply);
-        stream.setCodec("UTF-8");
-
-        // Read all data and queue the reply for deletion
-        QString jsonString = stream.readAll();
-        reply->deleteLater();
-
-        QJsonParseError error;
-        QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonString.toUtf8(), &error);
-        if (jsonDoc.isNull()) {
-            qWarning() << "Update manifest malformed:" << error.errorString();
-            return;
-        }
-
-        QJsonArray array = jsonDoc.array();
-        if (array.isEmpty()) {
-            qWarning() << "Update manifest doesn't contain an array";
-            return;
-        }
-
-        for (QJsonValueRef updateEntry : array) {
-            if (updateEntry.isObject()) {
-                QJsonObject updateObj = updateEntry.toObject();
-                if (!updateObj.contains("platform") ||
-                        !updateObj.contains("arch") ||
-                        !updateObj.contains("version") ||
-                        !updateObj.contains("browser_url")) {
-                    qWarning() << "Update manifest entry missing vital field";
-                    continue;
-                }
-
-                if (!updateObj["platform"].isString() ||
-                        !updateObj["arch"].isString() ||
-                        !updateObj["version"].isString() ||
-                        !updateObj["browser_url"].isString()) {
-                    qWarning() << "Update manifest entry has unexpected vital field type";
-                    continue;
-                }
-
-                if (updateObj["arch"] == QSysInfo::buildCpuArchitecture() &&
-                        updateObj["platform"] == QSysInfo::productType()) {
-                    qDebug() << "Found update manifest match for current platform";
-
-                    QString latestVersion = updateObj["version"].toString();
-                    qDebug() << "Latest version of Moonlight for this platform is:" << latestVersion;
-
-                    QVector<int> latestVersionQuad;
-
-                    parseStringToVersionQuad(latestVersion, latestVersionQuad);
-
-                    for (int i = 0;; i++) {
-                        int latestVer = 0;
-                        int currentVer = 0;
-
-                        // Treat missing decimal places as 0
-                        if (i < latestVersionQuad.count()) {
-                            latestVer = latestVersionQuad[i];
-                        }
-                        if (i < m_CurrentVersionQuad.count()) {
-                            currentVer = m_CurrentVersionQuad[i];
-                        }
-                        if (i >= latestVersionQuad.count() && i >= m_CurrentVersionQuad.count()) {
-                            break;
-                        }
-
-                        if (currentVer < latestVer) {
-                            qDebug() << "Update available";
-
-                            emit onUpdateAvailable(updateObj["version"].toString(),
-                                                   updateObj["browser_url"].toString());
-                            return;
-                        }
-                        else if (currentVer > latestVer) {
-                            qDebug() << "Update manifest version lower than current version";
-                            return;
-                        }
-                    }
-
-                    qDebug() << "Update manifest version equal to current version";
-
-                    return;
-                }
-            }
-            else {
-                qWarning() << "Update manifest contained unrecognized entry:" << updateEntry.toString();
-            }
-        }
-
-        qWarning() << "No entry in update manifest found for current platform: "
-                   << QSysInfo::buildCpuArchitecture() << QSysInfo::productType();
-    }
-    else {
-        qWarning() << "Update checking failed with error: " << reply->error();
-        reply->deleteLater();
-    }
-}

app/backend/autoupdatechecker.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QNetworkAccessManager>
-
-class AutoUpdateChecker : public QObject
-{
-    Q_OBJECT
-public:
-    explicit AutoUpdateChecker(QObject *parent = nullptr);
-
-    Q_INVOKABLE void start();
-
-signals:
-    void onUpdateAvailable(QString newVersion, QString url);
-
-private slots:
-    void handleUpdateCheckRequestFinished(QNetworkReply* reply);
-
-private:
-    void parseStringToVersionQuad(QString& string, QVector<int>& version);
-
-    QVector<int> m_CurrentVersionQuad;
-    QNetworkAccessManager m_Nam;
-};

app/backend/boxartmanager.cpp

@@ -1,19 +1,14 @@
 #include "boxartmanager.h"
-#include "../path.h"
 
+#include <QStandardPaths>
 #include <QImageReader>
 #include <QImageWriter>
 
 BoxArtManager::BoxArtManager(QObject *parent) :
     QObject(parent),
-    m_BoxArtDir(Path::getBoxArtCacheDir()),
-    m_ThreadPool(this)
+    m_BoxArtDir(
+        QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/boxart")
 {
-    // 4 is a good balance between fast loading for large
-    // app grids and not crushing GFE with tons of requests
-    // and causing UI jank from constantly stalling to decode
-    // new images.
-    m_ThreadPool.setMaxThreadCount(4);
     if (!m_BoxArtDir.exists()) {
         m_BoxArtDir.mkpath(".");
     }
@@ -36,39 +31,6 @@ BoxArtManager::getFilePathForBoxArt(NvComputer* computer, int appId)
     return dir.filePath(QString::number(appId) + ".png");
 }
 
-class NetworkBoxArtLoadTask : public QObject, public QRunnable
-{
-    Q_OBJECT
-
-public:
-    NetworkBoxArtLoadTask(BoxArtManager* boxArtManager, NvComputer* computer, NvApp& app)
-        : m_Bam(boxArtManager),
-          m_Computer(computer),
-          m_App(app)
-    {
-        connect(this, SIGNAL(boxArtFetchCompleted(NvComputer*,NvApp,QUrl)),
-                boxArtManager, SLOT(handleBoxArtLoadComplete(NvComputer*,NvApp,QUrl)));
-    }
-
-signals:
-    void boxArtFetchCompleted(NvComputer* computer, NvApp app, QUrl image);
-
-private:
-    void run()
-    {
-        QUrl image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
-        if (image.isEmpty()) {
-            // Give it another shot if it fails once
-            image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
-        }
-        emit boxArtFetchCompleted(m_Computer, m_App, image);
-    }
-
-    BoxArtManager* m_Bam;
-    NvComputer* m_Computer;
-    NvApp m_App;
-};
-
 QUrl BoxArtManager::loadBoxArt(NvComputer* computer, NvApp& app)
 {
     // Try to open the cached file
@@ -80,7 +42,7 @@ QUrl BoxArtManager::loadBoxArt(NvComputer* computer, NvApp& app)
     // If we get here, we need to fetch asynchronously.
     // Kick off a worker on our thread pool to do just that.
     NetworkBoxArtLoadTask* netLoadTask = new NetworkBoxArtLoadTask(this, computer, app);
-    m_ThreadPool.start(netLoadTask);
+    QThreadPool::globalInstance()->start(netLoadTask);
 
     // Return the placeholder then we can notify the caller
     // later when the real image is ready.
@@ -89,14 +51,15 @@ QUrl BoxArtManager::loadBoxArt(NvComputer* computer, NvApp& app)
 
 void BoxArtManager::handleBoxArtLoadComplete(NvComputer* computer, NvApp app, QUrl image)
 {
-    if (!image.isEmpty()) {
-        emit boxArtLoadComplete(computer, app, image);
+    if (image.isEmpty()) {
+        image = QUrl("qrc:/res/no_app_image.png");
     }
+    emit boxArtLoadComplete(computer, app, image);
 }
 
 QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
 {
-    NvHTTP http(computer->activeAddress, computer->serverCert);
+    NvHTTP http(computer->activeAddress);
 
     QString cachePath = getFilePathForBoxArt(computer, appId);
     QImage image;
@@ -113,5 +76,3 @@ QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)
 
     return QUrl();
 }
-
-#include "boxartmanager.moc"

app/backend/boxartmanager.h

@@ -36,5 +36,37 @@ private:
     getFilePathForBoxArt(NvComputer* computer, int appId);
 
     QDir m_BoxArtDir;
-    QThreadPool m_ThreadPool;
+};
+
+class NetworkBoxArtLoadTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+
+public:
+    NetworkBoxArtLoadTask(BoxArtManager* boxArtManager, NvComputer* computer, NvApp& app)
+        : m_Bam(boxArtManager),
+          m_Computer(computer),
+          m_App(app)
+    {
+        connect(this, SIGNAL(boxArtFetchCompleted(NvComputer*,NvApp,QUrl)),
+                boxArtManager, SLOT(handleBoxArtLoadComplete(NvComputer*,NvApp,QUrl)));
+    }
+
+signals:
+    void boxArtFetchCompleted(NvComputer* computer, NvApp app, QUrl image);
+
+private:
+    void run()
+    {
+        QUrl image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
+        if (image.isEmpty()) {
+            // Give it another shot if it fails once
+            image = m_Bam->loadBoxArtFromNetwork(m_Computer, m_App.id);
+        }
+        emit boxArtFetchCompleted(m_Computer, m_App, image);
+    }
+
+    BoxArtManager* m_Bam;
+    NvComputer* m_Computer;
+    NvApp m_App;
 };

app/backend/computermanager.cpp

@@ -1,151 +1,273 @@
 #include "computermanager.h"
 #include "nvhttp.h"
-#include "settings/streamingpreferences.h"
-
-#include <Limelight.h>
-#include <QtEndian>
 
 #include <QThread>
+#include <QUdpSocket>
+#include <QHostInfo>
 #include <QThreadPool>
-#include <QCoreApplication>
 
 #define SER_HOSTS "hosts"
+#define SER_NAME "hostname"
+#define SER_UUID "uuid"
+#define SER_MAC "mac"
+#define SER_LOCALADDR "localaddress"
+#define SER_REMOTEADDR "remoteaddress"
+#define SER_MANUALADDR "manualaddress"
+#define SER_APPLIST "apps"
 
-class PcMonitorThread : public QThread
+#define SER_APPNAME "name"
+#define SER_APPID "id"
+#define SER_APPHDR "hdr"
+
+NvComputer::NvComputer(QSettings& settings)
 {
-    Q_OBJECT
+    this->name = settings.value(SER_NAME).toString();
+    this->uuid = settings.value(SER_UUID).toString();
+    this->macAddress = settings.value(SER_MAC).toByteArray();
+    this->localAddress = settings.value(SER_LOCALADDR).toString();
+    this->remoteAddress = settings.value(SER_REMOTEADDR).toString();
+    this->manualAddress = settings.value(SER_MANUALADDR).toString();
 
-#define TRIES_BEFORE_OFFLINING 2
-#define POLLS_PER_APPLIST_FETCH 10
+    int appCount = settings.beginReadArray(SER_APPLIST);
+    for (int i = 0; i < appCount; i++) {
+        NvApp app;
 
-public:
-    PcMonitorThread(NvComputer* computer)
-        : m_Computer(computer)
-    {
-        setObjectName("Polling thread for " + computer->name);
+        settings.setArrayIndex(i);
+
+        app.name = settings.value(SER_APPNAME).toString();
+        app.id = settings.value(SER_APPID).toInt();
+        app.hdrSupported = settings.value(SER_APPHDR).toBool();
+
+        this->appList.append(app);
+    }
+    settings.endArray();
+    sortAppList();
+
+    this->activeAddress = nullptr;
+    this->currentGameId = 0;
+    this->pairState = PS_UNKNOWN;
+    this->state = CS_UNKNOWN;
+    this->gfeVersion = nullptr;
+    this->appVersion = nullptr;
+    this->maxLumaPixelsHEVC = 0;
+    this->serverCodecModeSupport = 0;
+}
+
+void
+NvComputer::serialize(QSettings& settings)
+{
+    QReadLocker lock(&this->lock);
+
+    settings.setValue(SER_NAME, name);
+    settings.setValue(SER_UUID, uuid);
+    settings.setValue(SER_MAC, macAddress);
+    settings.setValue(SER_LOCALADDR, localAddress);
+    settings.setValue(SER_REMOTEADDR, remoteAddress);
+    settings.setValue(SER_MANUALADDR, manualAddress);
+
+    // Avoid deleting an existing applist if we couldn't get one
+    if (!appList.isEmpty()) {
+        settings.remove(SER_APPLIST);
+        settings.beginWriteArray(SER_APPLIST);
+        for (int i = 0; i < appList.count(); i++) {
+            settings.setArrayIndex(i);
+
+            settings.setValue(SER_APPNAME, appList[i].name);
+            settings.setValue(SER_APPID, appList[i].id);
+            settings.setValue(SER_APPHDR, appList[i].hdrSupported);
+        }
+        settings.endArray();
+    }
+}
+
+void NvComputer::sortAppList()
+{
+    std::stable_sort(appList.begin(), appList.end(), [](const NvApp& app1, const NvApp& app2) {
+       return app1.name.toLower() < app2.name.toLower();
+    });
+}
+
+NvComputer::NvComputer(QString address, QString serverInfo)
+{
+    this->name = NvHTTP::getXmlString(serverInfo, "hostname");
+    if (this->name.isNull()) {
+        this->name = "UNKNOWN";
     }
 
-private:
-    bool tryPollComputer(QString address, bool& changed)
-    {
-        NvHTTP http(address, m_Computer->serverCert);
-
-        QString serverInfo;
-        try {
-            serverInfo = http.getServerInfo(NvHTTP::NvLogLevel::NVLL_NONE);
-        } catch (...) {
-            return false;
+    this->uuid = NvHTTP::getXmlString(serverInfo, "uniqueid");
+    QString newMacString = NvHTTP::getXmlString(serverInfo, "mac");
+    if (newMacString != "00:00:00:00:00:00") {
+        QStringList macOctets = newMacString.split(':');
+        for (QString macOctet : macOctets) {
+            this->macAddress.append((char) macOctet.toInt(nullptr, 16));
         }
+    }
 
-        NvComputer newState(address, serverInfo, QSslCertificate());
+    QString codecSupport = NvHTTP::getXmlString(serverInfo, "ServerCodecModeSupport");
+    if (!codecSupport.isNull()) {
+        this->serverCodecModeSupport = codecSupport.toInt();
+    }
+    else {
+        this->serverCodecModeSupport = 0;
+    }
 
-        // Ensure the machine that responded is the one we intended to contact
-        if (m_Computer->uuid != newState.uuid) {
-            qInfo() << "Found unexpected PC " << newState.name << " looking for " << m_Computer->name;
-            return false;
-        }
+    QString maxLumaPixelsHEVC = NvHTTP::getXmlString(serverInfo, "MaxLumaPixelsHEVC");
+    if (!maxLumaPixelsHEVC.isNull()) {
+        this->maxLumaPixelsHEVC = maxLumaPixelsHEVC.toInt();
+    }
+    else {
+        this->maxLumaPixelsHEVC = 0;
+    }
 
-        changed = m_Computer->update(newState);
+    this->displayModes = NvHTTP::getDisplayModeList(serverInfo);
+    std::stable_sort(this->displayModes.begin(), this->displayModes.end(),
+                     [](const NvDisplayMode& mode1, const NvDisplayMode& mode2) {
+        return mode1.width * mode1.height * mode1.refreshRate <
+                mode2.width * mode2.height * mode2.refreshRate;
+    });
+
+    this->localAddress = NvHTTP::getXmlString(serverInfo, "LocalIP");
+    this->remoteAddress = NvHTTP::getXmlString(serverInfo, "ExternalIP");
+    this->pairState = NvHTTP::getXmlString(serverInfo, "PairStatus") == "1" ?
+                PS_PAIRED : PS_NOT_PAIRED;
+    this->currentGameId = NvHTTP::getCurrentGame(serverInfo);
+    this->appVersion = NvHTTP::getXmlString(serverInfo, "appversion");
+    this->gfeVersion = NvHTTP::getXmlString(serverInfo, "GfeVersion");
+    this->activeAddress = address;
+    this->state = NvComputer::CS_ONLINE;
+}
+
+bool NvComputer::wake()
+{
+    if (state == NvComputer::CS_ONLINE) {
+        qWarning() << name << " is already online";
         return true;
     }
 
-    bool updateAppList(bool& changed)
-    {
-        Q_ASSERT(m_Computer->activeAddress != nullptr);
-
-        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
-
-        QVector<NvApp> appList;
-
-        try {
-            appList = http.getAppList();
-            if (appList.isEmpty()) {
-                return false;
-            }
-        } catch (...) {
-            return false;
-        }
-
-        QWriteLocker lock(&m_Computer->lock);
-        if (m_Computer->appList != appList) {
-            m_Computer->appList = appList;
-            m_Computer->sortAppList();
-            changed = true;
-        }
-
-        return true;
+    if (macAddress.isNull()) {
+        qWarning() << name << " has no MAC address stored";
+        return false;
     }
 
-    void run() override
-    {
-        // Always fetch the applist the first time
-        int pollsSinceLastAppListFetch = POLLS_PER_APPLIST_FETCH;
-        while (!isInterruptionRequested()) {
-            bool stateChanged = false;
-            bool online = false;
-            bool wasOnline = m_Computer->state == NvComputer::CS_ONLINE;
-            for (int i = 0; i < TRIES_BEFORE_OFFLINING && !online; i++) {
-                for (auto& address : m_Computer->uniqueAddresses()) {
-                    if (isInterruptionRequested()) {
-                        return;
-                    }
+    const quint16 WOL_PORTS[] = {
+        7, 9, // Standard WOL ports
+        47998, 47999, 48000, // Ports opened by GFE
+    };
 
-                    if (tryPollComputer(address, stateChanged)) {
-                        if (!wasOnline) {
-                            qInfo() << m_Computer->name << "is now online at" << m_Computer->activeAddress;
-                        }
-                        online = true;
-                        break;
+    // Create the WoL payload
+    QByteArray wolPayload;
+    wolPayload.append(QByteArray::fromHex("FFFFFFFFFFFF"));
+    for (int i = 0; i < 16; i++) {
+        wolPayload.append(macAddress);
+    }
+    Q_ASSERT(wolPayload.count() == 102);
+
+    // Add the addresses that we know this host to be
+    // and broadcast addresses for this link just in
+    // case the host has timed out in ARP entries.
+    QVector<QString> addressList = uniqueAddresses();
+    addressList.append("255.255.255.255");
+
+    // Try all unique address strings or host names
+    bool success = false;
+    for (QString& addressString : addressList) {
+        QHostInfo hostInfo = QHostInfo::fromName(addressString);
+
+        // Try all IP addresses that this string resolves to
+        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)) {
+                        qDebug() << "Send WoL packet to " << name << " via " << address.toString() << ":" << port;
+                        success = true;
                     }
                 }
             }
-
-            // Check if we failed after all retry attempts
-            // Note: we don't need to acquire the read lock here,
-            // because we're on the writing thread.
-            if (!online && m_Computer->state != NvComputer::CS_OFFLINE) {
-                qInfo() << m_Computer->name << "is now offline";
-                m_Computer->state = NvComputer::CS_OFFLINE;
-                stateChanged = true;
-            }
-
-            // Grab the applist if it's empty or it's been long enough that we need to refresh
-            pollsSinceLastAppListFetch++;
-            if (m_Computer->state == NvComputer::CS_ONLINE &&
-                    m_Computer->pairState == NvComputer::PS_PAIRED &&
-                    (m_Computer->appList.isEmpty() || pollsSinceLastAppListFetch >= POLLS_PER_APPLIST_FETCH)) {
-                // Notify prior to the app list poll since it may take a while, and we don't
-                // want to delay onlining of a machine, especially if we already have a cached list.
-                if (stateChanged) {
-                    emit computerStateChanged(m_Computer);
-                    stateChanged = false;
-                }
-
-                if (updateAppList(stateChanged)) {
-                    pollsSinceLastAppListFetch = 0;
-                }
-            }
-
-            if (stateChanged) {
-                // Tell anyone listening that we've changed state
-                emit computerStateChanged(m_Computer);
-            }
-
-            // Wait a bit to poll again, but do it in 100 ms chunks
-            // so we can be interrupted reasonably quickly.
-            // FIXME: QWaitCondition would be better.
-            for (int i = 0; i < 30 && !isInterruptionRequested(); i++) {
-                QThread::msleep(100);
-            }
         }
     }
 
-signals:
-   void computerStateChanged(NvComputer* computer);
+    return success;
+}
 
-private:
-    NvComputer* m_Computer;
-};
+QVector<QString> NvComputer::uniqueAddresses()
+{
+    QVector<QString> uniqueAddressList;
+
+    // Start with addresses correctly ordered
+    uniqueAddressList.append(activeAddress);
+    uniqueAddressList.append(localAddress);
+    uniqueAddressList.append(remoteAddress);
+    uniqueAddressList.append(manualAddress);
+
+    // Prune duplicates (always giving precedence to the first)
+    for (int i = 0; i < uniqueAddressList.count(); i++) {
+        if (uniqueAddressList[i].isEmpty() || uniqueAddressList[i].isNull()) {
+            uniqueAddressList.remove(i);
+            i--;
+            continue;
+        }
+        for (int j = i + 1; j < uniqueAddressList.count(); j++) {
+            if (uniqueAddressList[i] == uniqueAddressList[j]) {
+                // Always remove the later occurrence
+                uniqueAddressList.remove(j);
+                j--;
+            }
+        }
+    }
+
+    // We must have at least 1 address
+    Q_ASSERT(!uniqueAddressList.isEmpty());
+
+    return uniqueAddressList;
+}
+
+bool NvComputer::update(NvComputer& that)
+{
+    bool changed = false;
+
+    // Lock us for write and them for read
+    QWriteLocker thisLock(&this->lock);
+    QReadLocker thatLock(&that.lock);
+
+    // UUID may not change or we're talking to a new PC
+    Q_ASSERT(this->uuid == that.uuid);
+
+#define ASSIGN_IF_CHANGED(field)       \
+    if (this->field != that.field) {   \
+        this->field = that.field;      \
+        changed = true;                \
+    }
+
+#define ASSIGN_IF_CHANGED_AND_NONEMPTY(field) \
+    if (!that.field.isEmpty() &&              \
+        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);
+    ASSIGN_IF_CHANGED_AND_NONEMPTY(remoteAddress);
+    ASSIGN_IF_CHANGED_AND_NONEMPTY(manualAddress);
+    ASSIGN_IF_CHANGED(pairState);
+    ASSIGN_IF_CHANGED(serverCodecModeSupport);
+    ASSIGN_IF_CHANGED(currentGameId);
+    ASSIGN_IF_CHANGED(activeAddress);
+    ASSIGN_IF_CHANGED(state);
+    ASSIGN_IF_CHANGED(gfeVersion);
+    ASSIGN_IF_CHANGED(appVersion);
+    ASSIGN_IF_CHANGED(maxLumaPixelsHEVC);
+    ASSIGN_IF_CHANGED_AND_NONEMPTY(appList);
+    ASSIGN_IF_CHANGED_AND_NONEMPTY(displayModes);
+    return changed;
+}
 
 ComputerManager::ComputerManager(QObject *parent)
     : QObject(parent),
@@ -162,44 +284,6 @@ ComputerManager::ComputerManager(QObject *parent)
         m_KnownHosts[computer->uuid] = computer;
     }
     settings.endArray();
-
-    // To quit in a timely manner, we must block additional requests
-    // after we receive the aboutToQuit() signal. This is neccessary
-    // because NvHTTP uses aboutToQuit() to abort requests in progres
-    // while quitting, however this is a one time signal - additional
-    // requests would not be aborted and block termination.
-    connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(handleAboutToQuit()));
-}
-
-ComputerManager::~ComputerManager()
-{
-    QWriteLocker lock(&m_Lock);
-
-    // Delete machines that haven't been resolved yet
-    while (!m_PendingResolution.isEmpty()) {
-        MdnsPendingComputer* computer = m_PendingResolution.first();
-        delete computer;
-        m_PendingResolution.removeFirst();
-    }
-
-    // Delete the browser to stop discovery
-    delete m_MdnsBrowser;
-    m_MdnsBrowser = nullptr;
-
-    // Interrupt polling
-    for (ComputerPollingEntry* entry : m_PollEntries) {
-        entry->interrupt();
-    }
-
-    // Delete all polling entries (and associated threads)
-    for (ComputerPollingEntry* entry : m_PollEntries) {
-        delete entry;
-    }
-
-    // Destroy all NvComputer objects now that polling is halted
-    for (NvComputer* computer : m_KnownHosts) {
-        delete computer;
-    }
 }
 
 void ComputerManager::saveHosts()
@@ -211,7 +295,7 @@ void ComputerManager::saveHosts()
     settings.beginWriteArray(SER_HOSTS);
     for (int i = 0; i < m_KnownHosts.count(); i++) {
         settings.setArrayIndex(i);
-        m_KnownHosts.value(m_KnownHosts.keys()[i])->serialize(settings);
+        m_KnownHosts[m_KnownHosts.keys()[i]]->serialize(settings);
     }
     settings.endArray();
 }
@@ -224,24 +308,17 @@ void ComputerManager::startPolling()
         return;
     }
 
-    StreamingPreferences prefs;
+    // Start an MDNS query for GameStream hosts
+    m_MdnsBrowser = new QMdnsEngine::Browser(&m_MdnsServer, "_nvstream._tcp.local.", &m_MdnsCache);
+    connect(m_MdnsBrowser, &QMdnsEngine::Browser::serviceAdded,
+            this, [this](const QMdnsEngine::Service& service) {
+        qDebug() << "Discovered mDNS host: " << service.hostname();
 
-    if (prefs.enableMdns) {
-        // Start an MDNS query for GameStream hosts
-        m_MdnsBrowser = new QMdnsEngine::Browser(&m_MdnsServer, "_nvstream._tcp.local.", &m_MdnsCache);
-        connect(m_MdnsBrowser, &QMdnsEngine::Browser::serviceAdded,
-                this, [this](const QMdnsEngine::Service& service) {
-            qInfo() << "Discovered mDNS host:" << service.hostname();
-
-            MdnsPendingComputer* pendingComputer = new MdnsPendingComputer(&m_MdnsServer, &m_MdnsCache, service);
-            connect(pendingComputer, SIGNAL(resolvedv4(MdnsPendingComputer*,QHostAddress)),
-                    this, SLOT(handleMdnsServiceResolved(MdnsPendingComputer*,QHostAddress)));
-            m_PendingResolution.append(pendingComputer);
-        });
-    }
-    else {
-        qWarning() << "mDNS is disabled by user preference";
-    }
+        MdnsPendingComputer* pendingComputer = new MdnsPendingComputer(&m_MdnsServer, &m_MdnsCache, service);
+        connect(pendingComputer, SIGNAL(resolvedv4(MdnsPendingComputer*,QHostAddress)),
+                this, SLOT(handleMdnsServiceResolved(MdnsPendingComputer*,QHostAddress)));
+        m_PendingResolution.append(pendingComputer);
+    });
 
     // Start polling threads for each known host
     QMapIterator<QString, NvComputer*> i(m_KnownHosts);
@@ -251,35 +328,10 @@ void ComputerManager::startPolling()
     }
 }
 
-// Must hold m_Lock for write
-void ComputerManager::startPollingComputer(NvComputer* computer)
-{
-    if (m_PollingRef == 0) {
-        return;
-    }
-
-    ComputerPollingEntry* pollingEntry;
-
-    if (!m_PollEntries.contains(computer->uuid)) {
-        pollingEntry = m_PollEntries[computer->uuid] = new ComputerPollingEntry();
-    }
-    else {
-        pollingEntry = m_PollEntries[computer->uuid];
-    }
-
-    if (!pollingEntry->isActive()) {
-        PcMonitorThread* thread = new PcMonitorThread(computer);
-        connect(thread, SIGNAL(computerStateChanged(NvComputer*)),
-                this, SLOT(handleComputerStateChanged(NvComputer*)));
-        pollingEntry->setActiveThread(thread);
-        thread->start();
-    }
-}
-
 void ComputerManager::handleMdnsServiceResolved(MdnsPendingComputer* computer,
                                                 const QHostAddress& address)
 {
-    qInfo() << "Resolved" << computer->hostname() << "to" << address.toString();
+    qDebug() << "Resolved " << computer->hostname() << " to " << address.toString();
 
     addNewHost(address.toString(), true);
 
@@ -287,19 +339,6 @@ void ComputerManager::handleMdnsServiceResolved(MdnsPendingComputer* computer,
     computer->deleteLater();
 }
 
-void ComputerManager::handleComputerStateChanged(NvComputer* computer)
-{
-    emit computerStateChanged(computer);
-
-    if (computer->pendingQuit && computer->currentGameId == 0) {
-        computer->pendingQuit = false;
-        emit quitAppCompleted(QVariant());
-    }
-
-    // Save updated hosts to QSettings
-    saveHosts();
-}
-
 QVector<NvComputer*> ComputerManager::getComputers()
 {
     QReadLocker lock(&m_Lock);
@@ -316,26 +355,24 @@ public:
 
     void run()
     {
-        ComputerPollingEntry* pollingEntry;
+        QWriteLocker lock(&m_ComputerManager->m_Lock);
 
-        // Only do the minimum amount of work while holding the writer lock.
-        // We must release it before calling saveHosts().
-        {
-            QWriteLocker lock(&m_ComputerManager->m_Lock);
+        QThread* pollingThread = m_ComputerManager->m_PollThreads[m_Computer->uuid];
+        if (pollingThread != nullptr) {
+            pollingThread->requestInterruption();
 
-            pollingEntry = m_ComputerManager->m_PollEntries.take(m_Computer->uuid);
+            // We must wait here because we're going to delete computer
+            // and we can't do that out from underneath the poller.
+            pollingThread->wait();
 
-            m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
+            // The thread is safe to delete now
+            Q_ASSERT(pollingThread->isFinished());
+            delete pollingThread;
         }
 
-        // Persist the new host list
-        m_ComputerManager->saveHosts();
+        m_ComputerManager->m_PollThreads.remove(m_Computer->uuid);
+        m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
 
-        // Delete the polling entry first. This will stop all polling threads too.
-        delete pollingEntry;
-
-        // Finally, delete the computer itself. This must be done
-        // last because the polling thread might be using it.
         delete m_Computer;
     }
 
@@ -351,66 +388,6 @@ void ComputerManager::deleteHost(NvComputer* computer)
     QThreadPool::globalInstance()->start(new DeferredHostDeletionTask(this, computer));
 }
 
-void ComputerManager::handleAboutToQuit()
-{
-    QWriteLocker lock(&m_Lock);
-
-    // Interrupt polling threads immediately, so they
-    // avoid making additional requests while quitting
-    for (ComputerPollingEntry* entry : m_PollEntries) {
-        entry->interrupt();
-    }
-}
-
-class PendingPairingTask : public QObject, public QRunnable
-{
-    Q_OBJECT
-
-public:
-    PendingPairingTask(ComputerManager* computerManager, NvComputer* computer, QString pin)
-        : m_Computer(computer),
-          m_Pin(pin)
-    {
-        connect(this, &PendingPairingTask::pairingCompleted,
-                computerManager, &ComputerManager::pairingCompleted);
-    }
-
-signals:
-    void pairingCompleted(NvComputer* computer, QString error);
-
-private:
-    void run()
-    {
-        NvPairingManager pairingManager(m_Computer->activeAddress);
-
-        try {
-           NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin, m_Computer->serverCert);
-           switch (result)
-           {
-           case NvPairingManager::PairState::PIN_WRONG:
-               emit pairingCompleted(m_Computer, "The PIN from the PC didn't match. Please try again.");
-               break;
-           case NvPairingManager::PairState::FAILED:
-               emit pairingCompleted(m_Computer, "Pairing failed. Please try again.");
-               break;
-           case NvPairingManager::PairState::ALREADY_IN_PROGRESS:
-               emit pairingCompleted(m_Computer, "Another pairing attempt is already in progress.");
-               break;
-           case NvPairingManager::PairState::PAIRED:
-               emit pairingCompleted(m_Computer, nullptr);
-               break;
-           }
-        } catch (const GfeHttpResponseException& e) {
-            emit pairingCompleted(m_Computer, "GeForce Experience returned error: " + e.toQString());
-        } catch (const QtNetworkReplyException& e) {
-            emit pairingCompleted(m_Computer, e.toQString());
-        }
-    }
-
-    NvComputer* m_Computer;
-    QString m_Pin;
-};
-
 void ComputerManager::pairHost(NvComputer* computer, QString pin)
 {
     // Punt to a worker thread to avoid stalling the
@@ -419,64 +396,6 @@ void ComputerManager::pairHost(NvComputer* computer, QString pin)
     QThreadPool::globalInstance()->start(pairing);
 }
 
-class PendingQuitTask : public QObject, public QRunnable
-{
-    Q_OBJECT
-
-public:
-    PendingQuitTask(ComputerManager* computerManager, NvComputer* computer)
-        : m_Computer(computer)
-    {
-        connect(this, &PendingQuitTask::quitAppFailed,
-                computerManager, &ComputerManager::quitAppCompleted);
-    }
-
-signals:
-    void quitAppFailed(QString error);
-
-private:
-    void run()
-    {
-        NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
-
-        try {
-            if (m_Computer->currentGameId != 0) {
-                http.quitApp();
-            }
-        } catch (const GfeHttpResponseException& e) {
-            {
-                QWriteLocker lock(&m_Computer->lock);
-                m_Computer->pendingQuit = false;
-            }
-            if (e.getStatusCode() == 599) {
-                // 599 is a special code we make a custom message for
-                emit quitAppFailed("The running game wasn't started by this PC. "
-                                   "You must quit the game on the host PC manually or use the device that originally started the game.");
-            }
-            else {
-                emit quitAppFailed(e.toQString());
-            }
-        } catch (const QtNetworkReplyException& e) {
-            {
-                QWriteLocker lock(&m_Computer->lock);
-                m_Computer->pendingQuit = false;
-            }
-            emit quitAppFailed(e.toQString());
-        }
-    }
-
-    NvComputer* m_Computer;
-};
-
-void ComputerManager::quitRunningApp(NvComputer* computer)
-{
-    QWriteLocker lock(&computer->lock);
-    computer->pendingQuit = true;
-
-    PendingQuitTask* quit = new PendingQuitTask(this, computer);
-    QThreadPool::globalInstance()->start(quit);
-}
-
 void ComputerManager::stopPollingAsync()
 {
     QWriteLocker lock(&m_Lock);
@@ -498,168 +417,23 @@ void ComputerManager::stopPollingAsync()
     m_MdnsBrowser = nullptr;
 
     // Interrupt all threads, but don't wait for them to terminate
-    for (ComputerPollingEntry* entry : m_PollEntries) {
-        entry->interrupt();
+    QMutableMapIterator<QString, QThread*> i(m_PollThreads);
+    while (i.hasNext()) {
+        i.next();
+
+        QThread* thread = i.value();
+
+        // Let this thread delete itself when it's finished
+        connect(thread, SIGNAL(finished()),
+                thread, SLOT(deleteLater()));
+
+        // The threads will delete themselves when they terminate,
+        // but we remove them from the polling threads map here.
+        i.value()->requestInterruption();
+        i.remove();
     }
 }
 
-class PendingAddTask : public QObject, public QRunnable
-{
-    Q_OBJECT
-
-public:
-    PendingAddTask(ComputerManager* computerManager, QString address, bool mdns)
-        : m_ComputerManager(computerManager),
-          m_Address(address),
-          m_Mdns(mdns)
-    {
-        connect(this, &PendingAddTask::computerAddCompleted,
-                computerManager, &ComputerManager::computerAddCompleted);
-        connect(this, &PendingAddTask::computerStateChanged,
-                computerManager, &ComputerManager::handleComputerStateChanged);
-    }
-
-signals:
-    void computerAddCompleted(QVariant success);
-
-    void computerStateChanged(NvComputer* computer);
-
-private:
-    QString fetchServerInfo(NvHTTP& http)
-    {
-        QString serverInfo;
-        try {
-            // There's a race condition between GameStream servers reporting presence over
-            // mDNS and the HTTPS server being ready to respond to our queries. To work
-            // around this issue, we will issue the request again after a few seconds if
-            // we see a ServiceUnavailableError error.
-            try {
-                serverInfo = http.getServerInfo(NvHTTP::NVLL_VERBOSE);
-            } catch (const QtNetworkReplyException& e) {
-                if (e.getError() == QNetworkReply::ServiceUnavailableError) {
-                    qWarning() << "Retrying request in 5 seconds after ServiceUnavailableError";
-                    QThread::sleep(5);
-                    serverInfo = http.getServerInfo(NvHTTP::NVLL_VERBOSE);
-                    qInfo() << "Retry successful";
-                }
-                else {
-                    // Rethrow other errors
-                    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;
-        }
-
-        // 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.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();
-
-                // 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;
-
-                // 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;
-    QString m_Address;
-    bool m_Mdns;
-};
-
 void ComputerManager::addNewHost(QString address, bool mdns)
 {
     // Punt to a worker thread to avoid stalling the
@@ -668,4 +442,32 @@ void ComputerManager::addNewHost(QString address, bool mdns)
     QThreadPool::globalInstance()->start(addTask);
 }
 
-#include "computermanager.moc"
+void
+ComputerManager::handleComputerStateChanged(NvComputer* computer)
+{
+    emit computerStateChanged(computer);
+
+    // Save updated hosts to QSettings
+    saveHosts();
+}
+
+// Must hold m_Lock for write
+void
+ComputerManager::startPollingComputer(NvComputer* computer)
+{
+    if (m_PollingRef == 0) {
+        return;
+    }
+
+    if (m_PollThreads.contains(computer->uuid)) {
+        Q_ASSERT(m_PollThreads[computer->uuid]->isRunning());
+        return;
+    }
+
+    PcMonitorThread* thread = new PcMonitorThread(computer);
+    connect(thread, SIGNAL(computerStateChanged(NvComputer*)),
+            this, SLOT(handleComputerStateChanged(NvComputer*)));
+    m_PollThreads[computer->uuid] = thread;
+    thread->start();
+}
+

app/backend/computermanager.h

@@ -1,6 +1,5 @@
 #pragma once
-
-#include "nvcomputer.h"
+#include "nvhttp.h"
 #include "nvpairingmanager.h"
 
 #include <qmdnsengine/server.h>
@@ -14,6 +13,195 @@
 #include <QSettings>
 #include <QRunnable>
 
+class NvComputer
+{
+    friend class PcMonitorThread;
+
+private:
+    void sortAppList();
+
+public:
+    explicit NvComputer(QString address, QString serverInfo);
+
+    explicit NvComputer(QSettings& settings);
+
+    bool
+    update(NvComputer& that);
+
+    bool
+    wake();
+
+    QVector<QString>
+    uniqueAddresses();
+
+    void
+    serialize(QSettings& settings);
+
+    enum PairState
+    {
+        PS_UNKNOWN,
+        PS_PAIRED,
+        PS_NOT_PAIRED
+    };
+
+    enum ComputerState
+    {
+        CS_UNKNOWN,
+        CS_ONLINE,
+        CS_OFFLINE
+    };
+
+    // Ephemeral traits
+    ComputerState state;
+    PairState pairState;
+    QString activeAddress;
+    int currentGameId;
+    QString gfeVersion;
+    QString appVersion;
+    QVector<NvDisplayMode> displayModes;
+    int maxLumaPixelsHEVC;
+    int serverCodecModeSupport;
+
+    // Persisted traits
+    QString localAddress;
+    QString remoteAddress;
+    QString manualAddress;
+    QByteArray macAddress;
+    QString name;
+    QString uuid;
+    QVector<NvApp> appList;
+
+    // Synchronization
+    QReadWriteLock lock;
+};
+
+// FIXME: MOC isn't finding Q_OBJECT properly when this is confined
+// to computermanager.cpp as it should be.
+class PcMonitorThread : public QThread
+{
+    Q_OBJECT
+
+#define TRIES_BEFORE_OFFLINING 2
+#define POLLS_PER_APPLIST_FETCH 10
+
+public:
+    PcMonitorThread(NvComputer* computer)
+        : m_Computer(computer)
+    {
+        setObjectName("Polling thread for " + computer->name);
+    }
+
+private:
+    bool tryPollComputer(QString address, bool& changed)
+    {
+        NvHTTP http(address);
+
+        QString serverInfo;
+        try {
+            serverInfo = http.getServerInfo();
+        } catch (...) {
+            return false;
+        }
+
+        NvComputer newState(address, serverInfo);
+
+        // Ensure the machine that responded is the one we intended to contact
+        if (m_Computer->uuid != newState.uuid) {
+            qInfo() << "Found unexpected PC " << newState.name << " looking for " << m_Computer->name;
+            return false;
+        }
+
+        changed = m_Computer->update(newState);
+        return true;
+    }
+
+    bool updateAppList(bool& changed)
+    {
+        Q_ASSERT(m_Computer->activeAddress != nullptr);
+
+        NvHTTP http(m_Computer->activeAddress);
+
+        QVector<NvApp> appList;
+
+        try {
+            appList = http.getAppList();
+            if (appList.isEmpty()) {
+                return false;
+            }
+        } catch (...) {
+            return false;
+        }
+
+        QWriteLocker lock(&m_Computer->lock);
+        if (m_Computer->appList != appList) {
+            m_Computer->appList = appList;
+            m_Computer->sortAppList();
+            changed = true;
+        }
+
+        return true;
+    }
+
+    void run() override
+    {
+        // Always fetch the applist the first time
+        int pollsSinceLastAppListFetch = POLLS_PER_APPLIST_FETCH;
+        while (!isInterruptionRequested()) {
+            bool stateChanged = false;
+            for (int i = 0; i < TRIES_BEFORE_OFFLINING; i++) {
+                for (auto& address : m_Computer->uniqueAddresses()) {
+                    if (isInterruptionRequested()) {
+                        return;
+                    }
+
+                    if (tryPollComputer(address, stateChanged)) {
+                        break;
+                    }
+                }
+
+                // No need to continue retrying if we're online
+                if (m_Computer->state == NvComputer::CS_ONLINE) {
+                    break;
+                }
+            }
+
+            // Check if we failed after all retry attempts
+            // Note: we don't need to acquire the read lock here,
+            // because we're on the writing thread.
+            if (m_Computer->state != NvComputer::CS_ONLINE) {
+                if (m_Computer->state != NvComputer::CS_OFFLINE) {
+                    m_Computer->state = NvComputer::CS_OFFLINE;
+                    stateChanged = true;
+                }
+            }
+
+            // Grab the applist if it's empty or it's been long enough that we need to refresh
+            pollsSinceLastAppListFetch++;
+            if (m_Computer->state == NvComputer::CS_ONLINE &&
+                    m_Computer->pairState == NvComputer::PS_PAIRED &&
+                    (m_Computer->appList.isEmpty() || pollsSinceLastAppListFetch >= POLLS_PER_APPLIST_FETCH)) {
+                if (updateAppList(stateChanged)) {
+                    pollsSinceLastAppListFetch = 0;
+                }
+            }
+
+            if (stateChanged) {
+                // Tell anyone listening that we've changed state
+                emit computerStateChanged(m_Computer);
+            }
+
+            // Wait a bit to poll again
+            QThread::sleep(3);
+        }
+    }
+
+signals:
+   void computerStateChanged(NvComputer* computer);
+
+private:
+    NvComputer* m_Computer;
+};
+
 class MdnsPendingComputer : public QObject
 {
     Q_OBJECT
@@ -51,79 +239,6 @@ private:
     QMdnsEngine::Resolver m_Resolver;
 };
 
-class ComputerPollingEntry
-{
-public:
-    ComputerPollingEntry()
-        : m_ActiveThread(nullptr)
-    {
-
-    }
-
-    virtual ~ComputerPollingEntry()
-    {
-        interrupt();
-
-        // interrupt() should have taken care of this
-        Q_ASSERT(m_ActiveThread == nullptr);
-
-        for (QThread* thread : m_InactiveList) {
-            thread->wait();
-            delete thread;
-        }
-    }
-
-    bool isActive()
-    {
-        cleanInactiveList();
-
-        return m_ActiveThread != nullptr;
-    }
-
-    void setActiveThread(QThread* thread)
-    {
-        cleanInactiveList();
-
-        Q_ASSERT(!isActive());
-        m_ActiveThread = thread;
-    }
-
-    void interrupt()
-    {
-        cleanInactiveList();
-
-        if (m_ActiveThread != nullptr) {
-            // Interrupt the active thread
-            m_ActiveThread->requestInterruption();
-
-            // Place it on the inactive list awaiting death
-            m_InactiveList.append(m_ActiveThread);
-
-            m_ActiveThread = nullptr;
-        }
-    }
-
-private:
-    void cleanInactiveList()
-    {
-        QMutableListIterator<QThread*> i(m_InactiveList);
-
-        // Reap any threads that have finished
-        while (i.hasNext()) {
-            i.next();
-
-            QThread* thread = i.value();
-            if (thread->isFinished()) {
-                delete thread;
-                i.remove();
-            }
-        }
-    }
-
-    QThread* m_ActiveThread;
-    QList<QThread*> m_InactiveList;
-};
-
 class ComputerManager : public QObject
 {
     Q_OBJECT
@@ -134,8 +249,6 @@ class ComputerManager : public QObject
 public:
     explicit ComputerManager(QObject *parent = nullptr);
 
-    virtual ~ComputerManager();
-
     Q_INVOKABLE void startPolling();
 
     Q_INVOKABLE void stopPollingAsync();
@@ -144,8 +257,6 @@ public:
 
     void pairHost(NvComputer* computer, QString pin);
 
-    void quitRunningApp(NvComputer* computer);
-
     QVector<NvComputer*> getComputers();
 
     // computer is deleted inside this call
@@ -158,11 +269,7 @@ signals:
 
     void computerAddCompleted(QVariant success);
 
-    void quitAppCompleted(QVariant error);
-
 private slots:
-    void handleAboutToQuit();
-
     void handleComputerStateChanged(NvComputer* computer);
 
     void handleMdnsServiceResolved(MdnsPendingComputer* computer, const QHostAddress& address);
@@ -175,9 +282,148 @@ private:
     int m_PollingRef;
     QReadWriteLock m_Lock;
     QMap<QString, NvComputer*> m_KnownHosts;
-    QMap<QString, ComputerPollingEntry*> m_PollEntries;
+    QMap<QString, QThread*> m_PollThreads;
     QMdnsEngine::Server m_MdnsServer;
     QMdnsEngine::Browser* m_MdnsBrowser;
     QMdnsEngine::Cache m_MdnsCache;
     QVector<MdnsPendingComputer*> m_PendingResolution;
 };
+
+class PendingPairingTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+
+public:
+    PendingPairingTask(ComputerManager* computerManager, NvComputer* computer, QString pin)
+        : m_Computer(computer),
+          m_Pin(pin)
+    {
+        connect(this, &PendingPairingTask::pairingCompleted,
+                computerManager, &ComputerManager::pairingCompleted);
+    }
+
+signals:
+    void pairingCompleted(NvComputer* computer, QString error);
+
+private:
+    void run()
+    {
+        NvPairingManager pairingManager(m_Computer->activeAddress);
+
+        try {
+           NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin);
+           switch (result)
+           {
+           case NvPairingManager::PairState::PIN_WRONG:
+               emit pairingCompleted(m_Computer, "The PIN from the PC didn't match. Please try again.");
+               break;
+           case NvPairingManager::PairState::FAILED:
+               emit pairingCompleted(m_Computer, "Pairing failed. Please try again.");
+               break;
+           case NvPairingManager::PairState::ALREADY_IN_PROGRESS:
+               emit pairingCompleted(m_Computer, "Another pairing attempt is already in progress.");
+               break;
+           case NvPairingManager::PairState::PAIRED:
+               emit pairingCompleted(m_Computer, nullptr);
+               break;
+           }
+        } catch (const GfeHttpResponseException& e) {
+            emit pairingCompleted(m_Computer, e.toQString());
+        }
+    }
+
+    NvComputer* m_Computer;
+    QString m_Pin;
+};
+
+class PendingAddTask : public QObject, public QRunnable
+{
+    Q_OBJECT
+
+public:
+    PendingAddTask(ComputerManager* computerManager, QString address, bool mdns)
+        : m_ComputerManager(computerManager),
+          m_Address(address),
+          m_Mdns(mdns)
+    {
+        connect(this, &PendingAddTask::computerAddCompleted,
+                computerManager, &ComputerManager::computerAddCompleted);
+        connect(this, &PendingAddTask::computerStateChanged,
+                computerManager, &ComputerManager::handleComputerStateChanged);
+    }
+
+signals:
+    void computerAddCompleted(QVariant success);
+
+    void computerStateChanged(NvComputer* computer);
+
+private:
+    void run()
+    {
+        NvHTTP http(m_Address);
+
+        QString serverInfo;
+        try {
+            serverInfo = http.getServerInfo();
+        } catch (...) {
+            if (!m_Mdns) {
+                emit computerAddCompleted(false);
+            }
+            return;
+        }
+
+        NvComputer* newComputer = new NvComputer(m_Address, serverInfo);
+
+        // Update addresses depending on the context
+        if (m_Mdns) {
+            newComputer->localAddress = m_Address;
+        }
+        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;
+
+            // 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 if something changed
+            if (changed) {
+                emit computerStateChanged(existingComputer);
+            }
+        }
+        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;
+    QString m_Address;
+    bool m_Mdns;
+};

app/backend/computerseeker.cpp

@@ -1,59 +0,0 @@
-#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();
-}

app/backend/computerseeker.h

@@ -1,33 +0,0 @@
-#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;
-};

app/backend/identitymanager.cpp

@@ -2,12 +2,12 @@
 #include "utils.h"
 
 #include <QDebug>
+#include <QRandomGenerator64>
 
 #include <openssl/pem.h>
 #include <openssl/rsa.h>
 #include <openssl/bn.h>
 #include <openssl/x509.h>
-#include <openssl/rand.h>
 
 #define SER_UNIQUEID "uniqueid"
 #define SER_CERT "certificate"
@@ -101,7 +101,7 @@ void IdentityManager::createCredentials(QSettings& settings)
     settings.setValue(SER_CERT, m_CachedPemCert);
     settings.setValue(SER_KEY, m_CachedPrivateKey);
 
-    qInfo() << "Wrote new identity credentials to settings";
+    qDebug() << "Wrote new identity credentials to settings";
 }
 
 IdentityManager::IdentityManager()
@@ -112,7 +112,7 @@ IdentityManager::IdentityManager()
     m_CachedPrivateKey = settings.value(SER_KEY).toByteArray();
 
     if (m_CachedPemCert.isEmpty() || m_CachedPrivateKey.isEmpty()) {
-        qInfo() << "No existing credentials found";
+        qDebug() << "No existing credentials found";
         createCredentials(settings);
     }
     else if (getSslCertificate().isNull()) {
@@ -157,14 +157,10 @@ IdentityManager::getSslKey()
 
         // We must write out our PEM in the old PKCS1 format for SecureTransport
         // on macOS/iOS to be able to read it.
-#ifdef Q_OS_DARWIN
-        PEM_write_bio_PrivateKey_traditional(bio, pk, nullptr, nullptr, 0, nullptr, 0);
-#else
-        PEM_write_bio_PrivateKey(bio, pk, nullptr, nullptr, 0, nullptr, 0);
-#endif
-
         BUF_MEM* mem;
         BIO_get_mem_ptr(bio, &mem);
+        PEM_write_bio_PrivateKey_traditional(bio, pk, nullptr, nullptr, 0, nullptr, 0);
+
         m_CachedSslKey = QSslKey(QByteArray::fromRawData(mem->data, (int)mem->length), QSsl::Rsa);
 
         BIO_free(bio);
@@ -185,21 +181,20 @@ IdentityManager::getSslConfig()
 QString
 IdentityManager::getUniqueId()
 {
-    if (m_CachedUniqueId.isEmpty()) {
+    if (m_CachedUniqueId.isNull()) {
         QSettings settings;
 
         // Load the unique ID from settings
         m_CachedUniqueId = settings.value(SER_UNIQUEID).toString();
-        if (!m_CachedUniqueId.isEmpty()) {
-            qInfo() << "Loaded unique ID from settings:" << m_CachedUniqueId;
+        if (!m_CachedUniqueId.isEmpty() && !m_CachedUniqueId.isNull()) {
+            qDebug() << "Loaded unique ID from settings: " << m_CachedUniqueId;
         }
         else {
             // Generate a new unique ID in base 16
-            uint64_t uid;
-            RAND_bytes(reinterpret_cast<unsigned char*>(&uid), sizeof(uid));
-            m_CachedUniqueId = QString::number(uid, 16);
+            m_CachedUniqueId = QString::number(
+                        QRandomGenerator64::securelySeeded().generate64(), 16);
 
-            qInfo() << "Generated new unique ID:" << m_CachedUniqueId;
+            qDebug() << "Generated new unique ID: " << m_CachedUniqueId;
 
             settings.setValue(SER_UNIQUEID, m_CachedUniqueId);
         }

app/backend/nvcomputer.cpp

@@ -1,313 +0,0 @@
-#include "nvcomputer.h"
-
-#include <QUdpSocket>
-#include <QHostInfo>
-#include <QNetworkInterface>
-
-#define SER_NAME "hostname"
-#define SER_UUID "uuid"
-#define SER_MAC "mac"
-#define SER_LOCALADDR "localaddress"
-#define SER_REMOTEADDR "remoteaddress"
-#define SER_MANUALADDR "manualaddress"
-#define SER_APPLIST "apps"
-#define SER_SRVCERT "srvcert"
-
-#define SER_APPNAME "name"
-#define SER_APPID "id"
-#define SER_APPHDR "hdr"
-
-NvComputer::NvComputer(QSettings& settings)
-{
-    this->name = settings.value(SER_NAME).toString();
-    this->uuid = settings.value(SER_UUID).toString();
-    this->macAddress = settings.value(SER_MAC).toByteArray();
-    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++) {
-        NvApp app;
-
-        settings.setArrayIndex(i);
-
-        app.name = settings.value(SER_APPNAME).toString();
-        app.id = settings.value(SER_APPID).toInt();
-        app.hdrSupported = settings.value(SER_APPHDR).toBool();
-
-        this->appList.append(app);
-    }
-    settings.endArray();
-    sortAppList();
-
-    this->activeAddress = nullptr;
-    this->currentGameId = 0;
-    this->pairState = PS_UNKNOWN;
-    this->state = CS_UNKNOWN;
-    this->gfeVersion = nullptr;
-    this->appVersion = nullptr;
-    this->maxLumaPixelsHEVC = 0;
-    this->serverCodecModeSupport = 0;
-    this->pendingQuit = false;
-    this->gpuModel = nullptr;
-}
-
-void NvComputer::serialize(QSettings& settings)
-{
-    QReadLocker lock(&this->lock);
-
-    settings.setValue(SER_NAME, name);
-    settings.setValue(SER_UUID, uuid);
-    settings.setValue(SER_MAC, macAddress);
-    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()) {
-        settings.remove(SER_APPLIST);
-        settings.beginWriteArray(SER_APPLIST);
-        for (int i = 0; i < appList.count(); i++) {
-            settings.setArrayIndex(i);
-
-            settings.setValue(SER_APPNAME, appList[i].name);
-            settings.setValue(SER_APPID, appList[i].id);
-            settings.setValue(SER_APPHDR, appList[i].hdrSupported);
-        }
-        settings.endArray();
-    }
-}
-
-void NvComputer::sortAppList()
-{
-    std::stable_sort(appList.begin(), appList.end(), [](const NvApp& app1, const NvApp& app2) {
-       return app1.name.toLower() < app2.name.toLower();
-    });
-}
-
-NvComputer::NvComputer(QString address, QString serverInfo, QSslCertificate serverCert)
-{
-    this->serverCert = serverCert;
-
-    this->name = NvHTTP::getXmlString(serverInfo, "hostname");
-    if (this->name.isEmpty()) {
-        this->name = "UNKNOWN";
-    }
-
-    this->uuid = NvHTTP::getXmlString(serverInfo, "uniqueid");
-    QString newMacString = NvHTTP::getXmlString(serverInfo, "mac");
-    if (newMacString != "00:00:00:00:00:00") {
-        QStringList macOctets = newMacString.split(':');
-        for (QString macOctet : macOctets) {
-            this->macAddress.append((char) macOctet.toInt(nullptr, 16));
-        }
-    }
-
-    QString codecSupport = NvHTTP::getXmlString(serverInfo, "ServerCodecModeSupport");
-    if (!codecSupport.isEmpty()) {
-        this->serverCodecModeSupport = codecSupport.toInt();
-    }
-    else {
-        this->serverCodecModeSupport = 0;
-    }
-
-    QString maxLumaPixelsHEVC = NvHTTP::getXmlString(serverInfo, "MaxLumaPixelsHEVC");
-    if (!maxLumaPixelsHEVC.isEmpty()) {
-        this->maxLumaPixelsHEVC = maxLumaPixelsHEVC.toInt();
-    }
-    else {
-        this->maxLumaPixelsHEVC = 0;
-    }
-
-    this->displayModes = NvHTTP::getDisplayModeList(serverInfo);
-    std::stable_sort(this->displayModes.begin(), this->displayModes.end(),
-                     [](const NvDisplayMode& mode1, const NvDisplayMode& mode2) {
-        return mode1.width * mode1.height * mode1.refreshRate <
-                mode2.width * mode2.height * mode2.refreshRate;
-    });
-
-    this->localAddress = NvHTTP::getXmlString(serverInfo, "LocalIP");
-    this->remoteAddress = NvHTTP::getXmlString(serverInfo, "ExternalIP");
-    this->pairState = NvHTTP::getXmlString(serverInfo, "PairStatus") == "1" ?
-                PS_PAIRED : PS_NOT_PAIRED;
-    this->currentGameId = NvHTTP::getCurrentGame(serverInfo);
-    this->appVersion = NvHTTP::getXmlString(serverInfo, "appversion");
-    this->gfeVersion = NvHTTP::getXmlString(serverInfo, "GfeVersion");
-    this->gpuModel = NvHTTP::getXmlString(serverInfo, "gputype");
-    this->activeAddress = address;
-    this->state = NvComputer::CS_ONLINE;
-    this->pendingQuit = false;
-}
-
-bool NvComputer::wake()
-{
-    if (state == NvComputer::CS_ONLINE) {
-        qWarning() << name << "is already online";
-        return true;
-    }
-
-    if (macAddress.isEmpty()) {
-        qWarning() << name << "has no MAC address stored";
-        return false;
-    }
-
-    const quint16 WOL_PORTS[] = {
-        7, 9, // Standard WOL ports
-        47998, 47999, 48000, // Ports opened by GFE
-    };
-
-    // Create the WoL payload
-    QByteArray wolPayload;
-    wolPayload.append(QByteArray::fromHex("FFFFFFFFFFFF"));
-    for (int i = 0; i < 16; i++) {
-        wolPayload.append(macAddress);
-    }
-    Q_ASSERT(wolPayload.count() == 102);
-
-    // Add the addresses that we know this host to be
-    // and broadcast addresses for this link just in
-    // case the host has timed out in ARP entries.
-    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) {
-        QHostInfo hostInfo = QHostInfo::fromName(addressString);
-
-        if (hostInfo.error() != QHostInfo::NoError) {
-            qWarning() << "Error resolving" << addressString << ":" << hostInfo.errorString();
-            continue;
-        }
-
-        // Try all IP addresses that this string resolves to
-        for (QHostAddress& address : hostInfo.addresses()) {
-            QUdpSocket sock;
-
-            // 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();
-                }
-            }
-        }
-    }
-
-    return success;
-}
-
-QVector<QString> NvComputer::uniqueAddresses()
-{
-    QVector<QString> uniqueAddressList;
-
-    // Start with addresses correctly ordered
-    uniqueAddressList.append(activeAddress);
-    uniqueAddressList.append(localAddress);
-    uniqueAddressList.append(remoteAddress);
-    uniqueAddressList.append(manualAddress);
-
-    // Prune duplicates (always giving precedence to the first)
-    for (int i = 0; i < uniqueAddressList.count(); i++) {
-        if (uniqueAddressList[i].isEmpty()) {
-            uniqueAddressList.remove(i);
-            i--;
-            continue;
-        }
-        for (int j = i + 1; j < uniqueAddressList.count(); j++) {
-            if (uniqueAddressList[i] == uniqueAddressList[j]) {
-                // Always remove the later occurrence
-                uniqueAddressList.remove(j);
-                j--;
-            }
-        }
-    }
-
-    // We must have at least 1 address
-    Q_ASSERT(!uniqueAddressList.isEmpty());
-
-    return uniqueAddressList;
-}
-
-bool NvComputer::update(NvComputer& that)
-{
-    bool changed = false;
-
-    // Lock us for write and them for read
-    QWriteLocker thisLock(&this->lock);
-    QReadLocker thatLock(&that.lock);
-
-    // UUID may not change or we're talking to a new PC
-    Q_ASSERT(this->uuid == that.uuid);
-
-#define ASSIGN_IF_CHANGED(field)       \
-    if (this->field != that.field) {   \
-        this->field = that.field;      \
-        changed = true;                \
-    }
-
-#define ASSIGN_IF_CHANGED_AND_NONEMPTY(field) \
-    if (!that.field.isEmpty() &&              \
-        this->field != that.field) {          \
-        this->field = that.field;             \
-        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);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(remoteAddress);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(manualAddress);
-    ASSIGN_IF_CHANGED(pairState);
-    ASSIGN_IF_CHANGED(serverCodecModeSupport);
-    ASSIGN_IF_CHANGED(currentGameId);
-    ASSIGN_IF_CHANGED(activeAddress);
-    ASSIGN_IF_CHANGED(state);
-    ASSIGN_IF_CHANGED(gfeVersion);
-    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;
-}

app/backend/nvcomputer.h

@@ -1,76 +0,0 @@
-#pragma once
-
-#include "nvhttp.h"
-
-#include <QThread>
-#include <QReadWriteLock>
-#include <QSettings>
-#include <QRunnable>
-
-class NvComputer
-{
-    friend class PcMonitorThread;
-    friend class ComputerManager;
-    friend class PendingQuitTask;
-
-private:
-    void sortAppList();
-
-    bool pendingQuit;
-
-public:
-    explicit NvComputer(QString address, QString serverInfo, QSslCertificate serverCert);
-
-    explicit NvComputer(QSettings& settings);
-
-    bool
-    update(NvComputer& that);
-
-    bool
-    wake();
-
-    QVector<QString>
-    uniqueAddresses();
-
-    void
-    serialize(QSettings& settings);
-
-    enum PairState
-    {
-        PS_UNKNOWN,
-        PS_PAIRED,
-        PS_NOT_PAIRED
-    };
-
-    enum ComputerState
-    {
-        CS_UNKNOWN,
-        CS_ONLINE,
-        CS_OFFLINE
-    };
-
-    // Ephemeral traits
-    ComputerState state;
-    PairState pairState;
-    QString activeAddress;
-    int currentGameId;
-    QString gfeVersion;
-    QString appVersion;
-    QVector<NvDisplayMode> displayModes;
-    int maxLumaPixelsHEVC;
-    int serverCodecModeSupport;
-    QString gpuModel;
-
-    // Persisted traits
-    QString localAddress;
-    QString remoteAddress;
-    QString manualAddress;
-    QByteArray macAddress;
-    QString name;
-    QString uuid;
-    QSslCertificate serverCert;
-    QVector<NvApp> appList;
-
-    // Synchronization
-    QReadWriteLock lock;
-};

app/backend/nvhttp.cpp

@@ -10,50 +10,26 @@
 #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, QSslCertificate serverCert) :
-    m_Address(address),
-    m_ServerCert(serverCert)
+NvHTTP::NvHTTP(QString address) :
+    m_Address(address)
 {
-    Q_ASSERT(!address.isEmpty());
-
     m_BaseUrlHttp.setScheme("http");
     m_BaseUrlHttps.setScheme("https");
     m_BaseUrlHttp.setHost(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);
-
-    connect(&m_Nam, &QNetworkAccessManager::sslErrors, this, &NvHTTP::handleSslErrors);
-}
-
-void NvHTTP::setServerCert(QSslCertificate serverCert)
-{
-    m_ServerCert = serverCert;
 }
 
 QVector<int>
 NvHTTP::parseQuad(QString quad)
 {
+    QStringList parts = quad.split(".");
     QVector<int> ret;
 
-    // Return an empty vector for old GFE versions
-    // that were missing GfeVersion.
-    if (quad.isEmpty()) {
-        return ret;
-    }
-
-    QStringList parts = quad.split(".");
     for (int i = 0; i < 4; i++)
     {
         ret.append(parts.at(i).toInt());
@@ -80,54 +56,38 @@ NvHTTP::getCurrentGame(QString serverInfo)
 }
 
 QString
-NvHTTP::getServerInfo(NvLogLevel logLevel)
+NvHTTP::getServerInfo()
 {
     QString serverInfo;
 
-    // Check if we have a pinned cert for this host yet
-    if (!m_ServerCert.isNull())
+    try
     {
-        try
-        {
-            // Always try HTTPS first, since it properly reports
-            // pairing status (and a few other attributes).
-            serverInfo = openConnectionToString(m_BaseUrlHttps,
-                                                "serverinfo",
-                                                nullptr,
-                                                REQUEST_TIMEOUT_MS,
-                                                logLevel);
-            // Throws if the request failed
-            verifyResponseStatus(serverInfo);
-        }
-        catch (const GfeHttpResponseException& 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,
+        // Always try HTTPS first, since it properly reports
+        // pairing status (and a few other attributes).
+        serverInfo = openConnectionToString(m_BaseUrlHttps,
                                             "serverinfo",
                                             nullptr,
-                                            REQUEST_TIMEOUT_MS,
-                                            logLevel);
+                                            true);
+        // Throws if the request failed
         verifyResponseStatus(serverInfo);
     }
+    catch (const GfeHttpResponseException& e)
+    {
+        if (e.getStatusCode() == 401)
+        {
+            // Certificate validation error, fallback to HTTP
+            serverInfo = openConnectionToString(m_BaseUrlHttp,
+                                                "serverinfo",
+                                                nullptr,
+                                                true);
+            verifyResponseStatus(serverInfo);
+        }
+        else
+        {
+            // Rethrow real errors
+            throw e;
+        }
+    }
 
     return serverInfo;
 }
@@ -163,24 +123,16 @@ NvHTTP::launchApp(int appId,
                   bool localAudio,
                   int gamepadMask)
 {
-    int riKeyId;
-
-    memcpy(&riKeyId, streamConfig->remoteInputAesIv, sizeof(riKeyId));
-    riKeyId = qFromBigEndian(riKeyId);
-
     QString response =
             openConnectionToString(m_BaseUrlHttps,
                                    "launch",
                                    "appid="+QString::number(appId)+
                                    "&mode="+QString::number(streamConfig->width)+"x"+
                                    QString::number(streamConfig->height)+"x"+
-                                   // Using an FPS value over 60 causes SOPS to default to 720p60,
-                                   // so force it to 60 when starting. This won't impact our ability
-                                   // to get > 60 FPS while actually streaming though.
-                                   QString::number(streamConfig->fps > 60 ? 60 : streamConfig->fps)+
+                                   QString::number(streamConfig->fps)+
                                    "&additionalStates=1&sops="+QString::number(sops ? 1 : 0)+
                                    "&rikey="+QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex()+
-                                   "&rikeyid="+QString::number(riKeyId)+
+                                   "&rikeyid="+QString::number(qFromBigEndian(*(int*)streamConfig->remoteInputAesIv))+
                                    (streamConfig->enableHdr ?
                                        "&hdrMode=1&clientHdrCapVersion=0&clientHdrCapSupportedFlagsInUint32=0&clientHdrCapMetaDataId=NV_STATIC_METADATA_TYPE_1&clientHdrCapDisplayData=0x0x0x0x0x0x0x0x0x0x0" :
                                         "")+
@@ -188,7 +140,7 @@ NvHTTP::launchApp(int appId,
                                    "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration)+
                                    "&remoteControllersBitmap="+QString::number(gamepadMask)+
                                    "&gcmap="+QString::number(gamepadMask),
-                                   LAUNCH_TIMEOUT_MS);
+                                   false);
 
     // Throws if the request failed
     verifyResponseStatus(response);
@@ -197,18 +149,13 @@ NvHTTP::launchApp(int appId,
 void
 NvHTTP::resumeApp(PSTREAM_CONFIGURATION streamConfig)
 {
-    int riKeyId;
-
-    memcpy(&riKeyId, streamConfig->remoteInputAesIv, sizeof(riKeyId));
-    riKeyId = qFromBigEndian(riKeyId);
-
     QString response =
             openConnectionToString(m_BaseUrlHttps,
                                    "resume",
                                    "rikey="+QString(QByteArray(streamConfig->remoteInputAesKey, sizeof(streamConfig->remoteInputAesKey)).toHex())+
-                                   "&rikeyid="+QString::number(riKeyId)+
+                                   "&rikeyid="+QString::number(qFromBigEndian(*(int*)streamConfig->remoteInputAesIv))+
                                    "&surroundAudioInfo="+getSurroundAudioInfoString(streamConfig->audioConfiguration),
-                                   RESUME_TIMEOUT_MS);
+                                   false);
 
     // Throws if the request failed
     verifyResponseStatus(response);
@@ -221,14 +168,14 @@ NvHTTP::quitApp()
             openConnectionToString(m_BaseUrlHttps,
                                    "cancel",
                                    nullptr,
-                                   QUIT_TIMEOUT_MS);
+                                   false);
 
     // Throws if the request failed
     verifyResponseStatus(response);
 
     // Newer GFE versions will just return success even if quitting fails
     // if we're not the original requestor.
-    if (getCurrentGame(getServerInfo(NvHTTP::NVLL_ERROR)) != 0) {
+    if (getCurrentGame(getServerInfo()) != 0) {
         // Generate a synthetic GfeResponseException letting the caller know
         // that they can't kill someone else's stream.
         throw GfeHttpResponseException(599, "");
@@ -268,8 +215,7 @@ NvHTTP::getAppList()
     QString appxml = openConnectionToString(m_BaseUrlHttps,
                                             "applist",
                                             nullptr,
-                                            REQUEST_TIMEOUT_MS,
-                                            NvLogLevel::NVLL_ERROR);
+                                            true);
     verifyResponseStatus(appxml);
 
     QXmlStreamReader xmlReader(appxml);
@@ -319,10 +265,7 @@ NvHTTP::verifyResponseStatus(QString xml)
             else
             {
                 QString statusMessage = xmlReader.attributes().value("status_message").toString();
-                if (statusCode != 401) {
-                    // 401 is expected for unpaired PCs when we fetch serverinfo over HTTPS
-                    qWarning() << "Request failed:" << statusCode << statusMessage;
-                }
+                qDebug() << "Request failed: " << statusCode << " " << statusMessage;
                 throw GfeHttpResponseException(statusCode, statusMessage);
             }
         }
@@ -336,8 +279,7 @@ NvHTTP::getBoxArt(int appId)
                                           "appasset",
                                           "appid="+QString::number(appId)+
                                           "&AssetType=2&AssetIdx=0",
-                                          REQUEST_TIMEOUT_MS,
-                                          NvLogLevel::NVLL_VERBOSE);
+                                          true);
     QImage image = QImageReader(reply).read();
     delete reply;
 
@@ -379,41 +321,16 @@ NvHTTP::getXmlString(QString xml,
     return nullptr;
 }
 
-void NvHTTP::handleSslErrors(QNetworkReply* reply, const QList<QSslError>& errors)
-{
-    bool ignoreErrors = true;
-
-    if (m_ServerCert.isNull()) {
-        // We should never make an HTTPS request without a cert
-        Q_ASSERT(!m_ServerCert.isNull());
-        return;
-    }
-
-    for (auto error : errors) {
-        if (m_ServerCert != error.certificate()) {
-            ignoreErrors = false;
-            break;
-        }
-    }
-
-    if (ignoreErrors) {
-        reply->ignoreSslErrors(errors);
-    }
-}
-
 QString
 NvHTTP::openConnectionToString(QUrl baseUrl,
                                QString command,
                                QString arguments,
-                               int timeoutMs,
-                               NvLogLevel logLevel)
+                               bool enableTimeout)
 {
-    QNetworkReply* reply = openConnection(baseUrl, command, arguments, timeoutMs, logLevel);
+    QNetworkReply* reply = openConnection(baseUrl, command, arguments, enableTimeout);
     QString ret;
 
-    QTextStream stream(reply);
-    stream.setCodec("UTF-8");
-    ret = stream.readAll();
+    ret = QTextStream(reply).readAll();
     delete reply;
 
     return ret;
@@ -423,45 +340,39 @@ QNetworkReply*
 NvHTTP::openConnection(QUrl baseUrl,
                        QString command,
                        QString arguments,
-                       int timeoutMs,
-                       NvLogLevel logLevel)
+                       bool enableTimeout)
 {
     // Build a URL for the request
     QUrl url(baseUrl);
     url.setPath("/" + command);
-
-    // 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() +
+    url.setQuery("uniqueid=" + IdentityManager::get()->getUniqueId() +
+                 "&uuid=" + QUuid::createUuid().toRfc4122().toHex() +
                  ((arguments != nullptr) ? ("&" + arguments) : ""));
 
-    QNetworkRequest request(url);
+    QNetworkRequest request = QNetworkRequest(url);
 
     // Add our client certificate
     request.setSslConfiguration(IdentityManager::get()->getSslConfig());
 
     QNetworkReply* reply = m_Nam.get(request);
 
+    // Ignore self-signed certificate errors (since GFE uses them)
+    reply->ignoreSslErrors();
+
     // Run the request with a timeout if requested
     QEventLoop loop;
-    connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
-    connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), &loop, SLOT(quit()));
-    if (timeoutMs) {
-        QTimer::singleShot(timeoutMs, &loop, SLOT(quit()));
-    }
-    if (logLevel >= NvLogLevel::NVLL_VERBOSE) {
-        qInfo() << "Executing request:" << url.toString();
+    QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
+    if (enableTimeout)
+    {
+        QTimer::singleShot(REQUEST_TIMEOUT_MS, &loop, SLOT(quit()));
     }
+    qDebug() << "Executing request: " << url.toString();
     loop.exec(QEventLoop::ExcludeUserInputEvents);
 
     // Abort the request if it timed out
     if (!reply->isFinished())
     {
-        if (logLevel >= NvLogLevel::NVLL_ERROR) {
-            qWarning() << "Aborting timed out request for" << url.toString();
-        }
+        qDebug() << "Aborting timed out request for " << url.toString();
         reply->abort();
     }
 
@@ -472,27 +383,10 @@ NvHTTP::openConnection(QUrl baseUrl,
     // Handle error
     if (reply->error() != QNetworkReply::NoError)
     {
-        if (logLevel >= NvLogLevel::NVLL_ERROR) {
-            qWarning() << command << " request failed with error " << reply->error();
-        }
-
-        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;
-        }
+        qDebug() << command << " request failed with error " << reply->error();
+        GfeHttpResponseException exception(reply->error(), reply->errorString());
+        delete reply;
+        throw exception;
     }
 
     return reply;

app/backend/nvhttp.h

@@ -5,8 +5,7 @@
 #include <Limelight.h>
 
 #include <QUrl>
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
+#include <QtNetwork/QNetworkAccessManager>
 
 class NvApp
 {
@@ -18,7 +17,7 @@ public:
 
     bool isInitialized()
     {
-        return id != 0 && !name.isEmpty();
+        return id != 0 && !name.isNull();
     }
 
     int id;
@@ -78,60 +77,17 @@ private:
     QString m_StatusMessage;
 };
 
-class QtNetworkReplyException : public std::exception
+class NvHTTP
 {
 public:
-    QtNetworkReplyException(QNetworkReply::NetworkError error, QString errorText) :
-        m_Error(error),
-        m_ErrorText(errorText)
-    {
-
-    }
-
-    const char* what() const throw()
-    {
-        return m_ErrorText.toLatin1();
-    }
-
-    const char* getErrorText() const
-    {
-        return m_ErrorText.toLatin1();
-    }
-
-    QNetworkReply::NetworkError getError() const
-    {
-        return m_Error;
-    }
-
-    QString toQString() const
-    {
-        return m_ErrorText + " (Error " + QString::number(m_Error) + ")";
-    }
-
-private:
-    QNetworkReply::NetworkError m_Error;
-    QString m_ErrorText;
-};
-
-class NvHTTP : public QObject
-{
-    Q_OBJECT
-
-public:
-    enum NvLogLevel {
-        NVLL_NONE,
-        NVLL_ERROR,
-        NVLL_VERBOSE
-    };
-
-    explicit NvHTTP(QString address, QSslCertificate serverCert);
+    explicit NvHTTP(QString address);
 
     static
     int
     getCurrentGame(QString serverInfo);
 
     QString
-    getServerInfo(NvLogLevel logLevel);
+    getServerInfo();
 
     static
     void
@@ -151,10 +107,7 @@ public:
     openConnectionToString(QUrl baseUrl,
                            QString command,
                            QString arguments,
-                           int timeoutMs,
-                           NvLogLevel logLevel = NvLogLevel::NVLL_VERBOSE);
-
-    void setServerCert(QSslCertificate serverCert);
+                           bool enableTimeout);
 
     static
     QVector<int>
@@ -186,17 +139,12 @@ public:
     QUrl m_BaseUrlHttp;
     QUrl m_BaseUrlHttps;
 private:
-    void
-    handleSslErrors(QNetworkReply* reply, const QList<QSslError>& errors);
-
     QNetworkReply*
     openConnection(QUrl baseUrl,
                    QString command,
                    QString arguments,
-                   int timeoutMs,
-                   NvLogLevel logLevel);
+                   bool enableTimeout);
 
     QString m_Address;
     QNetworkAccessManager m_Nam;
-    QSslCertificate m_ServerCert;
 };

app/backend/nvpairingmanager.cpp

@@ -1,6 +1,8 @@
 #include "nvpairingmanager.h"
 #include "utils.h"
 
+#include <QRandomGenerator>
+
 #include <openssl/bio.h>
 #include <openssl/aes.h>
 #include <openssl/rand.h>
@@ -8,10 +10,8 @@
 #include <openssl/x509.h>
 #include <openssl/evp.h>
 
-#define REQUEST_TIMEOUT_MS 5000
-
 NvPairingManager::NvPairingManager(QString address) :
-    m_Http(address, QSslCertificate())
+    m_Http(address)
 {
     QByteArray cert = IdentityManager::get()->getCertificate();
     BIO *bio = BIO_new_mem_buf(cert.data(), -1);
@@ -21,7 +21,7 @@ NvPairingManager::NvPairingManager(QString address) :
     BIO_free_all(bio);
     if (m_Cert == nullptr)
     {
-        throw std::runtime_error("Unable to load certificate");
+        throw new std::runtime_error("Unable to load certificate");
     }
 
     QByteArray pk = IdentityManager::get()->getPrivateKey();
@@ -32,7 +32,7 @@ NvPairingManager::NvPairingManager(QString address) :
     BIO_free_all(bio);
     if (m_PrivateKey == nullptr)
     {
-        throw std::runtime_error("Unable to load private key");
+        throw new std::runtime_error("Unable to load private key");
     }
 }
 
@@ -89,16 +89,14 @@ NvPairingManager::getSignatureFromPemCert(QByteArray certificate)
     X509* cert = PEM_read_bio_X509(bio, nullptr, nullptr, nullptr);
     BIO_free_all(bio);
 
-#if (OPENSSL_VERSION_NUMBER < 0x10002000L)
-    ASN1_BIT_STRING *asnSignature = cert->signature;
-#elif (OPENSSL_VERSION_NUMBER < 0x10100000L)
-    ASN1_BIT_STRING *asnSignature;
-    X509_get0_signature(&asnSignature, NULL, cert);
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
+   ASN1_BIT_STRING *asnSignature;
 #else
-    const ASN1_BIT_STRING *asnSignature;
-    X509_get0_signature(&asnSignature, NULL, cert);
+   const ASN1_BIT_STRING *asnSignature;
 #endif
 
+    X509_get0_signature(&asnSignature, NULL, cert);
+
     QByteArray signature(reinterpret_cast<char*>(asnSignature->data), asnSignature->length);
 
     X509_free(cert);
@@ -163,10 +161,10 @@ NvPairingManager::saltPin(QByteArray salt, QString pin)
 }
 
 NvPairingManager::PairState
-NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverCert)
+NvPairingManager::pair(QString appVersion, QString pin)
 {
     int serverMajorVersion = NvHTTP::parseQuad(appVersion).at(0);
-    qInfo() << "Pairing with server generation:" << serverMajorVersion;
+    qDebug() << "Pairing with server generation: " << serverMajorVersion;
 
     QCryptographicHash::Algorithm hashAlgo;
     int hashLength;
@@ -194,46 +192,34 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
                                                     "pair",
                                                     "devicename=roth&updateState=1&phrase=getservercert&salt=" +
                                                     salt.toHex() + "&clientcert=" + IdentityManager::get()->getCertificate().toHex(),
-                                                    0);
+                                                    false);
     NvHTTP::verifyResponseStatus(getCert);
     if (NvHTTP::getXmlString(getCert, "paired") != "1")
     {
-        qCritical() << "Failed pairing at stage #1";
+        qDebug() << "Failed pairing at stage #1";
         return PairState::FAILED;
     }
 
-    QByteArray serverCertStr = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
-    if (serverCertStr == nullptr)
+    QByteArray serverCert = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
+    if (serverCert == nullptr)
     {
-        qCritical() << "Server likely already pairing";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Server likely already pairing";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         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(),
-                                                         REQUEST_TIMEOUT_MS);
+                                                         true);
     NvHTTP::verifyResponseStatus(challengeXml);
     if (NvHTTP::getXmlString(challengeXml, "paired") != "1")
     {
-        qCritical() << "Failed pairing at stage #2";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #2";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         return PairState::FAILED;
     }
 
@@ -242,15 +228,13 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
     QByteArray challengeResponse;
     QByteArray serverResponse(challengeResponseData.data(), hashLength);
 
-#if (OPENSSL_VERSION_NUMBER < 0x10002000L)
-    ASN1_BIT_STRING *asnSignature = m_Cert->signature;
-#elif (OPENSSL_VERSION_NUMBER < 0x10100000L)
+ #if (OPENSSL_VERSION_NUMBER < 0x10100000L)
     ASN1_BIT_STRING *asnSignature;
-    X509_get0_signature(&asnSignature, NULL, m_Cert);
-#else
+ #else
     const ASN1_BIT_STRING *asnSignature;
+ #endif
+
     X509_get0_signature(&asnSignature, NULL, m_Cert);
-#endif
 
     challengeResponse.append(challengeResponseData.data() + hashLength, 16);
     challengeResponse.append(reinterpret_cast<char*>(asnSignature->data), asnSignature->length);
@@ -261,12 +245,12 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
                                                     "pair",
                                                     "devicename=roth&updateState=1&serverchallengeresp=" +
                                                     encryptedChallengeResponseHash.toHex(),
-                                                    REQUEST_TIMEOUT_MS);
+                                                    true);
     NvHTTP::verifyResponseStatus(respXml);
     if (NvHTTP::getXmlString(respXml, "paired") != "1")
     {
-        qCritical() << "Failed pairing at stage #3";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #3";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         return PairState::FAILED;
     }
 
@@ -276,21 +260,21 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
 
     if (!verifySignature(serverSecret,
                          serverSignature,
-                         serverCertStr))
+                         serverCert))
     {
-        qCritical() << "MITM detected";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "MITM detected";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         return PairState::FAILED;
     }
 
     QByteArray expectedResponseData;
     expectedResponseData.append(randomChallenge);
-    expectedResponseData.append(getSignatureFromPemCert(serverCertStr));
+    expectedResponseData.append(getSignatureFromPemCert(serverCert));
     expectedResponseData.append(serverSecret);
     if (QCryptographicHash::hash(expectedResponseData, hashAlgo) != serverResponse)
     {
-        qCritical() << "Incorrect PIN";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Incorrect PIN";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         return PairState::PIN_WRONG;
     }
 
@@ -302,24 +286,24 @@ NvPairingManager::pair(QString appVersion, QString pin, QSslCertificate& serverC
                                                           "pair",
                                                           "devicename=roth&updateState=1&clientpairingsecret=" +
                                                           clientPairingSecret.toHex(),
-                                                          REQUEST_TIMEOUT_MS);
+                                                          true);
     NvHTTP::verifyResponseStatus(secretRespXml);
     if (NvHTTP::getXmlString(secretRespXml, "paired") != "1")
     {
-        qCritical() << "Failed pairing at stage #4";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #4";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         return PairState::FAILED;
     }
 
     QString pairChallengeXml = m_Http.openConnectionToString(m_Http.m_BaseUrlHttps,
                                                              "pair",
                                                              "devicename=roth&updateState=1&phrase=pairchallenge",
-                                                             REQUEST_TIMEOUT_MS);
+                                                             true);
     NvHTTP::verifyResponseStatus(pairChallengeXml);
     if (NvHTTP::getXmlString(pairChallengeXml, "paired") != "1")
     {
-        qCritical() << "Failed pairing at stage #5";
-        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, REQUEST_TIMEOUT_MS);
+        qDebug() << "Failed pairing at stage #5";
+        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
         return PairState::FAILED;
     }
 

app/backend/nvpairingmanager.h

@@ -23,7 +23,7 @@ public:
     ~NvPairingManager();
 
     PairState
-    pair(QString appVersion, QString pin, QSslCertificate& serverCert);
+    pair(QString appVersion, QString pin);
 
 private:
     QByteArray

app/backend/systemproperties.cpp

@@ -1,117 +0,0 @@
-#include "systemproperties.h"
-
-#include <QGuiApplication>
-
-#include "streaming/session.h"
-#include "streaming/streamutils.h"
-
-SystemProperties::SystemProperties()
-{
-    isRunningWayland = qgetenv("XDG_SESSION_TYPE") == "wayland";
-    isRunningXWayland = qgetenv("XDG_SESSION_TYPE") == "wayland" && QGuiApplication::platformName() == "xcb";
-
-#ifdef Q_OS_WIN32
-    isWow64 = QSysInfo::currentCpuArchitecture() != QSysInfo::buildCpuArchitecture();
-#else
-    isWow64 = false;
-#endif
-
-#ifndef STEAM_LINK
-    hasBrowser = true;
-#else
-    hasBrowser = false;
-#endif
-
-    unmappedGamepads = SdlInputHandler::getUnmappedGamepads();
-
-    // Populate data that requires talking to SDL. We do it all in one shot
-    // and cache the results to speed up future queries on this data.
-    querySdlVideoInfo();
-
-    Q_ASSERT(maximumStreamingFrameRate >= 60);
-    Q_ASSERT(!monitorDesktopResolutions.isEmpty());
-    Q_ASSERT(!monitorNativeResolutions.isEmpty());
-}
-
-QRect SystemProperties::getDesktopResolution(int displayIndex)
-{
-    // Returns default constructed QRect if out of bounds
-    return monitorDesktopResolutions.value(displayIndex);
-}
-
-QRect SystemProperties::getNativeResolution(int displayIndex)
-{
-    // Returns default constructed QRect if out of bounds
-    return monitorNativeResolutions.value(displayIndex);
-}
-
-void SystemProperties::querySdlVideoInfo()
-{
-    monitorDesktopResolutions.clear();
-    monitorNativeResolutions.clear();
-    hasHardwareAcceleration = false;
-
-    // Never let the maximum drop below 60 FPS
-    maximumStreamingFrameRate = 60;
-
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return;
-    }
-
-    SDL_DisplayMode bestMode;
-    for (int displayIndex = 0; displayIndex < SDL_GetNumVideoDisplays(); displayIndex++) {
-        SDL_DisplayMode desktopMode;
-        int err;
-
-        err = SDL_GetDesktopDisplayMode(displayIndex, &desktopMode);
-        if (err == 0) {
-            monitorDesktopResolutions.insert(displayIndex, QRect(0, 0, desktopMode.w, desktopMode.h));
-        }
-        else {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "SDL_GetDesktopDisplayMode() failed: %s",
-                         SDL_GetError());
-        }
-
-        if (StreamUtils::getRealDesktopMode(displayIndex, &desktopMode)) {
-            monitorNativeResolutions.insert(displayIndex, QRect(0, 0, desktopMode.w, desktopMode.h));
-
-            // Start at desktop mode and work our way up
-            bestMode = desktopMode;
-            for (int i = 0; i < SDL_GetNumDisplayModes(displayIndex); i++) {
-                SDL_DisplayMode mode;
-                if (SDL_GetDisplayMode(displayIndex, i, &mode) == 0) {
-                    if (mode.w == desktopMode.w && mode.h == desktopMode.h) {
-                        if (mode.refresh_rate > bestMode.refresh_rate) {
-                            bestMode = mode;
-                        }
-                    }
-                }
-            }
-
-            maximumStreamingFrameRate = qMax(maximumStreamingFrameRate, bestMode.refresh_rate);
-        }
-    }
-
-    SDL_Window* testWindow = SDL_CreateWindow("", 0, 0, 1280, 720, SDL_WINDOW_HIDDEN);
-    if (!testWindow) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to create window for hardware decode test: %s",
-                     SDL_GetError());
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        return;
-    }
-
-    hasHardwareAcceleration =
-            Session::isHardwareDecodeAvailable(testWindow,
-                                               StreamingPreferences::VDS_AUTO,
-                                               VIDEO_FORMAT_H264,
-                                               1920, 1080, 60);
-
-    SDL_DestroyWindow(testWindow);
-
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
-}

app/backend/systemproperties.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QRect>
-
-class SystemProperties : public QObject
-{
-    Q_OBJECT
-
-public:
-    SystemProperties();
-
-    Q_PROPERTY(bool hasHardwareAcceleration MEMBER hasHardwareAcceleration CONSTANT)
-    Q_PROPERTY(bool isRunningWayland MEMBER isRunningWayland CONSTANT)
-    Q_PROPERTY(bool isRunningXWayland MEMBER isRunningXWayland CONSTANT)
-    Q_PROPERTY(bool isWow64 MEMBER isWow64 CONSTANT)
-    Q_PROPERTY(bool hasBrowser MEMBER hasBrowser CONSTANT)
-    Q_PROPERTY(QString unmappedGamepads MEMBER unmappedGamepads NOTIFY unmappedGamepadsChanged)
-    Q_PROPERTY(int maximumStreamingFrameRate MEMBER maximumStreamingFrameRate CONSTANT)
-
-    Q_INVOKABLE QRect getDesktopResolution(int displayIndex);
-    Q_INVOKABLE QRect getNativeResolution(int displayIndex);
-
-signals:
-    void unmappedGamepadsChanged();
-
-private:
-    void querySdlVideoInfo();
-
-    bool hasHardwareAcceleration;
-    bool isRunningWayland;
-    bool isRunningXWayland;
-    bool isWow64;
-    bool hasBrowser;
-    QString unmappedGamepads;
-    int maximumStreamingFrameRate;
-    QList<QRect> monitorDesktopResolutions;
-    QList<QRect> monitorNativeResolutions;
-};
-

app/cli/commandlineparser.cpp

@@ -1,414 +0,0 @@
-#include "commandlineparser.h"
-
-#include <QCommandLineParser>
-#include <QRegularExpression>
-
-#if defined(Q_OS_WIN)
-#include <qt_windows.h>
-#endif
-
-static bool inRange(int value, int min, int max)
-{
-    return value >= min && value <= max;
-}
-
-// This method returns key's value from QMap where the key is a QString.
-// Key matching is case insensitive.
-template <typename T>
-static T mapValue(QMap<QString, T> map, QString key)
-{
-    for(auto& item : map.toStdMap()) {
-        if (QString::compare(item.first, key, Qt::CaseInsensitive) == 0) {
-            return item.second;
-        }
-    }
-    return T();
-}
-
-class CommandLineParser : public QCommandLineParser
-{
-public:
-    enum MessageType {
-        Info,
-        Error
-    };
-
-    void setupCommonOptions()
-    {
-        setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
-        addHelpOption();
-        addVersionOption();
-    }
-
-    void handleHelpAndVersionOptions()
-    {
-        if (isSet("help")) {
-            showInfo(helpText());
-        }
-        if (isSet("version")) {
-            showVersion();
-        }
-    }
-
-    void handleUnknownOptions()
-    {
-        if (unknownOptionNames().length()) {
-            showError(QString("Unknown options: %1").arg(unknownOptionNames().join(", ")));
-        }
-    }
-
-    void showMessage(QString message, MessageType type) const
-    {
-    #if defined(Q_OS_WIN32)
-        UINT flags = MB_OK | MB_TOPMOST | MB_SETFOREGROUND;
-        flags |= (type == Info ? MB_ICONINFORMATION : MB_ICONERROR);
-        QString title = "Moonlight";
-        MessageBoxW(nullptr, reinterpret_cast<const wchar_t *>(message.utf16()),
-                    reinterpret_cast<const wchar_t *>(title.utf16()), flags);
-    #endif
-        message = message.endsWith('\n') ? message : message + '\n';
-        fputs(qPrintable(message), type == Info ? stdout : stderr);
-    }
-
-    [[ noreturn ]] void showInfo(QString message) const
-    {
-        showMessage(message, Info);
-        exit(0);
-    }
-
-    [[ noreturn ]] void showError(QString message) const
-    {
-        showMessage(message + "\n\n" + helpText(), Error);
-        exit(1);
-    }
-
-    int getIntOption(QString name) const
-    {
-        bool ok;
-        int intValue = value(name).toInt(&ok);
-        if (!ok) {
-            showError(QString("Invalid %1 value: %2").arg(name, value(name)));
-        }
-        return intValue;
-    }
-
-    bool getToggleOptionValue(QString name, bool defaultValue) const
-    {
-        QRegularExpression re(QString("^(%1|no-%1)$").arg(name));
-        QStringList options = optionNames().filter(re);
-        if (options.isEmpty()) {
-            return defaultValue;
-        } else {
-            return options.last() == name;
-        }
-    }
-
-    QString getChoiceOptionValue(QString name) const
-    {
-        if (!m_Choices[name].contains(value(name), Qt::CaseInsensitive)) {
-            showError(QString("Invalid %1 choice: %2").arg(name, value(name)));
-        }
-        return value(name);
-    }
-
-    QPair<int,int> getResolutionOptionValue(QString name) const
-    {
-        QRegularExpression re("^(\\d+)x(\\d+)$", QRegularExpression::CaseInsensitiveOption);
-        auto match = re.match(value(name));
-        if (!match.hasMatch()) {
-            showError(QString("Invalid %1 format: %2").arg(name, value(name)));
-        }
-        return qMakePair(match.captured(1).toInt(), match.captured(2).toInt());
-    }
-
-    void addFlagOption(QString name, QString descriptiveName)
-    {
-        addOption(QCommandLineOption(name, QString("Use %1.").arg(descriptiveName)));
-    }
-
-    void addToggleOption(QString name, QString descriptiveName)
-    {
-        addOption(QCommandLineOption(name, QString("Use %1.").arg(descriptiveName)));
-        addOption(QCommandLineOption("no-" + name, QString("Do not use %1.").arg(descriptiveName)));
-    }
-
-    void addValueOption(QString name, QString descriptiveName)
-    {
-        addOption(QCommandLineOption(name, QString("Specify %1 to use.").arg(descriptiveName), name));
-    }
-
-    void addChoiceOption(QString name, QString descriptiveName, QStringList choices)
-    {
-        addOption(QCommandLineOption(name, QString("Select %1: %2.").arg(descriptiveName, choices.join('/')), name));
-        m_Choices[name] = choices;
-    }
-
-private:
-    QMap<QString, QStringList> m_Choices;
-};
-
-GlobalCommandLineParser::GlobalCommandLineParser()
-{
-}
-
-GlobalCommandLineParser::~GlobalCommandLineParser()
-{
-}
-
-GlobalCommandLineParser::ParseResult GlobalCommandLineParser::parse(const QStringList &args)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "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."
-    );
-    parser.addPositionalArgument("action", "Action to execute", "<action>");
-    parser.parse(args);
-    auto posArgs = parser.positionalArguments();
-    QString action = posArgs.isEmpty() ? QString() : posArgs.first().toLower();
-
-    if (action == "") {
-        // This method will not return and terminates the process if --version
-        // or --help is specified
-        parser.handleHelpAndVersionOptions();
-        parser.handleUnknownOptions();
-        return NormalStartRequested;
-    } else if (action == "quit") {
-        return QuitRequested;
-    } else if (action == "stream") {
-        return StreamRequested;
-    } else {
-        parser.showError(QString("Invalid action: %1").arg(action));
-    }
-}
-
-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 = {
-        {"fullscreen", StreamingPreferences::WM_FULLSCREEN},
-        {"windowed",   StreamingPreferences::WM_WINDOWED},
-        {"borderless", StreamingPreferences::WM_FULLSCREEN_DESKTOP},
-    };
-    m_AudioConfigMap = {
-        {"stereo",       StreamingPreferences::AC_STEREO},
-        {"5.1-surround", StreamingPreferences::AC_51_SURROUND},
-    };
-    m_VideoCodecMap = {
-        {"auto",  StreamingPreferences::VCC_AUTO},
-        {"H.264", StreamingPreferences::VCC_FORCE_H264},
-        {"HEVC",  StreamingPreferences::VCC_FORCE_HEVC},
-    };
-    m_VideoDecoderMap = {
-        {"auto",     StreamingPreferences::VDS_AUTO},
-        {"software", StreamingPreferences::VDS_FORCE_HARDWARE},
-        {"hardware", StreamingPreferences::VDS_FORCE_SOFTWARE},
-    };
-}
-
-StreamCommandLineParser::~StreamCommandLineParser()
-{
-}
-
-void StreamCommandLineParser::parse(const QStringList &args, StreamingPreferences *preferences)
-{
-    CommandLineParser parser;
-    parser.setupCommonOptions();
-    parser.setApplicationDescription(
-        "\n"
-        "Starts directly streaming a given app."
-    );
-    parser.addPositionalArgument("stream", "Start stream");
-
-    // Add other arguments and options
-    parser.addPositionalArgument("host", "Host computer name, UUID, or IP address", "<host>");
-    parser.addPositionalArgument("app", "App to stream", "\"<app>\"");
-
-    parser.addFlagOption("720",  "1280x720 resolution");
-    parser.addFlagOption("1080", "1920x1080 resolution");
-    parser.addFlagOption("1440", "2560x1440 resolution");
-    parser.addFlagOption("4K", "3840x2160 resolution");
-    parser.addValueOption("resolution", "custom <width>x<height> resolution");
-    parser.addToggleOption("vsync", "V-Sync");
-    parser.addValueOption("fps", "FPS");
-    parser.addValueOption("bitrate", "bitrate in Kbps");
-    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());
-
-    if (!parser.parse(args)) {
-        parser.showError(parser.errorText());
-    }
-
-    parser.handleUnknownOptions();
-
-    // Resolve display's width and height
-    QRegularExpression resolutionRexExp("^(720|1080|1440|4K|resolution)$");
-    QStringList resoOptions = parser.optionNames().filter(resolutionRexExp);
-    bool displaySet = resoOptions.length();
-    if (displaySet) {
-        QString name = resoOptions.last();
-        if (name == "720") {
-            preferences->width  = 1280;
-            preferences->height = 720;
-            displaySet = true;
-        } else if (name == "1080") {
-            preferences->width  = 1920;
-            preferences->height = 1080;
-            displaySet = true;
-        } else if (name == "1440") {
-            preferences->width  = 2560;
-            preferences->height = 1440;
-            displaySet = true;
-        } else if (name == "4K") {
-            preferences->width  = 3840;
-            preferences->height = 2160;
-            displaySet = true;
-        } else if (name == "resolution") {
-            auto resolution = parser.getResolutionOptionValue(name);
-            preferences->width  = resolution.first;
-            preferences->height = resolution.second;
-        }
-    }
-
-    // Resolve --fps option
-    if (parser.isSet("fps")) {
-        preferences->fps = parser.getIntOption("fps");
-        if (!inRange(preferences->fps, 30, 120)) {
-            parser.showError("FPS must be in range: 30 - 120");
-        }
-    }
-
-    // Resolve --bitrate option
-    if (parser.isSet("bitrate")) {
-        preferences->bitrateKbps = parser.getIntOption("bitrate");
-        if (!inRange(preferences->bitrateKbps, 500, 150000)) {
-            parser.showError("Bitrate must be in range: 500 - 150000");
-        }
-    } else if (displaySet || parser.isSet("fps")) {
-        preferences->bitrateKbps = preferences->getDefaultBitrate(
-            preferences->width, preferences->height, preferences->fps);
-    }
-
-    // Resolve --display option
-    if (parser.isSet("display-mode")) {
-        preferences->windowMode = mapValue(m_WindowModeMap, parser.getChoiceOptionValue("display-mode"));
-    }
-
-    // Resolve --vsync and --no-vsync options
-    preferences->enableVsync = parser.getToggleOptionValue("vsync", preferences->enableVsync);
-
-    // Resolve --audio-config option
-    if (parser.isSet("audio-config")) {
-        preferences->audioConfig = mapValue(m_AudioConfigMap, parser.getChoiceOptionValue("audio-config"));
-    }
-
-    // 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);
-
-    // Resolve --game-optimization and --no-game-optimization options
-    preferences->gameOptimizations = parser.getToggleOptionValue("game-optimization", preferences->gameOptimizations);
-
-    // 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"));
-    }
-
-    // Resolve --video-decoder option
-    if (parser.isSet("video-decoder")) {
-        preferences->videoDecoderSelection = mapValue(m_VideoDecoderMap, parser.getChoiceOptionValue("video-decoder"));
-    }
-
-    // This method will not return and terminates the process if --version or
-    // --help is specified
-    parser.handleHelpAndVersionOptions();
-
-    // Verify that both host and app has been provided
-    auto posArgs = parser.positionalArguments();
-    if (posArgs.length() < 2) {
-        parser.showError("Host not provided");
-    }
-    m_Host = parser.positionalArguments().at(1);
-
-    if (posArgs.length() < 3) {
-        parser.showError("App not provided");
-    }
-    m_AppName = parser.positionalArguments().at(2);
-}
-
-QString StreamCommandLineParser::getHost() const
-{
-    return m_Host;
-}
-
-QString StreamCommandLineParser::getAppName() const
-{
-    return m_AppName;
-}

app/cli/commandlineparser.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include "settings/streamingpreferences.h"
-
-#include <QMap>
-#include <QString>
-
-class GlobalCommandLineParser
-{
-public:
-    enum ParseResult {
-        NormalStartRequested,
-        StreamRequested,
-        QuitRequested,
-    };
-
-    GlobalCommandLineParser();
-    virtual ~GlobalCommandLineParser();
-
-    ParseResult parse(const QStringList &args);
-
-};
-
-class QuitCommandLineParser
-{
-public:
-    QuitCommandLineParser();
-    virtual ~QuitCommandLineParser();
-
-    void parse(const QStringList &args);
-
-    QString getHost() const;
-
-private:
-    QString m_Host;
-};
-
-class StreamCommandLineParser
-{
-public:
-    StreamCommandLineParser();
-    virtual ~StreamCommandLineParser();
-
-    void parse(const QStringList &args, StreamingPreferences *preferences);
-
-    QString getHost() const;
-    QString getAppName() const;
-
-private:
-    QString m_Host;
-    QString m_AppName;
-    QMap<QString, StreamingPreferences::WindowMode> m_WindowModeMap;
-    QMap<QString, StreamingPreferences::AudioConfig> m_AudioConfigMap;
-    QMap<QString, StreamingPreferences::VideoCodecConfig> m_VideoCodecMap;
-    QMap<QString, StreamingPreferences::VideoDecoderSelection> m_VideoDecoderMap;
-};

app/cli/quitstream.cpp

@@ -1,171 +0,0 @@
-#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);
-}
-
-}

app/cli/quitstream.h

@@ -1,40 +0,0 @@
-#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;
-};
-
-}

app/cli/startstream.cpp

@@ -1,256 +0,0 @@
-#include "startstream.h"
-#include "backend/computermanager.h"
-#include "backend/computerseeker.h"
-#include "streaming/session.h"
-
-#include <QCoreApplication>
-#include <QTimer>
-
-#define COMPUTER_SEEK_TIMEOUT 10000
-#define APP_SEEK_TIMEOUT 10000
-
-namespace CliStartStream
-{
-
-enum State {
-    StateInit,
-    StateSeekComputer,
-    StateSeekApp,
-    StateStartSession,
-    StateFailure,
-};
-
-class Event
-{
-public:
-    enum Type {
-        AppQuitCompleted,
-        AppQuitRequested,
-        ComputerFound,
-        ComputerUpdated,
-        Executed,
-        Timedout,
-    };
-
-    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);
-        Session* session;
-        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_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);
-                q->connect(m_ComputerManager, &ComputerManager::quitAppCompleted,
-                           q, &Launcher::onQuitAppCompleted);
-
-                emit q->searchingComputer();
-            }
-            break;
-        // Occurs when searched computer is found
-        case Event::ComputerFound:
-            if (m_State == StateSeekComputer) {
-                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;
-                        session = new Session(m_Computer, app, m_Preferences);
-                        emit q->sessionCreated(app.name, session);
-                    } else {
-                        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;
-                emit q->failed(QString("Failed to connect to %1").arg(m_ComputerName));
-            }
-            if (m_State == StateSeekApp) {
-                m_State = StateFailure;
-                emit q->failed(QString("Failed to find application %1").arg(m_AppName));
-            }
-            break;
-        }
-    }
-
-    int getAppIndex() const
-    {
-        for (int i = 0; i < m_Computer->appList.length(); i++) {
-            if (m_Computer->appList[i].name.toLower() == m_AppName.toLower()) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    bool isNotStreaming() const
-    {
-        return m_Computer->currentGameId == 0;
-    }
-
-    bool isStreamingApp(NvApp app) const
-    {
-        return m_Computer->currentGameId == app.id;
-    }
-
-    QString getCurrentAppName() const
-    {
-        for (NvApp app : m_Computer->appList) {
-            if (m_Computer->currentGameId == app.id) {
-                return app.name;
-            }
-        }
-        return "<UNKNOWN>";
-    }
-
-    Launcher *q_ptr;
-    QString m_ComputerName;
-    QString m_AppName;
-    StreamingPreferences *m_Preferences;
-    ComputerManager *m_ComputerManager;
-    ComputerSeeker *m_ComputerSeeker;
-    NvComputer *m_Computer;
-    State m_State;
-    QTimer *m_TimeoutTimer;
-};
-
-Launcher::Launcher(QString computer, QString app,
-                   StreamingPreferences* preferences, QObject *parent)
-    : QObject(parent),
-      m_DPtr(new LauncherPrivate(this))
-{
-    Q_D(Launcher);
-    d->m_ComputerName = computer;
-    d->m_AppName = app;
-    d->m_Preferences = preferences;
-    d->m_State = StateInit;
-    d->m_TimeoutTimer = new QTimer(this);
-    d->m_TimeoutTimer->setSingleShot(true);
-    connect(d->m_TimeoutTimer, &QTimer::timeout,
-            this, &Launcher::onTimeout);
-}
-
-Launcher::~Launcher()
-{
-}
-
-void Launcher::execute(ComputerManager *manager)
-{
-    Q_D(Launcher);
-    Event event(Event::Executed);
-    event.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);
-    Event event(Event::ComputerUpdated);
-    event.computer = computer;
-    d->handleEvent(event);
-}
-
-void Launcher::onTimeout()
-{
-    Q_D(Launcher);
-    Event event(Event::Timedout);
-    d->handleEvent(event);
-}
-
-void Launcher::onQuitAppCompleted(QVariant error)
-{
-    Q_D(Launcher);
-    Event event(Event::AppQuitCompleted);
-    event.errorMessage = error.toString();
-    d->handleEvent(event);
-}
-
-}

app/cli/startstream.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <QObject>
-#include <QVariant>
-
-class ComputerManager;
-class NvComputer;
-class Session;
-class StreamingPreferences;
-
-namespace CliStartStream
-{
-
-class Event;
-class LauncherPrivate;
-
-class Launcher : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE_D(m_DPtr, Launcher)
-
-public:
-    explicit Launcher(QString computer, QString app,
-                      StreamingPreferences* preferences,
-                      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;
-};
-
-}

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

@@ -1,340 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<component type="desktop">
-	<id>com.moonlight_stream.Moonlight</id>
-	<metadata_license>CC0-1.0</metadata_license>
-	<project_license>GPL-3.0+</project_license>
-	<name>Moonlight</name>
-	<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>
-		<p>Features include:</p>
-		<ul>
-			<li>Streaming at up to 4K resolution</li>
-			<li>Support for up to 120 FPS streaming (high refresh rate monitor recommended)</li>
-			<li>Hardware accelerated video decoding with VAAPI and VDPAU support</li>
-			<li>5.1 surround sound audio support</li>
-			<li>HEVC support for better video compression efficiency</li>
-			<li>Gamepad support with force feedback for up to 4 players</li>
-		</ul>
-	</description>
-
-	<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.org/appstream_resources/moonlight_screenshot_1.png</image>
-		</screenshot>
-		<screenshot>
-			<image>https://moonlight-stream.org/appstream_resources/moonlight_screenshot_2.png</image>
-		</screenshot>
-	</screenshots>
-
-	<releases>
-		<release version="0.10.1" date="2019-04-28">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Video performance optimizations</li>
-					<li>VAAPI support on Wayland</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed a crash when attempting to dismiss the connection terminated dialog</li>
-					<li>Fixed a crash when using the overlay on the software decoder</li>
-					<li>Fixed software decoder not displaying output in some cases</li>
-					<li>Fixed some minor UI issues on the PC grid</li>
-					<li>Improved visibility of toolbar highlights</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.10.0" date="2019-04-07">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Redesigned App Grid with larger game artwork and less blank space</li>
-					<li>Redesigned UI dialogs using Material Design</li>
-					<li>Added a connection warning overlay (which can be disabled in settings)</li>
-					<li>Streaming window no longer minimizes when it loses focus in full-screen mode</li>
-					<li>The Steam Link device is now a supported platform</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed several bugs that could cause UI hangs or lag</li>
-					<li>Fixed rumble support on gamepads with limited rumble motor control</li>
-					<li>Fixed increased memory usage if the software renderer gets delayed</li>
-					<li>Fixed crashes on certain desktop configurations when loading the UI</li>
-					<li>Fixed handling of pairing certificates with a bogus date</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.9.1" date="2019-02-17">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added gamepad rumble support</li>
-					<li>Added a dedicated quit button to the running app tile</li>
-					<li>Reduced video latency on Windows and Linux</li>
-					<li>Added a performance overlay for software decoding</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed delayed first video frame with GFE 3.17</li>
-					<li>Fixed erroneously setting host resolution to 720p in certain configurations</li>
-					<li>The connection termination dialog is no longer displayed for intentional termination</li>
-					<li>Fixed some gamepads only functioning for UI navigation and not in game</li>
-					<li>Fixed audio latency increasing when switching audio devices</li>
-					<li>Fixed VDPAU scaling behavior on AMD cards</li>
-					<li>Fixed several bugs in gamepad navigation behavior</li>
-					<li>Work around a bug in QGnomePlatform that breaks dialog rendering on Linux</li>
-					<li>Updated included SDL gamepad mappings</li>
-					<li>Fixed hotkey behavior on non-latin keyboards</li>
-					<li>Fixed incorrect frame drop percentages in debug stats</li>
-				</ul>
-			</description>
-		</release>
-		<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>
-				<ul>
-					<li>Added keyboard and gamepad UI navigation</li>
-					<li>Added support for mouse X1 and X2 buttons (back and forward)</li>
-					<li>Added support for mouse movement with touchscreens</li>
-					<li>Improved HEVC performance at high bitrates</li>
-					<li>Added support for launching streaming sessions directly from a terminal or script</li>
-					<li>Added quit shortcut for gamepads: Select+Start+L1+R1</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed not saving deletion of PCs</li>
-					<li>Fixed keys being stuck down on the host PC after Moonlight loses focus or quits</li>
-					<li>Fixed some warning dialogs being stuck behind the UI window</li>
-					<li>Updated included gamepad mapping list</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.5.0" date="2018-09-15">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added option to enable mouse acceleration for remote desktop usage</li>
-					<li>Added option to disable automatic PC discovery</li>
-					<li>Added gamepad mappings from gabomdq's SDL_GameControllerDB</li>
-					<li>Added help links to error dialogs</li>
-					<li>Added quit shortcut tip to stream loading page</li>
-					<li>Restored the autodetect audio configuration option</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed quit app dialog starting the wrong app</li>
-					<li>Fixed very high input lag on GFE 3.14.0 and earlier</li>
-					<li>Fixed sending errant mouse click when capturing the mouse</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.4.0" date="2018-09-08">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Added option to enable (unsupported) 90/120 FPS streaming on 60 Hz monitors</li>
-					<li>Added refresh rate matching for better frame pacing on high refresh rate monitors</li>
-					<li>The streaming window now appears on the same monitor the UI was displayed on</li>
-					<li>The streaming window is now centered on the target monitor</li>
-					<li>Display a dialog when the connection is terminated by the remote PC</li>
-					<li>Added option to select between full-screen exclusive and borderless windowed mode</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed streaming with no audio device</li>
-					<li>Fixed mouse lag with some high polling rate mice</li>
-					<li>Improved UI performance on the app grid page</li>
-					<li>1440p and 4K 120 FPS performance is improved to avoid encoder bottlenecks</li>
-					<li>Autodetect audio configuration option removed because it was broken</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.3.0" date="2018-08-21">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Reduced power consumption when the app is minimized</li>
-					<li>Fixed malformed asset requests being sent when the first host in the grid is offline</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.2.0" date="2018-08-12">
-			<description>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Fixed functionality of '=', 'Numpad Dot', and 'Numpad Enter' keys</li>
-					<li>Fixed uninitialized variable causing strange gamepad behavior</li>
-					<li>Added a warning for incompatible configs and decoder failures</li>
-					<li>Added a warning for Wayland performance issues</li>
-					<li>Stopped capturing the mouse by default for windowed streams</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.1.0" date="2018-08-05">
-			<description>
-				<p>New features:</p>
-				<ul>
-					<li>Allow streaming at the client's native resolution</li>
-					<li>VDPAU hardware decoding support for NVIDIA GPUs</li>
-					<li>Updated UI to replace status text with icons</li>
-					<li>Stream window is now resizable</li>
-					<li>Display warnings during game launch for configuration issues</li>
-				</ul>
-				<p>Bugfixes:</p>
-				<ul>
-					<li>Gamepad input now works even if the app doesn't have focus</li>
-					<li>Fixed streaming black screen if the host supported HEVC but the client didn't</li>
-					<li>Fixed broken video scaling causing extra stretching and off-center video</li>
-					<li>Fixed gamepad input issue causing some Y axis inputs to be reversed</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.0.5" date="2018-08-01">
-			<description>
-				<p>Changes from 0.0.4:</p>
-				<ul>
-					<li>Fixed a bug causing increased frame drops and input lag</li>
-					<li>Added support for quitting running games</li>
-					<li>Added support for waking sleeping PCs with Wake-on-LAN</li>
-					<li>Increased the FPS limit to 120 FPS</li>
-				</ul>
-			</description>
-		</release>
-		<release version="0.0.4a" date="2018-07-30">
-			<description>
-				<p>Initial pre-alpha release for Linux. Please file bugs!</p>
-			</description>
-		</release>
-	</releases>
-
-	<categories>
-		<category>Game</category>
-		<category>Qt</category>
-	</categories>
-
-	<developer_name>Moonlight Game Streaming Team</developer_name>
-	<update_contact>cameron@moonlight-stream.org</update_contact>
-
-	<launchable type="desktop-id">com.moonlight_stream.Moonlight.desktop</launchable>
-
-	<provides>
-		<binary>moonlight</binary>
-	</provides>
-
-	<content_rating type="oars-1.0" />
-</component>

app/deploy/linux/com.moonlight_stream.Moonlight.desktop

@@ -1,9 +0,0 @@
-[Desktop Entry]
-Name=Moonlight
-Comment=Stream games from your NVIDIA GameStream-enabled PC
-Exec=moonlight
-Icon=moonlight
-Terminal=false
-Type=Application
-Categories=Qt;Game;
-Keywords=nvidia;gamestream;stream;

app/deploy/steamlink/moonlight.sh

@@ -1,13 +0,0 @@
-#!/bin/sh
-
-# The default HOME is not persistent, so override
-# it to a path on the onboard flash. Otherwise our
-# pairing data will be lost each reboot.
-HOME=/usr/local/moonlight
-
-# Renice PE_Single_CPU which seems to host A/V stuff
-renice -10 -p $(pidof PE_Single_CPU)
-
-# Renice Moonlight itself to avoid preemption by background tasks
-# Write output to a logfile in /tmp
-exec nice -n -10 ./bin/moonlight > /tmp/moonlight.log

app/deploy/steamlink/toc.txt

@@ -1,3 +0,0 @@
-name=Moonlight
-icon=moonlight.png
-run=moonlight.sh

app/gui/AppView.qml

@@ -2,41 +2,40 @@ import QtQuick 2.9
 import QtQuick.Controls 2.2
 
 import AppModel 1.0
+
 import ComputerManager 1.0
 
-CenteredGridView {
+GridView {
     property int computerIndex
     property AppModel appModel : createModel()
-    property bool activated
 
     id: appGrid
+    anchors.fill: parent
+    anchors.leftMargin: (parent.width % (cellWidth + anchors.rightMargin)) / 2
+    anchors.topMargin: 5
+    anchors.rightMargin: 5
+    anchors.bottomMargin: 5
+    cellWidth: 225; cellHeight: 350;
     focus: true
-    activeFocusOnTab: true
-    topMargin: 20
-    bottomMargin: 5
-    cellWidth: 230; cellHeight: 297;
 
-    function computerLost()
-    {
-        // Go back to the PC view on PC loss
-        stackView.pop()
-    }
+    // Cache delegates for 1000px in both directions to improve
+    // scrolling and resizing performance
+    cacheBuffer: 1000
 
-    Component.onCompleted: {
-        // Don't show any highlighted item until interacting with them.
-        // We do this here instead of onActivated to avoid losing the user's
-        // selection when backing out of a different page of the app.
-        currentIndex = -1
-    }
+    // 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
 
-    StackView.onActivated: {
-        appModel.computerLost.connect(computerLost)
-        activated = true
-    }
-
-    StackView.onDeactivating: {
-        appModel.computerLost.disconnect(computerLost)
-        activated = false
+    onVisibleChanged: {
+        if (visible) {
+            // Start polling when this view is shown
+            ComputerManager.startPolling()
+        }
+        else {
+            // Stop polling when this view is not on top
+            ComputerManager.stopPollingAsync()
+        }
     }
 
     function createModel()
@@ -48,225 +47,60 @@ CenteredGridView {
 
     model: appModel
 
-    delegate: NavigableItemDelegate {
-        width: 220; height: 287;
-        grid: appGrid
+    delegate: Item {
+        width: 200; height: 300;
+
+        Component.onCompleted: {
+            if (model.running) {
+                appNameText.text = "<font color=\"green\">Running</font><font color=\"white\"> - </font>" + appNameText.text
+            }
+        }
 
         Image {
-            property bool isPlaceholder: false
-
             id: appIcon
-            anchors.horizontalCenter: parent.horizontalCenter
-            y: 10
+            anchors.horizontalCenter: parent.horizontalCenter;
             source: model.boxart
-
-            onSourceSizeChanged: {
-                if ((sourceSize.width == 130 && sourceSize.height == 180) || // GFE 2.0 placeholder image
-                    (sourceSize.width == 628 && sourceSize.height == 888) || // GFE 3.0 placeholder image
-                    (sourceSize.width == 200 && sourceSize.height == 266))   // Our no_app_image.png
-                {
-                    isPlaceholder = true
-                }
-                else
-                {
-                    isPlaceholder = false
-                }
-
-                width = 200
-                height = 267
+            sourceSize {
+                width: 150
+                height: 200
             }
-
-            // 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) && (!appNameText.visible || appNameText.truncated)
         }
 
-        ToolButton {
-            id: resumeButton
-            anchors.horizontalCenterOffset: appIcon.isPlaceholder ? -47 : 0
-            anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : -60
-            anchors.centerIn: appIcon
-            visible: model.running
-            implicitWidth: 125
-            implicitHeight: 125
-
-            Image {
-                source: "qrc:/res/baseline-play_circle_filled_white-48px.svg"
-                anchors.centerIn: parent
-                sourceSize {
-                    width: 75
-                    height: 75
-                }
-            }
-
-            onClicked: {
-                launchOrResumeSelectedApp()
-            }
-
-            ToolTip.text: "Resume Game"
-            ToolTip.delay: 1000
-            ToolTip.timeout: 3000
-            ToolTip.visible: hovered
-        }
-
-        ToolButton {
-            id: quitButton
-            anchors.horizontalCenterOffset: appIcon.isPlaceholder ? 47 : 0
-            anchors.verticalCenterOffset: appIcon.isPlaceholder ? -75 : 60
-            anchors.centerIn: appIcon
-            visible: model.running
-            implicitWidth: 125
-            implicitHeight: 125
-
-            Image {
-                source: "qrc:/res/baseline-cancel-24px.svg"
-                anchors.centerIn: parent
-                sourceSize {
-                    width: 75
-                    height: 75
-                }
-            }
-
-            onClicked: {
-                doQuitGame()
-            }
-
-            ToolTip.text: "Quit Game"
-            ToolTip.delay: 1000
-            ToolTip.timeout: 3000
-            ToolTip.visible: hovered
-        }
-
-        Label {
+        Text {
             id: appNameText
-            visible: appIcon.isPlaceholder
             text: model.name
-            width: appIcon.width
-            height: model.running ? 175 : appIcon.height
-            anchors.left: appIcon.left
-            anchors.right: appIcon.right
-            anchors.bottom: appIcon.bottom
-            font.pointSize: 22
-            verticalAlignment: Text.AlignVCenter
+            color: "white"
+
+            width: parent.width
+            height: 100
+            anchors.top: appIcon.bottom
+            font.pointSize: 26
             horizontalAlignment: Text.AlignHCenter
             wrapMode: Text.Wrap
-            elide: Text.ElideRight
         }
 
-        function launchOrResumeSelectedApp()
-        {
-            var runningIndex = appModel.getRunningAppIndex()
-            if (runningIndex >= 0 && runningIndex !== index) {
-                quitAppDialog.appName = appModel.getRunningAppName()
-                quitAppDialog.segueToStream = true
-                quitAppDialog.nextAppName = model.name
-                quitAppDialog.nextAppIndex = index
-                quitAppDialog.open()
-                return
-            }
+        MouseArea {
+            anchors.fill: parent
+            onClicked: {
+                // TODO: Check if a different game is running
 
-            var component = Qt.createComponent("StreamSegue.qml")
-            var segue = component.createObject(stackView, {"appName": model.name, "session": appModel.createSessionForApp(index)})
-            stackView.push(segue)
-        }
-
-        onClicked: {
-            // Only allow clicking on the box art for non-running games.
-            // For running games, buttons will appear to resume or quit which
-            // will handle starting the game and clicks on the box art will
-            // be ignored.
-            if (!model.running) {
-                launchOrResumeSelectedApp()
+                var component = Qt.createComponent("StreamSegue.qml")
+                var segue = component.createObject(stackView)
+                segue.appname = model.name
+                segue.session = appModel.createSessionForApp(index)
+                stackView.push(segue)
             }
         }
-
-        Keys.onReturnPressed: {
-            // Open the app context menu if activated via the gamepad or keyboard
-            // for running games. If the game isn't running, the above onClicked
-            // method will handle the launch.
-            if (model.running) {
-                // This will be keyboard/gamepad driven so use
-                // open() instead of popup()
-                appContextMenu.open()
-            }
-        }
-
-        Keys.onMenuPressed: {
-            if (model.running) {
-                // This will be keyboard/gamepad driven so use
-                // open() instead of popup()
-                appContextMenu.open()
-            }
-        }
-
-        function doQuitGame() {
-            quitAppDialog.appName = appModel.getRunningAppName()
-            quitAppDialog.segueToStream = false
-            quitAppDialog.open()
-        }
-
-        NavigableMenu {
-            id: appContextMenu
-            NavigableMenuItem {
-                parentMenu: appContextMenu
-                text: model.running ? "Resume Game" : "Launch Game"
-                onTriggered: launchOrResumeSelectedApp()
-            }
-            NavigableMenuItem {
-                parentMenu: appContextMenu
-                text: "Quit Game"
-                onTriggered: doQuitGame()
-                visible: model.running
-            }
-        }
-    }
-
-    NavigableMessageDialog {
-        id: quitAppDialog
-        property string appName : ""
-        property bool segueToStream : false
-        property string nextAppName: ""
-        property int nextAppIndex: 0
-        text:"Are you sure you want to quit " + appName +"? Any unsaved progress will be lost."
-        standardButtons: Dialog.Yes | Dialog.No
-
-        function quitApp() {
-            var component = Qt.createComponent("QuitSegue.qml")
-            var params = {"appName": appName}
-            if (segueToStream) {
-                // Store the session and app name if we're going to stream after
-                // successfully quitting the old app.
-                params.nextAppName = nextAppName
-                params.nextSession = appModel.createSessionForApp(nextAppIndex)
-            }
-            else {
-                params.nextAppName = null
-                params.nextSession = null
-            }
-
-            stackView.push(component.createObject(stackView, params))
-
-            // Trigger the quit after pushing the quit segue on screen
-            appModel.quitRunningApp()
-        }
-
-        onAccepted: quitApp()
     }
 
     ScrollBar.vertical: ScrollBar {
-        // Manually hide the scrollbar to prevent it from being drawn on top
-        // of the StreamSegue during the transition. It can sometimes get stuck
-        // there since we're not consistently pumping the event loop while
-        // starting the stream.
-        visible: activated
-
         parent: appGrid.parent
         anchors {
-            top: parent.top
-            right: parent.right
-            bottom: parent.bottom
+            top: appGrid.top
+            left: appGrid.right
+            bottom: appGrid.bottom
+
+            leftMargin: -10
         }
     }
 }

app/gui/AutoResizingComboBox.qml

@@ -1,31 +0,0 @@
-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
-ComboBox {
-    property int textWidth
-
-    implicitWidth: leftPadding + textWidth + indicator.width + rightPadding
-
-    TextMetrics {
-        id: popupMetrics
-    }
-
-    TextMetrics {
-        id: textMetrics
-    }
-
-    // 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)
-            popupMetrics.text = textAt(i)
-            textWidth = Math.max(textMetrics.width, textWidth)
-            textWidth = Math.max(popupMetrics.width, textWidth)
-        }
-    }
-}

app/gui/CenteredGridView.qml

@@ -1,41 +0,0 @@
-import QtQuick 2.9
-import QtQuick.Controls 2.2
-
-GridView {
-    // Detect Qt 5.11 or earlier using presence of synchronousDrag.
-    // Prior to 5.12, the leftMargin and rightMargin values did not work.
-    property bool hasBrokenMargins: this.synchronousDrag === undefined
-
-    property int minMargin: 10
-    property real availableWidth: (parent.width - 2 * minMargin)
-    property int itemsPerRow: availableWidth / cellWidth
-    property real horizontalMargin: itemsPerRow < count && availableWidth >= cellWidth ?
-                                        (availableWidth % cellWidth) / 2 : minMargin
-
-    function updateMargins() {
-        leftMargin = horizontalMargin
-        rightMargin = horizontalMargin
-
-        if (hasBrokenMargins) {
-            anchors.leftMargin = leftMargin
-            anchors.rightMargin = rightMargin
-        }
-    }
-
-    onHorizontalMarginChanged: {
-        updateMargins()
-    }
-
-    Component.onCompleted: {
-        if (hasBrokenMargins) {
-            // This will cause an anchor conflict with the parent StackView
-            // which breaks animation, but otherwise the grid will not be
-            // centered in the window.
-            anchors.fill = parent
-            anchors.topMargin = topMargin
-            anchors.bottomMargin = bottomMargin
-        }
-
-        updateMargins()
-    }
-}

app/gui/CliQuitStreamSegue.qml

@@ -1,57 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-import Session 1.0
-
-Item {
-    function onSearchingComputer() {
-        stageLabel.text = "Establishing connection to PC..."
-    }
-
-    function onQuittingApp() {
-        stageLabel.text = "Quitting app..."
-    }
-
-    function onFailure(message) {
-        errorDialog.text = message
-        errorDialog.open()
-    }
-
-    StackView.onActivated: {
-        if (!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
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-
-        onClosed: {
-            Qt.quit()
-        }
-    }
-}

app/gui/CliStartStreamSegue.qml

@@ -1,90 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-
-Item {
-    function onSearchingComputer() {
-        stageLabel.text = "Establishing connection to PC..."
-    }
-
-    function onSearchingApp() {
-        stageLabel.text = "Loading app list..."
-    }
-
-    function onSessionCreated(appName, session) {
-        var component = Qt.createComponent("StreamSegue.qml")
-        var segue = component.createObject(stackView, {
-            "appName": appName,
-            "session": session,
-            "quitAfter": true
-        })
-        stackView.push(segue)
-    }
-
-    function onLaunchFailed(message) {
-        errorDialog.text = message
-        errorDialog.open()
-    }
-
-    function onAppQuitRequired(appName) {
-        quitAppDialog.appName = appName
-        quitAppDialog.open()
-    }
-
-    StackView.onActivated: {
-        if (!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)
-        }
-    }
-
-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-
-        BusyIndicator {
-            id: stageSpinner
-        }
-
-        Label {
-            id: stageLabel
-            height: stageSpinner.height
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-
-            wrapMode: Text.Wrap
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-
-        onClosed: {
-            Qt.quit();
-        }
-    }
-
-    NavigableMessageDialog {
-        id: quitAppDialog
-        text:"Are you sure you want to quit " + appName +"? Any unsaved progress will be lost."
-        standardButtons: Dialog.Yes | Dialog.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()
-        }
-
-        onAccepted: quitApp()
-        onRejected: Qt.quit()
-    }
-}

app/gui/ErrorMessageDialog.qml

@@ -1,8 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import SystemProperties 1.0
-
-NavigableMessageDialog {
-    standardButtons: Dialog.Ok | (SystemProperties.hasBrowser ? Dialog.Help : 0)
-}

app/gui/NavigableDialog.qml

@@ -1,17 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-Dialog {
-    parent: overlay
-
-    x: Math.round((parent.width - width) / 2)
-    y: Math.round((parent.height - height) / 2)
-
-    onAboutToHide: {
-        // We must force focus back to the last item for platforms without
-        // support for more than one active window like Steam Link. If
-        // we don't, gamepad and keyboard navigation will break after a
-        // dialog appears.
-        stackView.forceActiveFocus()
-    }
-}

app/gui/NavigableItemDelegate.qml

@@ -1,24 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-ItemDelegate {
-    property GridView grid
-
-    highlighted: grid.activeFocus && grid.currentItem === this
-
-    Keys.onLeftPressed: {
-        grid.moveCurrentIndexLeft()
-    }
-    Keys.onRightPressed: {
-        grid.moveCurrentIndexRight()
-    }
-    Keys.onDownPressed: {
-        grid.moveCurrentIndexDown()
-    }
-    Keys.onUpPressed: {
-        grid.moveCurrentIndexUp()
-    }
-    Keys.onReturnPressed: {
-        clicked()
-    }
-}

app/gui/NavigableMenu.qml

@@ -1,8 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-Menu {
-    onOpened: {
-        itemAt(0).forceActiveFocus(Qt.TabFocusReason)
-    }
-}

app/gui/NavigableMenuItem.qml

@@ -1,28 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-MenuItem {
-    // Qt 5.10 has a menu property, but we need to support 5.9
-    // so we must make our own.
-    property Menu parentMenu
-
-    // Ensure focus can't be given to an invisible item
-    enabled: visible
-    height: visible ? implicitHeight : 0
-    focusPolicy: visible ? Qt.TabFocus : Qt.NoFocus
-
-    onTriggered: {
-        // We must close the context menu first or
-        // it can steal focus from any dialogs that
-        // onTriggered may spawn.
-        parentMenu.close()
-    }
-
-    Keys.onReturnPressed: {
-        triggered()
-    }
-
-    Keys.onEscapePressed: {
-        parentMenu.close()
-    }
-}

app/gui/NavigableMessageDialog.qml

@@ -1,65 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-import QtQuick.Layouts 1.2
-
-NavigableDialog {
-    id: dialog
-
-    property alias text: dialogLabel.dialogText
-
-    property string helpText
-    property string helpUrl : "https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting"
-    property string helpTextSeparator : " "
-
-    onOpened: {
-        // Force keyboard focus on the label so keyboard navigation works
-        dialogLabel.forceActiveFocus()
-    }
-
-    RowLayout {
-        spacing: 10
-
-        Image {
-            source: (standardButtons & Dialog.Yes) ?
-                        "qrc:/res/baseline-help_outline-24px.svg" :
-                        "qrc:/res/baseline-error_outline-24px.svg"
-            sourceSize {
-                // The icon should be square so use the height as the width too
-                width: 50
-                height: 50
-            }
-        }
-
-        Label {
-            property string dialogText
-
-            id: dialogLabel
-            text: dialogText + ((helpText && (standardButtons & Dialog.Help)) ? (helpTextSeparator + helpText) : "")
-            wrapMode: Text.Wrap
-            elide: Label.ElideRight
-
-            // Cap the width so the dialog doesn't grow horizontally forever. This
-            // will cause word wrap to kick in.
-            Layout.maximumWidth: 400
-            Layout.maximumHeight: 400
-
-            Keys.onReturnPressed: {
-                accept()
-            }
-
-            Keys.onEscapePressed: {
-                reject()
-            }
-        }
-    }
-
-    footer: DialogButtonBox {
-        id: dialogButtonBox
-        standardButtons: dialog.standardButtons
-
-        onHelpRequested: {
-            Qt.openUrlExternally(helpUrl)
-            close()
-        }
-    }
-}

app/gui/NavigableToolButton.qml

@@ -1,37 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-ToolButton {
-    property string iconSource
-
-    activeFocusOnTab: true
-
-    // FIXME: We're using an Image here rather than icon.source because
-    // icons don't work on Qt 5.9 LTS.
-    Image {
-        id: image
-        source: iconSource
-        anchors.centerIn: parent.background
-        sourceSize {
-            width: parent.background.width * 1.10
-            height: parent.background.height * 1.10
-        }
-    }
-
-    // This determines the size of the Material highlight. We increase it
-    // from the default because we use larger than normal icons for TV readability.
-    background.width: (parent.height - parent.anchors.bottomMargin - parent.anchors.topMargin) * 0.60
-    background.height: (parent.height - parent.anchors.bottomMargin - parent.anchors.topMargin) * 0.60
-
-    Keys.onReturnPressed: {
-        clicked()
-    }
-
-    Keys.onRightPressed: {
-        nextItemInFocusChain(true).forceActiveFocus(Qt.TabFocus)
-    }
-
-    Keys.onLeftPressed: {
-        nextItemInFocusChain(false).forceActiveFocus(Qt.TabFocus)
-    }
-}

app/gui/PcView.qml

@@ -1,36 +1,44 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
+import QtQuick.Dialogs 1.3
+import QtQuick.Layouts 1.3
 
 import ComputerModel 1.0
 
 import ComputerManager 1.0
-import StreamingPreferences 1.0
 
-CenteredGridView {
+GridView {
     property ComputerModel computerModel : createModel()
 
     id: pcGrid
+    anchors.fill: parent
+    anchors.leftMargin: (parent.width % (cellWidth + anchors.rightMargin)) / 2
+    anchors.topMargin: 5
+    anchors.rightMargin: 5
+    anchors.bottomMargin: 5
+    cellWidth: 350; cellHeight: 350;
     focus: true
-    activeFocusOnTab: true
-    topMargin: 20
-    bottomMargin: 5
-    cellWidth: 310; cellHeight: 330;
     objectName: "Computers"
 
-    Component.onCompleted: {
-        // Don't show any highlighted item until interacting with them.
-        // We do this here instead of onActivated to avoid losing the user's
-        // selection when backing out of a different page of the app.
-        currentIndex = -1
-    }
+    // 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
 
-    StackView.onActivated: {
+    Component.onCompleted: {
         // Setup signals on CM
         ComputerManager.computerAddCompleted.connect(addComplete)
     }
 
-    StackView.onDeactivating: {
-        ComputerManager.computerAddCompleted.disconnect(addComplete)
+    onVisibleChanged: {
+        if (visible) {
+            // Start polling when this view is shown
+            ComputerManager.startPolling()
+        }
+        else {
+            // Stop polling when this view is not top-most
+            ComputerManager.stopPollingAsync()
+        }
     }
 
     function pairingComplete(error)
@@ -38,10 +46,12 @@ CenteredGridView {
         // Close the PIN dialog
         pairDialog.close()
 
+        // Start polling again
+        ComputerManager.startPolling()
+
         // Display a failed dialog if we got an error
-        if (error !== undefined) {
+        if (error !== null) {
             errorDialog.text = error
-            errorDialog.helpText = ""
             errorDialog.open()
         }
     }
@@ -49,8 +59,7 @@ CenteredGridView {
     function addComplete(success)
     {
         if (!success) {
-            errorDialog.text = "Unable to connect to the specified PC."
-            errorDialog.helpText = "Click the Help button for possible solutions."
+            errorDialog.text = "Unable to connect to the specified PC. Ensure GameStream is enabled in GeForce Experience."
             errorDialog.open()
         }
     }
@@ -63,197 +72,171 @@ CenteredGridView {
         return model
     }
 
-    Row {
-        anchors.centerIn: parent
-        spacing: 5
-        visible: pcGrid.count === 0
+    model: createModel()
 
-        BusyIndicator {
-            id: searchSpinner
-            visible: StreamingPreferences.enableMdns
-        }
-
-        Label {
-            height: searchSpinner.height
-            elide: Label.ElideRight
-            text: StreamingPreferences.enableMdns ? "Searching for PCs with NVIDIA GameStream enabled..."
-                                                  : "Automatic PC discovery is disabled. Add your PC manually."
-            font.pointSize: 20
-            verticalAlignment: Text.AlignVCenter
-            wrapMode: Text.Wrap
-        }
-    }
-
-    model: computerModel
-
-    delegate: NavigableItemDelegate {
-        width: 300; height: 320;
-        grid: pcGrid
+    delegate: Item {
+        width: 300; height: 300;
 
         Image {
             id: pcIcon
-            anchors.horizontalCenter: parent.horizontalCenter
-            source: "qrc:/res/ic_tv_white_48px.svg"
+            anchors.horizontalCenter: parent.horizontalCenter;
+            source: {
+                model.addPc ? "qrc:/res/ic_add_to_queue_white_48px.svg" : "qrc:/res/ic_tv_white_48px.svg"
+            }
             sourceSize {
                 width: 200
                 height: 200
             }
         }
 
-        Image {
-            // TODO: Tooltip
-            id: stateIcon
-            anchors.horizontalCenter: pcIcon.horizontalCenter
-            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: -10
-            visible: !model.statusUnknown && (!model.online || !model.paired)
-            source: !model.online ? "qrc:/res/baseline-warning-24px.svg" : "qrc:/res/baseline-lock-24px.svg"
-            sourceSize {
-                width: 75
-                height: 75
-            }
-        }
-
-        BusyIndicator {
-            id: statusUnknownSpinner
-            anchors.horizontalCenter: pcIcon.horizontalCenter
-            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: -10
-            width: 75
-            height: 75
-            visible: model.statusUnknown
-        }
-
-        Label {
+        Text {
             id: pcNameText
             text: model.name
+            color: "white"
 
             width: parent.width
             anchors.top: pcIcon.bottom
-            anchors.bottom: parent.bottom
             font.pointSize: 36
             horizontalAlignment: Text.AlignHCenter
             wrapMode: Text.Wrap
-            elide: Text.ElideRight
         }
 
-        NavigableMenu {
-            id: pcContextMenu
-            NavigableMenuItem {
-                parentMenu: pcContextMenu
-                text: "Delete PC"
-                onTriggered: {
-                    deletePcDialog.pcIndex = index
-                    // get confirmation first, actual closing is called from the dialog
-                    deletePcDialog.open()
-                }
-            }
-            NavigableMenuItem {
-                parentMenu: pcContextMenu
-                text: "Wake PC"
-                onTriggered: computerModel.wakeComputer(index)
-                visible: !model.online && model.wakeable
-            }
-        }
-
-        onClicked: {
-            if (model.online) {
-                if (model.paired) {
-                    // go to game view
-                    var component = Qt.createComponent("AppView.qml")
-                    var appView = component.createObject(stackView, {"computerIndex": index, "objectName": model.name})
-                    stackView.push(appView)
-                }
-                else {
-                    if (!model.busy) {
-                        var pin = ("0000" + Math.floor(Math.random() * 10000)).slice(-4)
-
-                        // Kick off pairing in the background
-                        computerModel.pairComputer(index, pin)
-
-                        // Display the pairing dialog
-                        pairDialog.pin = pin
-                        pairDialog.open()
+        Text {
+            function getStatusText(model)
+            {
+                if (model.online) {
+                    var text = "<font color=\"green\">Online</font>"
+                    text += "<font color=\"white\"> - </font>"
+                    if (model.paired) {
+                        text += "<font color=\"skyblue\">Paired</font>"
+                    }
+                    else if (model.busy) {
+                        text += "<font color=\"red\">Busy</font>"
                     }
                     else {
-                        // cannot pair while something is streaming or attempting to pair
-                        errorDialog.text = "You cannot pair while a previous session is still running on the host PC. Quit any running games or reboot the host PC, then try pairing again."
-                        errorDialog.helpText = ""
-                        errorDialog.open()
+                        text += "<font color=\"red\">Not Paired</font>"
                     }
+                    return text
+                }
+                else {
+                    return "<font color=\"red\">Offline</font>";
                 }
-            } else if (!model.online) {
-                // Using open() here because it may be activated by keyboard
-                pcContextMenu.open()
             }
-        }
 
-        onPressAndHold: {
-            // popup() ensures the menu appears under the mouse cursor
-            if (pcContextMenu.popup) {
-                pcContextMenu.popup()
-            }
-            else {
-                // Qt 5.9 doesn't have popup()
-                pcContextMenu.open()
-            }
+            id: pcPairedText
+            text: getStatusText(model)
+            visible: !model.addPc
+
+            width: parent.width
+            anchors.top: pcNameText.bottom
+            font.pointSize: 24
+            horizontalAlignment: Text.AlignHCenter
         }
 
         MouseArea {
             anchors.fill: parent
-            acceptedButtons: Qt.RightButton;
             onClicked: {
-                parent.onPressAndHold()
+                if (model.addPc) {
+                    addPcDialog.open()
+                }
+                else if (model.online) {
+                    if (model.paired) {
+                        // go to game view
+                        var component = Qt.createComponent("AppView.qml")
+                        var appView = component.createObject(stackView)
+                        appView.computerIndex = index
+                        appView.objectName = model.name
+                        stackView.push(appView)
+                    }
+                    else {
+                        if (!model.busy) {
+                            var pin = ("0000" + Math.floor(Math.random() * 10000)).slice(-4)
+
+                            // Stop polling, since pairing may make GFE unresponsive
+                            ComputerManager.stopPollingAsync()
+
+                            // Kick off pairing in the background
+                            computerModel.pairComputer(index, pin)
+
+                            // Display the pairing dialog
+                            pairDialog.pin = pin
+                            pairDialog.open()
+                        }
+                        else {
+                            // cannot pair while something is streaming or attempting to pair
+                            errorDialog.text = "This PC is currently busy. Make sure to quit any running games and try again."
+                            errorDialog.open()
+                        }
+                    }
+                }
+                else {
+                    // TODO: Wake on LAN and delete PC options
+                }
             }
         }
-
-        Keys.onMenuPressed: {
-            // We must use open() here so the menu is positioned on
-            // the ItemDelegate and not where the mouse cursor is
-            pcContextMenu.open()
-        }
     }
 
-    ErrorMessageDialog {
+    MessageDialog {
         id: errorDialog
-
-        // Using Setup-Guide here instead of Troubleshooting because it's likely that users
-        // will arrive here by forgetting to enable GameStream or not forwarding ports.
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide"
+        // don't allow edits to the rest of the window while open
+        modality:Qt.WindowModal
+        icon: StandardIcon.Critical
+        standardButtons: StandardButton.Ok
     }
 
-    NavigableMessageDialog {
+    MessageDialog {
         id: pairDialog
         // don't allow edits to the rest of the window while open
+        modality:Qt.WindowModal
         property string pin : "0000"
         text:"Please enter " + pin + " on your GameStream PC. This dialog will close when pairing is completed."
-        standardButtons: Dialog.Cancel
+        standardButtons: StandardButton.Cancel
         onRejected: {
             // FIXME: We should interrupt pairing here
         }
     }
 
-    NavigableMessageDialog {
-        id: deletePcDialog
-        // don't allow edits to the rest of the window while open
-        property int pcIndex : -1;
-        text:"Are you sure you want to remove this PC?"
-        standardButtons: Dialog.Yes | Dialog.No
+    Dialog {
+        id: addPcDialog
+        property string label: "Enter the IP address of your GameStream PC"
+        property string hint: "192.168.1.100"
+        property alias editText : editTextItem
 
-        function deletePc() {
-            console.log("deleting PC pairing for PC at index: " + pcIndex)
-            computerModel.deleteComputer(pcIndex);
+        standardButtons: StandardButton.Ok | StandardButton.Cancel
+        onVisibleChanged: {
+            editTextItem.focus = true
+            editTextItem.selectAll()
+        }
+        onAccepted: {
+            ComputerManager.addNewHost(editText.text, false)
         }
 
-        onAccepted: deletePc()
+        ColumnLayout {
+            Text {
+                id: addPcDialogLabel
+                text: addPcDialog.label
+            }
+            Rectangle {
+                implicitWidth: parent.parent.width
+                height: editTextItem.height
+
+                TextInput {
+                    id: editTextItem
+                    inputMethodHints: Qt.ImhPreferUppercase
+                    text: addPcDialog.hint
+                }
+            }
+        }
     }
 
     ScrollBar.vertical: ScrollBar {
         parent: pcGrid.parent
         anchors {
-            top: parent.top
-            right: parent.right
-            bottom: parent.bottom
+            top: pcGrid.top
+            left: pcGrid.right
+            bottom: pcGrid.bottom
+
+            leftMargin: -10
         }
     }
 }

app/gui/QuitSegue.qml

@@ -1,72 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-import ComputerManager 1.0
-import Session 1.0
-
-Item {
-    property string appName
-    property Session nextSession : null
-    property string nextAppName : ""
-
-    property string stageText : "Quitting " + appName + "..."
-
-    function quitAppCompleted(error)
-    {
-        // Display a failed dialog if we got an error
-        if (error !== undefined) {
-            errorDialog.text = error
-            errorDialog.open()
-        }
-
-        // If we're supposed to launch another game after this, do so now
-        if (error === undefined && nextSession !== null) {
-            var component = Qt.createComponent("StreamSegue.qml")
-            var segue = component.createObject(stackView, {"appName": nextAppName, "session": nextSession})
-            stackView.replace(segue)
-        }
-        else {
-            // Exit this view
-            stackView.pop()
-        }
-    }
-
-    StackView.onActivated: {
-        // Hide the toolbar before we start loading
-        toolBar.visible = false
-
-        // Connect the quit completion signal
-        ComputerManager.quitAppCompleted.connect(quitAppCompleted)
-    }
-
-    StackView.onDeactivating: {
-        // Show the toolbar again
-        toolBar.visible = true
-
-        // Disconnect the signal
-        ComputerManager.quitAppCompleted.disconnect(quitAppCompleted)
-    }
-
-    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
-        }
-    }
-
-    ErrorMessageDialog {
-        id: errorDialog
-    }
-}

app/gui/SettingsView.qml

@@ -2,47 +2,28 @@ import QtQuick 2.9
 import QtQuick.Controls 2.2
 
 import StreamingPreferences 1.0
-import ComputerManager 1.0
-import SdlGamepadKeyNavigation 1.0
-import SystemProperties 1.0
 
-Flickable {
+ScrollView {
     id: settingsPage
     objectName: "Settings"
 
-    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
     }
 
-    StackView.onActivated: {
-        SdlGamepadKeyNavigation.setSettingsMode(true)
-    }
-
-    StackView.onDeactivating: {
-        SdlGamepadKeyNavigation.setSettingsMode(false)
-
-        // Save the prefs so the Session can observe the changes
-        StreamingPreferences.save()
+    Component.onDestruction: {
+        prefs.save()
     }
 
     Column {
-        padding: 10
-        id: settingsColumn1
-        width: settingsPage.width / 2 - padding
+        x: 10
+        y: 10
+        width: settingsPage.width
+        height: 400
 
         GroupBox {
             id: basicSettingsGroupBox
-            width: (parent.width - 2 * parent.padding)
+            width: (parent.width - 20)
             padding: 12
             title: "<font color=\"skyblue\">Basic Settings</font>"
             font.pointSize: 12
@@ -54,225 +35,93 @@ Flickable {
                 Label {
                     width: parent.width
                     id: resFPStitle
-                    text: qsTr("Resolution and FPS")
+                    text: qsTr("Resolution and FPS target")
                     font.pointSize: 12
-                    wrapMode: Text.Wrap
+                    wrapMode: Text.Wrap                    
+                    color: "white"
                 }
 
                 Label {
                     width: parent.width
                     id: resFPSdesc
-                    text: qsTr("Setting values too high for your PC or network connection may cause lag, stuttering, or errors.")
+                    text: qsTr("Setting values too high for your device may cause lag or crashes")
                     font.pointSize: 9
                     wrapMode: Text.Wrap
+                    color: "white"
                 }
 
-                Row {
-                    spacing: 5
-
-                    AutoResizingComboBox {
-                        // ignore setting the index at first, and actually set it when the component is loaded
-                        Component.onCompleted: {
-                            // Add native resolutions for all attached displays
-                            var done = false
-                            for (var displayIndex = 0; !done; displayIndex++) {
-                                for (var displayResIndex = 0; displayResIndex < 2; displayResIndex++) {
-                                    var screenRect;
-
-                                    // Some platforms have different desktop resolutions
-                                    // and native resolutions (like macOS with Retina displays)
-                                    if (displayResIndex == 0) {
-                                        screenRect = SystemProperties.getDesktopResolution(displayIndex)
-                                    }
-                                    else {
-                                        screenRect = SystemProperties.getNativeResolution(displayIndex)
-                                    }
-
-                                    if (screenRect.width === 0) {
-                                        // Exceeded max count of displays
-                                        done = true
-                                        break
-                                    }
-
-                                    var indexToAdd = 0
-                                    for (var j = 0; j < resolutionComboBox.count; j++) {
-                                        var existing_width = parseInt(resolutionListModel.get(j).video_width);
-                                        var existing_height = parseInt(resolutionListModel.get(j).video_height);
-
-                                        if (screenRect.width === existing_width && screenRect.height === existing_height) {
-                                            // Duplicate entry, skip
-                                            indexToAdd = -1
-                                            break
-                                        }
-                                        else if (screenRect.width * screenRect.height > existing_width * existing_height) {
-                                            // Candidate entrypoint after this entry
-                                            indexToAdd = j + 1
-                                        }
-                                    }
-
-                                    // Insert this display's resolution if it's not a duplicate
-                                    if (indexToAdd >= 0) {
-                                        resolutionListModel.insert(indexToAdd,
-                                                                   {
-                                                                       "text": "Native ("+screenRect.width+"x"+screenRect.height+")",
-                                                                       "video_width": ""+screenRect.width,
-                                                                       "video_height": ""+screenRect.height
-                                                                   })
-                                    }
-                                }
-                            }
-
-                            // load the saved width/height, and iterate through the ComboBox until a match is found
-                            // and set it to that index.
-                            var saved_width = StreamingPreferences.width
-                            var saved_height = StreamingPreferences.height
-                            currentIndex = 0
-                            for (var i = 0; i < resolutionListModel.count; i++) {
-                                var el_width = parseInt(resolutionListModel.get(i).video_width);
-                                var el_height = parseInt(resolutionListModel.get(i).video_height);
-
-                                // Pick the highest value lesser or equal to the saved resolution
-                                if (saved_width * saved_height >= el_width * el_height) {
-                                    currentIndex = i
-                                }
-                            }
-
-                            // Persist the selected value
-                            activated(currentIndex)
-                        }
-
-                        id: resolutionComboBox
-                        textRole: "text"
-                        model: ListModel {
-                            id: resolutionListModel
-                            // Other elements may be added at runtime
-                            // based on attached display resolution
-                            ListElement {
-                                text: "720p"
-                                video_width: "1280"
-                                video_height: "720"
-                            }
-                            ListElement {
-                                text: "1080p"
-                                video_width: "1920"
-                                video_height: "1080"
-                            }
-                            ListElement {
-                                text: "1440p"
-                                video_width: "2560"
-                                video_height: "1440"
-                            }
-                            ListElement {
-                                text: "4K"
-                                video_width: "3840"
-                                video_height: "2160"
-                            }
-                        }
-                        // ::onActivated must be used, as it only listens for when the index is changed by a human
-                        onActivated : {
-                            var selectedWidth = parseInt(resolutionListModel.get(currentIndex).video_width)
-                            var selectedHeight = parseInt(resolutionListModel.get(currentIndex).video_height)
-
-                            // Only modify the bitrate if the values actually changed
-                            if (StreamingPreferences.width !== selectedWidth || StreamingPreferences.height !== selectedHeight) {
-                                StreamingPreferences.width = selectedWidth
-                                StreamingPreferences.height = selectedHeight
-
-                                StreamingPreferences.bitrateKbps = StreamingPreferences.getDefaultBitrate(StreamingPreferences.width,
-                                                                                                          StreamingPreferences.height,
-                                                                                                          StreamingPreferences.fps);
-                                slider.value = StreamingPreferences.bitrateKbps
-                            }
+                ComboBox {
+                    // ignore setting the index at first, and actually set it when the component is loaded
+                    Component.onCompleted: {
+                        // load the saved width/height/fps, and iterate through the ComboBox until a match is found
+                        // set it to that index.
+                        var saved_width = prefs.width
+                        var saved_height = prefs.height
+                        var saved_fps = prefs.fps
+                        currentIndex = 0
+                        for(var i = 0; i < resolutionComboBox.count; i++) {
+                            var el_width = parseInt(resolutionListModel.get(i).video_width);
+                            var el_height = parseInt(resolutionListModel.get(i).video_height);
+                            var el_fps = parseInt(resolutionListModel.get(i).video_fps);
+                          if(saved_width === el_width &&
+                                  saved_height === el_height &&
+                                  saved_fps === el_fps) {
+                              currentIndex = i
+                          }
                         }
                     }
 
-                    AutoResizingComboBox {
-                        function createModel() {
-                            var fpsListModel = Qt.createQmlObject('import QtQuick 2.0; ListModel {}', parent, '')
-
-                            var max_fps = SystemProperties.maximumStreamingFrameRate
-
-                            // Default entries
-                            fpsListModel.append({"text": "30 FPS", "video_fps": "30"})
-                            fpsListModel.append({"text": "60 FPS", "video_fps": "60"})
-
-                            // Add unsupported FPS values that come before the display max FPS
-                            if (StreamingPreferences.unsupportedFps) {
-                                if (max_fps > 90) {
-                                    fpsListModel.append({"text": "90 FPS (Unsupported)", "video_fps": "90"})
-                                }
-                                if (max_fps > 120) {
-                                    fpsListModel.append({"text": "120 FPS (Unsupported)", "video_fps": "120"})
-                                }
-                            }
-
-                            // Use 64 as the cutoff for adding a separate option to
-                            // handle wonky displays that report just over 60 Hz.
-                            if (max_fps > 64) {
-                                // Mark any FPS value greater than 120 as unsupported
-                                if (StreamingPreferences.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
-                            if (StreamingPreferences.unsupportedFps) {
-                                if (max_fps < 90) {
-                                    fpsListModel.append({"text": "90 FPS (Unsupported)", "video_fps": "90"})
-                                }
-                                if (max_fps < 120) {
-                                    fpsListModel.append({"text": "120 FPS (Unsupported)", "video_fps": "120"})
-                                }
-                            }
-
-                            return fpsListModel
+                    id: resolutionComboBox
+                    width: Math.min(bitrateDesc.implicitWidth, parent.width)
+                    font.pointSize: 9
+                    textRole: "text"
+                    model: ListModel {
+                        id: resolutionListModel
+                        ListElement {
+                            text: "720p 30 FPS"
+                            video_width: "1280"
+                            video_height: "720"
+                            video_fps: "30"
                         }
-
-                        function reinitialize() {
-                            model = createModel()
-
-                            var saved_fps = StreamingPreferences.fps
-                            currentIndex = 0
-                            for (var i = 0; i < model.count; i++) {
-                                var el_fps = parseInt(model.get(i).video_fps);
-
-                                // Pick the highest value lesser or equal to the saved FPS
-                                if (saved_fps >= el_fps) {
-                                    currentIndex = i
-                                }
-                            }
-
-                            // Persist the selected value
-                            activated(currentIndex)
+                        ListElement {
+                            text: "720p 60 FPS"
+                            video_width: "1280"
+                            video_height: "720"
+                            video_fps: "60"
                         }
-
-                        // ignore setting the index at first, and actually set it when the component is loaded
-                        Component.onCompleted: {
-                            reinitialize()
+                        ListElement {
+                            text: "1080p 30 FPS"
+                            video_width: "1920"
+                            video_height: "1080"
+                            video_fps: "30"
                         }
-
-                        id: fpsComboBox
-                        textRole: "text"
-                        // ::onActivated must be used, as it only listens for when the index is changed by a human
-                        onActivated : {
-                            var selectedFps = parseInt(model.get(currentIndex).video_fps)
-
-                            // Only modify the bitrate if the values actually changed
-                            if (StreamingPreferences.fps !== selectedFps) {
-                                StreamingPreferences.fps = selectedFps
-
-                                StreamingPreferences.bitrateKbps = StreamingPreferences.getDefaultBitrate(StreamingPreferences.width,
-                                                                                                          StreamingPreferences.height,
-                                                                                                          StreamingPreferences.fps);
-                                slider.value = StreamingPreferences.bitrateKbps
-                            }
+                        ListElement {
+                            text: "1080p 60 FPS"
+                            video_width: "1920"
+                            video_height: "1080"
+                            video_fps: "60"
                         }
+                        ListElement {
+                            text: "4K 30 FPS"
+                            video_width: "3840"
+                            video_height: "2160"
+                            video_fps: "30"
+                        }
+                        ListElement {
+                            text: "4K 60 FPS"
+                            video_width: "3840"
+                            video_height: "2160"
+                            video_fps: "60"
+                        }
+                    }
+                    // ::onActivated must be used, as it only listens for when the index is changed by a human
+                    onActivated : {
+                        prefs.width = parseInt(resolutionListModel.get(currentIndex).video_width)
+                        prefs.height = parseInt(resolutionListModel.get(currentIndex).video_height)
+                        prefs.fps = parseInt(resolutionListModel.get(currentIndex).video_fps)
+
+                        prefs.bitrateKbps = prefs.getDefaultBitrate(prefs.width, prefs.height, prefs.fps);
+                        slider.value = prefs.bitrateKbps
                     }
                 }
 
@@ -282,115 +131,45 @@ Flickable {
                     text: qsTr("Video bitrate: ")
                     font.pointSize: 12
                     wrapMode: Text.Wrap
+                    color: "white"
                 }
 
                 Label {
                     width: parent.width
                     id: bitrateDesc
-                    text: qsTr("Lower the bitrate on slower connections. Raise the bitrate to increase image quality.")
+                    text: qsTr("Lower bitrate to reduce lag and stuttering. Raise bitrate to increase image quality.")
                     font.pointSize: 9
                     wrapMode: Text.Wrap
+                    color: "white"
                 }
 
                 Slider {
                     id: slider
+                    wheelEnabled: true
 
-                    value: StreamingPreferences.bitrateKbps
+                    value: prefs.bitrateKbps
 
                     stepSize: 500
                     from : 500
-                    to: 150000
+                    to: 100000
 
                     snapMode: "SnapOnRelease"
                     width: Math.min(bitrateDesc.implicitWidth, parent.width)
 
                     onValueChanged: {
                         bitrateTitle.text = "Video bitrate: " + (value / 1000.0) + " Mbps"
-                        StreamingPreferences.bitrateKbps = value
+                        prefs.bitrateKbps = value
                     }
                 }
 
-                Label {
-                    width: parent.width
-                    id: windowModeTitle
-                    text: qsTr("Display mode")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var savedWm = StreamingPreferences.windowMode
-                        currentIndex = 0
-                        for (var i = 0; i < windowModeListModel.count; i++) {
-                             var thisWm = windowModeListModel.get(i).val;
-                             if (savedWm === thisWm) {
-                                 currentIndex = i
-                                 break
-                             }
-                        }
-                        activated(currentIndex)
-                    }
-
-                    id: windowModeComboBox
-                    hoverEnabled: true
-                    textRole: "text"
-                    model: ListModel {
-                        id: windowModeListModel
-                        ListElement {
-                            text: "Full-screen (Recommended)"
-                            val: StreamingPreferences.WM_FULLSCREEN
-                        }
-                        ListElement {
-                            text: "Borderless windowed"
-                            val: StreamingPreferences.WM_FULLSCREEN_DESKTOP
-                        }
-                        ListElement {
-                            text: "Windowed"
-                            val: StreamingPreferences.WM_WINDOWED
-                        }
-                    }
-                    onActivated: {
-                        StreamingPreferences.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
-                    hoverEnabled: true
-                    text: "V-Sync"
+                    id: fullScreenCheck
+                    text: "<font color=\"white\">Full-screen</font>"
                     font.pointSize:  12
-                    checked: StreamingPreferences.enableVsync
+                    checked: prefs.fullScreen
                     onCheckedChanged: {
-                        StreamingPreferences.enableVsync = checked
+                        prefs.fullScreen = 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: StreamingPreferences.enableVsync
-                    checked: StreamingPreferences.enableVsync && StreamingPreferences.framePacing
-                    onCheckedChanged: {
-                        StreamingPreferences.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"
                 }
             }
         }
@@ -398,105 +177,35 @@ Flickable {
         GroupBox {
 
             id: audioSettingsGroupBox
-            width: (parent.width - 2 * parent.padding)
+            width: (parent.width - 20)
             padding: 12
             title: "<font color=\"skyblue\">Audio Settings</font>"
             font.pointSize: 12
 
-            Column {
-                anchors.fill: parent
-                spacing: 5
-
-                Label {
-                    width: parent.width
-                    id: resAudioTitle
-                    text: qsTr("Audio configuration")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var saved_audio = StreamingPreferences.audioConfig
-                        currentIndex = 0
-                        for (var i = 0; i < audioListModel.count; i++) {
-                            var el_audio = audioListModel.get(i).val;
-                            if (saved_audio === el_audio) {
-                                currentIndex = i
-                                break
-                            }
-                        }
-                        activated(currentIndex)
-                    }
-
-                    id: audioComboBox
-                    textRole: "text"
-                    model: ListModel {
-                        id: audioListModel
-                        ListElement {
-                            text: "Stereo"
-                            val: StreamingPreferences.AC_STEREO
-                        }
-                        ListElement {
-                            text: "5.1 surround sound"
-                            val: StreamingPreferences.AC_51_SURROUND
-                        }
-                    }
-                    // ::onActivated must be used, as it only listens for when the index is changed by a human
-                    onActivated : {
-                        StreamingPreferences.audioConfig = audioListModel.get(currentIndex).val
-                    }
-                }
-
-            }
-        }
-
-        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: !StreamingPreferences.startWindowed
-                    onCheckedChanged: {
-                        StreamingPreferences.startWindowed = !checked
-                    }
-                }
+                    id: surroundSoundCheck
+                    text: "<font color=\"white\">Enable 5.1 surround sound</font>"
+                    font.pointSize:  12
+
+                    // the backend actually supports auto/stereo/5.1.  We'll expose stereo/5.1
+                    checked: prefs.audioConfig === StreamingPreferences.AC_FORCE_SURROUND
 
-                CheckBox {
-                    id: connectionWarningsCheck
-                    text: "Show connection quality warnings"
-                    font.pointSize: 12
-                    checked: StreamingPreferences.connectionWarnings
                     onCheckedChanged: {
-                        StreamingPreferences.connectionWarnings = checked
+                        prefs.audioConfig = checked ? StreamingPreferences.AC_FORCE_SURROUND : StreamingPreferences.AC_FORCE_STEREO
                     }
                 }
             }
         }
-    }
-
-    Column {
-        padding: 10
-        anchors.left: settingsColumn1.right
-        id: settingsColumn2
-        width: settingsPage.width / 2 - padding
 
         GroupBox {
             id: gamepadSettingsGroupBox
-            width: (parent.width - parent.padding)
+            width: (parent.width - 20)
             padding: 12
-            title: "<font color=\"skyblue\">Input Settings</font>"
+            title: "<font color=\"skyblue\">Gamepad Settings</font>"
             font.pointSize: 12
 
             Column {
@@ -504,42 +213,46 @@ Flickable {
                 spacing: 5
 
                 CheckBox {
-                    id: singleControllerCheck
-                    text: "Force gamepad #1 always present"
+                    id: multiControllerCheck
+                    text: "<font color=\"white\">Multiple controller support</font>"
                     font.pointSize:  12
-                    checked: !StreamingPreferences.multiController
+                    checked: prefs.multiController
                     onCheckedChanged: {
-                        StreamingPreferences.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: mouseEmulationCheck
+                    text: "<font color=\"white\">Mouse emulation via gamepad</font>"
+                    font.pointSize:  12
+                    // TODO: make this actually do anything
+                }
+            }
+        }
+
+        GroupBox {
+            id: onScreenControlsGroupBox
+            width: (parent.width - 20)
+            padding: 12
+            title: "<font color=\"skyblue\">On-screen Controls Settings</font>"
+            font.pointSize: 12
+
+            Column {
+                anchors.fill: parent
+                spacing: 5
 
                 CheckBox {
-                    id: rawInputCheck
-                    hoverEnabled: true
-                    text: "Raw mouse input"
+                    id: onScreenControlsCheck
+                    text: "<font color=\"white\">Show on-screen controls</font>"
                     font.pointSize:  12
-                    checked: !StreamingPreferences.mouseAcceleration
-                    onCheckedChanged: {
-                        StreamingPreferences.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"
+                    // TODO: make this actually do anything
                 }
             }
         }
 
         GroupBox {
             id: hostSettingsGroupBox
-            width: (parent.width - parent.padding)
+            width: (parent.width - 20)
             padding: 12
             title: "<font color=\"skyblue\">Host Settings</font>"
             font.pointSize: 12
@@ -550,21 +263,21 @@ Flickable {
 
                 CheckBox {
                     id: optimizeGameSettingsCheck
-                    text: "Optimize game settings"
+                    text: "<font color=\"white\">Optimize game settings</font>"
                     font.pointSize:  12
-                    checked: StreamingPreferences.gameOptimizations
+                    checked: prefs.gameOptimizations
                     onCheckedChanged: {
-                        StreamingPreferences.gameOptimizations = checked
+                        prefs.gameOptimizations = checked
                     }
                 }
 
                 CheckBox {
                     id: audioPcCheck
-                    text: "Play audio on host PC"
+                    text: "<font color=\"white\">Play audio on host PC</font>"
                     font.pointSize:  12
-                    checked: StreamingPreferences.playAudioOnHost
+                    checked: prefs.playAudioOnHost
                     onCheckedChanged: {
-                        StreamingPreferences.playAudioOnHost = checked
+                        prefs.playAudioOnHost = checked
                     }
                 }
             }
@@ -572,7 +285,7 @@ Flickable {
 
         GroupBox {
             id: advancedSettingsGroupBox
-            width: (parent.width - parent.padding)
+            width: (parent.width - 20)
             padding: 12
             title: "<font color=\"skyblue\">Advanced Settings</font>"
             font.pointSize: 12
@@ -581,155 +294,10 @@ Flickable {
                 anchors.fill: parent
                 spacing: 5
 
-                Label {
-                    width: parent.width
-                    id: resVDSTitle
-                    text: qsTr("Video decoder")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var saved_vds = StreamingPreferences.videoDecoderSelection
-                        currentIndex = 0
-                        for (var i = 0; i < decoderListModel.count; i++) {
-                            var el_vds = decoderListModel.get(i).val;
-                            if (saved_vds === el_vds) {
-                                currentIndex = i
-                                break
-                            }
-                        }
-                        activated(currentIndex)
-                    }
-
-                    id: decoderComboBox
-                    textRole: "text"
-                    model: ListModel {
-                        id: decoderListModel
-                        ListElement {
-                            text: "Automatic (Recommended)"
-                            val: StreamingPreferences.VDS_AUTO
-                        }
-                        ListElement {
-                            text: "Force software decoding"
-                            val: StreamingPreferences.VDS_FORCE_SOFTWARE
-                        }
-                        ListElement {
-                            text: "Force hardware decoding"
-                            val: StreamingPreferences.VDS_FORCE_HARDWARE
-                        }
-                    }
-                    // ::onActivated must be used, as it only listens for when the index is changed by a human
-                    onActivated : {
-                        StreamingPreferences.videoDecoderSelection = decoderListModel.get(currentIndex).val
-                    }
-                }
-
-                Label {
-                    width: parent.width
-                    id: resVCCTitle
-                    text: qsTr("Video codec")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var saved_vcc = StreamingPreferences.videoCodecConfig
-                        currentIndex = 0
-                        for(var i = 0; i < codecListModel.count; i++) {
-                            var el_vcc = codecListModel.get(i).val;
-                            if (saved_vcc === el_vcc) {
-                                currentIndex = i
-                                break
-                            }
-                        }
-                        activated(currentIndex)
-                    }
-
-                    id: codecComboBox
-                    textRole: "text"
-                    model: ListModel {
-                        id: codecListModel
-                        ListElement {
-                            text: "Automatic (Recommended)"
-                            val: StreamingPreferences.VCC_AUTO
-                        }
-                        ListElement {
-                            text: "Force H.264"
-                            val: StreamingPreferences.VCC_FORCE_H264
-                        }
-                        ListElement {
-                            text: "Force HEVC"
-                            val: StreamingPreferences.VCC_FORCE_HEVC
-                        }
-                        // HDR seems to be broken in GFE 3.14.1, and even when that's fixed
-                        // we'll probably need to gate this feature on OS support in our
-                        // renderers.
-                        /* ListElement {
-                            text: "Force HEVC HDR"
-                            val: StreamingPreferences.VCC_FORCE_HEVC_HDR
-                        } */
-                    }
-                    // ::onActivated must be used, as it only listens for when the index is changed by a human
-                    onActivated : {
-                        StreamingPreferences.videoCodecConfig = codecListModel.get(currentIndex).val
-                    }
-                }
-
                 CheckBox {
-                    id: unlockUnsupportedFps
-                    text: "Unlock unsupported FPS options"
-                    font.pointSize: 12
-                    checked: StreamingPreferences.unsupportedFps
-                    onCheckedChanged: {
-                        // This is called on init, so only do the work if we've
-                        // actually changed the value.
-                        if (StreamingPreferences.unsupportedFps != checked) {
-                            StreamingPreferences.unsupportedFps = checked
-
-                            // The selectable FPS values depend on whether
-                            // this option is enabled or not
-                            fpsComboBox.reinitialize()
-                        }
-                    }
-                }
-
-                CheckBox {
-                    id: enableMdns
-                    text: "Automatically find PCs on the local network (Recommended)"
-                    font.pointSize: 12
-                    checked: StreamingPreferences.enableMdns
-                    onCheckedChanged: {
-                        // This is called on init, so only do the work if we've
-                        // actually changed the value.
-                        if (StreamingPreferences.enableMdns != checked) {
-                            StreamingPreferences.enableMdns = checked
-
-                            // We must save the updated preference to ensure
-                            // ComputerManager can observe the change internally.
-                            StreamingPreferences.save()
-
-                            // Restart polling so the mDNS change takes effect
-                            if (window.pollingActive) {
-                                ComputerManager.stopPollingAsync()
-                                ComputerManager.startPolling()
-                            }
-                        }
-                    }
-                }
-
-                CheckBox {
-                    id: quitAppAfter
-                    text: "Quit app after quitting session"
-                    font.pointSize: 12
-                    checked: StreamingPreferences.quitAppAfter
-                    onCheckedChanged: {
-                        StreamingPreferences.quitAppAfter = checked
-                    }
+                    id: neverDropFramesCheck
+                    text: "<font color=\"white\">Never drop frames</font>"
+                    font.pointSize:  12
                 }
             }
         }

app/gui/StreamSegue.qml

@@ -1,15 +1,20 @@
 import QtQuick 2.0
 import QtQuick.Controls 2.2
-import QtQuick.Window 2.2
+import QtQuick.Dialogs 1.3
 
-import SdlGamepadKeyNavigation 1.0
 import Session 1.0
 
 Item {
     property Session session
-    property string appName
-    property string stageText : "Starting " + appName + "..."
-    property bool quitAfter : false
+    property string appname
+    property string stageText : "Starting " + appname + "..."
+
+    anchors.fill: parent
+
+    // 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
 
     function stageStarting(stage)
     {
@@ -19,8 +24,8 @@ Item {
 
     function stageFailed(stage, errorCode)
     {
-        // Display the error dialog after Session::exec() returns
-        streamSegueErrorDialog.text = "Starting " + stage + " failed: Error " + errorCode
+        errorDialog.text = "Starting " + stage + " failed: Error " + errorCode
+        errorDialog.open()
     }
 
     function connectionStarted()
@@ -29,7 +34,6 @@ Item {
         // see them briefly when we pop off the StackView
         stageSpinner.visible = false
         stageLabel.visible = false
-        hintText.visible = false
 
         // Hide the window now that streaming has begun
         window.visible = false
@@ -37,111 +41,40 @@ Item {
 
     function displayLaunchError(text)
     {
-        // Display the error dialog after Session::exec() returns
-        streamSegueErrorDialog.text = text
+        errorDialog.text = text
+        errorDialog.open()
     }
 
     function displayLaunchWarning(text)
     {
-        // This toast appears for 3 seconds, just shorter than how long
-        // Session will wait for it to be displayed. This gives it time
-        // to transition to invisible before continuing.
-        var toast = Qt.createQmlObject('import QtQuick.Controls 2.2; ToolTip {}', parent, '')
-        toast.text = text
-        toast.timeout = 3000
-        toast.visible = true
+        // TODO: toast
     }
 
-    function quitStarting()
-    {
-        // Avoid the push transition animation
-        var component = Qt.createComponent("QuitSegue.qml")
-        stackView.replace(stackView.currentItem, component.createObject(stackView, {"appName": appName}), StackView.Immediate)
+    onVisibleChanged: {
+        if (visible) {
+            // Hide the toolbar before we start loading
+            toolBar.visible = false
 
-        // Show the Qt window again to show quit segue
-        window.visible = true
-    }
+            // Hook up our signals
+            session.stageStarting.connect(stageStarting)
+            session.stageFailed.connect(stageFailed)
+            session.connectionStarted.connect(connectionStarted)
+            session.displayLaunchError.connect(displayLaunchError)
+            session.displayLaunchWarning.connect(displayLaunchWarning)
 
-    function sessionFinished()
-    {
-        // Enable GUI gamepad usage now
-        SdlGamepadKeyNavigation.enable()
-
-        if (quitAfter) {
-            if (streamSegueErrorDialog.text) {
-                // Quit when the error dialog is acknowledged
-                streamSegueErrorDialog.quitAfter = quitAfter
-                streamSegueErrorDialog.open()
-            }
-            else {
-                // Quit immediately
-                Qt.quit()
-            }
-        } else {
-            // Exit this view
-            stackView.pop()
+            // Run the streaming session to completion
+            session.exec()
 
             // 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 (streamSegueErrorDialog.text) {
-                streamSegueErrorDialog.quitAfter = quitAfter
-                streamSegueErrorDialog.open()
-            }
+            // Exit this view
+            stackView.pop()
         }
-    }
-
-    StackView.onDeactivating: {
-        // Show the toolbar again when popped off the stack
-        toolBar.visible = true
-
-        // Enable GUI gamepad usage now
-        SdlGamepadKeyNavigation.enable()
-    }
-
-    StackView.onActivated: {
-        // Hide the toolbar before we start loading
-        toolBar.visible = false
-
-        // 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)
-
-        // Kick off the stream
-        streamLoader.active = true
-    }
-
-    Loader {
-        id: streamLoader
-        active: false
-        asynchronous: true
-
-        onLoaded: {
-            // 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 = SdlGamepadKeyNavigation.getConnectedGamepads() > 0 ?
-                      "Tip: Press Start+Select+L1+R1 to disconnect your session" :
-                      "Tip: Press Ctrl+Alt+Shift+Q to disconnect your session"
-
-            // Stop GUI gamepad usage now
-            SdlGamepadKeyNavigation.disable()
-
-            // Run the streaming session to completion
-            session.exec(Screen.virtualX, Screen.virtualY)
+        else {
+            // Show the toolbar again when we become hidden
+            toolBar.visible = true
         }
-
-        sourceComponent: Item {}
     }
 
     Row {
@@ -160,17 +93,14 @@ Item {
             verticalAlignment: Text.AlignVCenter
 
             wrapMode: Text.Wrap
+            color: "white"
         }
     }
 
-    Label {
-        id: hintText
-        anchors.bottom: parent.bottom
-        anchors.bottomMargin: 50
-        anchors.horizontalCenter: parent.horizontalCenter
-        font.pointSize: 18
-        verticalAlignment: Text.AlignVCenter
-
-        wrapMode: Text.Wrap
+    MessageDialog {
+        id: errorDialog
+        modality:Qt.WindowModal
+        icon: StandardIcon.Critical
+        standardButtons: StandardButton.Ok
     }
 }

app/gui/appmodel.cpp

@@ -19,32 +19,6 @@ void AppModel::initialize(ComputerManager* computerManager, int computerIndex)
     m_CurrentGameId = m_Computer->currentGameId;
 }
 
-int AppModel::getRunningAppIndex()
-{
-    if (m_CurrentGameId != 0) {
-        for (int i = 0; i < m_Apps.count(); i++) {
-            if (m_Apps[i].id == m_CurrentGameId) {
-                return i;
-            }
-        }
-    }
-
-    return -1;
-}
-
-QString AppModel::getRunningAppName()
-{
-    if (m_CurrentGameId != 0) {
-        for (int i = 0; i < m_Apps.count(); i++) {
-            if (m_Apps[i].id == m_CurrentGameId) {
-                return m_Apps[i].name;
-            }
-        }
-    }
-
-    return nullptr;
-}
-
 Session* AppModel::createSessionForApp(int appIndex)
 {
     Q_ASSERT(appIndex < m_Apps.count());
@@ -96,11 +70,6 @@ QHash<int, QByteArray> AppModel::roleNames() const
     return names;
 }
 
-void AppModel::quitRunningApp()
-{
-    m_ComputerManager->quitRunningApp(m_Computer);
-}
-
 void AppModel::handleComputerStateChanged(NvComputer* computer)
 {
     // Ignore updates for computers that aren't ours
@@ -108,14 +77,6 @@ void AppModel::handleComputerStateChanged(NvComputer* computer)
         return;
     }
 
-    // If the computer has gone offline or we've been unpaired,
-    // signal the UI so we can go back to the PC view.
-    if (m_Computer->state == NvComputer::CS_OFFLINE ||
-            m_Computer->pairState == NvComputer::PS_NOT_PAIRED) {
-        emit computerLost();
-        return;
-    }
-
     // First, process additions/removals from the app list. This
     // is required because the new game may now be running, so
     // we can't check that first.
@@ -162,15 +123,10 @@ void AppModel::handleBoxArtLoaded(NvComputer* computer, NvApp app, QUrl /* image
     Q_ASSERT(computer == m_Computer);
 
     int index = m_Apps.indexOf(app);
+    Q_ASSERT(index >= 0);
 
-    // Make sure we're not delivering a callback to an app that's already been removed
-    if (index >= 0) {
-        // Let our view know the box art data has changed for this app
-        emit dataChanged(createIndex(index, 0),
-                         createIndex(index, 0),
-                         QVector<int>() << BoxArtRole);
-    }
-    else {
-        qWarning() << "App not found for box art callback:" << app.name;
-    }
+    // Let our view know the box art data has changed for this app
+    emit dataChanged(createIndex(index, 0),
+                     createIndex(index, 0),
+                     QVector<int>() << BoxArtRole);
 }

app/gui/appmodel.h

@@ -2,7 +2,7 @@
 
 #include "backend/boxartmanager.h"
 #include "backend/computermanager.h"
-#include "streaming/session.h"
+#include "streaming/session.hpp"
 
 #include <QAbstractListModel>
 
@@ -25,12 +25,6 @@ public:
 
     Q_INVOKABLE Session* createSessionForApp(int appIndex);
 
-    Q_INVOKABLE int getRunningAppIndex();
-
-    Q_INVOKABLE QString getRunningAppName();
-
-    Q_INVOKABLE void quitRunningApp();
-
     QVariant data(const QModelIndex &index, int role) const override;
 
     int rowCount(const QModelIndex &parent) const override;
@@ -42,9 +36,6 @@ private slots:
 
     void handleBoxArtLoaded(NvComputer* computer, NvApp app, QUrl image);
 
-signals:
-    void computerLost();
-
 private:
     NvComputer* m_Computer;
     BoxArtManager m_BoxArtManager;

app/gui/computermodel.cpp

@@ -1,7 +1,5 @@
 #include "computermodel.h"
 
-#include <QThreadPool>
-
 ComputerModel::ComputerModel(QObject* object)
     : QAbstractListModel(object) {}
 
@@ -22,6 +20,18 @@ QVariant ComputerModel::data(const QModelIndex& index, int role) const
         return QVariant();
     }
 
+    if (index.row() == m_Computers.count()) {
+        // We insert a synthetic item at the end for the Add PC option
+        switch (role) {
+        case NameRole:
+            return "Add PC";
+        case AddPcRole:
+            return true;
+        default:
+            return QVariant();
+        }
+    }
+
     Q_ASSERT(index.row() < m_Computers.count());
 
     NvComputer* computer = m_Computers[index.row()];
@@ -36,10 +46,8 @@ QVariant ComputerModel::data(const QModelIndex& index, int role) const
         return computer->pairState == NvComputer::PS_PAIRED;
     case BusyRole:
         return computer->currentGameId != 0;
-    case WakeableRole:
-        return !computer->macAddress.isEmpty();
-    case StatusUnknownRole:
-        return computer->state == NvComputer::CS_UNKNOWN;
+    case AddPcRole:
+        return false;
     default:
         return QVariant();
     }
@@ -53,7 +61,8 @@ int ComputerModel::rowCount(const QModelIndex& parent) const
         return 0;
     }
 
-    return m_Computers.count();
+    // Add PC placeholder counts as 1
+    return m_Computers.count() + 1;
 }
 
 QHash<int, QByteArray> ComputerModel::roleNames() const
@@ -64,8 +73,7 @@ QHash<int, QByteArray> ComputerModel::roleNames() const
     names[OnlineRole] = "online";
     names[PairedRole] = "paired";
     names[BusyRole] = "busy";
-    names[WakeableRole] = "wakeable";
-    names[StatusUnknownRole] = "statusUnknown";
+    names[AddPcRole] = "addPc";
 
     return names;
 }
@@ -105,27 +113,11 @@ void ComputerModel::deleteComputer(int computerIndex)
     endRemoveRows();
 }
 
-class DeferredWakeHostTask : public QRunnable
-{
-public:
-    DeferredWakeHostTask(NvComputer* computer)
-        : m_Computer(computer) {}
-
-    void run()
-    {
-        m_Computer->wake();
-    }
-
-private:
-    NvComputer* m_Computer;
-};
-
-void ComputerModel::wakeComputer(int computerIndex)
+bool ComputerModel::wakeComputer(int computerIndex)
 {
     Q_ASSERT(computerIndex < m_Computers.count());
 
-    DeferredWakeHostTask* wakeTask = new DeferredWakeHostTask(m_Computers[computerIndex]);
-    QThreadPool::globalInstance()->start(wakeTask);
+    return m_Computers[computerIndex]->wake();
 }
 
 void ComputerModel::pairComputer(int computerIndex, QString pin)
@@ -137,7 +129,7 @@ void ComputerModel::pairComputer(int computerIndex, QString pin)
 
 void ComputerModel::handlePairingCompleted(NvComputer*, QString error)
 {
-    emit pairingCompleted(error.isEmpty() ? QVariant() : error);
+    emit pairingCompleted(error.isNull() ? QVariant() : error);
 }
 
 void ComputerModel::handleComputerStateChanged(NvComputer* computer)

app/gui/computermodel.h

@@ -1,5 +1,5 @@
 #include "backend/computermanager.h"
-#include "streaming/session.h"
+#include "streaming/session.hpp"
 
 #include <QAbstractListModel>
 
@@ -13,8 +13,7 @@ class ComputerModel : public QAbstractListModel
         OnlineRole,
         PairedRole,
         BusyRole,
-        WakeableRole,
-        StatusUnknownRole
+        AddPcRole
     };
 
 public:
@@ -33,7 +32,7 @@ public:
 
     Q_INVOKABLE void pairComputer(int computerIndex, QString pin);
 
-    Q_INVOKABLE void wakeComputer(int computerIndex);
+    Q_INVOKABLE bool wakeComputer(int computerIndex);
 
     Q_INVOKABLE Session* createSessionForCurrentGame(int computerIndex);
 

app/gui/main.qml

@@ -1,160 +1,22 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
 import QtQuick.Layouts 1.3
-import QtQuick.Window 2.2
 
-import ComputerManager 1.0
-import AutoUpdateChecker 1.0
-import StreamingPreferences 1.0
-import SystemProperties 1.0
-import SdlGamepadKeyNavigation 1.0
+import QtQuick.Controls.Material 2.1
 
 ApplicationWindow {
-    property bool pollingActive: false
-
     id: window
     visible: true
     width: 1280
     height: 600
 
-    visibility: StreamingPreferences.startWindowed ? "Windowed" : "Maximized"
-
-    Component.onCompleted: {
-        SdlGamepadKeyNavigation.enable()
-    }
+    Material.theme: Material.Dark
+    Material.accent: Material.Purple
 
     StackView {
         id: stackView
-        initialItem: initialView
+        initialItem: "PcView.qml"
         anchors.fill: parent
-        focus: true
-
-        onCurrentItemChanged: {
-            // Ensure focus travels to the next view when going back
-            if (currentItem) {
-                currentItem.forceActiveFocus()
-            }
-        }
-
-        Keys.onEscapePressed: {
-            if (depth > 1) {
-                stackView.pop()
-            }
-            else {
-                quitConfirmationDialog.open()
-            }
-        }
-
-        Keys.onBackPressed: {
-            if (depth > 1) {
-                stackView.pop()
-            }
-            else {
-                quitConfirmationDialog.open()
-            }
-        }
-
-        Keys.onMenuPressed: {
-            settingsButton.clicked()
-        }
-
-        // This is a keypress we've reserved for letting the
-        // SdlGamepadKeyNavigation object tell us to show settings
-        // when Menu is consumed by a focused control.
-        Keys.onHangupPressed: {
-            settingsButton.clicked()
-        }
-    }
-
-    // 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
-            }
-        }
-    }
-
-    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()
-        }
-    }
-
-    property bool initialized: false
-
-    // BUG: Using onAfterSynchronizing: here causes very strange
-    // failures on Linux. Many shaders fail to compile and we
-    // eventually segfault deep inside the Qt OpenGL code.
-    onAfterRendering: {
-        // We use this callback to trigger dialog display because
-        // it only happens once the window is fully constructed.
-        // 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 (SystemProperties.isWow64) {
-                wow64Dialog.open()
-            }
-            else if (!SystemProperties.hasHardwareAcceleration) {
-                if (SystemProperties.isRunningXWayland) {
-                    xWaylandDialog.open()
-                }
-                else {
-                    noHwDecoderDialog.open()
-                }
-            }
-
-            if (SystemProperties.unmappedGamepads) {
-                unmappedGamepadDialog.unmappedGamepads = SystemProperties.unmappedGamepads
-                unmappedGamepadDialog.open()
-            }
-        }
     }
 
     function navigateTo(url, objectName)
@@ -175,26 +37,22 @@ ApplicationWindow {
 
     header: ToolBar {
         id: toolBar
-        height: 60
-        anchors.topMargin: 5
-        anchors.bottomMargin: 5
 
         RowLayout {
             spacing: 20
-            anchors.leftMargin: 10
-            anchors.rightMargin: 10
             anchors.fill: parent
 
-            NavigableToolButton {
+            ToolButton {
                 // Only make the button visible if the user has navigated somewhere.
                 visible: stackView.depth > 1
 
-                iconSource: "qrc:/res/arrow_left.svg"
-
+                icon.source: "qrc:/res/arrow_left.svg"
                 onClicked: stackView.pop()
 
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: backButton
+                    x: parent.width - width
+                    transformOrigin: Menu.TopRight
                 }
             }
 
@@ -208,230 +66,38 @@ ApplicationWindow {
                 Layout.fillWidth: true
             }
 
-            NavigableToolButton {
-                id: addPcButton
-                visible: stackView.currentItem.objectName === "Computers"
-
-                iconSource:  "qrc:/res/ic_add_to_queue_white_48px.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: "Add PC manually" + (newPcShortcut.nativeText ? (" ("+newPcShortcut.nativeText+")") : "")
-
-                Shortcut {
-                    id: newPcShortcut
-                    sequence: StandardKey.New
-                    onActivated: addPcButton.clicked()
-                }
-
-                onClicked: {
-                    addPcDialog.open()
-                }
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-            }
-
-            NavigableToolButton {
-                property string browserUrl: ""
-
-                id: updateButton
-
-                iconSource: "qrc:/res/update.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-
-                // Invisible until we get a callback notifying us that
-                // an update is available
-                visible: false
-
-                onClicked: Qt.openUrlExternally(browserUrl);
-
-                function updateAvailable(version, url)
-                {
-                    ToolTip.text = "Update available for Moonlight: Version " + version
-                    updateButton.browserUrl = url
-                    updateButton.visible = true
-                }
-
-                Component.onCompleted: {
-                    AutoUpdateChecker.onUpdateAvailable.connect(updateAvailable)
-                    AutoUpdateChecker.start()
-                }
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-            }
-
-            NavigableToolButton {
-                id: helpButton
-                visible: SystemProperties.hasBrowser
-
-                iconSource: "qrc:/res/question_mark.svg"
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: "Help" + (helpShortcut.nativeText ? (" ("+helpShortcut.nativeText+")") : "")
-
-                Shortcut {
-                    id: helpShortcut
-                    sequence: StandardKey.HelpContents
-                    onActivated: helpButton.clicked()
-                }
+            ToolButton {
+                icon.source: "qrc:/res/question_mark.svg"
 
                 // TODO need to make sure browser is brought to foreground.
                 onClicked: Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide");
 
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: helpButton
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                 }
             }
 
-            NavigableToolButton {
-                // TODO: Implement gamepad mapping then unhide this button
-                visible: false
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: "Gamepad Mapper"
-
-                iconSource: "qrc:/res/ic_videogame_asset_white_48px.svg"
-
+            ToolButton {
+                icon.source: "qrc:/res/ic_videogame_asset_white_48px.svg"
                 onClicked: navigateTo("qrc:/gui/GamepadMapper.qml", "Gamepad Mapping")
 
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: gamepadMappingMenu
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                 }
             }
 
-            NavigableToolButton {
-                id: settingsButton
-
-                iconSource:  "qrc:/res/settings.svg"
-
+            ToolButton {
+                icon.source: "qrc:/res/settings.svg"
                 onClicked: navigateTo("qrc:/gui/SettingsView.qml", "Settings")
 
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-
-                Shortcut {
-                    id: settingsShortcut
-                    sequence: StandardKey.Preferences
-                    onActivated: settingsButton.clicked()
-                }
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: "Settings" + (settingsShortcut.nativeText ? (" ("+settingsShortcut.nativeText+")") : "")
-            }
-        }
-    }
-
-    ErrorMessageDialog {
-        id: noHwDecoderDialog
-        text: "No functioning hardware accelerated H.264 video decoder was detected by Moonlight. " +
-              "Your streaming performance may be severely degraded in this configuration."
-        helpText: "Click the Help button for more information on solving this problem."
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems"
-    }
-
-    ErrorMessageDialog {
-        id: xWaylandDialog
-        text: "Hardware acceleration doesn't work on XWayland. Continuing on XWayland may result in poor streaming performance. " +
-              "Try running with QT_QPA_PLATFORM=wayland or switch to X11."
-        helpText: "Click the Help button for more information."
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems"
-    }
-
-    NavigableMessageDialog {
-        id: wow64Dialog
-        standardButtons: Dialog.Ok | Dialog.Cancel
-        text: "This PC is running a 64-bit version of Windows. Please download the x64 version of Moonlight for the best streaming performance."
-        onAccepted: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-qt/releases");
-        }
-    }
-
-    ErrorMessageDialog {
-        id: unmappedGamepadDialog
-        property string unmappedGamepads : ""
-        text: "Moonlight detected gamepads without a mapping:\n" + unmappedGamepads
-        helpTextSeparator: "\n\n"
-        helpText: "Click the Help button for information on how to map your gamepads."
-        helpUrl: "https://github.com/moonlight-stream/moonlight-docs/wiki/Gamepad-Mapping"
-    }
-
-    // This dialog appears when quitting via keyboard or gamepad button
-    NavigableMessageDialog {
-        id: quitConfirmationDialog
-        standardButtons: Dialog.Yes | Dialog.No
-        text: "Are you sure you want to quit?"
-        // For keyboard/gamepad navigation
-        onAccepted: Qt.quit()
-    }
-
-    // HACK: This belongs in StreamSegue but keeping a dialog around after the parent
-    // dies can trigger bugs in Qt 5.12 that cause the app to crash. For now, we will
-    // host this dialog in a QML component that is never destroyed.
-    //
-    // To repro: Start a stream, cut the network connection to trigger the "Connection
-    // terminated" dialog, wait until the app grid times out back to the PC grid, then
-    // try to dismiss the dialog.
-    ErrorMessageDialog {
-        id: streamSegueErrorDialog
-
-        property bool quitAfter: false
-
-        onClosed: {
-            if (quitAfter) {
-                Qt.quit()
-            }
-
-            // StreamSegue assumes its dialog will be re-created each time we
-            // start streaming, so fake it by wiping out the text each time.
-            text = ""
-        }
-    }
-
-    NavigableDialog {
-        id: addPcDialog
-        property string label: "Enter the IP address of your GameStream PC:"
-
-        standardButtons: Dialog.Ok | Dialog.Cancel
-
-        onOpened: {
-            // Force keyboard focus on the textbox so keyboard navigation works
-            editText.forceActiveFocus()
-        }
-
-        onAccepted: {
-            if (editText.text) {
-                ComputerManager.addNewHost(editText.text, false)
-            }
-        }
-
-        ColumnLayout {
-            Label {
-                text: addPcDialog.label
-                font.bold: true
-            }
-
-            TextField {
-                id: editText
-                Layout.fillWidth: true
-                focus: true
-
-                Keys.onReturnPressed: {
-                    addPcDialog.accept()
+                Menu {
+                    id: optionsMenu
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                 }
             }
         }

app/gui/sdlgamepadkeynavigation.cpp

@@ -1,266 +0,0 @@
-#include "sdlgamepadkeynavigation.h"
-
-#include <QKeyEvent>
-#include <QGuiApplication>
-#include <QWindow>
-
-#include "settings/mappingmanager.h"
-
-#define AXIS_NAVIGATION_REPEAT_DELAY 150
-
-SdlGamepadKeyNavigation::SdlGamepadKeyNavigation()
-    : m_Enabled(false),
-      m_SettingsMode(false),
-      m_LastAxisNavigationEventTime(0)
-{
-    m_PollingTimer = new QTimer(this);
-    connect(m_PollingTimer, SIGNAL(timeout()), this, SLOT(onPollingTimerFired()));
-}
-
-SdlGamepadKeyNavigation::~SdlGamepadKeyNavigation()
-{
-    disable();
-}
-
-void SdlGamepadKeyNavigation::enable()
-{
-    if (m_Enabled) {
-        return;
-    }
-
-    // We have to initialize and uninitialize this in enable()/disable()
-    // because we need to get out of the way of the Session class. If it
-    // doesn't get to reinitialize the GC subsystem, it won't get initial
-    // arrival events. Additionally, there's a race condition between
-    // our QML objects being destroyed and SDL being deinitialized that
-    // this solves too.
-    if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) failed: %s",
-                     SDL_GetError());
-        return;
-    }
-
-    MappingManager mappingManager;
-    mappingManager.applyMappings();
-
-    // Drop all pending gamepad add events. SDL will generate these for us
-    // on first init of the GC subsystem. We can't depend on them due to
-    // overlapping lifetimes of SdlGamepadKeyNavigation instances, so we
-    // will attach ourselves.
-    SDL_PumpEvents();
-    SDL_FlushEvent(SDL_CONTROLLERDEVICEADDED);
-
-    // Open all currently attached game controllers
-    for (int i = 0; i < SDL_NumJoysticks(); i++) {
-        if (SDL_IsGameController(i)) {
-            SDL_GameController* gc = SDL_GameControllerOpen(i);
-            if (gc != nullptr) {
-                m_Gamepads.append(gc);
-            }
-        }
-    }
-
-    // Poll every 50 ms for a new joystick event
-    m_PollingTimer->start(50);
-
-    m_Enabled = true;
-}
-
-void SdlGamepadKeyNavigation::disable()
-{
-    if (!m_Enabled) {
-        return;
-    }
-
-    m_PollingTimer->stop();
-
-    while (!m_Gamepads.isEmpty()) {
-        SDL_GameControllerClose(m_Gamepads[0]);
-        m_Gamepads.removeAt(0);
-    }
-
-    SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
-
-    m_Enabled = false;
-}
-
-void SdlGamepadKeyNavigation::onPollingTimerFired()
-{
-    SDL_Event event;
-
-    while (SDL_PollEvent(&event)) {
-        switch (event.type) {
-        case SDL_QUIT:
-            // SDL may send us a quit event since we initialize
-            // the video subsystem on startup. If we get one,
-            // forward it on for Qt to take care of.
-            QCoreApplication::instance()->quit();
-            break;
-        case SDL_CONTROLLERBUTTONDOWN:
-        case SDL_CONTROLLERBUTTONUP:
-        {
-            QEvent::Type type =
-                    event.type == SDL_CONTROLLERBUTTONDOWN ?
-                        QEvent::Type::KeyPress : QEvent::Type::KeyRelease;
-
-            switch (event.cbutton.button) {
-            case SDL_CONTROLLER_BUTTON_DPAD_UP:
-                if (m_SettingsMode) {
-                    // Back-tab
-                    sendKey(type, Qt::Key_Tab, Qt::ShiftModifier);
-                }
-                else {
-                    sendKey(type, Qt::Key_Up);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_DPAD_DOWN:
-                if (m_SettingsMode) {
-                    sendKey(type, Qt::Key_Tab);
-                }
-                else {
-                    sendKey(type, Qt::Key_Down);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_DPAD_LEFT:
-                sendKey(type, Qt::Key_Left);
-                if (m_SettingsMode) {
-                    // Some settings controls respond to left/right (like the slider)
-                    // and others respond to up/down (like combo boxes). They seem to
-                    // be mutually exclusive though so let's just send both.
-                    sendKey(type, Qt::Key_Up);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_DPAD_RIGHT:
-                sendKey(type, Qt::Key_Right);
-                if (m_SettingsMode) {
-                    // Some settings controls respond to left/right (like the slider)
-                    // and others respond to up/down (like combo boxes). They seem to
-                    // be mutually exclusive though so let's just send both.
-                    sendKey(type, Qt::Key_Down);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_A:
-                if (m_SettingsMode) {
-                    sendKey(type, Qt::Key_Space);
-                }
-                else {
-                    sendKey(type, Qt::Key_Return);
-                }
-                break;
-            case SDL_CONTROLLER_BUTTON_B:
-                sendKey(type, Qt::Key_Escape);
-                break;
-            case SDL_CONTROLLER_BUTTON_X:
-                sendKey(type, Qt::Key_Menu);
-                break;
-            case SDL_CONTROLLER_BUTTON_Y:
-            case SDL_CONTROLLER_BUTTON_START:
-                // HACK: We use this keycode to inform main.qml
-                // to show the settings when Key_Menu is handled
-                // by the control in focus.
-                sendKey(type, Qt::Key_Hangup);
-                break;
-            default:
-                break;
-            }
-            break;
-        }
-        case SDL_CONTROLLERDEVICEADDED:
-            SDL_GameController* gc = SDL_GameControllerOpen(event.cdevice.which);
-            if (gc != nullptr) {
-                m_Gamepads.append(gc);
-            }
-            break;
-        }
-    }
-
-    // Handle analog sticks by polling
-    for (auto gc : m_Gamepads) {
-        short leftX = SDL_GameControllerGetAxis(gc, SDL_CONTROLLER_AXIS_LEFTX);
-        short leftY = SDL_GameControllerGetAxis(gc, SDL_CONTROLLER_AXIS_LEFTY);
-        if (SDL_GetTicks() - m_LastAxisNavigationEventTime < AXIS_NAVIGATION_REPEAT_DELAY) {
-            // Do nothing
-        }
-        else if (leftY < -30000) {
-            if (m_SettingsMode) {
-                // Back-tab
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Tab, Qt::ShiftModifier);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Tab, Qt::ShiftModifier);
-            }
-            else {
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Up);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Up);
-            }
-
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-        else if (leftY > 30000) {
-            if (m_SettingsMode) {
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Tab);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Tab);
-            }
-            else {
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Down);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Down);
-            }
-
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-        else if (leftX < -30000) {
-            sendKey(QEvent::Type::KeyPress, Qt::Key_Left);
-            sendKey(QEvent::Type::KeyRelease, Qt::Key_Left);
-            if (m_SettingsMode) {
-                // Some settings controls respond to left/right (like the slider)
-                // and others respond to up/down (like combo boxes). They seem to
-                // be mutually exclusive though so let's just send both.
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Up);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Up);
-            }
-
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-        else if (leftX > 30000) {
-            sendKey(QEvent::Type::KeyPress, Qt::Key_Right);
-            sendKey(QEvent::Type::KeyRelease, Qt::Key_Right);
-            if (m_SettingsMode) {
-                // Some settings controls respond to left/right (like the slider)
-                // and others respond to up/down (like combo boxes). They seem to
-                // be mutually exclusive though so let's just send both.
-                sendKey(QEvent::Type::KeyPress, Qt::Key_Down);
-                sendKey(QEvent::Type::KeyRelease, Qt::Key_Down);
-            }
-
-            m_LastAxisNavigationEventTime = SDL_GetTicks();
-        }
-    }
-}
-
-void SdlGamepadKeyNavigation::sendKey(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers)
-{
-    QGuiApplication* app = static_cast<QGuiApplication*>(QGuiApplication::instance());
-    QWindow* focusWindow = app->focusWindow();
-    if (focusWindow != nullptr) {
-        QKeyEvent keyPressEvent(type, key, modifiers);
-        app->sendEvent(focusWindow, &keyPressEvent);
-    }
-}
-
-void SdlGamepadKeyNavigation::setSettingsMode(bool settingsMode)
-{
-    m_SettingsMode = settingsMode;
-}
-
-int SdlGamepadKeyNavigation::getConnectedGamepads()
-{
-    Q_ASSERT(m_Enabled);
-
-    int count = 0;
-    for (int i = 0; i < SDL_NumJoysticks(); i++) {
-        if (SDL_IsGameController(i)) {
-            count++;
-        }
-    }
-
-    return count;
-}

app/gui/sdlgamepadkeynavigation.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <QTimer>
-#include <QEvent>
-
-#include <SDL.h>
-
-class SdlGamepadKeyNavigation : public QObject
-{
-    Q_OBJECT
-
-public:
-    SdlGamepadKeyNavigation();
-
-    ~SdlGamepadKeyNavigation();
-
-    Q_INVOKABLE void enable();
-
-    Q_INVOKABLE void disable();
-
-    Q_INVOKABLE void setSettingsMode(bool settingsMode);
-
-    Q_INVOKABLE int getConnectedGamepads();
-
-private:
-    void sendKey(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
-
-private slots:
-    void onPollingTimerFired();
-
-private:
-    QTimer* m_PollingTimer;
-    QList<SDL_GameController*> m_Gamepads;
-    bool m_Enabled;
-    bool m_SettingsMode;
-    Uint32 m_LastAxisNavigationEventTime;
-};

app/main.cpp

@@ -1,14 +1,7 @@
 #include <QGuiApplication>
 #include <QQmlApplicationEngine>
-#include <QQmlContext>
 #include <QIcon>
 #include <QQuickStyle>
-#include <QMutex>
-#include <QtDebug>
-#include <QNetworkProxyFactory>
-#include <QPalette>
-#include <QFont>
-#include <QCursor>
 
 // Don't let SDL hook our main function, since Qt is already
 // doing the same thing. This needs to be before any headers
@@ -16,462 +9,64 @@
 #define SDL_MAIN_HANDLED
 #include <SDL.h>
 
-#ifdef HAVE_FFMPEG
-#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"
 #include "gui/computermodel.h"
 #include "gui/appmodel.h"
-#include "backend/autoupdatechecker.h"
-#include "backend/systemproperties.h"
-#include "streaming/session.h"
+#include "streaming/session.hpp"
 #include "settings/streamingpreferences.h"
-#include "gui/sdlgamepadkeynavigation.h"
-
-#if !defined(QT_DEBUG) && defined(Q_OS_WIN32)
-// Log to file for release Windows builds
-#define USE_CUSTOM_LOGGER
-#define LOG_TO_FILE
-#elif defined(Q_OS_UNIX) && !defined(Q_OS_DARWIN)
-// Use stdout logger on all Linux/BSD builds
-#define USE_CUSTOM_LOGGER
-#elif !defined(QT_DEBUG) && defined(Q_OS_DARWIN)
-// Log to file for release Mac builds
-#define USE_CUSTOM_LOGGER
-#define LOG_TO_FILE
-#else
-// For debug Windows and Mac builds, use default logger
-#endif
-
-#ifdef USE_CUSTOM_LOGGER
-static QTime s_LoggerTime;
-static QTextStream s_LoggerStream(stdout);
-static QMutex s_LoggerLock;
-#ifdef LOG_TO_FILE
-#define MAX_LOG_LINES 10000
-static int s_LogLinesWritten = 0;
-static bool s_LogLimitReached = false;
-static QFile* s_LoggerFile;
-#endif
-
-void logToLoggerStream(QString& message)
-{
-    QMutexLocker lock(&s_LoggerLock);
-
-#ifdef LOG_TO_FILE
-    if (s_LogLimitReached) {
-        return;
-    }
-    else if (s_LogLinesWritten == MAX_LOG_LINES) {
-        s_LoggerStream << "Log size limit reached!" << endl;
-        s_LogLimitReached = true;
-        return;
-    }
-    else {
-        s_LogLinesWritten++;
-    }
-#endif
-
-    s_LoggerStream << message;
-    s_LoggerStream.flush();
-}
-
-void sdlLogToDiskHandler(void*, int category, SDL_LogPriority priority, const char* message)
-{
-    QString priorityTxt;
-
-    switch (priority) {
-    case SDL_LOG_PRIORITY_VERBOSE:
-        priorityTxt = "Verbose";
-        break;
-    case SDL_LOG_PRIORITY_DEBUG:
-        priorityTxt = "Debug";
-        break;
-    case SDL_LOG_PRIORITY_INFO:
-        priorityTxt = "Info";
-        break;
-    case SDL_LOG_PRIORITY_WARN:
-        priorityTxt = "Warn";
-        break;
-    case SDL_LOG_PRIORITY_ERROR:
-        priorityTxt = "Error";
-        break;
-    case SDL_LOG_PRIORITY_CRITICAL:
-        priorityTxt = "Critical";
-        break;
-    default:
-        priorityTxt = "Unknown";
-        break;
-    }
-
-    QTime logTime = QTime::fromMSecsSinceStartOfDay(s_LoggerTime.elapsed());
-    QString txt = QString("%1 - SDL %2 (%3): %4\n").arg(logTime.toString()).arg(priorityTxt).arg(category).arg(message);
-
-    logToLoggerStream(txt);
-}
-
-void qtLogToDiskHandler(QtMsgType type, const QMessageLogContext&, const QString& msg)
-{
-    QString typeTxt;
-
-    switch (type) {
-    case QtDebugMsg:
-        typeTxt = "Debug";
-        break;
-    case QtInfoMsg:
-        typeTxt = "Info";
-        break;
-    case QtWarningMsg:
-        typeTxt = "Warning";
-        break;
-    case QtCriticalMsg:
-        typeTxt = "Critical";
-        break;
-    case QtFatalMsg:
-        typeTxt = "Fatal";
-        break;
-    }
-
-    QTime logTime = QTime::fromMSecsSinceStartOfDay(s_LoggerTime.elapsed());
-    QString txt = QString("%1 - Qt %2: %3\n").arg(logTime.toString()).arg(typeTxt).arg(msg);
-
-    logToLoggerStream(txt);
-}
-
-#ifdef HAVE_FFMPEG
-
-void ffmpegLogToDiskHandler(void* ptr, int level, const char* fmt, va_list vl)
-{
-    char lineBuffer[1024];
-    static int printPrefix = 1;
-
-    if ((level & 0xFF) > av_log_get_level()) {
-        return;
-    }
-
-    av_log_format_line(ptr, level, fmt, vl, lineBuffer, sizeof(lineBuffer), &printPrefix);
-
-    QTime logTime = QTime::fromMSecsSinceStartOfDay(s_LoggerTime.elapsed());
-    QString txt = QString("%1 - FFmpeg: %2").arg(logTime.toString()).arg(lineBuffer);
-
-    logToLoggerStream(txt);
-}
-
-#endif
-
-#endif
-
-#ifdef Q_OS_WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
-#include <DbgHelp.h>
-
-static UINT s_HitUnhandledException = 0;
-
-LONG WINAPI UnhandledExceptionHandler(struct _EXCEPTION_POINTERS *ExceptionInfo)
-{
-    // Only write a dump for the first unhandled exception
-    if (InterlockedCompareExchange(&s_HitUnhandledException, 1, 0) != 0) {
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    WCHAR dmpFileName[MAX_PATH];
-    swprintf_s(dmpFileName, L"%ls\\Moonlight-%I64u.dmp",
-               (PWCHAR)QDir::toNativeSeparators(Path::getLogDir()).utf16(), QDateTime::currentSecsSinceEpoch());
-    QString qDmpFileName = QString::fromUtf16((unsigned short*)dmpFileName);
-    HANDLE dumpHandle = CreateFileW(dmpFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if (dumpHandle != INVALID_HANDLE_VALUE) {
-        MINIDUMP_EXCEPTION_INFORMATION info;
-
-        info.ThreadId = GetCurrentThreadId();
-        info.ExceptionPointers = ExceptionInfo;
-        info.ClientPointers = FALSE;
-
-        DWORD typeFlags = MiniDumpWithIndirectlyReferencedMemory |
-                MiniDumpIgnoreInaccessibleMemory |
-                MiniDumpWithUnloadedModules |
-                MiniDumpWithThreadInfo;
-
-        if (MiniDumpWriteDump(GetCurrentProcess(),
-                               GetCurrentProcessId(),
-                               dumpHandle,
-                               (MINIDUMP_TYPE)typeFlags,
-                               &info,
-                               nullptr,
-                               nullptr)) {
-            qCritical() << "Unhandled exception! Minidump written to:" << qDmpFileName;
-        }
-        else {
-            qCritical() << "Unhandled exception! Failed to write dump:" << GetLastError();
-        }
-
-        CloseHandle(dumpHandle);
-    }
-    else {
-        qCritical() << "Unhandled exception! Failed to open dump file:" << qDmpFileName << "with error" << GetLastError();
-    }
-
-    // Let the program crash and WER collect a dump
-    return EXCEPTION_CONTINUE_SEARCH;
-}
-
-#endif
 
 int main(int argc, char *argv[])
 {
-    SDL_SetMainReady();
-
-    // 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().
-    QCoreApplication::setOrganizationName("Moonlight Game Streaming Project");
-    QCoreApplication::setOrganizationDomain("moonlight-stream.com");
-    QCoreApplication::setApplicationName("Moonlight");
-
-    if (QFile(QDir::currentPath() + "/portable.dat").exists()) {
-        qInfo() << "Running in portable mode from:" << QDir::currentPath();
-        QSettings::setDefaultFormat(QSettings::IniFormat);
-        QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, QDir::currentPath());
-        QSettings::setPath(QSettings::IniFormat, QSettings::SystemScope, QDir::currentPath());
-
-        // Initialize paths for portable mode
-        Path::initialize(true);
-    }
-    else {
-        // Initialize paths for standard installation
-        Path::initialize(false);
-    }
-
-#ifdef USE_CUSTOM_LOGGER
-#ifdef LOG_TO_FILE
-    QDir tempDir(Path::getLogDir());
-    s_LoggerFile = new QFile(tempDir.filePath(QString("Moonlight-%1.log").arg(QDateTime::currentSecsSinceEpoch())));
-    if (s_LoggerFile->open(QIODevice::WriteOnly)) {
-        qInfo() << "Redirecting log output to " << s_LoggerFile->fileName();
-        s_LoggerStream.setDevice(s_LoggerFile);
-    }
-#endif
-
-    s_LoggerTime.start();
-    qInstallMessageHandler(qtLogToDiskHandler);
-    SDL_LogSetOutputFunction(sdlLogToDiskHandler, nullptr);
-
-#ifdef HAVE_FFMPEG
-    av_log_set_callback(ffmpegLogToDiskHandler);
-#endif
-
-#endif
-
-#ifdef Q_OS_WIN32
-    // Create a crash dump when we crash on Windows
-    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
     // password prompts on macOS.
-    qputenv("QT_SSL_USE_TEMPORARY_KEYCHAIN", "1");
+    qputenv("QT_SSL_USE_TEMPORARY_KEYCHAIN", QByteArray("1"));
 
-#ifdef Q_OS_WIN32
-    if (!qEnvironmentVariableIsSet("QT_OPENGL")) {
-        // On Windows, use ANGLE so we don't have to load OpenGL
-        // user-mode drivers into our app. OGL drivers (especially Intel)
-        // seem to crash Moonlight far more often than DirectX.
-        qputenv("QT_OPENGL", "angle");
-    }
-#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);
+    // Set these here to allow us to use the default QSettings constructor
+    QCoreApplication::setOrganizationName("Moonlight Game Streaming Project");
+    QCoreApplication::setOrganizationDomain("moonlight-stream.com");
+    QCoreApplication::setApplicationName("Moonlight");
 
     // Register custom metatypes for use in signals
     qRegisterMetaType<NvApp>("NvApp");
 
-    // Allow the display to sleep by default. We will manually use SDL_DisableScreenSaver()
-    // and SDL_EnableScreenSaver() when appropriate. This hint must be set before
-    // initializing the SDL video subsystem to have any effect.
-    SDL_SetHint(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, "1");
-
-    if (SDL_InitSubSystem(SDL_INIT_TIMER) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_TIMER) failed: %s",
-                     SDL_GetError());
-        return -1;
-    }
-
-#ifdef STEAM_LINK
-    // Steam Link requires that we initialize video before creating our
-    // QGuiApplication in order to configure the framebuffer correctly.
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return -1;
-    }
-#endif
-
-    // Use atexit() to ensure SDL_Quit() is called. This avoids
-    // racing with object destruction where SDL may be used.
-    atexit(SDL_Quit);
-
-    // Avoid the default behavior of changing the timer resolution to 1 ms.
-    // We don't want this all the time that Moonlight is open. We will set
-    // it manually when we start streaming.
-    SDL_SetHint(SDL_HINT_TIMER_RESOLUTION, "0");
-
-    // Disable minimize on focus loss by default. Users seem to want this off by default.
-    SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
-
     QGuiApplication app(argc, argv);
 
-    // After the QGuiApplication is created, the platform stuff will be initialized
-    // and we can set the SDL video driver to match Qt.
-    if (qgetenv("XDG_SESSION_TYPE") == "wayland" && QGuiApplication::platformName() == "xcb") {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "Detected XWayland. This will probably break hardware decoding! Try running with QT_QPA_PLATFORM=wayland or switch to X11.");
-    }
-    else if (QGuiApplication::platformName().startsWith("wayland")) {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Detected Wayland. Performance may be worse than X11.");
-        qputenv("SDL_VIDEODRIVER", "wayland");
-    }
-
-#ifdef STEAM_LINK
-    // Qt 5.9 from the Steam Link SDK is not able to load any fonts
-    // since the Steam Link doesn't include any of the ones it looks
-    // for. We know it has NotoSans so we will explicitly ask for that.
-    if (app.font().family().isEmpty()) {
-        qWarning() << "SL HACK: No default font - using NotoSans";
-
-        QFont fon("NotoSans");
-        app.setFont(fon);
-    }
-
-    // Move the mouse to the bottom right so it's invisible when using
-    // gamepad-only navigation.
-    QCursor().setPos(0xFFFF, 0xFFFF);
-#endif
-
     app.setWindowIcon(QIcon(":/res/moonlight.svg"));
 
     // Register our C++ types for QML
     qmlRegisterType<ComputerModel>("ComputerModel", 1, 0, "ComputerModel");
     qmlRegisterType<AppModel>("AppModel", 1, 0, "AppModel");
+    qmlRegisterType<StreamingPreferences>("StreamingPreferences", 1, 0, "StreamingPreferences");
     qmlRegisterUncreatableType<Session>("Session", 1, 0, "Session", "Session cannot be created from QML");
     qmlRegisterSingletonType<ComputerManager>("ComputerManager", 1, 0,
                                               "ComputerManager",
                                               [](QQmlEngine*, QJSEngine*) -> QObject* {
                                                   return new ComputerManager();
                                               });
-    qmlRegisterSingletonType<AutoUpdateChecker>("AutoUpdateChecker", 1, 0,
-                                                "AutoUpdateChecker",
-                                                [](QQmlEngine*, QJSEngine*) -> QObject* {
-                                                    return new AutoUpdateChecker();
-                                                });
-    qmlRegisterSingletonType<SystemProperties>("SystemProperties", 1, 0,
-                                               "SystemProperties",
-                                               [](QQmlEngine*, QJSEngine*) -> QObject* {
-                                                   return new SystemProperties();
-                                               });
-    qmlRegisterSingletonType<SdlGamepadKeyNavigation>("SdlGamepadKeyNavigation", 1, 0,
-                                                      "SdlGamepadKeyNavigation",
-                                                      [](QQmlEngine*, QJSEngine*) -> QObject* {
-                                                          return new SdlGamepadKeyNavigation();
-                                                      });
-    qmlRegisterSingletonType<StreamingPreferences>("StreamingPreferences", 1, 0,
-                                                   "StreamingPreferences",
-                                                   [](QQmlEngine*, QJSEngine*) -> QObject* {
-                                                       return new StreamingPreferences();
-                                                   });
 
-#ifndef Q_OS_WINRT
-    // Use the dense material dark theme by default
-    if (!qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_STYLE")) {
-        qputenv("QT_QUICK_CONTROLS_STYLE", "Material");
-    }
-#else
-    // Use universal dark on WinRT
-    if (!qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_STYLE")) {
-        qputenv("QT_QUICK_CONTROLS_STYLE", "Universal");
-    }
-#endif
-    if (!qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_MATERIAL_THEME")) {
-        qputenv("QT_QUICK_CONTROLS_MATERIAL_THEME", "Dark");
-    }
-    if (!qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_MATERIAL_ACCENT")) {
-        qputenv("QT_QUICK_CONTROLS_MATERIAL_ACCENT", "Purple");
-    }
-    if (!qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_MATERIAL_VARIANT")) {
-        qputenv("QT_QUICK_CONTROLS_MATERIAL_VARIANT", "Dense");
-    }
-    if (!qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_UNIVERSAL_THEME")) {
-        qputenv("QT_QUICK_CONTROLS_UNIVERSAL_THEME", "Dark");
-    }
-
-    QQmlApplicationEngine engine;
-    QString initialView;
-
-    GlobalCommandLineParser parser;
-    switch (parser.parse(app.arguments())) {
-    case GlobalCommandLineParser::NormalStartRequested:
-        initialView = "qrc:/gui/PcView.qml";
-        break;
-    case GlobalCommandLineParser::StreamRequested:
-        {
-            initialView = "qrc:/gui/CliStartStreamSegue.qml";
-            StreamingPreferences* preferences = new StreamingPreferences(&app);
-            StreamCommandLineParser streamParser;
-            streamParser.parse(app.arguments(), preferences);
-            QString host    = streamParser.getHost();
-            QString appName = streamParser.getAppName();
-            auto launcher   = new CliStartStream::Launcher(host, appName, preferences, &app);
-            engine.rootContext()->setContextProperty("launcher", launcher);
-            break;
-        }
-    case GlobalCommandLineParser::QuitRequested:
-        {
-            initialView = "qrc:/gui/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);
+    QQuickStyle::setStyle("Material");
 
     // Load the main.qml file
+    QQmlApplicationEngine engine;
     engine.load(QUrl(QStringLiteral("qrc:/gui/main.qml")));
     if (engine.rootObjects().isEmpty())
         return -1;
 
+    // Ensure that SDL is always initialized since we may need to use it
+    // for non-streaming purposes (like checking on audio devices)
+    SDL_SetMainReady();
+    if (SDL_Init(SDL_INIT_VIDEO |
+                 SDL_INIT_AUDIO |
+                 SDL_INIT_GAMECONTROLLER) != 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "SDL_Init() failed: %s",
+                     SDL_GetError());
+    }
+
     int err = app.exec();
 
-    // Give worker tasks time to properly exit. Fixes PendingQuitTask
-    // sometimes freezing and blocking process exit.
-    QThreadPool::globalInstance()->waitForDone(30000);
+    SDL_Quit();
 
     return err;
 }

app/path.cpp

@@ -1,78 +0,0 @@
-#include "path.h"
-
-#include <QtDebug>
-#include <QDir>
-#include <QStandardPaths>
-#include <QSettings>
-#include <QCoreApplication>
-
-QString Path::s_LogDir;
-QString Path::s_BoxArtCacheDir;
-
-QString Path::getLogDir()
-{
-    Q_ASSERT(!s_LogDir.isEmpty());
-    return s_LogDir;
-}
-
-QString Path::getBoxArtCacheDir()
-{
-    Q_ASSERT(!s_BoxArtCacheDir.isEmpty());
-    return s_BoxArtCacheDir;
-}
-
-QByteArray Path::readDataFile(QString fileName)
-{
-    QFile dataFile(getDataFilePath(fileName));
-    dataFile.open(QIODevice::ReadOnly);
-    return dataFile.readAll();
-}
-
-QString Path::getDataFilePath(QString fileName)
-{
-    QString candidatePath;
-
-    // Check the current directory first
-    candidatePath = QDir(QDir::currentPath()).absoluteFilePath(fileName);
-    if (QFile::exists(candidatePath)) {
-        qInfo() << "Found" << fileName << "at" << candidatePath;
-        return candidatePath;
-    }
-
-    // Now check the data directories (for Linux, in particular)
-    candidatePath = QStandardPaths::locate(QStandardPaths::DataLocation, fileName);
-    if (!candidatePath.isEmpty() && QFile::exists(candidatePath)) {
-        qInfo() << "Found" << fileName << "at" << candidatePath;
-        return candidatePath;
-    }
-
-    // Now try the directory of our app installation (for Windows, if current dir doesn't find it)
-    candidatePath = QDir(QCoreApplication::applicationDirPath()).absoluteFilePath(fileName);
-    if (QFile::exists(candidatePath)) {
-        qInfo() << "Found" << fileName << "at" << candidatePath;
-        return candidatePath;
-    }
-
-    // Return the QRC embedded copy
-    candidatePath = ":/data/" + fileName;
-    qInfo() << "Found" << fileName << "at" << candidatePath;
-    return QString(candidatePath);
-}
-
-void Path::initialize(bool portable)
-{
-    if (portable) {
-        s_LogDir = QDir::currentPath();
-        s_BoxArtCacheDir = QDir::currentPath() + "/boxart";
-    }
-    else {
-#ifdef Q_OS_DARWIN
-        // On macOS, $TMPDIR is some random folder under /var/folders/ that nobody can
-        // easily find, so use the system's global tmp directory instead.
-        s_LogDir = "/tmp";
-#else
-        s_LogDir = QDir::tempPath();
-#endif
-        s_BoxArtCacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + "/boxart";
-    }
-}

app/path.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <QString>
-
-class Path
-{
-public:
-    static QString getLogDir();
-
-    static QString getBoxArtCacheDir();
-
-    static QByteArray readDataFile(QString fileName);
-
-    // Only safe to use directly for Qt classes
-    static QString getDataFilePath(QString fileName);
-
-    static void initialize(bool portable);
-
-private:
-    static QString s_LogDir;
-    static QString s_BoxArtCacheDir;
-};

app/qml.qrc

@@ -6,17 +6,5 @@
         <file>gui/SettingsView.qml</file>
         <file>gui/StreamSegue.qml</file>
         <file>gui/GamepadMapper.qml</file>
-        <file>gui/QuitSegue.qml</file>
-        <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>
-        <file>gui/NavigableMenu.qml</file>
-        <file>gui/ErrorMessageDialog.qml</file>
-        <file>gui/NavigableMessageDialog.qml</file>
-        <file>gui/NavigableDialog.qml</file>
-        <file>gui/CenteredGridView.qml</file>
     </qresource>
 </RCC>

app/res/baseline-cancel-24px.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#fff"><path d="M12 2C6.47 2 2 6.47 2 12s4.47 10 10 10 10-4.47 10-10S17.53 2 12 2zm5 13.59L15.59 17 12 13.41 8.41 17 7 15.59 10.59 12 7 8.41 8.41 7 12 10.59 15.59 7 17 8.41 13.41 12 17 15.59z"/><path d="M0 0h24v24H0z" fill="none"/></svg>

app/res/baseline-error_outline-24px.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#FFFFFF"><path fill="none" d="M0 0h24v24H0V0z"/><path d="M11 15h2v2h-2zm0-8h2v6h-2zm.99-5C6.47 2 2 6.48 2 12s4.47 10 9.99 10C17.52 22 22 17.52 22 12S17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z"/></svg>

app/res/baseline-help_outline-24px.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="#FFFFFF"><path fill="none" d="M0 0h24v24H0z"/><path d="M11 18h2v-2h-2v2zm1-16C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm0-14c-2.21 0-4 1.79-4 4h2c0-1.1.9-2 2-2s2 .9 2 2c0 2-3 1.75-3 5h2c0-2.25 3-2.5 3-5 0-2.21-1.79-4-4-4z"/></svg>

app/res/baseline-lock-24px.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="#FFFFFF" width="24" height="24" viewBox="0 0 24 24">
-    <path d="M0 0h24v24H0z" fill="none"/>
-    <path d="M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zm-6 9c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z"/>
-</svg>

app/res/baseline-play_circle_filled_white-48px.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48" fill="#fff">
-    <path d="M0 0h48v48H0z" fill="none"/>
-    <path d="M24 4C12.95 4 4 12.95 4 24s8.95 20 20 20 20-8.95 20-20S35.05 4 24 4zm-4 29V15l12 9-12 9z"/>
-</svg>

app/res/baseline-warning-24px.svg

@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="#FFFFFF" width="24" height="24" viewBox="0 0 24 24">
-    <path d="M0 0h24v24H0z" fill="none"/>
-    <path d="M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"/>
-</svg>

app/res/moonlight.svg

@@ -1 +1,23 @@
-<?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>
+<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" version="1.0">
+  <defs>
+    <filter id="f1" y="-40%" width="120%" height="220%">
+      <feOffset xmlns="http://www.w3.org/2000/svg" result="offOut" in="SourceAlpha" dy="-100"/>
+      <feGaussianBlur result="blurOut" in="offOut" stdDeviation="200"/>
+      <feBlend in="SourceGraphic" in2="blurOut" mode="normal"/>
+    </filter>
+  </defs>
+  <!-- -105, 521 are within 0.5 pixel-perfect -->
+  <!-- offsetting more to show shadow -->
+  <g transform="translate(-95,530) scale(0.100000,-0.100000)" filter="url(#f1)">
+    <circle cx="4755" cy="1505" r="3700" fill="#565C64">
+     </circle>
+    <path 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" style="fill:#ffffff"/>
+    <path xmlns="http://www.w3.org/2000/svg" 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" style="fill:#ffffff"/>
+    <path 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" style="fill:#ffffff"/>
+    <path 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" style="fill:#ffffff"/>
+    <path 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" style="fill:#ffffff"/>
+    <path 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" style="fill:#ffffff"/>
+    <path 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" style="fill:#ffffff"/>
+    <path 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" style="fill:#ffffff"/>
+  </g>
+</svg>

app/res/update.svg

@@ -1,3 +0,0 @@
-<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>

app/resources.qrc

@@ -5,21 +5,10 @@
         <file>res/ic_videogame_asset_white_48px.svg</file>
         <file>res/ic_tv_white_48px.svg</file>
         <file>res/ic_add_to_queue_white_48px.svg</file>
-        <file>res/baseline-lock-24px.svg</file>
-        <file>res/baseline-play_circle_filled_white-48px.svg</file>
-        <file>res/baseline-warning-24px.svg</file>
-        <file>res/baseline-cancel-24px.svg</file>
         <file>res/no_app_image.png</file>
         <file>res/settings.svg</file>
         <file>res/arrow_left.svg</file>
         <file>res/question_mark.svg</file>
         <file>res/moonlight.svg</file>
-        <file>res/update.svg</file>
-        <file>res/baseline-help_outline-24px.svg</file>
-        <file>res/baseline-error_outline-24px.svg</file>
-    </qresource>
-    <qresource prefix="/data">
-        <file alias="gamecontrollerdb.txt">SDL_GameControllerDB/gamecontrollerdb.txt</file>
-        <file alias="ModeSeven.ttf">ModeSeven.ttf</file>
     </qresource>
 </RCC>

app/settings/mappingmanager.cpp

@@ -1,103 +0,0 @@
-#include "mappingmanager.h"
-#include "path.h"
-
-#include <QDir>
-
-#include <SDL.h>
-
-#define SER_GAMEPADMAPPING "gcmapping"
-
-#define SER_GUID "guid"
-#define SER_MAPPING "mapping"
-
-MappingManager::MappingManager()
-{
-    QSettings settings;
-
-    // First load existing saved mappings. This ensures the user's
-    // hints can always override the old data.
-    int mappingCount = settings.beginReadArray(SER_GAMEPADMAPPING);
-    for (int i = 0; i < mappingCount; i++) {
-        settings.setArrayIndex(i);
-
-        SdlGamepadMapping mapping(settings.value(SER_GUID).toString(), settings.value(SER_MAPPING).toString());
-        addMapping(mapping);
-    }
-    settings.endArray();
-
-    // Finally load mappings from SDL_HINT_GAMECONTROLLERCONFIG
-    QStringList sdlMappings = QString::fromLocal8Bit(SDL_GetHint(SDL_HINT_GAMECONTROLLERCONFIG)).split('\n', QString::SkipEmptyParts);
-    for (QString sdlMapping : sdlMappings) {
-        SdlGamepadMapping mapping(sdlMapping);
-        addMapping(mapping);
-    }
-
-    // Save the updated mappings to settings
-    save();
-}
-
-void MappingManager::save()
-{
-    QSettings settings;
-
-    settings.remove(SER_GAMEPADMAPPING);
-    settings.beginWriteArray(SER_GAMEPADMAPPING);
-    QList<SdlGamepadMapping> mappings = m_Mappings.values();
-    for (int i = 0; i < mappings.count(); i++) {
-        settings.setArrayIndex(i);
-
-        settings.setValue(SER_GUID, mappings[i].getGuid());
-        settings.setValue(SER_MAPPING, mappings[i].getMapping());
-    }
-    settings.endArray();
-}
-
-void MappingManager::applyMappings()
-{
-    QByteArray mappingData = Path::readDataFile("gamecontrollerdb.txt");
-    if (!mappingData.isEmpty()) {
-        int newMappings = SDL_GameControllerAddMappingsFromRW(
-                    SDL_RWFromConstMem(mappingData.constData(), mappingData.size()), 1);
-        if (newMappings < 0) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "Error loading gamepad mappings: %s",
-                         SDL_GetError());
-        }
-        else {
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Loaded %d new gamepad mappings",
-                        newMappings);
-        }
-    }
-    else {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Unable to load gamepad mapping file");
-    }
-
-    QList<SdlGamepadMapping> mappings = m_Mappings.values();
-    for (const SdlGamepadMapping& mapping : mappings) {
-        QString sdlMappingString = mapping.getSdlMappingString();
-        int ret = SDL_GameControllerAddMapping(qPrintable(sdlMappingString));
-        if (ret < 0) {
-            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                        "Unable to add mapping: %s",
-                        qPrintable(sdlMappingString));
-        }
-        else if (ret == 1) {
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Loaded saved user mapping: %s",
-                        qPrintable(sdlMappingString));
-        }
-    }
-}
-
-void MappingManager::addMapping(QString mappingString)
-{
-    SdlGamepadMapping mapping(mappingString);
-    addMapping(mapping);
-}
-
-void MappingManager::addMapping(SdlGamepadMapping& mapping)
-{
-    m_Mappings[mapping.getGuid()] = mapping;
-}

app/settings/mappingmanager.h

@@ -1,74 +0,0 @@
-#pragma once
-
-#include <QSettings>
-
-class SdlGamepadMapping
-{
-public:
-    SdlGamepadMapping() {}
-
-    SdlGamepadMapping(QString string)
-    {
-        QStringList mapping = string.split(",");
-        if (!mapping.isEmpty()) {
-            m_Guid = mapping[0];
-
-            string.remove(0, m_Guid.length() + 1);
-            m_Mapping = string;
-        }
-    }
-
-    SdlGamepadMapping(QString guid, QString mapping)
-        : m_Guid(guid),
-          m_Mapping(mapping)
-    {
-
-    }
-
-    bool operator==(const SdlGamepadMapping& other) const
-    {
-        return m_Guid == other.m_Guid && m_Mapping == other.m_Mapping;
-    }
-
-    QString getGuid() const
-    {
-        return m_Guid;
-    }
-
-    QString getMapping() const
-    {
-        return m_Mapping;
-    }
-
-    QString getSdlMappingString() const
-    {
-        if (m_Guid.isEmpty() || m_Mapping.isEmpty()) {
-            return "";
-        }
-        else {
-            return m_Guid + "," + m_Mapping;
-        }
-    }
-
-private:
-    QString m_Guid;
-    QString m_Mapping;
-};
-
-class MappingManager
-{
-public:
-    MappingManager();
-
-    void addMapping(QString gamepadString);
-
-    void addMapping(SdlGamepadMapping& gamepadMapping);
-
-    void applyMappings();
-
-    void save();
-
-private:
-    QMap<QString, SdlGamepadMapping> m_Mappings;
-};
-

app/settings/streamingpreferences.cpp

@@ -8,24 +8,14 @@
 #define SER_FPS "fps"
 #define SER_BITRATE "bitrate"
 #define SER_FULLSCREEN "fullscreen"
-#define SER_VSYNC "vsync"
 #define SER_GAMEOPTS "gameopts"
 #define SER_HOSTAUDIO "hostaudio"
 #define SER_MULTICONT "multicontroller"
 #define SER_AUDIOCFG "audiocfg"
 #define SER_VIDEOCFG "videocfg"
 #define SER_VIDEODEC "videodec"
-#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"
-#define SER_CONNWARNINGS "connwarnings"
 
-StreamingPreferences::StreamingPreferences(QObject *parent)
-    : QObject(parent)
+StreamingPreferences::StreamingPreferences()
 {
     reload();
 }
@@ -38,27 +28,16 @@ void StreamingPreferences::reload()
     height = settings.value(SER_HEIGHT, 720).toInt();
     fps = settings.value(SER_FPS, 60).toInt();
     bitrateKbps = settings.value(SER_BITRATE, getDefaultBitrate(width, height, fps)).toInt();
-    enableVsync = settings.value(SER_VSYNC, true).toBool();
+    fullScreen = settings.value(SER_FULLSCREEN, true).toBool();
     gameOptimizations = settings.value(SER_GAMEOPTS, true).toBool();
     playAudioOnHost = settings.value(SER_HOSTAUDIO, false).toBool();
     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();
-    connectionWarnings = settings.value(SER_CONNWARNINGS, true).toBool();
     audioConfig = static_cast<AudioConfig>(settings.value(SER_AUDIOCFG,
-                                                  static_cast<int>(AudioConfig::AC_STEREO)).toInt());
+                                                  static_cast<int>(AudioConfig::AC_AUTO)).toInt());
     videoCodecConfig = static_cast<VideoCodecConfig>(settings.value(SER_VIDEOCFG,
                                                   static_cast<int>(VideoCodecConfig::VCC_AUTO)).toInt());
     videoDecoderSelection = static_cast<VideoDecoderSelection>(settings.value(SER_VIDEODEC,
                                                   static_cast<int>(VideoDecoderSelection::VDS_AUTO)).toInt());
-    windowMode = static_cast<WindowMode>(settings.value(SER_WINDOWMODE,
-                                                        // Try to load from the old preference value too
-                                                        static_cast<int>(settings.value(SER_FULLSCREEN, true).toBool() ?
-                                                                             WindowMode::WM_FULLSCREEN : WindowMode::WM_WINDOWED)).toInt());
 }
 
 void StreamingPreferences::save()
@@ -69,41 +48,33 @@ void StreamingPreferences::save()
     settings.setValue(SER_HEIGHT, height);
     settings.setValue(SER_FPS, fps);
     settings.setValue(SER_BITRATE, bitrateKbps);
-    settings.setValue(SER_VSYNC, enableVsync);
+    settings.setValue(SER_FULLSCREEN, fullScreen);
     settings.setValue(SER_GAMEOPTS, gameOptimizations);
     settings.setValue(SER_HOSTAUDIO, playAudioOnHost);
     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_CONNWARNINGS, connectionWarnings);
     settings.setValue(SER_AUDIOCFG, static_cast<int>(audioConfig));
     settings.setValue(SER_VIDEOCFG, static_cast<int>(videoCodecConfig));
     settings.setValue(SER_VIDEODEC, static_cast<int>(videoDecoderSelection));
-    settings.setValue(SER_WINDOWMODE, static_cast<int>(windowMode));
 }
 
 int StreamingPreferences::getDefaultBitrate(int width, int height, int fps)
 {
-    // This table prefers 16:10 resolutions because they are
-    // only slightly more pixels than the 16:9 equivalents, so
-    // we don't want to bump those 16:10 resolutions up to the
-    // next 16:9 slot.
-
-    // This covers 1280x720 and 1280x800 too
-    if (width * height <= 1366 * 768) {
-        return static_cast<int>(5000 * (fps / 30.0));
+    if (width * height * fps <=  1280 * 720 * 30) {
+        return 5000;
     }
-    else if (width * height <= 1920 * 1200) {
-        return static_cast<int>(10000 * (fps / 30.0));
+    else if (width * height * fps <= 1280 * 720 * 60) {
+        return 10000;
     }
-    else if (width * height <= 2560 * 1600) {
-        return static_cast<int>(20000 * (fps / 30.0));
+    else if (width * height * fps <= 1920 * 1080 * 30) {
+        return 10000;
     }
-    else /* if (width * height <= 3840 * 2160) */ {
-        return static_cast<int>(40000 * (fps / 30.0));
+    else if (width * height * fps <= 1920 * 1080 * 60) {
+        return 20000;
+    }
+    else if (width * height * fps <= 3840 * 2160 * 30) {
+        return 40000;
+    }
+    else /* if (width * height * fps <= 3840 * 2160 * 60) */ {
+        return 80000;
     }
 }

app/settings/streamingpreferences.h

@@ -1,14 +1,13 @@
 #pragma once
 
 #include <QObject>
-#include <QRect>
 
 class StreamingPreferences : public QObject
 {
     Q_OBJECT
 
 public:
-    StreamingPreferences(QObject *parent = nullptr);
+    StreamingPreferences();
 
     Q_INVOKABLE static int
     getDefaultBitrate(int width, int height, int fps);
@@ -19,8 +18,9 @@ public:
 
     enum AudioConfig
     {
-        AC_STEREO,
-        AC_51_SURROUND
+        AC_AUTO,
+        AC_FORCE_STEREO,
+        AC_FORCE_SURROUND
     };
     Q_ENUM(AudioConfig)
 
@@ -41,72 +41,40 @@ public:
     };
     Q_ENUM(VideoDecoderSelection)
 
-    enum WindowMode
-    {
-        WM_FULLSCREEN,
-        WM_FULLSCREEN_DESKTOP,
-        WM_WINDOWED
-    };
-    Q_ENUM(WindowMode)
-
     Q_PROPERTY(int width MEMBER width NOTIFY displayModeChanged)
     Q_PROPERTY(int height MEMBER height NOTIFY displayModeChanged)
     Q_PROPERTY(int fps MEMBER fps NOTIFY displayModeChanged)
     Q_PROPERTY(int bitrateKbps MEMBER bitrateKbps NOTIFY bitrateChanged)
-    Q_PROPERTY(bool enableVsync MEMBER enableVsync NOTIFY enableVsyncChanged)
+    Q_PROPERTY(bool fullScreen MEMBER fullScreen NOTIFY fullScreenChanged)
     Q_PROPERTY(bool gameOptimizations MEMBER gameOptimizations NOTIFY gameOptimizationsChanged)
     Q_PROPERTY(bool playAudioOnHost MEMBER playAudioOnHost NOTIFY playAudioOnHostChanged)
     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(bool connectionWarnings MEMBER connectionWarnings NOTIFY connectionWarningsChanged)
     Q_PROPERTY(AudioConfig audioConfig MEMBER audioConfig NOTIFY audioConfigChanged)
     Q_PROPERTY(VideoCodecConfig videoCodecConfig MEMBER videoCodecConfig NOTIFY videoCodecConfigChanged)
     Q_PROPERTY(VideoDecoderSelection videoDecoderSelection MEMBER videoDecoderSelection NOTIFY videoDecoderSelectionChanged)
-    Q_PROPERTY(WindowMode windowMode MEMBER windowMode NOTIFY windowModeChanged)
 
     // Directly accessible members for preferences
     int width;
     int height;
     int fps;
     int bitrateKbps;
-    bool enableVsync;
+    bool fullScreen;
     bool gameOptimizations;
     bool playAudioOnHost;
     bool multiController;
-    bool unsupportedFps;
-    bool enableMdns;
-    bool quitAppAfter;
-    bool mouseAcceleration;
-    bool startWindowed;
-    bool framePacing;
-    bool connectionWarnings;
     AudioConfig audioConfig;
     VideoCodecConfig videoCodecConfig;
     VideoDecoderSelection videoDecoderSelection;
-    WindowMode windowMode;
 
 signals:
     void displayModeChanged();
     void bitrateChanged();
-    void enableVsyncChanged();
+    void fullScreenChanged();
     void gameOptimizationsChanged();
     void playAudioOnHostChanged();
     void multiControllerChanged();
-    void unsupportedFpsChanged();
-    void enableMdnsChanged();
-    void quitAppAfterChanged();
-    void mouseAccelerationChanged();
     void audioConfigChanged();
     void videoCodecConfigChanged();
     void videoDecoderSelectionChanged();
-    void windowModeChanged();
-    void startWindowedChanged();
-    void framePacingChanged();
-    void connectionWarningsChanged();
 };
 

app/streaming/audio.cpp

@@ -0,0 +1,198 @@
+#include "session.hpp"
+
+#include <Limelight.h>
+#include <SDL.h>
+
+#define MAX_CHANNELS 6
+#define SAMPLES_PER_FRAME 240
+#define MIN_QUEUED_FRAMES 2
+#define MAX_QUEUED_FRAMES 4
+#define STOP_THE_WORLD_LIMIT 20
+#define DROP_RATIO_DENOM 32
+
+SDL_AudioDeviceID Session::s_AudioDevice;
+OpusMSDecoder* Session::s_OpusDecoder;
+short Session::s_OpusDecodeBuffer[MAX_CHANNELS * SAMPLES_PER_FRAME];
+int Session::s_ChannelCount;
+int Session::s_PendingDrops;
+int Session::s_PendingHardDrops;
+unsigned int Session::s_SampleIndex;
+Uint32 Session::s_BaselinePendingData;
+
+int Session::sdlDetermineAudioConfiguration()
+{
+    SDL_AudioSpec want, have;
+    SDL_AudioDeviceID dev;
+
+    SDL_zero(want);
+    want.freq = 48000;
+    want.format = AUDIO_S16;
+    want.channels = 6;
+    want.samples = 1024;
+
+    // Try to open for 5.1 surround sound, but allow SDL to tell us that's
+    // not available.
+    dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, SDL_AUDIO_ALLOW_CHANNELS_CHANGE);
+    if (dev == 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "Failed to open audio device");
+        // We'll probably have issues during audio stream init, but we'll
+        // try anyway
+        return AUDIO_CONFIGURATION_STEREO;
+    }
+
+    SDL_CloseAudioDevice(dev);
+
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "Audio device has %d channels", have.channels);
+
+    if (have.channels > 2) {
+        // We don't support quadraphonic or 7.1 surround, but SDL
+        // should be able to downmix or upmix better from 5.1 than
+        // from stereo, so use 5.1 in non-stereo cases.
+        return AUDIO_CONFIGURATION_51_SURROUND;
+    }
+    else {
+        return AUDIO_CONFIGURATION_STEREO;
+    }
+}
+
+int Session::sdlAudioInit(int /* audioConfiguration */,
+                          POPUS_MULTISTREAM_CONFIGURATION opusConfig,
+                          void* /* arContext */, int /* arFlags */)
+{
+    SDL_AudioSpec want, have;
+    int error;
+
+    SDL_zero(want);
+    want.freq = opusConfig->sampleRate;
+    want.format = AUDIO_S16;
+    want.channels = opusConfig->channelCount;
+
+    // This is supposed to be a power of 2, but our
+    // frames contain a non-power of 2 number of samples,
+    // so the slop would require buffering another full frame.
+    // Specifying non-Po2 seems to work for our supported platforms.
+    want.samples = SAMPLES_PER_FRAME;
+
+    s_AudioDevice = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
+    if (s_AudioDevice == 0) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "Failed to open audio device: %s",
+                     SDL_GetError());
+        return -1;
+    }
+
+    s_OpusDecoder = opus_multistream_decoder_create(opusConfig->sampleRate,
+                                                    opusConfig->channelCount,
+                                                    opusConfig->streams,
+                                                    opusConfig->coupledStreams,
+                                                    opusConfig->mapping,
+                                                    &error);
+    if (s_OpusDecoder == NULL) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "Failed to create decoder: %d",
+                     error);
+        SDL_CloseAudioDevice(s_AudioDevice);
+        s_AudioDevice = 0;
+        return -2;
+    }
+
+    // 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.
+    s_BaselinePendingData = 0;
+#ifdef _WIN32
+    for (int i = 0; i < 100; i++) {
+        s_BaselinePendingData = qMax(s_BaselinePendingData, SDL_GetQueuedAudioSize(s_AudioDevice));
+        SDL_Delay(10);
+    }
+#endif
+    s_BaselinePendingData *= 2;
+    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                "Baseline pending audio data: %d bytes",
+                s_BaselinePendingData);
+
+    s_ChannelCount = opusConfig->channelCount;
+    s_SampleIndex = 0;
+    s_PendingDrops = s_PendingHardDrops = 0;
+
+    return 0;
+}
+
+void Session::sdlAudioStart()
+{
+    // Unpause the audio device
+    SDL_PauseAudioDevice(s_AudioDevice, 0);
+}
+
+void Session::sdlAudioStop()
+{
+    // Pause the audio device
+    SDL_PauseAudioDevice(s_AudioDevice, 1);
+}
+
+void Session::sdlAudioCleanup()
+{
+    SDL_CloseAudioDevice(s_AudioDevice);
+    s_AudioDevice = 0;
+
+    opus_multistream_decoder_destroy(s_OpusDecoder);
+    s_OpusDecoder = NULL;
+}
+
+void Session::sdlAudioDecodeAndPlaySample(char* sampleData, int sampleLength)
+{
+    int samplesDecoded;
+
+    s_SampleIndex++;
+
+    Uint32 queuedAudio = qMax((int)SDL_GetQueuedAudioSize(s_AudioDevice) - (int)s_BaselinePendingData, 0);
+    Uint32 framesQueued = queuedAudio / (SAMPLES_PER_FRAME * s_ChannelCount * sizeof(short));
+
+    // Pend enough drops to get us back to MIN_QUEUED_FRAMES
+    if (framesQueued - s_PendingHardDrops > STOP_THE_WORLD_LIMIT) {
+        s_PendingHardDrops = framesQueued - MIN_QUEUED_FRAMES;
+        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                    "Pending hard drop of %u audio frames",
+                    s_PendingHardDrops);
+    }
+    else if (framesQueued - s_PendingHardDrops - s_PendingDrops > MAX_QUEUED_FRAMES) {
+        s_PendingDrops = framesQueued - MIN_QUEUED_FRAMES;
+    }
+
+    // Determine if this frame should be dropped
+    if (framesQueued <= MIN_QUEUED_FRAMES) {
+        s_PendingDrops = s_PendingHardDrops = 0;
+    }
+    else if (s_PendingHardDrops != 0) {
+        // Hard drops happen all at once to forcefully
+        // resync with the source.
+        s_PendingHardDrops--;
+        return;
+    }
+    else if (s_PendingDrops != 0 && s_SampleIndex % DROP_RATIO_DENOM == 0) {
+        // Normal drops are interspersed with the audio data
+        // to hide the glitches.
+        s_PendingDrops--;
+        return;
+    }
+
+    samplesDecoded = opus_multistream_decode(s_OpusDecoder,
+                                             (unsigned char*)sampleData,
+                                             sampleLength,
+                                             s_OpusDecodeBuffer,
+                                             SAMPLES_PER_FRAME,
+                                             0);
+    if (samplesDecoded > 0) {
+        if (SDL_QueueAudio(s_AudioDevice,
+                           s_OpusDecodeBuffer,
+                           sizeof(short) * samplesDecoded * s_ChannelCount) < 0) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                         "Failed to queue audio sample: %s",
+                         SDL_GetError());
+        }
+    }
+}

app/streaming/audio/audio.cpp

@@ -1,191 +0,0 @@
-#include "../session.h"
-#include "renderers/renderer.h"
-
-#ifdef HAVE_SOUNDIO
-#include "renderers/soundioaudiorenderer.h"
-#endif
-
-#ifdef HAVE_SLAUDIO
-#include "renderers/slaud.h"
-#endif
-
-#include "renderers/sdl.h"
-
-#include <Limelight.h>
-
-IAudioRenderer* Session::createAudioRenderer()
-{
-#if defined(HAVE_SOUNDIO)
-    if (qgetenv("ML_AUDIO") == "SDL") {
-        return new SdlAudioRenderer();
-    }
-
-    return new SoundIoAudioRenderer();
-#elif defined(HAVE_SLAUDIO)
-    return new SLAudioRenderer();
-#else
-    return new SdlAudioRenderer();
-#endif
-}
-
-bool Session::testAudio(int audioConfiguration)
-{
-    IAudioRenderer* audioRenderer;
-
-    audioRenderer = createAudioRenderer();
-    if (audioRenderer == nullptr) {
-        return false;
-    }
-
-    // Build a fake OPUS_MULTISTREAM_CONFIGURATION to give
-    // the renderer the channel count and sample rate.
-    OPUS_MULTISTREAM_CONFIGURATION opusConfig = {};
-    opusConfig.sampleRate = 48000;
-
-    switch (audioConfiguration)
-    {
-    case AUDIO_CONFIGURATION_STEREO:
-        opusConfig.channelCount = 2;
-        break;
-    case AUDIO_CONFIGURATION_51_SURROUND:
-        opusConfig.channelCount = 6;
-        break;
-    default:
-        SDL_assert(false);
-        return false;
-    }
-
-    bool ret = audioRenderer->prepareForPlayback(&opusConfig);
-
-    delete audioRenderer;
-
-    return ret;
-}
-
-int Session::arInit(int /* audioConfiguration */,
-                    const POPUS_MULTISTREAM_CONFIGURATION opusConfig,
-                    void* /* arContext */, int /* arFlags */)
-{
-    int error;
-
-    SDL_memcpy(&s_ActiveSession->m_AudioConfig, opusConfig, sizeof(*opusConfig));
-
-    s_ActiveSession->m_OpusDecoder =
-            opus_multistream_decoder_create(opusConfig->sampleRate,
-                                            opusConfig->channelCount,
-                                            opusConfig->streams,
-                                            opusConfig->coupledStreams,
-                                            opusConfig->mapping,
-                                            &error);
-    if (s_ActiveSession->m_OpusDecoder == NULL) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to create decoder: %d",
-                     error);
-        return -1;
-    }
-
-    s_ActiveSession->m_AudioRenderer = s_ActiveSession->createAudioRenderer();
-    if (!s_ActiveSession->m_AudioRenderer->prepareForPlayback(opusConfig)) {
-        delete s_ActiveSession->m_AudioRenderer;
-        opus_multistream_decoder_destroy(s_ActiveSession->m_OpusDecoder);
-        return -2;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Audio stream has %d channels",
-                opusConfig->channelCount);
-
-    return 0;
-}
-
-void Session::arCleanup()
-{
-    delete s_ActiveSession->m_AudioRenderer;
-    s_ActiveSession->m_AudioRenderer = nullptr;
-
-    opus_multistream_decoder_destroy(s_ActiveSession->m_OpusDecoder);
-    s_ActiveSession->m_OpusDecoder = nullptr;
-}
-
-void Session::arDecodeAndPlaySample(char* sampleData, int sampleLength)
-{
-    int samplesDecoded;
-
-#ifndef STEAM_LINK
-    // Set this thread to high priority to reduce the chance of missing
-    // our sample delivery time. On Steam Link, this causes starvation
-    // of other threads due to severely restricted CPU time available,
-    // so we will skip it on that platform.
-    if (s_ActiveSession->m_AudioSampleCount == 0) {
-        if (SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH) < 0) {
-            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                        "Unable to set audio thread to high priority: %s",
-                        SDL_GetError());
-        }
-    }
-#endif
-
-    // See if we need to drop this sample
-    if (s_ActiveSession->m_DropAudioEndTime != 0) {
-        if (SDL_TICKS_PASSED(SDL_GetTicks(), s_ActiveSession->m_DropAudioEndTime)) {
-            // Avoid calling SDL_GetTicks() now
-            s_ActiveSession->m_DropAudioEndTime = 0;
-
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Audio drop window has ended");
-        }
-        else {
-            // We're still in the drop window
-            return;
-        }
-    }
-
-    s_ActiveSession->m_AudioSampleCount++;
-
-    if (s_ActiveSession->m_AudioRenderer != nullptr) {
-        samplesDecoded = opus_multistream_decode(s_ActiveSession->m_OpusDecoder,
-                                                 (unsigned char*)sampleData,
-                                                 sampleLength,
-                                                 s_ActiveSession->m_OpusDecodeBuffer,
-                                                 SAMPLES_PER_FRAME,
-                                                 0);
-        if (samplesDecoded > 0) {
-            if (!s_ActiveSession->m_AudioRenderer->submitAudio(s_ActiveSession->m_OpusDecodeBuffer,
-                                                               static_cast<int>(
-                                                                   sizeof(short) *
-                                                                   samplesDecoded *
-                                                                   s_ActiveSession->m_AudioConfig.channelCount))) {
-
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                            "Reinitializing audio renderer after failure");
-
-                delete s_ActiveSession->m_AudioRenderer;
-                s_ActiveSession->m_AudioRenderer = nullptr;
-            }
-        }
-    }
-
-    // Only try to recreate the audio renderer every 200 samples (1 second)
-    // to avoid thrashing if the audio device is unavailable. It is
-    // safe to reinitialize here because we can't be torn down while
-    // the audio decoder/playback thread is still alive.
-    if (s_ActiveSession->m_AudioRenderer == nullptr && (s_ActiveSession->m_AudioSampleCount % 200) == 0) {
-        // Since we're doing this inline and audio initialization takes time, we need
-        // to drop samples to account for the time we've spent blocking audio rendering
-        // so we return to real-time playback and don't accumulate latency.
-        Uint32 audioReinitStartTime = SDL_GetTicks();
-
-        s_ActiveSession->m_AudioRenderer = s_ActiveSession->createAudioRenderer();
-        if (!s_ActiveSession->m_AudioRenderer->prepareForPlayback(&s_ActiveSession->m_AudioConfig)) {
-            delete s_ActiveSession->m_AudioRenderer;
-            s_ActiveSession->m_AudioRenderer = nullptr;
-        }
-
-        Uint32 audioReinitStopTime = SDL_GetTicks();
-
-        s_ActiveSession->m_DropAudioEndTime = audioReinitStopTime + (audioReinitStopTime - audioReinitStartTime);
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Audio reinitialization took %d ms - starting drop window",
-                    audioReinitStopTime - audioReinitStartTime);
-    }
-}

app/streaming/audio/renderers/qtaud.cpp

@@ -1,96 +0,0 @@
-#include "qtaud.h"
-
-#include <QDebug>
-
-QtAudioRenderer::QtAudioRenderer()
-    : m_AudioOutput(nullptr),
-      m_OutputDevice(nullptr)
-{
-
-}
-
-QtAudioRenderer::~QtAudioRenderer()
-{
-    delete m_AudioOutput;
-}
-
-bool QtAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig)
-{
-    QAudioFormat format;
-
-    // testAudio() assumes this sample rate
-    Q_ASSERT(opusConfig->sampleRate == 48000);
-
-    format.setSampleRate(opusConfig->sampleRate);
-    format.setChannelCount(opusConfig->channelCount);
-    format.setSampleSize(16);
-    format.setSampleType(QAudioFormat::SignedInt);
-    format.setCodec("audio/pcm");
-
-    m_AudioOutput = new QAudioOutput(format);
-
-    // Buffer 40 ms of audio data
-    m_AudioOutput->setBufferSize(format.bytesForDuration(40000));
-
-    m_OutputDevice = m_AudioOutput->start();
-    if (m_OutputDevice == nullptr) {
-        qWarning() << "Audio start failed:" << m_AudioOutput->error();
-        return false;
-    }
-
-    // Check what buffer size was really used after starting
-    qInfo() << "Audio stream buffer:" << m_AudioOutput->bufferSize() << "bytes";
-
-    return true;
-}
-
-void QtAudioRenderer::submitAudio(short* audioBuffer, int audioSize)
-{
-    m_OutputDevice->write((const char *)audioBuffer, audioSize);
-}
-
-bool QtAudioRenderer::testAudio(int audioConfiguration)
-{
-    QAudioFormat format;
-
-    format.setSampleRate(48000);
-    format.setSampleSize(16);
-    format.setSampleType(QAudioFormat::SignedInt);
-    format.setCodec("audio/pcm");
-
-    switch (audioConfiguration) {
-    case AUDIO_CONFIGURATION_STEREO:
-        format.setChannelCount(2);
-        break;
-    case AUDIO_CONFIGURATION_51_SURROUND:
-        format.setChannelCount(6);
-        break;
-    default:
-        Q_ASSERT(false);
-        return false;
-    }
-
-    if (QAudioDeviceInfo::defaultOutputDevice().isFormatSupported(format)) {
-        qInfo() << "Audio test successful with" << format.channelCount() << "channels";
-        return true;
-    }
-    else {
-        qWarning() << "Audio test failed with" << format.channelCount() << "channels";
-        return false;
-    }
-}
-
-int QtAudioRenderer::detectAudioConfiguration()
-{
-    int preferredChannelCount = QAudioDeviceInfo::defaultOutputDevice().preferredFormat().channelCount();
-
-    qInfo() << "Audio output device prefers" << preferredChannelCount << "channel configuration";
-
-    // We can better downmix 5.1 to quad than we can upmix stereo
-    if (preferredChannelCount > 2) {
-        return AUDIO_CONFIGURATION_51_SURROUND;
-    }
-    else {
-        return AUDIO_CONFIGURATION_STEREO;
-    }
-}

app/streaming/audio/renderers/qtaud.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include "renderer.h"
-#include <QAudioOutput>
-
-class QtAudioRenderer : public IAudioRenderer
-{
-public:
-    QtAudioRenderer();
-
-    virtual ~QtAudioRenderer();
-
-    virtual bool prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig);
-
-    virtual void submitAudio(short* audioBuffer, int audioSize);
-
-    virtual bool testAudio(int audioConfiguration);
-
-    virtual int detectAudioConfiguration();
-
-private:
-    QAudioOutput* m_AudioOutput;
-    QIODevice* m_OutputDevice;
-};

app/streaming/audio/renderers/renderer.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <Limelight.h>
-
-#define MAX_CHANNELS 6
-#define SAMPLES_PER_FRAME 240
-
-class IAudioRenderer
-{
-public:
-    virtual ~IAudioRenderer() {}
-
-    virtual bool prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig) = 0;
-
-    // Return false if an unrecoverable error has occurred and the renderer must be reinitialized
-    virtual bool submitAudio(short* audioBuffer, int audioSize) = 0;
-};

app/streaming/audio/renderers/sdl.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "renderer.h"
-#include <SDL.h>
-
-class SdlAudioRenderer : public IAudioRenderer
-{
-public:
-    SdlAudioRenderer();
-
-    virtual ~SdlAudioRenderer();
-
-    virtual bool prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig);
-
-    virtual bool submitAudio(short* audioBuffer, int audioSize);
-
-private:
-    SDL_AudioDeviceID m_AudioDevice;
-};

app/streaming/audio/renderers/sdlaud.cpp

@@ -1,81 +0,0 @@
-#include "sdl.h"
-
-#include <Limelight.h>
-#include <SDL.h>
-
-#include <QtGlobal>
-
-SdlAudioRenderer::SdlAudioRenderer()
-    : m_AudioDevice(0)
-{
-    SDL_assert(!SDL_WasInit(SDL_INIT_AUDIO));
-    if (SDL_InitSubSystem(SDL_INIT_AUDIO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_AUDIO) failed: %s",
-                     SDL_GetError());
-        SDL_assert(SDL_WasInit(SDL_INIT_AUDIO));
-    }
-}
-
-bool SdlAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig)
-{
-    SDL_AudioSpec want, have;
-
-    SDL_zero(want);
-    want.freq = opusConfig->sampleRate;
-    want.format = AUDIO_S16;
-    want.channels = opusConfig->channelCount;
-
-    // This is supposed to be a power of 2, but our
-    // frames contain a non-power of 2 number of samples,
-    // so the slop would require buffering another full frame.
-    // Specifying non-Po2 seems to work for our supported platforms.
-    want.samples = SAMPLES_PER_FRAME;
-
-    m_AudioDevice = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0);
-    if (m_AudioDevice == 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to open audio device: %s",
-                     SDL_GetError());
-        SDL_QuitSubSystem(SDL_INIT_AUDIO);
-        return false;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Desired audio buffer: %u samples (%lu bytes)",
-                want.samples,
-                want.samples * sizeof(short) * want.channels);
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Obtained audio buffer: %u samples (%u bytes)",
-                have.samples,
-                have.size);
-
-    // Start playback
-    SDL_PauseAudioDevice(m_AudioDevice, 0);
-
-    return true;
-}
-
-SdlAudioRenderer::~SdlAudioRenderer()
-{
-    if (m_AudioDevice != 0) {
-        // Stop playback
-        SDL_PauseAudioDevice(m_AudioDevice, 1);
-        SDL_CloseAudioDevice(m_AudioDevice);
-    }
-
-    SDL_QuitSubSystem(SDL_INIT_AUDIO);
-    SDL_assert(!SDL_WasInit(SDL_INIT_AUDIO));
-}
-
-bool SdlAudioRenderer::submitAudio(short* audioBuffer, int audioSize)
-{
-    if (SDL_QueueAudio(m_AudioDevice, audioBuffer, audioSize) < 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to queue audio sample: %s",
-                     SDL_GetError());
-    }
-
-    return true;
-}

app/streaming/audio/renderers/slaud.cpp

@@ -1,115 +0,0 @@
-#include "slaud.h"
-
-#include <SDL.h>
-
-// To reduce CPU load on the Steam Link, we need to accumulate several frames
-// before submitting for playback. Higher frames per submission saves more CPU
-// but increases audio latency.
-#define FRAMES_PER_SUBMISSION 4
-
-SLAudioRenderer::SLAudioRenderer()
-    : m_AudioContext(nullptr),
-      m_AudioStream(nullptr),
-      m_AudioBuffer(nullptr),
-      m_AudioBufferBytesFilled(0)
-{
-    SLAudio_SetLogFunction(SLAudioRenderer::slLogCallback, nullptr);
-}
-
-bool SLAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig)
-{
-    m_AudioContext = SLAudio_CreateContext();
-    if (m_AudioContext == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SLAudio_CreateContext() failed");
-        return false;
-    }
-
-    m_AudioBufferSize = SAMPLES_PER_FRAME * sizeof(short) * opusConfig->channelCount * FRAMES_PER_SUBMISSION;
-    m_AudioStream = SLAudio_CreateStream(m_AudioContext,
-                                         opusConfig->sampleRate,
-                                         opusConfig->channelCount,
-                                         m_AudioBufferSize,
-                                         1);
-    if (m_AudioStream == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SLAudio_CreateStream() failed");
-        return false;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Using SLAudio renderer");
-
-    return true;
-}
-
-SLAudioRenderer::~SLAudioRenderer()
-{
-    if (m_AudioBufferBytesFilled != 0) {
-        // We had a buffer in flight when we quit. Just in case
-        // SLAudio doesn't handle this properly, we'll zero and submit
-        // it just to be safe.
-        memset(m_AudioBuffer, 0, m_AudioBufferSize);
-        SLAudio_SubmitFrame(m_AudioStream);
-    }
-
-    if (m_AudioStream != nullptr) {
-        SLAudio_FreeStream(m_AudioStream);
-    }
-
-    if (m_AudioContext != nullptr) {
-        SLAudio_FreeContext(m_AudioContext);
-    }
-}
-
-bool SLAudioRenderer::submitAudio(short* audioBuffer, int audioSize)
-{
-    if (m_AudioBufferBytesFilled == 0) {
-        // Get a new audio buffer from SLAudio
-        m_AudioBuffer = (char*)SLAudio_BeginFrame(m_AudioStream);
-        if (m_AudioBuffer == nullptr) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SLAudio_BeginFrame() failed");
-            return true;
-        }
-    }
-
-    // Accumulate several frames of audio before submitting to reduce CPU load
-    SDL_assert(audioSize <= m_AudioBufferSize - m_AudioBufferBytesFilled);
-    memcpy(&m_AudioBuffer[m_AudioBufferBytesFilled], audioBuffer, audioSize);
-    m_AudioBufferBytesFilled += audioSize;
-
-    // Submit the buffer when it's full
-    if (m_AudioBufferBytesFilled == m_AudioBufferSize) {
-        SLAudio_SubmitFrame(m_AudioStream);
-        m_AudioBufferBytesFilled = 0;
-    }
-
-    return true;
-}
-
-void SLAudioRenderer::slLogCallback(void *context, ESLAudioLog logLevel, const char *message)
-{
-    SDL_LogPriority priority;
-
-    switch (logLevel)
-    {
-    case k_ESLAudioLogError:
-        priority = SDL_LOG_PRIORITY_ERROR;
-        break;
-    case k_ESLAudioLogWarning:
-        priority = SDL_LOG_PRIORITY_WARN;
-        break;
-    case k_ESLAudioLogInfo:
-        priority = SDL_LOG_PRIORITY_INFO;
-        break;
-    default:
-    case k_ESLAudioLogDebug:
-        priority = SDL_LOG_PRIORITY_DEBUG;
-        break;
-    }
-
-    SDL_LogMessage(SDL_LOG_CATEGORY_APPLICATION,
-                   priority,
-                   "SLAudio: %s",
-                   message);
-}

app/streaming/audio/renderers/slaud.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include "renderer.h"
-#include <SLAudio.h>
-
-class SLAudioRenderer : public IAudioRenderer
-{
-public:
-    SLAudioRenderer();
-
-    virtual ~SLAudioRenderer();
-
-    virtual bool prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig);
-
-    virtual bool submitAudio(short* audioBuffer, int audioSize);
-
-private:
-    static void slLogCallback(void* context, ESLAudioLog logLevel, const char* message);
-
-    CSLAudioContext* m_AudioContext;
-    CSLAudioStream* m_AudioStream;
-    char* m_AudioBuffer;
-    int m_AudioBufferSize;
-    int m_AudioBufferBytesFilled;
-};

app/streaming/audio/renderers/soundioaudiorenderer.cpp

@@ -1,463 +0,0 @@
-#include "soundioaudiorenderer.h"
-
-#include <SDL.h>
-
-#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)
-{
-
-}
-
-SoundIoAudioRenderer::~SoundIoAudioRenderer()
-{
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Audio latency: %f",
-                m_Latency);
-
-    if (m_OutputStream != nullptr) {
-        soundio_outstream_destroy(m_OutputStream);
-    }
-
-    // Must be destroyed after the stream is stopped
-    // or we could still get sioWriteCallback() calls.
-    if (m_RingBuffer != nullptr) {
-        soundio_ring_buffer_destroy(m_RingBuffer);
-    }
-
-    if (m_Device != nullptr) {
-        soundio_device_unref(m_Device);
-    }
-
-    if (m_SoundIo != nullptr) {
-        soundio_destroy(m_SoundIo);
-    }
-}
-
-int SoundIoAudioRenderer::scoreChannelLayout(const struct SoundIoChannelLayout* layout, const OPUS_MULTISTREAM_CONFIGURATION* opusConfig)
-{
-    int score = 50;
-
-    // Compute a score for this layout based on how many matching channels
-    // we find (or acceptable alternatives).
-    for (int i = 0; i < layout->channel_count; i++) {
-        if (opusConfig->channelCount >= 2) {
-            switch (layout->channels[i]) {
-            case SoundIoChannelIdFrontLeft:
-            case SoundIoChannelIdFrontRight:
-                score += 2;
-                break;
-            default:
-                break;
-            }
-        }
-
-        if (opusConfig->channelCount >= 6) {
-            switch (layout->channels[i]) {
-            case SoundIoChannelIdFrontCenter:
-            case SoundIoChannelIdLfe:
-                score += 2;
-                break;
-
-            case SoundIoChannelIdSideLeft:
-            case SoundIoChannelIdSideRight:
-                score++;
-                break;
-
-            // Score layouts using the back L/R as higher
-            // value than those using side L/R.
-            case SoundIoChannelIdBackLeft:
-            case SoundIoChannelIdBackRight:
-                score += 2;
-                break;
-
-            default:
-                break;
-            }
-        }
-    }
-
-    // Now subtract the difference between the desired and actual channel count
-    // to punish layouts that have extra unused speakers.
-    if (opusConfig->channelCount < layout->channel_count) {
-        score -= layout->channel_count - opusConfig->channelCount;
-    }
-
-    return score;
-}
-
-bool SoundIoAudioRenderer::prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig)
-{
-    m_SoundIo = soundio_create();
-    if (m_SoundIo == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_create() failed");
-        return false;
-    }
-
-    m_SoundIo->app_name = "Moonlight";
-    m_SoundIo->userdata = this;
-    m_SoundIo->on_backend_disconnect = sioBackendDisconnect;
-    m_SoundIo->on_devices_change = sioDevicesChanged;
-
-    int err = soundio_connect(m_SoundIo);
-    if (err != SoundIoErrorNone) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_connect() failed: %s",
-                     soundio_strerror(err));
-        return false;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Audio backend: %s",
-                soundio_backend_name(m_SoundIo->current_backend));
-
-    // Don't continue if we could only open the dummy backend
-    if (m_SoundIo->current_backend == SoundIoBackendDummy) {
-        return false;
-    }
-
-    // Flush events to update with new device arrivals
-    soundio_flush_events(m_SoundIo);
-
-    // Remember the actual channel count for later
-    m_OpusChannelCount = opusConfig->channelCount;
-
-    int outputDeviceIndex = soundio_default_output_device_index(m_SoundIo);
-    if (outputDeviceIndex < 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "No output device found");
-        return false;
-    }
-
-    m_Device = soundio_get_output_device(m_SoundIo, outputDeviceIndex);
-    if (m_Device == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_get_output_device() failed");
-        return false;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Selected audio device: %s",
-                m_Device->name);
-
-    m_OutputStream = soundio_outstream_create(m_Device);
-    if (m_OutputStream == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_outstream_create() failed");
-        return false;
-    }
-
-    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;
-
-    SoundIoChannelLayout bestLayout = m_Device->current_layout;
-    for (int i = 0; i < m_Device->layout_count; i++) {
-        if (scoreChannelLayout(&bestLayout, opusConfig) <
-                scoreChannelLayout(&m_Device->layouts[i], opusConfig)) {
-            bestLayout = m_Device->layouts[i];
-        }
-    }
-
-    if (bestLayout.channel_count < opusConfig->channelCount) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "No compatible channel layouts found. Some channels may not be played!");
-    }
-
-    m_OutputStream->layout = bestLayout;
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Native layout: %s (%d channels)",
-                m_OutputStream->layout.name ?
-                    m_OutputStream->layout.name : "<UNKNOWN>",
-                m_OutputStream->layout.channel_count);
-
-    err = soundio_outstream_open(m_OutputStream);
-    if (err != SoundIoErrorNone) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_outstream_open() failed: %s",
-                     soundio_strerror(err));
-        return false;
-    }
-
-    if (m_OutputStream->layout_error) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "Channel layout failed: %s",
-                    soundio_strerror(m_OutputStream->layout_error));
-
-        // ALSA through PulseAudio appears to fail snd_pcm_set_chmap()
-        // even after claiming the layout is supported (and even on totally
-        // standard layouts like Stereo). We'll just ignore this for ALSA
-        // and only bail if we get an actual failure out of one of these APIs.
-        if (m_SoundIo->current_backend != SoundIoBackendAlsa) {
-            return false;
-        }
-    }
-
-    m_EffectiveLayout = m_OutputStream->layout;
-    for (int i = 0; i < m_EffectiveLayout.channel_count; i++) {
-        // Fixup the layout to use back L/R so our channel position
-        // logic in sioWriteCallback() works.
-        if (m_EffectiveLayout.channels[i] == SoundIoChannelIdSideLeft) {
-            m_EffectiveLayout.channels[i] = SoundIoChannelIdBackLeft;
-        }
-        if (m_EffectiveLayout.channels[i] == SoundIoChannelIdSideRight) {
-            m_EffectiveLayout.channels[i] = SoundIoChannelIdBackRight;
-        }
-    }
-
-    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 *
-                                              packetsToBuffer);
-    if (m_RingBuffer == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_ring_buffer_create() failed");
-        return false;
-    }
-
-    err = soundio_outstream_start(m_OutputStream);
-    if (err != SoundIoErrorNone) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "soundio_outstream_start() failed: %s",
-                     soundio_strerror(err));
-        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;
-}
-
-bool SoundIoAudioRenderer::submitAudio(short* audioBuffer, int audioSize)
-{
-    if (m_Errored) {
-        return false;
-    }
-
-    // Flush events to update with new device arrivals
-    soundio_flush_events(m_SoundIo);
-
-    // We must always write a full frame of audio. If we don't,
-    // the reader will get out of sync with the writer and our
-    // channels will get all mixed up. To ensure this is always
-    // the case, round our bytes free down to the next multiple
-    // of our frame size.
-    int bytesFree = soundio_ring_buffer_free_count(m_RingBuffer);
-    int bytesPerFrame = m_OpusChannelCount * m_OutputStream->bytes_per_sample;
-    int bytesToWrite = qMin(audioSize, (bytesFree / bytesPerFrame) * bytesPerFrame);
-    memcpy(soundio_ring_buffer_write_ptr(m_RingBuffer), audioBuffer, bytesToWrite);
-    soundio_ring_buffer_advance_write_ptr(m_RingBuffer, bytesToWrite);
-
-    return true;
-}
-
-void SoundIoAudioRenderer::sioErrorCallback(SoundIoOutStream* stream, int err)
-{
-    auto me = reinterpret_cast<SoundIoAudioRenderer*>(stream->userdata);
-
-    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                 "Audio rendering error: %s",
-                 soundio_strerror(err));
-
-    // Trigger reinitialization
-    me->m_Errored = true;
-}
-
-void SoundIoAudioRenderer::sioBackendDisconnect(SoundIo* soundio, int err)
-{
-    auto me = reinterpret_cast<SoundIoAudioRenderer*>(soundio->userdata);
-
-    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                "Audio backend disconnected: %s",
-                soundio_strerror(err));
-
-    // Trigger reinitialization
-    me->m_Errored = true;
-}
-
-void SoundIoAudioRenderer::sioDevicesChanged(SoundIo* soundio)
-{
-    auto me = reinterpret_cast<SoundIoAudioRenderer*>(soundio->userdata);
-
-    if (me->m_Device == nullptr) {
-        // Ignore calls that take place during initialization
-        return;
-    }
-
-    int outputDeviceIndex = soundio_default_output_device_index(soundio);
-    if (outputDeviceIndex >= 0) {
-        struct SoundIoDevice* outputDevice = soundio_get_output_device(soundio, outputDeviceIndex);
-        if (outputDevice == nullptr) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "soundio_get_output_device() failed");
-            return;
-        }
-
-        if (!soundio_device_equal(outputDevice, me->m_Device)) {
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Default audio output device changed");
-
-            // Trigger reinitialization
-            me->m_Errored = true;
-        }
-
-        soundio_device_unref(outputDevice);
-    }
-}
-
-// bytes_per_frame should never be used on the ring buffer! It's not always
-// the same number of bytes per frames as the output stream!
-void SoundIoAudioRenderer::sioWriteCallback(SoundIoOutStream* stream, int frameCountMin, int frameCountMax)
-{
-    auto me = reinterpret_cast<SoundIoAudioRenderer*>(stream->userdata);
-    char* readPtr = soundio_ring_buffer_read_ptr(me->m_RingBuffer);
-    int framesLeft = soundio_ring_buffer_fill_count(me->m_RingBuffer) /
-            (me->m_OpusChannelCount * stream->bytes_per_sample);
-    int bytesRead = 0;
-
-    // Clamp framesLeft to frameCountMax
-    framesLeft = qMin(framesLeft, frameCountMax);
-
-    // 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);
-
-    // 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 (;;) {
-        int frameCount;
-        int err;
-        struct SoundIoChannelArea* areas;
-
-        // Always meet the minimum but don't write more than that
-        // if we'll have to insert silence
-        frameCount = qMax(framesLeft, frameCountMin);
-
-        if (frameCount == 0) {
-            // Nothing more to write
-            break;
-        }
-
-        err = soundio_outstream_begin_write(stream, &areas, &frameCount);
-        if (err != SoundIoErrorNone) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "soundio_outstream_begin_write() failed: %s",
-                         soundio_strerror(err));
-            break;
-        }
-
-        for (int frame = 0; frame < frameCount; frame++) {
-            for (int ch = 0; ch < me->m_EffectiveLayout.channel_count; ch++) {
-                // SoundIoChannelId - 1 happens to match Moonlight's channel layout.
-                // For side L/R, this logic depends on us fixing those up
-                // in m_EffectiveLayout to back L/R.
-                int readPtrChannel = me->m_EffectiveLayout.channels[ch] - 1;
-
-                if (frame >= framesLeft || readPtrChannel >= me->m_OpusChannelCount) {
-                    // Write silence if we have no buffered frames left or
-                    // nothing in the audio stream for this channel
-                    memset(areas[ch].ptr, 0, stream->bytes_per_sample);
-                }
-                else {
-                    // Write audio data from our ring buffer
-                    memcpy(areas[ch].ptr,
-                           &readPtr[readPtrChannel * stream->bytes_per_sample],
-                           stream->bytes_per_sample);
-                }
-
-                areas[ch].ptr += areas[ch].step;
-            }
-
-            // Move on to the next frame if we aren't inserting silence
-            if (frame < framesLeft) {
-                readPtr += stream->bytes_per_sample * me->m_OpusChannelCount;
-                bytesRead += stream->bytes_per_sample * me->m_OpusChannelCount;
-            }
-        }
-
-        err = soundio_outstream_end_write(stream);
-        if (err != SoundIoErrorNone && err != SoundIoErrorUnderflow) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "soundio_outstream_end_write() failed: %s",
-                         soundio_strerror(err));
-            break;
-        }
-
-        if (framesLeft >= frameCount) {
-            framesLeft -= frameCount;
-        }
-        else {
-            framesLeft = 0;
-        }
-
-        if (frameCountMin >= frameCount) {
-            frameCountMin -= frameCount;
-        }
-        else {
-            frameCountMin = 0;
-        }
-    }
-
-    soundio_ring_buffer_advance_read_ptr(me->m_RingBuffer, bytesRead);
-}

app/streaming/audio/renderers/soundioaudiorenderer.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include "renderer.h"
-
-#include <soundio/soundio.h>
-
-class SoundIoAudioRenderer : public IAudioRenderer
-{
-public:
-    SoundIoAudioRenderer();
-
-    ~SoundIoAudioRenderer();
-
-    virtual bool prepareForPlayback(const OPUS_MULTISTREAM_CONFIGURATION* opusConfig);
-
-    virtual bool submitAudio(short* audioBuffer, int audioSize);
-
-private:
-    int scoreChannelLayout(const struct SoundIoChannelLayout* layout, const OPUS_MULTISTREAM_CONFIGURATION* opusConfig);
-
-    static void sioErrorCallback(struct SoundIoOutStream* stream, int err);
-
-    static void sioWriteCallback(struct SoundIoOutStream* stream, int frameCountMin, int frameCountMax);
-
-    static void sioBackendDisconnect(struct SoundIo* soundio, int err);
-
-    static void sioDevicesChanged(SoundIo* soundio);
-
-    int m_OpusChannelCount;
-    struct SoundIo* m_SoundIo;
-    struct SoundIoDevice* m_Device;
-    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;
-};