Experimental AVFoundation renderer

2026-10-17 14:04:49 +00:00 · 2018-07-17 22:57:15 -07:00
292 changed files with 17533 additions and 17841 deletions
@@ -1,31 +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.
-
-**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 1803]
- - Moonlight Version: [e.g. v0.2.0]
-
-**Logs (please attach)**
- On Windows, `Moonlight-###.log` files can be found in `%TEMP%`. Simply type that into the File Explorer path field to navigate there.
- On macOS, `Moonlight-###.log` files can be found in `/tmp`. In Finder, press Cmd+Shift+G, then type `/tmp` to navigate there.
- On Linux, logs print to the terminal when running via `flatpak run com.moonlight_stream.Moonlight`
-
-**Additional context**
-Add any other context about the problem here.
@@ -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.
@@ -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.
@@ -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
@@ -1,5 +1 @@
 *pro.user
-
-
-**/.vs/
-build/
@@ -1,12 +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
@@ -1,50 +0,0 @@
-language: cpp
-
-git:
-  depth: 1
-
-matrix:
-  include:
-    - os: osx
-      compiler: clang
-    - os: linux
-      sudo: required
-      dist: xenial
-      compiler: gcc
-      addons:
-        apt:
-          sources:
-            - sourceline: 'ppa:beineri/opt-qt596-xenial'
-            - sourceline: 'ppa:jonathonf/ffmpeg-4'
-          packages:
-            - qt59base
-            - qt59quickcontrols2
-            - qt59svg
-            - qt59multimedia
-            - 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.8 && wget https://www.libsdl.org/release/SDL2-$SDL2_VER.tar.gz && tar -xvf SDL2-$SDL2_VER.tar.gz && cd SDL2-$SDL2_VER && ./configure && make && 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 debug
-    - make release
@@ -1,56 +1,20 @@
 # Moonlight PC

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

-See the [releases page](https://github.com/moonlight-stream/moonlight-qt/releases) for download links for Windows and Mac. For Linux, we're on [Flathub](https://flathub.org/apps/details/com.moonlight_stream.Moonlight).
-
-You can follow development on our [Discord server](https://discord.gg/6ERtzFY).
-
- [![Windows AppVeyor Status](https://ci.appveyor.com/api/projects/status/glj5cxqwy2w3bglv/branch/master?svg=true)](https://ci.appveyor.com/project/cgutman/moonlight-qt/branch/master)
- [![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 SDL gamepad mappings
+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 Requirements
-* Windows 7 or later
-* Visual Studio 2015 or later
-* Select MSVC Desktop toolchain during Qt installation
-* 7-Zip (only if building installers for non-development PCs)
-* WiX Toolset v3.11 or later (only if building installers for non-development PCs)
-
-### Mac-specific Requirements
-* macOS El Capitan (10.11) or later
-* Xcode with High Sierra (10.13) SDK (Mojave SDK not yet supported until Qt 5.12 later this year)
-* [create-dmg](https://github.com/sindresorhus/create-dmg) (only if building DMGs for use on non-development Macs)
-
-### Linux-specific Requirements
-* GCC or Clang
-* Install your distro equivalents of: `openssl-devel qt5-devel SDL2-devel ffmpeg-devel qt5-qtquickcontrols2-devel libva-devel libvdpau-devel opus-devel`
-* FFmpeg 4.0 is required to build. If your distro doesn't package FFmpeg 4.0, you can build and install it from source on http://ffmpeg.org/
-
-### Build Setup Steps
 1. Install the latest Qt SDK (and optionally, the Qt Creator IDE) from https://www.qt.io/download
-    * You may also use Homebrew on macOS or your Linux distro's package manager for the Qt SDK as long as the packages are Qt 5.9 or later.
-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`.
+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
@@ -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>0.6.0</string>
-	<key>CFBundleShortVersionString</key>
-	<string>0.6.0</string>
-	<key>CFBundleDisplayName</key>
-	<string>Moonlight</string>
 </dict>
 </plist>
@@ -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>
@@ -1,26 +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
-}
-
-# Support debug and release builds from command line for CI
-CONFIG += debug_and_release
-
-# Ensure symbols are always generated
-CONFIG += force_debug_info
-
-# 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 += qtquickcompiler
-}
-
+TARGET = moonlight-qt
 TEMPLATE = app

 # The following define makes your compiler emit warnings if you use
@@ -44,187 +25,69 @@ win32 {
        LIBS += -L$$PWD/../libs/windows/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 $$PWD/../libs/mac/Frameworks/SDL2.framework/Versions/A/Headers
-    LIBS += -L$$PWD/../libs/mac/lib -F$$PWD/../libs/mac/Frameworks
+    INCLUDEPATH += $$PWD/../libs/mac/include
+    LIBS += -L$$PWD/../libs/mac/lib
 }

 unix:!macx {
    CONFIG += link_pkgconfig
-    PKGCONFIG += openssl sdl2 opus
-
-    # For libsoundio
-    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
-        }
-    }
+    PKGCONFIG += openssl sdl2 libavcodec libavdevice libavformat libavutil
 }
 win32 {
-    LIBS += -llibssl -llibcrypto -lSDL2 -lavcodec -lavutil -lopus
-    CONFIG += ffmpeg soundio
+    LIBS += -llibssl -llibcrypto -lSDL2 -lavcodec -lavdevice -lavformat -lavutil
 }
 macx {
-    LIBS += -lssl -lcrypto -lavcodec.58 -lavutil.56 -lopus -framework SDL2
-    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/identitymanager.cpp \
-    backend/nvcomputer.cpp \
    backend/nvhttp.cpp \
    backend/nvpairingmanager.cpp \
    backend/computermanager.cpp \
    backend/boxartmanager.cpp \
-    cli/commandlineparser.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/ffmpeg-renderers/sdl.cpp
+
+win32 {
+    SOURCES += streaming/video/ffmpeg-renderers/dxva2.cpp
+}
+macx {
+    SOURCES += streaming/video/avfoundation.mm
+}

 HEADERS += \
    utils.h \
    backend/identitymanager.h \
-    backend/nvcomputer.h \
    backend/nvhttp.h \
    backend/nvpairingmanager.h \
    backend/computermanager.h \
    backend/boxartmanager.h \
-    cli/commandlineparser.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/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/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
-}
-config_SLVideo {
-    message(SLVideo decoder/renderer selected)
-
-    DEFINES += HAVE_SLVIDEO
-    LIBS += -lSLVideo
-
-    SOURCES += streaming/video/sl.cpp
-    HEADERS += streaming/video/sl.h
-}
 win32 {
-    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
+    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 += \
@@ -244,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
@@ -251,56 +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

-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
-
-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/
-
-    appdata.files = SDL_GameControllerDB/gamecontrollerdb.txt
-    appdata.path = "$$PREFIX/$$DATADIR/Moonlight Game Streaming Project/Moonlight/"
-
-    INSTALLS += target appdata 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 {
    QMAKE_INFO_PLIST = $$PWD/Info.plist
-
-    APP_BUNDLE_RESOURCES.files = moonlight.icns SDL_GameControllerDB/gamecontrollerdb.txt
-    APP_BUNDLE_RESOURCES.path = Contents/Resources
-    QMAKE_BUNDLE_DATA += APP_BUNDLE_RESOURCES
+    APP_QML_FILES.files = res/macos.icns
+    APP_QML_FILES.path = Contents/Resources
+    QMAKE_BUNDLE_DATA += APP_QML_FILES
 }
-
-VERSION = 0.6.0
-DEFINES += VERSION_STR=\\\"0.6.0\\\"
@@ -1,142 +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);
-
-    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.com/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["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();
-    }
-}
@@ -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 url);
-
-private slots:
-    void handleUpdateCheckRequestFinished(QNetworkReply* reply);
-
-private:
-    void parseStringToVersionQuad(QString& string, QVector<int>& version);
-
-    QVector<int> m_CurrentVersionQuad;
-    QNetworkAccessManager m_Nam;
-};
@@ -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.
@@ -114,5 +76,3 @@ QUrl BoxArtManager::loadBoxArtFromNetwork(NvComputer* computer, int appId)

    return QUrl();
 }
-
-#include "boxartmanager.moc"
@@ -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;
 };
@@ -1,143 +1,273 @@
 #include "computermanager.h"
 #include "nvhttp.h"
-#include "settings/streamingpreferences.h"

 #include <QThread>
+#include <QUdpSocket>
+#include <QHostInfo>
 #include <QThreadPool>

 #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);
-
-        QString serverInfo;
-        try {
-            serverInfo = http.getServerInfo(NvHTTP::NvLogLevel::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);
+    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);
-
-        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
-            QThread::sleep(3);
        }
    }

-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),
@@ -156,56 +286,6 @@ ComputerManager::ComputerManager(QObject *parent)
    settings.endArray();
 }

-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;
-
-    {
-        QMutableMapIterator<QString, QThread*> i(m_PollThreads);
-
-        // Interrupt all polling threads
-        while (i.hasNext()) {
-            i.next();
-            i.value()->requestInterruption();
-        }
-
-        // Wait for all threads to terminate before destroying
-        // the NvComputer objects.
-        i.toFront();
-        while (i.hasNext()) {
-            i.next();
-
-            QThread* thread = i.value();
-            thread->wait();
-            delete thread;
-
-            i.remove();
-        }
-    }
-
-    {
-        QMutableMapIterator<QString, NvComputer*> i(m_KnownHosts);
-
-        // Destroy all NvComputer objects
-        while (i.hasNext()) {
-            i.next();
-            delete i.value();
-            i.remove();
-        }
-    }
-}
-
 void ComputerManager::saveHosts()
 {
    QSettings settings;
@@ -228,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);
@@ -255,29 +328,10 @@ void ComputerManager::startPolling()
    }
 }

-// 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();
-}
-
 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);

@@ -285,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);
@@ -314,23 +355,9 @@ public:

    void run()
    {
-        QThread* pollingThread;
+        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);
-
-            pollingThread = m_ComputerManager->m_PollThreads[m_Computer->uuid];
-
-            m_ComputerManager->m_PollThreads.remove(m_Computer->uuid);
-            m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
-        }
-
-        // Persist the new host list
-        m_ComputerManager->saveHosts();
-
-        // Delete the polling thread
+        QThread* pollingThread = m_ComputerManager->m_PollThreads[m_Computer->uuid];
        if (pollingThread != nullptr) {
            pollingThread->requestInterruption();

@@ -343,8 +370,9 @@ public:
            delete pollingThread;
        }

-        // Finally, delete the computer itself. This must be done
-        // last because the polling thread might be using it.
+        m_ComputerManager->m_PollThreads.remove(m_Computer->uuid);
+        m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
+
        delete m_Computer;
    }

@@ -360,55 +388,6 @@ void ComputerManager::deleteHost(NvComputer* computer)
    QThreadPool::globalInstance()->start(new DeferredHostDeletionTask(this, computer));
 }

-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());
-        } 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
@@ -417,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);
-
-        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);
@@ -513,118 +434,6 @@ void ComputerManager::stopPollingAsync()
    }
 }

-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);
-
-        qInfo() << "Processing new PC at" << m_Address << "from" << (m_Mdns ? "mDNS" : "user");
-
-        QString serverInfo;
-        try {
-            // There's a race condition between GameStream servers reporting presence over
-            // 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::NvLogLevel::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::NvLogLevel::VERBOSE);
-                    qInfo() << "Retry successful";
-                }
-                else {
-                    // Rethrow other errors
-                    throw e;
-                }
-            }
-        } 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) {
-                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
@@ -633,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();
+}
+
@@ -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
@@ -61,8 +249,6 @@ class ComputerManager : public QObject
 public:
    explicit ComputerManager(QObject *parent = nullptr);

-    virtual ~ComputerManager();
-
    Q_INVOKABLE void startPolling();

    Q_INVOKABLE void stopPollingAsync();
@@ -71,8 +257,6 @@ public:

    void pairHost(NvComputer* computer, QString pin);

-    void quitRunningApp(NvComputer* computer);
-
    QVector<NvComputer*> getComputers();

    // computer is deleted inside this call
@@ -85,8 +269,6 @@ signals:

    void computerAddCompleted(QVariant success);

-    void quitAppCompleted(QVariant error);
-
 private slots:
    void handleComputerStateChanged(NvComputer* computer);

@@ -106,3 +288,142 @@ private:
    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;
+};
@@ -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);
        }
@@ -1,275 +0,0 @@
-#include "nvcomputer.h"
-
-#include <QUdpSocket>
-#include <QHostInfo>
-
-#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_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();
-
-    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);
-
-    // 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.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 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;
-
-            // Bind to any address on the correct protocol
-            if (sock.bind(address.protocol() == QUdpSocket::IPv4Protocol ?
-                          QHostAddress::AnyIPv4 : QHostAddress::AnyIPv6)) {
-
-                // Send to all ports
-                for (quint16 port : WOL_PORTS) {
-                    if (sock.writeDatagram(wolPayload, address, port)) {
-                        qInfo().nospace().noquote() << "Send WoL packet to " << name << " via " << address.toString() << ":" << port;
-                        success = true;
-                    }
-                }
-            }
-        }
-    }
-
-    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;                       \
-    }
-
-    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_NONEMPTY(appList);
-    ASSIGN_IF_CHANGED_AND_NONEMPTY(displayModes);
-    return changed;
-}
@@ -1,75 +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);
-
-    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;
-    QVector<NvApp> appList;
-
-    // Synchronization
-    QReadWriteLock lock;
-};
@@ -16,8 +16,6 @@
 NvHTTP::NvHTTP(QString address) :
    m_Address(address)
 {
-    Q_ASSERT(!address.isEmpty());
-
    m_BaseUrlHttp.setScheme("http");
    m_BaseUrlHttps.setScheme("https");
    m_BaseUrlHttp.setHost(address);
@@ -29,15 +27,9 @@ NvHTTP::NvHTTP(QString address) :
 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());
@@ -64,7 +56,7 @@ NvHTTP::getCurrentGame(QString serverInfo)
 }

 QString
-NvHTTP::getServerInfo(NvLogLevel logLevel)
+NvHTTP::getServerInfo()
 {
    QString serverInfo;

@@ -75,8 +67,7 @@ NvHTTP::getServerInfo(NvLogLevel logLevel)
        serverInfo = openConnectionToString(m_BaseUrlHttps,
                                            "serverinfo",
                                            nullptr,
-                                            true,
-                                            logLevel);
+                                            true);
        // Throws if the request failed
        verifyResponseStatus(serverInfo);
    }
@@ -88,8 +79,7 @@ NvHTTP::getServerInfo(NvLogLevel logLevel)
            serverInfo = openConnectionToString(m_BaseUrlHttp,
                                                "serverinfo",
                                                nullptr,
-                                                true,
-                                                logLevel);
+                                                true);
            verifyResponseStatus(serverInfo);
        }
        else
@@ -133,11 +123,6 @@ 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",
@@ -147,7 +132,7 @@ NvHTTP::launchApp(int appId,
                                   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" :
                                        "")+
@@ -164,16 +149,11 @@ 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),
                                   false);

@@ -195,7 +175,7 @@ NvHTTP::quitApp()

    // Newer GFE versions will just return success even if quitting fails
    // if we're not the original requestor.
-    if (getCurrentGame(getServerInfo(NvHTTP::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, "");
@@ -235,8 +215,7 @@ NvHTTP::getAppList()
    QString appxml = openConnectionToString(m_BaseUrlHttps,
                                            "applist",
                                            nullptr,
-                                            true,
-                                            NvLogLevel::ERROR);
+                                            true);
    verifyResponseStatus(appxml);

    QXmlStreamReader xmlReader(appxml);
@@ -286,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);
            }
        }
@@ -303,8 +279,7 @@ NvHTTP::getBoxArt(int appId)
                                          "appasset",
                                          "appid="+QString::number(appId)+
                                          "&AssetType=2&AssetIdx=0",
-                                          true,
-                                          NvLogLevel::VERBOSE);
+                                          true);
    QImage image = QImageReader(reply).read();
    delete reply;

@@ -350,15 +325,12 @@ QString
 NvHTTP::openConnectionToString(QUrl baseUrl,
                               QString command,
                               QString arguments,
-                               bool enableTimeout,
-                               NvLogLevel logLevel)
+                               bool enableTimeout)
 {
-    QNetworkReply* reply = openConnection(baseUrl, command, arguments, enableTimeout, 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;
@@ -368,8 +340,7 @@ QNetworkReply*
 NvHTTP::openConnection(QUrl baseUrl,
                       QString command,
                       QString arguments,
-                       bool enableTimeout,
-                       NvLogLevel logLevel)
+                       bool enableTimeout)
 {
    // Build a URL for the request
    QUrl url(baseUrl);
@@ -395,17 +366,13 @@ NvHTTP::openConnection(QUrl baseUrl,
    {
        QTimer::singleShot(REQUEST_TIMEOUT_MS, &loop, SLOT(quit()));
    }
-    if (logLevel >= NvLogLevel::VERBOSE) {
-        qInfo() << "Executing request:" << url.toString();
-    }
+    qDebug() << "Executing request: " << url.toString();
    loop.exec(QEventLoop::ExcludeUserInputEvents);

    // Abort the request if it timed out
    if (!reply->isFinished())
    {
-        if (logLevel >= NvLogLevel::ERROR) {
-            qWarning() << "Aborting timed out request for" << url.toString();
-        }
+        qDebug() << "Aborting timed out request for " << url.toString();
        reply->abort();
    }

@@ -416,10 +383,8 @@ NvHTTP::openConnection(QUrl baseUrl,
    // Handle error
    if (reply->error() != QNetworkReply::NoError)
    {
-        if (logLevel >= NvLogLevel::ERROR) {
-            qWarning() << command << " request failed with error " << reply->error();
-        }
-        QtNetworkReplyException exception(reply->error(), reply->errorString());
+        qDebug() << command << " request failed with error " << reply->error();
+        GfeHttpResponseException exception(reply->error(), reply->errorString());
        delete reply;
        throw exception;
    }
@@ -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,50 +77,9 @@ private:
    QString m_StatusMessage;
 };

-class QtNetworkReplyException : public std::exception
-{
-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:
-    enum NvLogLevel {
-        NONE,
-        ERROR,
-        VERBOSE
-    };
-
    explicit NvHTTP(QString address);

    static
@@ -129,7 +87,7 @@ public:
    getCurrentGame(QString serverInfo);

    QString
-    getServerInfo(NvLogLevel logLevel);
+    getServerInfo();

    static
    void
@@ -149,8 +107,7 @@ public:
    openConnectionToString(QUrl baseUrl,
                           QString command,
                           QString arguments,
-                           bool enableTimeout,
-                           NvLogLevel logLevel = NvLogLevel::VERBOSE);
+                           bool enableTimeout);

    static
    QVector<int>
@@ -186,8 +143,7 @@ private:
    openConnection(QUrl baseUrl,
                   QString command,
                   QString arguments,
-                   bool enableTimeout,
-                   NvLogLevel logLevel);
+                   bool enableTimeout);

    QString m_Address;
    QNetworkAccessManager m_Nam;
@@ -1,6 +1,8 @@
 #include "nvpairingmanager.h"
 #include "utils.h"

+#include <QRandomGenerator>
+
 #include <openssl/bio.h>
 #include <openssl/aes.h>
 #include <openssl/rand.h>
@@ -19,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();
@@ -30,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");
    }
 }

@@ -87,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);
@@ -164,7 +164,7 @@ NvPairingManager::PairState
 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;
@@ -196,14 +196,14 @@ NvPairingManager::pair(QString appVersion, QString pin)
    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 serverCert = NvHTTP::getXmlStringFromHex(getCert, "plaincert");
    if (serverCert == nullptr)
    {
-        qCritical() << "Server likely already pairing";
+        qDebug() << "Server likely already pairing";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::ALREADY_IN_PROGRESS;
    }
@@ -218,7 +218,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
    NvHTTP::verifyResponseStatus(challengeXml);
    if (NvHTTP::getXmlString(challengeXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #2";
+        qDebug() << "Failed pairing at stage #2";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }
@@ -228,15 +228,13 @@ NvPairingManager::pair(QString appVersion, QString pin)
    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);
@@ -251,7 +249,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
    NvHTTP::verifyResponseStatus(respXml);
    if (NvHTTP::getXmlString(respXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #3";
+        qDebug() << "Failed pairing at stage #3";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }
@@ -264,7 +262,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
                         serverSignature,
                         serverCert))
    {
-        qCritical() << "MITM detected";
+        qDebug() << "MITM detected";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }
@@ -275,7 +273,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
    expectedResponseData.append(serverSecret);
    if (QCryptographicHash::hash(expectedResponseData, hashAlgo) != serverResponse)
    {
-        qCritical() << "Incorrect PIN";
+        qDebug() << "Incorrect PIN";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::PIN_WRONG;
    }
@@ -292,7 +290,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
    NvHTTP::verifyResponseStatus(secretRespXml);
    if (NvHTTP::getXmlString(secretRespXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #4";
+        qDebug() << "Failed pairing at stage #4";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }
@@ -304,7 +302,7 @@ NvPairingManager::pair(QString appVersion, QString pin)
    NvHTTP::verifyResponseStatus(pairChallengeXml);
    if (NvHTTP::getXmlString(pairChallengeXml, "paired") != "1")
    {
-        qCritical() << "Failed pairing at stage #5";
+        qDebug() << "Failed pairing at stage #5";
        m_Http.openConnectionToString(m_Http.m_BaseUrlHttp, "unpair", nullptr, true);
        return PairState::FAILED;
    }
@@ -1,362 +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_WIN)
-        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"
-        "  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 == "stream") {
-        return StreamRequested;
-    } else {
-        parser.showError(QString("Invalid action: %1").arg(action));
-    }
-}
-
-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("mouse-acceleration", "mouse acceleration");
-    parser.addToggleOption("game-optimization", "game optimizations");
-    parser.addToggleOption("audio-on-host", "audio on host PC");
-    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 --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 --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;
-}
-
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "settings/streamingpreferences.h"
-
-#include <QMap>
-#include <QString>
-
-class GlobalCommandLineParser
-{
-public:
-    enum ParseResult {
-        NormalStartRequested,
-        StreamRequested,
-    };
-
-    GlobalCommandLineParser();
-    virtual ~GlobalCommandLineParser();
-
-    ParseResult parse(const QStringList &args);
-
-};
-
-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;
-};
@@ -1,220 +0,0 @@
-#include "startstream.h"
-#include "backend/computermanager.h"
-#include "streaming/session.h"
-
-#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 {
-        ComputerUpdated,
-        Executed,
-        Timedout,
-    };
-
-    Event(Type type)
-        : type(type), computerManager(nullptr), computer(nullptr) {}
-
-    Type type;
-    ComputerManager *computerManager;
-    NvComputer *computer;
-};
-
-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) {
-        case Event::Executed:
-            if (m_State == StateInit) {
-                m_State = StateSeekComputer;
-                m_TimeoutTimer->start(COMPUTER_SEEK_TIMEOUT);
-                m_ComputerManager = event.computerManager;
-                q->connect(m_ComputerManager, &ComputerManager::computerStateChanged,
-                           q, &Launcher::onComputerUpdated);
-                // Seek desired computer by both connecting to it directly (this may fail
-                // if m_ComputerName is UUID, or the name that doesn't resolve to an IP
-                // address) and by polling it using mDNS, hopefully one of these methods
-                // would find the host
-                m_ComputerManager->addNewHost(m_ComputerName, false);
-                m_ComputerManager->startPolling();
-                emit q->searchingComputer();
-            }
-            break;
-        case Event::ComputerUpdated:
-            if (m_State == StateSeekComputer) {
-                if (matchComputer(event.computer) && isOnline(event.computer)) {
-                    if (isPaired(event.computer)) {
-                        m_State = StateSeekApp;
-                        m_TimeoutTimer->start(APP_SEEK_TIMEOUT);
-                        m_Computer = event.computer;
-                        m_ComputerManager->stopPollingAsync();
-                        emit q->searchingApp();
-                    } else {
-                        m_State = StateFailure;
-                        QString msg = QString("Computer %1 has not been paired. "
-                                              "Please open Moonlight to pair before streaming.")
-                                .arg(event.computer->name);
-                        emit q->failed(msg);
-                    }
-                }
-            }
-            if (m_State == StateSeekApp) {
-                int index = getAppIndex();
-                if (-1 != index) {
-                    app = m_Computer->appList[index];
-                    if (isNotStreaming() || isStreamingApp(app)) {
-                        m_State = StateStartSession;
-                        m_TimeoutTimer->stop();
-                        session = new Session(m_Computer, app, m_Preferences);
-                        emit q->sessionCreated(app.name, session);
-                    } else {
-                        m_State = StateFailure;
-                        QString msg = QString("%1 is already running. Please quit %1 to stream %2.")
-                                .arg(getCurrentAppName(), app.name);
-                        emit q->failed(msg);
-                    }
-                }
-            }
-            break;
-        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;
-        }
-    }
-
-    bool matchComputer(NvComputer *computer) const
-    {
-        QString value = m_ComputerName.toLower();
-        return computer->name.toLower() == value ||
-               computer->localAddress.toLower() == value ||
-               computer->remoteAddress.toLower() == value ||
-               computer->manualAddress.toLower() == value ||
-               computer->uuid.toLower() == value;
-    }
-
-    bool isOnline(NvComputer *computer) const
-    {
-        return computer->state == NvComputer::CS_ONLINE;
-    }
-
-    bool isPaired(NvComputer *computer) const
-    {
-        return computer->pairState == NvComputer::PS_PAIRED;
-    }
-
-    int getAppIndex() const
-    {
-        for (int i = 0; i < m_Computer->appList.length(); i++) {
-            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;
-    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::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);
-}
-
-}
@@ -1,42 +0,0 @@
-#pragma once
-
-#include <QObject>
-
-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);
-
-signals:
-    void searchingComputer();
-    void searchingApp();
-    void sessionCreated(QString appName, Session *session);
-    void failed(QString text);
-
-private slots:
-    void onComputerUpdated(NvComputer *computer);
-    void onTimeout();
-
-private:
-    QScopedPointer<LauncherPrivate> m_DPtr;
-};
-
-}
@@ -1,169 +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>Stream games 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 SDL mapping compatibility</li>
-		</ul>
-	</description>
-
-	<url type="homepage">https://moonlight-stream.com</url>
-	<url type="bugtracker">https://github.com/moonlight-stream/moonlight-qt/issues</url>
-	<url type="help">https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide</url>
-
-	<screenshots>
-		<screenshot type="default">
-			<image>https://moonlight-stream.com/appstream_resources/moonlight_screenshot_1.png</image>
-		</screenshot>
-		<screenshot>
-			<image>https://moonlight-stream.com/appstream_resources/moonlight_screenshot_2.png</image>
-		</screenshot>
-	</screenshots>
-
-	<releases>
-		<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.com</update_contact>
-
-	<launchable type="desktop-id">com.moonlight_stream.Moonlight.desktop</launchable>
-
-	<provides>
-		<binary>moonlight</binary>
-	</provides>
-
-	<content_rating type="oars-1.0" />
-</component>
@@ -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;
@@ -1,53 +1,40 @@
 import QtQuick 2.9
-import QtQuick.Dialogs 1.2
 import QtQuick.Controls 2.2

 import AppModel 1.0
+
 import ComputerManager 1.0
-import SdlGamepadKeyNavigation 1.0

 GridView {
    property int computerIndex
    property AppModel appModel : createModel()

    id: appGrid
-    focus: true
-    activeFocusOnTab: true
    anchors.fill: parent
    anchors.leftMargin: (parent.width % (cellWidth + anchors.rightMargin)) / 2
-    anchors.topMargin: 20
+    anchors.topMargin: 5
    anchors.rightMargin: 5
    anchors.bottomMargin: 5
-    cellWidth: 225; cellHeight: 385;
+    cellWidth: 225; cellHeight: 350;
+    focus: true
+
+    // Cache delegates for 1000px in both directions to improve
+    // scrolling and resizing performance
+    cacheBuffer: 1000

    // 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 computerLost()
-    {
-        // Go back to the PC view on PC loss
-        stackView.pop()
-    }
-
-    Component.onCompleted: {
-        // Don't show any highlighted item until interacting with them
-        currentIndex = -1
-    }
-
-    SdlGamepadKeyNavigation {
-        id: gamepadKeyNav
-    }
-
    onVisibleChanged: {
        if (visible) {
-            appModel.computerLost.connect(computerLost)
-            gamepadKeyNav.enable()
+            // Start polling when this view is shown
+            ComputerManager.startPolling()
        }
        else {
-            appModel.computerLost.disconnect(computerLost)
-            gamepadKeyNav.disable()
+            // Stop polling when this view is not on top
+            ComputerManager.stopPollingAsync()
        }
    }

@@ -60,140 +47,50 @@ GridView {

    model: appModel

-    delegate: NavigableItemDelegate {
-        width: 200; height: 335;
-        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 {
            id: appIcon
            anchors.horizontalCenter: parent.horizontalCenter;
-            y: 20
            source: model.boxart
            sourceSize {
                width: 150
                height: 200
            }
-            width: sourceSize.width
-            height: sourceSize.height
-            fillMode: Image.Pad
-        }
-
-        Image {
-            id: runningIcon
-            anchors.centerIn: appIcon
-            visible: model.running
-            source: "qrc:/res/baseline-play_circle_filled_white-48px.svg"
-            sourceSize {
-                width: 75
-                height: 75
-            }
        }

        Text {
            id: appNameText
            text: model.name
            color: "white"
+
            width: parent.width
-            height: 125
+            height: 100
            anchors.top: appIcon.bottom
-            font.pointSize: 22
+            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
-            }
-
-            var component = Qt.createComponent("StreamSegue.qml")
-            var segue = component.createObject(stackView, {"appName": model.name, "session": appModel.createSessionForApp(index)})
-            stackView.push(segue)
-        }
-
-        onClicked: {
-            // Nothing is running or this app is running
-            launchOrResumeSelectedApp()
        }

        MouseArea {
            anchors.fill: parent
-            acceptedButtons: Qt.RightButton
            onClicked: {
-                // popup() ensures the menu appears under the mouse cursor
-                appContextMenu.popup()
+                // TODO: Check if a different game is running
+
+                var component = Qt.createComponent("StreamSegue.qml")
+                var segue = component.createObject(stackView)
+                segue.appname = model.name
+                segue.session = appModel.createSessionForApp(index)
+                stackView.push(segue)
            }
        }
-
-        Keys.onMenuPressed: {
-            // We must use open() here so the menu is positioned on
-            // the ItemDelegate and not where the mouse cursor is
-            appContextMenu.open()
-        }
-
-        Menu {
-            id: appContextMenu
-            NavigableMenuItem {
-                text: model.running ? "Resume Game" : "Launch Game"
-                onTriggered: {
-                    appContextMenu.close()
-                    launchOrResumeSelectedApp()
-                }
-            }
-            NavigableMenuItem {
-                text: "Quit Game"
-                onTriggered: {
-                    quitAppDialog.appName = appModel.getRunningAppName()
-                    quitAppDialog.segueToStream = false
-                    quitAppDialog.open()
-                }
-                visible: model.running
-            }
-        }
-    }
-
-    MessageDialog {
-        id: quitAppDialog
-        modality:Qt.WindowModal
-        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: StandardButton.Yes | StandardButton.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()
-        }
-
-        onYes: quitApp()
-
-        // For keyboard/gamepad navigation
-        onAccepted: quitApp()
    }

    ScrollBar.vertical: ScrollBar {
@@ -1,31 +0,0 @@
-import QtQuick 2.11
-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
-        font: popup.font
-    }
-
-    TextMetrics {
-        id: textMetrics
-        font: parent.font
-    }
-
-    // We call this every time the options change (and init)
-    // so we can adjust the combo box width here too
-    onActivated: {
-        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)
-        }
-    }
-}
@@ -1,78 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-import QtQuick.Dialogs 1.2
-
-import ComputerManager 1.0
-
-Item {
-    visible: false
-
-    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()
-    }
-
-    onVisibleChanged: {
-        if (visible) {
-            toolBar.visible = false
-            launcher.searchingComputer.connect(onSearchingComputer)
-            launcher.searchingApp.connect(onSearchingApp)
-            launcher.sessionCreated.connect(onSessionCreated)
-            launcher.failed.connect(onLaunchFailed)
-            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
-            color: "white"
-        }
-    }
-
-    MessageDialog {
-        id: errorDialog
-        modality:Qt.WindowModal
-        icon: StandardIcon.Critical
-        standardButtons: StandardButton.Ok | StandardButton.Help
-        onHelp: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting");
-        }
-        onVisibleChanged: {
-            if (!visible) {
-                Qt.quit();
-            }
-        }
-    }
-
-}
@@ -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()
-    }
-}
@@ -1,12 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-MenuItem {
-    // Ensure focus can't be given to an invisible item
-    enabled: visible
-    height: visible ? implicitHeight : 0
-
-    Keys.onReturnPressed: {
-        triggered()
-    }
-}
@@ -1,18 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-
-ToolButton {
-    activeFocusOnTab: true
-
-    Keys.onReturnPressed: {
-        clicked()
-    }
-
-    Keys.onRightPressed: {
-        nextItemInFocusChain(true).forceActiveFocus(Qt.TabFocus)
-    }
-
-    Keys.onLeftPressed: {
-        nextItemInFocusChain(false).forceActiveFocus(Qt.TabFocus)
-    }
-}
@@ -1,27 +1,23 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
-import QtQuick.Dialogs 1.2
+import QtQuick.Dialogs 1.3
 import QtQuick.Layouts 1.3
-import QtQuick.Window 2.2

 import ComputerModel 1.0

 import ComputerManager 1.0
-import StreamingPreferences 1.0
-import SdlGamepadKeyNavigation 1.0

 GridView {
    property ComputerModel computerModel : createModel()

    id: pcGrid
-    focus: true
-    activeFocusOnTab: true
    anchors.fill: parent
    anchors.leftMargin: (parent.width % (cellWidth + anchors.rightMargin)) / 2
-    anchors.topMargin: 20
+    anchors.topMargin: 5
    anchors.rightMargin: 5
    anchors.bottomMargin: 5
    cellWidth: 350; cellHeight: 350;
+    focus: true
    objectName: "Computers"

    // The StackView will trigger a visibility change when
@@ -29,38 +25,32 @@ GridView {
    // routine to run, but only if we start as invisible
    visible: false

-    StreamingPreferences {
-        id: prefs
-    }
-
-    SdlGamepadKeyNavigation {
-        id: gamepadKeyNav
+    Component.onCompleted: {
+        // Setup signals on CM
+        ComputerManager.computerAddCompleted.connect(addComplete)
    }

    onVisibleChanged: {
        if (visible) {
-            gamepadKeyNav.enable()
+            // Start polling when this view is shown
+            ComputerManager.startPolling()
        }
        else {
-            gamepadKeyNav.disable()
+            // Stop polling when this view is not top-most
+            ComputerManager.stopPollingAsync()
        }
    }

-    Component.onCompleted: {
-        // Setup signals on CM
-        ComputerManager.computerAddCompleted.connect(addComplete)
-
-        // Don't show any highlighted item until interacting with them
-        currentIndex = -1
-    }
-
    function pairingComplete(error)
    {
        // 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.open()
        }
@@ -69,7 +59,7 @@ GridView {
    function addComplete(success)
    {
        if (!success) {
-            errorDialog.text = "Unable to connect to the specified PC. 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()
        }
    }
@@ -82,15 +72,14 @@ GridView {
        return model
    }

-    model: computerModel
+    model: createModel()

-    delegate: NavigableItemDelegate {
+    delegate: Item {
        width: 300; height: 300;
-        grid: pcGrid

        Image {
            id: pcIcon
-            anchors.horizontalCenter: parent.horizontalCenter
+            anchors.horizontalCenter: parent.horizontalCenter;
            source: {
                model.addPc ? "qrc:/res/ic_add_to_queue_white_48px.svg" : "qrc:/res/ic_tv_white_48px.svg"
            }
@@ -100,30 +89,6 @@ GridView {
            }
        }

-        Image {
-            // TODO: Tooltip
-            id: stateIcon
-            anchors.horizontalCenter: pcIcon.horizontalCenter
-            anchors.verticalCenter: pcIcon.verticalCenter
-            anchors.verticalCenterOffset: -10
-            visible: !model.addPc && !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.addPc && model.statusUnknown
-        }
-
        Text {
            id: pcNameText
            text: model.name
@@ -136,73 +101,77 @@ GridView {
            wrapMode: Text.Wrap
        }

-        Menu {
-            id: pcContextMenu
-            NavigableMenuItem {
-                text: "Wake PC"
-                onTriggered: computerModel.wakeComputer(index)
-                visible: !model.addPc && !model.online && model.wakeable
-            }
-            NavigableMenuItem {
-                text: "Delete PC"
-                onTriggered: {
-                    deletePcDialog.pcIndex = index
-                    // get confirmation first, actual closing is called from the dialog
-                    deletePcDialog.open()
-                }
-            }
-        }
-
-        onClicked: {
-            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, {"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 = "This PC is currently busy. Make sure to quit any running games and try again."
-                        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()
            }
+
+            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: {
-                if (!model.addPc) {
-                    // popup() ensures the menu appears under the mouse cursor
-                    pcContextMenu.popup()
+                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)

-        Keys.onMenuPressed: {
-            if (!model.addPc) {
-                // We must use open() here so the menu is positioned on
-                // the ItemDelegate and not where the mouse cursor is
-                pcContextMenu.open()
+                            // 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
+                }
            }
        }
    }
@@ -212,12 +181,7 @@ GridView {
        // don't allow edits to the rest of the window while open
        modality:Qt.WindowModal
        icon: StandardIcon.Critical
-        standardButtons: StandardButton.Ok | StandardButton.Help
-        onHelp: {
-            // 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.
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Setup-Guide");
-        }
+        standardButtons: StandardButton.Ok
    }

    MessageDialog {
@@ -232,25 +196,6 @@ GridView {
        }
    }

-    MessageDialog {
-        id: deletePcDialog
-        // don't allow edits to the rest of the window while open
-        modality:Qt.WindowModal
-        property int pcIndex : -1;
-        text:"Are you sure you want to remove this PC?"
-        standardButtons: StandardButton.Yes | StandardButton.No
-
-        function deletePc() {
-            console.log("deleting PC pairing for PC at index: " + pcIndex)
-            computerModel.deleteComputer(pcIndex);
-        }
-
-        onYes: deletePc()
-
-        // For keyboard/gamepad activation
-        onAccepted: deletePc()
-    }
-
    Dialog {
        id: addPcDialog
        property string label: "Enter the IP address of your GameStream PC"
@@ -1,78 +0,0 @@
-import QtQuick 2.0
-import QtQuick.Controls 2.2
-import QtQuick.Dialogs 1.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 + "..."
-
-    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 quitAppCompleted(error)
-    {
-        // Display a failed dialog if we got an error
-        if (error !== undefined) {
-            errorDialog.text = error
-            errorDialog.open()
-        }
-
-        // Exit this view
-        stackView.pop()
-
-        // 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.push(segue)
-        }
-    }
-
-    onVisibleChanged: {
-        if (visible) {
-            // Connect the quit completion signal
-            ComputerManager.quitAppCompleted.connect(quitAppCompleted)
-        }
-        else {
-            // 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
-            color: "white"
-        }
-    }
-
-    MessageDialog {
-        id: errorDialog
-        modality:Qt.WindowModal
-        icon: StandardIcon.Critical
-        standardButtons: StandardButton.Ok
-    }
-}
@@ -2,8 +2,6 @@ import QtQuick 2.9
 import QtQuick.Controls 2.2

 import StreamingPreferences 1.0
-import ComputerManager 1.0
-import SdlGamepadKeyNavigation 1.0

 ScrollView {
    id: settingsPage
@@ -13,37 +11,19 @@ ScrollView {
        id: prefs
    }

-    // 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
-
-    SdlGamepadKeyNavigation {
-        id: gamepadKeyNav
-    }
-
-    onVisibleChanged: {
-        if (visible) {
-            gamepadKeyNav.setSettingsMode(true)
-            gamepadKeyNav.enable()
-        }
-        else {
-            gamepadKeyNav.disable()
-        }
-    }
-
    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
@@ -55,7 +35,7 @@ ScrollView {
                Label {
                    width: parent.width
                    id: resFPStitle
-                    text: qsTr("Resolution and FPS")
+                    text: qsTr("Resolution and FPS target")
                    font.pointSize: 12
                    wrapMode: Text.Wrap                    
                    color: "white"
@@ -64,206 +44,84 @@ ScrollView {
                Label {
                    width: parent.width
                    id: resFPSdesc
-                    text: qsTr("Setting values too high for your PC may cause lag, stuttering, or errors.")
+                    text: qsTr("Setting values too high for your 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 = prefs.getDesktopResolution(displayIndex)
-                                    }
-                                    else {
-                                        screenRect = prefs.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 = prefs.width
-                            var saved_height = prefs.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 (prefs.width !== selectedWidth || prefs.height !== selectedHeight) {
-                                prefs.width = selectedWidth
-                                prefs.height = selectedHeight
-
-                                prefs.bitrateKbps = prefs.getDefaultBitrate(prefs.width, prefs.height, prefs.fps);
-                                slider.value = prefs.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, '')
-
-                            // Get the max supported FPS on this system
-                            var max_fps = prefs.getMaximumStreamingFrameRate();
-
-                            // 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 (prefs.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) {
-                                fpsListModel.append({"text": max_fps+" FPS", "video_fps": ""+max_fps})
-                            }
-
-                            // Add unsupported FPS values that come after the display max FPS
-                            if (prefs.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 = prefs.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 (prefs.fps !== selectedFps) {
-                                prefs.fps = selectedFps
-
-                                prefs.bitrateKbps = prefs.getDefaultBitrate(prefs.width, prefs.height, prefs.fps);
-                                slider.value = prefs.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
                    }
                }

@@ -293,7 +151,7 @@ ScrollView {

                    stepSize: 500
                    from : 500
-                    to: 150000
+                    to: 100000

                    snapMode: "SnapOnRelease"
                    width: Math.min(bitrateDesc.implicitWidth, parent.width)
@@ -304,59 +162,13 @@ ScrollView {
                    }
                }

-                Label {
-                    width: parent.width
-                    id: windowModeTitle
-                    text: qsTr("Display mode")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                    color: "white"
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var savedWm = prefs.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
-                    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: {
-                        prefs.windowMode = windowModeListModel.get(currentIndex).val
-                    }
-                }
-
                CheckBox {
-                    id: vsyncCheck
-                    text: "<font color=\"white\">Enable V-Sync</font>"
+                    id: fullScreenCheck
+                    text: "<font color=\"white\">Full-screen</font>"
                    font.pointSize:  12
-                    checked: prefs.enableVsync
+                    checked: prefs.fullScreen
                    onCheckedChanged: {
-                        prefs.enableVsync = checked
+                        prefs.fullScreen = checked
                    }
                }
            }
@@ -365,7 +177,7 @@ ScrollView {
        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
@@ -374,67 +186,29 @@ ScrollView {
                anchors.fill: parent
                spacing: 5

-                Label {
-                    width: parent.width
-                    id: resAudioTitle
-                    text: qsTr("Audio configuration")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                    color: "white"
-                }
+                CheckBox {
+                    id: surroundSoundCheck
+                    text: "<font color=\"white\">Enable 5.1 surround sound</font>"
+                    font.pointSize:  12

-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var saved_audio = prefs.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)
-                    }
+                    // the backend actually supports auto/stereo/5.1.  We'll expose stereo/5.1
+                    checked: prefs.audioConfig === StreamingPreferences.AC_FORCE_SURROUND

-                    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 : {
-                        prefs.audioConfig = audioListModel.get(currentIndex).val
+                    onCheckedChanged: {
+                        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

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

@@ -447,35 +221,49 @@ ScrollView {
                        prefs.multiController = checked
                    }
                }
+                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: mouseAccelerationCheck
-                    text: "<font color=\"white\">Enable mouse acceleration</font>"
+                    id: onScreenControlsCheck
+                    text: "<font color=\"white\">Show on-screen controls</font>"
                    font.pointSize:  12
-                    checked: prefs.mouseAcceleration
-                    onCheckedChanged: {
-                        prefs.mouseAcceleration = checked
-                    }
+                    // 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

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

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

        GroupBox {
            id: advancedSettingsGroupBox
-            width: (parent.width - parent.padding)
+            width: (parent.width - 20)
            padding: 12
            title: "<font color=\"skyblue\">Advanced Settings</font>"
            font.pointSize: 12
@@ -506,139 +294,10 @@ ScrollView {
                anchors.fill: parent
                spacing: 5

-                Label {
-                    width: parent.width
-                    id: resVDSTitle
-                    text: qsTr("Video decoder")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                    color: "white"
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var saved_vds = prefs.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 : {
-                        prefs.videoDecoderSelection = decoderListModel.get(currentIndex).val
-                    }
-                }
-
-                Label {
-                    width: parent.width
-                    id: resVCCTitle
-                    text: qsTr("Video codec")
-                    font.pointSize: 12
-                    wrapMode: Text.Wrap
-                    color: "white"
-                }
-
-                AutoResizingComboBox {
-                    // ignore setting the index at first, and actually set it when the component is loaded
-                    Component.onCompleted: {
-                        var saved_vcc = prefs.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 : {
-                        prefs.videoCodecConfig = codecListModel.get(currentIndex).val
-                    }
-                }
-
                CheckBox {
-                    id: unlockUnsupportedFps
-                    text: "<font color=\"white\">Unlock unsupported FPS options</font>"
-                    font.pointSize: 12
-                    checked: prefs.unsupportedFps
-                    onCheckedChanged: {
-                        prefs.unsupportedFps = checked
-
-                        // The selectable FPS values depend on whether
-                        // this option is enabled or not
-                        fpsComboBox.reinitialize()
-                    }
-                }
-
-                CheckBox {
-                    id: enableMdns
-                    text: "<font color=\"white\">Automatically find PCs on the local network (Recommended)</font>"
-                    font.pointSize: 12
-                    checked: prefs.enableMdns
-                    onCheckedChanged: {
-                        prefs.enableMdns = checked
-
-                        // We must save the updated preference to ensure
-                        // ComputerManager can observe the change internally.
-                        prefs.save()
-
-                        // Restart polling so the mDNS change takes effect
-                        if (window.pollingActive) {
-                            ComputerManager.stopPollingAsync()
-                            ComputerManager.startPolling()
-                        }
-                    }
+                    id: neverDropFramesCheck
+                    text: "<font color=\"white\">Never drop frames</font>"
+                    font.pointSize:  12
                }
            }
        }
@@ -1,15 +1,13 @@
 import QtQuick 2.0
 import QtQuick.Controls 2.2
-import QtQuick.Dialogs 1.2
-import QtQuick.Window 2.2
+import QtQuick.Dialogs 1.3

 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

@@ -43,19 +41,13 @@ Item {

    function displayLaunchError(text)
    {
-        // Display the error dialog after Session::exec() returns
        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.3; ToolTip {}', parent, '')
-        toast.text = text
-        toast.timeout = 3000
-        toast.visible = true
+        // TODO: toast
    }

    onVisibleChanged: {
@@ -71,25 +63,13 @@ Item {
            session.displayLaunchWarning.connect(displayLaunchWarning)

            // Run the streaming session to completion
-            session.exec(Screen.virtualX, Screen.virtualY)
+            session.exec()

-            if (quitAfter) {
-                Qt.quit()
-            } else {
-                // Show the Qt window again after streaming
-                window.visible = true
+            // Show the Qt window again after streaming
+            window.visible = true

-                // Exit this view
-                stackView.pop()
-
-                // Display any launch errors. We do this after
-                // the Qt UI is visible again to prevent losing
-                // focus on the dialog which would impact gamepad
-                // users.
-                if (errorDialog.text) {
-                    errorDialog.open()
-                }
-            }
+            // Exit this view
+            stackView.pop()
        }
        else {
            // Show the toolbar again when we become hidden
@@ -117,25 +97,10 @@ Item {
        }
    }

-    Label {
-        text: "Tip: Press Ctrl+Alt+Shift+Q to disconnect your session"
-        anchors.bottom: parent.bottom
-        anchors.bottomMargin: 50
-        anchors.horizontalCenter: parent.horizontalCenter
-        font.pointSize: 18
-        verticalAlignment: Text.AlignVCenter
-
-        wrapMode: Text.Wrap
-        color: "white"
-    }
-
    MessageDialog {
        id: errorDialog
        modality:Qt.WindowModal
        icon: StandardIcon.Critical
-        standardButtons: StandardButton.Ok | StandardButton.Help
-        onHelp: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Troubleshooting");
-        }
+        standardButtons: StandardButton.Ok
    }
 }
@@ -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);
 }
@@ -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;
@@ -1,7 +1,5 @@
 #include "computermodel.h"

-#include <QThreadPool>
-
 ComputerModel::ComputerModel(QObject* object)
    : QAbstractListModel(object) {}

@@ -48,12 +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 AddPcRole:
        return false;
-    case StatusUnknownRole:
-        return computer->state == NvComputer::CS_UNKNOWN;
    default:
        return QVariant();
    }
@@ -80,8 +74,6 @@ QHash<int, QByteArray> ComputerModel::roleNames() const
    names[PairedRole] = "paired";
    names[BusyRole] = "busy";
    names[AddPcRole] = "addPc";
-    names[WakeableRole] = "wakeable";
-    names[StatusUnknownRole] = "statusUnknown";

    return names;
 }
@@ -121,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)
@@ -153,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)
@@ -1,5 +1,5 @@
 #include "backend/computermanager.h"
-#include "streaming/session.h"
+#include "streaming/session.hpp"

 #include <QAbstractListModel>

@@ -13,8 +13,6 @@ class ComputerModel : public QAbstractListModel
        OnlineRole,
        PairedRole,
        BusyRole,
-        WakeableRole,
-        StatusUnknownRole,
        AddPcRole
    };

@@ -34,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);

@@ -1,120 +1,22 @@
 import QtQuick 2.9
 import QtQuick.Controls 2.2
-import QtQuick.Dialogs 1.2
 import QtQuick.Layouts 1.3
-import QtQuick.Window 2.2

 import QtQuick.Controls.Material 2.1

-import ComputerManager 1.0
-import AutoUpdateChecker 1.0
-import StreamingPreferences 1.0
-
 ApplicationWindow {
-    property bool pollingActive: false
-
    id: window
    visible: true
    width: 1280
    height: 600

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

-    StreamingPreferences {
-        id: prefs
-    }
-
    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()
-            }
-        }
-
-        Keys.onBackPressed: {
-            if (depth > 1) {
-                stackView.pop()
-            }
-        }
-
-        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()
-        }
-    }
-
-    onVisibilityChanged: {
-        // We don't want to just use 'active' here because that will stop polling if
-        // we lose focus, which might be overzealous for users with multiple screens
-        // where we may be clearly visible on the other display. Ideally we'll poll
-        // only if the window is visible to the user (not if obscured by other windows),
-        // but it seems difficult to do this portably.
-        var shouldPoll = visibility !== Window.Minimized && visibility !== Window.Hidden
-
-        if (shouldPoll && !pollingActive) {
-            ComputerManager.startPolling()
-            pollingActive = true
-        }
-        else if (!shouldPoll && pollingActive) {
-            ComputerManager.stopPollingAsync()
-            pollingActive = false
-        }
-    }
-
-    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) {
-            if (prefs.isRunningWayland()) {
-                waylandDialog.open()
-            }
-            else if (prefs.isWow64()) {
-                wow64Dialog.open()
-            }
-            else if (!prefs.hasAnyHardwareAcceleration()) {
-                noHwDecoderDialog.open()
-            }
-
-            var unmappedGamepads = prefs.getUnmappedGamepads()
-            if (unmappedGamepads) {
-                unmappedGamepadDialog.unmappedGamepads = unmappedGamepads
-                unmappedGamepadDialog.open()
-            }
-
-            initialized = true;
-        }
    }

    function navigateTo(url, objectName)
@@ -135,33 +37,22 @@ ApplicationWindow {

    header: ToolBar {
        id: toolBar
-        anchors.topMargin: 5
-        anchors.bottomMargin: 5

        RowLayout {
            spacing: 20
            anchors.fill: parent

-            NavigableToolButton {
+            ToolButton {
                // Only make the button visible if the user has navigated somewhere.
                visible: stackView.depth > 1

-                // FIXME: We're using an Image here rather than icon.source because
-                // icons don't work on Qt 5.9 LTS.
-                Image {
-                    source: "qrc:/res/arrow_left.svg"
-                    anchors.centerIn: parent
-                    sourceSize {
-                        // The icon should be square so use the height as the width too
-                        width: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                        height: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                    }
-                }
-
+                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
                }
            }

@@ -175,182 +66,40 @@ ApplicationWindow {
                Layout.fillWidth: true
            }

-            NavigableToolButton {
-                property string browserUrl: ""
-
-                id: updateButton
-
-                Image {
-                    source: "qrc:/res/update.svg"
-                    anchors.centerIn: parent
-                    sourceSize {
-                        width: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                        height: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                    }
-                }
-
-                ToolTip.delay: 1000
-                ToolTip.timeout: 3000
-                ToolTip.visible: hovered
-                ToolTip.text: "Update available for Moonlight"
-
-                // Invisible until we get a callback notifying us that
-                // an update is available
-                visible: false
-
-                onClicked: Qt.openUrlExternally(browserUrl);
-
-                function updateAvailable(url)
-                {
-                    updateButton.browserUrl = url
-                    updateButton.visible = true
-                }
-
-                Component.onCompleted: {
-                    AutoUpdateChecker.onUpdateAvailable.connect(updateAvailable)
-                    AutoUpdateChecker.start()
-                }
-
-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
-                }
-            }
-
-            NavigableToolButton {
-                id: helpButton
-
-                Image {
-                    source: "qrc:/res/question_mark.svg"
-                    anchors.centerIn: parent
-                    sourceSize {
-                        width: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                        height: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                    }
-                }
-
-                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"
-
-                Image {
-                    source: "qrc:/res/ic_videogame_asset_white_48px.svg"
-                    anchors.centerIn: parent
-                    sourceSize {
-                        width: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                        height: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                    }
-                }
-
+            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
-
-                Image {
-                    source: "qrc:/res/settings.svg"
-                    anchors.centerIn: parent
-                    sourceSize {
-                        width: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                        height: toolBar.height - toolBar.anchors.bottomMargin - toolBar.anchors.topMargin
-                    }
-                }
-
+            ToolButton {
+                icon.source: "qrc:/res/settings.svg"
                onClicked: navigateTo("qrc:/gui/SettingsView.qml", "Settings")

-                Keys.onDownPressed: {
-                    stackView.currentItem.forceActiveFocus(Qt.TabFocus)
+                Menu {
+                    id: optionsMenu
+                    x: parent.width
+                    transformOrigin: Menu.TopRight
                }
-
-                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+")") : "")
            }
        }
    }
-
-    MessageDialog {
-        id: noHwDecoderDialog
-        modality:Qt.WindowModal
-        icon: StandardIcon.Warning
-        standardButtons: StandardButton.Ok | StandardButton.Help
-        text: "No functioning hardware accelerated H.264 video decoder was detected by Moonlight. " +
-              "Your streaming performance may be severely degraded in this configuration. " +
-              "Click the Help button for more information on solving this problem."
-        onHelp: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems");
-        }
-    }
-
-    MessageDialog {
-        id: waylandDialog
-        modality:Qt.WindowModal
-        icon: StandardIcon.Warning
-        standardButtons: StandardButton.Ok | StandardButton.Help
-        text: "Moonlight does not support hardware acceleration on Wayland. Continuing on Wayland may result in poor streaming performance. " +
-              "Please switch to an X session for optimal performance."
-        onHelp: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Fixing-Hardware-Decoding-Problems");
-        }
-    }
-
-    MessageDialog {
-        id: wow64Dialog
-        modality:Qt.WindowModal
-        icon: StandardIcon.Warning
-        standardButtons: StandardButton.Ok | StandardButton.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");
-        }
-    }
-
-    MessageDialog {
-        id: unmappedGamepadDialog
-        property string unmappedGamepads : ""
-        modality:Qt.WindowModal
-        icon: StandardIcon.Warning
-        standardButtons: StandardButton.Ok | StandardButton.Help
-        text: "Moonlight detected gamepads without a proper mapping. " +
-              "The following gamepads will not function until this is resolved: " + unmappedGamepads + "\n\n" +
-              "Click the Help button for information on how to map your gamepads."
-        onHelp: {
-            Qt.openUrlExternally("https://github.com/moonlight-stream/moonlight-docs/wiki/Gamepad-Mapping");
-        }
-    }
 }
@@ -1,246 +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_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;
-}
@@ -1,35 +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);
-
-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;
-};
@@ -1,10 +1,7 @@
 #include <QGuiApplication>
 #include <QQmlApplicationEngine>
-#include <QQmlContext>
 #include <QIcon>
 #include <QQuickStyle>
-#include <QMutex>
-#include <QtDebug>

 // Don't let SDL hook our main function, since Qt is already
 // doing the same thing. This needs to be before any headers
@@ -12,271 +9,23 @@
 #define SDL_MAIN_HANDLED
 #include <SDL.h>

-#ifdef HAVE_FFMPEG
-#include "streaming/video/ffmpeg.h"
-#endif
-
-#include "cli/startstream.h"
-#include "cli/commandlineparser.h"
-#include "path.h"
 #include "gui/computermodel.h"
 #include "gui/appmodel.h"
-#include "backend/autoupdatechecker.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[])
 {
-    // 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
-
    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", 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
+    // 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");
@@ -289,67 +38,35 @@ int main(int argc, char *argv[])
    qmlRegisterType<ComputerModel>("ComputerModel", 1, 0, "ComputerModel");
    qmlRegisterType<AppModel>("AppModel", 1, 0, "AppModel");
    qmlRegisterType<StreamingPreferences>("StreamingPreferences", 1, 0, "StreamingPreferences");
-    qmlRegisterType<SdlGamepadKeyNavigation>("SdlGamepadKeyNavigation", 1, 0, "SdlGamepadKeyNavigation");
    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();
-                                                });

    QQuickStyle::setStyle("Material");

-    QQmlApplicationEngine engine;
-    QString initialView;
-
-    GlobalCommandLineParser parser;
-    switch (parser.parse(app.arguments())) {
-    case GlobalCommandLineParser::NormalStartRequested:
-        initialView = "PcView.qml";
-        break;
-    case GlobalCommandLineParser::StreamRequested:
-        {
-            initialView = "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;
-        }
-    }
-
-    engine.rootContext()->setContextProperty("initialView", initialView);
-
    // 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(0) != 0) {
+    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());
    }

-    // 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");
-
    int err = app.exec();

+    SDL_Quit();
+
    return err;
 }
@@ -1,77 +0,0 @@
-#include "path.h"
-
-#include <QtDebug>
-#include <QDir>
-#include <QStandardPaths>
-#include <QSettings>
-#include <QCoreApplication>
-
-QString Path::s_LogDir;
-QString Path::s_BoxArtCacheDir;
-const QString Path::k_GameControllerMappingFile("gamecontrollerdb.txt");
-
-QString Path::getLogDir()
-{
-    Q_ASSERT(!s_LogDir.isEmpty());
-    return s_LogDir;
-}
-
-QString Path::getBoxArtCacheDir()
-{
-    Q_ASSERT(!s_BoxArtCacheDir.isEmpty());
-    return s_BoxArtCacheDir;
-}
-
-QString Path::getGamepadMappingFile()
-{
-    QString candidatePath;
-
-    // Check the current directory first
-    candidatePath = QDir(QDir::currentPath()).absoluteFilePath(k_GameControllerMappingFile);
-    if (QFile::exists(candidatePath)) {
-        return candidatePath;
-    }
-
-    // Now check the data directories (for Linux, in particular)
-    candidatePath = QStandardPaths::locate(QStandardPaths::DataLocation, k_GameControllerMappingFile);
-    if (!candidatePath.isEmpty() && QFile::exists(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(k_GameControllerMappingFile);
-    if (QFile::exists(candidatePath)) {
-        return candidatePath;
-    }
-
-    // Now try the Resources folder in our app bundle for macOS
-    QDir dir = QDir(QCoreApplication::applicationDirPath());
-    dir.cdUp();
-    dir.cd("Resources");
-    dir.filePath(k_GameControllerMappingFile);
-    candidatePath = dir.absoluteFilePath(k_GameControllerMappingFile);
-    if (QFile::exists(candidatePath)) {
-        return candidatePath;
-    }
-
-    // Couldn't find it
-    return QString();
-}
-
-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";
-    }
-}
@@ -1,20 +0,0 @@
-#pragma once
-
-#include <QString>
-
-class Path
-{
-public:
-    static QString getLogDir();
-
-    static QString getBoxArtCacheDir();
-
-    static QString getGamepadMappingFile();
-
-    static void initialize(bool portable);
-
-private:
-    static QString s_LogDir;
-    static QString s_BoxArtCacheDir;
-    static const QString k_GameControllerMappingFile;
-};
@@ -6,11 +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/CliStartStreamSegue.qml</file>
-        <file>gui/AutoResizingComboBox.qml</file>
    </qresource>
 </RCC>
@@ -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>
@@ -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>
@@ -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>
@@ -1,69 +1,23 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   id="svg3761"
-   viewBox="0 0 680 680"
-   height="680"
-   width="680"
-   version="1.0">
-  <metadata
-     id="metadata3767">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <defs
-     id="defs3765" />
-  <g
-     id="g3759"
-     transform="translate(-135,491) scale(0.100000,-0.100000)">
-    <circle
-       id="circle3741"
-       fill="#565C64"
-       r="3400"
-       cy="1505"
-       cx="4755" />
-    <path
-       id="path3743"
-       style="fill:#ffffff"
-       d="M4550 4230 c-582 -48 -1123 -271 -1568 -646 l-84 -70 869 -869 c477 -477 871 -868 876 -868 4 0 6 552 5 1228 l-3 1227 -25 1 c-14 0 -45 -1 -70 -3z" />
-    <path
-       id="path3745"
-       style="fill:#ffffff"
-       d="M4867 4230 c-10 -9 -9 -2453 1 -2453 4 0 398 391 875 868 l869 869 -84 70 c-344 290 -749 492 -1178 587 -166 36 -469 74 -483 59z" />
-    <path
-       id="path3747"
-       style="fill:#ffffff"
-       d="M2673 3275 c-241 -285 -412 -595 -526 -953 -63 -196 -111 -458 -119 -640 l-3 -70 1228 -3 c675 -1 1227 1 1227 5 0 5 -391 399 -868 876 l-869 869 -70 -84z" />
-    <path
-       id="path3749"
-       style="fill:#ffffff"
-       d="M5898 2490 c-478 -477 -868 -871 -868 -876 0 -4 552 -6 1228 -5 l1227 3 -3 70 c-14 326 -124 729 -287 1055 -91 182 -259 430 -387 573 l-43 48 -867 -868z" />
-    <path
-       id="path3751"
-       style="fill:#ffffff"
-       d="M2026 1388 c-7 -11 10 -198 30 -321 76 -486 291 -952 617 -1338 l70 -84 869 869 c477 477 868 871 868 875 0 11 -2448 10 -2454 -1z" />
-    <path
-       id="path3753"
-       style="fill:#ffffff"
-       d="M5030 1390 c0 -5 391 -399 868 -876 l869 -869 70 84 c241 285 412 595 526 953 63 196 111 458 119 640 l3 70 -1227 3 c-676 1 -1228 -1 -1228 -5z" />
-    <path
-       id="path3755"
-       style="fill:#ffffff"
-       d="M3767 359 l-869 -869 84 -70 c285 -241 595 -412 953 -526 196 -63 458 -111 640 -119 l70 -3 3 1228 c1 675 -1 1227 -5 1227 -5 0 -399 -391 -876 -868z" />
-    <path
-       id="path3757"
-       style="fill:#ffffff"
-       d="M4862 0 l3 -1228 70 3 c182 8 444 56 640 119 358 114 668 285 953 526 l84 70 -869 869 c-477 477 -871 868 -876 868 -4 0 -6 -552 -5 -1227z" />
+<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>
+</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="#0BF200">
-    <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>
@@ -5,14 +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/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>
    </qresource>
 </RCC>
@@ -1,108 +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()
-{
-    QString mappingFile = Path::getGamepadMappingFile();
-    if (!mappingFile.isEmpty()) {
-        std::string mappingFileNative = QDir::toNativeSeparators(mappingFile).toStdString();
-
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Loading gamepad mappings from: %s",
-                    mappingFileNative.c_str());
-
-        int newMappings = SDL_GameControllerAddMappingsFromFile(mappingFileNative.c_str());
-        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_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "No gamepad mapping file found");
-    }
-
-    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;
-}
@@ -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;
-};
-
@@ -1,6 +1,4 @@
 #include "streamingpreferences.h"
-#include "streaming/session.h"
-#include "streaming/streamutils.h"

 #include <QSettings>

@@ -10,20 +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_MOUSEACCELERATION "mouseacceleration"

-StreamingPreferences::StreamingPreferences(QObject *parent)
-    : QObject(parent)
+StreamingPreferences::StreamingPreferences()
 {
    reload();
 }
@@ -36,23 +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();
-    mouseAcceleration = settings.value(SER_MOUSEACCELERATION, false).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()
@@ -63,160 +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_MOUSEACCELERATION, mouseAcceleration);
    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));
-}
-
-bool StreamingPreferences::hasAnyHardwareAcceleration()
-{
-    // Always use VDS_AUTO to avoid spamming the user with warnings
-    // if they've forced software decoding.
-    return Session::isHardwareDecodeAvailable(VDS_AUTO,
-                                              VIDEO_FORMAT_H264,
-                                              1920, 1080, 60);
-}
-
-bool StreamingPreferences::isRunningWayland()
-{
-    return qgetenv("XDG_SESSION_TYPE") == QByteArray("wayland");
-}
-
-bool StreamingPreferences::isWow64()
-{
-#ifdef Q_OS_WIN32
-    return QSysInfo::currentCpuArchitecture() != QSysInfo::buildCpuArchitecture();
-#else
-    return false;
-#endif
-}
-
-QString StreamingPreferences::getUnmappedGamepads()
-{
-    return SdlInputHandler::getUnmappedGamepads();
-}
-
-int StreamingPreferences::getMaximumStreamingFrameRate()
-{
-    // Never let the maximum drop below 60 FPS
-    int maxFrameRate = 60;
-
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return maxFrameRate;
-    }
-
-    SDL_DisplayMode mode, bestMode, desktopMode;
-    for (int displayIndex = 0; displayIndex < SDL_GetNumVideoDisplays(); displayIndex++) {
-        // Get the native desktop resolution
-        if (StreamUtils::getRealDesktopMode(displayIndex, &desktopMode)) {
-
-            // Start at desktop mode and work our way up
-            bestMode = desktopMode;
-            for (int i = 0; i < SDL_GetNumDisplayModes(displayIndex); i++) {
-                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;
-                        }
-                    }
-                }
-            }
-
-            // Cap the frame rate at 120 FPS. Past this, the encoders start
-            // to max out and drop frames.
-            maxFrameRate = qMax(maxFrameRate, qMin(120, bestMode.refresh_rate));
-        }
-    }
-
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
-
-    return maxFrameRate;
-}
-
-QRect StreamingPreferences::getDesktopResolution(int displayIndex)
-{
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return QRect();
-    }
-
-    if (displayIndex >= SDL_GetNumVideoDisplays()) {
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        return QRect();
-    }
-
-    SDL_DisplayMode mode;
-    int err = SDL_GetDesktopDisplayMode(displayIndex, &mode);
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
-
-    if (err == 0) {
-        return QRect(0, 0, mode.w, mode.h);
-    }
-    else {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_GetDesktopDisplayMode() failed: %s",
-                     SDL_GetError());
-        return QRect();
-    }
-}
-
-QRect StreamingPreferences::getNativeResolution(int displayIndex)
-{
-    if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
-                     SDL_GetError());
-        return QRect();
-    }
-
-    if (displayIndex >= SDL_GetNumVideoDisplays()) {
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-        return QRect();
-    }
-
-    SDL_DisplayMode mode;
-    bool success = StreamUtils::getRealDesktopMode(displayIndex, &mode);
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
-
-    if (success) {
-        return QRect(0, 0, mode.w, mode.h);
-    }
-    else {
-        return QRect();
-    }
 }

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

    Q_INVOKABLE void save();

-    Q_INVOKABLE static bool hasAnyHardwareAcceleration();
-
-    Q_INVOKABLE static bool isRunningWayland();
-
-    Q_INVOKABLE static bool isWow64();
-
-    Q_INVOKABLE static int getMaximumStreamingFrameRate();
-
-    Q_INVOKABLE QRect getDesktopResolution(int displayIndex);
-
-    Q_INVOKABLE QRect getNativeResolution(int displayIndex);
-
-    Q_INVOKABLE QString getUnmappedGamepads();
-
    void reload();

    enum AudioConfig
    {
-        AC_STEREO,
-        AC_51_SURROUND
+        AC_AUTO,
+        AC_FORCE_STEREO,
+        AC_FORCE_SURROUND
    };
    Q_ENUM(AudioConfig)

@@ -55,60 +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 mouseAcceleration MEMBER mouseAcceleration NOTIFY mouseAccelerationChanged)
    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 mouseAcceleration;
    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 mouseAccelerationChanged();
    void audioConfigChanged();
    void videoCodecConfigChanged();
    void videoDecoderSelectionChanged();
-    void windowModeChanged();
 };

@@ -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());
+        }
+    }
+}
@@ -1,150 +0,0 @@
-#include "../session.h"
-#include "renderers/renderer.h"
-
-#ifdef HAVE_SOUNDIO
-#include "renderers/soundioaudiorenderer.h"
-#else
-#include "renderers/sdl.h"
-#endif
-
-#include <Limelight.h>
-
-IAudioRenderer* Session::createAudioRenderer()
-{
-#ifdef HAVE_SOUNDIO
-    return new SoundIoAudioRenderer();
-#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;
-
-    // Set this thread to high priority to reduce
-    // the chance of missing our sample delivery time
-    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());
-        }
-    }
-
-    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) {
-        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;
-        }
-    }
-}
@@ -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;
-    }
-}
@@ -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;
-};
@@ -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;
-};
@@ -1,24 +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;
-    Uint32 m_ChannelCount;
-    Uint32 m_PendingDrops;
-    Uint32 m_PendingHardDrops;
-    Uint32 m_SampleIndex;
-    Uint32 m_BaselinePendingData;
-};
@@ -1,159 +0,0 @@
-#include "sdl.h"
-
-#include <Limelight.h>
-#include <SDL.h>
-
-#include <QtGlobal>
-
-#define MIN_QUEUED_FRAMES 2
-#define MAX_QUEUED_FRAMES 4
-#define STOP_THE_WORLD_LIMIT 20
-#define DROP_RATIO_DENOM 32
-
-SdlAudioRenderer::SdlAudioRenderer()
-    : m_AudioDevice(0),
-      m_ChannelCount(0),
-      m_PendingDrops(0),
-      m_PendingHardDrops(0),
-      m_SampleIndex(0),
-      m_BaselinePendingData(0)
-{
-    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);
-
-    // SDL counts pending samples in the queued
-    // audio size using the WASAPI backend. This
-    // includes silence, which can throw off our
-    // pending data count. Get a baseline so we
-    // can exclude that data.
-    m_BaselinePendingData = 0;
-#ifdef Q_OS_WIN32
-    for (int i = 0; i < 100; i++) {
-        m_BaselinePendingData = qMax(m_BaselinePendingData, SDL_GetQueuedAudioSize(m_AudioDevice));
-        SDL_Delay(10);
-    }
-#endif
-    m_BaselinePendingData *= 2;
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Baseline pending audio data: %d bytes",
-                m_BaselinePendingData);
-
-    m_ChannelCount = opusConfig->channelCount;
-    m_SampleIndex = 0;
-    m_PendingDrops = m_PendingHardDrops = 0;
-
-    // Start playback
-    SDL_PauseAudioDevice(m_AudioDevice, 0);
-
-    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)
-{
-    m_SampleIndex++;
-
-    Uint32 queuedAudio = SDL_GetQueuedAudioSize(m_AudioDevice);
-    if (queuedAudio > m_BaselinePendingData) {
-        queuedAudio -= m_BaselinePendingData;
-    }
-    else {
-        queuedAudio = 0;
-    }
-
-    Uint32 framesQueued = queuedAudio / (SAMPLES_PER_FRAME * m_ChannelCount * sizeof(short));
-
-    // We must check this prior to the below checks to ensure we don't
-    // underflow if framesQueued - m_PendingHardDrops < 0.
-    if (framesQueued <= MIN_QUEUED_FRAMES) {
-        m_PendingDrops = m_PendingHardDrops = 0;
-    }
-    // Pend enough drops to get us back to MIN_QUEUED_FRAMES, checking first
-    // to ensure we don't underflow.
-    else if (framesQueued > m_PendingHardDrops &&
-             framesQueued - m_PendingHardDrops > STOP_THE_WORLD_LIMIT) {
-        m_PendingHardDrops = framesQueued - MIN_QUEUED_FRAMES;
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Pending hard drop of %u audio frames",
-                    m_PendingHardDrops);
-    }
-    // If we're under the stop the world limit, we can drop samples
-    // gracefully over the next little while.
-    else if (framesQueued > m_PendingHardDrops + m_PendingDrops &&
-             framesQueued - m_PendingHardDrops - m_PendingDrops > MAX_QUEUED_FRAMES) {
-        m_PendingDrops = framesQueued - MIN_QUEUED_FRAMES;
-    }
-
-    // Determine if this frame should be dropped
-    if (m_PendingHardDrops != 0) {
-        // Hard drops happen all at once to forcefully
-        // resync with the source.
-        m_PendingHardDrops--;
-        return true;
-    }
-    else if (m_PendingDrops != 0 && m_SampleIndex % DROP_RATIO_DENOM == 0) {
-        // Normal drops are interspersed with the audio data
-        // to hide the glitches.
-        m_PendingDrops--;
-        return true;
-    }
-
-    if (SDL_QueueAudio(m_AudioDevice, audioBuffer, audioSize) < 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to queue audio sample: %s",
-                     SDL_GetError());
-    }
-
-    return true;
-}
@@ -1,436 +0,0 @@
-#include "soundioaudiorenderer.h"
-
-#include <SDL.h>
-
-#include <QtGlobal>
-
-SoundIoAudioRenderer::SoundIoAudioRenderer()
-    : m_OpusChannelCount(0),
-      m_SoundIo(nullptr),
-      m_Device(nullptr),
-      m_OutputStream(nullptr),
-      m_RingBuffer(nullptr),
-      m_Errored(false)
-{
-
-}
-
-SoundIoAudioRenderer::~SoundIoAudioRenderer()
-{
-    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->name = "Moonlight";
-    m_OutputStream->userdata = this;
-    m_OutputStream->error_callback = sioErrorCallback;
-    m_OutputStream->write_callback = sioWriteCallback;
-
-    // This determines the size of the buffers we'll
-    // get from CoreAudio. Since GFE sends us packets
-    // in 5 ms chunks, we'll give them to the OS in
-    // buffers of the same size.
-    m_OutputStream->software_latency = 0.005;
-
-    SoundIoChannelLayout bestLayout = m_Device->current_layout;
-    for (int i = 0; i < m_Device->layout_count; i++) {
-        if (scoreChannelLayout(&bestLayout, opusConfig) <
-                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;
-        }
-    }
-
-    // Buffer up to 6 packets of audio (30 ms) to smooth
-    // out network packet delivery jitter
-    m_RingBuffer = soundio_ring_buffer_create(m_SoundIo,
-                                              m_OutputStream->bytes_per_sample *
-                                              m_OpusChannelCount *
-                                              SAMPLES_PER_FRAME * 6);
-    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;
-    }
-
-    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);
-
-    // Place an upper-bound on audio stream latency to
-    // avoid accumulating packets in queue-based backends
-    // like WASAPI. This bound was set by testing on several
-    // Windows machines. The highest latency was found on
-    // a XPS 9343 running Windows 7 in Steam Big Picture
-    // and the 5.1 audio test clip from Fraunhofer.
-    if (me->m_SoundIo->current_backend == SoundIoBackendWasapi) {
-        double latency;
-        if (soundio_outstream_get_latency(stream, &latency) == SoundIoErrorNone) {
-            if (latency > 0.050) {
-                // If our latency is higher than desired, drop these samples to gracefully lower
-                // the latency without glitching too much. Dropping the whole buffer causes
-                // a much more noticeable glitch. This approach also ensures that we don't
-                // accidentally underflow if the driver/kernel side is delayed and isn't
-                // consuming data fast enough. Dropping a frame at a time and re-evaluating
-                // each time ensures that we'll stop dropping if latency returns to normal.
-                readPtr += framesLeft * stream->bytes_per_sample * me->m_OpusChannelCount;
-                bytesRead += framesLeft * stream->bytes_per_sample * me->m_OpusChannelCount;
-                framesLeft = 0;
-
-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "Latency exceeded drop cap: %f",
-                            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);
-}
@@ -1,36 +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;
-    bool m_Errored;
-};
@@ -1,11 +1,6 @@
 #include <Limelight.h>
 #include <SDL.h>
-#include "streaming/session.h"
-#include "settings/mappingmanager.h"
-#include "path.h"
-
-#include <QtGlobal>
-#include <QDir>
+#include "streaming/session.hpp"

 #define VK_0 0x30
 #define VK_A 0x41
@@ -14,18 +9,9 @@
 #ifndef VK_F1
 #define VK_F1 0x70
 #define VK_F13 0x7C
-#define VK_NUMPAD0 0x60
+#define VK_NUMPAD1 0x61
 #endif

-// How long the mouse button will be pressed for a tap to click gesture
-#define TAP_BUTTON_RELEASE_DELAY 100
-
-// How long the fingers must be stationary to start a drag
-#define DRAG_ACTIVATION_DELAY 650
-
-// How far the finger can move before it cancels a drag or tap
-#define DEAD_ZONE_DELTA 0.1f
-
 const int SdlInputHandler::k_ButtonMap[] = {
    A_FLAG, B_FLAG, X_FLAG, Y_FLAG,
    BACK_FLAG, SPECIAL_FLAG, PLAY_FLAG,
@@ -34,65 +20,15 @@ const int SdlInputHandler::k_ButtonMap[] = {
    UP_FLAG, DOWN_FLAG, LEFT_FLAG, RIGHT_FLAG
 };

-SdlInputHandler::SdlInputHandler(StreamingPreferences& prefs, NvComputer* computer, int streamWidth, int streamHeight)
-    : m_LastMouseMotionTime(0),
-      m_MultiController(prefs.multiController),
-      m_NeedsInputDelay(false),
-      m_LeftButtonReleaseTimer(0),
-      m_RightButtonReleaseTimer(0),
-      m_DragTimer(0),
-      m_DragButton(0),
-      m_NumFingersDown(0),
-      m_StreamWidth(streamWidth),
-      m_StreamHeight(streamHeight)
+SdlInputHandler::SdlInputHandler(bool multiController)
+    : m_MultiController(multiController)
 {
-    // Allow gamepad input when the app doesn't have focus
-    SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
-
-    // If mouse acceleration is enabled, use relative mode warp (which
-    // is via normal motion events that are influenced by mouse acceleration).
-    // Otherwise, we'll use raw input capture which is straight from the device
-    // without modification by the OS.
-    SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_MODE_WARP,
-                prefs.mouseAcceleration ? "1" : "0");
-
-    // We need to reinit this each time, since you only get
-    // an initial set of gamepad arrival events once per init.
-    SDL_assert(!SDL_WasInit(SDL_INIT_GAMECONTROLLER));
-    if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) failed: %s",
-                     SDL_GetError());
-    }
-
-    MappingManager mappingManager;
-    mappingManager.applyMappings();
-
    if (!m_MultiController) {
        // Player 1 is always present in non-MC mode
        m_GamepadMask = 0x1;
    }
-    else {
-        // Otherwise, detect gamepads on the fly
-        m_GamepadMask = 0;
-    }
-
-    // Prior to GFE 3.14.1, sending too many mouse motion events can cause
-    // GFE to choke and input latency to increase significantly. We will
-    // artificially throttle them to avoid this situation.
-    QVector<int> gfeVersion = NvHTTP::parseQuad(computer->gfeVersion);
-    if (gfeVersion.isEmpty() || // Very old versions don't have GfeVersion at all
-            gfeVersion[0] < 3 ||
-            (gfeVersion[0] == 3 && gfeVersion[1] < 14) ||
-            (gfeVersion[0] == 3 && gfeVersion[1] == 14 && gfeVersion[2] < 1)) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "This older version of GFE requires input delay hack");
-        m_NeedsInputDelay = true;
-    }

    SDL_zero(m_GamepadState);
-    SDL_zero(m_TouchDownEvent);
-    SDL_zero(m_CumulativeDelta);
 }

 SdlInputHandler::~SdlInputHandler()
@@ -102,13 +38,6 @@ SdlInputHandler::~SdlInputHandler()
            SDL_GameControllerClose(m_GamepadState[i].controller);
        }
    }
-
-    SDL_RemoveTimer(m_LeftButtonReleaseTimer);
-    SDL_RemoveTimer(m_RightButtonReleaseTimer);
-    SDL_RemoveTimer(m_DragTimer);
-
-    SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
-    SDL_assert(!SDL_WasInit(SDL_INIT_GAMECONTROLLER));
 }

 void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
@@ -121,13 +50,28 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
            (event->keysym.mod & KMOD_CTRL) &&
            (event->keysym.mod & KMOD_ALT) &&
            (event->keysym.mod & KMOD_SHIFT)) {
+
        // Check for quit combo (Ctrl+Alt+Shift+Q)
        if (event->keysym.sym == SDLK_q) {
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                        "Detected quit key combo");

-            // Push a quit event to the main loop
+            // Force raise all keys in the combo to avoid
+            // leaving them down after disconnecting
+            LiSendKeyboardEvent(0xA0, KEY_ACTION_UP, 0);
+            LiSendKeyboardEvent(0xA1, KEY_ACTION_UP, 0);
+            LiSendKeyboardEvent(0xA2, KEY_ACTION_UP, 0);
+            LiSendKeyboardEvent(0xA3, KEY_ACTION_UP, 0);
+            LiSendKeyboardEvent(0xA4, KEY_ACTION_UP, 0);
+            LiSendKeyboardEvent(0xA5, KEY_ACTION_UP, 0);
+
            SDL_Event event;
+
+            // Drain the event queue of any additional input
+            // that might be processed before our quit message.
+            while (SDL_PollEvent(&event));
+
+            // Push a quit event to the main loop
            event.type = SDL_QUIT;
            event.quit.timestamp = SDL_GetTicks();
            SDL_PushEvent(&event);
@@ -137,24 +81,19 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
        else if (event->keysym.sym == SDLK_z) {
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                        "Detected mouse capture toggle combo");
-
-            // Stop handling future input
            SDL_SetRelativeMouseMode((SDL_bool)!SDL_GetRelativeMouseMode());
-
-            // Force raise all keys to ensure they aren't stuck,
-            // since we won't get their key up events.
-            raiseAllKeys();
            return;
        }
        // Check for the full-screen combo (Ctrl+Alt+Shift+X)
        else if (event->keysym.sym == SDLK_x) {
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                        "Detected full-screen toggle combo");
-            Session::s_ActiveSession->toggleFullscreen();
-
-            // Force raise all keys just be safe across this full-screen/windowed
-            // transition just in case key events get lost.
-            raiseAllKeys();
+            if (SDL_GetWindowFlags(Session::s_ActiveSession->m_Window) & SDL_WINDOW_FULLSCREEN) {
+                SDL_SetWindowFullscreen(Session::s_ActiveSession->m_Window, 0);
+            }
+            else {
+                SDL_SetWindowFullscreen(Session::s_ActiveSession->m_Window, SDL_WINDOW_FULLSCREEN);
+            }
            return;
        }
    }
@@ -176,218 +115,199 @@ void SdlInputHandler::handleKeyEvent(SDL_KeyboardEvent* event)
        modifiers |= MODIFIER_SHIFT;
    }

-    // Set keycode. We explicitly use scancode here because GFE will try to correct
-    // for AZERTY layouts on the host but it depends on receiving VK_ values matching
-    // a QWERTY layout to work.
-    if (event->keysym.scancode >= SDL_SCANCODE_1 && event->keysym.scancode <= SDL_SCANCODE_9) {
-        // SDL defines SDL_SCANCODE_0 > SDL_SCANCODE_9, so we need to handle that manually
-        keyCode = (event->keysym.scancode - SDL_SCANCODE_1) + VK_0 + 1;
+    // Set keycode
+    if (event->keysym.sym >= SDLK_0 && event->keysym.sym <= SDLK_9) {
+        keyCode = (event->keysym.sym - SDLK_0) + VK_0;
    }
-    else if (event->keysym.scancode >= SDL_SCANCODE_A && event->keysym.scancode <= SDL_SCANCODE_Z) {
-        keyCode = (event->keysym.scancode - SDL_SCANCODE_A) + VK_A;
+    else if (event->keysym.sym >= SDLK_a && event->keysym.sym <= SDLK_z) {
+        keyCode = (event->keysym.sym - SDLK_a) + VK_A;
    }
-    else if (event->keysym.scancode >= SDL_SCANCODE_F1 && event->keysym.scancode <= SDL_SCANCODE_F12) {
-        keyCode = (event->keysym.scancode - SDL_SCANCODE_F1) + VK_F1;
+    else if (event->keysym.sym >= SDLK_F1 && event->keysym.sym <= SDLK_F12) {
+        keyCode = (event->keysym.sym - SDLK_F1) + VK_F1;
    }
-    else if (event->keysym.scancode >= SDL_SCANCODE_F13 && event->keysym.scancode <= SDL_SCANCODE_F24) {
-        keyCode = (event->keysym.scancode - SDL_SCANCODE_F13) + VK_F13;
+    else if (event->keysym.sym >= SDLK_F13 && event->keysym.sym <= SDLK_F24) {
+        keyCode = (event->keysym.sym - SDLK_F13) + VK_F13;
    }
-    else if (event->keysym.scancode >= SDL_SCANCODE_KP_1 && event->keysym.scancode <= SDL_SCANCODE_KP_9) {
-        // SDL defines SDL_SCANCODE_KP_0 > SDL_SCANCODE_KP_9, so we need to handle that manually
-        keyCode = (event->keysym.scancode - SDL_SCANCODE_KP_1) + VK_NUMPAD0 + 1;
+    else if (event->keysym.sym >= SDLK_KP_1 && event->keysym.sym <= SDLK_KP_9) {
+        // SDL defines SDLK_KP_0 > SDLK_KP_9, so we need to handle that manually
+        keyCode = (event->keysym.sym - SDLK_KP_1) + VK_NUMPAD1;
    }
    else {
-        switch (event->keysym.scancode) {
-            case SDL_SCANCODE_BACKSPACE:
+        switch (event->keysym.sym) {
+            case SDLK_BACKSPACE:
                keyCode = 0x08;
                break;
-            case SDL_SCANCODE_TAB:
+            case SDLK_TAB:
                keyCode = 0x09;
                break;
-            case SDL_SCANCODE_CLEAR:
+            case SDLK_CLEAR:
                keyCode = 0x0C;
                break;
-            case SDL_SCANCODE_KP_ENTER: // FIXME: Is this correct?
-            case SDL_SCANCODE_RETURN:
+            case SDLK_RETURN:
                keyCode = 0x0D;
                break;
-            case SDL_SCANCODE_PAUSE:
+            case SDLK_PAUSE:
                keyCode = 0x13;
                break;
-            case SDL_SCANCODE_CAPSLOCK:
+            case SDLK_CAPSLOCK:
                keyCode = 0x14;
                break;
-            case SDL_SCANCODE_ESCAPE:
+            case SDLK_ESCAPE:
                keyCode = 0x1B;
                break;
-            case SDL_SCANCODE_SPACE:
+            case SDLK_SPACE:
                keyCode = 0x20;
                break;
-            case SDL_SCANCODE_PAGEUP:
+            case SDLK_PAGEUP:
                keyCode = 0x21;
                break;
-            case SDL_SCANCODE_PAGEDOWN:
+            case SDLK_PAGEDOWN:
                keyCode = 0x22;
                break;
-            case SDL_SCANCODE_END:
+            case SDLK_END:
                keyCode = 0x23;
                break;
-            case SDL_SCANCODE_HOME:
+            case SDLK_HOME:
                keyCode = 0x24;
                break;
-            case SDL_SCANCODE_LEFT:
+            case SDLK_LEFT:
                keyCode = 0x25;
                break;
-            case SDL_SCANCODE_UP:
+            case SDLK_UP:
                keyCode = 0x26;
                break;
-            case SDL_SCANCODE_RIGHT:
+            case SDLK_RIGHT:
                keyCode = 0x27;
                break;
-            case SDL_SCANCODE_DOWN:
+            case SDLK_DOWN:
                keyCode = 0x28;
                break;
-            case SDL_SCANCODE_SELECT:
+            case SDLK_SELECT:
                keyCode = 0x29;
                break;
-            case SDL_SCANCODE_EXECUTE:
+            case SDLK_EXECUTE:
                keyCode = 0x2B;
                break;
-            case SDL_SCANCODE_PRINTSCREEN:
+            case SDLK_PRINTSCREEN:
                keyCode = 0x2C;
                break;
-            case SDL_SCANCODE_INSERT:
+            case SDLK_INSERT:
                keyCode = 0x2D;
                break;
-            case SDL_SCANCODE_DELETE:
+            case SDLK_DELETE:
                keyCode = 0x2E;
                break;
-            case SDL_SCANCODE_HELP:
+            case SDLK_HELP:
                keyCode = 0x2F;
                break;
-            case SDL_SCANCODE_KP_0:
-                // See comment above about why we only handle SDL_SCANCODE_KP_0 here
-                keyCode = VK_NUMPAD0;
+            case SDLK_KP_0:
+                // See comment above about why we only handle KP_0 here
+                keyCode = 0x60;
                break;
-            case SDL_SCANCODE_0:
-                // See comment above about why we only handle SDL_SCANCODE_0 here
-                keyCode = VK_0;
-                break;
-            case SDL_SCANCODE_KP_MULTIPLY:
+            case SDLK_KP_MULTIPLY:
                keyCode = 0x6A;
                break;
-            case SDL_SCANCODE_KP_PLUS:
+            case SDLK_KP_PLUS:
                keyCode = 0x6B;
                break;
-            case SDL_SCANCODE_KP_COMMA:
+            case SDLK_KP_COMMA:
                keyCode = 0x6C;
                break;
-            case SDL_SCANCODE_KP_MINUS:
+            case SDLK_KP_MINUS:
                keyCode = 0x6D;
                break;
-            case SDL_SCANCODE_KP_PERIOD:
+            case SDLK_KP_DECIMAL:
                keyCode = 0x6E;
                break;
-            case SDL_SCANCODE_KP_DIVIDE:
+            case SDLK_KP_DIVIDE:
                keyCode = 0x6F;
                break;
-            case SDL_SCANCODE_NUMLOCKCLEAR:
+            case SDLK_NUMLOCKCLEAR:
                keyCode = 0x90;
                break;
-            case SDL_SCANCODE_SCROLLLOCK:
+            case SDLK_SCROLLLOCK:
                keyCode = 0x91;
                break;
-            case SDL_SCANCODE_LSHIFT:
+            case SDLK_LSHIFT:
                keyCode = 0xA0;
                break;
-            case SDL_SCANCODE_RSHIFT:
+            case SDLK_RSHIFT:
                keyCode = 0xA1;
                break;
-            case SDL_SCANCODE_LCTRL:
+            case SDLK_LCTRL:
                keyCode = 0xA2;
                break;
-            case SDL_SCANCODE_RCTRL:
+            case SDLK_RCTRL:
                keyCode = 0xA3;
                break;
-            case SDL_SCANCODE_LALT:
+            case SDLK_LALT:
                keyCode = 0xA4;
                break;
-            case SDL_SCANCODE_RALT:
+            case SDLK_RALT:
                keyCode = 0xA5;
                break;
-            case SDL_SCANCODE_AC_BACK:
+            case SDLK_AC_BACK:
                keyCode = 0xA6;
                break;
-            case SDL_SCANCODE_AC_FORWARD:
+            case SDLK_AC_FORWARD:
                keyCode = 0xA7;
                break;
-            case SDL_SCANCODE_AC_REFRESH:
+            case SDLK_AC_REFRESH:
                keyCode = 0xA8;
                break;
-            case SDL_SCANCODE_AC_STOP:
+            case SDLK_AC_STOP:
                keyCode = 0xA9;
                break;
-            case SDL_SCANCODE_AC_SEARCH:
+            case SDLK_AC_SEARCH:
                keyCode = 0xAA;
                break;
-            case SDL_SCANCODE_AC_BOOKMARKS:
+            case SDLK_AC_BOOKMARKS:
                keyCode = 0xAB;
                break;
-            case SDL_SCANCODE_AC_HOME:
+            case SDLK_AC_HOME:
                keyCode = 0xAC;
                break;
-            case SDL_SCANCODE_SEMICOLON:
+            case SDLK_SEMICOLON:
                keyCode = 0xBA;
                break;
-            case SDL_SCANCODE_EQUALS:
+            case SDLK_PLUS:
                keyCode = 0xBB;
                break;
-            case SDL_SCANCODE_COMMA:
+            case SDLK_COMMA:
                keyCode = 0xBC;
                break;
-            case SDL_SCANCODE_MINUS:
+            case SDLK_MINUS:
                keyCode = 0xBD;
                break;
-            case SDL_SCANCODE_PERIOD:
+            case SDLK_PERIOD:
                keyCode = 0xBE;
                break;
-            case SDL_SCANCODE_SLASH:
+            case SDLK_SLASH:
                keyCode = 0xBF;
                break;
-            case SDL_SCANCODE_GRAVE:
+            case SDLK_BACKQUOTE:
                keyCode = 0xC0;
                break;
-            case SDL_SCANCODE_LEFTBRACKET:
+            case SDLK_LEFTBRACKET:
                keyCode = 0xDB;
                break;
-            case SDL_SCANCODE_BACKSLASH:
+            case SDLK_BACKSLASH:
                keyCode = 0xDC;
                break;
-            case SDL_SCANCODE_RIGHTBRACKET:
+            case SDLK_RIGHTBRACKET:
                keyCode = 0xDD;
                break;
-            case SDL_SCANCODE_APOSTROPHE:
+            case SDLK_QUOTE:
                keyCode = 0xDE;
                break;
-            case SDL_SCANCODE_NONUSBACKSLASH:
-                keyCode = 0xE2;
-                break;
            default:
                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                            "Unhandled button event: %d",
-                             event->keysym.scancode);
+                             event->keysym.sym);
                return;
        }
    }

-    // Track the key state so we always know which keys are down
-    if (event->state == SDL_PRESSED) {
-        m_KeysDown.insert(keyCode);
-    }
-    else {
-        m_KeysDown.remove(keyCode);
-    }
-
    LiSendKeyboardEvent(keyCode,
                        event->state == SDL_PRESSED ?
                            KEY_ACTION_DOWN : KEY_ACTION_UP,
@@ -398,13 +318,9 @@ void SdlInputHandler::handleMouseButtonEvent(SDL_MouseButtonEvent* event)
 {
    int button;

-    // Capture the mouse again if clicked when unbound.
-    // We start capture on left button released instead of
-    // pressed to avoid sending an errant mouse button released
-    // event to the host when clicking into our window (since
-    // the pressed event was consumed by this code).
+    // Capture the mouse again if clicked when unbound
    if (event->button == SDL_BUTTON_LEFT &&
-            event->state == SDL_RELEASED &&
+            event->state == SDL_PRESSED &&
            !SDL_GetRelativeMouseMode()) {
        SDL_SetRelativeMouseMode(SDL_TRUE);
        return;
@@ -413,10 +329,6 @@ void SdlInputHandler::handleMouseButtonEvent(SDL_MouseButtonEvent* event)
        // Not capturing
        return;
    }
-    else if (event->which == SDL_TOUCH_MOUSEID) {
-        // Ignore synthetic mouse events
-        return;
-    }

    switch (event->button)
    {
@@ -430,11 +342,9 @@ void SdlInputHandler::handleMouseButtonEvent(SDL_MouseButtonEvent* event)
            button = BUTTON_RIGHT;
            break;
        case SDL_BUTTON_X1:
-            button = BUTTON_X1;
-            break;
        case SDL_BUTTON_X2:
-            button = BUTTON_X2;
-            break;
+            // Unsupported by GameStream
+            return;
        default:
            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
                        "Unhandled button event: %d",
@@ -454,44 +364,10 @@ void SdlInputHandler::handleMouseMotionEvent(SDL_MouseMotionEvent* event)
        // Not capturing
        return;
    }
-    else if (event->which == SDL_TOUCH_MOUSEID) {
-        // Ignore synthetic mouse events
-        return;
-    }

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

@@ -501,10 +377,6 @@ void SdlInputHandler::handleMouseWheelEvent(SDL_MouseWheelEvent* event)
        // Not capturing
        return;
    }
-    else if (event->which == SDL_TOUCH_MOUSEID) {
-        // Ignore synthetic mouse events
-        return;
-    }

    if (event->y != 0) {
        LiSendScrollEvent((signed char)event->y);
@@ -542,36 +414,6 @@ void SdlInputHandler::sendGamepadState(GamepadState* state)
                               state->rsY);
 }

-Uint32 SdlInputHandler::releaseLeftButtonTimerCallback(Uint32, void*)
-{
-    LiSendMouseButtonEvent(BUTTON_ACTION_RELEASE, BUTTON_LEFT);
-    return 0;
-}
-
-Uint32 SdlInputHandler::releaseRightButtonTimerCallback(Uint32, void*)
-{
-    LiSendMouseButtonEvent(BUTTON_ACTION_RELEASE, BUTTON_RIGHT);
-    return 0;
-}
-
-Uint32 SdlInputHandler::dragTimerCallback(Uint32, void *param)
-{
-    auto me = reinterpret_cast<SdlInputHandler*>(param);
-
-    // Check how many fingers are down now to decide
-    // which button to hold down
-    if (me->m_NumFingersDown == 2) {
-        me->m_DragButton = BUTTON_RIGHT;
-    }
-    else if (me->m_NumFingersDown == 1) {
-        me->m_DragButton = BUTTON_LEFT;
-    }
-
-    LiSendMouseButtonEvent(BUTTON_ACTION_PRESS, me->m_DragButton);
-
-    return 0;
-}
-
 void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
 {
    GamepadState* state = findStateForGamepad(event->which);
@@ -585,18 +427,13 @@ void SdlInputHandler::handleControllerAxisEvent(SDL_ControllerAxisEvent* event)
            state->lsX = event->value;
            break;
        case SDL_CONTROLLER_AXIS_LEFTY:
-            // Signed values have one more negative value than
-            // positive value, so inverting the sign on -32768
-            // could actually cause the value to overflow and
-            // wrap around to be negative again. Avoid that by
-            // capping the value at 32767.
-            state->lsY = -qMax(event->value, (short)-32767);
+            state->lsY = -event->value;
            break;
        case SDL_CONTROLLER_AXIS_RIGHTX:
            state->rsX = event->value;
            break;
        case SDL_CONTROLLER_AXIS_RIGHTY:
-            state->rsY = -qMax(event->value, (short)-32767);
+            state->rsY = -event->value;
            break;
        case SDL_CONTROLLER_AXIS_TRIGGERLEFT:
            state->lt = (unsigned char)(event->value * 255UL / 32767);
@@ -628,23 +465,6 @@ void SdlInputHandler::handleControllerButtonEvent(SDL_ControllerButtonEvent* eve
        state->buttons &= ~k_ButtonMap[event->button];
    }

-    // Handle Start+Select+L1+R1 as a gamepad quit combo
-    if (state->buttons == (PLAY_FLAG | BACK_FLAG | LB_FLAG | RB_FLAG)) {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Detected quit gamepad button combo");
-
-        // Push a quit event to the main loop
-        SDL_Event event;
-        event.type = SDL_QUIT;
-        event.quit.timestamp = SDL_GetTicks();
-        SDL_PushEvent(&event);
-
-        // Clear buttons down on this gameapd
-        LiSendMultiControllerEvent(state->index, m_GamepadMask,
-                                   0, 0, 0, 0, 0, 0, 0);
-        return;
-    }
-
    sendGamepadState(state);
 }

@@ -734,172 +554,9 @@ void SdlInputHandler::handleControllerDeviceEvent(SDL_ControllerDeviceEvent* eve
    }
 }

-void SdlInputHandler::handleJoystickArrivalEvent(SDL_JoyDeviceEvent* event)
-{
-    SDL_assert(event->type == SDL_JOYDEVICEADDED);
-
-    if (!SDL_IsGameController(event->which)) {
-        char guidStr[33];
-        SDL_JoystickGetGUIDString(SDL_JoystickGetDeviceGUID(event->which),
-                                  guidStr, sizeof(guidStr));
-        const char* name = SDL_JoystickNameForIndex(event->which);
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "Joystick discovered with no mapping: %s %s",
-                    name ? name : "<UNKNOWN>",
-                    guidStr);
-        SDL_Joystick* joy = SDL_JoystickOpen(event->which);
-        if (joy != nullptr) {
-            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                        "Number of axes: %d | Number of buttons: %d | Number of hats: %d",
-                        SDL_JoystickNumAxes(joy), SDL_JoystickNumButtons(joy),
-                        SDL_JoystickNumHats(joy));
-            SDL_JoystickClose(joy);
-        }
-        else {
-            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                        "Unable to open joystick for query: %s",
-                        SDL_GetError());
-        }
-    }
-}
-
-void SdlInputHandler::handleTouchFingerEvent(SDL_TouchFingerEvent* event)
-{
-    int fingerIndex = -1;
-
-    // Observations on Windows 10: x and y appear to be relative to 0,0 of the window client area.
-    // Although SDL documentation states they are 0.0 - 1.0 float values, they can actually be higher
-    // or lower than those values as touch events continue for touches started within the client area that
-    // leave the client area during a drag motion.
-    // dx and dy are deltas from the last touch event, not the first touch down.
-
-    // Determine the index of this finger using our list
-    // of fingers that are currently active on screen.
-    // This is also required to handle finger up which
-    // where the finger will not be in SDL_GetTouchFinger()
-    // anymore.
-    if (event->type != SDL_FINGERDOWN) {
-        for (int i = 0; i < MAX_FINGERS; i++) {
-            if (event->fingerId == m_TouchDownEvent[i].fingerId) {
-                fingerIndex = i;
-                break;
-            }
-        }
-    }
-    else {
-        // Resolve the new finger by determining the ID of each
-        // finger on the display.
-        int numTouchFingers = SDL_GetNumTouchFingers(event->touchId);
-        for (int i = 0; i < numTouchFingers; i++) {
-            SDL_Finger* finger = SDL_GetTouchFinger(event->touchId, i);
-            SDL_assert(finger != nullptr);
-            if (finger != nullptr) {
-                if (finger->id == event->fingerId) {
-                    fingerIndex = i;
-                    break;
-                }
-            }
-        }
-    }
-
-    if (fingerIndex < 0 || fingerIndex >= MAX_FINGERS) {
-        // Too many fingers
-        return;
-    }
-
-    // Handle cursor motion based on the position of the
-    // primary finger on screen
-    if (fingerIndex == 0) {
-        // The event x and y values are relative to our window width
-        // and height. However, we want to scale them to be relative
-        // to the host resolution. Fortunately this is easy since we
-        // already have normalized values. We'll just multiply them
-        // by the stream dimensions to get real X and Y values rather
-        // than the client window dimensions.
-        short deltaX = static_cast<short>(event->dx * m_StreamWidth);
-        short deltaY = static_cast<short>(event->dy * m_StreamHeight);
-        if (deltaX != 0 || deltaY != 0) {
-            LiSendMouseMoveEvent(deltaX, deltaY);
-        }
-    }
-
-    // Start a drag timer when primary or secondary
-    // fingers go down
-    if (event->type == SDL_FINGERDOWN &&
-            (fingerIndex == 0 || fingerIndex == 1)) {
-        SDL_RemoveTimer(m_DragTimer);
-        m_DragTimer = SDL_AddTimer(DRAG_ACTIVATION_DELAY,
-                                   dragTimerCallback,
-                                   this);
-    }
-
-    if (event->type == SDL_FINGERMOTION) {
-        // Count the total cumulative dx/dy that the finger
-        // has moved.
-        m_CumulativeDelta[fingerIndex] += qAbs(event->x);
-        m_CumulativeDelta[fingerIndex] += qAbs(event->y);
-
-        // If it's outside the deadzone delta, cancel drags and taps
-        if (m_CumulativeDelta[fingerIndex] > DEAD_ZONE_DELTA) {
-            SDL_RemoveTimer(m_DragTimer);
-            m_DragTimer = 0;
-
-            // This effectively cancels the tap logic below
-            m_TouchDownEvent[fingerIndex].timestamp = 0;
-        }
-    }
-
-    if (event->type == SDL_FINGERUP) {
-        // Cancel the drag timer on finger up
-        SDL_RemoveTimer(m_DragTimer);
-        m_DragTimer = 0;
-
-        // Release any drag
-        if (m_DragButton != 0) {
-            LiSendMouseButtonEvent(BUTTON_ACTION_RELEASE, m_DragButton);
-            m_DragButton = 0;
-        }
-        // 2 finger tap
-        else if (event->timestamp - m_TouchDownEvent[1].timestamp < 250) {
-            // Zero timestamp of the primary finger to ensure we won't
-            // generate a left click if the primary finger comes up soon.
-            m_TouchDownEvent[0].timestamp = 0;
-
-            // Press down the right mouse button
-            LiSendMouseButtonEvent(BUTTON_ACTION_PRESS, BUTTON_RIGHT);
-
-            // Queue a timer to release it in 100 ms
-            SDL_RemoveTimer(m_RightButtonReleaseTimer);
-            m_RightButtonReleaseTimer = SDL_AddTimer(TAP_BUTTON_RELEASE_DELAY,
-                                                     releaseRightButtonTimerCallback,
-                                                     nullptr);
-        }
-        // 1 finger tap
-        else if (event->timestamp - m_TouchDownEvent[0].timestamp < 250) {
-            // Press down the left mouse button
-            LiSendMouseButtonEvent(BUTTON_ACTION_PRESS, BUTTON_LEFT);
-
-            // Queue a timer to release it in 100 ms
-            SDL_RemoveTimer(m_LeftButtonReleaseTimer);
-            m_LeftButtonReleaseTimer = SDL_AddTimer(TAP_BUTTON_RELEASE_DELAY,
-                                                    releaseLeftButtonTimerCallback,
-                                                    nullptr);
-        }
-    }
-
-    m_NumFingersDown = SDL_GetNumTouchFingers(event->touchId);
-
-    if (event->type == SDL_FINGERDOWN) {      
-        m_TouchDownEvent[fingerIndex] = *event;
-        m_CumulativeDelta[fingerIndex] = 0;
-    }
-    else if (event->type == SDL_FINGERUP) {
-        m_TouchDownEvent[fingerIndex] = {};
-    }
-}
-
 int SdlInputHandler::getAttachedGamepadMask()
 {
+    int i;
    int count;
    int mask;

@@ -909,7 +566,7 @@ int SdlInputHandler::getAttachedGamepadMask()
    }

    count = mask = 0;
-    for (int i = 0; i < SDL_NumJoysticks(); i++) {
+    for (i = 0; i < SDL_NumJoysticks(); i++) {
        if (SDL_IsGameController(i)) {
            mask |= (1 << count++);
        }
@@ -917,78 +574,3 @@ int SdlInputHandler::getAttachedGamepadMask()

    return mask;
 }
-
-void SdlInputHandler::raiseAllKeys()
-{
-    if (m_KeysDown.isEmpty()) {
-        return;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Raising %d keys",
-                m_KeysDown.count());
-
-    for (auto keyDown : m_KeysDown) {
-        LiSendKeyboardEvent(keyDown, KEY_ACTION_UP, 0);
-    }
-
-    m_KeysDown.clear();
-}
-
-QString SdlInputHandler::getUnmappedGamepads()
-{
-    QString ret;
-
-    if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) failed: %s",
-                     SDL_GetError());
-    }
-
-    MappingManager mappingManager;
-    mappingManager.applyMappings();
-
-    for (int i = 0; i < SDL_NumJoysticks(); i++) {
-        if (!SDL_IsGameController(i)) {
-            char guidStr[33];
-            SDL_JoystickGetGUIDString(SDL_JoystickGetDeviceGUID(i),
-                                      guidStr, sizeof(guidStr));
-            const char* name = SDL_JoystickNameForIndex(i);
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Unmapped joystick: %s %s",
-                        name ? name : "<UNKNOWN>",
-                        guidStr);
-            SDL_Joystick* joy = SDL_JoystickOpen(i);
-            if (joy != nullptr) {
-                int numButtons = SDL_JoystickNumButtons(joy);
-                int numHats = SDL_JoystickNumHats(joy);
-                int numAxes = SDL_JoystickNumAxes(joy);
-
-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "Number of axes: %d | Number of buttons: %d | Number of hats: %d",
-                            numAxes, numButtons, numHats);
-
-                if (numAxes >= 4 && numButtons >= 8 && numHats <= 1) {
-                    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                                "Joystick likely to be an unmapped game controller");
-                    if (!ret.isEmpty()) {
-                        ret += ", ";
-                    }
-
-                    ret += name;
-                }
-
-                SDL_JoystickClose(joy);
-            }
-            else {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                            "Unable to open joystick for query: %s",
-                            SDL_GetError());
-            }
-        }
-    }
-
-    SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
-
-    return ret;
-}
@@ -1,88 +0,0 @@
-#pragma once
-
-#include "settings/streamingpreferences.h"
-#include "backend/computermanager.h"
-
-#include <SDL.h>
-
-struct GamepadState {
-    SDL_GameController* controller;
-    SDL_JoystickID jsId;
-    short index;
-
-    short buttons;
-    short lsX, lsY;
-    short rsX, rsY;
-    unsigned char lt, rt;
-};
-
-#define MAX_GAMEPADS 4
-#define MAX_FINGERS 2
-
-class SdlInputHandler
-{
-public:
-    explicit SdlInputHandler(StreamingPreferences& prefs, NvComputer* computer,
-                             int streamWidth, int streamHeight);
-
-    ~SdlInputHandler();
-
-    void handleKeyEvent(SDL_KeyboardEvent* event);
-
-    void handleMouseButtonEvent(SDL_MouseButtonEvent* event);
-
-    void handleMouseMotionEvent(SDL_MouseMotionEvent* event);
-
-    void handleMouseWheelEvent(SDL_MouseWheelEvent* event);
-
-    void handleControllerAxisEvent(SDL_ControllerAxisEvent* event);
-
-    void handleControllerButtonEvent(SDL_ControllerButtonEvent* event);
-
-    void handleControllerDeviceEvent(SDL_ControllerDeviceEvent* event);
-
-    void handleJoystickArrivalEvent(SDL_JoyDeviceEvent* event);
-
-    void handleTouchFingerEvent(SDL_TouchFingerEvent* event);
-
-    int getAttachedGamepadMask();
-
-    void raiseAllKeys();
-
-    static
-    QString getUnmappedGamepads();
-
-private:
-    GamepadState*
-    findStateForGamepad(SDL_JoystickID id);
-
-    void sendGamepadState(GamepadState* state);
-
-    static
-    Uint32 releaseLeftButtonTimerCallback(Uint32 interval, void* param);
-
-    static
-    Uint32 releaseRightButtonTimerCallback(Uint32 interval, void* param);
-
-    static
-    Uint32 dragTimerCallback(Uint32 interval, void* param);
-
-    Uint32 m_LastMouseMotionTime;
-    bool m_MultiController;
-    bool m_NeedsInputDelay;
-    int m_GamepadMask;
-    GamepadState m_GamepadState[MAX_GAMEPADS];
-    QSet<short> m_KeysDown;
-
-    SDL_TouchFingerEvent m_TouchDownEvent[MAX_FINGERS];
-    float m_CumulativeDelta[MAX_FINGERS];
-    SDL_TimerID m_LeftButtonReleaseTimer;
-    SDL_TimerID m_RightButtonReleaseTimer;
-    SDL_TimerID m_DragTimer;
-    char m_DragButton;
-    int m_NumFingersDown;
-    int m_StreamWidth;
-    int m_StreamHeight;
-
-    static const int k_ButtonMap[];
-};
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <SDL.h>
+
+struct GamepadState {
+    SDL_GameController* controller;
+    SDL_JoystickID jsId;
+    short index;
+
+    short buttons;
+    short lsX, lsY;
+    short rsX, rsY;
+    unsigned char lt, rt;
+};
+
+#define MAX_GAMEPADS 4
+
+class SdlInputHandler
+{
+public:
+    explicit SdlInputHandler(bool multiController);
+
+    ~SdlInputHandler();
+
+    void handleKeyEvent(SDL_KeyboardEvent* event);
+
+    void handleMouseButtonEvent(SDL_MouseButtonEvent* event);
+
+    void handleMouseMotionEvent(SDL_MouseMotionEvent* event);
+
+    void handleMouseWheelEvent(SDL_MouseWheelEvent* event);
+
+    void handleControllerAxisEvent(SDL_ControllerAxisEvent* event);
+
+    void handleControllerButtonEvent(SDL_ControllerButtonEvent* event);
+
+    void handleControllerDeviceEvent(SDL_ControllerDeviceEvent* event);
+
+    int getAttachedGamepadMask();
+
+private:
+    GamepadState*
+    findStateForGamepad(SDL_JoystickID id);
+
+    void sendGamepadState(GamepadState* state);
+
+    bool m_MultiController;
+    int m_GamepadMask;
+    GamepadState m_GamepadState[MAX_GAMEPADS];
+
+    static const int k_ButtonMap[];
+};
@@ -6,9 +6,8 @@
 #include <opus_multistream.h>
 #include "backend/computermanager.h"
 #include "settings/streamingpreferences.h"
-#include "input.h"
+#include "input.hpp"
 #include "video/decoder.h"
-#include "audio/renderers/renderer.h"

 class Session : public QObject
 {
@@ -18,17 +17,9 @@ class Session : public QObject
    friend class DeferredSessionCleanupTask;

 public:
-    explicit Session(NvComputer* computer, NvApp& app, StreamingPreferences *preferences = nullptr);
+    explicit Session(NvComputer* computer, NvApp& app);

-    Q_INVOKABLE void exec(int displayOriginX, int displayOriginY);
-
-    static
-    bool isHardwareDecodeAvailable(StreamingPreferences::VideoDecoderSelection vds,
-                                   int videoFormat, int width, int height, int frameRate);
-
-    static
-    int getDecoderCapabilities(StreamingPreferences::VideoDecoderSelection vds,
-                               int videoFormat, int width, int height, int frameRate);
+    Q_INVOKABLE void exec();

 signals:
    void stageStarting(QString stage);
@@ -42,31 +33,20 @@ signals:
    void displayLaunchWarning(QString text);

 private:
-    void initialize();
-
    bool validateLaunch();

-    void emitLaunchWarning(QString text);
-
    int getDecoderCapabilities();

-    IAudioRenderer* createAudioRenderer();
+    int sdlDetermineAudioConfiguration();

-    int detectAudioConfiguration();
-
-    bool testAudio(int audioConfiguration);
-
-    void getWindowDimensions(int& x, int& y,
-                             int& width, int& height);
-
-    void toggleFullscreen();
-
-    void updateOptimalWindowDisplayMode();
+    static
+    bool isHardwareDecodeAvailable(StreamingPreferences::VideoDecoderSelection vds,
+                                   int videoFormat, int width, int height, int frameRate);

    static
    bool chooseDecoder(StreamingPreferences::VideoDecoderSelection vds,
                       SDL_Window* window, int videoFormat, int width, int height,
-                       int frameRate, bool enableVsync, IVideoDecoder*& chosenDecoder);
+                       int frameRate, IVideoDecoder*& chosenDecoder);

    static
    void clStageStarting(int stage);
@@ -80,17 +60,6 @@ private:
    static
    void clLogMessage(const char* format, ...);

-    static
-    int arInit(int audioConfiguration,
-               const POPUS_MULTISTREAM_CONFIGURATION opusConfig,
-               void* arContext, int arFlags);
-
-    static
-    void arCleanup();
-
-    static
-    void arDecodeAndPlaySample(char* sampleData, int sampleLength);
-
    static
    int drSetup(int videoFormat, int width, int height, int frameRate, void*, int);

@@ -100,7 +69,24 @@ private:
    static
    int drSubmitDecodeUnit(PDECODE_UNIT du);

-    StreamingPreferences* m_Preferences;
+    static
+    int sdlAudioInit(int audioConfiguration,
+                     POPUS_MULTISTREAM_CONFIGURATION opusConfig,
+                     void* arContext, int arFlags);
+
+    static
+    void sdlAudioStart();
+
+    static
+    void sdlAudioStop();
+
+    static
+    void sdlAudioCleanup();
+
+    static
+    void sdlAudioDecodeAndPlaySample(char* sampleData, int sampleLength);
+
+    StreamingPreferences m_Preferences;
    STREAM_CONFIGURATION m_StreamConfig;
    DECODER_RENDERER_CALLBACKS m_VideoCallbacks;
    NvComputer* m_Computer;
@@ -108,23 +94,15 @@ private:
    SDL_Window* m_Window;
    IVideoDecoder* m_VideoDecoder;
    SDL_SpinLock m_DecoderLock;
-    bool m_NeedsIdr;
-    bool m_AudioDisabled;
-    Uint32 m_FullScreenFlag;
-    int m_DisplayOriginX;
-    int m_DisplayOriginY;
-    bool m_PendingWindowedTransition;

-    int m_ActiveVideoFormat;
-    int m_ActiveVideoWidth;
-    int m_ActiveVideoHeight;
-    int m_ActiveVideoFrameRate;
-
-    OpusMSDecoder* m_OpusDecoder;
-    short m_OpusDecodeBuffer[MAX_CHANNELS * SAMPLES_PER_FRAME];
-    IAudioRenderer* m_AudioRenderer;
-    OPUS_MULTISTREAM_CONFIGURATION m_AudioConfig;
-    int m_AudioSampleCount;
+    static SDL_AudioDeviceID s_AudioDevice;
+    static OpusMSDecoder* s_OpusDecoder;
+    static short s_OpusDecodeBuffer[];
+    static int s_ChannelCount;
+    static int s_PendingDrops;
+    static int s_PendingHardDrops;
+    static unsigned int s_SampleIndex;
+    static Uint32 s_BaselinePendingData;

    static AUDIO_RENDERER_CALLBACKS k_AudioCallbacks;
    static CONNECTION_LISTENER_CALLBACKS k_ConnCallbacks;
@@ -1,127 +0,0 @@
-#include "streamutils.h"
-
-#include <Qt>
-
-#ifdef Q_OS_DARWIN
-#include <ApplicationServices/ApplicationServices.h>
-#endif
-
-void StreamUtils::scaleSourceToDestinationSurface(SDL_Rect* src, SDL_Rect* dst)
-{
-    int dstH = dst->w * src->h / src->w;
-    int dstW = dst->h * src->w / src->h;
-
-    if (dstH > dst->h) {
-        dst->y = 0;
-        dst->x = (dst->w - dstW) / 2;
-        dst->w = dstW;
-        SDL_assert(dst->w * src->h / src->w <= dst->h);
-    }
-    else {
-        dst->x = 0;
-        dst->y = (dst->h - dstH) / 2;
-        dst->h = dstH;
-        SDL_assert(dst->h * src->w / src->h <= dst->w);
-    }
-}
-
-int StreamUtils::getDisplayRefreshRate(SDL_Window* window)
-{
-    int displayIndex = SDL_GetWindowDisplayIndex(window);
-    if (displayIndex < 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to get current display: %s",
-                     SDL_GetError());
-
-        // Assume display 0 if it fails
-        displayIndex = 0;
-    }
-
-    SDL_DisplayMode mode;
-    if ((SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN) {
-        // Use the window display mode for full-screen exclusive mode
-        if (SDL_GetWindowDisplayMode(window, &mode) != 0) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "SDL_GetWindowDisplayMode() failed: %s",
-                         SDL_GetError());
-
-            // Assume 60 Hz
-            return 60;
-        }
-    }
-    else {
-        // Use the current display mode for windowed and borderless
-        if (SDL_GetCurrentDisplayMode(displayIndex, &mode) != 0) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "SDL_GetCurrentDisplayMode() failed: %s",
-                         SDL_GetError());
-
-            // Assume 60 Hz
-            return 60;
-        }
-    }
-
-    // May be zero if undefined
-    if (mode.refresh_rate == 0) {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "Refresh rate unknown; assuming 60 Hz");
-        mode.refresh_rate = 60;
-    }
-
-    return mode.refresh_rate;
-}
-
-bool StreamUtils::getRealDesktopMode(int displayIndex, SDL_DisplayMode* mode)
-{
-#ifdef Q_OS_DARWIN
-#define MAX_DISPLAYS 16
-    CGDirectDisplayID displayIds[MAX_DISPLAYS];
-    uint32_t displayCount = 0;
-    CGGetActiveDisplayList(MAX_DISPLAYS, displayIds, &displayCount);
-    if (displayIndex >= displayCount) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Too many displays: %d vs %d",
-                     displayIndex, displayCount);
-        return false;
-    }
-
-    SDL_zerop(mode);
-
-    // Retina displays have non-native resolutions both below and above (!) their
-    // native resolution, so it's impossible for us to figure out what's actually
-    // native on macOS using the SDL API alone. We'll talk to CoreGraphics to
-    // find the correct resolution and match it in our SDL list.
-    CFArrayRef modeList = CGDisplayCopyAllDisplayModes(displayIds[displayIndex], nullptr);
-    CFIndex count = CFArrayGetCount(modeList);
-    for (CFIndex i = 0; i < count; i++) {
-        auto cgMode = (CGDisplayModeRef)(CFArrayGetValueAtIndex(modeList, i));
-        if ((CGDisplayModeGetIOFlags(cgMode) & kDisplayModeNativeFlag) != 0) {
-            mode->w = static_cast<int>(CGDisplayModeGetWidth(cgMode));
-            mode->h = static_cast<int>(CGDisplayModeGetHeight(cgMode));
-            break;
-        }
-    }
-    CFRelease(modeList);
-
-    // Now find the SDL mode that matches the CG native mode
-    for (int i = 0; i < SDL_GetNumDisplayModes(displayIndex); i++) {
-        SDL_DisplayMode thisMode;
-        if (SDL_GetDisplayMode(displayIndex, i, &thisMode) == 0) {
-            if (thisMode.w == mode->w && thisMode.h == mode->h &&
-                    thisMode.refresh_rate >= mode->refresh_rate) {
-                *mode = thisMode;
-                break;
-            }
-        }
-    }
-#else
-    if (SDL_GetDesktopDisplayMode(displayIndex, mode) != 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_GetDesktopDisplayMode() failed: %s",
-                     SDL_GetError());
-        return false;
-    }
-#endif
-
-    return true;
-}
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <SDL.h>
-
-class StreamUtils
-{
-public:
-    static
-    void scaleSourceToDestinationSurface(SDL_Rect* src, SDL_Rect* dst);
-
-    static
-    bool getRealDesktopMode(int displayIndex, SDL_DisplayMode* mode);
-
-    static
-    int getDisplayRefreshRate(SDL_Window* window);
-};
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "decoder.h"
+
+// A factory is required to avoid pulling in
+// incompatible Objective-C headers.
+class AVFoundationDecoderFactory {
+public:
+    static
+    IVideoDecoder* createDecoder();
+};
@@ -0,0 +1,521 @@
+#include "avfoundation.h"
+
+#include <SDL_syswm.h>
+
+#import <Cocoa/Cocoa.h>
+#import <VideoToolbox/VideoToolbox.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreVideo/CoreVideo.h>
+
+#define FRAME_START_PREFIX_SIZE 4
+#define NALU_START_PREFIX_SIZE 3
+#define NAL_LENGTH_PREFIX_SIZE 4
+
+#define FUTURE_FRAMES_IN_VSYNC 3
+
+class AVFoundationDecoder : public IVideoDecoder
+{
+public:
+    AVFoundationDecoder()
+        : m_DisplayLayer(nullptr),
+          m_FormatDesc(nullptr),
+          m_SpsData(nullptr),
+          m_PpsData(nullptr),
+          m_VpsData(nullptr),
+          m_View(nullptr),
+          m_NeedsIdr(false),
+          m_DisplayLink(nullptr),
+          m_VsyncTime(0),
+          m_LastVsyncTime(0),
+          m_VsyncStatsLock(0)
+    {
+        SDL_zero(m_FrameCountOnVsync);
+    }
+
+    virtual ~AVFoundationDecoder()
+    {
+        if (m_FormatDesc != nullptr) {
+            CFRelease(m_FormatDesc);
+        }
+
+        if (m_DisplayLink != nullptr) {
+            CVDisplayLinkStop(m_DisplayLink);
+            CVDisplayLinkRelease(m_DisplayLink);
+        }
+
+        delete m_SpsData;
+        delete m_PpsData;
+        delete m_VpsData;
+    }
+
+    static
+    CVReturn
+    displayLinkOutputCallback(
+        CVDisplayLinkRef,
+        const CVTimeStamp*,
+        const CVTimeStamp* vsyncTime,
+        CVOptionFlags,
+        CVOptionFlags*,
+        void *displayLinkContext)
+    {
+        AVFoundationDecoder* me = reinterpret_cast<AVFoundationDecoder*>(displayLinkContext);
+
+        SDL_AtomicLock(&me->m_VsyncStatsLock);
+        me->m_LastVsyncTime = me->m_VsyncTime;
+        me->m_VsyncTime = vsyncTime->hostTime;
+
+        int framesThisVsync = *(volatile int*)&me->m_FrameCountOnVsync[0];
+
+        memmove(&me->m_FrameCountOnVsync[0],
+                &me->m_FrameCountOnVsync[1],
+                sizeof(me->m_FrameCountOnVsync) - sizeof(me->m_FrameCountOnVsync[0]));
+        me->m_FrameCountOnVsync[FUTURE_FRAMES_IN_VSYNC - 1] = 0;
+        SDL_AtomicUnlock(&me->m_VsyncStatsLock);
+
+        if (framesThisVsync != 1)
+            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
+                        "V-Sync interval frames: %d",
+                        framesThisVsync);
+
+        return kCVReturnSuccess;
+    }
+
+    virtual bool initialize(StreamingPreferences::VideoDecoderSelection vds,
+                            SDL_Window* window,
+                            int videoFormat,
+                            int, int, int) override
+    {
+        m_VideoFormat = videoFormat;
+
+        // Fail if the user wants software decode only
+        if (vds == StreamingPreferences::VDS_FORCE_SOFTWARE) {
+            return false;
+        }
+
+        if (videoFormat & VIDEO_FORMAT_MASK_H264) {
+            // Prior to 10.13, we'll just assume everything has
+            // H.264 support and fail open to allow VT decode.
+    #if __MAC_OS_X_VERSION_MAX_ALLOWED >= 101300
+            if (__builtin_available(macOS 10.13, *)) {
+                if (!VTIsHardwareDecodeSupported(kCMVideoCodecType_H264)) {
+                    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                                "No HW accelerated H.264 decode via VT");
+                    return false;
+                }
+            }
+            else
+    #endif
+            {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "Assuming H.264 HW decode on < macOS 10.13");
+            }
+        }
+        else if (videoFormat & VIDEO_FORMAT_MASK_H265) {
+    #if __MAC_OS_X_VERSION_MAX_ALLOWED >= 101300
+            if (__builtin_available(macOS 10.13, *)) {
+                if (!VTIsHardwareDecodeSupported(kCMVideoCodecType_HEVC)) {
+                    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                                "No HW accelerated HEVC decode via VT");
+                    return false;
+                }
+            }
+            else
+    #endif
+            {
+                // Fail closed for HEVC if we're not on 10.13+
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "No HEVC support on < macOS 10.13");
+                return false;
+            }
+        }
+
+        SDL_SysWMinfo info;
+
+        SDL_VERSION(&info.version);
+
+        if (!SDL_GetWindowWMInfo(window, &info)) {
+            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                        "SDL_GetWindowWMInfo() failed: %s",
+                        SDL_GetError());
+            return false;
+        }
+
+        SDL_assert(info.subsystem == SDL_SYSWM_COCOA);
+
+        // SDL adds its own content view to listen for events.
+        // We need to add a subview for our display layer.
+        NSView* contentView = info.info.cocoa.window.contentView;
+        m_View = [[NSView alloc] initWithFrame:contentView.bounds];
+        m_View.wantsLayer = YES;
+        [contentView addSubview: m_View];
+
+        setupDisplayLayer();
+
+        CVDisplayLinkCreateWithActiveCGDisplays(&m_DisplayLink);
+        CVDisplayLinkSetOutputCallback(m_DisplayLink, displayLinkOutputCallback, (void*)this);
+        CVDisplayLinkStart(m_DisplayLink);
+
+        return true;
+    }
+
+    virtual bool isHardwareAccelerated() override
+    {
+        // We only use AVFoundation for HW acceleration
+        return true;
+    }
+
+    virtual int submitDecodeUnit(PDECODE_UNIT du) override
+    {
+        OSStatus status;
+
+        unsigned char* data = (unsigned char*)malloc(du->fullLength);
+        if (!data) {
+            return DR_NEED_IDR;
+        }
+
+        PLENTRY entry = du->bufferList;
+        int pictureDataLength = 0;
+        while (entry != nullptr) {
+            if (entry->bufferType == BUFFER_TYPE_VPS) {
+                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Got VPS");
+                delete m_VpsData;
+                m_VpsData = new QByteArray(&entry->data[FRAME_START_PREFIX_SIZE], entry->length - FRAME_START_PREFIX_SIZE);
+
+                // We got a new VPS so wait for a new SPS to match it
+                delete m_SpsData;
+                delete m_PpsData;
+                m_SpsData = m_PpsData = nullptr;
+            }
+            else if (entry->bufferType == BUFFER_TYPE_SPS) {
+                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Got SPS");
+                delete m_SpsData;
+                m_SpsData = new QByteArray(&entry->data[FRAME_START_PREFIX_SIZE], entry->length - FRAME_START_PREFIX_SIZE);
+
+                // We got a new SPS so wait for a new PPS to match it
+                delete m_PpsData;
+                m_PpsData = nullptr;
+            }
+            else if (entry->bufferType == BUFFER_TYPE_PPS) {
+                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Got PPS");
+                delete m_PpsData;
+                m_PpsData = new QByteArray(&entry->data[FRAME_START_PREFIX_SIZE], entry->length - FRAME_START_PREFIX_SIZE);
+            }
+            else {
+                // Picture data
+                SDL_assert(entry->bufferType == BUFFER_TYPE_PICDATA);
+                memcpy(&data[pictureDataLength],
+                       entry->data,
+                       entry->length);
+                pictureDataLength += entry->length;
+            }
+
+            entry = entry->next;
+        }
+
+        SDL_assert(pictureDataLength <= du->fullLength);
+
+        if (du->frameType == FRAME_TYPE_IDR) {
+            m_NeedsIdr = false;
+
+            if (m_FormatDesc != nullptr) {
+                CFRelease(m_FormatDesc);
+            }
+
+            if (m_VideoFormat & VIDEO_FORMAT_MASK_H264) {
+                const uint8_t* const parameterSetPointers[] = { (uint8_t*)m_SpsData->data(),
+                                                                (uint8_t*)m_PpsData->data() };
+                const size_t parameterSetSizes[] = { (size_t)m_SpsData->length(),
+                                                     (size_t)m_PpsData->length() };
+
+                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Constructing new H264 format description");
+                status = CMVideoFormatDescriptionCreateFromH264ParameterSets(kCFAllocatorDefault,
+                                                                             2, /* count of parameter sets */
+                                                                             parameterSetPointers,
+                                                                             parameterSetSizes,
+                                                                             NAL_LENGTH_PREFIX_SIZE,
+                                                                             &m_FormatDesc);
+                if (status != noErr) {
+                    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                                 "Failed to create H264 format description: %d",
+                                 (int)status);
+                    m_FormatDesc = NULL;
+                }
+            }
+            else {
+#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 101300
+                const uint8_t* const parameterSetPointers[] = { (uint8_t*)m_VpsData->data(),
+                                                                (uint8_t*)m_SpsData->data(),
+                                                                (uint8_t*)m_PpsData->data() };
+                const size_t parameterSetSizes[] = { (size_t)m_VpsData->length(),
+                                                     (size_t)m_SpsData->length(),
+                                                     (size_t)m_PpsData->length() };
+
+                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Constructing new HEVC format description");
+
+                if (__builtin_available(macOS 10.13, *)) {
+                    status = CMVideoFormatDescriptionCreateFromHEVCParameterSets(kCFAllocatorDefault,
+                                                                                 3, /* count of parameter sets */
+                                                                                 parameterSetPointers,
+                                                                                 parameterSetSizes,
+                                                                                 NAL_LENGTH_PREFIX_SIZE,
+                                                                                 nil,
+                                                                                 &m_FormatDesc);
+                    if (status != noErr) {
+                        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                                     "Failed to create HEVC format description: %d",
+                                     (int)status);
+                        m_FormatDesc = NULL;
+                    }
+                }
+                else
+#endif
+                {
+                    // This means Moonlight-common-c decided to give us an HEVC stream
+                    // even though we said we couldn't support it. All we can do is abort().
+                    abort();
+                }
+            }
+        }
+
+        if (m_FormatDesc == nullptr || m_NeedsIdr) {
+            // Can't decode if we haven't gotten our parameter sets yet
+            free(data);
+            return DR_NEED_IDR;
+        }
+
+        // Now we're decoding actual frame data here
+        CMBlockBufferRef blockBuffer;
+
+        status = CMBlockBufferCreateEmpty(NULL, 0, 0, &blockBuffer);
+        if (status != noErr) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                         "CMBlockBufferCreateEmpty failed: %d",
+                         (int)status);
+            free(data);
+            return DR_NEED_IDR;
+        }
+
+        int lastOffset = -1;
+        for (int i = 0; i < pictureDataLength - FRAME_START_PREFIX_SIZE; i++) {
+            // Search for a NALU
+            if (data[i] == 0 && data[i+1] == 0 && data[i+2] == 1) {
+                // It's the start of a new NALU
+                if (lastOffset != -1) {
+                    // We've seen a start before this so enqueue that NALU
+                    updateBufferForRange(blockBuffer, data, lastOffset, i - lastOffset);
+                }
+
+                lastOffset = i;
+            }
+        }
+
+        if (lastOffset != -1) {
+            // Enqueue the remaining data
+            updateBufferForRange(blockBuffer, data, lastOffset, pictureDataLength - lastOffset);
+        }
+
+        // From now on, CMBlockBuffer owns the data pointer and will free it when it's released
+
+        CMSampleBufferRef sampleBuffer;
+
+        CMSampleTimingInfo time = {
+            .decodeTimeStamp = kCMTimeInvalid,
+            .duration = kCMTimeInvalid
+        };
+
+        SDL_AtomicLock(&m_VsyncStatsLock);
+        // Find a slot to put this frame
+        for (int i = 0; i < FUTURE_FRAMES_IN_VSYNC; i++) {
+            if (m_FrameCountOnVsync[i] == 0) {
+                time.presentationTimeStamp =
+                        CMTimeMake(m_VsyncTime + (i + 1) * (m_VsyncTime - m_LastVsyncTime),
+                                   1000 * 1000 * 1000);
+                m_FrameCountOnVsync[i]++;
+            }
+        }
+        SDL_AtomicUnlock(&m_VsyncStatsLock);
+
+        status = CMSampleBufferCreate(kCFAllocatorDefault,
+                                      blockBuffer,
+                                      true, NULL,
+                                      NULL, m_FormatDesc, 1, 1,
+                                      &time, 0, NULL,
+                                      &sampleBuffer);
+        if (status != noErr) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                         "CMSampleBufferCreate failed: %d",
+                         (int)status);
+            CFRelease(blockBuffer);
+            return DR_NEED_IDR;
+        }
+
+        // Submit for callback on the main thread
+        queueFrame(sampleBuffer, (void*)(long)du->frameType);
+
+        return DR_OK;
+    }
+
+    // This is called on the main thread, so it's safe to interact with
+    // the AVSampleBufferDisplayLayer here.
+    void submitBuffer(CMSampleBufferRef sampleBuffer, int frameType)
+    {
+        if (m_DisplayLayer.status == AVQueuedSampleBufferRenderingStatusFailed) {
+            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                        "Resetting failed AVSampleBufferDisplay layer");
+            setupDisplayLayer();
+            CFRelease(sampleBuffer);
+            return;
+        }
+
+        CFArrayRef attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, YES);
+        CFMutableDictionaryRef dict = (CFMutableDictionaryRef)CFArrayGetValueAtIndex(attachments, 0);
+
+        CFDictionarySetValue(dict, kCMSampleAttachmentKey_IsDependedOnByOthers, kCFBooleanTrue);
+
+        if (frameType == FRAME_TYPE_PFRAME) {
+            // P-frame
+            CFDictionarySetValue(dict, kCMSampleAttachmentKey_NotSync, kCFBooleanTrue);
+            CFDictionarySetValue(dict, kCMSampleAttachmentKey_DependsOnOthers, kCFBooleanTrue);
+        } else {
+            // I-frame
+            CFDictionarySetValue(dict, kCMSampleAttachmentKey_NotSync, kCFBooleanFalse);
+            CFDictionarySetValue(dict, kCMSampleAttachmentKey_DependsOnOthers, kCFBooleanFalse);
+        }
+
+        [m_DisplayLayer enqueueSampleBuffer:sampleBuffer];
+
+        CFRelease(sampleBuffer);
+    }
+
+    virtual void renderFrame(SDL_UserEvent* event) override
+    {
+        submitBuffer((CMSampleBufferRef)event->data1, (int)(long)event->data2);
+    }
+
+    virtual void dropFrame(SDL_UserEvent* event) override
+    {
+        // Submit anyway and let the drop happen in the render pipeline
+        submitBuffer((CMSampleBufferRef)event->data1, (int)(long)event->data2);
+    }
+
+private:
+    void setupDisplayLayer()
+    {
+        CALayer* oldLayer = m_DisplayLayer;
+
+        m_DisplayLayer = [[AVSampleBufferDisplayLayer alloc] init];
+        m_DisplayLayer.bounds = m_View.bounds;
+        m_DisplayLayer.position = CGPointMake(CGRectGetMidX(m_View.bounds), CGRectGetMidY(m_View.bounds));
+        m_DisplayLayer.videoGravity = AVLayerVideoGravityResizeAspect;
+
+        CALayer* viewLayer = m_View.layer;
+        if (oldLayer != nil) {
+            [viewLayer replaceSublayer:oldLayer with:m_DisplayLayer];
+        }
+        else {
+            [viewLayer addSublayer:m_DisplayLayer];
+        }
+
+        // Wait for another IDR frame
+        m_NeedsIdr = true;
+
+        delete m_SpsData;
+        delete m_PpsData;
+        delete m_VpsData;
+
+        m_SpsData = m_PpsData = m_VpsData = nullptr;
+    }
+
+    void updateBufferForRange(CMBlockBufferRef existingBuffer, unsigned char* data, int offset, int nalLength)
+    {
+        OSStatus status;
+        size_t oldOffset = CMBlockBufferGetDataLength(existingBuffer);
+
+        // If we're at index 1 (first NALU in frame), enqueue this buffer to the memory block
+        // so it can handle freeing it when the block buffer is destroyed
+        if (offset == 1) {
+            int dataLength = nalLength - NALU_START_PREFIX_SIZE;
+
+            // Pass the real buffer pointer directly (no offset)
+            // This will give it to the block buffer to free when it's released.
+            // All further calls to CMBlockBufferAppendMemoryBlock will do so
+            // at an offset and will not be asking the buffer to be freed.
+            status = CMBlockBufferAppendMemoryBlock(existingBuffer, data,
+                                                    nalLength + 1, // Add 1 for the offset we decremented
+                                                    kCFAllocatorDefault,
+                                                    NULL, 0, nalLength + 1, 0);
+            if (status != noErr) {
+                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                             "CMBlockBufferReplaceDataBytes failed: %d",
+                             (int)status);
+                return;
+            }
+
+            // Write the length prefix to existing buffer
+            const uint8_t lengthBytes[] = {(uint8_t)(dataLength >> 24), (uint8_t)(dataLength >> 16),
+                (uint8_t)(dataLength >> 8), (uint8_t)dataLength};
+            status = CMBlockBufferReplaceDataBytes(lengthBytes, existingBuffer,
+                                                   oldOffset, NAL_LENGTH_PREFIX_SIZE);
+            if (status != noErr) {
+                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                             "CMBlockBufferReplaceDataBytes failed: %d",
+                             (int)status);
+                return;
+            }
+        } else {
+            // Append a 4 byte buffer to this block for the length prefix
+            status = CMBlockBufferAppendMemoryBlock(existingBuffer, NULL,
+                                                    NAL_LENGTH_PREFIX_SIZE,
+                                                    kCFAllocatorDefault, NULL, 0,
+                                                    NAL_LENGTH_PREFIX_SIZE, 0);
+            if (status != noErr) {
+                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                             "CMBlockBufferAppendMemoryBlock failed: %d",
+                             (int)status);
+                return;
+            }
+
+            // Write the length prefix to the new buffer
+            int dataLength = nalLength - NALU_START_PREFIX_SIZE;
+            const uint8_t lengthBytes[] = {(uint8_t)(dataLength >> 24), (uint8_t)(dataLength >> 16),
+                (uint8_t)(dataLength >> 8), (uint8_t)dataLength};
+            status = CMBlockBufferReplaceDataBytes(lengthBytes, existingBuffer,
+                                                   oldOffset, NAL_LENGTH_PREFIX_SIZE);
+            if (status != noErr) {
+                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                             "CMBlockBufferReplaceDataBytes failed: %d",
+                             (int)status);
+                return;
+            }
+
+            // Attach the buffer by reference to the block buffer
+            status = CMBlockBufferAppendMemoryBlock(existingBuffer, &data[offset+NALU_START_PREFIX_SIZE],
+                                                    dataLength,
+                                                    kCFAllocatorNull, // Don't deallocate data on free
+                                                    NULL, 0, dataLength, 0);
+            if (status != noErr) {
+                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                             "CMBlockBufferReplaceDataBytes failed: %d",
+                             (int)status);
+                return;
+            }
+        }
+    }
+
+    AVSampleBufferDisplayLayer* m_DisplayLayer;
+    CMVideoFormatDescriptionRef m_FormatDesc;
+    int m_VideoFormat;
+    QByteArray* m_SpsData;
+    QByteArray* m_PpsData;
+    QByteArray* m_VpsData;
+    NSView* m_View;
+    bool m_NeedsIdr;
+    CVDisplayLinkRef m_DisplayLink;
+    uint64_t m_VsyncTime, m_LastVsyncTime;
+    int m_FrameCountOnVsync[FUTURE_FRAMES_IN_VSYNC];
+    SDL_SpinLock m_VsyncStatsLock;
+};
+
+IVideoDecoder* AVFoundationDecoderFactory::createDecoder() {
+    return new AVFoundationDecoder();
+}
@@ -8,21 +8,6 @@

 #define MAX_SLICES 4

-typedef struct _VIDEO_STATS {
-    uint32_t receivedFrames;
-    uint32_t decodedFrames;
-    uint32_t renderedFrames;
-    uint32_t networkDroppedFrames;
-    uint32_t pacerDroppedFrames;
-    uint32_t totalReassemblyTime;
-    uint32_t totalDecodeTime;
-    uint32_t totalRenderTime;
-    float receivedFps;
-    float decodedFps;
-    float renderedFps;
-    uint32_t measurementStartTimestamp;
-} VIDEO_STATS, *PVIDEO_STATS;
-
 class IVideoDecoder {
 public:
    virtual ~IVideoDecoder() {}
@@ -31,10 +16,8 @@ public:
                            int videoFormat,
                            int width,
                            int height,
-                            int frameRate,
-                            bool enableVsync) = 0;
+                            int frameRate) = 0;
    virtual bool isHardwareAccelerated() = 0;
-    virtual int getDecoderCapabilities() = 0;
    virtual int submitDecodeUnit(PDECODE_UNIT du) = 0;
    virtual void renderFrame(SDL_UserEvent* event) = 0;
    virtual void dropFrame(SDL_UserEvent* event) = 0;
@@ -1,14 +1,5 @@
-#include <initguid.h>
+#include <Initguid.h>
 #include "dxva2.h"
-#include "../ffmpeg.h"
-#include <streaming/streamutils.h>
-
-#include <SDL_syswm.h>
-
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
-#include <VersionHelpers.h>
-#include <dwmapi.h>

 #include <Limelight.h>

@@ -17,27 +8,23 @@ DEFINE_GUID(DXVADDI_Intel_ModeH264_E, 0x604F8E68,0x4951,0x4C54,0x88,0xFE,0xAB,0x
 #define SAFE_COM_RELEASE(x) if (x) { (x)->Release(); }

 DXVA2Renderer::DXVA2Renderer() :
+    m_FrameIndex(0),
+    m_SurfacesUsed(0),
+    m_SdlRenderer(nullptr),
    m_DecService(nullptr),
    m_Decoder(nullptr),
-    m_SurfacesUsed(0),
    m_Pool(nullptr),
    m_Device(nullptr),
    m_RenderTarget(nullptr),
    m_ProcService(nullptr),
-    m_Processor(nullptr),
-    m_FrameIndex(0)
+    m_Processor(nullptr)
 {
    RtlZeroMemory(m_DecSurfaces, sizeof(m_DecSurfaces));
    RtlZeroMemory(&m_DXVAContext, sizeof(m_DXVAContext));
-
-    // Use MMCSS scheduling for lower scheduling latency while we're streaming
-    DwmEnableMMCSS(TRUE);
 }

 DXVA2Renderer::~DXVA2Renderer()
 {
-    DwmEnableMMCSS(FALSE);
-
    SAFE_COM_RELEASE(m_DecService);
    SAFE_COM_RELEASE(m_Decoder);
    SAFE_COM_RELEASE(m_Device);
@@ -52,6 +39,10 @@ DXVA2Renderer::~DXVA2Renderer()
    if (m_Pool != nullptr) {
        av_buffer_pool_uninit(&m_Pool);
    }
+
+    if (m_SdlRenderer != nullptr) {
+        SDL_DestroyRenderer(m_SdlRenderer);
+    }
 }

 void DXVA2Renderer::ffPoolDummyDelete(void*, uint8_t*)
@@ -84,8 +75,11 @@ bool DXVA2Renderer::prepareDecoderContext(AVCodecContext* context)

    context->hwaccel_context = &m_DXVAContext;

+    context->get_format = ffGetFormat;
    context->get_buffer2 = ffGetBuffer2;

+    context->opaque = this;
+
    m_Pool = av_buffer_pool_init2(ARRAYSIZE(m_DecSurfaces), this, ffPoolAlloc, nullptr);
    if (!m_Pool) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
@@ -93,15 +87,12 @@ bool DXVA2Renderer::prepareDecoderContext(AVCodecContext* context)
        return false;
    }

-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Using DXVA2 accelerated renderer");
-
    return true;
 }

 int DXVA2Renderer::ffGetBuffer2(AVCodecContext* context, AVFrame* frame, int)
 {
-    DXVA2Renderer* me = (DXVA2Renderer*)((FFmpegVideoDecoder*)context->opaque)->getRenderer();
+    DXVA2Renderer* me = reinterpret_cast<DXVA2Renderer*>(context->opaque);

    frame->buf[0] = av_buffer_pool_get(me->m_Pool);
    if (!frame->buf[0]) {
@@ -110,20 +101,31 @@ int DXVA2Renderer::ffGetBuffer2(AVCodecContext* context, AVFrame* frame, int)

    frame->data[3] = frame->buf[0]->data;
    frame->format = AV_PIX_FMT_DXVA2_VLD;
-    frame->width = me->m_VideoWidth;
-    frame->height = me->m_VideoHeight;
+    frame->width = me->m_Width;
+    frame->height = me->m_Height;

    return 0;
 }

+enum AVPixelFormat DXVA2Renderer::ffGetFormat(AVCodecContext*,
+                                              const enum AVPixelFormat* pixFmts)
+{
+    const enum AVPixelFormat *p;
+
+    for (p = pixFmts; *p != -1; p++) {
+        if (*p == AV_PIX_FMT_DXVA2_VLD)
+            return *p;
+    }
+
+    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                 "Failed to find DXVA2 HW surface format");
+    return AV_PIX_FMT_NONE;
+}
+
 bool DXVA2Renderer::initializeDecoder()
 {
    HRESULT hr;

-    if (isDecoderBlacklisted()) {
-        return false;
-    }
-
    hr = DXVA2CreateVideoService(m_Device, IID_IDirectXVideoDecoderService,
                                 reinterpret_cast<void**>(&m_DecService));
    if (FAILED(hr)) {
@@ -206,11 +208,18 @@ bool DXVA2Renderer::initializeDecoder()
        return false;
    }

-    // Alignment was already taken care of
-    SDL_assert(m_Desc.SampleWidth % 16 == 0);
-    SDL_assert(m_Desc.SampleHeight % 16 == 0);
-    hr = m_DecService->CreateSurface(m_Desc.SampleWidth,
-                                     m_Desc.SampleHeight,
+    int alignment;
+
+    // HEVC using DXVA requires 128B alignment
+    if (m_VideoFormat & VIDEO_FORMAT_MASK_H265) {
+        alignment = 128;
+    }
+    else {
+        alignment = 16;
+    }
+
+    hr = m_DecService->CreateSurface(FFALIGN(m_Width, alignment),
+                                     FFALIGN(m_Height, alignment),
                                     ARRAYSIZE(m_DecSurfaces) - 1,
                                     m_Desc.Format,
                                     D3DPOOL_DEFAULT,
@@ -253,9 +262,6 @@ bool DXVA2Renderer::initializeRenderer()
    D3DSURFACE_DESC renderTargetDesc;
    m_RenderTarget->GetDesc(&renderTargetDesc);

-    m_DisplayWidth = renderTargetDesc.Width;
-    m_DisplayHeight = renderTargetDesc.Height;
-
    hr = DXVA2CreateVideoService(m_Device, IID_IDirectXVideoProcessorService,
                                 reinterpret_cast<void**>(&m_ProcService));

@@ -266,354 +272,111 @@ bool DXVA2Renderer::initializeRenderer()
        return false;
    }

-    DXVA2_VideoProcessorCaps caps;
-    hr = m_ProcService->GetVideoProcessorCaps(DXVA2_VideoProcProgressiveDevice, &m_Desc, renderTargetDesc.Format, &caps);
+    UINT guidCount;
+    GUID* guids;
+    hr = m_ProcService->GetVideoProcessorDeviceGuids(&m_Desc, &guidCount, &guids);
    if (FAILED(hr)) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "GetVideoProcessorCaps() failed for DXVA2_VideoProcProgressiveDevice: %x",
+                     "GetVideoProcessorDeviceGuids() failed: %x",
                     hr);
        return false;
    }

-    if (!(caps.DeviceCaps & DXVA2_VPDev_HardwareDevice)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "DXVA2_VideoProcProgressiveDevice is not hardware: %x",
-                     caps.DeviceCaps);
-        return false;
-    }
-    else if (!(caps.VideoProcessorOperations & DXVA2_VideoProcess_YUV2RGB) &&
-             !(caps.VideoProcessorOperations & DXVA2_VideoProcess_YUV2RGBExtended)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "DXVA2_VideoProcProgressiveDevice can't convert YUV2RGB: %x",
-                     caps.VideoProcessorOperations);
-        return false;
-    }
-    else if (!(caps.VideoProcessorOperations & DXVA2_VideoProcess_StretchX) ||
-             !(caps.VideoProcessorOperations & DXVA2_VideoProcess_StretchY)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "DXVA2_VideoProcProgressiveDevice can't stretch video: %x",
-                     caps.VideoProcessorOperations);
-        return false;
-    }
-
-    if (caps.DeviceCaps & DXVA2_VPDev_EmulatedDXVA1) {
-        // DXVA2 over DXVA1 may have bad performance
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "DXVA2_VideoProcProgressiveDevice is DXVA1");
-    }
-
-    m_ProcService->GetProcAmpRange(DXVA2_VideoProcProgressiveDevice, &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Brightness, &m_BrightnessRange);
-    m_ProcService->GetProcAmpRange(DXVA2_VideoProcProgressiveDevice, &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Contrast, &m_ContrastRange);
-    m_ProcService->GetProcAmpRange(DXVA2_VideoProcProgressiveDevice, &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Hue, &m_HueRange);
-    m_ProcService->GetProcAmpRange(DXVA2_VideoProcProgressiveDevice, &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Saturation, &m_SaturationRange);
-
-    hr = m_ProcService->CreateVideoProcessor(DXVA2_VideoProcProgressiveDevice, &m_Desc, renderTargetDesc.Format, 0, &m_Processor);
-    if (FAILED(hr)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "CreateVideoProcessor() failed for DXVA2_VideoProcProgressiveDevice: %x",
-                     hr);
-        return false;
-    }
-
-    return true;
-}
-
-bool DXVA2Renderer::isDecoderBlacklisted()
-{
-    IDirect3D9* d3d9;
-    HRESULT hr;
-    bool result = false;
-
-    // TODO: Update for HEVC Main10
-    SDL_assert(m_VideoFormat != VIDEO_FORMAT_H265_MAIN10);
-
-    hr = m_Device->GetDirect3D(&d3d9);
-    if (SUCCEEDED(hr)) {
-        D3DCAPS9 caps;
-
-        hr = m_Device->GetDeviceCaps(&caps);
+    UINT i;
+    for (i = 0; i < guidCount; i++) {
+        DXVA2_VideoProcessorCaps caps;
+        hr = m_ProcService->GetVideoProcessorCaps(guids[i], &m_Desc, renderTargetDesc.Format, &caps);
        if (SUCCEEDED(hr)) {
-            D3DADAPTER_IDENTIFIER9 id;
-
-            hr = d3d9->GetAdapterIdentifier(caps.AdapterOrdinal, 0, &id);
-            if (SUCCEEDED(hr)) {
-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "Detected GPU: %s (%x:%x)",
-                            id.Description,
-                            id.VendorId,
-                            id.DeviceId);
-                SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                            "GPU driver: %s %d.%d.%d.%d",
-                            id.Driver,
-                            HIWORD(id.DriverVersion.HighPart),
-                            LOWORD(id.DriverVersion.HighPart),
-                            HIWORD(id.DriverVersion.LowPart),
-                            LOWORD(id.DriverVersion.LowPart));
-
-                if (id.VendorId == 0x8086) {
-                    // Intel seems to encode the series in the high byte of
-                    // the device ID. We want to avoid the "Partial" acceleration
-                    // support explicitly. Those will claim to have HW acceleration
-                    // but perform badly.
-                    // https://en.wikipedia.org/wiki/Intel_Graphics_Technology#Capabilities_(GPU_video_acceleration)
-                    // https://raw.githubusercontent.com/GameTechDev/gpudetect/master/IntelGfx.cfg
-                    switch (id.DeviceId & 0xFF00) {
-                    case 0x0400: // Haswell
-                    case 0x0A00: // Haswell
-                    case 0x0D00: // Haswell
-                    case 0x1600: // Broadwell
-                    case 0x2200: // Cherry Trail and Braswell
-                        // Blacklist these for HEVC to avoid hybrid decode
-                        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                                    "GPU blacklisted for HEVC due to hybrid decode");
-                        result = (m_VideoFormat & VIDEO_FORMAT_MASK_H265) != 0;
-                        break;
-                    default:
-                        // Intel drivers from before late-2017 had a bug that caused some strange artifacts
-                        // when decoding HEVC. Avoid HEVC on drivers prior to build 4836 which I confirmed
-                        // is not affected on my Intel HD 515.
-                        // https://github.com/moonlight-stream/moonlight-qt/issues/32
-                        // https://www.intel.com/content/www/us/en/support/articles/000005654/graphics-drivers.html
-                        if (LOWORD(id.DriverVersion.LowPart) < 4836) {
-                            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                                        "Intel driver version blacklisted for HEVC");
-                            result = (m_VideoFormat & VIDEO_FORMAT_MASK_H265) != 0;
-                        }
-                        else {
-                            // Everything else is fine with whatever it says it supports
-                            result = false;
-                        }
-                        break;
-                    }
-                }
-                else if (id.VendorId == 0x10DE) {
-                    // For NVIDIA, we wait to avoid those GPUs with Feature Set E
-                    // for HEVC decoding, since that's hybrid. It appears that Kepler GPUs
-                    // also had some hybrid decode support (per DXVA2 Checker) so we'll
-                    // blacklist those too.
-                    // https://en.wikipedia.org/wiki/Nvidia_PureVideo
-                    // https://bluesky23.yukishigure.com/en/dxvac/deviceInfo/decoder.html
-                    // http://envytools.readthedocs.io/en/latest/hw/pciid.html (missing GM200)
-                    if ((id.DeviceId >= 0x1180 && id.DeviceId <= 0x11BF) || // GK104
-                            (id.DeviceId >= 0x11C0 && id.DeviceId <= 0x11FF) || // GK106
-                            (id.DeviceId >= 0x0FC0 && id.DeviceId <= 0x0FFF) || // GK107
-                            (id.DeviceId >= 0x1000 && id.DeviceId <= 0x103F) || // GK110/GK110B
-                            (id.DeviceId >= 0x1280 && id.DeviceId <= 0x12BF) || // GK208
-                            (id.DeviceId >= 0x1340 && id.DeviceId <= 0x137F) || // GM108
-                            (id.DeviceId >= 0x1380 && id.DeviceId <= 0x13BF) || // GM107
-                            (id.DeviceId >= 0x13C0 && id.DeviceId <= 0x13FF) || // GM204
-                            (id.DeviceId >= 0x1617 && id.DeviceId <= 0x161A) || // GM204
-                            (id.DeviceId == 0x1667) || // GM204
-                            (id.DeviceId >= 0x17C0 && id.DeviceId <= 0x17FF)) { // GM200
-                        // Avoid HEVC on Feature Set E GPUs
-                        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                                    "GPU blacklisted for HEVC due to hybrid decode");
-                        result = (m_VideoFormat & VIDEO_FORMAT_MASK_H265) != 0;
-                    }
-                    else {
-                        result = false;
-                    }
-                }
-                else if (id.VendorId == 0x1002) {
-                    // AMD doesn't seem to do hybrid acceleration?
-                    result = false;
-                }
-                else {
-                    SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                                "Unrecognized vendor ID: %x",
-                                id.VendorId);
-                }
+            if (!(caps.DeviceCaps & DXVA2_VPDev_HardwareDevice)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "Device %d is not hardware: %x",
+                            i,
+                            caps.DeviceCaps);
+                continue;
            }
+            else if (!(caps.VideoProcessorOperations & DXVA2_VideoProcess_YUV2RGB) &&
+                     !(caps.VideoProcessorOperations & DXVA2_VideoProcess_YUV2RGBExtended)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "Device %d can't convert YUV2RGB: %x",
+                            i,
+                            caps.VideoProcessorOperations);
+                continue;
+            }
+
+            m_ProcService->GetProcAmpRange(guids[i], &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Brightness, &m_BrightnessRange);
+            m_ProcService->GetProcAmpRange(guids[i], &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Contrast, &m_ContrastRange);
+            m_ProcService->GetProcAmpRange(guids[i], &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Hue, &m_HueRange);
+            m_ProcService->GetProcAmpRange(guids[i], &m_Desc, renderTargetDesc.Format, DXVA2_ProcAmp_Saturation, &m_SaturationRange);
+
+            hr = m_ProcService->CreateVideoProcessor(guids[i], &m_Desc, renderTargetDesc.Format, 0, &m_Processor);
+            if (FAILED(hr)) {
+                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                            "CreateVideoProcessor() failed for GUID %d: %x",
+                            i,
+                            hr);
+                continue;
+            }
+
+            break;
        }
        else {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "GetDeviceCaps() failed: %x", hr);
+            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
+                        "GetVideoProcessorCaps() failed for GUID %d: %x",
+                        i,
+                        hr);
        }
-
-        d3d9->Release();
    }
-    else {
+
+    CoTaskMemFree(guids);
+
+    if (i == guidCount) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "GetDirect3D() failed: %x", hr);
-    }
-
-    if (result) {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "GPU blacklisted for format %x",
-                    m_VideoFormat);
-    }
-
-    return result;
-}
-
-bool DXVA2Renderer::initializeDevice(SDL_Window* window, bool enableVsync)
-{
-    SDL_SysWMinfo info;
-
-    SDL_VERSION(&info.version);
-    SDL_GetWindowWMInfo(window, &info);
-
-    IDirect3D9Ex* d3d9ex;
-    HRESULT hr = Direct3DCreate9Ex(D3D_SDK_VERSION, &d3d9ex);
-    if (FAILED(hr)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Direct3DCreate9Ex() failed: %x",
-                     hr);
-        return false;
-    }
-
-    int adapterIndex = SDL_Direct3D9GetAdapterIndex(SDL_GetWindowDisplayIndex(window));
-    Uint32 windowFlags = SDL_GetWindowFlags(window);
-
-    D3DCAPS9 deviceCaps;
-    d3d9ex->GetDeviceCaps(adapterIndex, D3DDEVTYPE_HAL, &deviceCaps);
-
-    D3DDISPLAYMODEEX currentMode;
-    currentMode.Size = sizeof(currentMode);
-    d3d9ex->GetAdapterDisplayModeEx(adapterIndex, &currentMode, nullptr);
-
-    D3DPRESENT_PARAMETERS d3dpp = {};
-    d3dpp.hDeviceWindow = info.info.win.window;
-    d3dpp.Flags = D3DPRESENTFLAG_VIDEO;
-
-    if ((windowFlags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN) {
-        d3dpp.Windowed = false;
-        d3dpp.BackBufferWidth = currentMode.Width;
-        d3dpp.BackBufferHeight = currentMode.Height;
-        d3dpp.FullScreen_RefreshRateInHz = currentMode.RefreshRate;
-        d3dpp.BackBufferFormat = currentMode.Format;
-    }
-    else {
-        d3dpp.Windowed = true;
-        d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
-
-        SDL_GetWindowSize(window, (int*)&d3dpp.BackBufferWidth, (int*)&d3dpp.BackBufferHeight);
-    }
-
-    BOOL dwmEnabled;
-    DwmIsCompositionEnabled(&dwmEnabled);
-    if (d3dpp.Windowed && dwmEnabled) {
-        // If composition enabled, disable v-sync and let DWM manage things
-        // to reduce latency by avoiding double v-syncing.
-        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
-
-        // If V-sync is enabled (not rendering faster than display),
-        // we can use FlipEx for more efficient swapping.
-        if (enableVsync) {
-            // D3DSWAPEFFECT_FLIPEX requires at least 2 back buffers to allow us to
-            // continue while DWM is waiting to render the surface to the display.
-            d3dpp.SwapEffect = D3DSWAPEFFECT_FLIPEX;
-            d3dpp.BackBufferCount = 2;
-        }
-        else {
-            // With V-sync off, we won't use FlipEx because that will block while
-            // DWM is waiting to render our surface (effectively behaving like V-Sync).
-            d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
-            d3dpp.BackBufferCount = 1;
-        }
-
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Windowed mode with DWM running");
-    }
-    else if (enableVsync) {
-        // Uncomposited desktop or full-screen exclusive mode with V-sync enabled
-        // We will enable V-sync in this scenario to avoid tearing.
-        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
-        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
-        d3dpp.BackBufferCount = 1;
-
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "V-Sync enabled");
-    }
-    else {
-        // Uncomposited desktop or full-screen exclusive mode with V-sync disabled
-        // We will allowing tearing for lowest latency.
-        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
-        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
-        d3dpp.BackBufferCount = 1;
-
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "V-Sync disabled in tearing mode");
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Windowed: %d | Present Interval: %x",
-                d3dpp.Windowed, d3dpp.PresentationInterval);
-
-    // FFmpeg requires this attribute for doing asynchronous decoding
-    // in a separate thread with this device.
-    int deviceFlags = D3DCREATE_MULTITHREADED;
-
-    if (deviceCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) {
-        deviceFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
-    }
-    else {
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "No hardware vertex processing support!");
-        deviceFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
-    }
-
-    hr = d3d9ex->CreateDeviceEx(adapterIndex,
-                                D3DDEVTYPE_HAL,
-                                d3dpp.hDeviceWindow,
-                                deviceFlags,
-                                &d3dpp,
-                                d3dpp.Windowed ? nullptr : &currentMode,
-                                &m_Device);
-
-    d3d9ex->Release();
-
-    if (FAILED(hr)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "CreateDeviceEx() failed: %x",
-                     hr);
-        return false;
-    }
-
-    hr = m_Device->SetMaximumFrameLatency(1);
-    if (FAILED(hr)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SetMaximumFrameLatency() failed: %x",
-                     hr);
+                     "Unable to find a usable DXVA2 processor");
        return false;
    }

    return true;
 }

-bool DXVA2Renderer::initialize(SDL_Window* window, int videoFormat, int width, int height, int, bool enableVsync)
+bool DXVA2Renderer::initialize(SDL_Window* window, int videoFormat, int width, int height)
 {
    m_VideoFormat = videoFormat;
-    m_VideoWidth = width;
-    m_VideoHeight = height;
+    m_Width = width;
+    m_Height = height;

-    RtlZeroMemory(&m_Desc, sizeof(m_Desc));
+    // FFmpeg will be decoding on different threads than the main thread that we're
+    // currently running on right now. We must set this hint so SDL will pass
+    // D3DCREATE_MULTITHREADED to IDirect3D9::CreateDevice().
+    SDL_SetHint(SDL_HINT_RENDER_DIRECT3D_THREADSAFE, "1");

-    int alignment;
-
-    // HEVC using DXVA requires 128B alignment
-    if (m_VideoFormat & VIDEO_FORMAT_MASK_H265) {
-        alignment = 128;
-    }
-    else {
-        alignment = 16;
-    }
-
-    m_Desc.SampleWidth = FFALIGN(m_VideoWidth, alignment);
-    m_Desc.SampleHeight = FFALIGN(m_VideoHeight, alignment);
-    m_Desc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_Unknown;
-    m_Desc.SampleFormat.NominalRange = DXVA2_NominalRange_Unknown;
-    m_Desc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_Unknown;
-    m_Desc.SampleFormat.VideoLighting = DXVA2_VideoLighting_Unknown;
-    m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_Unknown;
-    m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_Unknown;
-    m_Desc.SampleFormat.SampleFormat = DXVA2_SampleProgressiveFrame;
-    m_Desc.Format = (D3DFORMAT)MAKEFOURCC('N','V','1','2');
-
-    if (!initializeDevice(window, enableVsync)) {
+    // We want VSYNC when running in full-screen. DWM will give us
+    // tear-free video when running composited (windowed) without any
+    // extra latency waiting for VSYNC.
+    m_SdlRenderer = SDL_CreateRenderer(window, -1,
+                                       SDL_RENDERER_ACCELERATED |
+                                       ((SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) ?
+                                           SDL_RENDERER_PRESENTVSYNC : 0));
+    if (!m_SdlRenderer) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "SDL_CreateRenderer() failed: %s",
+                     SDL_GetError());
        return false;
    }

+    m_Device = SDL_RenderGetD3D9Device(m_SdlRenderer);
+
+    RtlZeroMemory(&m_Desc, sizeof(m_Desc));
+    m_Desc.SampleWidth = m_Width;
+    m_Desc.SampleHeight = m_Height;
+    m_Desc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_ProgressiveChroma;
+    m_Desc.SampleFormat.NominalRange = DXVA2_NominalRange_0_255;
+    m_Desc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT709;
+    m_Desc.SampleFormat.VideoLighting = DXVA2_VideoLighting_dim;
+    m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_BT709;
+    m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_709;
+    m_Desc.SampleFormat.SampleFormat = DXVA2_SampleProgressiveFrame;
+    m_Desc.Format = (D3DFORMAT)MAKEFOURCC('N','V','1','2');
+
    if (!initializeDecoder()) {
        return false;
    }
@@ -622,158 +385,51 @@ bool DXVA2Renderer::initialize(SDL_Window* window, int videoFormat, int width, i
        return false;
    }

-    // For some reason, using Direct3D9Ex breaks this with multi-monitor setups.
-    // When focus is lost, the window is minimized then immediately restored without
-    // input focus. This glitches out the renderer and a bunch of other stuff.
-    // Direct3D9Ex itself seems to have this minimize on focus loss behavior on its
-    // own, so just disable SDL's handling of the focus loss event.
-    SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
-
    return true;
 }

-bool DXVA2Renderer::needsTestFrame()
-{
-    // We validate the DXVA2 profiles are supported
-    // in initialize() so no test frame is required
-    return false;
-}
-
-int DXVA2Renderer::getDecoderCapabilities()
-{
-    return 0;
-}
-
-IFFmpegRenderer::VSyncConstraint DXVA2Renderer::getVsyncConstraint()
-{
-    return VSYNC_ANY;
-}
-
-void DXVA2Renderer::renderFrameAtVsync(AVFrame *frame)
+void DXVA2Renderer::renderFrame(AVFrame* frame)
 {
    IDirect3DSurface9* surface = reinterpret_cast<IDirect3DSurface9*>(frame->data[3]);
    HRESULT hr;

-    switch (frame->color_range) {
-    case AVCOL_RANGE_JPEG:
-        m_Desc.SampleFormat.NominalRange = DXVA2_NominalRange_0_255;
-        break;
-    case AVCOL_RANGE_MPEG:
-        m_Desc.SampleFormat.NominalRange = DXVA2_NominalRange_16_235;
+    hr = m_Device->TestCooperativeLevel();
+    switch (hr) {
+    case D3D_OK:
        break;
+    case D3DERR_DEVICELOST:
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "D3D device lost!");
+        return;
+    case D3DERR_DEVICENOTRESET:
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "D3D device not reset!");
+        return;
    default:
-        m_Desc.SampleFormat.NominalRange = DXVA2_NominalRange_Unknown;
-        break;
-    }
-
-    switch (frame->color_primaries) {
-    case AVCOL_PRI_BT709:
-        m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_BT709;
-        break;
-    case AVCOL_PRI_BT470M:
-        m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_BT470_2_SysM;
-        break;
-    case AVCOL_PRI_BT470BG:
-        m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_BT470_2_SysBG;
-        break;
-    case AVCOL_PRI_SMPTE170M:
-        m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_SMPTE170M;
-        break;
-    case AVCOL_PRI_SMPTE240M:
-        m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_SMPTE240M;
-        break;
-    default:
-        m_Desc.SampleFormat.VideoPrimaries = DXVA2_VideoPrimaries_Unknown;
-        break;
-    }
-
-    switch (frame->color_trc) {
-    case AVCOL_TRC_SMPTE170M:
-    case AVCOL_TRC_BT709:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_709;
-        break;
-    case AVCOL_TRC_LINEAR:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_10;
-        break;
-    case AVCOL_TRC_GAMMA22:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_22;
-        break;
-    case AVCOL_TRC_GAMMA28:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_28;
-        break;
-    case AVCOL_TRC_SMPTE240M:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_240M;
-        break;
-    case AVCOL_TRC_IEC61966_2_1:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_sRGB;
-        break;
-    default:
-        m_Desc.SampleFormat.VideoTransferFunction = DXVA2_VideoTransFunc_Unknown;
-        break;
-    }
-
-    switch (frame->colorspace) {
-    case AVCOL_SPC_BT709:
-        m_Desc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT709;
-        break;
-    case AVCOL_SPC_BT470BG:
-    case AVCOL_SPC_SMPTE170M:
-        m_Desc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_BT601;
-        break;
-    case AVCOL_SPC_SMPTE240M:
-        m_Desc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_SMPTE240M;
-        break;
-    default:
-        m_Desc.SampleFormat.VideoTransferMatrix = DXVA2_VideoTransferMatrix_Unknown;
-        break;
-    }
-
-    switch (frame->chroma_location) {
-    case AVCHROMA_LOC_LEFT:
-        m_Desc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_Horizontally_Cosited |
-                                                     DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes;
-        break;
-    case AVCHROMA_LOC_CENTER:
-        m_Desc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes;
-        break;
-    case AVCHROMA_LOC_TOPLEFT:
-        m_Desc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_Horizontally_Cosited |
-                                                     DXVA2_VideoChromaSubsampling_Vertically_Cosited;
-        break;
-    default:
-        m_Desc.SampleFormat.VideoChromaSubsampling = DXVA2_VideoChromaSubsampling_Unknown;
-        break;
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
+                     "Unknown D3D error: %x",
+                     hr);
+        return;
    }

    DXVA2_VideoSample sample = {};
    sample.Start = m_FrameIndex;
    sample.End = m_FrameIndex + 1;
    sample.SrcSurface = surface;
-    sample.SrcRect.right = m_VideoWidth;
-    sample.SrcRect.bottom = m_VideoHeight;
+    sample.SrcRect.right = m_Desc.SampleWidth;
+    sample.SrcRect.bottom = m_Desc.SampleHeight;
+    sample.DstRect = sample.SrcRect;
    sample.SampleFormat = m_Desc.SampleFormat;
    sample.PlanarAlpha = DXVA2_Fixed32OpaqueAlpha();

-    // Center in frame and preserve aspect ratio
-    SDL_Rect src, dst;
-    src.x = src.y = 0;
-    src.w = m_VideoWidth;
-    src.h = m_VideoHeight;
-    dst.x = dst.y = 0;
-    dst.w = m_DisplayWidth;
-    dst.h = m_DisplayHeight;
-
-    StreamUtils::scaleSourceToDestinationSurface(&src, &dst);
-
-    sample.DstRect.left = dst.x;
-    sample.DstRect.right = dst.x + dst.w;
-    sample.DstRect.top = dst.y;
-    sample.DstRect.bottom = dst.y + dst.h;
-
    DXVA2_VideoProcessBltParams bltParams = {};

    bltParams.TargetFrame = m_FrameIndex++;
-    bltParams.TargetRect = sample.DstRect;
+    bltParams.TargetRect.right = m_Desc.SampleWidth;
+    bltParams.TargetRect.bottom = m_Desc.SampleHeight;
+    bltParams.BackgroundColor.Y = 0x1000;
+    bltParams.BackgroundColor.Cb = 0x8000;
+    bltParams.BackgroundColor.Cr = 0x8000;
    bltParams.BackgroundColor.Alpha = 0xFFFF;

    bltParams.DestFormat.SampleFormat = DXVA2_SampleProgressiveFrame;
@@ -785,27 +441,12 @@ void DXVA2Renderer::renderFrameAtVsync(AVFrame *frame)

    bltParams.Alpha = DXVA2_Fixed32OpaqueAlpha();

-    m_Device->Clear(0, nullptr, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255, 0, 0, 0), 0.0f, 0);
-
    hr = m_Processor->VideoProcessBlt(m_RenderTarget, &bltParams, &sample, 1, nullptr);
    if (FAILED(hr)) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                     "VideoProcessBlt() failed: %x",
                     hr);
-        SDL_Event event;
-        event.type = SDL_RENDER_TARGETS_RESET;
-        SDL_PushEvent(&event);
-        return;
    }

-    hr = m_Device->PresentEx(nullptr, nullptr, nullptr, nullptr, 0);
-    if (FAILED(hr)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "PresentEx() failed: %x",
-                     hr);
-        SDL_Event event;
-        event.type = SDL_RENDER_TARGETS_RESET;
-        SDL_PushEvent(&event);
-        return;
-    }
+    m_Device->Present(nullptr, nullptr, nullptr, nullptr);
 }
@@ -1,7 +1,6 @@
 #pragma once

 #include "renderer.h"
-#include "pacer/pacer.h"

 #include <d3d9.h>
 #include <dxva2api.h>
@@ -18,20 +17,13 @@ public:
    virtual bool initialize(SDL_Window* window,
                            int videoFormat,
                            int width,
-                            int height,
-                            int maxFps,
-                            bool enableVsync);
+                            int height);
    virtual bool prepareDecoderContext(AVCodecContext* context);
-    virtual void renderFrameAtVsync(AVFrame* frame);
-    virtual bool needsTestFrame();
-    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
+    virtual void renderFrame(AVFrame* frame);

 private:
    bool initializeDecoder();
    bool initializeRenderer();
-    bool initializeDevice(SDL_Window* window, bool enableVsync);
-    bool isDecoderBlacklisted();

    static
    AVBufferRef* ffPoolAlloc(void* opaque, int size);
@@ -42,12 +34,15 @@ private:
    static
    int ffGetBuffer2(AVCodecContext* context, AVFrame* frame, int flags);

-    int m_VideoFormat;
-    int m_VideoWidth;
-    int m_VideoHeight;
+    static
+    enum AVPixelFormat ffGetFormat(AVCodecContext*,
+                                   const enum AVPixelFormat* pixFmts);

-    int m_DisplayWidth;
-    int m_DisplayHeight;
+    int m_VideoFormat;
+    int m_Width;
+    int m_Height;
+
+    SDL_Renderer* m_SdlRenderer;

    struct dxva_context m_DXVAContext;
    IDirect3DSurface9* m_DecSurfaces[19];
@@ -57,7 +52,7 @@ private:
    int m_SurfacesUsed;
    AVBufferPool* m_Pool;

-    IDirect3DDevice9Ex* m_Device;
+    IDirect3DDevice9* m_Device;
    IDirect3DSurface9* m_RenderTarget;
    IDirectXVideoProcessorService* m_ProcService;
    IDirectXVideoProcessor* m_Processor;
@@ -1,11 +0,0 @@
-#pragma once
-
-#include "pacer.h"
-
-class DisplayLinkVsyncSourceFactory
-{
-public:
-    static
-    IVsyncSource* createVsyncSource(Pacer* pacer);
-};
-
@@ -1,132 +0,0 @@
-#include "displaylinkvsyncsource.h"
-
-#include <SDL_syswm.h>
-
-#include <CoreVideo/CoreVideo.h>
-
-#import <Cocoa/Cocoa.h>
-
-class DisplayLinkVsyncSource : public IVsyncSource
-{
-public:
-    DisplayLinkVsyncSource(Pacer* pacer)
-        : m_Pacer(pacer),
-          m_DisplayLink(nullptr)
-    {
-
-    }
-
-    virtual ~DisplayLinkVsyncSource() override
-    {
-        if (m_DisplayLink != nullptr) {
-            CVDisplayLinkStop(m_DisplayLink);
-            CVDisplayLinkRelease(m_DisplayLink);
-        }
-    }
-
-    static
-    CGDirectDisplayID
-    getDisplayID(NSScreen* screen)
-    {
-        NSNumber* screenNumber = [screen deviceDescription][@"NSScreenNumber"];
-        return [screenNumber unsignedIntValue];
-    }
-
-    static
-    CVReturn
-    displayLinkOutputCallback(
-        CVDisplayLinkRef displayLink,
-        const CVTimeStamp* /* now */,
-        const CVTimeStamp* /* vsyncTime */,
-        CVOptionFlags,
-        CVOptionFlags*,
-        void *displayLinkContext)
-    {
-        auto me = reinterpret_cast<DisplayLinkVsyncSource*>(displayLinkContext);
-
-        SDL_assert(displayLink == me->m_DisplayLink);
-
-        // In my testing on macOS 10.13, this callback is invoked about 24 ms
-        // prior to the specified v-sync time (now - vsyncTime). Since this is
-        // greater than the standard v-sync interval (16 ms = 60 FPS), we will
-        // draw using the current host time, rather than the actual v-sync target
-        // time. Because the CVDisplayLink is in sync with the actual v-sync
-        // interval, even if many ms prior, we can safely use the current host time
-        // and get a consistent callback for each v-sync. This reduces video latency
-        // by at least 1 frame vs. rendering with the actual vsyncTime.
-        me->m_Pacer->vsyncCallback(500 / me->m_DisplayFps);
-
-        return kCVReturnSuccess;
-    }
-
-    virtual bool initialize(SDL_Window* window, int displayFps) override
-    {
-        SDL_SysWMinfo info;
-
-        SDL_VERSION(&info.version);
-
-        if (!SDL_GetWindowWMInfo(window, &info)) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "SDL_GetWindowWMInfo() failed: %s",
-                         SDL_GetError());
-            return false;
-        }
-
-        SDL_assert(info.subsystem == SDL_SYSWM_COCOA);
-
-        m_DisplayFps = displayFps;
-
-        NSScreen* screen = [info.info.cocoa.window screen];
-        CVReturn status;
-        if (screen == nullptr) {
-            // Window not visible on any display, so use a
-            // CVDisplayLink that can work with all active displays.
-            // When we become visible, we'll recreate ourselves
-            // and associate with the new screen.
-            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                        "NSWindow is not visible on any display");
-            status = CVDisplayLinkCreateWithActiveCGDisplays(&m_DisplayLink);
-        }
-        else {
-            CGDirectDisplayID displayId;
-            displayId = getDisplayID(screen);
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "NSWindow on display: %x",
-                        displayId);
-            status = CVDisplayLinkCreateWithCGDisplay(displayId, &m_DisplayLink);
-        }
-        if (status != kCVReturnSuccess) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "Failed to create CVDisplayLink: %d",
-                         status);
-            return false;
-        }
-
-        status = CVDisplayLinkSetOutputCallback(m_DisplayLink, displayLinkOutputCallback, this);
-        if (status != kCVReturnSuccess) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "CVDisplayLinkSetOutputCallback() failed: %d",
-                         status);
-            return false;
-        }
-
-        status = CVDisplayLinkStart(m_DisplayLink);
-        if (status != kCVReturnSuccess) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "CVDisplayLinkStart() failed: %d",
-                         status);
-            return false;
-        }
-
-        return true;
-    }
-
-private:
-    Pacer* m_Pacer;
-    CVDisplayLinkRef m_DisplayLink;
-    int m_DisplayFps;
-};
-
-IVsyncSource* DisplayLinkVsyncSourceFactory::createVsyncSource(Pacer* pacer) {
-    return new DisplayLinkVsyncSource(pacer);
-}
@@ -1,168 +0,0 @@
-#include "dxvsyncsource.h"
-
-// Useful references:
-// https://bugs.chromium.org/p/chromium/issues/detail?id=467617
-// https://chromium.googlesource.com/chromium/src.git/+/c564f2fe339b2b2abb0c8773c90c83215670ea71/gpu/ipc/service/gpu_vsync_provider_win.cc
-
-DxVsyncSource::DxVsyncSource(Pacer* pacer) :
-    m_Pacer(pacer),
-    m_Thread(nullptr),
-    m_Gdi32Handle(nullptr)
-{
-    SDL_AtomicSet(&m_Stopping, 0);
-}
-
-DxVsyncSource::~DxVsyncSource()
-{
-    if (m_Thread != nullptr) {
-        SDL_AtomicSet(&m_Stopping, 1);
-        SDL_WaitThread(m_Thread, nullptr);
-    }
-
-    if (m_Gdi32Handle != nullptr) {
-        FreeLibrary(m_Gdi32Handle);
-    }
-}
-
-bool DxVsyncSource::initialize(SDL_Window* window, int displayFps)
-{
-    m_DisplayFps = displayFps;
-
-    m_Gdi32Handle = LoadLibraryA("gdi32.dll");
-    if (m_Gdi32Handle == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to load gdi32.dll: %d",
-                     GetLastError());
-        return false;
-    }
-
-    m_D3DKMTOpenAdapterFromHdc = (PFND3DKMTOPENADAPTERFROMHDC)GetProcAddress(m_Gdi32Handle, "D3DKMTOpenAdapterFromHdc");
-    m_D3DKMTCloseAdapter = (PFND3DKMTCLOSEADAPTER)GetProcAddress(m_Gdi32Handle, "D3DKMTCloseAdapter");
-    m_D3DKMTWaitForVerticalBlankEvent = (PFND3DKMTWAITFORVERTICALBLANKEVENT)GetProcAddress(m_Gdi32Handle, "D3DKMTWaitForVerticalBlankEvent");
-
-    if (m_D3DKMTOpenAdapterFromHdc == nullptr ||
-            m_D3DKMTCloseAdapter == nullptr ||
-            m_D3DKMTWaitForVerticalBlankEvent == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Missing required function in gdi32.dll");
-        return false;
-    }
-
-    SDL_SysWMinfo info;
-
-    SDL_VERSION(&info.version);
-
-    if (!SDL_GetWindowWMInfo(window, &info)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_GetWindowWMInfo() failed: %s",
-                     SDL_GetError());
-        return false;
-    }
-
-    m_Window = info.info.win.window;
-
-    m_Thread = SDL_CreateThread(vsyncThread, "DX Vsync Thread", this);
-    if (m_Thread == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Unable to create DX V-sync thread: %s",
-                     SDL_GetError());
-        return false;
-    }
-
-    return true;
-}
-
-int DxVsyncSource::vsyncThread(void* context)
-{
-    DxVsyncSource* me = reinterpret_cast<DxVsyncSource*>(context);
-
-    SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
-
-    D3DKMT_OPENADAPTERFROMHDC openAdapterParams = {};
-    HMONITOR lastMonitor = nullptr;
-    DEVMODEA monitorMode;
-    monitorMode.dmSize = sizeof(monitorMode);
-
-    while (SDL_AtomicGet(&me->m_Stopping) == 0) {
-        D3DKMT_WAITFORVERTICALBLANKEVENT waitForVblankEventParams;
-        NTSTATUS status;
-
-        // If the monitor has changed from last time, open the new adapter
-        HMONITOR currentMonitor = MonitorFromWindow(me->m_Window, MONITOR_DEFAULTTONEAREST);
-        if (currentMonitor != lastMonitor) {
-            MONITORINFOEXA monitorInfo = {};
-            monitorInfo.cbSize = sizeof(monitorInfo);
-            if (!GetMonitorInfoA(currentMonitor, &monitorInfo)) {
-                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                             "GetMonitorInfo() failed: %d",
-                             GetLastError());
-                SDL_Delay(10);
-                continue;
-            }
-
-            if (!EnumDisplaySettingsA(monitorInfo.szDevice, ENUM_CURRENT_SETTINGS, &monitorMode)) {
-                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                             "EnumDisplaySettings() failed: %d",
-                             GetLastError());
-                SDL_Delay(10);
-                continue;
-            }
-
-            SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                        "Monitor changed: %s %d Hz",
-                        monitorInfo.szDevice,
-                        monitorMode.dmDisplayFrequency);
-
-            if (openAdapterParams.hAdapter != 0) {
-                D3DKMT_CLOSEADAPTER closeAdapterParams = {};
-                closeAdapterParams.hAdapter = openAdapterParams.hAdapter;
-                me->m_D3DKMTCloseAdapter(&closeAdapterParams);
-            }
-
-            openAdapterParams.hDc = CreateDCA(nullptr, monitorInfo.szDevice, nullptr, nullptr);
-            if (!openAdapterParams.hDc) {
-                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                             "CreateDC() failed: %d",
-                             GetLastError());
-                SDL_Delay(10);
-                continue;
-            }
-
-            status = me->m_D3DKMTOpenAdapterFromHdc(&openAdapterParams);
-            DeleteDC(openAdapterParams.hDc);
-
-            if (status != STATUS_SUCCESS) {
-                SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                             "D3DKMTOpenAdapterFromHdc() failed: %x",
-                             status);
-                SDL_Delay(10);
-                continue;
-            }
-
-            lastMonitor = currentMonitor;
-        }
-
-        waitForVblankEventParams.hAdapter = openAdapterParams.hAdapter;
-        waitForVblankEventParams.hDevice = 0;
-        waitForVblankEventParams.VidPnSourceId = openAdapterParams.VidPnSourceId;
-
-        status = me->m_D3DKMTWaitForVerticalBlankEvent(&waitForVblankEventParams);
-        if (status != STATUS_SUCCESS) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "D3DKMTWaitForVerticalBlankEvent() failed: %x",
-                         status);
-            SDL_Delay(10);
-            continue;
-        }
-
-        me->m_Pacer->vsyncCallback(1000 / me->m_DisplayFps);
-    }
-
-    if (openAdapterParams.hAdapter != 0) {
-        D3DKMT_CLOSEADAPTER closeAdapterParams = {};
-        closeAdapterParams.hAdapter = openAdapterParams.hAdapter;
-        me->m_D3DKMTCloseAdapter(&closeAdapterParams);
-    }
-
-    return 0;
-}
@@ -1,53 +0,0 @@
-#pragma once
-
-#include "pacer.h"
-
-#include <SDL_syswm.h>
-
-// from <D3dkmthk.h>
-typedef LONG NTSTATUS;
-typedef UINT D3DKMT_HANDLE;
-typedef UINT D3DDDI_VIDEO_PRESENT_SOURCE_ID;
-#define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
-#define STATUS_GRAPHICS_PRESENT_OCCLUDED ((NTSTATUS)0xC01E0006L)
-typedef struct _D3DKMT_OPENADAPTERFROMHDC {
-  HDC hDc;
-  D3DKMT_HANDLE hAdapter;
-  LUID AdapterLuid;
-  D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
-} D3DKMT_OPENADAPTERFROMHDC;
-typedef struct _D3DKMT_CLOSEADAPTER {
-  D3DKMT_HANDLE hAdapter;
-} D3DKMT_CLOSEADAPTER;
-typedef struct _D3DKMT_WAITFORVERTICALBLANKEVENT {
-  D3DKMT_HANDLE hAdapter;
-  D3DKMT_HANDLE hDevice;
-  D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
-} D3DKMT_WAITFORVERTICALBLANKEVENT;
-typedef NTSTATUS(APIENTRY* PFND3DKMTOPENADAPTERFROMHDC)(D3DKMT_OPENADAPTERFROMHDC*);
-typedef NTSTATUS(APIENTRY* PFND3DKMTCLOSEADAPTER)(D3DKMT_CLOSEADAPTER*);
-typedef NTSTATUS(APIENTRY* PFND3DKMTWAITFORVERTICALBLANKEVENT)(D3DKMT_WAITFORVERTICALBLANKEVENT*);
-
-class DxVsyncSource : public IVsyncSource
-{
-public:
-    DxVsyncSource(Pacer* pacer);
-
-    virtual ~DxVsyncSource();
-
-    virtual bool initialize(SDL_Window* window, int displayFps);
-
-private:
-    static int vsyncThread(void* context);
-
-    Pacer* m_Pacer;
-    SDL_Thread* m_Thread;
-    SDL_atomic_t m_Stopping;
-    HMODULE m_Gdi32Handle;
-    HWND m_Window;
-    int m_DisplayFps;
-
-    PFND3DKMTOPENADAPTERFROMHDC m_D3DKMTOpenAdapterFromHdc;
-    PFND3DKMTCLOSEADAPTER m_D3DKMTCloseAdapter;
-    PFND3DKMTWAITFORVERTICALBLANKEVENT m_D3DKMTWaitForVerticalBlankEvent;
-};
@@ -1,43 +0,0 @@
-#include "nullthreadedvsyncsource.h"
-
-NullThreadedVsyncSource::NullThreadedVsyncSource(Pacer* pacer) :
-    m_Pacer(pacer),
-    m_Thread(nullptr)
-{
-    SDL_AtomicSet(&m_Stopping, 0);
-}
-
-NullThreadedVsyncSource::~NullThreadedVsyncSource()
-{
-    if (m_Thread != nullptr) {
-        SDL_AtomicSet(&m_Stopping, 1);
-        SDL_WaitThread(m_Thread, nullptr);
-    }
-}
-
-bool NullThreadedVsyncSource::initialize(SDL_Window*, int displayFps)
-{
-    m_DisplayFps = displayFps;
-    m_Thread = SDL_CreateThread(vsyncThread, "Null Vsync Thread", this);
-    if (m_Thread == nullptr) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Unable to create DX V-sync thread: %s",
-                     SDL_GetError());
-        return false;
-    }
-
-    return true;
-}
-
-int NullThreadedVsyncSource::vsyncThread(void* context)
-{
-    NullThreadedVsyncSource* me = reinterpret_cast<NullThreadedVsyncSource*>(context);
-
-    SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
-
-    while (SDL_AtomicGet(&me->m_Stopping) == 0) {
-        me->m_Pacer->vsyncCallback(1000 / me->m_DisplayFps);
-    }
-
-    return 0;
-}
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "pacer.h"
-
-class NullThreadedVsyncSource : public IVsyncSource
-{
-public:
-    NullThreadedVsyncSource(Pacer* pacer);
-
-    virtual ~NullThreadedVsyncSource();
-
-    virtual bool initialize(SDL_Window* window, int displayFps);
-
-private:
-    static int vsyncThread(void* context);
-
-    Pacer* m_Pacer;
-    SDL_Thread* m_Thread;
-    SDL_atomic_t m_Stopping;
-    int m_DisplayFps;
-};
@@ -1,183 +0,0 @@
-#include "pacer.h"
-#include "streaming/streamutils.h"
-
-#include "nullthreadedvsyncsource.h"
-
-#ifdef Q_OS_DARWIN
-#include "displaylinkvsyncsource.h"
-#endif
-
-#ifdef Q_OS_WIN32
-#include "dxvsyncsource.h"
-#endif
-
-#define FRAME_HISTORY_ENTRIES 8
-
-// We may be woken up slightly late so don't go all the way
-// up to the next V-sync since we may accidentally step into
-// the next V-sync period. It also takes some amount of time
-// to do the render itself, so we can't render right before
-// V-sync happens.
-#define TIMER_SLACK_MS 3
-
-Pacer::Pacer(IFFmpegRenderer* renderer, PVIDEO_STATS videoStats) :
-    m_FrameQueueLock(0),
-    m_VsyncSource(nullptr),
-    m_VsyncRenderer(renderer),
-    m_MaxVideoFps(0),
-    m_DisplayFps(0),
-    m_VideoStats(videoStats)
-{
-
-}
-
-Pacer::~Pacer()
-{
-    // Stop V-sync callbacks
-    delete m_VsyncSource;
-    m_VsyncSource = nullptr;
-
-    while (!m_FrameQueue.isEmpty()) {
-        AVFrame* frame = m_FrameQueue.dequeue();
-        av_frame_free(&frame);
-    }
-}
-
-// Called in an arbitrary thread by the IVsyncSource on V-sync
-// or an event synchronized with V-sync
-void Pacer::vsyncCallback(int timeUntilNextVsyncMillis)
-{
-    // Make sure initialize() has been called
-    SDL_assert(m_MaxVideoFps != 0);
-
-    SDL_assert(timeUntilNextVsyncMillis >= TIMER_SLACK_MS);
-
-    Uint32 vsyncCallbackStartTime = SDL_GetTicks();
-
-    SDL_AtomicLock(&m_FrameQueueLock);
-
-    // If the queue length history entries are large, be strict
-    // about dropping excess frames.
-    int frameDropTarget = 1;
-
-    // If we may get more frames per second than we can display, use
-    // frame history to drop frames only if consistently above the
-    // one queued frame mark.
-    if (m_MaxVideoFps >= m_DisplayFps) {
-        for (int i = 0; i < m_FrameQueueHistory.count(); i++) {
-            if (m_FrameQueueHistory[i] <= 1) {
-                // Be lenient as long as the queue length
-                // resolves before the end of frame history
-                frameDropTarget = 3;
-                break;
-            }
-        }
-
-        if (m_FrameQueueHistory.count() == FRAME_HISTORY_ENTRIES) {
-            m_FrameQueueHistory.dequeue();
-        }
-
-        m_FrameQueueHistory.enqueue(m_FrameQueue.count());
-    }
-
-    // Catch up if we're several frames ahead
-    while (m_FrameQueue.count() > frameDropTarget) {
-        AVFrame* frame = m_FrameQueue.dequeue();
-        m_VideoStats->pacerDroppedFrames++;
-        av_frame_free(&frame);
-    }
-
-
-    if (m_FrameQueue.isEmpty()) {
-        SDL_AtomicUnlock(&m_FrameQueueLock);
-
-        while (!SDL_TICKS_PASSED(SDL_GetTicks(),
-                                 vsyncCallbackStartTime + timeUntilNextVsyncMillis - TIMER_SLACK_MS)) {
-            SDL_Delay(1);
-
-            SDL_AtomicLock(&m_FrameQueueLock);
-            if (!m_FrameQueue.isEmpty()) {
-                // Don't release the lock
-                goto RenderNextFrame;
-            }
-            SDL_AtomicUnlock(&m_FrameQueueLock);
-        }
-
-        // Nothing to render at this time
-        return;
-    }
-
-RenderNextFrame:
-    // Grab the first frame
-    AVFrame* frame = m_FrameQueue.dequeue();
-    SDL_AtomicUnlock(&m_FrameQueueLock);
-
-    // Render it
-    Uint32 beforeRender = SDL_GetTicks();
-    m_VsyncRenderer->renderFrameAtVsync(frame);
-    m_VideoStats->totalRenderTime += SDL_GetTicks() - beforeRender;
-    m_VideoStats->renderedFrames++;
-
-    // Free the frame
-    av_frame_free(&frame);
-}
-
-bool Pacer::initialize(SDL_Window* window, int maxVideoFps, bool enableVsync)
-{
-    m_MaxVideoFps = maxVideoFps;
-    m_EnableVsync = enableVsync;
-    m_DisplayFps = StreamUtils::getDisplayRefreshRate(window);
-
-    if (m_EnableVsync) {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Frame pacing in tear-free mode: target %d Hz with %d FPS stream",
-                    m_DisplayFps, m_MaxVideoFps);
-
-    #if defined(Q_OS_DARWIN)
-        m_VsyncSource = DisplayLinkVsyncSourceFactory::createVsyncSource(this);
-    #elif defined(Q_OS_WIN32)
-        m_VsyncSource = new DxVsyncSource(this);
-    #else
-        // Platforms without a VsyncSource will just render frames
-        // immediately like they used to.
-    #endif
-
-        if (m_VsyncSource != nullptr && !m_VsyncSource->initialize(window, m_DisplayFps)) {
-            return false;
-        }
-    }
-    else {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Minimal latency tearing mode: target %d Hz with %d FPS stream",
-                    m_DisplayFps, m_MaxVideoFps);
-    }
-
-    return true;
-}
-
-void Pacer::submitFrame(AVFrame* frame)
-{
-    // Make sure initialize() has been called
-    SDL_assert(m_MaxVideoFps != 0);
-
-    // Queue the frame until the V-sync callback if
-    // we have a V-sync source, otherwise deliver it
-    // immediately and hope for the best.
-    if (isUsingFrameQueue()) {
-        SDL_AtomicLock(&m_FrameQueueLock);
-        m_FrameQueue.enqueue(frame);
-        SDL_AtomicUnlock(&m_FrameQueueLock);
-    }
-    else {
-        Uint32 beforeRender = SDL_GetTicks();
-        m_VsyncRenderer->renderFrameAtVsync(frame);
-        m_VideoStats->totalRenderTime += SDL_GetTicks() - beforeRender;
-        m_VideoStats->renderedFrames++;
-        av_frame_free(&frame);
-    }
-}
-
-bool Pacer::isUsingFrameQueue()
-{
-    return m_VsyncSource != nullptr;
-}
@@ -1,40 +0,0 @@
-#pragma once
-
-#include "../../decoder.h"
-#include "../renderer.h"
-
-#include <QQueue>
-
-class IVsyncSource {
-public:
-    virtual ~IVsyncSource() {}
-    virtual bool initialize(SDL_Window* window, int displayFps) = 0;
-};
-
-class Pacer
-{
-public:
-    Pacer(IFFmpegRenderer* renderer, PVIDEO_STATS videoStats);
-
-    ~Pacer();
-
-    void submitFrame(AVFrame* frame);
-
-    bool initialize(SDL_Window* window, int maxVideoFps, bool enableVsync);
-
-    void vsyncCallback(int timeUntilNextVsyncMillis);
-
-    bool isUsingFrameQueue();
-
-private:
-    QQueue<AVFrame*> m_FrameQueue;
-    QQueue<int> m_FrameQueueHistory;
-    SDL_SpinLock m_FrameQueueLock;
-
-    IVsyncSource* m_VsyncSource;
-    IFFmpegRenderer* m_VsyncRenderer;
-    int m_MaxVideoFps;
-    int m_DisplayFps;
-    bool m_EnableVsync;
-    PVIDEO_STATS m_VideoStats;
-};
@@ -8,24 +8,13 @@ extern "C" {

 class IFFmpegRenderer {
 public:
-    enum VSyncConstraint {
-        VSYNC_FORCE_OFF,
-        VSYNC_FORCE_ON,
-        VSYNC_ANY
-    };
-
    virtual ~IFFmpegRenderer() {}
    virtual bool initialize(SDL_Window* window,
                            int videoFormat,
                            int width,
-                            int height,
-                            int maxFps,
-                            bool enableVsync) = 0;
+                            int height) = 0;
    virtual bool prepareDecoderContext(AVCodecContext* context) = 0;
-    virtual void renderFrameAtVsync(AVFrame* frame) = 0;
-    virtual bool needsTestFrame() = 0;
-    virtual int getDecoderCapabilities() = 0;
-    virtual VSyncConstraint getVsyncConstraint() = 0;
+    virtual void renderFrame(AVFrame* frame) = 0;
 };

 class SdlRenderer : public IFFmpegRenderer {
@@ -35,14 +24,9 @@ public:
    virtual bool initialize(SDL_Window* window,
                            int videoFormat,
                            int width,
-                            int height,
-                            int maxFps,
-                            bool enableVsync);
+                            int height);
    virtual bool prepareDecoderContext(AVCodecContext* context);
-    virtual void renderFrameAtVsync(AVFrame* frame);
-    virtual bool needsTestFrame();
-    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
+    virtual void renderFrame(AVFrame* frame);

 private:
    SDL_Renderer* m_Renderer;
@@ -1,7 +1,5 @@
 #include "renderer.h"

-#include <Limelight.h>
-
 SdlRenderer::SdlRenderer()
    : m_Renderer(nullptr),
      m_Texture(nullptr)
@@ -23,50 +21,15 @@ SdlRenderer::~SdlRenderer()
 bool SdlRenderer::prepareDecoderContext(AVCodecContext*)
 {
    /* Nothing to do */
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Using SDL software renderer");
-
    return true;
 }

-bool SdlRenderer::needsTestFrame()
-{
-    // This renderer should always work
-    return false;
-}
-
-int SdlRenderer::getDecoderCapabilities()
-{
-    // The FFmpeg CPU decoder can handle reference frame invalidation,
-    // but only for H.264.
-    return CAPABILITY_REFERENCE_FRAME_INVALIDATION_AVC;
-}
-
-IFFmpegRenderer::VSyncConstraint SdlRenderer::getVsyncConstraint()
-{
-    return VSYNC_ANY;
-}
-
 bool SdlRenderer::initialize(SDL_Window* window,
                             int,
                             int width,
-                             int height,
-                             int,
-                             bool enableVsync)
+                             int height)
 {
-    Uint32 rendererFlags = SDL_RENDERER_ACCELERATED;
-
-    if ((SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN) {
-        // In full-screen exclusive mode, we enable V-sync if requested. For other modes, Windows and Mac
-        // have compositors that make rendering tear-free. Linux compositor varies by distro and user
-        // configuration but doesn't seem feasible to detect here.
-        if (enableVsync) {
-            rendererFlags |= SDL_RENDERER_PRESENTVSYNC;
-        }
-    }
-
-    m_Renderer = SDL_CreateRenderer(window, -1, rendererFlags);
+    m_Renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (!m_Renderer) {
        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
                     "SDL_CreateRenderer() failed: %s",
@@ -78,11 +41,6 @@ bool SdlRenderer::initialize(SDL_Window* window,
    // logical rendering surface size is equal to the stream size
    SDL_RenderSetLogicalSize(m_Renderer, width, height);

-    // Draw a black frame until the video stream starts rendering
-    SDL_SetRenderDrawColor(m_Renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
-    SDL_RenderClear(m_Renderer);
-    SDL_RenderPresent(m_Renderer);
-
    m_Texture = SDL_CreateTexture(m_Renderer,
                                  SDL_PIXELFORMAT_YV12,
                                  SDL_TEXTUREACCESS_STREAMING,
@@ -98,7 +56,7 @@ bool SdlRenderer::initialize(SDL_Window* window,
    return true;
 }

-void SdlRenderer::renderFrameAtVsync(AVFrame* frame)
+void SdlRenderer::renderFrame(AVFrame* frame)
 {
    SDL_UpdateYUVTexture(m_Texture, nullptr,
                         frame->data[0],
@@ -107,7 +65,6 @@ void SdlRenderer::renderFrameAtVsync(AVFrame* frame)
                         frame->linesize[1],
                         frame->data[2],
                         frame->linesize[2]);
-
    SDL_RenderClear(m_Renderer);
    SDL_RenderCopy(m_Renderer, m_Texture, nullptr, nullptr);
    SDL_RenderPresent(m_Renderer);
@@ -1,224 +0,0 @@
-#include "vaapi.h"
-#include <streaming/streamutils.h>
-
-#include <SDL_syswm.h>
-
-VAAPIRenderer::VAAPIRenderer()
-    : m_HwContext(nullptr)
-{
-
-}
-
-VAAPIRenderer::~VAAPIRenderer()
-{
-    if (m_HwContext != nullptr) {
-        AVHWDeviceContext* deviceContext = (AVHWDeviceContext*)m_HwContext->data;
-        AVVAAPIDeviceContext* vaDeviceContext = (AVVAAPIDeviceContext*)deviceContext->hwctx;
-
-        // Hold onto this VADisplay since we'll need it to uninitialize VAAPI
-        VADisplay display = vaDeviceContext->display;
-
-        av_buffer_unref(&m_HwContext);
-
-        if (display) {
-            vaTerminate(display);
-        }
-    }
-}
-
-bool
-VAAPIRenderer::initialize(SDL_Window* window, int, int width, int height, int, bool)
-{
-    int err;
-    SDL_SysWMinfo info;
-
-    m_VideoWidth = width;
-    m_VideoHeight = height;
-
-    SDL_GetWindowSize(window, &m_DisplayWidth, &m_DisplayHeight);
-
-    SDL_VERSION(&info.version);
-
-    if (!SDL_GetWindowWMInfo(window, &info)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_GetWindowWMInfo() failed: %s",
-                     SDL_GetError());
-        return false;
-    }
-
-    m_HwContext = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_VAAPI);
-    if (!m_HwContext) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                    "Failed to allocate VAAPI context");
-        return false;
-    }
-
-    AVHWDeviceContext* deviceContext = (AVHWDeviceContext*)m_HwContext->data;
-    AVVAAPIDeviceContext* vaDeviceContext = (AVVAAPIDeviceContext*)deviceContext->hwctx;
-
-    m_WindowSystem = info.subsystem;
-    if (info.subsystem == SDL_SYSWM_X11) {
-#ifdef HAVE_LIBVA_X11
-        m_XWindow = info.info.x11.window;
-        vaDeviceContext->display = vaGetDisplay(info.info.x11.display);
-        if (!vaDeviceContext->display) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "Unable to open X11 display for VAAPI");
-            return false;
-        }
-#else
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Moonlight not compiled with VAAPI X11 support!");
-        return false;
-#endif
-    }
-    else if (info.subsystem == SDL_SYSWM_WAYLAND) {
-#ifdef HAVE_LIBVA_WAYLAND
-        m_WaylandSurface = info.info.wl.surface;
-        m_WaylandDisplay = info.info.wl.display;
-        vaDeviceContext->display = vaGetDisplayWl(info.info.wl.display);
-        if (!vaDeviceContext->display) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "Unable to open Wayland display for VAAPI");
-            return false;
-        }
-#else
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Moonlight not compiled with VAAPI Wayland support!");
-        return false;
-#endif
-    }
-    else {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Unsupported VAAPI rendering subsystem: %d",
-                     info.subsystem);
-        return false;
-    }
-
-    int major, minor;
-    VAStatus status;
-    status = vaInitialize(vaDeviceContext->display, &major, &minor);
-    if (status != VA_STATUS_SUCCESS) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to initialize VAAPI: %d",
-                     status);
-        return false;
-    }
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Initialized VAAPI %d.%d",
-                major, minor);
-
-    const char* vendorString = vaQueryVendorString(vaDeviceContext->display);
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Driver: %s",
-                vendorString ? vendorString : "<unknown>");
-
-    // This will populate the driver_quirks
-    err = av_hwdevice_ctx_init(m_HwContext);
-    if (err < 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to initialize VAAPI context: %d",
-                     err);
-        return false;
-    }
-
-    // This quirk is set for the VDPAU wrapper which doesn't work with our VAAPI renderer
-    if (vaDeviceContext->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES) {
-        // Fail and let our VDPAU renderer pick this up
-        SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                    "Avoiding VDPAU wrapper for VAAPI decoding");
-        return false;
-    }
-
-    return true;
-}
-
-bool
-VAAPIRenderer::prepareDecoderContext(AVCodecContext* context)
-{
-    context->hw_device_ctx = av_buffer_ref(m_HwContext);
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Using VAAPI accelerated renderer on %s",
-                m_WindowSystem == SDL_SYSWM_X11 ? "X11" : "Wayland");
-
-    return true;
-}
-
-bool
-VAAPIRenderer::needsTestFrame()
-{
-    // We need a test frame to see if this VAAPI driver
-    // supports the profile used for streaming
-    return true;
-}
-
-int
-VAAPIRenderer::getDecoderCapabilities()
-{
-    return 0;
-}
-
-IFFmpegRenderer::VSyncConstraint VAAPIRenderer::getVsyncConstraint()
-{
-    return VSYNC_ANY;
-}
-
-void
-VAAPIRenderer::renderFrameAtVsync(AVFrame* frame)
-{
-    VASurfaceID surface = (VASurfaceID)(uintptr_t)frame->data[3];
-    AVHWDeviceContext* deviceContext = (AVHWDeviceContext*)m_HwContext->data;
-    AVVAAPIDeviceContext* vaDeviceContext = (AVVAAPIDeviceContext*)deviceContext->hwctx;
-
-    SDL_Rect src, dst;
-    src.x = src.y = 0;
-    src.w = m_VideoWidth;
-    src.h = m_VideoHeight;
-    dst.x = dst.y = 0;
-    dst.w = m_DisplayWidth;
-    dst.h = m_DisplayHeight;
-
-    StreamUtils::scaleSourceToDestinationSurface(&src, &dst);
-
-    if (m_WindowSystem == SDL_SYSWM_X11) {
-#ifdef HAVE_LIBVA_X11
-        vaPutSurface(vaDeviceContext->display,
-                     surface,
-                     m_XWindow,
-                     0, 0,
-                     m_VideoWidth, m_VideoHeight,
-                     dst.x, dst.y,
-                     dst.w, dst.h,
-                     NULL, 0, 0);
-#endif
-    }
-    else if (m_WindowSystem == SDL_SYSWM_WAYLAND) {
-#ifdef HAVE_LIBVA_WAYLAND
-        struct wl_buffer* buffer;
-        VAStatus status;
-
-        status = vaGetSurfaceBufferWl(vaDeviceContext->display,
-                                      surface,
-                                      VA_FRAME_PICTURE,
-                                      &buffer);
-        if (status == VA_STATUS_SUCCESS) {
-            wl_surface_attach(m_WaylandSurface, buffer, 0, 0);
-            wl_surface_damage(m_WaylandSurface, dst.x, dst.y, dst.w, dst.h);
-
-            wl_display_flush(m_WaylandDisplay);
-            wl_surface_commit(m_WaylandSurface);
-        }
-        else {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "vaGetSurfaceBufferWl failed(): %d",
-                         status);
-        }
-#endif
-    }
-    else {
-        // We don't accept anything else in initialize().
-        SDL_assert(false);
-    }
-}
@@ -1,62 +0,0 @@
-#pragma once
-
-#include "renderer.h"
-
-// Avoid X11 if SDL was built without it
-#ifndef SDL_VIDEO_DRIVER_X11
-#warning Unable to use libva-x11 without SDL support
-#undef HAVE_LIBVA_X11
-#endif
-
-// Avoid Wayland if SDL was built without it
-#ifndef SDL_VIDEO_DRIVER_WAYLAND
-#warning Unable to use libva-wayland without SDL support
-#undef HAVE_LIBVA_WAYLAND
-#endif
-
-extern "C" {
-#include <va/va.h>
-#ifdef HAVE_LIBVA_X11
-#include <va/va_x11.h>
-#endif
-#ifdef HAVE_LIBVA_WAYLAND
-#include <va/va_wayland.h>
-#endif
-#include <libavutil/hwcontext_vaapi.h>
-}
-
-class VAAPIRenderer : public IFFmpegRenderer
-{
-public:
-    VAAPIRenderer();
-    virtual ~VAAPIRenderer();
-    virtual bool initialize(SDL_Window* window,
-                            int videoFormat,
-                            int width,
-                            int height,
-                            int maxFps,
-                            bool enableVsync);
-    virtual bool prepareDecoderContext(AVCodecContext* context);
-    virtual void renderFrameAtVsync(AVFrame* frame);
-    virtual bool needsTestFrame();
-    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
-
-private:
-    int m_WindowSystem;
-    AVBufferRef* m_HwContext;
-
-#ifdef HAVE_LIBVA_X11
-    Window m_XWindow;
-#endif
-
-#ifdef HAVE_LIBVA_WAYLAND
-    struct wl_surface* m_WaylandSurface;
-    struct wl_display* m_WaylandDisplay;
-#endif
-
-    int m_VideoWidth;
-    int m_VideoHeight;
-    int m_DisplayWidth;
-    int m_DisplayHeight;
-};
@@ -1,357 +0,0 @@
-#include "vdpau.h"
-#include <streaming/streamutils.h>
-
-#include <SDL_syswm.h>
-
-#define BAIL_ON_FAIL(status, something) if ((status) != VDP_STATUS_OK) { \
-                                            SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, \
-                                                        #something " failed: %d", (status)); \
-                                            return false; \
-                                        }
-
-#define GET_PROC_ADDRESS(id, func) status = vdpauCtx->get_proc_address(m_Device, id, (void**)func); \
-                                   BAIL_ON_FAIL(status, id)
-
-const VdpRGBAFormat VDPAURenderer::k_OutputFormats[] = {
-    VDP_RGBA_FORMAT_B8G8R8A8,
-    VDP_RGBA_FORMAT_R8G8B8A8
-};
-
-VDPAURenderer::VDPAURenderer()
-    : m_HwContext(nullptr),
-      m_PresentationQueueTarget(0),
-      m_PresentationQueue(0),
-      m_VideoMixer(0),
-      m_NextSurfaceIndex(0)
-{
-    SDL_zero(m_OutputSurface);
-}
-
-VDPAURenderer::~VDPAURenderer()
-{
-    if (m_PresentationQueue != 0) {
-        m_VdpPresentationQueueDestroy(m_PresentationQueue);
-    }
-
-    if (m_VideoMixer != 0) {
-        m_VdpVideoMixerDestroy(m_VideoMixer);
-    }
-
-    if (m_PresentationQueueTarget != 0) {
-        m_VdpPresentationQueueTargetDestroy(m_PresentationQueueTarget);
-    }
-
-    for (int i = 0; i < OUTPUT_SURFACE_COUNT; i++) {
-        if (m_OutputSurface[i] != 0) {
-            m_VdpOutputSurfaceDestroy(m_OutputSurface[i]);
-        }
-    }
-
-    // This must be done last as it frees VDPAU context required to call
-    // the functions above.
-    if (m_HwContext != nullptr) {
-        av_buffer_unref(&m_HwContext);
-    }
-}
-
-bool VDPAURenderer::initialize(SDL_Window* window, int, int width, int height, int, bool)
-{
-    int err;
-    VdpStatus status;
-    SDL_SysWMinfo info;
-
-    m_VideoWidth = width;
-    m_VideoHeight = height;
-
-    err = av_hwdevice_ctx_create(&m_HwContext,
-                                 AV_HWDEVICE_TYPE_VDPAU,
-                                 nullptr, nullptr, 0);
-    if (err < 0) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Failed to create VDPAU context: %d",
-                     err);
-        return false;
-    }
-
-    AVHWDeviceContext* devCtx = (AVHWDeviceContext*)m_HwContext->data;
-    AVVDPAUDeviceContext* vdpauCtx = (AVVDPAUDeviceContext*)devCtx->hwctx;
-    m_Device = vdpauCtx->device;
-
-    GET_PROC_ADDRESS(VDP_FUNC_ID_GET_ERROR_STRING, &m_VdpGetErrorString);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY, &m_VdpPresentationQueueTargetDestroy);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_VIDEO_MIXER_CREATE, &m_VdpVideoMixerCreate);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_VIDEO_MIXER_DESTROY, &m_VdpVideoMixerDestroy);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_VIDEO_MIXER_RENDER, &m_VdpVideoMixerRender);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE, &m_VdpPresentationQueueCreate);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY, &m_VdpPresentationQueueDestroy);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY, &m_VdpPresentationQueueDisplay);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR, &m_VdpPresentationQueueSetBackgroundColor);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE, &m_VdpPresentationQueueBlockUntilSurfaceIdle);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_OUTPUT_SURFACE_CREATE, &m_VdpOutputSurfaceCreate);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY, &m_VdpOutputSurfaceDestroy);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES, &m_VdpOutputSurfaceQueryCapabilities);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS, &m_VdpVideoSurfaceGetParameters);
-    GET_PROC_ADDRESS(VDP_FUNC_ID_GET_INFORMATION_STRING, &m_VdpGetInformationString);
-
-    SDL_GetWindowSize(window, (int*)&m_DisplayWidth, (int*)&m_DisplayHeight);
-
-    SDL_VERSION(&info.version);
-
-    if (!SDL_GetWindowWMInfo(window, &info)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "SDL_GetWindowWMInfo() failed: %s",
-                     SDL_GetError());
-        return false;
-    }
-
-    SDL_assert(info.subsystem == SDL_SYSWM_X11);
-
-    if (info.subsystem == SDL_SYSWM_X11) {
-        GET_PROC_ADDRESS(VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11,
-                         &m_VdpPresentationQueueTargetCreateX11);
-        status = m_VdpPresentationQueueTargetCreateX11(m_Device,
-                                                       info.info.x11.window,
-                                                       &m_PresentationQueueTarget);
-        if (status != VDP_STATUS_OK) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "VdpPresentationQueueTargetCreateX11() failed: %s",
-                         m_VdpGetErrorString(status));
-            return false;
-        }
-    }
-    else if (info.subsystem == SDL_SYSWM_WAYLAND) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "VDPAU backend does not currently support Wayland");
-        return false;
-    }
-    else {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "Unsupported VDPAU rendering subsystem: %d",
-                     info.subsystem);
-        return false;
-    }
-
-    const char* infoString;
-    if (m_VdpGetInformationString(&infoString) == VDP_STATUS_OK) {
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "Driver: %s",
-                    infoString);
-    }
-
-    // Try our available output formats to find something the GPU supports
-    bool foundFormat = false;
-    for (int i = 0; i < OUTPUT_SURFACE_FORMAT_COUNT; i++) {
-        VdpBool supported;
-        uint32_t maxWidth, maxHeight;
-        status = m_VdpOutputSurfaceQueryCapabilities(m_Device, k_OutputFormats[i],
-                                                     &supported, &maxWidth, &maxHeight);
-        if (status != VDP_STATUS_OK) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "VdpOutputSurfaceQueryCapabilities() failed: %s",
-                         m_VdpGetErrorString(status));
-            return false;
-        }
-
-        if (supported) {
-            if (m_DisplayWidth <= maxWidth && m_DisplayHeight <= maxHeight) {
-                m_OutputSurfaceFormat = k_OutputFormats[i];
-                foundFormat = true;
-                break;
-            }
-            else  {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                            "Display size not within capabilities %dx%d vs %dx%d",
-                            m_DisplayWidth, m_DisplayWidth,
-                            maxWidth, maxHeight);
-            }
-        }
-    }
-
-    if (!foundFormat) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "No compatible output surface format found!");
-        return false;
-    }
-
-    // Create the output surfaces
-    for (int i = 0; i < OUTPUT_SURFACE_COUNT; i++) {
-        // It seems there's some lazy freeing going on or something in VDPAU
-        // because we can get VDP_STATUS_RESOURCES, then wait a bit and it'll
-        // complete without a problem.
-        int tries = 1;
-        do {
-            status = m_VdpOutputSurfaceCreate(m_Device, m_OutputSurfaceFormat,
-                                              m_DisplayWidth, m_DisplayHeight,
-                                              &m_OutputSurface[i]);
-            if (status != VDP_STATUS_OK) {
-                SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION,
-                            "VdpOutputSurfaceCreate() try #%d: %s",
-                            tries,
-                            m_VdpGetErrorString(status));
-                SDL_Delay(250);
-            }
-        } while (status == VDP_STATUS_RESOURCES && ++tries <= 10);
-
-        if (status != VDP_STATUS_OK) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "VdpOutputSurfaceCreate() failed: %s",
-                         m_VdpGetErrorString(status));
-            return false;
-        }
-    }
-
-    status = m_VdpPresentationQueueCreate(m_Device, m_PresentationQueueTarget,
-                                          &m_PresentationQueue);
-    if (status != VDP_STATUS_OK) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "VdpPresentationQueueCreate() failed: %s",
-                     m_VdpGetErrorString(status));
-        return false;
-    }
-
-    // Set the background to opaque black
-    VdpColor color = {0.0, 0.0, 0.0, 1.0};
-    m_VdpPresentationQueueSetBackgroundColor(m_PresentationQueue, &color);
-
-    return true;
-}
-
-bool VDPAURenderer::prepareDecoderContext(AVCodecContext* context)
-{
-    context->hw_device_ctx = av_buffer_ref(m_HwContext);
-
-    // Allow HEVC usage on VDPAU. This was disabled by FFmpeg due to
-    // GL interop issues, but we use VDPAU for rendering so it's no issue.
-    // https://github.com/FFmpeg/FFmpeg/commit/64ecb78b7179cab2dbdf835463104679dbb7c895
-    context->hwaccel_flags |= AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH;
-
-    // This flag is recommended due to hardware underreporting supported levels
-    context->hwaccel_flags |= AV_HWACCEL_FLAG_IGNORE_LEVEL;
-
-    SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                "Using VDPAU accelerated renderer");
-
-    return true;
-}
-
-bool VDPAURenderer::needsTestFrame()
-{
-    // We need a test frame to see if this VDPAU driver
-    // supports the profile used for streaming
-    return true;
-}
-
-int VDPAURenderer::getDecoderCapabilities()
-{
-    return 0;
-}
-
-IFFmpegRenderer::VSyncConstraint VDPAURenderer::getVsyncConstraint()
-{
-    return VSYNC_ANY;
-}
-
-void VDPAURenderer::renderFrameAtVsync(AVFrame* frame)
-{
-    VdpStatus status;
-    VdpVideoSurface videoSurface = (VdpVideoSurface)(uintptr_t)frame->data[3];
-
-    // This is safe without locking because this is always called on the main thread
-    VdpOutputSurface chosenSurface = m_OutputSurface[m_NextSurfaceIndex];
-    m_NextSurfaceIndex = (m_NextSurfaceIndex + 1) % OUTPUT_SURFACE_COUNT;
-
-    // We need to create the mixer on the fly, because we don't know the dimensions
-    // of our video surfaces in advance of decoding
-    if (m_VideoMixer == 0) {
-        VdpChromaType videoSurfaceChroma;
-        uint32_t videoSurfaceWidth, videoSurfaceHeight;
-        status = m_VdpVideoSurfaceGetParameters(videoSurface, &videoSurfaceChroma,
-                                                &videoSurfaceWidth, &videoSurfaceHeight);
-        if (status != VDP_STATUS_OK) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "VdpVideoSurfaceGetParameters() failed: %s",
-                         m_VdpGetErrorString(status));
-            return;
-        }
-
-        SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION,
-                    "VDPAU surface size: %dx%d",
-                    videoSurfaceWidth, videoSurfaceHeight);
-
-    #define PARAM_COUNT 3
-        const VdpVideoMixerParameter params[PARAM_COUNT] = {
-            VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH,
-            VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT,
-            VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE,
-        };
-        const void* const paramValues[PARAM_COUNT] = {
-            &videoSurfaceWidth,
-            &videoSurfaceHeight,
-            &videoSurfaceChroma,
-        };
-
-        status = m_VdpVideoMixerCreate(m_Device, 0, nullptr,
-                                       PARAM_COUNT, params, paramValues,
-                                       &m_VideoMixer);
-        if (status != VDP_STATUS_OK) {
-            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                         "VdpVideoMixerCreate() failed: %s",
-                         m_VdpGetErrorString(status));
-            return;
-        }
-    }
-
-    // Wait for this frame to be off the screen
-    VdpTime pts;
-    m_VdpPresentationQueueBlockUntilSurfaceIdle(m_PresentationQueue, chosenSurface, &pts);
-
-    VdpRect sourceRect, outputRect;
-
-    SDL_Rect src, dst;
-    src.x = src.y = 0;
-    src.w = m_VideoWidth;
-    src.h = m_VideoHeight;
-    dst.x = dst.y = 0;
-    dst.w = m_DisplayWidth;
-    dst.h = m_DisplayHeight;
-
-    StreamUtils::scaleSourceToDestinationSurface(&src, &dst);
-
-    outputRect.x0 = dst.x;
-    outputRect.x1 = dst.x + dst.w;
-    outputRect.y0 = dst.y;
-    outputRect.y1 = dst.y + dst.h;
-
-    sourceRect.x0 = sourceRect.y0 = 0;
-    sourceRect.x1 = m_VideoWidth;
-    sourceRect.y1 = m_VideoHeight;
-
-    // Render the next frame into the output surface
-    status = m_VdpVideoMixerRender(m_VideoMixer,
-                                   VDP_INVALID_HANDLE, nullptr,
-                                   VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME,
-                                   0, nullptr,
-                                   videoSurface,
-                                   0, nullptr,
-                                   &sourceRect,
-                                   chosenSurface,
-                                   &outputRect,
-                                   nullptr,
-                                   0,
-                                   nullptr);
-    if (status != VDP_STATUS_OK) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "VdpVideoMixerRender() failed: %s",
-                     m_VdpGetErrorString(status));
-        return;
-    }
-
-    // Queue the frame for display immediately
-    status = m_VdpPresentationQueueDisplay(m_PresentationQueue, chosenSurface, 0, 0, 0);
-    if (status != VDP_STATUS_OK) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                     "VdpPresentationQueueDisplay() failed: %s",
-                     m_VdpGetErrorString(status));
-        return;
-    }
-}
@@ -1,65 +0,0 @@
-#pragma once
-
-#include "renderer.h"
-
-extern "C" {
-#include <vdpau/vdpau.h>
-#include <vdpau/vdpau_x11.h>
-#include <libavutil/hwcontext_vdpau.h>
-}
-
-class VDPAURenderer : public IFFmpegRenderer
-{
-public:
-    VDPAURenderer();
-    virtual ~VDPAURenderer();
-    virtual bool initialize(SDL_Window* window,
-                            int videoFormat,
-                            int width,
-                            int height,
-                            int maxFps,
-                            bool enableVsync);
-    virtual bool prepareDecoderContext(AVCodecContext* context);
-    virtual void renderFrameAtVsync(AVFrame* frame);
-    virtual bool needsTestFrame();
-    virtual int getDecoderCapabilities();
-    virtual VSyncConstraint getVsyncConstraint();
-
-private:
-    uint32_t m_VideoWidth, m_VideoHeight;
-    uint32_t m_DisplayWidth, m_DisplayHeight;
-    AVBufferRef* m_HwContext;
-    VdpPresentationQueueTarget m_PresentationQueueTarget;
-    VdpPresentationQueue m_PresentationQueue;
-    VdpVideoMixer m_VideoMixer;
-    VdpRGBAFormat m_OutputSurfaceFormat;
-    VdpDevice m_Device;
-
-#define OUTPUT_SURFACE_COUNT 3
-    VdpOutputSurface m_OutputSurface[OUTPUT_SURFACE_COUNT];
-    int m_NextSurfaceIndex;
-
-#define OUTPUT_SURFACE_FORMAT_COUNT 2
-    static const VdpRGBAFormat k_OutputFormats[OUTPUT_SURFACE_FORMAT_COUNT];
-
-    VdpGetErrorString* m_VdpGetErrorString;
-    VdpPresentationQueueTargetDestroy* m_VdpPresentationQueueTargetDestroy;
-    VdpVideoMixerCreate* m_VdpVideoMixerCreate;
-    VdpVideoMixerDestroy* m_VdpVideoMixerDestroy;
-    VdpVideoMixerRender* m_VdpVideoMixerRender;
-    VdpPresentationQueueCreate* m_VdpPresentationQueueCreate;
-    VdpPresentationQueueDestroy* m_VdpPresentationQueueDestroy;
-    VdpPresentationQueueDisplay* m_VdpPresentationQueueDisplay;
-    VdpPresentationQueueSetBackgroundColor* m_VdpPresentationQueueSetBackgroundColor;
-    VdpPresentationQueueBlockUntilSurfaceIdle* m_VdpPresentationQueueBlockUntilSurfaceIdle;
-    VdpOutputSurfaceCreate* m_VdpOutputSurfaceCreate;
-    VdpOutputSurfaceDestroy* m_VdpOutputSurfaceDestroy;
-    VdpOutputSurfaceQueryCapabilities* m_VdpOutputSurfaceQueryCapabilities;
-    VdpVideoSurfaceGetParameters* m_VdpVideoSurfaceGetParameters;
-    VdpGetInformationString* m_VdpGetInformationString;
-
-    // X11 stuff
-    VdpPresentationQueueTargetCreateX11* m_VdpPresentationQueueTargetCreateX11;
-};
-
-
--- a/Show More
+++ b/Show More