Fix video packet corruption after error correction

Reduce CPU usage with Linux NVENC

.clang-format

@@ -0,0 +1,67 @@
+# Generated from CLion C/C++ Code Style settings
+BasedOnStyle: LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: DontAlign
+AlignConsecutiveAssignments: true
+AlignOperands: Align
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Always
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterReturnType: None
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterUnion: false
+  BeforeCatch: true
+  BeforeElse: true
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializers: BeforeColon
+BreakInheritanceList: BeforeColon
+ColumnLimit: 0
+CompactNamespaces: false
+ContinuationIndentWidth: 2
+IndentCaseLabels: false
+IndentPPDirectives: None
+IndentWidth: 2
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PointerAlignment: Right
+ReflowComments: false
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: Never
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth: 2
+Cpp11BracedListStyle: false
+UseTab: Never

.gitignore

@@ -6,4 +6,5 @@ cmake-build*
 *.swp
 *.kdev4
 
+.cache
 .idea

.gitmodules

@@ -1,9 +1,12 @@
 [submodule "moonlight-common-c"]
-	path = moonlight-common-c
+	path = third-party/moonlight-common-c
 	url = https://github.com/moonlight-stream/moonlight-common-c.git
 [submodule "Simple-Web-Server"]
-	path = Simple-Web-Server
+	path = third-party/Simple-Web-Server
 	url = https://github.com/loki-47-6F-64/Simple-Web-Server.git
 [submodule "ViGEmClient"]
-	path = ViGEmClient
+	path = third-party/ViGEmClient
 	url = https://github.com/ViGEm/ViGEmClient
+[submodule "third-party/miniupnp"]
+	path = third-party/miniupnp
+	url = https://github.com/miniupnp/miniupnp

CMakeLists.txt

@@ -4,7 +4,14 @@ project(Sunshine)
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR})
 
-add_subdirectory(Simple-Web-Server)
+add_subdirectory(third-party/Simple-Web-Server)
+
+set(UPNPC_BUILD_SHARED OFF CACHE BOOL "no shared libraries")
+set(UPNPC_BUILD_TESTS OFF CACHE BOOL "Don't build tests for miniupnpc")
+set(UPNPC_BUILD_SAMPLE OFF CACHE BOOL "Don't build samples for miniupnpc")
+set(UPNPC_NO_INSTALL ON CACHE BOOL "Don't install any libraries build for miniupnpc")
+add_subdirectory(third-party/miniupnp/miniupnpc)
+include_directories(third-party/miniupnp)
 
 if(WIN32)
 	# Ugly hack to compile with #include <qos2.h>
@@ -13,7 +20,7 @@ if(WIN32)
 		PQOS_FLOWID=UINT32*
 		QOS_NON_ADAPTIVE_FLOW=2)
 endif()
-add_subdirectory(moonlight-common-c/enet)
+add_subdirectory(third-party/moonlight-common-c/enet)
 
 find_package(Threads REQUIRED)
 find_package(OpenSSL REQUIRED)
@@ -35,24 +42,28 @@ if(WIN32)
 		set(SUNSHINE_PREPARED_BINARIES "${CMAKE_CURRENT_BINARY_DIR}/pre-compiled/windows")
 	endif()
 
+	add_compile_definitions(SUNSHINE_PLATFORM="windows")
 	add_subdirectory(tools) #This is temporary, only tools for Windows are needed, for now
 
 	list(APPEND SUNSHINE_DEFINITIONS APPS_JSON="apps_windows.json")
 
-	include_directories(ViGEmClient/include)
+	include_directories(third-party/ViGEmClient/include)
 
 	set(PLATFORM_TARGET_FILES
+		sunshine/platform/windows/publish.cpp
+		sunshine/platform/windows/misc.h
+		sunshine/platform/windows/misc.cpp
 		sunshine/platform/windows/input.cpp
 		sunshine/platform/windows/display.h
 		sunshine/platform/windows/display_base.cpp
 		sunshine/platform/windows/display_vram.cpp
 		sunshine/platform/windows/display_ram.cpp
 		sunshine/platform/windows/audio.cpp
-		ViGEmClient/src/ViGEmClient.cpp
-		ViGEmClient/include/ViGEm/Client.h
-		ViGEmClient/include/ViGEm/Common.h
-		ViGEmClient/include/ViGEm/Util.h
-		ViGEmClient/include/ViGEm/km/BusShared.h)
+		third-party/ViGEmClient/src/ViGEmClient.cpp
+		third-party/ViGEmClient/include/ViGEm/Client.h
+		third-party/ViGEmClient/include/ViGEm/Common.h
+		third-party/ViGEmClient/include/ViGEm/Util.h
+		third-party/ViGEmClient/include/ViGEm/km/BusShared.h)
 
 	set(OPENSSL_LIBRARIES
 		libssl.a
@@ -86,19 +97,34 @@ if(WIN32)
 		iphlpapi
 		d3d11 dxgi D3DCompiler
 		setupapi
+		dnsapi
 		)
 
-	set_source_files_properties(ViGEmClient/src/ViGEmClient.cpp PROPERTIES COMPILE_DEFINITIONS "UNICODE=1;ERROR_INVALID_DEVICE_OBJECT_PARAMETER=650")
-	set_source_files_properties(ViGEmClient/src/ViGEmClient.cpp PROPERTIES COMPILE_FLAGS "-Wno-unknown-pragmas -Wno-misleading-indentation -Wno-class-memaccess")
+	set_source_files_properties(third-party/ViGEmClient/src/ViGEmClient.cpp PROPERTIES COMPILE_DEFINITIONS "UNICODE=1;ERROR_INVALID_DEVICE_OBJECT_PARAMETER=650")
+	set_source_files_properties(third-party/ViGEmClient/src/ViGEmClient.cpp PROPERTIES COMPILE_FLAGS "-Wno-unknown-pragmas -Wno-misleading-indentation -Wno-class-memaccess")
 else()
+	add_compile_definitions(SUNSHINE_PLATFORM="linux")
 	list(APPEND SUNSHINE_DEFINITIONS APPS_JSON="apps_linux.json")
 
 	find_package(X11 REQUIRED)
 	find_package(FFmpeg REQUIRED)
+
 	set(PLATFORM_TARGET_FILES
+		sunshine/platform/linux/publish.cpp
+		sunshine/platform/linux/vaapi.h
+		sunshine/platform/linux/vaapi.cpp
+		sunshine/platform/linux/misc.h
+		sunshine/platform/linux/misc.cpp
 		sunshine/platform/linux/display.cpp
-		sunshine/platform/linux/input.cpp)
-	
+		sunshine/platform/linux/audio.cpp
+		sunshine/platform/linux/input.cpp
+		third-party/glad/src/egl.c
+		third-party/glad/src/gl.c
+		third-party/glad/include/EGL/eglplatform.h
+		third-party/glad/include/KHR/khrplatform.h
+		third-party/glad/include/glad/gl.h
+		third-party/glad/include/glad/egl.h)
+		
 	set(PLATFORM_LIBRARIES
 		Xfixes
 		Xtst
@@ -107,6 +133,7 @@ else()
 		xcb-xfixes
 		Xrandr
 		${X11_LIBRARIES}
+		dl
 		evdev
 		pulse
 		pulse-simple
@@ -114,25 +141,31 @@ else()
 	
 	set(PLATFORM_INCLUDE_DIRS
 		${X11_INCLUDE_DIR}
-		/usr/include/libevdev-1.0)
+		/usr/include/libevdev-1.0
+		third-party/glad/include)
 
 	if(NOT DEFINED SUNSHINE_EXECUTABLE_PATH)
-		set(SUNSHINE_EXECUTABLE_PATH "${CMAKE_CURRENT_BINARY_DIR}/sunshine")
+		set(SUNSHINE_EXECUTABLE_PATH "sunshine")
 	endif()
 	configure_file(gen-deb.in gen-deb @ONLY)
 	configure_file(sunshine.service.in sunshine.service @ONLY)
 endif()
 
+add_subdirectory(third-party/cbs)
+
 set(Boost_USE_STATIC_LIBS ON)
 find_package(Boost COMPONENTS log filesystem REQUIRED)
 
 set(SUNSHINE_TARGET_FILES
-	moonlight-common-c/reedsolomon/rs.c
-	moonlight-common-c/reedsolomon/rs.h
-	moonlight-common-c/src/Input.h
-	moonlight-common-c/src/Rtsp.h
-	moonlight-common-c/src/RtspParser.c
-	moonlight-common-c/src/Video.h
+	third-party/moonlight-common-c/reedsolomon/rs.c
+	third-party/moonlight-common-c/reedsolomon/rs.h
+	third-party/moonlight-common-c/src/Input.h
+	third-party/moonlight-common-c/src/Rtsp.h
+	third-party/moonlight-common-c/src/RtspParser.c
+	third-party/moonlight-common-c/src/Video.h
+	sunshine/upnp.cpp
+	sunshine/upnp.h
+	sunshine/cbs.cpp
 	sunshine/utility.h
 	sunshine/uuid.h
 	sunshine/config.h
@@ -143,6 +176,10 @@ set(SUNSHINE_TARGET_FILES
 	sunshine/crypto.h
 	sunshine/nvhttp.cpp
 	sunshine/nvhttp.h
+	sunshine/httpcommon.cpp
+	sunshine/httpcommon.h
+	sunshine/confighttp.cpp
+	sunshine/confighttp.h
 	sunshine/rtsp.cpp
 	sunshine/rtsp.h
 	sunshine/stream.cpp
@@ -166,11 +203,14 @@ set(SUNSHINE_TARGET_FILES
 	sunshine/round_robin.h
 	${PLATFORM_TARGET_FILES})
 
+set_source_files_properties(sunshine/upnp.cpp PROPERTIES COMPILE_FLAGS -Wno-pedantic)
+
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}
-  ${CMAKE_CURRENT_SOURCE_DIR}/Simple-Web-Server
-  ${CMAKE_CURRENT_SOURCE_DIR}/moonlight-common-c/enet/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/moonlight-common-c/reedsolomon
+  ${CMAKE_CURRENT_SOURCE_DIR}/third-party
+  ${CMAKE_CURRENT_SOURCE_DIR}/third-party/cbs/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/third-party/moonlight-common-c/enet/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/third-party/moonlight-common-c/reedsolomon
   ${FFMPEG_INCLUDE_DIRS}
   ${PLATFORM_INCLUDE_DIRS}
 )
@@ -190,7 +230,12 @@ if(NOT SUNSHINE_ASSETS_DIR)
 	set(SUNSHINE_ASSETS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/assets")
 endif()
 
+list(APPEND CBS_EXTERNAL_LIBRARIES
+	cbs)
+
 list(APPEND SUNSHINE_EXTERNAL_LIBRARIES
+		libminiupnpc-static
+		${CBS_EXTERNAL_LIBRARIES}
 		${CMAKE_THREAD_LIBS_INIT}
 		stdc++fs
 		enet

README.md

@@ -1,6 +1,9 @@
 # Introduction
 Sunshine is a Gamestream host for Moonlight
 
+[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/cgrtw2g3fq9b0b70/branch/master?svg=true)](https://ci.appveyor.com/project/loki-47-6F-64/sunshine/branch/master)
+[![Downloads](https://img.shields.io/github/downloads/Loki-47-6F-64/sunshine/total)](https://github.com/Loki-47-6F-64/sunshine/releases)
+
 - [Building](README.md#building)
 - [Credits](README.md#credits)
 
@@ -14,7 +17,7 @@ Sunshine is a Gamestream host for Moonlight
 Ubuntu 20.04:
 Install the following
 ```
-sudo apt install cmake libssl-dev libavdevice-dev libboost-thread-dev libboost-filesystem-dev libboost-log-dev libpulse-dev libopus-dev libxtst-dev libx11-dev libxfixes-dev libevdev-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev
+sudo apt install cmake libssl-dev libavdevice-dev libboost-thread-dev libboost-filesystem-dev libboost-log-dev libpulse-dev libopus-dev libxtst-dev libx11-dev libxrandr-dev libxfixes-dev libevdev-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev
 ```
 
 ### Compilation:
@@ -32,7 +35,7 @@ sunshine needs access to uinput to create mouse and gamepad events:
 	- Run the following command: 
 	`nano /etc/udev/rules.d/85-sunshine-input.rules`
 	- Input the following contents:
-	`KERNEL=="uinput", GROUP="input", mode="0660"`
+	`KERNEL=="uinput", GROUP="input", MODE="0660"`
 	- Save the file and exit
 		1. `CTRL+X` to start exit
 		2. `Y` to save modifications
@@ -54,7 +57,7 @@ sunshine needs access to uinput to create mouse and gamepad events:
 	- `groups $USER`
 	
 - If Sunshine sends audio from the microphone instead of the speaker, try the following steps:
- 	1. pacmd list-sources | grep "name:"
+ 	1. `$ pacmd list-sources | grep "name:"` or `$ pactl info | grep Source` if running pipewire.
 	2. Copy the name to the configuration option "audio_sink"
 	3. restart sunshine
 
@@ -62,13 +65,13 @@ sunshine needs access to uinput to create mouse and gamepad events:
 
 ### Requirements:
 
-	mingw-w64-x86_64-openssl mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-opus mingw-w64-x86_64-x265 mingw-w64-x86_64-boost git yasm nasm diffutils make
+	mingw-w64-x86_64-openssl mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-opus mingw-w64-x86_64-x265 mingw-w64-x86_64-boost git mingw-w64-x86_64-make
 
 ### Compilation:
 - `git clone https://github.com/loki-47-6F-64/sunshine.git --recursive`
 - `cd sunshine && mkdir build && cd build`
 - `cmake -G"Unix Makefiles" ..`
-- `make`
+- `mingw32-make`
 
 ### Setup:
 - **OPTIONAL** Gamepad support: Download and run 'ViGEmBus_Setup_1.16.116.exe' from [https://github.com/ViGEm/ViGEmBus/releases]
@@ -79,11 +82,14 @@ sunshine needs access to uinput to create mouse and gamepad events:
 
 ## Usage:
 - run "sunshine path/to/sunshine.conf"
+- If running for the first time, make sure to note the username and password Sunshine showed to you, since you **cannot get back later**!
 - In Moonlight: Add PC manually
-- When Moonlight request you insert the correct pin on sunshine, either:
-	- Type in the URL bar of your browser: `xxx.xxx.xxx.xxx:47989/pin/####`
-	- `wget xxx.xxx.xxx.xxx:47989/pin/####` 
-	  - The x's are the IP of your instance, `####` is the pin
+- When Moonlight request you insert the correct pin on sunshine:
+	- Type in the URL bar of your browser: `https://xxx.xxx.xxx.xxx:47990` where `xxx.xxx.xxx.xxx` is the IP address of your computer
+	- Ignore any warning given by your browser about "insecure website"
+	- Type in the username and password shown the first time you run Sunshine
+	- Go to "PIN" in the Header
+	- Type in your PIN and press Enter, you should get a Success Message
 - Click on one of the Applications listed
 - Have fun :)
 
@@ -102,8 +108,10 @@ sunshine needs access to uinput to create mouse and gamepad events:
 - [Simple-Web-Server](https://gitlab.com/eidheim/Simple-Web-Server)
 - [Moonlight](https://github.com/moonlight-stream)
 - [Looking-Glass](https://github.com/gnif/LookingGlass) (For showing me how to properly capture frames on Windows, saving me a lot of time :)
+- [Eretik](http://eretik.omegahg.com/) (For creating PolicyConfig.h, allowing me to change the default audio device on Windows programmatically)
 
 ## Application List:
+**Note:** You can change the Application List in the "Apps" section of the User Interface `https://xxx.xxx.xxx.xxx:47990/`
 - You can use Environment variables in place of values
 	- $(HOME) will be replaced by the value of $HOME
 	- $$ will be replaced by $ --> $$(HOME) will be replaced by $(HOME)

appveyor.yml

@@ -9,7 +9,7 @@ environment:
 
 install:
   - sh: sudo apt update --ignore-missing
-  - sh: sudo apt install -y build-essential fakeroot gcc-10 g++-10 cmake libssl-dev libavdevice-dev libboost-thread-dev libboost-filesystem-dev libboost-log-dev libpulse-dev libopus-dev libxtst-dev libx11-dev libxrandr-dev libxfixes-dev libevdev-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev
+  - sh: sudo apt install -y build-essential fakeroot gcc-10 g++-10 cmake libssl-dev libavdevice-dev libboost-thread-dev libboost-filesystem-dev libboost-log-dev libpulse-dev libopus-dev libxtst-dev libx11-dev libxrandr-dev libxfixes-dev libevdev-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev 
   - cmd: C:\msys64\usr\bin\bash -lc "pacman --needed --noconfirm -S mingw-w64-x86_64-openssl mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-opus mingw-w64-x86_64-x265 mingw-w64-x86_64-boost git yasm nasm diffutils make"
 
 before_build:

assets/shaders/opengl/ConvertUV.frag

@@ -0,0 +1,35 @@
+#version 300 es
+
+#ifdef GL_ES
+precision lowp float;
+#endif
+
+uniform sampler2D image;
+
+layout(shared) uniform ColorMatrix {
+  vec4 color_vec_y;
+  vec4 color_vec_u;
+  vec4 color_vec_v;
+  vec2 range_y;
+  vec2 range_uv;
+};
+
+in vec3 uuv;
+layout(location = 0) out vec2 color;
+
+//--------------------------------------------------------------------------------------
+// Pixel Shader
+//--------------------------------------------------------------------------------------
+void main() {
+  vec3 rgb_left  = texture(image, uuv.xz).rgb;
+  vec3 rgb_right = texture(image, uuv.yz).rgb;
+  vec3 rgb       = (rgb_left + rgb_right) * 0.5;
+
+  float u = dot(color_vec_u.xyz, rgb) + color_vec_u.w;
+  float v = dot(color_vec_v.xyz, rgb) + color_vec_v.w;
+
+  u = u * range_uv.x + range_uv.y;
+  v = v * range_uv.x + range_uv.y;
+
+  color = vec2(u, v * 224.0f / 256.0f + 0.0625);
+}

assets/shaders/opengl/ConvertUV.vert

@@ -0,0 +1,27 @@
+#version 300 es
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+uniform float width_i;
+
+out vec3 uuv;
+//--------------------------------------------------------------------------------------
+// Vertex Shader
+//--------------------------------------------------------------------------------------
+void main()
+{
+	float idHigh = float(gl_VertexID >> 1);
+	float idLow = float(gl_VertexID & int(1));
+
+	float x = idHigh * 4.0 - 1.0;
+	float y = idLow * 4.0 - 1.0;
+
+	float u_right = idHigh * 2.0;
+	float u_left = u_right - width_i;
+	float v = idLow * 2.0;
+
+	uuv = vec3(u_left, u_right, v);
+	gl_Position = vec4(x, y, 0.0, 1.0);
+}

assets/shaders/opengl/ConvertY.frag

@@ -0,0 +1,26 @@
+#version 300 es
+
+#ifdef GL_ES
+precision lowp float;
+#endif
+
+uniform sampler2D image;
+
+layout(shared) uniform ColorMatrix {
+  vec4 color_vec_y;
+  vec4 color_vec_u;
+  vec4 color_vec_v;
+  vec2 range_y;
+  vec2 range_uv;
+};
+
+in vec2 tex;
+layout(location = 0) out float color;
+
+void main()
+{
+	vec3 rgb = texture(image, tex).rgb;
+	float y = dot(color_vec_y.xyz, rgb);
+
+	color = y * range_y.x + range_y.y;
+}

assets/shaders/opengl/Scene.frag

@@ -0,0 +1,14 @@
+#version 300 es
+
+#ifdef GL_ES
+precision lowp float;
+#endif
+
+uniform sampler2D image;
+
+in vec2 tex;
+layout(location = 0) out vec4 color;
+void main()
+{
+	color = texture(image, tex);
+}

assets/shaders/opengl/Scene.vert

@@ -0,0 +1,22 @@
+#version 300 es
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+out vec2 tex;
+
+void main()
+{
+	float idHigh = float(gl_VertexID >> 1);
+	float idLow = float(gl_VertexID & int(1));
+
+	float x = idHigh * 4.0 - 1.0;
+	float y = idLow * 4.0 - 1.0;
+
+	float u = idHigh * 2.0;
+	float v = idLow * 2.0;
+
+	gl_Position = vec4(x, y, 0.0, 1.0);
+	tex = vec2(u, v);
+}

assets/sunshine.conf

@@ -1,209 +1,271 @@
-# If no external IP address is given, the local IP address is used
-# external_ip = 123.456.789.12
-
-# The private key must be 2048 bits
-# pkey = /dir/pkey.pem
-
-# The certificate must be signed with a 2048 bit key
-# cert = /dir/cert.pem
-
-# The name displayed by Moonlight
-# If not specified, the PC's hostname is used
-# sunshine_name = Sunshine
-
-# The minimum log level printed to standard out
-#
-# none -> no logs are printed to standard out
-#
-# verbose = [0]
-# debug   = [1]
-# info    = [2]
-# warning = [3]
-# error   = [4]
-# fatal   = [5]
-# none    = [6]
-#
-# min_log_level = info
-
-# The origin of the remote endpoint address that is not denied for HTTP method /pin
-# Could be any of the following values:
-#   pc|lan|wan
-#     pc: Only localhost may access /pin
-#     lan: Only those in LAN may access /pin
-#     wan: Anyone may access /pin
-#
-# origin_pin_allowed = lan
-
-# The file where current state of Sunshine is stored
-# file_state = sunshine_state.json
-
-# How long to wait in milliseconds for data from moonlight before shutting down the stream
-# ping_timeout = 2000
-
-# The file where configuration for the different applications that Sunshine can run during a stream
-# file_apps = apps.json
-
-# How much error correcting packets must be send for every video
-# This is just some random number, don't know the optimal value
-# The higher fec_percentage, the lower space for the actual data to send per frame there is
-#
-# The value must be greater than 0 and lower than or equal to 100
-# fec_percentage = 10
-
-# When multicasting, it could be usefull to have different configurations for each connected Client.
-# For example:
-# 	Clients connected through WAN and LAN have different bitrate contstraints.
-# 	Decoders may require different settings for color
-#
-# Unlike simply broadcasting to multiple Client, this will generate distinct video streams.
-# Note, CPU usage increases for each distinct video stream generated
-# channels = 1
-
-# The back/select button on the controller
-# On the Shield, the home and powerbutton are not passed to Moonlight
-# If, after the timeout, the back button is still pressed down, Home/Guide button press is emulated.
-# If back_button_timeout < 0, then the Home/Guide button will not be emulated
-# back_button_timeout = 2000
-
-# !! Windows only !!
-# Control how fast keys will repeat themselves
-# The initial delay in milliseconds before repeating keys
-# key_repeat_delay = 500
-#
-# How often keys repeat every second
-# This configurable option supports decimals
-# key_repeat_frequency = 24.9
-
-# The name of the audio sink used for Audio Loopback
-# If you do not specify this variable, pulseaudio will select the default monitor device.
-#
-# You can find the name of the audio sink using the following command:
-# !! Linux only !!
-# pacmd list-sources | grep "name:"
-# audio_sink = alsa_output.pci-0000_09_00.3.analog-stereo.monitor
-#
-# !! Windows only !!
-# tools\audio-info.exe
-# audio_sink = {0.0.0.00000000}.{FD47D9CC-4218-4135-9CE2-0C195C87405B}
-
-# !! Windows only !!
-# You can select the video card you want to stream:
-# The appropriate values can be found using the following command:
-# tools\dxgi-info.exe
-# adapter_name = Radeon RX 580 Series
-# output_name  = \\.\DISPLAY1
-
-# !! Linux only !!
-# Set the display number to stream. I have no idea how they are numbered. They start from 1, usually.
-# output_name = 1
-
-###############################################
-# FFmpeg software encoding parameters
-# Honestly, I have no idea what the optimal values would be.
-# Play around with this :)
-
-# Constant Rate Factor. Between 1 and 52. It allows QP to go up during motion and down with still image, resulting in constant perceived quality
-# Higher value means more compression, but less quality
-# If crf == 0, then use QP directly instead
-# crf = 0
-
-# Quantitization Parameter
-# Higher value means more compression, but less quality
-# If crf != 0, then this parameter is ignored
-# qp = 28
-
-# Minimum number of threads used by ffmpeg to encode the video.
-# Increasing the value slightly reduces encoding efficiency, but the tradeoff is usually
-# worth it to gain the use of more CPU cores for encoding. The ideal value is the lowest
-# value that can reliably encode at your desired streaming settings on your hardware.
-# min_threads = 1
-
-# Allows the client to request HEVC Main or HEVC Main10 video streams.
-# HEVC is more CPU-intensive to encode, so enabling this may reduce performance when using software encoding.
-# If set to 0 (default), Sunshine will specify support for HEVC based on encoder
-# If set to 1, Sunshine will not advertise support for HEVC
-# If set to 2, Sunshine will advertise support for HEVC Main profile
-# If set to 3, Sunshine will advertise support for HEVC Main and Main10 (HDR) profiles
-# hevc_mode = 2
-
-# Force a specific encoder, otherwise Sunshine will use the first encoder that is available
-# supported encoders:
-#   nvenc
-#   amdvce # NOTE: alpha stage. The cursor is not yet displayed
-#   software
-#
-# encoder = nvenc
-##################################### Software #####################################
-# See x264 --fullhelp for the different presets
-# sw_preset  = superfast
-# sw_tune    = zerolatency
-#
-
-##################################### NVENC #####################################
-###### presets ###########
-# default
-# hp     -- high performance
-# hq     -- high quality
-# slow   -- hq 2 passes
-# medium -- hq 1 pass
-# fast   -- hp 1 pass
-# bd
-# ll     -- low latency
-# llhq
-# llhp
-# lossless
-# losslesshp
-##########################
-# nv_preset = llhq
-#
-####### rate control #####
-# auto      -- let ffmpeg decide rate control
-# constqp   -- constant QP mode
-# vbr       -- variable bitrate
-# cbr       -- constant bitrate
-# cbr_hq    -- cbr high quality
-# cbr_ld_hq -- cbr low delay high quality
-# vbr_hq    -- vbr high quality
-##########################
-# nv_rc = auto
-
-###### h264 entropy ######
-# auto -- let ffmpeg nvenc decide the entropy encoding
-# cabac
-# cavlc
-##########################
-# nv_coder = auto
-
-##################################### AMD #####################################
-###### presets ###########
-# default
-# speed
-# balanced
-##########################
-# amd_preset = balanced
-#
-####### rate control #####
-# auto        -- let ffmpeg decide rate control
-# constqp     -- constant QP mode
-# vbr_latency -- Latency Constrained Variable Bitrate
-# vbr_peak    -- Peak Contrained Variable Bitrate
-# cbr         -- constant bitrate
-##########################
-# amd_rc = auto
-
-###### h264 entropy ######
-# auto -- let ffmpeg nvenc decide the entropy encoding
-# cabac
-# cavlc
-##########################
-# amd_coder = auto
-
-##############################################
-# Some configurable parameters, are merely toggles for specific features
-# The first occurrence turns it on, the second occurence turns it off, the third occurence turns it on again, etc, etc
-# Here, you change the default state of any flag
-#
-# To set the initial state of flags -0 and -1 to on, set the following flags:
-# flags = 01
-#
-# See: sunshine --help for all options under the header: flags
+# If no external IP address is given, Sunshine will attempt to automatically detect external ip-address
+# external_ip = 123.456.789.12
+
+# Set the familly of ports used by Sunshine
+# port = 47989
+
+# The private key must be 2048 bits
+# pkey = /dir/pkey.pem
+
+# The certificate must be signed with a 2048 bit key
+# cert = /dir/cert.pem
+
+# The name displayed by Moonlight
+# If not specified, the PC's hostname is used
+# sunshine_name = Sunshine
+
+# The minimum log level printed to standard out
+#
+# none -> no logs are printed to standard out
+#
+# verbose = [0]
+# debug   = [1]
+# info    = [2]
+# warning = [3]
+# error   = [4]
+# fatal   = [5]
+# none    = [6]
+#
+# min_log_level = info
+
+# The origin of the remote endpoint address that is not denied for HTTP method /pin
+# Could be any of the following values:
+#   pc|lan|wan
+#     pc: Only localhost may access /pin
+#     lan: Only those in LAN may access /pin
+#     wan: Anyone may access /pin
+#
+# origin_pin_allowed = pc
+
+# The origin of the remote endpoint address that is not denied for HTTPS Web UI
+# Could be any of the following values:
+#   pc|lan|wan
+#     pc: Only localhost may access the Web Manager
+#     lan: Only those in LAN may access the Web Manager
+#     wan: Anyone may access the Web Manager
+#
+# origin_web_ui_allowed = lan
+
+# If UPnP is enabled, Sunshine will attempt to open ports for streaming over the internet
+# To enable it, uncomment the following line:
+# upnp = on
+
+# The file where current state of Sunshine is stored
+# file_state = sunshine_state.json
+
+# The file where user credentials for the UI are stored
+# By default, credentials are stored in `file_state`
+# credentials_file = sunshine_state.json
+
+# The display modes advertised by Sunshine
+#
+# Some versions of Moonlight, such as Moonlight-nx (Switch),
+# rely on this list to ensure that the requested resolutions and fps
+# are supported.
+#
+# fps = [10, 30, 60, 90, 120]
+# resolutions = [
+#     352x240,
+#     480x360,
+#     858x480,
+#     1280x720,
+#     1920x1080,
+#     2560x1080,
+#     3440x1440,
+#     1920x1200,
+#     3860x2160,
+#     3840x1600,
+# ]
+
+# How long to wait in milliseconds for data from moonlight before shutting down the stream
+# ping_timeout = 10000
+
+# The file where configuration for the different applications that Sunshine can run during a stream
+# file_apps = apps.json
+
+# Percentage of error correcting packets per data packet in each video frame
+# Higher values can correct for more network packet loss, but at the cost of increasing bandwidth usage
+# The default value of 20 is what GeForce Experience uses
+#
+# The value must be greater than 0 and lower than or equal to 255
+# fec_percentage = 20
+
+# When multicasting, it could be usefull to have different configurations for each connected Client.
+# For example:
+# 	Clients connected through WAN and LAN have different bitrate contstraints.
+# 	Decoders may require different settings for color
+#
+# Unlike simply broadcasting to multiple Client, this will generate distinct video streams.
+# Note, CPU usage increases for each distinct video stream generated
+# channels = 1
+
+# The back/select button on the controller
+# On the Shield, the home and powerbutton are not passed to Moonlight
+# If, after the timeout, the back button is still pressed down, Home/Guide button press is emulated.
+# If back_button_timeout < 0, then the Home/Guide button will not be emulated
+# back_button_timeout = 2000
+
+# !! Windows only !!
+# Control how fast keys will repeat themselves
+# The initial delay in milliseconds before repeating keys
+# key_repeat_delay = 500
+#
+# How often keys repeat every second
+# This configurable option supports decimals
+# key_repeat_frequency = 24.9
+
+# The name of the audio sink used for Audio Loopback
+# If you do not specify this variable, pulseaudio will select the default monitor device.
+#
+# You can find the name of the audio sink using the following command:
+# !! Linux only !!
+# pacmd list-sinks | grep "name:" if running vanilla pulseaudio
+# pactl info | grep Source` if running pipewire
+# audio_sink = alsa_output.pci-0000_09_00.3.analog-stereo
+#
+# !! Windows only !!
+# tools\audio-info.exe
+# audio_sink   = {0.0.0.00000000}.{FD47D9CC-4218-4135-9CE2-0C195C87405B}
+#
+# The virtual sink, is the audio device that's virtual (Like Steam Streaming Speakers), it allows Sunshine
+# to stream audio, while muting the speakers.
+# virtual_sink = {0.0.0.00000000}.{8edba70c-1125-467c-b89c-15da389bc1d4}
+
+# !! Windows only !!
+# You can select the video card you want to stream:
+# The appropriate values can be found using the following command:
+# tools\dxgi-info.exe
+# adapter_name = Radeon RX 580 Series
+# output_name  = \\.\DISPLAY1
+
+# !! Linux only !!
+# Set the display number to stream.
+# You can find them by the following command:
+# xrandr --listmonitors
+# Example output: "0: +HDMI-1 1920/518x1200/324+0+0  HDMI-1"
+#                  ^ <-- You need this.
+# output_name = 0
+
+###############################################
+# FFmpeg software encoding parameters
+# Honestly, I have no idea what the optimal values would be.
+# Play around with this :)
+
+# Constant Rate Factor. Between 1 and 52. It allows QP to go up during motion and down with still image, resulting in constant perceived quality
+# Higher value means more compression, but less quality
+# If crf == 0, then use QP directly instead
+# crf = 0
+
+# Quantitization Parameter
+# Higher value means more compression, but less quality
+# If crf != 0, then this parameter is ignored
+# qp = 28
+
+# Minimum number of threads used by ffmpeg to encode the video.
+# Increasing the value slightly reduces encoding efficiency, but the tradeoff is usually
+# worth it to gain the use of more CPU cores for encoding. The ideal value is the lowest
+# value that can reliably encode at your desired streaming settings on your hardware.
+# min_threads = 1
+
+# Allows the client to request HEVC Main or HEVC Main10 video streams.
+# HEVC is more CPU-intensive to encode, so enabling this may reduce performance when using software encoding.
+# If set to 0 (default), Sunshine will specify support for HEVC based on encoder
+# If set to 1, Sunshine will not advertise support for HEVC
+# If set to 2, Sunshine will advertise support for HEVC Main profile
+# If set to 3, Sunshine will advertise support for HEVC Main and Main10 (HDR) profiles
+# hevc_mode = 2
+
+# Force a specific encoder, otherwise Sunshine will use the first encoder that is available
+# supported encoders:
+#   nvenc
+#   amdvce # NOTE: alpha stage. The cursor is not yet displayed
+#   software
+#
+# encoder = nvenc
+##################################### Software #####################################
+# See x264 --fullhelp for the different presets
+# sw_preset  = superfast
+# sw_tune    = zerolatency
+#
+
+##################################### NVENC #####################################
+###### presets ###########
+# default
+# hp     -- high performance
+# hq     -- high quality
+# slow   -- hq 2 passes
+# medium -- hq 1 pass
+# fast   -- hp 1 pass
+# bd
+# ll     -- low latency
+# llhq
+# llhp
+# lossless
+# losslesshp
+##########################
+# nv_preset = llhq
+#
+####### rate control #####
+# auto      -- let ffmpeg decide rate control
+# constqp   -- constant QP mode
+# vbr       -- variable bitrate
+# cbr       -- constant bitrate
+# cbr_hq    -- cbr high quality
+# cbr_ld_hq -- cbr low delay high quality
+# vbr_hq    -- vbr high quality
+##########################
+# nv_rc = auto
+
+###### h264 entropy ######
+# auto -- let ffmpeg nvenc decide the entropy encoding
+# cabac
+# cavlc
+##########################
+# nv_coder = auto
+
+##################################### AMD #####################################
+###### presets ###########
+# default
+# speed
+# balanced
+##########################
+# amd_preset = balanced
+#
+####### rate control #####
+# auto        -- let ffmpeg decide rate control
+# constqp     -- constant QP mode
+# vbr_latency -- Latency Constrained Variable Bitrate
+# vbr_peak    -- Peak Contrained Variable Bitrate
+# cbr         -- constant bitrate
+##########################
+# amd_rc = auto
+
+###### h264 entropy ######
+# auto -- let ffmpeg nvenc decide the entropy encoding
+# cabac
+# cavlc
+##########################
+# amd_coder = auto
+
+#################################### VAAPI ###################################
+####### adapter ##########
+# Unlike with `amdvce` and `nvenc`, it doesn't matter if video encoding is done
+# on a different GPU.
+# Run the following commands:
+# 1. ls /dev/dri/renderD*
+#   to find all devices capable of VAAPI
+# 2. vainfo --display drm --device /dev/dri/renderD129 | grep -E "((VAProfileH264High|VAProfileHEVCMain|VAProfileHEVCMain10).*VAEntrypointEncSlice)|Driver version"
+#   Lists the name and capabilities of the device.
+#   To be supported by Sunshine, it needs to have at the very minimum:
+#       VAProfileH264High   : VAEntrypointEncSlice
+# adapter_name = /dev/dri/renderD128
+
+##############################################
+# Some configurable parameters, are merely toggles for specific features
+# The first occurrence turns it on, the second occurence turns it off, the third occurence turns it on again, etc, etc
+# Here, you change the default state of any flag
+#
+# To set the initial state of flags -0 and -1 to on, set the following flags:
+# flags = 012
+#
+# See: sunshine --help for all options under the header: flags

assets/web/apps.html

@@ -0,0 +1,162 @@
+<div id="app" class="container">
+  <div class="my-4">
+    <h1>Applications</h1>
+    <div>Applications are refreshed only when Client is restarted</div>
+  </div>
+  <div class="card p-4">
+    <table class="table">
+      <thead>
+        <tr>
+          <th scope="col">Name</th>
+          <th scope="col">Actions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="(app,i) in apps" :key="i">
+          <td>{{app.name}}</td>
+          <td><button class="btn btn-primary" @click="editApp(i)">Edit</button>
+            <button class="btn btn-danger" @click="showDeleteForm(i)">Delete</button>
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </div>
+  <div class="edit-form card mt-2" v-if="showEditForm">
+    <div class="p-4">
+      <!--name-->
+      <div class="mb-3">
+        <label for="appName" class="form-label">Application Name</label>
+        <input type="text" class="form-control" id="appName" aria-describedby="appNameHelp" v-model="editForm.name">
+        <div id="appNameHelp" class="form-text">Application Name, as shown on Moonlight</div>
+      </div>
+      <!--output-->
+      <div class="mb-3">
+        <label for="appOutput" class="form-label">Output</label>
+        <input type="text" class="form-control  monospace" id="appOutput" aria-describedby="appOutputHelp"
+          v-model="editForm.output">
+        <div id="appOutputHelp" class="form-text">The file where the output of the command is stored, if it is not
+          specified, the output is ignored</div>
+      </div>
+      <!--prep-cmd-->
+      <div class="mb-3 d-flex flex-column">
+        <label for="appName" class="form-label">Command Preparations</label>
+        <div class="form-text">A list of commands to be run before/after the application. <br> If any of the
+          prep-commands fail, starting the application is aborted</div>
+        <table v-if="editForm['prep-cmd'].length > 0">
+          <thead>
+            <th class="precmd-head">Do</th>
+            <th class="precmd-head">Undo</th>
+            <th style="width: 48px;"></th>
+          </thead>
+          <tbody>
+            <tr v-for="(c,i) in editForm['prep-cmd']">
+              <td><input type="text" class="form-control monospace" v-model="c.do"></td>
+              <td><input type="text" class="form-control monospace" v-model="c.undo"></td>
+              <td><button class="btn btn-danger" @click="editForm['prep-cmd'].splice(i,1)">&times;</button></td>
+            </tr>
+          </tbody>
+        </table>
+        <button class="mt-2 btn btn-success" style="margin: 0 auto;" @click="addPrepCmd">&plus; Add</button>
+      </div>
+      <!--detatched-->
+      <div class="mb-3">
+        <label for="appName" class="form-label">Detached Commands</label>
+        <div v-for="(c,i) in editForm.detached" class="d-flex justify-content-between my-2">
+          <pre>{{c}}</pre>
+          <button class="btn btn-danger mx-2" @click="editForm.detached.splice(i,1)">&times;</button>
+        </div>
+        <div class="d-flex justify-content-between">
+          <input type="text" class="form-control monospace" v-model="detachedCmd">
+          <button class="btn btn-success mx-2" @click="editForm.detached.push(detachedCmd);detachedCmd = '';">+</button>
+        </div>
+        <div class="form-text">A list of commands to be run and forgotten about</div>
+      </div>
+      <!--command-->
+      <div class="mb-3">
+        <label for="appCmd" class="form-label">Command</label>
+        <input type="text" class="form-control monospace" id="appCmd" aria-describedby="appCmdHelp"
+          v-model="editForm.cmd">
+        <div id="appCmdHelp" class="form-text">The main application, if it is not specified, a processs is started that
+          sleeps indefinitely</div>
+      </div>
+      <!--buttons-->
+      <div class="d-flex">
+        <button @click="showEditForm = false" class="btn btn-secondary m-2">Cancel</button>
+        <button class="btn btn-primary m-2" @click="save">Save</button>
+      </div>
+    </div>
+  </div>
+  <div class="mt-2" v-else>
+    <button class="btn btn-primary" @click="newApp">+ Add New</button>
+  </div>
+</div>
+
+<script>
+  new Vue({
+    el: '#app',
+    data() {
+      return {
+        apps: [],
+        showEditForm: false,
+        editForm: null,
+        detachedCmd: '',
+      }
+    },
+    created() {
+      fetch("/api/apps").then(r => r.json()).then((r) => {
+        console.log(r);
+        this.apps = r.apps;
+      })
+    },
+    methods: {
+      newApp() {
+        this.editForm = {
+          name: '',
+          output: '',
+          cmd: [],
+          index: -1,
+          "prep-cmd": [],
+          "detached": []
+        };
+        this.editForm.index = -1;
+        this.showEditForm = true;
+      },
+      editApp(id) {
+        this.editForm = JSON.parse(JSON.stringify(this.apps[id]));
+        this.$set(this.editForm, "index", id);
+        if (this.editForm["prep-cmd"] === undefined) this.$set(this.editForm, "prep-cmd", []);
+        if (this.editForm["detached"] === undefined) this.$set(this.editForm, "detached", []);
+        this.showEditForm = true;
+      },
+      showDeleteForm(id) {
+        let resp = confirm("Are you sure to delete " + this.apps[id].name + "?");
+        if (resp) {
+          fetch("/api/apps/" + id, { method: "DELETE" }).then((r) => {
+            if (r.status == 200) document.location.reload();
+          });
+        }
+      },
+      addPrepCmd() {
+        this.editForm['prep-cmd'].push({
+          do: '',
+          undo: '',
+        });
+      },
+      save() {
+        fetch("/api/apps", { method: "POST", body: JSON.stringify(this.editForm) }).then((r) => {
+          if (r.status == 200) document.location.reload();
+        });
+      }
+    }
+  })
+</script>
+
+<style>
+  .precmd-head {
+    width: 200px;
+  }
+
+  .monospace {
+    font-family: monospace;
+  }
+</style>

assets/web/clients.html

@@ -0,0 +1,3 @@
+<div id="content" class="container">
+    <h1>Clients</h1>
+</div>

assets/web/config.html

@@ -0,0 +1,592 @@
+<div id="app" class="container">
+    <h1 class="my-4">Configuration</h1>
+    <div class="form" v-if="config">
+        <!--Header-->
+        <ul class="nav nav-tabs">
+            <li class="nav-item" v-for="tab in tabs" :key="tab.id">
+                <a class="nav-link" :class="{'active': tab.id === currentTab}" href="#"
+                    @click="currentTab = tab.id">{{tab.name}}</a>
+            </li>
+        </ul>
+        <!--General Tab-->
+        <div v-if="currentTab === 'general'" class="config-page">
+            <!--Sunshine Name-->
+            <div class="mb-3">
+                <label for="sunshine_name" class="form-label">Sunshine Name</label>
+                <input type="text" class="form-control" id="sunshine_name" placeholder="Sunshine"
+                    v-model="config.sunshine_name">
+                <div class="form-text">The name displayed by Moonlight. If not specified, the PC's hostname is used
+                </div>
+            </div>
+            <!--Log Level-->
+            <div class="mb-3">
+                <label for="min_log_level" class="form-label">Log Level</label>
+                <select id="min_log_level" class="form-select" v-model="config.min_log_level">
+                    <option :value="0">Verbose</option>
+                    <option :value="1">Debug</option>
+                    <option :value="2">Info</option>
+                    <option :value="3">Warning</option>
+                    <option :value="4">Error</option>
+                    <option :value="5">Fatal</option>
+                    <option :value="6">None</option>
+                </select>
+                <div class="form-text">The minimum log level printed to standard out</div>
+            </div>
+            <!--Origin Web UI Allowed-->
+            <div class="mb-3">
+                <label for="origin_web_ui_allowed" class="form-label">Origin Web UI Allowed</label>
+                <select id="origin_web_ui_allowed" class="form-select" v-model="config.origin_web_ui_allowed">
+                    <option value="pc">Only localhost may access Web UI</option>
+                    <option value="lan">Only those in LAN may access Web UI</option>
+                    <option value="wan">Anyone may access Web UI</option>
+                </select>
+                <div class="form-text">The origin of the remote endpoint address that is not denied access to Web UI
+                </div>
+            </div>
+            <!--UPnP-->
+            <div class="mb-3">
+                <label for="upnp" class="form-label">UPnP</label>
+                <select id="upnp" class="form-select" v-model="config.upnp">
+                    <option value="disabled">Disabled</option>
+                    <option value="enabled">Enabled</option>
+                </select>
+                <div class="form-text">Automatically configure port forwarding</div>
+            </div>
+            <!--Ping Timeout-->
+            <div class="mb-3">
+                <label for="ping_timeout" class="form-label">Ping Timeout</label>
+                <input type="text" class="form-control" id="ping_timeout" placeholder="10000"
+                    v-model="config.ping_timeout">
+                <div class="form-text">How long to wait in milliseconds for data from moonlight before shutting down the
+                    stream</div>
+            </div>
+            <!--Advertised FPS and Resolutions-->
+            <div class="mb-3">
+                <label for="ping_timeout" class="form-label">Advertised Resolutions and FPS</label>
+                <div class="resolutions-container">
+                    <label>Resolutions</label>
+                    <div class="resolutions d-flex flex-wrap">
+                        <div class="p-2 ms-item m-2 d-flex justify-content-between" v-for="(r,i) in resolutions"
+                            :key="r">
+                            <span class="px-2">{{r}}</span>
+                            <span style="cursor: pointer;" @click="resolutions.splice(i,1)">&times;</span>
+                        </div>
+                        <form @submit.prevent="resolutions.push(resIn);resIn = '';" class="d-flex align-items-center">
+                            <input type="text" v-model="resIn" required pattern="[0-9]+x[0-9]+"
+                                style="border-top-right-radius: 0;border-bottom-right-radius: 0;" class="form-control">
+                            <button style="border-top-left-radius: 0;border-bottom-left-radius: 0;"
+                                class="btn btn-success">+</button>
+                        </form>
+                    </div>
+                </div>
+                <div class="fps-container">
+                    <label>FPS</label>
+                    <div class="fps d-flex flex-wrap">
+                        <div class="p-2 ms-item m-2 d-flex justify-content-between" v-for="(f,i) in fps" :key="f">
+                            <span class="px-2">{{f}}</span>
+                            <span style="cursor: pointer;" @click="fps.splice(i,1)">&times;</span>
+                        </div>
+                        <form @submit.prevent="fps.push(fpsIn);fpsIn = '';" class="d-flex align-items-center">
+                            <input type="text" v-model="fpsIn" required pattern="[0-9]+"
+                                style="width: 6ch;border-top-right-radius: 0;border-bottom-right-radius: 0;"
+                                class="form-control">
+                            <button style="border-top-left-radius: 0;border-bottom-left-radius: 0;"
+                                class="btn btn-success">+</button>
+                        </form>
+                    </div>
+                </div>
+                <div class="form-text">
+                    The display modes advertised by Sunshine<br>
+                    Some versions of Moonlight, such as Moonlight-nx (Switch),
+                    rely on this list to ensure that the requested resolutions and fps
+                    are supported.
+                </div>
+            </div>
+        </div>
+        <!--Files Tab-->
+        <div v-if="currentTab === 'files'" class="config-page">
+            <!--Private Key-->
+            <div class="mb-3">
+                <label for="pkey" class="form-label">Private Key</label>
+                <input type="text" class="form-control" id="pkey" placeholder="/dir/pkey.pem" v-model="config.pkey">
+                <div class="form-text">The private key must be 2048 bits</div>
+            </div>
+            <!--Cert-->
+            <div class="mb-3">
+                <label for="cert" class="form-label">Cert</label>
+                <input type="text" class="form-control" id="cert" placeholder="/dir/cert.pem" v-model="config.cert">
+                <div class="form-text">The certificate must be signed with a 2048 bit key</div>
+            </div>
+
+            <!--State File-->
+            <div class="mb-3">
+                <label for="file_state" class="form-label">State File</label>
+                <input type="text" class="form-control" id="file_state" placeholder="sunshine_state.json"
+                    v-model="config.file_state">
+                <div class="form-text">The file where current state of Sunshine is stored</div>
+            </div>
+            <!--Apps File-->
+            <div class="mb-3">
+                <label for="file_apps" class="form-label">Apps File</label>
+                <input type="text" class="form-control" id="file_apps" placeholder="apps.json"
+                    v-model="config.file_apps">
+                <div class="form-text">The file where current apps of Sunshine are stored</div>
+            </div>
+        </div>
+        <div v-if="currentTab === 'input'" class="config-page">
+            <!--Back Button Timeout-->
+            <div class="mb-3">
+                <label for="back_button_timeout" class="form-label">Back Button Timeout</label>
+                <input type="text" class="form-control" id="back_button_timeout" placeholder="2000"
+                    v-model="config.back_button_timeout">
+                <div class="form-text">
+                    The back/select button on the controller.<br>
+                    On the Shield, the home and powerbutton are not passed to Moonlight.<br>
+                    If, after the timeout, the back button is still pressed down, Home/Guide button press is
+                    emulated.<br>
+                    If back_button_timeout &lt; 0, then the Home/Guide button will not be emulated<br>
+                </div>
+            </div>
+            <!-- Key Repeat Delay-->
+            <div class="mb-3" v-if="platform === 'windows'">
+                <label for="key_repeat_delay" class="form-label">Key Repeat Delay</label>
+                <input type="text" class="form-control" id="key_repeat_delay" placeholder="500"
+                    v-model="config.key_repeat_delay">
+                <div class="form-text">
+                    Control how fast keys will repeat themselves<br>
+                    The initial delay in milliseconds before repeating keys
+                </div>
+            </div>
+            <!-- Key Repeat Frequency-->
+            <div class="mb-3" v-if="platform === 'windows'">
+                <label for="key_repeat_frequency" class="form-label">Key Repeat Frequency</label>
+                <input type="text" class="form-control" id="key_repeat_frequency" placeholder="24.9"
+                    v-model="config.key_repeat_frequency">
+                <div class="form-text">
+                    How often keys repeat every second<br>
+                    This configurable option supports decimals
+                </div>
+            </div>
+        </div>
+        <!--Files Tab-->
+        <div v-if="currentTab === 'av'" class="config-page">
+            <!--Audio Sink-->
+            <div class="mb-3" v-if="platform === 'windows'">
+                <label for="audio_sink" class="form-label">Audio Sink</label>
+                <input type="text" class="form-control" id="audio_sink"
+                    placeholder="{0.0.0.00000000}.{FD47D9CC-4218-4135-9CE2-0C195C87405B}" v-model="config.audio_sink">
+                <div class="form-text">
+                    The name of the audio sink used for Audio Loopback<br>
+                    You can find the name of the audio sink using the following command:<br>
+                    <pre>tools\audio-info.exe</pre>
+                </div>
+            </div>
+            <div class="mb-3" v-if="platform === 'linux'">
+                <label for="audio_sink" class="form-label">Audio Sink</label>
+                <input type="text" class="form-control" id="audio_sink"
+                    placeholder="alsa_output.pci-0000_09_00.3.analog-stereo" v-model="config.audio_sink">
+                <div class="form-text">
+                    The name of the audio sink used for Audio Loopback<br>
+                    If you do not specify this variable, pulseaudio will select the default monitor device.<br>
+                    <br>
+                    You can find the name of the audio sink using either command:<br>
+                    <pre>pacmd list-sinks | grep "name:"</pre>
+                    <pre>pactl info | grep Source</pre><br>
+                </div>
+            </div>
+            <!--Virtual Sink-->
+            <div class="mb-3" v-if="platform === 'windows'">
+                <label for="virtual_sink" class="form-label">Virtual Sink</label>
+                <input type="text" class="form-control" id="virtual_sink"
+                    placeholder="{0.0.0.00000000}.{8edba70c-1125-467c-b89c-15da389bc1d4}" v-model="config.virtual_sink">
+                <div class="form-text">
+                    The virtual sink, is the audio device that's virtual (Like Steam Streaming Speakers), it allows
+                    Sunshine
+                    to stream audio, while muting the speakers.
+                </div>
+            </div>
+            <!--Adapter Name -->
+            <div class="mb-3" v-if="platform === 'windows'">
+                <label for="adapter_name" class="form-label">Adapter Name</label>
+                <input type="text" class="form-control" id="adapter_name" placeholder="Radeon RX 580 Series"
+                    v-model="config.adapter_name">
+                <div class="form-text" v-if="platform === 'windows'">
+                    You can select the video card you want to stream:<br>
+                    The appropriate values can be found using the following command:<br>
+                    <pre>tools\dxgi-info.exe</pre>
+                </div>
+            </div>
+            <!--Output Name -->
+            <div class="mb-3" class="config-page" v-if="platform === 'windows'">
+                <label for="output_name" class="form-label">Output Name</label>
+                <input type="text" class="form-control" id="output_name" placeholder="\\.\DISPLAY1"
+                    v-model="config.output_name">
+                <div class="form-text">
+                    You can select the video card you want to stream:<br>
+                    The appropriate values can be found using the following command:<br>
+                    tools\dxgi-info.exe<br><br>
+                </div>
+            </div>
+            <div class="mb-3" class="config-page" v-if="platform === 'linux'">
+                <label for="output_name" class="form-label">Monitor number</label>
+                <input type="text" class="form-control" id="output_name" placeholder="0" v-model="config.output_name">
+                <div class="form-text">
+                    xrandr --listmonitors<br>
+                    Example output:
+                    <pre>   0: +HDMI-1 1920/518x1200/324+0+0 HDMI-1</pre>
+                </div>
+            </div>
+        </div>
+        <div v-if="currentTab === 'advanced'" class="config-page">
+            <!--Port familly-->
+            <div class="mb-3">
+                <label for="port" class="form-label">Port</label>
+                <input type="number" min="0" max="65529" class="form-control" id="port" placeholder="47989"
+                    v-model="config.port">
+                <div class="form-text">
+                    Set the familly of ports used by Sunshine
+                </div>
+            </div>
+            <!--Constant Rate Factor-->
+            <div class="mb-3">
+                <label for="crf" class="form-label">Constant Rate Factor</label>
+                <input type="number" min="0" max="52" class="form-control" id="crf" placeholder="0"
+                    v-model="config.crf">
+                <div class="form-text">
+                    Constant Rate Factor. Between 1 and 52. It allows QP to go up during motion and down with still
+                    image,
+                    resulting in constant perceived quality<br>
+                    Higher value means more compression, but less quality<br>
+                    If crf == 0, then use QP directly instead
+                </div>
+            </div>
+            <!-- Quantization Parameter -->
+            <div class="mb-3">
+                <label for="qp" class="form-label">Quantitization Parameter</label>
+                <input type="number" class="form-control" id="qp" placeholder="28" v-model="config.qp">
+                <div class="form-text">
+                    Quantitization Parameter<br>
+                    Higher value means more compression, but less quality<br>
+                    If crf != 0, then this parameter is ignored
+                </div>
+            </div>
+            <!-- Min Threads -->
+            <div class="mb-3">
+                <label for="min_threads" class="form-label">Minimum number of threads used by ffmpeg to encode the
+                    video.</label>
+                <input type="number" min="1" class="form-control" id="min_threads" placeholder="1"
+                    v-model="config.min_threads">
+                <div class="form-text">
+                    Minimum number of threads used by ffmpeg to encode the video.<br>
+                    Increasing the value slightly reduces encoding efficiency, but the tradeoff is usually<br>
+                    worth it to gain the use of more CPU cores for encoding. The ideal value is the lowest<br>
+                    value that can reliably encode at your desired streaming settings on your hardware.
+                </div>
+            </div>
+            <!--HEVC Suppport -->
+            <div class="mb-3">
+                <label for="hevc_mode" class="form-label">HEVC Support</label>
+                <select id="hevc_mode" class="form-select" v-model="config.hevc_mode">
+                    <option value="0">Sunshine will specify support for HEVC based on encoder</option>
+                    <option value="1">Sunshine will not advertise support for HEVC</option>
+                    <option value="2">Sunshine will advertise support for HEVC Main profile</option>
+                    <option value="3">Sunshine will advertise support for HEVC Main and Main10 (HDR) profiles
+                    </option>
+                </select>
+                <div class="form-text">
+                    Allows the client to request HEVC Main or HEVC Main10 video streams.<br>
+                    HEVC is more CPU-intensive to encode, so enabling this may reduce performance when using
+                    software
+                    encoding.
+                </div>
+            </div>
+            <!--Encoder -->
+            <div class="mb-3">
+                <label for="encoder" class="form-label">Force a Specific Encoder</label>
+                <select id="encoder" class="form-select" v-model="config.encoder">
+                    <option :value="''">Autodetect</option>
+                    <option value="nvenc">nVidia NVENC</option>
+                    <option value="amdvce">AMD AMF/VCE</option>
+                    <option value="vaapi">VA-API</option>
+                    <option value="software">Software</option>
+                </select>
+                <div class="form-text">
+                    Force a specific encoder, otherwise Sunshine will use the first encoder that is available
+                </div>
+            </div>
+            <!--FEC Percentage-->
+            <div class="mb-3">
+                <label for="fec_percentage" class="form-label">FEC Percentage</label>
+                <input type="text" class="form-control" id="fec_percentage" placeholder="20"
+                    v-model="config.fec_percentage">
+                <div class="form-text">
+                    Percentage of error correcting packets per data packet in each video frame.<br>
+                    Higher values can correct for more network packet loss, but at the cost of increasing bandwidth usage.<br>
+                    The default value of 20 is what GeForce Experience uses.
+                </div>
+            </div>
+            <!--Channels-->
+            <div class="mb-3">
+                <label for="channels" class="form-label">Channels</label>
+                <input type="text" class="form-control" id="channels" placeholder="1" v-model="config.channels">
+                <div class="form-text">
+                    When multicasting, it could be useful to have different configurations for each connected
+                    Client.
+                    For example:
+                    <ul>
+                        <li>Clients connected through WAN and LAN have different bitrate contstraints.</li>
+                        <li>Decoders may require different settings for color</li>
+                    </ul>
+                    Unlike simply broadcasting to multiple Client, this will generate distinct video streams.<br>
+                    Note, CPU usage increases for each distinct video stream generated
+                </div>
+            </div>
+            <!--Credentials File-->
+            <div class="mb-3">
+                <label for="credentials_file" class="form-label">Web Manager Credentials File</label>
+                <input type="text" class="form-control" id="credentials_file" placeholder="sunshine_state.json"
+                    v-model="config.credentials_file">
+                <div class="form-text">
+                    Store Username/Password seperately from Sunshine's state file.
+                </div>
+            </div>
+            <!--Origin PIN Allowed-->
+            <div class="mb-3">
+                <label for="origin_pin_allowed" class="form-label">Origin PIN Allowed</label>
+                <select id="origin_pin_allowed" class="form-select" v-model="config.origin_pin_allowed">
+                    <option value="pc">Only localhost may access /pin</option>
+                    <option value="lan">Only those in LAN may access /pin</option>
+                    <option value="wan">Anyone may access /pin</option>
+                </select>
+                <div class="form-text">The origin of the remote endpoint address that is not denied for HTTP method /pin
+                </div>
+            </div>
+            <!--External IP-->
+            <div class="mb-3">
+                <label for="external_ip" class="form-label">External IP</label>
+                <input type="text" class="form-control" id="external_ip" placeholder="123.456.789.12"
+                    v-model="config.external_ip">
+                <div class="form-text">If no external IP address is given, Sunshine will automatically detect external
+                    IP</div>
+            </div>
+        </div>
+        <!--Software Settings-->
+        <div v-if="currentTab === 'sw'" class="config-page">
+            <div class="mb-3">
+                <label for="sw_preset" class="form-label">SW Presets</label>
+                <input class="form-control" id="sw_preset" placeholder="superfast" v-model="config.sw_preset">
+            </div>
+            <div class="mb-3">
+                <label for="sw_tune" class="form-label">SW Tune</label>
+                <input class="form-control" id="sw_tune" placeholder="zerolatency" v-model="config.sw_tune">
+            </div>
+        </div>
+        <!--Nvidia Encoder Settings-->
+        <div v-if="currentTab === 'nv'" class="config-page">
+            <!--NVENC SETTINGS-->
+            <div class="mb-3">
+                <label for="nv_preset" class="form-label">NVEnc Preset</label>
+                <select id="nv_preset" class="form-select" v-model="config.nv_preset">
+                    <option value="default">Default</option>
+                    <option value="hp">High Performance</option>
+                    <option value="hq">High Quality</option>
+                    <option value="slow">Slow - hq 2 passes</option>
+                    <option value="medium">medium -- hq 1 pass</option>
+                    <option value="fast">fast -- hp 1 pass</option>
+                    <option value="bd">bd</option>
+                    <option value="ll">ll -- low latency</option>
+                    <option value="llhq">llhq</option>
+                    <option value="llhp">llhp</option>
+                    <option value="lossless">lossless</option>
+                    <option value="losslesshp">losslesshp</option>
+                </select>
+            </div>
+            <div class="mb-3">
+                <label for="nv_rc" class="form-label">NVEnc Rate Control</label>
+                <select id="nv_rc" class="form-select" v-model="config.nv_rc">
+                    <option value="auto">auto -- let ffmpeg decide rate control</option>
+                    <option value="constqp">constqp -- constant QP mode</option>
+                    <option value="vbr">vbr -- variable bitrate</option>
+                    <option value="cbr">cbr -- constant bitrate</option>
+                    <option value="cbr_hq">cbr_hq -- cbr high quality</option>
+                    <option value="cbr_ld_hq">cbr_ld_hq -- cbr low delay high quality</option>
+                    <option value="vbr_hq">vbr_hq -- vbr high quality</option>
+                </select>
+            </div>
+            <div class="mb-3">
+                <label for="nv_coder" class="form-label">NVEnc Coder</label>
+                <select id="nv_coder" class="form-select" v-model="config.nv_coder">
+                    <option value="auto">auto</option>
+                    <option value="cabac">cabac</option>
+                    <option value="cavlc">cavlc</option>
+                </select>
+            </div>
+        </div>
+        <!--AMD Encoder Settings-->
+        <div v-if="currentTab === 'amd'" class="config-page">
+            <!--Presets-->
+            <div class="mb-3">
+                <label for="amd_quality" class="form-label">AMD AMF Quality</label>
+                <select id="amd_quality" class="form-select" v-model="config.amd_quality">
+                    <option value="default">Default</option>
+                    <option value="speed">Speed</option>
+                    <option value="balanced">Balanced</option>
+                </select>
+            </div>
+            <div class="mb-3">
+                <label for="amd_rc" class="form-label">AMD AMF Rate Control</label>
+                <select id="amd_rc" class="form-select" v-model="config.amd_rc">
+                    <option value="auto">auto -- let ffmpeg decide rate control</option>
+                    <option value="constqp">constqp -- constant QP mode</option>
+                    <option value="vbr_latency">vbr_latency -- Latency Constrained Variable Bitrate</option>
+                    <option value="vbr_peak">vbr_peak -- Peak Contrained Variable Bitrate</option>
+                    <option value="cbr">cbr -- constant bitrate</option>
+                </select>
+            </div>
+            <div class="mb-3">
+                <label for="amd_coder" class="form-label">AMD AMF Rate Control</label>
+                <select id="amd_coder" class="form-select" v-model="config.amd_coder">
+                    <option value="auto">auto</option>
+                    <option value="cabac">cabac</option>
+                    <option value="cavlc">cavlc</option>
+                </select>
+            </div>
+        </div>
+        <div v-if="currentTab === 'va-api'" class="config-page">
+            <input class="form-control" id="adapter_name" placeholder="/dev/dri/renderD128"
+                v-model="config.adapter_name">
+        </div>
+    </div>
+    <div class="alert alert-success my-4" v-if="success"><b>Success!</b> Restart Sunshine to apply changes</div>
+    <div class="mb-3 buttons">
+        <button class="btn btn-primary" @click="save">Save</button>
+    </div>
+</div>
+
+<script>
+    new Vue({
+        el: '#app',
+        data() {
+            return {
+                platform: '',
+                success: false,
+                config: null,
+                fps: [],
+                resolutions: [],
+                currentTab: 'general',
+                resIn: '',
+                fpsIn: '',
+                tabs: [{
+                    id: 'general',
+                    name: "General"
+                },
+                {
+                    id: 'files',
+                    name: "Files"
+                },
+                {
+                    id: 'input',
+                    name: "Input"
+                },
+                {
+                    id: 'av',
+                    name: "Audio/Video"
+                },
+                {
+                    id: 'advanced',
+                    name: "Advanced"
+                },
+                {
+                    id: "sw",
+                    name: "Software Encoder"
+                },
+                {
+                    id: "nv",
+                    name: "NVENC Encoder"
+                },
+                {
+                    id: "amd",
+                    name: "AMF Encoder"
+                },
+                {
+                    id: "va-api",
+                    name: "VA-API encoder"
+                }
+                ]
+            }
+        },
+        created() {
+            fetch("/api/config").then(r => r.json()).then((r) => {
+                this.config = r;
+                this.platform = this.config.platform;
+
+                var app = document.getElementById("app");
+                if (this.platform == "windows") {
+                    this.tabs = this.tabs.filter(el => {
+                        return el.id !== "va-api";
+                    });
+                }
+                if (this.platform == "linux") {
+                    this.tabs = this.tabs.filter(el => {
+                        return el.id !== "amd";
+                    });
+                }
+
+                delete this.config.status;
+                delete this.config.platform;
+                //Populate default values if not present in config
+                this.config.upnp = this.config.upnp || 'disabled';
+                this.config.min_log_level = this.config.min_log_level || 2;
+                this.config.origin_pin_allowed = this.config.origin_pin_allowed || "pc";
+                this.config.origin_web_ui_allowed = this.config.origin_web_manager_allowed || "lan";
+                this.config.hevc_mode = this.config.hevc_mode || 0;
+                this.config.encoder = this.config.encoder || '';
+                this.config.nv_preset = this.config.nv_preset || 'default';
+                this.config.nv_rc = this.config.nv_rc || 'auto';
+                this.config.nv_coder = this.config.nv_coder || 'auto';
+                this.config.amd_quality = this.config.amd_quality || 'default';
+                this.config.amd_rc = this.config.amd_rc || 'auto';
+                this.config.fps = this.config.fps || '[10, 30, 60, 90, 120]';
+                this.config.resolutions = this.config.resolutions || '[352x240,480x360,858x480,1280x720,1920x1080,2560x1080,3440x1440,1920x1200,3860x2160,3840x1600]';
+                this.fps = JSON.parse(this.config.fps);
+                //Resolutions should be fixed because are not valid JSON
+                let res = this.config.resolutions.substring(1, this.config.resolutions.length - 1);
+                let resolutions = [];
+                res.split(",").forEach(r => resolutions.push(r.trim()));
+                this.resolutions = resolutions;
+            })
+        },
+        methods: {
+            save() {
+                this.success = false;
+                let nl = this.config === 'windows' ? "\r\n" : "\n";
+                this.config.resolutions = "[" + nl + "    " + this.resolutions.join("," + nl + "    ") + nl + "]";
+                this.config.fps = JSON.stringify(this.fps);
+                fetch("/api/config", {
+                    method: "POST",
+                    body: JSON.stringify(this.config)
+                }).then((r) => {
+                    if (r.status == 200) this.success = true;
+                });
+            }
+        }
+    })
+</script>
+
+<style>
+    .config-page {
+        padding: 1em;
+        border: 1px solid #dee2e6;
+        border-top: none;
+    }
+
+    .buttons {
+        padding: 1em 0;
+    }
+
+    .ms-item {
+        background-color: #CCC;
+        font-size: 12px;
+        font-weight: bold;
+    }
+</style>

assets/web/header.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sunshine</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0" crossorigin="anonymous">
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0/dist/js/bootstrap.bundle.min.js"
+        integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8" crossorigin="anonymous">
+    </script>
+<script src="https://cdn.jsdelivr.net/npm/vue@2.6.12/dist/vue.js"></script>
+</head>
+
+<body>
+    <nav class="navbar navbar-expand-lg navbar-light" style="background-color: #ffc400;">
+        <div class="container-fluid">
+            <span class="navbar-brand">Sunshine</span>
+            <button class="navbar-toggler" type="button" data-bs-toggle="collapse"
+                data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false"
+                aria-label="Toggle navigation">
+                <span class="navbar-toggler-icon"></span>
+            </button>
+            <div class="collapse navbar-collapse" id="navbarSupportedContent">
+                <ul class="navbar-nav me-auto mb-2 mb-lg-0">
+                    <li class="nav-item">
+                        <a class="nav-link" href="/">Home</a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link" href="/pin">PIN</a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link" href="/apps">Applications</a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link" href="/config">Configuration</a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link" href="/password">Change Password</a>
+                    </li>
+                </ul>
+            </div>
+    </nav>

assets/web/index.html

@@ -0,0 +1,9 @@
+<div id="content" class="container">
+    <div class="row">
+        <div class="col-md-6 py-4" style="margin: 0 auto;">
+            <h1>Hello, Sunshine!</h1>
+            <p>Sunshine is a Gamestream host for Moonlight</p>
+            <a href="https://github.com/loki-47-6F-64/sunshine">Official GitHub Repository</a>
+        </div>
+    </div>
+</div>

assets/web/password.html

@@ -0,0 +1,97 @@
+<div id="app" class="container">
+    <h1 class="my-4">Password Change</h1>
+    <form @submit.prevent="save">
+        <div class="card d-flex p-4 flex-row">
+            <div class="col-md-6 px-4">
+                <h4>Current Credentials</h4>
+                <div class="mb-3">
+                    <label for="currentUsername" class="form-label">Username</label>
+                    <input required type="text" class="form-control" id="currentUsername" v-model="passwordData.currentUsername">
+                    <div class="form-text">&nbsp;</div>
+                </div>
+                <div class="mb-3">
+                    <label for="currentPassword" class="form-label">Password</label>
+                    <input autocomplete="current-password" type="password" class="form-control" id="currentPassword" v-model="passwordData.currentPassword">
+                </div>
+            </div>
+            <div class="col-md-6 px-4">
+                <h4>New Credentials</h4>
+                <div class="mb-3">
+                    <label for="newUsername" class="form-label">New Username</label>
+                    <input type="text" class="form-control" id="newUsername" v-model="passwordData.newUsername">
+                    <div class="form-text">If not specified, the username will not change
+                    </div>
+                </div>
+                <div class="mb-3">
+                    <label for="newPassword" class="form-label">Password</label>
+                    <input autocomplete="new-password" required type="password" class="form-control" id="newPassword" v-model="passwordData.newPassword">
+                </div>
+                <div class="mb-3">
+                    <label for="confirmNewPassword" class="form-label">Confirm Password</label>
+                    <input autocomplete="new-password" required type="password" class="form-control" id="confirmNewPassword" v-model="passwordData.confirmNewPassword">
+                </div>
+            </div>
+        </div>
+        <div class="alert alert-danger" v-if="error"><b>Error: </b>{{error}}</div>
+        <div class="alert alert-success" v-if="success"><b>Success! </b>This page will reload soon, your browser will ask you for the new credentials</div>
+        <div class="mb-3 buttons">
+            <button class="btn btn-primary">Save</button>
+        </div>
+    </form>
+</div>
+
+<script>
+    new Vue({
+        el: '#app',
+        data() {
+            return {
+                error: null,
+                success: false,
+                passwordData: {
+                    currentUsername: '',
+                    currentPassword: '',
+                    newUsername: '',
+                    newPassword: '',
+                    confirmNewPassword: ''
+                }
+            }
+        },
+        methods: {
+            save() {
+                this.error = null;
+                fetch("/api/password", {
+                    method: "POST",
+                    body: JSON.stringify(this.passwordData)
+                }).then((r) => {
+                    if (r.status == 200){
+                        r.json().then((rj) => {
+                            if(rj.status.toString() === "true"){
+                                this.success = true;
+                                setTimeout(()=>{
+                                    document.location.reload();
+                                },5000);
+                            } else {
+                                this.error = rj.error;
+                            }
+                        })
+                    }
+                    else  {
+                        this.error = "Internal Server Error"
+                    }
+                });
+            }
+        }
+    })
+</script>
+
+<style>
+    .config-page {
+        padding: 1em;
+        border: 1px solid #dee2e6;
+        border-top: none;
+    }
+
+    .buttons {
+        padding: 1em 0;
+    }
+</style>

assets/web/pin.html

@@ -0,0 +1,31 @@
+
+<div id="content" class="container">
+    <h1 class="my-4">PIN Pairing</h1>
+    <form action="" class="form d-flex flex-column align-items-center" id="form">
+        <div class="card flex-column d-flex p-4 mb-4">
+            <input type="number" placeholder="PIN" id="pin-input" class="form-control my-4">
+            <button class="btn btn-primary">Send</button>
+        </div>
+        <div class="alert alert-warning">
+            <b>Warning!</b> Make sure you have access to the client you are pairing with.<br>
+            This software can give total control to your computer, so be careful!
+        </div>
+        <div id="status"></div>
+    </form>
+</div>
+
+<script>
+    document.querySelector("#form").addEventListener("submit", (e) => {
+        e.preventDefault();
+        let pin = document.querySelector("#pin-input").value;
+        document.querySelector("#status").innerHTML = "";
+        let b = JSON.stringify({pin: pin});
+        fetch("/api/pin",{method: "POST",body: b}).then((response) => response.json()).then((response)=>{
+            if(response.status){
+                document.querySelector("#status").innerHTML = `<div class="alert alert-success" role="alert">Success! Please check Moonlight to continue</div>`;
+            } else {
+                document.querySelector("#status").innerHTML = `<div class="alert alert-danger" role="alert">PIN does not match, please check if it's typed correctly</div>`;
+            }
+        })
+    })
+</script>

gen-deb.in

@@ -10,15 +10,17 @@ if [ -d package-deb ]; then
 	rm -rf package-deb
 fi
 
-export DEBIAN=package-deb/sunshine/DEBIAN
-export RULES=package-deb/sunshine/etc/udev/rules.d
-export BIN=package-deb/sunshine/usr/bin
-export ASSETS=package-deb/sunshine/etc/sunshine
+export DEBIAN=@CMAKE_CURRENT_BINARY_DIR@/package-deb/sunshine/DEBIAN
+export RULES=@CMAKE_CURRENT_BINARY_DIR@/package-deb/sunshine/etc/udev/rules.d
+export BIN=@CMAKE_CURRENT_BINARY_DIR@/package-deb/sunshine/usr/bin
+export SERVICE=@CMAKE_CURRENT_BINARY_DIR@/package-deb/sunshine/usr/lib/systemd/user
+export ASSETS=@CMAKE_CURRENT_BINARY_DIR@/package-deb/sunshine/etc/sunshine
 
 mkdir -p $DEBIAN
 mkdir -p $RULES
 mkdir -p $BIN
-mkdir -p $ASSETS
+mkdir -p $ASSETS/shaders
+mkdir -p $SERVICE
 
 if [ ! -f sunshine ]; then
 	echo "Error: Can't find sunshine"
@@ -35,8 +37,8 @@ Package: sunshine
 Architecture: amd64
 Maintainer: @loki
 Priority: optional
-Version: 0.3.1
-Depends: libssl1.1, libavdevice58, libboost-thread1.71.0, libboost-filesystem1.71.0, libboost-log1.71.0, libpulse0, libopus0, libxcb-shm0, libxcb-xfixes0
+Version: 0.8.1
+Depends: libssl1.1, libavdevice58, libboost-thread1.67.0 | libboost-thread1.71.0, libboost-filesystem1.67.0 | libboost-filesystem1.71.0, libboost-log1.67.0 | libboost-log1.71.0, libpulse0, libopus0, libxcb-shm0, libxcb-xfixes0, libxtst6, libevdev2
 Description: Gamestream host for Moonlight
 EOF
 
@@ -54,6 +56,17 @@ if [ -f /etc/group ]; then
 else
         echo "Warning: /etc/group not found"
 fi
+
+# Update permissions on config files for Web Manager
+if [ -f /etc/sunshine/apps_linux.json ]; then
+	echo "chmod 666 /etc/sunshine/apps_linux.json"
+	chmod 666 /etc/sunshine/apps_linux.json
+fi
+
+if [ -f /etc/sunshine/sunshine.conf ]; then
+	echo "chmod 666 /etc/sunshine/sunshine.conf"
+	chmod 666 /etc/sunshine/sunshine.conf
+fi
 EOF
 
 cat << 'EOF' > $RULES/85-sunshine-rules.rules
@@ -63,10 +76,15 @@ EOF
 cp sunshine $BIN/sunshine
 cp @CMAKE_CURRENT_SOURCE_DIR@/assets/apps_linux.json $ASSETS/apps_linux.json
 cp @CMAKE_CURRENT_SOURCE_DIR@/assets/sunshine.conf $ASSETS/sunshine.conf
+cp @CMAKE_CURRENT_BINARY_DIR@/sunshine.service $SERVICE/sunshine.service
+cp -r @CMAKE_CURRENT_SOURCE_DIR@/assets/web $ASSETS/web
+cp -r @CMAKE_CURRENT_SOURCE_DIR@/assets/shaders/opengl $ASSETS/shaders/opengl
 
 chmod 755 $DEBIAN/postinst
 chmod 755 $BIN/sunshine
 chmod 644 $RULES/85-sunshine-rules.rules
+chmod 666 $ASSETS/apps_linux.json
+chmod 666 $ASSETS/sunshine.conf
 
 cd package-deb
 if fakeroot dpkg-deb --build sunshine; then

sunshine/audio.cpp

@@ -4,55 +4,80 @@
 
 #include "platform/common.h"
 
-#include "utility.h"
-#include "thread_safe.h"
 #include "audio.h"
+#include "config.h"
 #include "main.h"
+#include "thread_safe.h"
+#include "utility.h"
 
 namespace audio {
 using namespace std::literals;
-using opus_t = util::safe_ptr<OpusMSEncoder, opus_multistream_encoder_destroy>;
+using opus_t         = util::safe_ptr<OpusMSEncoder, opus_multistream_encoder_destroy>;
 using sample_queue_t = std::shared_ptr<safe::queue_t<std::vector<std::int16_t>>>;
 
-struct opus_stream_config_t {
-  std::int32_t sampleRate;
-  int channelCount;
-  int streams;
-  int coupledStreams;
-  const std::uint8_t *mapping;
+struct audio_ctx_t {
+  // We want to change the sink for the first stream only
+  std::unique_ptr<std::atomic_bool> sink_flag;
+
+  std::unique_ptr<platf::audio_control_t> control;
+
+  bool restore_sink;
+  platf::sink_t sink;
 };
 
-constexpr std::uint8_t map_stereo[] { 0, 1 };
-constexpr std::uint8_t map_surround51[] {0, 4, 1, 5, 2, 3};
-constexpr std::uint8_t map_high_surround51[] {0, 1, 2, 3, 4, 5};
+static int start_audio_control(audio_ctx_t &ctx);
+static void stop_audio_control(audio_ctx_t &);
+
+int map_stream(int channels, bool quality);
+
 constexpr auto SAMPLE_RATE = 48000;
-static opus_stream_config_t stereo = {
+
+opus_stream_config_t stream_configs[MAX_STREAM_CONFIG] {
+  {
     SAMPLE_RATE,
     2,
     1,
     1,
-    map_stereo
-};
-
-static opus_stream_config_t Surround51 = {
+    platf::speaker::map_stereo,
+  },
+  {
     SAMPLE_RATE,
     6,
     4,
     2,
-    map_surround51
-};
-
-static opus_stream_config_t HighSurround51 = {
+    platf::speaker::map_surround51,
+  },
+  {
     SAMPLE_RATE,
     6,
     6,
     0,
-    map_high_surround51
+    platf::speaker::map_surround51,
+  },
+  {
+    SAMPLE_RATE,
+    8,
+    5,
+    3,
+    platf::speaker::map_surround71,
+  },
+  {
+    SAMPLE_RATE,
+    8,
+    8,
+    0,
+    platf::speaker::map_surround71,
+  },
 };
 
-void encodeThread(packet_queue_t packets, sample_queue_t samples, config_t config, void *channel_data) {
+auto control_shared = safe::make_shared<audio_ctx_t>(start_audio_control, stop_audio_control);
+
+void encodeThread(sample_queue_t samples, config_t config, void *channel_data) {
+  auto packets = mail::man->queue<packet_t>(mail::audio_packets);
+
   //FIXME: Pick correct opus_stream_config_t based on config.channels
-  auto stream = &stereo;
+  auto stream = &stream_configs[map_stream(config.channels, config.flags[config_t::HIGH_QUALITY])];
+
   opus_t opus { opus_multistream_encoder_create(
     stream->sampleRate,
     stream->channelCount,
@@ -60,16 +85,17 @@ void encodeThread(packet_queue_t packets, sample_queue_t samples, config_t confi
     stream->coupledStreams,
     stream->mapping,
     OPUS_APPLICATION_AUDIO,
-    nullptr)
-  };
+    nullptr) };
+
+  opus_multistream_encoder_ctl(opus.get(), OPUS_SET_VBR(0));
 
   auto frame_size = config.packetDuration * stream->sampleRate / 1000;
   while(auto sample = samples->pop()) {
-    packet_t packet { 16*1024 }; // 16KB
+    buffer_t packet { 1024 }; // 1KB
 
     int bytes = opus_multistream_encode(opus.get(), sample->data(), frame_size, std::begin(packet), packet.size());
     if(bytes < 0) {
-      BOOST_LOG(error) << opus_strerror(bytes);
+      BOOST_LOG(error) << "Couldn't encode audio: "sv << opus_strerror(bytes);
       packets->stop();
 
       return;
@@ -80,9 +106,53 @@ void encodeThread(packet_queue_t packets, sample_queue_t samples, config_t confi
   }
 }
 
-void capture(safe::signal_t *shutdown_event, packet_queue_t packets, config_t config, void *channel_data) {
+void capture(safe::mail_t mail, config_t config, void *channel_data) {
+  auto shutdown_event = mail->event<bool>(mail::shutdown);
+
+  //FIXME: Pick correct opus_stream_config_t based on config.channels
+  auto stream = &stream_configs[map_stream(config.channels, config.flags[config_t::HIGH_QUALITY])];
+
+  auto ref = control_shared.ref();
+  if(!ref) {
+    return;
+  }
+
+  auto &control = ref->control;
+  if(!control) {
+    BOOST_LOG(error) << "Couldn't create audio control"sv;
+
+    return;
+  }
+
+  std::string *sink =
+    config::audio.sink.empty() ? &ref->sink.host : &config::audio.sink;
+  if(ref->sink.null) {
+    auto &null = *ref->sink.null;
+    switch(stream->channelCount) {
+    case 2:
+      sink = &null.stereo;
+      break;
+    case 6:
+      sink = &null.surround51;
+      break;
+    case 8:
+      sink = &null.surround71;
+      break;
+    }
+  }
+
+  // Only the first to start a session may change the default sink
+  if(!ref->sink_flag->exchange(true, std::memory_order_acquire)) {
+    ref->restore_sink = !config.flags[config_t::HOST_AUDIO];
+
+    // If the client requests audio on the host, don't change the default sink
+    if(!config.flags[config_t::HOST_AUDIO] && control->set_sink(*sink)) {
+      return;
+    }
+  }
+
   auto samples = std::make_shared<sample_queue_t::element_type>(30);
-  std::thread thread { encodeThread, packets, samples, config, channel_data };
+  std::thread thread { encodeThread, samples, config, channel_data };
 
   auto fg = util::fail_guard([&]() {
     samples->stop();
@@ -91,43 +161,85 @@ void capture(safe::signal_t *shutdown_event, packet_queue_t packets, config_t co
     shutdown_event->view();
   });
 
-  //FIXME: Pick correct opus_stream_config_t based on config.channels
-  auto stream = &stereo;
+  auto frame_size       = config.packetDuration * stream->sampleRate / 1000;
+  int samples_per_frame = frame_size * stream->channelCount;
 
-  auto mic = platf::microphone(stream->sampleRate);
+  auto mic = control->microphone(stream->mapping, stream->channelCount, stream->sampleRate, frame_size);
   if(!mic) {
-    BOOST_LOG(error) << "Couldn't create audio input"sv ;
+    BOOST_LOG(error) << "Couldn't create audio input"sv;
 
     return;
   }
 
-  auto frame_size = config.packetDuration * stream->sampleRate / 1000;
-  int samples_per_frame = frame_size * stream->channelCount;
-
   while(!shutdown_event->peek()) {
     std::vector<std::int16_t> sample_buffer;
     sample_buffer.resize(samples_per_frame);
 
     auto status = mic->sample(sample_buffer);
     switch(status) {
-      case platf::capture_e::ok:
-        break;
-      case platf::capture_e::timeout:
-        continue;
-      case platf::capture_e::reinit:
-        mic.reset();
-        mic = platf::microphone(stream->sampleRate);
-        if(!mic) {
-          BOOST_LOG(error) << "Couldn't re-initialize audio input"sv ;
+    case platf::capture_e::ok:
+      break;
+    case platf::capture_e::timeout:
+      continue;
+    case platf::capture_e::reinit:
+      mic.reset();
+      mic = control->microphone(stream->mapping, stream->channelCount, stream->sampleRate, frame_size);
+      if(!mic) {
+        BOOST_LOG(error) << "Couldn't re-initialize audio input"sv;
 
-          return;
-        }
-        return;
-      default:
         return;
+      }
+      return;
+    default:
+      return;
     }
 
     samples->raise(std::move(sample_buffer));
   }
 }
+
+int map_stream(int channels, bool quality) {
+  int shift = quality ? 1 : 0;
+  switch(channels) {
+  case 2:
+    return STEREO;
+  case 6:
+    return SURROUND51 + shift;
+  case 8:
+    return SURROUND71 + shift;
+  }
+  return STEREO;
 }
+
+int start_audio_control(audio_ctx_t &ctx) {
+  ctx.sink_flag = std::make_unique<std::atomic_bool>(false);
+
+  if(!(ctx.control = platf::audio_control())) {
+    return -1;
+  }
+
+  auto sink = ctx.control->sink_info();
+  if(!sink) {
+    return -1;
+  }
+
+  // The default sink has not been replaced yet.
+  ctx.restore_sink = false;
+
+  ctx.sink = std::move(*sink);
+  return 0;
+}
+
+void stop_audio_control(audio_ctx_t &ctx) {
+  // restore audio-sink if applicable
+  if(!ctx.restore_sink) {
+    return;
+  }
+
+  const std::string &sink = config::audio.sink.empty() ? ctx.sink.host : config::audio.sink;
+  if(!sink.empty()) {
+    // Best effort, it's allowed to fail
+    ctx.control->set_sink(sink);
+  }
+}
+} // namespace audio

sunshine/audio.h

@@ -1,18 +1,45 @@
 #ifndef SUNSHINE_AUDIO_H
 #define SUNSHINE_AUDIO_H
 
-#include "utility.h"
 #include "thread_safe.h"
+#include "utility.h"
 namespace audio {
+enum stream_config_e : int {
+  STEREO,
+  SURROUND51,
+  HIGH_SURROUND51,
+  SURROUND71,
+  HIGH_SURROUND71,
+  MAX_STREAM_CONFIG
+};
+
+struct opus_stream_config_t {
+  std::int32_t sampleRate;
+  int channelCount;
+  int streams;
+  int coupledStreams;
+  const std::uint8_t *mapping;
+};
+
+extern opus_stream_config_t stream_configs[MAX_STREAM_CONFIG];
+
 struct config_t {
+  enum flags_e : int {
+    HIGH_QUALITY,
+    HOST_AUDIO,
+    MAX_FLAGS
+  };
+
   int packetDuration;
   int channels;
   int mask;
+
+  std::bitset<MAX_FLAGS> flags;
 };
 
-using packet_t = util::buffer_t<std::uint8_t>;
-using packet_queue_t = std::shared_ptr<safe::queue_t<std::pair<void*, packet_t>>>;
-void capture(safe::signal_t *shutdown_event, packet_queue_t packets, config_t config, void *channel_data);
-}
+using buffer_t = util::buffer_t<std::uint8_t>;
+using packet_t = std::pair<void *, buffer_t>;
+void capture(safe::mail_t mail, config_t config, void *channel_data);
+} // namespace audio
 
 #endif

sunshine/cbs.cpp

@@ -0,0 +1,300 @@
+extern "C" {
+#include <cbs/cbs_h264.h>
+#include <cbs/cbs_h265.h>
+#include <cbs/video_levels.h>
+#include <libavcodec/avcodec.h>
+#include <libavutil/pixdesc.h>
+}
+
+#include "cbs.h"
+#include "main.h"
+#include "utility.h"
+
+using namespace std::literals;
+namespace cbs {
+void close(CodedBitstreamContext *c) {
+  ff_cbs_close(&c);
+}
+
+using ctx_t = util::safe_ptr<CodedBitstreamContext, close>;
+
+class frag_t : public CodedBitstreamFragment {
+public:
+  frag_t(frag_t &&o) {
+    std::copy((std::uint8_t *)&o, (std::uint8_t *)(&o + 1), (std::uint8_t *)this);
+
+    o.data  = nullptr;
+    o.units = nullptr;
+  };
+
+  frag_t() {
+    std::fill_n((std::uint8_t *)this, sizeof(*this), 0);
+  }
+
+  frag_t &operator=(frag_t &&o) {
+    std::copy((std::uint8_t *)&o, (std::uint8_t *)(&o + 1), (std::uint8_t *)this);
+
+    o.data  = nullptr;
+    o.units = nullptr;
+
+    return *this;
+  };
+
+
+  ~frag_t() {
+    if(data || units) {
+      ff_cbs_fragment_free(this);
+    }
+  }
+};
+
+util::buffer_t<std::uint8_t> write(const cbs::ctx_t &cbs_ctx, std::uint8_t nal, void *uh, AVCodecID codec_id) {
+  cbs::frag_t frag;
+  auto err = ff_cbs_insert_unit_content(&frag, -1, nal, uh, nullptr);
+  if(err < 0) {
+    char err_str[AV_ERROR_MAX_STRING_SIZE] { 0 };
+    BOOST_LOG(error) << "Could not insert NAL unit SPS: "sv << av_make_error_string(err_str, AV_ERROR_MAX_STRING_SIZE, err);
+
+    return {};
+  }
+
+  err = ff_cbs_write_fragment_data(cbs_ctx.get(), &frag);
+  if(err < 0) {
+    char err_str[AV_ERROR_MAX_STRING_SIZE] { 0 };
+    BOOST_LOG(error) << "Could not write fragment data: "sv << av_make_error_string(err_str, AV_ERROR_MAX_STRING_SIZE, err);
+
+    return {};
+  }
+
+  // frag.data_size * 8 - frag.data_bit_padding == bits in fragment
+  util::buffer_t<std::uint8_t> data { frag.data_size };
+  std::copy_n(frag.data, frag.data_size, std::begin(data));
+
+  return data;
+}
+
+util::buffer_t<std::uint8_t> write(std::uint8_t nal, void *uh, AVCodecID codec_id) {
+  cbs::ctx_t cbs_ctx;
+  ff_cbs_init(&cbs_ctx, codec_id, nullptr);
+
+  return write(cbs_ctx, nal, uh, codec_id);
+}
+
+util::buffer_t<std::uint8_t> make_sps_h264(const AVCodecContext *ctx) {
+  H264RawSPS sps {};
+
+  /* b_per_p == ctx->max_b_frames for h264 */
+  /* desired_b_depth == avoption("b_depth") == 1 */
+  /* max_b_depth == std::min(av_log2(ctx->b_per_p) + 1, desired_b_depth) ==> 1 */
+  auto max_b_depth = 1;
+  auto dpb_frame   = ctx->gop_size == 1 ? 0 : 1 + max_b_depth;
+  auto mb_width    = (FFALIGN(ctx->width, 16) / 16) * 16;
+  auto mb_height   = (FFALIGN(ctx->height, 16) / 16) * 16;
+
+
+  sps.nal_unit_header.nal_ref_idc   = 3;
+  sps.nal_unit_header.nal_unit_type = H264_NAL_SPS;
+
+  sps.profile_idc = FF_PROFILE_H264_HIGH & 0xFF;
+
+  sps.constraint_set1_flag = 1;
+
+  if(ctx->level != FF_LEVEL_UNKNOWN) {
+    sps.level_idc = ctx->level;
+  }
+  else {
+    auto framerate = ctx->framerate;
+
+    auto level = ff_h264_guess_level(
+      sps.profile_idc,
+      ctx->bit_rate,
+      framerate.num / framerate.den,
+      mb_width,
+      mb_height,
+      dpb_frame);
+
+    if(!level) {
+      BOOST_LOG(error) << "Could not guess h264 level"sv;
+
+      return {};
+    }
+    sps.level_idc = level->level_idc;
+  }
+
+  sps.seq_parameter_set_id = 0;
+  sps.chroma_format_idc    = 1;
+
+  sps.log2_max_frame_num_minus4         = 3; //4;
+  sps.pic_order_cnt_type                = 0;
+  sps.log2_max_pic_order_cnt_lsb_minus4 = 0; //4;
+
+  sps.max_num_ref_frames = dpb_frame;
+
+  sps.pic_width_in_mbs_minus1        = mb_width / 16 - 1;
+  sps.pic_height_in_map_units_minus1 = mb_height / 16 - 1;
+
+  sps.frame_mbs_only_flag       = 1;
+  sps.direct_8x8_inference_flag = 1;
+
+  if(ctx->width != mb_width || ctx->height != mb_height) {
+    sps.frame_cropping_flag      = 1;
+    sps.frame_crop_left_offset   = 0;
+    sps.frame_crop_top_offset    = 0;
+    sps.frame_crop_right_offset  = (mb_width - ctx->width) / 2;
+    sps.frame_crop_bottom_offset = (mb_height - ctx->height) / 2;
+  }
+
+  sps.vui_parameters_present_flag = 1;
+
+  auto &vui = sps.vui;
+
+  vui.video_format                    = 5;
+  vui.colour_description_present_flag = 1;
+  vui.video_signal_type_present_flag  = 1;
+  vui.video_full_range_flag           = ctx->color_range == AVCOL_RANGE_JPEG;
+  vui.colour_primaries                = ctx->color_primaries;
+  vui.transfer_characteristics        = ctx->color_trc;
+  vui.matrix_coefficients             = ctx->colorspace;
+
+  vui.low_delay_hrd_flag = 1 - vui.fixed_frame_rate_flag;
+
+  vui.bitstream_restriction_flag              = 1;
+  vui.motion_vectors_over_pic_boundaries_flag = 1;
+  vui.log2_max_mv_length_horizontal           = 15;
+  vui.log2_max_mv_length_vertical             = 15;
+  vui.max_num_reorder_frames                  = max_b_depth;
+  vui.max_dec_frame_buffering                 = max_b_depth + 1;
+
+  return write(sps.nal_unit_header.nal_unit_type, (void *)&sps.nal_unit_header, AV_CODEC_ID_H264);
+}
+
+hevc_t make_sps_hevc(const AVCodecContext *avctx, const AVPacket *packet) {
+  cbs::ctx_t ctx;
+  if(ff_cbs_init(&ctx, AV_CODEC_ID_H265, nullptr)) {
+    return {};
+  }
+
+  cbs::frag_t frag;
+
+  int err = ff_cbs_read_packet(ctx.get(), &frag, packet);
+  if(err < 0) {
+    char err_str[AV_ERROR_MAX_STRING_SIZE] { 0 };
+    BOOST_LOG(error) << "Couldn't read packet: "sv << av_make_error_string(err_str, AV_ERROR_MAX_STRING_SIZE, err);
+
+    return {};
+  }
+
+
+  auto vps_p = ((CodedBitstreamH265Context *)ctx->priv_data)->active_vps;
+  auto sps_p = ((CodedBitstreamH265Context *)ctx->priv_data)->active_sps;
+
+  H265RawSPS sps { *sps_p };
+  H265RawVPS vps { *vps_p };
+
+  vps.profile_tier_level.general_profile_compatibility_flag[4] = 1;
+  sps.profile_tier_level.general_profile_compatibility_flag[4] = 1;
+
+  auto &vui = sps.vui;
+  std::memset(&vui, 0, sizeof(vui));
+
+  sps.vui_parameters_present_flag = 1;
+
+  // skip sample aspect ratio
+
+  vui.video_format                    = 5;
+  vui.colour_description_present_flag = 1;
+  vui.video_signal_type_present_flag  = 1;
+  vui.video_full_range_flag           = avctx->color_range == AVCOL_RANGE_JPEG;
+  vui.colour_primaries                = avctx->color_primaries;
+  vui.transfer_characteristics        = avctx->color_trc;
+  vui.matrix_coefficients             = avctx->colorspace;
+
+
+  vui.vui_timing_info_present_flag        = vps.vps_timing_info_present_flag;
+  vui.vui_num_units_in_tick               = vps.vps_num_units_in_tick;
+  vui.vui_time_scale                      = vps.vps_time_scale;
+  vui.vui_poc_proportional_to_timing_flag = vps.vps_poc_proportional_to_timing_flag;
+  vui.vui_num_ticks_poc_diff_one_minus1   = vps.vps_num_ticks_poc_diff_one_minus1;
+  vui.vui_hrd_parameters_present_flag     = 0;
+
+  vui.bitstream_restriction_flag              = 1;
+  vui.motion_vectors_over_pic_boundaries_flag = 1;
+  vui.restricted_ref_pic_lists_flag           = 1;
+  vui.max_bytes_per_pic_denom                 = 0;
+  vui.max_bits_per_min_cu_denom               = 0;
+  vui.log2_max_mv_length_horizontal           = 15;
+  vui.log2_max_mv_length_vertical             = 15;
+
+  cbs::ctx_t write_ctx;
+  ff_cbs_init(&write_ctx, AV_CODEC_ID_H265, nullptr);
+
+
+  return hevc_t {
+    nal_t {
+      write(write_ctx, vps.nal_unit_header.nal_unit_type, (void *)&vps.nal_unit_header, AV_CODEC_ID_H265),
+      write(ctx, vps_p->nal_unit_header.nal_unit_type, (void *)&vps_p->nal_unit_header, AV_CODEC_ID_H265),
+    },
+
+    nal_t {
+      write(write_ctx, sps.nal_unit_header.nal_unit_type, (void *)&sps.nal_unit_header, AV_CODEC_ID_H265),
+      write(ctx, sps_p->nal_unit_header.nal_unit_type, (void *)&sps_p->nal_unit_header, AV_CODEC_ID_H265),
+    },
+  };
+}
+
+util::buffer_t<std::uint8_t> read_sps_h264(const AVPacket *packet) {
+  cbs::ctx_t ctx;
+  if(ff_cbs_init(&ctx, AV_CODEC_ID_H264, nullptr)) {
+    return {};
+  }
+
+  cbs::frag_t frag;
+
+  int err = ff_cbs_read_packet(ctx.get(), &frag, &*packet);
+  if(err < 0) {
+    char err_str[AV_ERROR_MAX_STRING_SIZE] { 0 };
+    BOOST_LOG(error) << "Couldn't read packet: "sv << av_make_error_string(err_str, AV_ERROR_MAX_STRING_SIZE, err);
+
+    return {};
+  }
+
+  auto h264 = (H264RawNALUnitHeader *)((CodedBitstreamH264Context *)ctx->priv_data)->active_sps;
+  return write(h264->nal_unit_type, (void *)h264, AV_CODEC_ID_H264);
+}
+
+h264_t make_sps_h264(const AVCodecContext *ctx, const AVPacket *packet) {
+  return h264_t {
+    make_sps_h264(ctx),
+    read_sps_h264(packet),
+  };
+}
+
+bool validate_sps(const AVPacket *packet, int codec_id) {
+  cbs::ctx_t ctx;
+  if(ff_cbs_init(&ctx, (AVCodecID)codec_id, nullptr)) {
+    return false;
+  }
+
+  cbs::frag_t frag;
+
+  int err = ff_cbs_read_packet(ctx.get(), &frag, packet);
+  if(err < 0) {
+    char err_str[AV_ERROR_MAX_STRING_SIZE] { 0 };
+    BOOST_LOG(error) << "Couldn't read packet: "sv << av_make_error_string(err_str, AV_ERROR_MAX_STRING_SIZE, err);
+
+    return false;
+  }
+
+  if(codec_id == AV_CODEC_ID_H264) {
+    auto h264 = (CodedBitstreamH264Context *)ctx->priv_data;
+
+    if(!h264->active_sps->vui_parameters_present_flag) {
+      return false;
+    }
+
+    return true;
+  }
+
+  return ((CodedBitstreamH265Context *)ctx->priv_data)->active_sps->vui_parameters_present_flag;
+}
+} // namespace cbs

sunshine/cbs.h

@@ -0,0 +1,34 @@
+#ifndef SUNSHINE_CBS_H
+#define SUNSHINE_CBS_H
+
+#include "utility.h"
+
+struct AVPacket;
+struct AVCodecContext;
+
+namespace cbs {
+
+struct nal_t {
+  util::buffer_t<std::uint8_t> _new;
+  util::buffer_t<std::uint8_t> old;
+};
+
+struct hevc_t {
+  nal_t vps;
+  nal_t sps;
+};
+
+struct h264_t {
+  nal_t sps;
+};
+
+hevc_t make_sps_hevc(const AVCodecContext *ctx, const AVPacket *packet);
+h264_t make_sps_h264(const AVCodecContext *ctx, const AVPacket *packet);
+
+/**
+ * Check if SPS->VUI is present
+ */
+bool validate_sps(const AVPacket *packet, int codec_id);
+} // namespace cbs
+
+#endif

sunshine/config.cpp

@@ -1,12 +1,20 @@
+#include <algorithm>
+#include <filesystem>
 #include <fstream>
-#include <iostream>
 #include <functional>
+#include <iostream>
 #include <unordered_map>
 
 #include <boost/asio.hpp>
 
-#include "utility.h"
 #include "config.h"
+#include "main.h"
+#include "utility.h"
+
+#include "platform/common.h"
+
+namespace fs = std::filesystem;
+using namespace std::literals;
 
 #define CA_DIR "credentials"
 #define PRIVATE_KEY_FILE CA_DIR "/cakey.pem"
@@ -14,7 +22,6 @@
 
 #define APPS_JSON_PATH SUNSHINE_ASSETS_DIR "/" APPS_JSON
 namespace config {
-using namespace std::literals;
 
 namespace nv {
 enum preset_e : int {
@@ -33,12 +40,12 @@ enum preset_e : int {
 };
 
 enum rc_e : int {
-  constqp   = 0x0,       /**< Constant QP mode */
-  vbr       = 0x1,       /**< Variable bitrate mode */
-  cbr       = 0x2,       /**< Constant bitrate mode */
-  cbr_ld_hq = 0x8,       /**< low-delay CBR, high quality */
-  cbr_hq    = 0x10,      /**< CBR, high quality (slower) */
-  vbr_hq    = 0x20       /**< VBR, high quality (slower) */
+  constqp   = 0x0,  /**< Constant QP mode */
+  vbr       = 0x1,  /**< Variable bitrate mode */
+  cbr       = 0x2,  /**< Constant bitrate mode */
+  cbr_ld_hq = 0x8,  /**< low-delay CBR, high quality */
+  cbr_hq    = 0x10, /**< CBR, high quality (slower) */
+  vbr_hq    = 0x20  /**< VBR, high quality (slower) */
 };
 
 enum coder_e : int {
@@ -48,7 +55,8 @@ enum coder_e : int {
 };
 
 std::optional<preset_e> preset_from_view(const std::string_view &preset) {
-#define _CONVERT_(x) if(preset == #x##sv) return x
+#define _CONVERT_(x) \
+  if(preset == #x##sv) return x
   _CONVERT_(slow);
   _CONVERT_(medium);
   _CONVERT_(fast);
@@ -65,7 +73,8 @@ std::optional<preset_e> preset_from_view(const std::string_view &preset) {
 }
 
 std::optional<rc_e> rc_from_view(const std::string_view &rc) {
-#define _CONVERT_(x) if(rc == #x##sv) return x
+#define _CONVERT_(x) \
+  if(rc == #x##sv) return x
   _CONVERT_(constqp);
   _CONVERT_(vbr);
   _CONVERT_(cbr);
@@ -78,12 +87,12 @@ std::optional<rc_e> rc_from_view(const std::string_view &rc) {
 
 int coder_from_view(const std::string_view &coder) {
   if(coder == "auto"sv) return _auto;
-  if(coder == "cabac"sv  || coder == "ac"sv) return cabac;
-  if(coder == "cavlc"sv  || coder == "vlc"sv) return cavlc;
+  if(coder == "cabac"sv || coder == "ac"sv) return cabac;
+  if(coder == "cavlc"sv || coder == "vlc"sv) return cavlc;
 
   return -1;
 }
-}
+} // namespace nv
 
 namespace amd {
 enum quality_e : int {
@@ -107,7 +116,8 @@ enum coder_e : int {
 };
 
 std::optional<quality_e> quality_from_view(const std::string_view &quality) {
-#define _CONVERT_(x) if(quality == #x##sv) return x
+#define _CONVERT_(x) \
+  if(quality == #x##sv) return x
   _CONVERT_(speed);
   _CONVERT_(balanced);
   //_CONVERT_(quality2);
@@ -117,7 +127,8 @@ std::optional<quality_e> quality_from_view(const std::string_view &quality) {
 }
 
 std::optional<rc_e> rc_from_view(const std::string_view &rc) {
-#define _CONVERT_(x) if(rc == #x##sv) return x
+#define _CONVERT_(x) \
+  if(rc == #x##sv) return x
   _CONVERT_(constqp);
   _CONVERT_(vbr_latency);
   _CONVERT_(vbr_peak);
@@ -128,108 +139,190 @@ std::optional<rc_e> rc_from_view(const std::string_view &rc) {
 
 int coder_from_view(const std::string_view &coder) {
   if(coder == "auto"sv) return _auto;
-  if(coder == "cabac"sv  || coder == "ac"sv) return cabac;
-  if(coder == "cavlc"sv  || coder == "vlc"sv) return cavlc;
+  if(coder == "cabac"sv || coder == "ac"sv) return cabac;
+  if(coder == "cavlc"sv || coder == "vlc"sv) return cavlc;
 
   return -1;
 }
-}
+} // namespace amd
 
 video_t video {
-  0, // crf
+  0,  // crf
   28, // qp
 
   0, // hevc_mode
 
   1, // min_threads
   {
-    "superfast"s, // preset
+    "superfast"s,   // preset
     "zerolatency"s, // tune
-  }, // software
+  },                // software
 
   {
     nv::llhq,
     std::nullopt,
-    -1
-  }, // nv
+    -1 }, // nv
 
   {
     amd::balanced,
     std::nullopt,
-    -1
-  }, // amd  
+    -1 }, // amd
 
   {}, // encoder
   {}, // adapter_name
-  {},  // output_name
+  {}, // output_name
 };
 
 audio_t audio {};
 
 stream_t stream {
-  2s, // ping_timeout
+  10s, // ping_timeout
 
   APPS_JSON_PATH,
 
-  10, // fecPercentage
-  1 // channels
+  20, // fecPercentage
+  1   // channels
 };
 
 nvhttp_t nvhttp {
-  "lan", // origin_pin
+  "pc",  // origin_pin
+  "lan", // origin web manager
+
   PRIVATE_KEY_FILE,
   CERTIFICATE_FILE,
 
   boost::asio::ip::host_name(), // sunshine_name,
-  "sunshine_state.json"s // file_state
+  "sunshine_state.json"s,       // file_state
+  {},                           // external_ip
+  {
+    "352x240"s,
+    "480x360"s,
+    "858x480"s,
+    "1280x720"s,
+    "1920x1080"s,
+    "2560x1080"s,
+    "3440x1440"s
+    "1920x1200"s,
+    "3860x2160"s,
+    "3840x1600"s,
+  }, // supported resolutions
+
+  { 10, 30, 60, 90, 120 }, // supported fps
 };
 
 input_t input {
-  2s, // back_button_timeout
-  500ms, // key_repeat_delay
-  std::chrono::duration<double> { 1 / 24.9 }  // key_repeat_period
+  2s,                                        // back_button_timeout
+  500ms,                                     // key_repeat_delay
+  std::chrono::duration<double> { 1 / 24.9 } // key_repeat_period
 };
 
 sunshine_t sunshine {
-  2, // min_log_level
-  0 // flags
+  2,                                    // min_log_level
+  0,                                    // flags
+  {},                                   // User file
+  {},                                   // Username
+  {},                                   // Password
+  {},                                   // Password Salt
+  SUNSHINE_ASSETS_DIR "/sunshine.conf", // config file
+  {},                                   // cmd args
+  47989,
 };
 
-bool whitespace(char ch) {
+bool endline(char ch) {
+  return ch == '\r' || ch == '\n';
+}
+
+bool space_tab(char ch) {
   return ch == ' ' || ch == '\t';
 }
 
-std::string to_string(const char *begin, const char *end) {
-  return { begin, (std::size_t)(end - begin) };
+bool whitespace(char ch) {
+  return space_tab(ch) || endline(ch);
 }
 
-std::optional<std::pair<std::string, std::string>> parse_line(std::string_view::const_iterator begin, std::string_view::const_iterator end) {
-  begin = std::find_if(begin, end, std::not_fn(whitespace));
-  end   = std::find(begin, end, '#');
-  end   = std::find_if(std::make_reverse_iterator(end), std::make_reverse_iterator(begin), std::not_fn(whitespace)).base();
+std::string to_string(const char *begin, const char *end) {
+  std::string result;
 
-  auto eq = std::find(begin, end, '=');
-  if(eq == end || eq == begin) {
-    return std::nullopt;
+  KITTY_WHILE_LOOP(auto pos = begin, pos != end, {
+    auto comment = std::find(pos, end, '#');
+    auto endl    = std::find_if(comment, end, endline);
+
+    result.append(pos, comment);
+
+    pos = endl;
+  })
+
+  return result;
+}
+
+template<class It>
+It skip_list(It skipper, It end) {
+  int stack = 1;
+  while(skipper != end && stack) {
+    if(*skipper == '[') {
+      ++stack;
+    }
+    if(*skipper == ']') {
+      --stack;
+    }
+
+    ++skipper;
   }
 
-  auto end_name = std::find_if(std::make_reverse_iterator(eq), std::make_reverse_iterator(begin), std::not_fn(whitespace)).base();
-  auto begin_val = std::find_if(eq + 1, end, std::not_fn(whitespace));
-
-  return std::pair { to_string(begin, end_name), to_string(begin_val, end) };
+  return skipper;
 }
 
-std::unordered_map<std::string, std::string> parse_config(std::string_view file_content) {
+std::pair<
+  std::string_view::const_iterator,
+  std::optional<std::pair<std::string, std::string>>>
+parse_option(std::string_view::const_iterator begin, std::string_view::const_iterator end) {
+  begin     = std::find_if_not(begin, end, whitespace);
+  auto endl = std::find_if(begin, end, endline);
+  auto endc = std::find(begin, endl, '#');
+  endc      = std::find_if(std::make_reverse_iterator(endc), std::make_reverse_iterator(begin), std::not_fn(whitespace)).base();
+
+  auto eq = std::find(begin, endc, '=');
+  if(eq == endc || eq == begin) {
+    return std::make_pair(endl, std::nullopt);
+  }
+
+  auto end_name  = std::find_if_not(std::make_reverse_iterator(eq), std::make_reverse_iterator(begin), space_tab).base();
+  auto begin_val = std::find_if_not(eq + 1, endc, space_tab);
+
+  if(begin_val == endl) {
+    return std::make_pair(endl, std::nullopt);
+  }
+
+  // Lists might contain newlines
+  if(*begin_val == '[') {
+    endl = skip_list(begin_val + 1, end);
+    if(endl == end) {
+      std::cout << "Warning: Config option ["sv << to_string(begin, end_name) << "] Missing ']'"sv;
+
+      return std::make_pair(endl, std::nullopt);
+    }
+  }
+
+  return std::make_pair(
+    endl,
+    std::make_pair(to_string(begin, end_name), to_string(begin_val, endl)));
+}
+
+std::unordered_map<std::string, std::string> parse_config(const std::string_view &file_content) {
   std::unordered_map<std::string, std::string> vars;
 
   auto pos = std::begin(file_content);
   auto end = std::end(file_content);
 
   while(pos < end) {
-    auto newline = std::find_if(pos, end, [](auto ch) { return ch == '\n' || ch == '\r'; });
-    auto var = parse_line(pos, newline);
+    // auto newline = std::find_if(pos, end, [](auto ch) { return ch == '\n' || ch == '\r'; });
+    TUPLE_2D(endl, var, parse_option(pos, end));
+
+    pos = endl;
+    if(pos != end) {
+      pos += (*pos == '\r') ? 2 : 1;
+    }
 
-    pos = (*newline == '\r') ? newline + 2 : newline + 1;
     if(!var) {
       continue;
     }
@@ -263,6 +356,38 @@ void string_restricted_f(std::unordered_map<std::string, std::string> &vars, con
   }
 }
 
+void path_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, fs::path &input) {
+  // appdata needs to be retrieved once only
+  static auto appdata = platf::appdata();
+
+  std::string temp;
+  string_f(vars, name, temp);
+
+  if(!temp.empty()) {
+    input = temp;
+  }
+
+  if(input.is_relative()) {
+    input = appdata / input;
+  }
+
+  auto dir = input;
+  dir.remove_filename();
+
+  // Ensure the directories exists
+  if(!fs::exists(dir)) {
+    fs::create_directories(dir);
+  }
+}
+
+void path_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, std::string &input) {
+  fs::path temp = input;
+
+  path_f(vars, name, temp);
+
+  input = temp.string();
+}
+
 void int_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, int &input) {
   auto it = vars.find(name);
 
@@ -271,7 +396,7 @@ void int_f(std::unordered_map<std::string, std::string> &vars, const std::string
   }
 
   auto &val = it->second;
-  input = util::from_chars(&val[0], &val[0] + val.size());
+  input     = util::from_chars(&val[0], &val[0] + val.size());
 
   vars.erase(it);
 }
@@ -284,7 +409,7 @@ void int_f(std::unordered_map<std::string, std::string> &vars, const std::string
   }
 
   auto &val = it->second;
-  input = util::from_chars(&val[0], &val[0] + val.size());
+  input     = util::from_chars(&val[0], &val[0] + val.size());
 
   vars.erase(it);
 }
@@ -319,15 +444,17 @@ void int_between_f(std::unordered_map<std::string, std::string> &vars, const std
 }
 
 bool to_bool(std::string &boolean) {
-  std::for_each(std::begin(boolean), std::end(boolean), [](char ch)  { return (char)std::tolower(ch);  });
+  std::for_each(std::begin(boolean), std::end(boolean), [](char ch) { return (char)std::tolower(ch); });
 
-  return
-    boolean == "true"sv   ||
-    boolean == "yes"sv    ||
-    boolean == "enable"sv ||
-    (std::find(std::begin(boolean), std::end(boolean), '1') != std::end(boolean));
+  return boolean == "true"sv ||
+         boolean == "yes"sv ||
+         boolean == "enable"sv ||
+         boolean == "enabled"sv ||
+         boolean == "on"sv ||
+         (std::find(std::begin(boolean), std::end(boolean), '1') != std::end(boolean));
 }
-void bool_f(std::unordered_map<std::string, std::string> &vars, const std::string  &name, int &input) {
+
+void bool_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, bool &input) {
   std::string tmp;
   string_f(vars, name, tmp);
 
@@ -335,10 +462,10 @@ void bool_f(std::unordered_map<std::string, std::string> &vars, const std::strin
     return;
   }
 
-  input = to_bool(tmp) ? 1 : 0;
+  input = to_bool(tmp);
 }
 
-void double_f(std::unordered_map<std::string, std::string> &vars, const std::string  &name, double &input) {
+void double_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, double &input) {
   std::string tmp;
   string_f(vars, name, tmp);
 
@@ -367,33 +494,76 @@ void double_between_f(std::unordered_map<std::string, std::string> &vars, const
   }
 }
 
-void print_help(const char *name) {
-  std::cout <<
-    "Usage: "sv << name << " [options] [/path/to/configuration_file]"sv << std::endl <<
-    "    Any configurable option can be overwritten with: \"name=value\""sv << std::endl << std::endl <<
-    "    --help | print help"sv << std::endl << std::endl <<
-    "    flags"sv << std::endl <<
-    "        -0 | Read PIN from stdin"sv << std::endl <<
-    "        -1 | Do not load previously saved state and do retain any state after shutdown"sv << std::endl <<
-    "           | Effectively starting as if for the first time without overwriting any pairings with your devices"sv;
+void list_string_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, std::vector<std::string> &input) {
+  std::string string;
+  string_f(vars, name, string);
+
+  if(string.empty()) {
+    return;
+  }
+
+  input.clear();
+
+  auto begin = std::cbegin(string);
+  if(*begin == '[') {
+    ++begin;
+  }
+
+  begin = std::find_if_not(begin, std::cend(string), whitespace);
+  if(begin == std::cend(string)) {
+    return;
+  }
+
+  auto pos = begin;
+  while(pos < std::cend(string)) {
+    if(*pos == '[') {
+      pos = skip_list(pos + 1, std::cend(string)) + 1;
+    }
+    else if(*pos == ']') {
+      break;
+    }
+    else if(*pos == ',') {
+      input.emplace_back(begin, pos);
+      pos = begin = std::find_if_not(pos + 1, std::cend(string), whitespace);
+    }
+    else {
+      ++pos;
+    }
+  }
+
+  if(pos != begin) {
+    input.emplace_back(begin, pos);
+  }
+}
+
+void list_int_f(std::unordered_map<std::string, std::string> &vars, const std::string &name, std::vector<int> &input) {
+  std::vector<std::string> list;
+  list_string_f(vars, name, list);
+
+  for(auto &el : list) {
+    input.emplace_back(util::from_view(el));
+  }
 }
 
 int apply_flags(const char *line) {
   int ret = 0;
   while(*line != '\0') {
     switch(*line) {
-      case '0':
-        config::sunshine.flags[config::flag::PIN_STDIN].flip();
-        break;
-      case '1':
-        config::sunshine.flags[config::flag::FRESH_STATE].flip();
-        break;
-      case 'p':
-        config::sunshine.flags[config::flag::CONST_PIN].flip();
-        break;
-      default:
-        std::cout << "Warning: Unrecognized flag: ["sv << *line << ']' << std::endl;
-        ret = -1;
+    case '0':
+      config::sunshine.flags[config::flag::PIN_STDIN].flip();
+      break;
+    case '1':
+      config::sunshine.flags[config::flag::FRESH_STATE].flip();
+      break;
+    case '2':
+      config::sunshine.flags[config::flag::FORCE_VIDEO_HEADER_REPLACE].flip();
+      break;
+    case 'p':
+      config::sunshine.flags[config::flag::UPNP].flip();
+      break;
+    default:
+      std::cout << "Warning: Unrecognized flag: ["sv << *line << ']' << std::endl;
+      ret = -1;
     }
 
     ++line;
@@ -410,9 +580,7 @@ void apply_config(std::unordered_map<std::string, std::string> &&vars) {
   int_f(vars, "crf", video.crf);
   int_f(vars, "qp", video.qp);
   int_f(vars, "min_threads", video.min_threads);
-  int_between_f(vars, "hevc_mode", video.hevc_mode, {
-    0, 3
-  });
+  int_between_f(vars, "hevc_mode", video.hevc_mode, { 0, 3 });
   string_f(vars, "sw_preset", video.sw.preset);
   string_f(vars, "sw_tune", video.sw.tune);
   int_f(vars, "nv_preset", video.nv.preset, nv::preset_from_view);
@@ -427,34 +595,36 @@ void apply_config(std::unordered_map<std::string, std::string> &&vars) {
   string_f(vars, "adapter_name", video.adapter_name);
   string_f(vars, "output_name", video.output_name);
 
-  string_f(vars, "pkey", nvhttp.pkey);
-  string_f(vars, "cert", nvhttp.cert);
+  path_f(vars, "pkey", nvhttp.pkey);
+  path_f(vars, "cert", nvhttp.cert);
   string_f(vars, "sunshine_name", nvhttp.sunshine_name);
-  string_f(vars, "file_state", nvhttp.file_state);
+
+  path_f(vars, "file_state", nvhttp.file_state);
+
+  // Must be run after "file_state"
+  config::sunshine.credentials_file = config::nvhttp.file_state;
+  path_f(vars, "credentials_file", config::sunshine.credentials_file);
+
   string_f(vars, "external_ip", nvhttp.external_ip);
+  list_string_f(vars, "resolutions"s, nvhttp.resolutions);
+  list_int_f(vars, "fps"s, nvhttp.fps);
 
   string_f(vars, "audio_sink", audio.sink);
+  string_f(vars, "virtual_sink", audio.virtual_sink);
 
-  string_restricted_f(vars, "origin_pin_allowed", nvhttp.origin_pin_allowed, {
-    "pc"sv, "lan"sv, "wan"sv
-  });
+  string_restricted_f(vars, "origin_pin_allowed", nvhttp.origin_pin_allowed, { "pc"sv, "lan"sv, "wan"sv });
+  string_restricted_f(vars, "origin_web_ui_allowed", nvhttp.origin_web_ui_allowed, { "pc"sv, "lan"sv, "wan"sv });
 
   int to = -1;
-  int_between_f(vars, "ping_timeout", to, {
-    -1, std::numeric_limits<int>::max()
-  });
+  int_between_f(vars, "ping_timeout", to, { -1, std::numeric_limits<int>::max() });
   if(to != -1) {
     stream.ping_timeout = std::chrono::milliseconds(to);
   }
 
-  int_between_f(vars, "channels", stream.channels, {
-    1, std::numeric_limits<int>::max()
-  });
+  int_between_f(vars, "channels", stream.channels, { 1, std::numeric_limits<int>::max() });
 
-  string_f(vars, "file_apps", stream.file_apps);
-  int_between_f(vars, "fec_percentage", stream.fec_percentage, {
-    1, 100
-  });
+  path_f(vars, "file_apps", stream.file_apps);
+  int_between_f(vars, "fec_percentage", stream.fec_percentage, { 1, 255 });
 
   to = std::numeric_limits<int>::min();
   int_f(vars, "back_button_timeout", to);
@@ -464,12 +634,10 @@ void apply_config(std::unordered_map<std::string, std::string> &&vars) {
   }
 
   double repeat_frequency { 0 };
-  double_between_f(vars, "key_repeat_frequency", repeat_frequency, {
-    0, std::numeric_limits<double>::max()
-  });
+  double_between_f(vars, "key_repeat_frequency", repeat_frequency, { 0, std::numeric_limits<double>::max() });
 
   if(repeat_frequency > 0) {
-    config::input.key_repeat_period = std::chrono::duration<double> {1 / repeat_frequency };
+    config::input.key_repeat_period = std::chrono::duration<double> { 1 / repeat_frequency };
   }
 
   to = -1;
@@ -478,10 +646,19 @@ void apply_config(std::unordered_map<std::string, std::string> &&vars) {
     input.key_repeat_delay = std::chrono::milliseconds { to };
   }
 
+  int port = sunshine.port;
+  int_f(vars, "port"s, port);
+  sunshine.port = (std::uint16_t)port;
+
+  bool upnp = false;
+  bool_f(vars, "upnp"s, upnp);
+
+  if(upnp) {
+    config::sunshine.flags[config::flag::UPNP].flip();
+  }
+
   std::string log_level_string;
-  string_restricted_f(vars, "min_log_level", log_level_string, {
-    "verbose"sv, "debug"sv, "info"sv, "warning"sv, "error"sv, "fatal"sv, "none"sv
-  });
+  string_restricted_f(vars, "min_log_level", log_level_string, { "verbose"sv, "debug"sv, "info"sv, "warning"sv, "error"sv, "fatal"sv, "none"sv });
 
   if(!log_level_string.empty()) {
     if(log_level_string == "verbose"sv) {
@@ -505,6 +682,13 @@ void apply_config(std::unordered_map<std::string, std::string> &&vars) {
     else if(log_level_string == "none"sv) {
       sunshine.min_log_level = 6;
     }
+    else {
+      // accept digit directly
+      auto val = log_level_string[0];
+      if(val >= '0' && val < '7') {
+        sunshine.min_log_level = val - '0';
+      }
+    }
   }
 
   auto it = vars.find("flags"s);
@@ -515,18 +699,16 @@ void apply_config(std::unordered_map<std::string, std::string> &&vars) {
   }
 
   if(sunshine.min_log_level <= 3) {
-    for(auto &[var,_] : vars) {
+    for(auto &[var, _] : vars) {
       std::cout << "Warning: Unrecognized configurable option ["sv << var << ']' << std::endl;
     }
   }
 }
 
 int parse(int argc, char *argv[]) {
-  const char *config_file = SUNSHINE_ASSETS_DIR "/sunshine.conf";
-
   std::unordered_map<std::string, std::string> cmd_vars;
 
-  for(auto x = argc -1; x > 0; --x) {
+  for(auto x = 1; x < argc; ++x) {
     auto line = argv[x];
 
     if(line == "--help"sv) {
@@ -534,6 +716,13 @@ int parse(int argc, char *argv[]) {
       return 1;
     }
     else if(*line == '-') {
+      if(*(line + 1) == '-') {
+        sunshine.cmd.name = line + 2;
+        sunshine.cmd.argc = argc - x - 1;
+        sunshine.cmd.argv = argv + x + 1;
+
+        break;
+      }
       if(apply_flags(line + 1)) {
         print_help(*argv);
         return -1;
@@ -544,35 +733,30 @@ int parse(int argc, char *argv[]) {
 
       auto pos = std::find(line, line_end, '=');
       if(pos == line_end) {
-        config_file = line;
+        sunshine.config_file = line;
       }
       else {
-        auto var = parse_line(line, line_end);
+        TUPLE_EL(var, 1, parse_option(line, line_end));
         if(!var) {
           print_help(*argv);
           return -1;
         }
 
+        TUPLE_EL_REF(name, 0, *var);
+
+        auto it = cmd_vars.find(name);
+        if(it != std::end(cmd_vars)) {
+          cmd_vars.erase(it);
+        }
+
         cmd_vars.emplace(std::move(*var));
       }
     }
   }
 
-  std::ifstream in { config_file };
+  auto vars = parse_config(read_file(sunshine.config_file.c_str()));
 
-  if(!in.is_open()) {
-    std::cout << "Error: Couldn't open "sv << config_file << std::endl;
-
-    return -1;
-  }
-
-  auto vars = parse_config(std::string {
-    // Quick and dirty
-    std::istreambuf_iterator<char>(in),
-    std::istreambuf_iterator<char>()
-  });
-
-  for(auto &[name,value] : cmd_vars) {
+  for(auto &[name, value] : cmd_vars) {
     vars.insert_or_assign(std::move(name), std::move(value));
   }
 
@@ -580,4 +764,4 @@ int parse(int argc, char *argv[]) {
 
   return 0;
 }
-}
+} // namespace config

sunshine/config.h

@@ -1,16 +1,18 @@
 #ifndef SUNSHINE_CONFIG_H
 #define SUNSHINE_CONFIG_H
 
-#include <chrono>
-#include <string>
 #include <bitset>
+#include <chrono>
 #include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 namespace config {
 struct video_t {
   // ffmpeg params
   int crf; // higher == more compression and less quality
-  int qp; // higher == more compression and less quality, ignored if crf != 0
+  int qp;  // higher == more compression and less quality, ignored if crf != 0
 
   int hevc_mode;
 
@@ -39,6 +41,7 @@ struct video_t {
 
 struct audio_t {
   std::string sink;
+  std::string virtual_sink;
 };
 
 struct stream_t {
@@ -56,6 +59,7 @@ struct nvhttp_t {
   // Could be any of the following values:
   // pc|lan|wan
   std::string origin_pin_allowed;
+  std::string origin_web_ui_allowed;
 
   std::string pkey; // must be 2048 bits
   std::string cert; // must be signed with a key of 2048 bits
@@ -65,6 +69,8 @@ struct nvhttp_t {
   std::string file_state;
 
   std::string external_ip;
+  std::vector<std::string> resolutions;
+  std::vector<int> fps;
 };
 
 struct input_t {
@@ -75,17 +81,33 @@ struct input_t {
 
 namespace flag {
 enum flag_e : std::size_t {
-  PIN_STDIN = 0, // Read PIN from stdin instead of http
-  FRESH_STATE, // Do not load or save state
-  FLAG_SIZE,
-  CONST_PIN= 4 // Use "universal" pin
+  PIN_STDIN = 0,              // Read PIN from stdin instead of http
+  FRESH_STATE,                // Do not load or save state
+  FORCE_VIDEO_HEADER_REPLACE, // force replacing headers inside video data
+  UPNP,                       // Try Universal Plug 'n Play
+  CONST_PIN,                  // Use "universal" pin
+  FLAG_SIZE
 };
 }
 
 struct sunshine_t {
   int min_log_level;
-
   std::bitset<flag::FLAG_SIZE> flags;
+  std::string credentials_file;
+
+  std::string username;
+  std::string password;
+  std::string salt;
+
+  std::string config_file;
+
+  struct cmd_t {
+    std::string name;
+    int argc;
+    char **argv;
+  } cmd;
+
+  std::uint16_t port;
 };
 
 extern video_t video;
@@ -96,6 +118,6 @@ extern input_t input;
 extern sunshine_t sunshine;
 
 int parse(int argc, char *argv[]);
-}
-
+std::unordered_map<std::string, std::string> parse_config(const std::string_view &file_content);
+} // namespace config
 #endif

sunshine/confighttp.cpp

@@ -0,0 +1,515 @@
+//
+// Created by TheElixZammuto on 2021-05-09.
+// TODO: Authentication, better handling of routes common to nvhttp, cleanup
+
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
+
+#include "process.h"
+
+#include <filesystem>
+
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+
+#include <boost/asio/ssl/context.hpp>
+
+#include <Simple-Web-Server/crypto.hpp>
+#include <Simple-Web-Server/server_https.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+
+#include "config.h"
+#include "confighttp.h"
+#include "crypto.h"
+#include "httpcommon.h"
+#include "main.h"
+#include "network.h"
+#include "nvhttp.h"
+#include "platform/common.h"
+#include "rtsp.h"
+#include "utility.h"
+#include "uuid.h"
+
+using namespace std::literals;
+
+namespace confighttp {
+namespace fs = std::filesystem;
+namespace pt = boost::property_tree;
+
+using https_server_t = SimpleWeb::Server<SimpleWeb::HTTPS>;
+
+using args_t       = SimpleWeb::CaseInsensitiveMultimap;
+using resp_https_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Response>;
+using req_https_t  = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Request>;
+
+enum class op_e {
+  ADD,
+  REMOVE
+};
+
+void print_req(const req_https_t &request) {
+  BOOST_LOG(debug) << "METHOD :: "sv << request->method;
+  BOOST_LOG(debug) << "DESTINATION :: "sv << request->path;
+
+  for(auto &[name, val] : request->header) {
+    BOOST_LOG(debug) << name << " -- " << val;
+  }
+
+  BOOST_LOG(debug) << " [--] "sv;
+
+  for(auto &[name, val] : request->parse_query_string()) {
+    BOOST_LOG(debug) << name << " -- " << val;
+  }
+
+  BOOST_LOG(debug) << " [--] "sv;
+}
+
+void send_unauthorized(resp_https_t response, req_https_t request) {
+  auto address = request->remote_endpoint_address();
+  BOOST_LOG(info) << "Web UI: ["sv << address << "] -- not authorized"sv;
+  const SimpleWeb::CaseInsensitiveMultimap headers {
+    { "WWW-Authenticate", R"(Basic realm="Sunshine Gamestream Host", charset="UTF-8")" }
+  };
+  response->write(SimpleWeb::StatusCode::client_error_unauthorized, headers);
+}
+
+bool authenticate(resp_https_t response, req_https_t request) {
+  auto address = request->remote_endpoint_address();
+  auto ip_type = net::from_address(address);
+
+  if(ip_type > http::origin_web_ui_allowed) {
+    BOOST_LOG(info) << "Web UI: ["sv << address << "] -- denied"sv;
+    response->write(SimpleWeb::StatusCode::client_error_forbidden);
+    return false;
+  }
+
+  auto fg = util::fail_guard([&]() {
+    send_unauthorized(response, request);
+  });
+
+  auto auth = request->header.find("authorization");
+  if(auth == request->header.end()) {
+    return false;
+  }
+
+  auto &rawAuth = auth->second;
+  auto authData = SimpleWeb::Crypto::Base64::decode(rawAuth.substr("Basic "sv.length()));
+
+  int index = authData.find(':');
+  if(index >= authData.size() - 1) {
+    return false;
+  }
+
+  auto username = authData.substr(0, index);
+  auto password = authData.substr(index + 1);
+  auto hash     = util::hex(crypto::hash(password + config::sunshine.salt)).to_string();
+
+  if(username != config::sunshine.username || hash != config::sunshine.password) {
+    return false;
+  }
+
+  fg.disable();
+  return true;
+}
+
+void not_found(resp_https_t response, req_https_t request) {
+  pt::ptree tree;
+  tree.put("root.<xmlattr>.status_code", 404);
+
+  std::ostringstream data;
+
+  pt::write_xml(data, tree);
+  response->write(data.str());
+
+  *response << "HTTP/1.1 404 NOT FOUND\r\n"
+            << data.str();
+}
+
+void getIndexPage(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string header  = read_file(WEB_DIR "header.html");
+  std::string content = read_file(WEB_DIR "index.html");
+  response->write(header + content);
+}
+
+void getPinPage(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string header  = read_file(WEB_DIR "header.html");
+  std::string content = read_file(WEB_DIR "pin.html");
+  response->write(header + content);
+}
+
+void getAppsPage(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string header  = read_file(WEB_DIR "header.html");
+  std::string content = read_file(WEB_DIR "apps.html");
+  response->write(header + content);
+}
+
+void getClientsPage(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string header  = read_file(WEB_DIR "header.html");
+  std::string content = read_file(WEB_DIR "clients.html");
+  response->write(header + content);
+}
+
+void getConfigPage(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string header  = read_file(WEB_DIR "header.html");
+  std::string content = read_file(WEB_DIR "config.html");
+  response->write(header + content);
+}
+
+void getPasswordPage(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string header  = read_file(WEB_DIR "header.html");
+  std::string content = read_file(WEB_DIR "password.html");
+  response->write(header + content);
+}
+
+void getApps(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::string content = read_file(config::stream.file_apps.c_str());
+  response->write(content);
+}
+
+void saveApp(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::stringstream ss;
+  ss << request->content.rdbuf();
+
+  pt::ptree outputTree;
+  auto g = util::fail_guard([&]() {
+    std::ostringstream data;
+
+    pt::write_json(data, outputTree);
+    response->write(data.str());
+  });
+
+  pt::ptree inputTree, fileTree;
+
+  BOOST_LOG(fatal) << config::stream.file_apps;
+  try {
+    //TODO: Input Validation
+    pt::read_json(ss, inputTree);
+    pt::read_json(config::stream.file_apps, fileTree);
+
+    if(inputTree.get_child("prep-cmd").empty()) {
+      inputTree.erase("prep-cmd");
+    }
+
+    if(inputTree.get_child("detached").empty()) {
+      inputTree.erase("detached");
+    }
+
+    auto &apps_node = fileTree.get_child("apps"s);
+    int index       = inputTree.get<int>("index");
+
+    inputTree.erase("index");
+
+    if(index == -1) {
+      apps_node.push_back(std::make_pair("", inputTree));
+    }
+    else {
+      //Unfortuantely Boost PT does not allow to directly edit the array, copy should do the trick
+      pt::ptree newApps;
+      int i = 0;
+      for(const auto &kv : apps_node) {
+        if(i == index) {
+          newApps.push_back(std::make_pair("", inputTree));
+        }
+        else {
+          newApps.push_back(std::make_pair("", kv.second));
+        }
+        i++;
+      }
+      fileTree.erase("apps");
+      fileTree.push_back(std::make_pair("apps", newApps));
+    }
+    pt::write_json(config::stream.file_apps, fileTree);
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(warning) << "SaveApp: "sv << e.what();
+
+    outputTree.put("status", "false");
+    outputTree.put("error", "Invalid Input JSON");
+    return;
+  }
+
+  outputTree.put("status", "true");
+  proc::refresh(config::stream.file_apps);
+}
+
+void deleteApp(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  pt::ptree outputTree;
+  auto g = util::fail_guard([&]() {
+    std::ostringstream data;
+
+    pt::write_json(data, outputTree);
+    response->write(data.str());
+  });
+  pt::ptree fileTree;
+  try {
+    pt::read_json(config::stream.file_apps, fileTree);
+    auto &apps_node = fileTree.get_child("apps"s);
+    int index       = stoi(request->path_match[1]);
+
+    if(index < 0) {
+      outputTree.put("status", "false");
+      outputTree.put("error", "Invalid Index");
+      return;
+    }
+    else {
+      //Unfortuantely Boost PT does not allow to directly edit the array, copy should do the trick
+      pt::ptree newApps;
+      int i = 0;
+      for(const auto &kv : apps_node) {
+        if(i++ != index) {
+          newApps.push_back(std::make_pair("", kv.second));
+        }
+      }
+      fileTree.erase("apps");
+      fileTree.push_back(std::make_pair("apps", newApps));
+    }
+    pt::write_json(config::stream.file_apps, fileTree);
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(warning) << "DeleteApp: "sv << e.what();
+    outputTree.put("status", "false");
+    outputTree.put("error", "Invalid File JSON");
+    return;
+  }
+
+  outputTree.put("status", "true");
+  proc::refresh(config::stream.file_apps);
+}
+
+void getConfig(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  pt::ptree outputTree;
+  auto g = util::fail_guard([&]() {
+    std::ostringstream data;
+
+    pt::write_json(data, outputTree);
+    response->write(data.str());
+  });
+
+  outputTree.put("status", "true");
+  outputTree.put("platform", SUNSHINE_PLATFORM);
+
+  auto vars = config::parse_config(read_file(config::sunshine.config_file.c_str()));
+
+  for(auto &[name, value] : vars) {
+    outputTree.put(std::move(name), std::move(value));
+  }
+}
+
+void saveConfig(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::stringstream ss;
+  std::stringstream configStream;
+  ss << request->content.rdbuf();
+  pt::ptree outputTree;
+  auto g = util::fail_guard([&]() {
+    std::ostringstream data;
+
+    pt::write_json(data, outputTree);
+    response->write(data.str());
+  });
+  pt::ptree inputTree;
+  try {
+    //TODO: Input Validation
+    pt::read_json(ss, inputTree);
+    for(const auto &kv : inputTree) {
+      std::string value = inputTree.get<std::string>(kv.first);
+      if(value.length() == 0 || value.compare("null") == 0) continue;
+
+      configStream << kv.first << " = " << value << std::endl;
+    }
+    write_file(config::sunshine.config_file.c_str(), configStream.str());
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(warning) << "SaveConfig: "sv << e.what();
+    outputTree.put("status", "false");
+    outputTree.put("error", e.what());
+    return;
+  }
+}
+
+void savePassword(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::stringstream ss;
+  std::stringstream configStream;
+  ss << request->content.rdbuf();
+
+  pt::ptree inputTree, outputTree;
+
+  auto g = util::fail_guard([&]() {
+    std::ostringstream data;
+    pt::write_json(data, outputTree);
+    response->write(data.str());
+  });
+
+  try {
+    //TODO: Input Validation
+    pt::read_json(ss, inputTree);
+    auto username        = inputTree.get<std::string>("currentUsername");
+    auto newUsername     = inputTree.get<std::string>("newUsername");
+    auto password        = inputTree.get<std::string>("currentPassword");
+    auto newPassword     = inputTree.get<std::string>("newPassword");
+    auto confirmPassword = inputTree.get<std::string>("confirmNewPassword");
+    if(newUsername.length() == 0) newUsername = username;
+
+    auto hash = util::hex(crypto::hash(password + config::sunshine.salt)).to_string();
+    if(username == config::sunshine.username && hash == config::sunshine.password) {
+      if(newPassword != confirmPassword) {
+        outputTree.put("status", false);
+        outputTree.put("error", "Password Mismatch");
+      }
+
+      http::save_user_creds(config::sunshine.credentials_file, newUsername, newPassword);
+      http::reload_user_creds(config::sunshine.credentials_file);
+      outputTree.put("status", true);
+    }
+    else {
+      outputTree.put("status", false);
+      outputTree.put("error", "Invalid Current Credentials");
+    }
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(warning) << "SavePassword: "sv << e.what();
+    outputTree.put("status", false);
+    outputTree.put("error", e.what());
+    return;
+  }
+}
+
+void savePin(resp_https_t response, req_https_t request) {
+  if(!authenticate(response, request)) return;
+
+  print_req(request);
+
+  std::stringstream ss;
+  ss << request->content.rdbuf();
+
+  pt::ptree inputTree, outputTree;
+
+  auto g = util::fail_guard([&]() {
+    std::ostringstream data;
+    pt::write_json(data, outputTree);
+    response->write(data.str());
+  });
+
+  try {
+    //TODO: Input Validation
+    pt::read_json(ss, inputTree);
+    std::string pin = inputTree.get<std::string>("pin");
+    outputTree.put("status", nvhttp::pin(pin));
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(warning) << "SavePin: "sv << e.what();
+    outputTree.put("status", false);
+    outputTree.put("error", e.what());
+    return;
+  }
+}
+
+void start() {
+  auto shutdown_event = mail::man->event<bool>(mail::shutdown);
+
+  auto port_https = map_port(PORT_HTTPS);
+
+  auto ctx = std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::tls);
+  ctx->use_certificate_chain_file(config::nvhttp.cert);
+  ctx->use_private_key_file(config::nvhttp.pkey, boost::asio::ssl::context::pem);
+  https_server_t server { ctx, 0 };
+  server.default_resource                           = not_found;
+  server.resource["^/$"]["GET"]                     = getIndexPage;
+  server.resource["^/pin$"]["GET"]                  = getPinPage;
+  server.resource["^/apps$"]["GET"]                 = getAppsPage;
+  server.resource["^/clients$"]["GET"]              = getClientsPage;
+  server.resource["^/config$"]["GET"]               = getConfigPage;
+  server.resource["^/password$"]["GET"]             = getPasswordPage;
+  server.resource["^/api/pin"]["POST"]              = savePin;
+  server.resource["^/api/apps$"]["GET"]             = getApps;
+  server.resource["^/api/apps$"]["POST"]            = saveApp;
+  server.resource["^/api/config$"]["GET"]           = getConfig;
+  server.resource["^/api/config$"]["POST"]          = saveConfig;
+  server.resource["^/api/password$"]["POST"]        = savePassword;
+  server.resource["^/api/apps/([0-9]+)$"]["DELETE"] = deleteApp;
+  server.config.reuse_address                       = true;
+  server.config.address                             = "0.0.0.0"s;
+  server.config.port                                = port_https;
+
+  try {
+    server.bind();
+    BOOST_LOG(info) << "Configuration UI available at [https://localhost:"sv << port_https << "]";
+  }
+  catch(boost::system::system_error &err) {
+    BOOST_LOG(fatal) << "Couldn't bind http server to ports ["sv << port_https << "]: "sv << err.what();
+
+    shutdown_event->raise(true);
+    return;
+  }
+  auto accept_and_run = [&](auto *server) {
+    try {
+      server->accept_and_run();
+    }
+    catch(boost::system::system_error &err) {
+      // It's possible the exception gets thrown after calling server->stop() from a different thread
+      if(shutdown_event->peek()) {
+        return;
+      }
+
+      BOOST_LOG(fatal) << "Couldn't start Configuration HTTPS server to port ["sv << port_https << "]: "sv << err.what();
+      shutdown_event->raise(true);
+      return;
+    }
+  };
+  std::thread tcp { accept_and_run, &server };
+
+  // Wait for any event
+  shutdown_event->view();
+
+  server.stop();
+
+  tcp.join();
+}
+} // namespace confighttp

sunshine/confighttp.h

@@ -0,0 +1,21 @@
+//
+// Created by loki on 6/3/19.
+//
+
+#ifndef SUNSHINE_CONFIGHTTP_H
+#define SUNSHINE_CONFIGHTTP_H
+
+#include <functional>
+#include <string>
+
+#include "thread_safe.h"
+
+#define WEB_DIR SUNSHINE_ASSETS_DIR "/web/"
+
+
+namespace confighttp {
+constexpr auto PORT_HTTPS = 1;
+void start();
+} // namespace confighttp
+
+#endif //SUNSHINE_CONFIGHTTP_H

sunshine/crypto.cpp

@@ -2,14 +2,15 @@
 // Created by loki on 5/31/19.
 //
 
-#include <openssl/pem.h>
 #include "crypto.h"
+#include <openssl/pem.h>
+
 namespace crypto {
 using big_num_t = util::safe_ptr<BIGNUM, BN_free>;
 //using rsa_t = util::safe_ptr<RSA, RSA_free>;
 using asn1_string_t = util::safe_ptr<ASN1_STRING, ASN1_STRING_free>;
 
-cert_chain_t::cert_chain_t() : _certs {}, _cert_ctx {X509_STORE_CTX_new() } {}
+cert_chain_t::cert_chain_t() : _certs {}, _cert_ctx { X509_STORE_CTX_new() } {}
 void cert_chain_t::add(x509_t &&cert) {
   x509_store_t x509_store { X509_STORE_new() };
 
@@ -17,6 +18,26 @@ void cert_chain_t::add(x509_t &&cert) {
   _certs.emplace_back(std::make_pair(std::move(cert), std::move(x509_store)));
 }
 
+static int openssl_verify_cb(int ok, X509_STORE_CTX *ctx) {
+  int err_code = X509_STORE_CTX_get_error(ctx);
+
+  switch(err_code) {
+  //FIXME: Checking for X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY is a temporary workaround to get mmonlight-embedded to work on the raspberry pi
+  case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
+    return 1;
+
+  // Expired or not-yet-valid certificates are fine. Sometimes Moonlight is running on embedded devices
+  // that don't have accurate clocks (or haven't yet synchronized by the time Moonlight first runs).
+  // This behavior also matches what GeForce Experience does.
+  case X509_V_ERR_CERT_NOT_YET_VALID:
+  case X509_V_ERR_CERT_HAS_EXPIRED:
+    return 1;
+
+  default:
+    return ok;
+  }
+}
+
 /*
  * When certificates from two or more instances of Moonlight have been added to x509_store_t,
  * only one of them will be verified by X509_verify_cert, resulting in only a single instance of
@@ -26,27 +47,24 @@ void cert_chain_t::add(x509_t &&cert) {
  */
 const char *cert_chain_t::verify(x509_t::element_type *cert) {
   int err_code = 0;
-  for(auto &[_,x509_store] : _certs) {
+  for(auto &[_, x509_store] : _certs) {
     auto fg = util::fail_guard([this]() {
       X509_STORE_CTX_cleanup(_cert_ctx.get());
     });
 
     X509_STORE_CTX_init(_cert_ctx.get(), x509_store.get(), nullptr, nullptr);
+    X509_STORE_CTX_set_verify_cb(_cert_ctx.get(), openssl_verify_cb);
     X509_STORE_CTX_set_cert(_cert_ctx.get(), cert);
 
     auto err = X509_verify_cert(_cert_ctx.get());
 
-    if (err == 1) {
+    if(err == 1) {
       return nullptr;
     }
 
     err_code = X509_STORE_CTX_get_error(_cert_ctx.get());
 
-    //FIXME: Checking for X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY is a temporary workaround to get mmonlight-embedded to work on the raspberry pi
-    if(err_code == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY) {
-      return nullptr;
-    }
-    if (err_code != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT && err_code != X509_V_ERR_INVALID_CA) {
+    if(err_code != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT && err_code != X509_V_ERR_INVALID_CA) {
       return X509_verify_cert_error_string(err_code);
     }
   }
@@ -54,71 +72,91 @@ const char *cert_chain_t::verify(x509_t::element_type *cert) {
   return X509_verify_cert_error_string(err_code);
 }
 
-cipher_t::cipher_t(const crypto::aes_t &key) : ctx { EVP_CIPHER_CTX_new() }, key { key }, padding { true } {}
-int cipher_t::decrypt(const std::string_view &cipher, std::vector<std::uint8_t> &plaintext) {
-  int len;
+namespace cipher {
 
-  auto fg = util::fail_guard([this]() {
-    EVP_CIPHER_CTX_reset(ctx.get());
-  });
+static int init_decrypt_gcm(cipher_ctx_t &ctx, aes_t *key, aes_t *iv, bool padding) {
+  ctx.reset(EVP_CIPHER_CTX_new());
 
-  // Gen 7 servers use 128-bit AES ECB
-  if (EVP_DecryptInit_ex(ctx.get(), EVP_aes_128_ecb(), nullptr, key.data(), nullptr) != 1) {
+  if(!ctx) {
     return -1;
   }
 
+  if(EVP_DecryptInit_ex(ctx.get(), EVP_aes_128_gcm(), nullptr, nullptr, nullptr) != 1) {
+    return -1;
+  }
+
+  if(EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_IVLEN, iv->size(), nullptr) != 1) {
+    return -1;
+  }
+
+  if(EVP_DecryptInit_ex(ctx.get(), nullptr, nullptr, key->data(), iv->data()) != 1) {
+    return -1;
+  }
   EVP_CIPHER_CTX_set_padding(ctx.get(), padding);
 
-  plaintext.resize((cipher.size() + 15) / 16 * 16);
-  auto size = (int)plaintext.size();
-  // Encrypt into the caller's buffer, leaving room for the auth tag to be prepended
-  if (EVP_DecryptUpdate(ctx.get(), plaintext.data(), &size, (const std::uint8_t*)cipher.data(), cipher.size()) != 1) {
-    return -1;
-  }
-
-  if (EVP_DecryptFinal_ex(ctx.get(), plaintext.data(), &len) != 1) {
-    return -1;
-  }
-
-  plaintext.resize(len + size);
   return 0;
 }
 
-int cipher_t::decrypt_gcm(aes_t &iv, const std::string_view &tagged_cipher,
-                          std::vector<std::uint8_t> &plaintext) {
-  auto cipher = tagged_cipher.substr(16);
-  auto tag    = tagged_cipher.substr(0, 16);
+static int init_encrypt_gcm(cipher_ctx_t &ctx, aes_t *key, aes_t *iv, bool padding) {
+  ctx.reset(EVP_CIPHER_CTX_new());
 
-  auto fg = util::fail_guard([this]() {
-    EVP_CIPHER_CTX_reset(ctx.get());
-  });
-
-  if (EVP_DecryptInit_ex(ctx.get(), EVP_aes_128_gcm(), nullptr, nullptr, nullptr) != 1) {
+  // Gen 7 servers use 128-bit AES ECB
+  if(EVP_EncryptInit_ex(ctx.get(), EVP_aes_128_gcm(), nullptr, nullptr, nullptr) != 1) {
     return -1;
   }
 
-  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_IVLEN, iv.size(), nullptr) != 1) {
+  if(EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_IVLEN, iv->size(), nullptr) != 1) {
     return -1;
   }
 
-  if (EVP_DecryptInit_ex(ctx.get(), nullptr, nullptr, key.data(), iv.data()) != 1) {
+  if(EVP_EncryptInit_ex(ctx.get(), nullptr, nullptr, key->data(), iv->data()) != 1) {
+    return -1;
+  }
+  EVP_CIPHER_CTX_set_padding(ctx.get(), padding);
+
+  return 0;
+}
+
+static int init_encrypt_cbc(cipher_ctx_t &ctx, aes_t *key, aes_t *iv, bool padding) {
+  ctx.reset(EVP_CIPHER_CTX_new());
+
+  // Gen 7 servers use 128-bit AES ECB
+  if(EVP_EncryptInit_ex(ctx.get(), EVP_aes_128_cbc(), nullptr, key->data(), iv->data()) != 1) {
     return -1;
   }
 
   EVP_CIPHER_CTX_set_padding(ctx.get(), padding);
-  plaintext.resize((cipher.size() + 15) / 16 * 16);
 
-  int size;
-  if (EVP_DecryptUpdate(ctx.get(), plaintext.data(), &size, (const std::uint8_t*)cipher.data(), cipher.size()) != 1) {
+  return 0;
+}
+
+int gcm_t::decrypt(const std::string_view &tagged_cipher, std::vector<std::uint8_t> &plaintext, aes_t *iv) {
+  if(!decrypt_ctx && init_decrypt_gcm(decrypt_ctx, &key, iv, padding)) {
     return -1;
   }
 
-  if (EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_TAG, tag.size(), const_cast<char*>(tag.data())) != 1) {
+  // Calling with cipher == nullptr results in a parameter change
+  // without requiring a reallocation of the internal cipher ctx.
+  if(EVP_DecryptInit_ex(decrypt_ctx.get(), nullptr, nullptr, nullptr, iv->data()) != 1) {
+    return false;
+  }
+
+  auto cipher = tagged_cipher.substr(tag_size);
+  auto tag    = tagged_cipher.substr(0, tag_size);
+
+  plaintext.resize((cipher.size() + 15) / 16 * 16);
+
+  int size;
+  if(EVP_DecryptUpdate(decrypt_ctx.get(), plaintext.data(), &size, (const std::uint8_t *)cipher.data(), cipher.size()) != 1) {
+    return -1;
+  }
+
+  if(EVP_CIPHER_CTX_ctrl(decrypt_ctx.get(), EVP_CTRL_GCM_SET_TAG, tag.size(), const_cast<char *>(tag.data())) != 1) {
     return -1;
   }
 
   int len = size;
-  if (EVP_DecryptFinal_ex(ctx.get(), plaintext.data() + size, &len) != 1) {
+  if(EVP_DecryptFinal_ex(decrypt_ctx.get(), plaintext.data() + size, &len) != 1) {
     return -1;
   }
 
@@ -126,28 +164,92 @@ int cipher_t::decrypt_gcm(aes_t &iv, const std::string_view &tagged_cipher,
   return 0;
 }
 
-int cipher_t::encrypt(const std::string_view &plaintext, std::vector<std::uint8_t> &cipher) {
+int gcm_t::encrypt(const std::string_view &plaintext, std::uint8_t *tagged_cipher, aes_t *iv) {
+  if(!encrypt_ctx && init_encrypt_gcm(encrypt_ctx, &key, iv, padding)) {
+    return -1;
+  }
+
+  // Calling with cipher == nullptr results in a parameter change
+  // without requiring a reallocation of the internal cipher ctx.
+  if(EVP_EncryptInit_ex(encrypt_ctx.get(), nullptr, nullptr, nullptr, iv->data()) != 1) {
+    return -1;
+  }
+
+  auto tag    = tagged_cipher;
+  auto cipher = tag + tag_size;
+
+  int len;
+  int size = round_to_pkcs7_padded(plaintext.size());
+
+  // Encrypt into the caller's buffer
+  if(EVP_EncryptUpdate(encrypt_ctx.get(), cipher, &size, (const std::uint8_t *)plaintext.data(), plaintext.size()) != 1) {
+    return -1;
+  }
+
+  // GCM encryption won't ever fill ciphertext here but we have to call it anyway
+  if(EVP_EncryptFinal_ex(encrypt_ctx.get(), cipher + size, &len) != 1) {
+    return -1;
+  }
+
+  if(EVP_CIPHER_CTX_ctrl(encrypt_ctx.get(), EVP_CTRL_GCM_GET_TAG, tag_size, tag) != 1) {
+    return -1;
+  }
+
+  return len + size;
+}
+
+int ecb_t::decrypt(const std::string_view &cipher, std::vector<std::uint8_t> &plaintext) {
   int len;
 
   auto fg = util::fail_guard([this]() {
-    EVP_CIPHER_CTX_reset(ctx.get());
+    EVP_CIPHER_CTX_reset(decrypt_ctx.get());
   });
 
   // Gen 7 servers use 128-bit AES ECB
-  if (EVP_EncryptInit_ex(ctx.get(), EVP_aes_128_ecb(), nullptr, key.data(), nullptr) != 1) {
+  if(EVP_DecryptInit_ex(decrypt_ctx.get(), EVP_aes_128_ecb(), nullptr, key.data(), nullptr) != 1) {
     return -1;
   }
 
-  EVP_CIPHER_CTX_set_padding(ctx.get(), padding);
+  EVP_CIPHER_CTX_set_padding(decrypt_ctx.get(), padding);
+
+  plaintext.resize((cipher.size() + 15) / 16 * 16);
+  auto size = (int)plaintext.size();
+  // Decrypt into the caller's buffer, leaving room for the auth tag to be prepended
+  if(EVP_DecryptUpdate(decrypt_ctx.get(), plaintext.data(), &size, (const std::uint8_t *)cipher.data(), cipher.size()) != 1) {
+    return -1;
+  }
+
+  if(EVP_DecryptFinal_ex(decrypt_ctx.get(), plaintext.data(), &len) != 1) {
+    return -1;
+  }
+
+  plaintext.resize(len + size);
+  return 0;
+}
+
+int ecb_t::encrypt(const std::string_view &plaintext, std::vector<std::uint8_t> &cipher) {
+  auto fg = util::fail_guard([this]() {
+    EVP_CIPHER_CTX_reset(encrypt_ctx.get());
+  });
+
+  // Gen 7 servers use 128-bit AES ECB
+  if(EVP_EncryptInit_ex(encrypt_ctx.get(), EVP_aes_128_ecb(), nullptr, key.data(), nullptr) != 1) {
+    return -1;
+  }
+
+  EVP_CIPHER_CTX_set_padding(encrypt_ctx.get(), padding);
+
+  int len;
 
   cipher.resize((plaintext.size() + 15) / 16 * 16);
   auto size = (int)cipher.size();
+
   // Encrypt into the caller's buffer
-  if (EVP_EncryptUpdate(ctx.get(), cipher.data(), &size, (const std::uint8_t*)plaintext.data(), plaintext.size()) != 1) {
+  if(EVP_EncryptUpdate(encrypt_ctx.get(), cipher.data(), &size, (const std::uint8_t *)plaintext.data(), plaintext.size()) != 1) {
     return -1;
   }
 
-  if (EVP_EncryptFinal_ex(ctx.get(), cipher.data() + size, &len) != 1) {
+  if(EVP_EncryptFinal_ex(encrypt_ctx.get(), cipher.data() + size, &len) != 1) {
     return -1;
   }
 
@@ -155,6 +257,44 @@ int cipher_t::encrypt(const std::string_view &plaintext, std::vector<std::uint8_
   return 0;
 }
 
+int cbc_t::encrypt(const std::string_view &plaintext, std::uint8_t *cipher, aes_t *iv) {
+  if(!encrypt_ctx && init_encrypt_cbc(encrypt_ctx, &key, iv, padding)) {
+    return -1;
+  }
+
+  // Calling with cipher == nullptr results in a parameter change
+  // without requiring a reallocation of the internal cipher ctx.
+  if(EVP_EncryptInit_ex(encrypt_ctx.get(), nullptr, nullptr, nullptr, iv->data()) != 1) {
+    return false;
+  }
+
+  int len;
+
+  int size = plaintext.size(); //round_to_pkcs7_padded(plaintext.size());
+
+  // Encrypt into the caller's buffer
+  if(EVP_EncryptUpdate(encrypt_ctx.get(), cipher, &size, (const std::uint8_t *)plaintext.data(), plaintext.size()) != 1) {
+    return -1;
+  }
+
+  if(EVP_EncryptFinal_ex(encrypt_ctx.get(), cipher + size, &len) != 1) {
+    return -1;
+  }
+
+  return size + len;
+}
+
+ecb_t::ecb_t(const aes_t &key, bool padding)
+    : cipher_t { EVP_CIPHER_CTX_new(), EVP_CIPHER_CTX_new(), key, padding } {}
+
+cbc_t::cbc_t(const aes_t &key, bool padding)
+    : cipher_t { nullptr, nullptr, key, padding } {}
+
+gcm_t::gcm_t(const crypto::aes_t &key, bool padding)
+    : cipher_t { nullptr, nullptr, key, padding } {}
+
+} // namespace cipher
+
 aes_t gen_aes_key(const std::array<uint8_t, 16> &salt, const std::string_view &pin) {
   aes_t key;
 
@@ -230,14 +370,14 @@ std::string_view signature(const x509_t &x) {
   const ASN1_BIT_STRING *asn1 = nullptr;
   X509_get0_signature(&asn1, nullptr, x.get());
 
-  return { (const char*)asn1->data, (std::size_t)asn1->length };
+  return { (const char *)asn1->data, (std::size_t)asn1->length };
 }
 
 std::string rand(std::size_t bytes) {
   std::string r;
   r.resize(bytes);
 
-  RAND_bytes((uint8_t*)r.data(), r.size());
+  RAND_bytes((uint8_t *)r.data(), r.size());
 
   return r;
 }
@@ -297,8 +437,8 @@ creds_t gen_creds(const std::string_view &cn, std::uint32_t key_bits) {
   X509_set_pubkey(x509.get(), pkey.get());
 
   auto name = X509_get_subject_name(x509.get());
-  X509_NAME_add_entry_by_txt(name,"CN", MBSTRING_ASC,
-    (const std::uint8_t*)cn.data(), cn.size(),
+  X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
+    (const std::uint8_t *)cn.data(), cn.size(),
     -1, 0);
 
   X509_set_issuer_name(x509.get(), name);
@@ -324,7 +464,7 @@ bool verify(const x509_t &x509, const std::string_view &data, const std::string_
     return false;
   }
 
-  if(EVP_DigestVerifyFinal(ctx.get(), (const uint8_t*)signature.data(), signature.size()) != 1) {
+  if(EVP_DigestVerifyFinal(ctx.get(), (const uint8_t *)signature.data(), signature.size()) != 1) {
     return false;
   }
 
@@ -338,4 +478,14 @@ bool verify256(const x509_t &x509, const std::string_view &data, const std::stri
 void md_ctx_destroy(EVP_MD_CTX *ctx) {
   EVP_MD_CTX_destroy(ctx);
 }
+
+std::string rand_alphabet(std::size_t bytes, const std::string_view &alphabet) {
+  auto value = rand(bytes);
+
+  for(std::size_t i = 0; i != value.size(); ++i) {
+    value[i] = alphabet[value[i] % alphabet.length()];
+  }
+  return value;
 }
+
+} // namespace crypto

sunshine/crypto.h

@@ -5,12 +5,11 @@
 #ifndef SUNSHINE_CRYPTO_H
 #define SUNSHINE_CRYPTO_H
 
-#include <cassert>
 #include <array>
 #include <openssl/evp.h>
+#include <openssl/rand.h>
 #include <openssl/sha.h>
 #include <openssl/x509.h>
-#include <openssl/rand.h>
 
 #include "utility.h"
 
@@ -25,16 +24,17 @@ void md_ctx_destroy(EVP_MD_CTX *);
 
 using sha256_t = std::array<std::uint8_t, SHA256_DIGEST_LENGTH>;
 
-using aes_t = std::array<std::uint8_t, 16>;
-using x509_t = util::safe_ptr<X509, X509_free>;
-using x509_store_t = util::safe_ptr<X509_STORE, X509_STORE_free>;
+using aes_t            = std::array<std::uint8_t, 16>;
+using x509_t           = util::safe_ptr<X509, X509_free>;
+using x509_store_t     = util::safe_ptr<X509_STORE, X509_STORE_free>;
 using x509_store_ctx_t = util::safe_ptr<X509_STORE_CTX, X509_STORE_CTX_free>;
-using cipher_ctx_t = util::safe_ptr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free>;
-using md_ctx_t = util::safe_ptr<EVP_MD_CTX, md_ctx_destroy>;
-using bio_t = util::safe_ptr<BIO, BIO_free_all>;
-using pkey_t = util::safe_ptr<EVP_PKEY, EVP_PKEY_free>;
+using cipher_ctx_t     = util::safe_ptr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free>;
+using md_ctx_t         = util::safe_ptr<EVP_MD_CTX, md_ctx_destroy>;
+using bio_t            = util::safe_ptr<BIO, BIO_free_all>;
+using pkey_t           = util::safe_ptr<EVP_PKEY, EVP_PKEY_free>;
 
 sha256_t hash(const std::string_view &plaintext);
+
 aes_t gen_aes_key(const std::array<uint8_t, 16> &salt, const std::string_view &pin);
 
 x509_t x509(const std::string_view &x);
@@ -50,6 +50,8 @@ creds_t gen_creds(const std::string_view &cn, std::uint32_t key_bits);
 std::string_view signature(const x509_t &x);
 
 std::string rand(std::size_t bytes);
+std::string rand_alphabet(std::size_t bytes,
+  const std::string_view &alphabet = std::string_view { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!%&()=-" });
 
 class cert_chain_t {
 public:
@@ -58,28 +60,76 @@ public:
   void add(x509_t &&cert);
 
   const char *verify(x509_t::element_type *cert);
+
 private:
   std::vector<std::pair<x509_t, x509_store_t>> _certs;
   x509_store_ctx_t _cert_ctx;
 };
 
-class cipher_t {
-public:
-  cipher_t(const aes_t &key);
-  cipher_t(cipher_t&&) noexcept = default;
-  cipher_t &operator=(cipher_t&&) noexcept = default;
-
-  int encrypt(const std::string_view &plaintext, std::vector<std::uint8_t> &cipher);
-
-  int decrypt_gcm(aes_t &iv, const std::string_view &cipher, std::vector<std::uint8_t> &plaintext);
-  int decrypt(const std::string_view &cipher, std::vector<std::uint8_t> &plaintext);
-private:
-  cipher_ctx_t ctx;
-  aes_t key;
-
-public:
-  bool padding;
-};
+namespace cipher {
+constexpr std::size_t tag_size = 16;
+constexpr std::size_t round_to_pkcs7_padded(std::size_t size) {
+  return ((size + 15) / 16) * 16;
 }
 
+class cipher_t {
+public:
+  cipher_ctx_t decrypt_ctx;
+  cipher_ctx_t encrypt_ctx;
+
+  aes_t key;
+
+  bool padding;
+};
+
+class ecb_t : public cipher_t {
+public:
+  ecb_t()                  = default;
+  ecb_t(ecb_t &&) noexcept = default;
+  ecb_t &operator=(ecb_t &&) noexcept = default;
+
+  ecb_t(const aes_t &key, bool padding = true);
+
+  int encrypt(const std::string_view &plaintext, std::vector<std::uint8_t> &cipher);
+  int decrypt(const std::string_view &cipher, std::vector<std::uint8_t> &plaintext);
+};
+
+class gcm_t : public cipher_t {
+public:
+  gcm_t()                  = default;
+  gcm_t(gcm_t &&) noexcept = default;
+  gcm_t &operator=(gcm_t &&) noexcept = default;
+
+  gcm_t(const crypto::aes_t &key, bool padding = true);
+
+  /**
+   * length of cipher must be at least: round_to_pkcs7_padded(plaintext.size()) + crypto::cipher::tag_size
+   * 
+   * return -1 on error
+   * return bytes written on success
+   */
+  int encrypt(const std::string_view &plaintext, std::uint8_t *tagged_cipher, aes_t *iv);
+
+  int decrypt(const std::string_view &cipher, std::vector<std::uint8_t> &plaintext, aes_t *iv);
+};
+
+class cbc_t : public cipher_t {
+public:
+  cbc_t()                  = default;
+  cbc_t(cbc_t &&) noexcept = default;
+  cbc_t &operator=(cbc_t &&) noexcept = default;
+
+  cbc_t(const crypto::aes_t &key, bool padding = true);
+
+  /**
+   * length of cipher must be at least: round_to_pkcs7_padded(plaintext.size())
+   * 
+   * return -1 on error
+   * return bytes written on success
+   */
+  int encrypt(const std::string_view &plaintext, std::uint8_t *cipher, aes_t *iv);
+};
+} // namespace cipher
+} // namespace crypto
+
 #endif //SUNSHINE_CRYPTO_H

sunshine/httpcommon.cpp

@@ -0,0 +1,192 @@
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
+
+#include "process.h"
+
+#include <filesystem>
+
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+
+#include <boost/asio/ssl/context.hpp>
+
+#include <Simple-Web-Server/server_http.hpp>
+#include <Simple-Web-Server/server_https.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+
+#include "config.h"
+#include "crypto.h"
+#include "httpcommon.h"
+#include "main.h"
+#include "network.h"
+#include "nvhttp.h"
+#include "platform/common.h"
+#include "rtsp.h"
+#include "utility.h"
+#include "uuid.h"
+
+namespace http {
+using namespace std::literals;
+namespace fs = std::filesystem;
+namespace pt = boost::property_tree;
+
+int reload_user_creds(const std::string &file);
+bool user_creds_exist(const std::string &file);
+
+std::string unique_id;
+net::net_e origin_pin_allowed;
+net::net_e origin_web_ui_allowed;
+
+int init() {
+  bool clean_slate      = config::sunshine.flags[config::flag::FRESH_STATE];
+  origin_pin_allowed    = net::from_enum_string(config::nvhttp.origin_pin_allowed);
+  origin_web_ui_allowed = net::from_enum_string(config::nvhttp.origin_web_ui_allowed);
+
+  if(clean_slate) {
+    unique_id           = util::uuid_t::generate().string();
+    auto dir            = std::filesystem::temp_directory_path() / "Sushine"sv;
+    config::nvhttp.cert = (dir / ("cert-"s + unique_id)).string();
+    config::nvhttp.pkey = (dir / ("pkey-"s + unique_id)).string();
+  }
+
+  if(!fs::exists(config::nvhttp.pkey) || !fs::exists(config::nvhttp.cert)) {
+    if(create_creds(config::nvhttp.pkey, config::nvhttp.cert)) {
+      return -1;
+    }
+  }
+  if(!user_creds_exist(config::sunshine.credentials_file)) {
+    if(save_user_creds(config::sunshine.credentials_file, "sunshine"s, crypto::rand_alphabet(16), true)) {
+      return -1;
+    }
+  }
+  if(reload_user_creds(config::sunshine.credentials_file)) {
+    return -1;
+  }
+
+  return 0;
+}
+
+int save_user_creds(const std::string &file, const std::string &username, const std::string &password, bool run_our_mouth) {
+  pt::ptree outputTree;
+
+  if(fs::exists(file)) {
+    try {
+      pt::read_json(file, outputTree);
+    }
+    catch(std::exception &e) {
+      BOOST_LOG(error) << "Couldn't read user credentials: "sv << e.what();
+      return -1;
+    }
+  }
+
+  auto salt = crypto::rand_alphabet(16);
+  outputTree.put("username", username);
+  outputTree.put("salt", salt);
+  outputTree.put("password", util::hex(crypto::hash(password + salt)).to_string());
+  try {
+    pt::write_json(file, outputTree);
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(error) << "generating user credentials: "sv << e.what();
+    return -1;
+  }
+
+  BOOST_LOG(info) << "New credentials have been created"sv;
+
+  if(run_our_mouth) {
+    BOOST_LOG(info) << "Username: "sv << username;
+    BOOST_LOG(info) << "Password: "sv << password;
+  }
+
+  return 0;
+}
+
+bool user_creds_exist(const std::string &file) {
+  if(!fs::exists(file)) {
+    return false;
+  }
+
+  pt::ptree inputTree;
+  try {
+    pt::read_json(file, inputTree);
+    return inputTree.find("username") != inputTree.not_found() &&
+           inputTree.find("password") != inputTree.not_found() &&
+           inputTree.find("salt") != inputTree.not_found();
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(error) << "validating user credentials: "sv << e.what();
+  }
+
+  return false;
+}
+
+int reload_user_creds(const std::string &file) {
+  pt::ptree inputTree;
+  try {
+    pt::read_json(file, inputTree);
+    config::sunshine.username = inputTree.get<std::string>("username");
+    config::sunshine.password = inputTree.get<std::string>("password");
+    config::sunshine.salt     = inputTree.get<std::string>("salt");
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(error) << "loading user credentials: "sv << e.what();
+    return -1;
+  }
+  return 0;
+}
+
+int create_creds(const std::string &pkey, const std::string &cert) {
+  fs::path pkey_path = pkey;
+  fs::path cert_path = cert;
+
+  auto creds = crypto::gen_creds("Sunshine Gamestream Host"sv, 2048);
+
+  auto pkey_dir = pkey_path;
+  auto cert_dir = cert_path;
+  pkey_dir.remove_filename();
+  cert_dir.remove_filename();
+
+  std::error_code err_code {};
+  fs::create_directories(pkey_dir, err_code);
+  if(err_code) {
+    BOOST_LOG(error) << "Couldn't create directory ["sv << pkey_dir << "] :"sv << err_code.message();
+    return -1;
+  }
+
+  fs::create_directories(cert_dir, err_code);
+  if(err_code) {
+    BOOST_LOG(error) << "Couldn't create directory ["sv << cert_dir << "] :"sv << err_code.message();
+    return -1;
+  }
+
+  if(write_file(pkey.c_str(), creds.pkey)) {
+    BOOST_LOG(error) << "Couldn't open ["sv << config::nvhttp.pkey << ']';
+    return -1;
+  }
+
+  if(write_file(cert.c_str(), creds.x509)) {
+    BOOST_LOG(error) << "Couldn't open ["sv << config::nvhttp.cert << ']';
+    return -1;
+  }
+
+  fs::permissions(pkey_path,
+    fs::perms::owner_read | fs::perms::owner_write,
+    fs::perm_options::replace, err_code);
+
+  if(err_code) {
+    BOOST_LOG(error) << "Couldn't change permissions of ["sv << config::nvhttp.pkey << "] :"sv << err_code.message();
+    return -1;
+  }
+
+  fs::permissions(cert_path,
+    fs::perms::owner_read | fs::perms::group_read | fs::perms::others_read | fs::perms::owner_write,
+    fs::perm_options::replace, err_code);
+
+  if(err_code) {
+    BOOST_LOG(error) << "Couldn't change permissions of ["sv << config::nvhttp.cert << "] :"sv << err_code.message();
+    return -1;
+  }
+
+  return 0;
+}
+} // namespace http

sunshine/httpcommon.h

@@ -0,0 +1,19 @@
+#include "network.h"
+#include "thread_safe.h"
+
+namespace http {
+
+int init();
+int create_creds(const std::string &pkey, const std::string &cert);
+int save_user_creds(
+  const std::string &file,
+  const std::string &username,
+  const std::string &password,
+  bool run_our_mouth = false);
+
+int reload_user_creds(const std::string &file);
+extern std::string unique_id;
+extern net::net_e origin_pin_allowed;
+extern net::net_e origin_web_ui_allowed;
+
+} // namespace http

sunshine/input.cpp

@@ -10,16 +10,16 @@ extern "C" {
 
 #include <bitset>
 
-#include "main.h"
 #include "config.h"
-#include "utility.h"
-#include "thread_pool.h"
 #include "input.h"
+#include "main.h"
 #include "platform/common.h"
+#include "thread_pool.h"
+#include "utility.h"
 
 namespace input {
 
-constexpr auto MAX_GAMEPADS = std::min((std::size_t)platf::MAX_GAMEPADS, sizeof(std::int16_t)*8);
+constexpr auto MAX_GAMEPADS = std::min((std::size_t)platf::MAX_GAMEPADS, sizeof(std::int16_t) * 8);
 #define DISABLE_LEFT_BUTTON_DELAY ((util::ThreadPool::task_id_t)0x01)
 #define ENABLE_LEFT_BUTTON_DELAY nullptr
 
@@ -46,11 +46,6 @@ void free_id(std::bitset<N> &gamepad_mask, int id) {
   gamepad_mask[id] = false;
 }
 
-touch_port_event_t touch_port_event;
-platf::touch_port_t touch_port {
-  0, 0, 0, 0
-};
-
 static util::TaskPool::task_id_t task_id {};
 static std::unordered_map<short, bool> key_press {};
 static std::array<std::uint8_t, 5> mouse_press {};
@@ -59,7 +54,7 @@ static platf::input_t platf_input;
 static std::bitset<platf::MAX_GAMEPADS> gamepadMask {};
 
 void free_gamepad(platf::input_t &platf_input, int id) {
-  platf::gamepad(platf_input, id, platf::gamepad_state_t{});
+  platf::gamepad(platf_input, id, platf::gamepad_state_t {});
   platf::free_gamepad(platf_input, id);
 
   free_id(gamepadMask, id);
@@ -68,7 +63,7 @@ struct gamepad_t {
   gamepad_t() : gamepad_state {}, back_timeout_id {}, id { -1 }, back_button_state { button_state_e::NONE } {}
   ~gamepad_t() {
     if(id >= 0) {
-      task_pool.push([id=this->id]() {
+      task_pool.push([id = this->id]() {
         free_gamepad(platf_input, id);
       });
     }
@@ -89,12 +84,21 @@ struct gamepad_t {
 };
 
 struct input_t {
-  input_t() : active_gamepad_state {}, gamepads (MAX_GAMEPADS), mouse_left_button_timeout {} { }
+  input_t(safe::mail_raw_t::event_t<input::touch_port_t> touch_port_event)
+      : active_gamepad_state {},
+        gamepads(MAX_GAMEPADS),
+        touch_port_event { std::move(touch_port_event) },
+        mouse_left_button_timeout {},
+        touch_port { 0, 0, 0, 0, 0, 0, 1.0f } {}
 
   std::uint16_t active_gamepad_state;
   std::vector<gamepad_t> gamepads;
 
+  safe::mail_raw_t::event_t<input::touch_port_t> touch_port_event;
+
   util::ThreadPool::task_id_t mouse_left_button_timeout;
+
+  input::touch_port_t touch_port;
 };
 
 using namespace std::literals;
@@ -158,33 +162,32 @@ void print(PNV_MULTI_CONTROLLER_PACKET packet) {
 
 constexpr int PACKET_TYPE_SCROLL_OR_KEYBOARD = PACKET_TYPE_SCROLL;
 void print(void *input) {
-  int input_type = util::endian::big(*(int*)input);
+  int input_type = util::endian::big(*(int *)input);
 
   switch(input_type) {
-    case PACKET_TYPE_REL_MOUSE_MOVE:
-      print((PNV_REL_MOUSE_MOVE_PACKET)input);
-      break;
-    case PACKET_TYPE_ABS_MOUSE_MOVE:
-      print((PNV_ABS_MOUSE_MOVE_PACKET)input);
-      break;
-    case PACKET_TYPE_MOUSE_BUTTON:
-      print((PNV_MOUSE_BUTTON_PACKET)input);
-      break;
-    case PACKET_TYPE_SCROLL_OR_KEYBOARD:
-    {
-      char *tmp_input = (char*)input + 4;
-      if(tmp_input[0] == 0x0A) {
-        print((PNV_SCROLL_PACKET)input);
-      }
-      else {
-        print((PNV_KEYBOARD_PACKET)input);
-      }
-
-      break;
+  case PACKET_TYPE_REL_MOUSE_MOVE:
+    print((PNV_REL_MOUSE_MOVE_PACKET)input);
+    break;
+  case PACKET_TYPE_ABS_MOUSE_MOVE:
+    print((PNV_ABS_MOUSE_MOVE_PACKET)input);
+    break;
+  case PACKET_TYPE_MOUSE_BUTTON:
+    print((PNV_MOUSE_BUTTON_PACKET)input);
+    break;
+  case PACKET_TYPE_SCROLL_OR_KEYBOARD: {
+    char *tmp_input = (char *)input + 4;
+    if(tmp_input[0] == 0x0A) {
+      print((PNV_SCROLL_PACKET)input);
     }
-    case PACKET_TYPE_MULTI_CONTROLLER:
-      print((PNV_MULTI_CONTROLLER_PACKET)input);
-      break;
+    else {
+      print((PNV_KEYBOARD_PACKET)input);
+    }
+
+    break;
+  }
+  case PACKET_TYPE_MULTI_CONTROLLER:
+    print((PNV_MULTI_CONTROLLER_PACKET)input);
+    break;
   }
 }
 
@@ -202,6 +205,8 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_ABS_MOUSE_MOVE_PACKET pack
     input->mouse_left_button_timeout = ENABLE_LEFT_BUTTON_DELAY;
   }
 
+  auto &touch_port_event = input->touch_port_event;
+  auto &touch_port       = input->touch_port;
   if(touch_port_event->peek()) {
     touch_port = *touch_port_event->pop();
   }
@@ -217,13 +222,27 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_ABS_MOUSE_MOVE_PACKET pack
     return;
   }
 
-  float width  = util::endian::big(packet->width);
-  float height = util::endian::big(packet->height);
+  auto width  = (float)util::endian::big(packet->width);
+  auto height = (float)util::endian::big(packet->height);
 
-  auto scale_x = (float)touch_port.width / width;
-  auto scale_y = (float)touch_port.height / height;
+  auto scalarX = touch_port.width / width;
+  auto scalarY = touch_port.height / height;
 
-  platf::abs_mouse(platf_input, touch_port, x * scale_x, y * scale_y);
+  x *= scalarX;
+  y *= scalarY;
+
+  auto offsetX = touch_port.client_offsetX;
+  auto offsetY = touch_port.client_offsetY;
+
+  std::clamp(x, offsetX, width - offsetX);
+  std::clamp(y, offsetY, height - offsetY);
+
+  platf::touch_port_t abs_port {
+    touch_port.offset_x, touch_port.offset_y,
+    touch_port.env_width, touch_port.env_height
+  };
+
+  platf::abs_mouse(platf_input, abs_port, (x - offsetX) * touch_port.scalar_inv, (y - offsetY) * touch_port.scalar_inv);
 }
 
 void passthrough(std::shared_ptr<input_t> &input, PNV_MOUSE_BUTTON_PACKET packet) {
@@ -245,8 +264,8 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MOUSE_BUTTON_PACKET packet
 
     mouse_press[button] = !release;
   }
-///////////////////////////////////
-   /*/
+  ///////////////////////////////////
+  /*/
     * When Moonlight sends mouse input through absolute coordinates,
     * it's possible that BUTTON_RIGHT is pressed down immediately after releasing BUTTON_LEFT.
     * As a result, Sunshine will left click on hyperlinks in the browser before right clicking
@@ -261,7 +280,7 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MOUSE_BUTTON_PACKET packet
     * when the last mouse coordinates were absolute
    /*/
   if(button == BUTTON_LEFT && release && !input->mouse_left_button_timeout) {
-    input->mouse_left_button_timeout = task_pool.pushDelayed([=]() {
+    auto f = [=]() {
       auto left_released = mouse_press[BUTTON_LEFT];
       if(left_released) {
         // Already released left button
@@ -269,16 +288,17 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MOUSE_BUTTON_PACKET packet
       }
       platf::button_mouse(platf_input, BUTTON_LEFT, release);
 
-      mouse_press[BUTTON_LEFT] = false;
+      mouse_press[BUTTON_LEFT]         = false;
       input->mouse_left_button_timeout = nullptr;
-    }, 10ms).task_id;
+    };
+
+    input->mouse_left_button_timeout = task_pool.pushDelayed(std::move(f), 10ms).task_id;
 
     return;
   }
   if(
     button == BUTTON_RIGHT && !release &&
-    input->mouse_left_button_timeout > DISABLE_LEFT_BUTTON_DELAY
-  ) {
+    input->mouse_left_button_timeout > DISABLE_LEFT_BUTTON_DELAY) {
     platf::button_mouse(platf_input, BUTTON_RIGHT, false);
     platf::button_mouse(platf_input, BUTTON_RIGHT, true);
 
@@ -286,7 +306,7 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MOUSE_BUTTON_PACKET packet
 
     return;
   }
-///////////////////////////////////
+  ///////////////////////////////////
 
   platf::button_mouse(platf_input, button, release);
 }
@@ -303,6 +323,20 @@ void repeat_key(short key_code) {
   task_id = task_pool.pushDelayed(repeat_key, config::input.key_repeat_period, key_code).task_id;
 }
 
+short map_keycode(short keycode) {
+  keycode &= 0x00FF;
+
+  switch(keycode) {
+  case 0x10:
+    return 0xA0;
+  case 0x11:
+    return 0xA2;
+  case 0x12:
+    return 0xA4;
+  }
+
+  return keycode;
+}
 void passthrough(std::shared_ptr<input_t> &input, PNV_KEYBOARD_PACKET packet) {
   auto constexpr BUTTON_RELEASED = 0x04;
 
@@ -330,7 +364,8 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_KEYBOARD_PACKET packet) {
   }
 
   pressed = !release;
-  platf::keyboard(platf_input, packet->keyCode & 0x00FF, release);
+
+  platf::keyboard(platf_input, map_keycode(packet->keyCode), release);
 }
 
 void passthrough(PNV_SCROLL_PACKET packet) {
@@ -341,7 +376,7 @@ void passthrough(PNV_SCROLL_PACKET packet) {
 
 int updateGamepads(std::vector<gamepad_t> &gamepads, std::int16_t old_state, std::int16_t new_state) {
   auto xorGamepadMask = old_state ^ new_state;
-  if (!xorGamepadMask) {
+  if(!xorGamepadMask) {
     return 0;
   }
 
@@ -350,7 +385,7 @@ int updateGamepads(std::vector<gamepad_t> &gamepads, std::int16_t old_state, std
       auto &gamepad = gamepads[x];
 
       if((old_state >> x) & 1) {
-        if (gamepad.id < 0) {
+        if(gamepad.id < 0) {
           return -1;
         }
 
@@ -410,7 +445,7 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MULTI_CONTROLLER_PACKET pa
   display_cursor = false;
 
   std::uint16_t bf = packet->buttonFlags;
-  platf::gamepad_state_t gamepad_state{
+  platf::gamepad_state_t gamepad_state {
     bf,
     packet->leftTrigger,
     packet->rightTrigger,
@@ -422,30 +457,30 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MULTI_CONTROLLER_PACKET pa
 
   auto bf_new = gamepad_state.buttonFlags;
   switch(gamepad.back_button_state) {
-    case button_state_e::UP:
-      if(!(platf::BACK & bf_new)) {
-        gamepad.back_button_state = button_state_e::NONE;
-      }
-      gamepad_state.buttonFlags &= ~platf::BACK;
-      break;
-    case button_state_e::DOWN:
-      if(platf::BACK & bf_new) {
-        gamepad.back_button_state = button_state_e::NONE;
-      }
-      gamepad_state.buttonFlags |= platf::BACK;
-      break;
-    case button_state_e::NONE:
-      break;
+  case button_state_e::UP:
+    if(!(platf::BACK & bf_new)) {
+      gamepad.back_button_state = button_state_e::NONE;
+    }
+    gamepad_state.buttonFlags &= ~platf::BACK;
+    break;
+  case button_state_e::DOWN:
+    if(platf::BACK & bf_new) {
+      gamepad.back_button_state = button_state_e::NONE;
+    }
+    gamepad_state.buttonFlags |= platf::BACK;
+    break;
+  case button_state_e::NONE:
+    break;
   }
 
-  bf = gamepad_state.buttonFlags ^ gamepad.gamepad_state.buttonFlags;
+  bf     = gamepad_state.buttonFlags ^ gamepad.gamepad_state.buttonFlags;
   bf_new = gamepad_state.buttonFlags;
 
-  if (platf::BACK & bf) {
-    if (platf::BACK & bf_new) {
+  if(platf::BACK & bf) {
+    if(platf::BACK & bf_new) {
       // Don't emulate home button if timeout < 0
       if(config::input.back_button_timeout >= 0ms) {
-        gamepad.back_timeout_id = task_pool.pushDelayed([input, controller=packet->controllerNumber]() {
+        auto f = [input, controller = packet->controllerNumber]() {
           auto &gamepad = input->gamepads[controller];
 
           auto &state = gamepad.gamepad_state;
@@ -464,10 +499,12 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MULTI_CONTROLLER_PACKET pa
           platf::gamepad(platf_input, gamepad.id, state);
 
           gamepad.back_timeout_id = nullptr;
-        }, config::input.back_button_timeout).task_id;
+        };
+
+        gamepad.back_timeout_id = task_pool.pushDelayed(std::move(f), config::input.back_button_timeout).task_id;
       }
     }
-    else if (gamepad.back_timeout_id) {
+    else if(gamepad.back_timeout_id) {
       task_pool.cancel(gamepad.back_timeout_id);
       gamepad.back_timeout_id = nullptr;
     }
@@ -481,33 +518,32 @@ void passthrough(std::shared_ptr<input_t> &input, PNV_MULTI_CONTROLLER_PACKET pa
 void passthrough_helper(std::shared_ptr<input_t> input, std::vector<std::uint8_t> &&input_data) {
   void *payload = input_data.data();
 
-  int input_type = util::endian::big(*(int*)payload);
+  int input_type = util::endian::big(*(int *)payload);
 
   switch(input_type) {
-    case PACKET_TYPE_REL_MOUSE_MOVE:
-      passthrough(input, (PNV_REL_MOUSE_MOVE_PACKET)payload);
-      break;
-    case PACKET_TYPE_ABS_MOUSE_MOVE:
-      passthrough(input, (PNV_ABS_MOUSE_MOVE_PACKET)payload);
-      break;
-    case PACKET_TYPE_MOUSE_BUTTON:
-      passthrough(input, (PNV_MOUSE_BUTTON_PACKET)payload);
-      break;
-    case PACKET_TYPE_SCROLL_OR_KEYBOARD:
-    {
-      char *tmp_input = (char*)payload + 4;
-      if(tmp_input[0] == 0x0A) {
-        passthrough((PNV_SCROLL_PACKET)payload);
-      }
-      else {
-        passthrough(input, (PNV_KEYBOARD_PACKET)payload);
-      }
-
-      break;
+  case PACKET_TYPE_REL_MOUSE_MOVE:
+    passthrough(input, (PNV_REL_MOUSE_MOVE_PACKET)payload);
+    break;
+  case PACKET_TYPE_ABS_MOUSE_MOVE:
+    passthrough(input, (PNV_ABS_MOUSE_MOVE_PACKET)payload);
+    break;
+  case PACKET_TYPE_MOUSE_BUTTON:
+    passthrough(input, (PNV_MOUSE_BUTTON_PACKET)payload);
+    break;
+  case PACKET_TYPE_SCROLL_OR_KEYBOARD: {
+    char *tmp_input = (char *)payload + 4;
+    if(tmp_input[0] == 0x0A) {
+      passthrough((PNV_SCROLL_PACKET)payload);
     }
-    case PACKET_TYPE_MULTI_CONTROLLER:
-      passthrough(input, (PNV_MULTI_CONTROLLER_PACKET)payload);
-      break;
+    else {
+      passthrough(input, (PNV_KEYBOARD_PACKET)payload);
+    }
+
+    break;
+  }
+  case PACKET_TYPE_MULTI_CONTROLLER:
+    passthrough(input, (PNV_MULTI_CONTROLLER_PACKET)payload);
+    break;
   }
 }
 
@@ -528,7 +564,7 @@ void reset(std::shared_ptr<input_t> &input) {
       }
     }
 
-    for(auto& kp : key_press) {
+    for(auto &kp : key_press) {
       platf::keyboard(platf_input, kp.first & 0x00FF, true);
       key_press[kp.first] = false;
     }
@@ -536,19 +572,19 @@ void reset(std::shared_ptr<input_t> &input) {
 }
 
 void init() {
-  touch_port_event = std::make_unique<touch_port_event_t::element_type>();
   platf_input = platf::input();
 }
 
-std::shared_ptr<input_t> alloc() {
-  auto input = std::make_shared<input_t>();
+std::shared_ptr<input_t> alloc(safe::mail_t mail) {
+  auto input = std::make_shared<input_t>(mail->event<input::touch_port_t>(mail::touch_port));
 
   // Workaround to ensure new frames will be captured when a client connects
   task_pool.pushDelayed([]() {
     platf::move_mouse(platf_input, 1, 1);
     platf::move_mouse(platf_input, -1, -1);
-  }, 100ms);
+  },
+    100ms);
 
   return input;
 }
-}
+} // namespace input

sunshine/input.h

@@ -5,8 +5,9 @@
 #ifndef SUNSHINE_INPUT_H
 #define SUNSHINE_INPUT_H
 
-#include "thread_safe.h"
 #include "platform/common.h"
+#include "thread_safe.h"
+
 namespace input {
 
 struct input_t;
@@ -18,10 +19,16 @@ void passthrough(std::shared_ptr<input_t> &input, std::vector<std::uint8_t> &&in
 
 void init();
 
-std::shared_ptr<input_t> alloc();
+std::shared_ptr<input_t> alloc(safe::mail_t mail);
 
-using touch_port_event_t = std::unique_ptr<safe::event_t<platf::touch_port_t>>;
-extern touch_port_event_t touch_port_event;
-}
+struct touch_port_t : public platf::touch_port_t {
+  int env_width, env_height;
+
+  // Offset x and y coordinates of the client
+  float client_offsetX, client_offsetY;
+
+  float scalar_inv;
+};
+} // namespace input
 
 #endif //SUNSHINE_INPUT_H

sunshine/main.cpp

@@ -4,28 +4,36 @@
 
 #include "process.h"
 
-#include <thread>
-#include <iostream>
 #include <csignal>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <thread>
 
-#include <boost/log/common.hpp>
-#include <boost/log/sinks.hpp>
-#include <boost/log/expressions.hpp>
-#include <boost/log/sources/severity_logger.hpp>
 #include <boost/log/attributes/clock.hpp>
+#include <boost/log/common.hpp>
+#include <boost/log/expressions.hpp>
+#include <boost/log/sinks.hpp>
+#include <boost/log/sources/severity_logger.hpp>
 
-#include "video.h"
+#include "config.h"
+#include "confighttp.h"
+#include "httpcommon.h"
+#include "main.h"
 #include "nvhttp.h"
 #include "rtsp.h"
-#include "config.h"
 #include "thread_pool.h"
+#include "upnp.h"
+#include "video.h"
 
 #include "platform/common.h"
 extern "C" {
-#include <rs.h>
 #include <libavutil/log.h>
+#include <rs.h>
 }
 
+safe::mail_t mail::man;
+
 using namespace std::literals;
 namespace bl = boost::log;
 
@@ -48,6 +56,30 @@ struct NoDelete {
 
 BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", int)
 
+void print_help(const char *name) {
+  std::cout
+    << "Usage: "sv << name << " [options] [/path/to/configuration_file] [--cmd]"sv << std::endl
+    << "    Any configurable option can be overwritten with: \"name=value\""sv << std::endl
+    << std::endl
+    << "    --help                    | print help"sv << std::endl
+    << "    --creds username password | set user credentials for the Web manager" << std::endl
+    << std::endl
+    << "    flags"sv << std::endl
+    << "        -0 | Read PIN from stdin"sv << std::endl
+    << "        -1 | Do not load previously saved state and do retain any state after shutdown"sv << std::endl
+    << "           | Effectively starting as if for the first time without overwriting any pairings with your devices"sv << std::endl
+    << "        -2 | Force replacement of headers in video stream" << std::endl
+    << "        -p | Enable/Disable UPnP" << std::endl
+    << std::endl;
+}
+
+namespace help {
+int entry(const char *name, int argc, char *argv[]) {
+  print_help(name);
+  return 0;
+}
+} // namespace help
+
 void log_flush() {
   sink->flush();
 }
@@ -64,14 +96,37 @@ void on_signal(int sig, FN &&fn) {
   std::signal(sig, on_signal_forwarder);
 }
 
+namespace gen_creds {
+int entry(const char *name, int argc, char *argv[]) {
+  if(argc < 2 || argv[0] == "help"sv || argv[1] == "help"sv) {
+    print_help(name);
+    return 0;
+  }
+
+  http::save_user_creds(config::sunshine.credentials_file, argv[0], argv[1]);
+
+  return 0;
+}
+} // namespace gen_creds
+
+std::map<std::string_view, std::function<int(const char *name, int argc, char **argv)>> cmd_to_func {
+  { "creds"sv, gen_creds::entry },
+  { "help"sv, help::entry }
+};
+
 int main(int argc, char *argv[]) {
+  mail::man = std::make_shared<safe::mail_raw_t>();
+
   if(config::parse(argc, argv)) {
     return 0;
   }
 
-  if(config::sunshine.min_log_level >= 2) {
+  if(config::sunshine.min_log_level >= 1) {
     av_log_set_level(AV_LOG_QUIET);
   }
+  else {
+    av_log_set_level(AV_LOG_DEBUG);
+  }
 
   sink = boost::make_shared<text_sink>();
 
@@ -79,31 +134,31 @@ int main(int argc, char *argv[]) {
   sink->locked_backend()->add_stream(stream);
   sink->set_filter(severity >= config::sunshine.min_log_level);
 
-  sink->set_formatter([message="Message"s, severity="Severity"s](const bl::record_view &view, bl::formatting_ostream &os) {
-    constexpr int DATE_BUFFER_SIZE = 21 +2 +1; // Full string plus ": \0"
+  sink->set_formatter([message = "Message"s, severity = "Severity"s](const bl::record_view &view, bl::formatting_ostream &os) {
+    constexpr int DATE_BUFFER_SIZE = 21 + 2 + 1; // Full string plus ": \0"
 
     auto log_level = view.attribute_values()[severity].extract<int>().get();
 
     std::string_view log_type;
     switch(log_level) {
-      case 0:
-        log_type = "Verbose: "sv;
-        break;
-      case 1:
-        log_type = "Debug: "sv;
-        break;
-      case 2:
-        log_type = "Info: "sv;
-        break;
-      case 3:
-        log_type = "Warning: "sv;
-        break;
-      case 4:
-        log_type = "Error: "sv;
-        break;
-      case 5:
-        log_type = "Fatal: "sv;
-        break;
+    case 0:
+      log_type = "Verbose: "sv;
+      break;
+    case 1:
+      log_type = "Debug: "sv;
+      break;
+    case 2:
+      log_type = "Info: "sv;
+      break;
+    case 3:
+      log_type = "Warning: "sv;
+      break;
+    case 4:
+      log_type = "Error: "sv;
+      break;
+    case 5:
+      log_type = "Fatal: "sv;
+      break;
     };
 
     char _date[DATE_BUFFER_SIZE];
@@ -116,25 +171,70 @@ int main(int argc, char *argv[]) {
   bl::core::get()->add_sink(sink);
   auto fg = util::fail_guard(log_flush);
 
+  if(!config::sunshine.cmd.name.empty()) {
+    auto fn = cmd_to_func.find(config::sunshine.cmd.name);
+    if(fn == std::end(cmd_to_func)) {
+      BOOST_LOG(fatal) << "Unknown command: "sv << config::sunshine.cmd.name;
+
+      BOOST_LOG(info) << "Possible commands:"sv;
+      for(auto &[key, _] : cmd_to_func) {
+        BOOST_LOG(info) << '\t' << key;
+      }
+
+      return 7;
+    }
+
+    return fn->second(argv[0], config::sunshine.cmd.argc, config::sunshine.cmd.argv);
+  }
+
+  task_pool.start(1);
+
+  bool shutdown_by_interrupt = false;
+
+  util::TaskPool::task_id_t force_shutdown = nullptr;
   // Create signal handler after logging has been initialized
-  auto shutdown_event = std::make_shared<safe::event_t<bool>>();
-  on_signal(SIGINT, [shutdown_event]() {
+  auto shutdown_event = mail::man->event<bool>(mail::shutdown);
+  on_signal(SIGINT, [&shutdown_by_interrupt, &force_shutdown, shutdown_event]() {
     BOOST_LOG(info) << "Interrupt handler called"sv;
+
+    auto task = []() {
+      BOOST_LOG(fatal) << "10 seconds passed, yet Sunshine's still running: Forcing shutdown"sv;
+      log_flush();
+      std::abort();
+    };
+    force_shutdown = task_pool.pushDelayed(task, 10s).task_id;
+
+    shutdown_by_interrupt = true;
     shutdown_event->raise(true);
   });
 
-  auto proc_opt = proc::parse(config::stream.file_apps);
-  if(!proc_opt) {
-    return 7;
-  }
+  on_signal(SIGTERM, [&force_shutdown, shutdown_event]() {
+    BOOST_LOG(info) << "Terminate handler called"sv;
 
-  {
-    proc::ctx_t ctx;
-    ctx.name = "Desktop"s;
-    proc_opt->get_apps().emplace(std::begin(proc_opt->get_apps()), std::move(ctx));
-  }
+    auto task = []() {
+      BOOST_LOG(fatal) << "10 seconds passed, yet Sunshine's still running: Forcing shutdown"sv;
+      log_flush();
+      std::abort();
+    };
+    force_shutdown = task_pool.pushDelayed(task, 10s).task_id;
 
-  proc::proc = std::move(*proc_opt);
+    shutdown_event->raise(true);
+  });
+
+  auto exit_guard = util::fail_guard([&shutdown_by_interrupt, &force_shutdown]() {
+    if(!shutdown_by_interrupt) {
+      return;
+    }
+
+    task_pool.cancel(force_shutdown);
+
+    std::cout << "Sunshine exited: Press enter to continue"sv << std::endl;
+
+    std::string _;
+    std::getline(std::cin, _);
+  });
+
+  proc::refresh(config::stream.file_apps);
 
   auto deinit_guard = platf::init();
   if(!deinit_guard) {
@@ -142,18 +242,73 @@ int main(int argc, char *argv[]) {
   }
 
   reed_solomon_init();
+  input::init();
   if(video::init()) {
     return 2;
   }
+  if(http::init()) {
+    return 3;
+  }
 
-  task_pool.start(1);
+  std::unique_ptr<platf::deinit_t> mDNS;
+  auto sync_mDNS = std::async(std::launch::async, [&mDNS]() {
+    mDNS = platf::publish::start();
+  });
 
-  std::thread httpThread { nvhttp::start, shutdown_event };
-  stream::rtpThread(shutdown_event);
+  std::unique_ptr<platf::deinit_t> upnp_unmap;
+  auto sync_upnp = std::async(std::launch::async, [&upnp_unmap]() {
+    upnp_unmap = upnp::start();
+  });
+
+  //FIXME: Temporary workaround: Simple-Web_server needs to be updated or replaced
+  if(shutdown_event->peek()) {
+    return 0;
+  }
+
+  std::thread httpThread { nvhttp::start };
+  std::thread configThread { confighttp::start };
+
+  stream::rtpThread();
 
   httpThread.join();
+  configThread.join();
+
   task_pool.stop();
   task_pool.join();
 
   return 0;
 }
+
+std::string read_file(const char *path) {
+  if(!std::filesystem::exists(path)) {
+    return {};
+  }
+
+  std::ifstream in(path);
+
+  std::string input;
+  std::string base64_cert;
+
+  while(!in.eof()) {
+    std::getline(in, input);
+    base64_cert += input + '\n';
+  }
+
+  return base64_cert;
+}
+
+int write_file(const char *path, const std::string_view &contents) {
+  std::ofstream out(path);
+
+  if(!out.is_open()) {
+    return -1;
+  }
+
+  out << contents;
+
+  return 0;
+}
+
+std::uint16_t map_port(int port) {
+  return (std::uint16_t)((int)config::sunshine.port + port);
+}

sunshine/main.h

@@ -5,8 +5,12 @@
 #ifndef SUNSHINE_MAIN_H
 #define SUNSHINE_MAIN_H
 
-#include <boost/log/common.hpp>
+#include <string_view>
+
 #include "thread_pool.h"
+#include "thread_safe.h"
+
+#include <boost/log/common.hpp>
 
 extern util::ThreadPool task_pool;
 extern bool display_cursor;
@@ -19,4 +23,32 @@ extern boost::log::sources::severity_logger<int> error;
 extern boost::log::sources::severity_logger<int> fatal;
 
 void log_flush();
+
+void print_help(const char *name);
+
+std::string read_file(const char *path);
+int write_file(const char *path, const std::string_view &contents);
+
+std::uint16_t map_port(int port);
+
+namespace mail {
+#define MAIL(x) \
+  constexpr auto x = std::string_view { #x }
+
+extern safe::mail_t man;
+
+// Global mail
+MAIL(shutdown);
+MAIL(broadcast_shutdown);
+
+MAIL(video_packets);
+MAIL(audio_packets);
+
+// Local mail
+MAIL(touch_port);
+MAIL(idr);
+#undef MAIL
+} // namespace mail
+
+
 #endif //SUNSHINE_MAIN_H

sunshine/move_by_copy.h

@@ -11,23 +11,24 @@ template<class T>
 class MoveByCopy {
 public:
   typedef T move_type;
+
 private:
   move_type _to_move;
-public:
 
-  explicit MoveByCopy(move_type &&to_move) : _to_move(std::move(to_move)) { }
+public:
+  explicit MoveByCopy(move_type &&to_move) : _to_move(std::move(to_move)) {}
 
   MoveByCopy(MoveByCopy &&other) = default;
-  
+
   MoveByCopy(const MoveByCopy &other) {
     *this = other;
   }
 
-  MoveByCopy& operator=(MoveByCopy &&other) = default;
-  
-  MoveByCopy& operator=(const MoveByCopy &other) {
-    this->_to_move = std::move(const_cast<MoveByCopy&>(other)._to_move);
-    
+  MoveByCopy &operator=(MoveByCopy &&other) = default;
+
+  MoveByCopy &operator=(const MoveByCopy &other) {
+    this->_to_move = std::move(const_cast<MoveByCopy &>(other)._to_move);
+
     return *this;
   }
 
@@ -44,7 +45,7 @@ MoveByCopy<T> cmove(T &movable) {
 // Do NOT use this unless you are absolutely certain the object to be moved is no longer used by the caller
 template<class T>
 MoveByCopy<T> const_cmove(const T &movable) {
-  return MoveByCopy<T>(std::move(const_cast<T&>(movable)));
-}
+  return MoveByCopy<T>(std::move(const_cast<T &>(movable)));
 }
+} // namespace util
 #endif

sunshine/network.cpp

@@ -2,12 +2,12 @@
 // Created by loki on 12/27/19.
 //
 
-#include <algorithm>
 #include "network.h"
 #include "utility.h"
+#include <algorithm>
 
-namespace net {
 using namespace std::literals;
+namespace net {
 // In the format "xxx.xxx.xxx.xxx/x"
 std::pair<std::uint32_t, std::uint32_t> ip_block(const std::string_view &ip);
 
@@ -16,22 +16,22 @@ std::vector<std::pair<std::uint32_t, std::uint32_t>> pc_ips {
 };
 std::vector<std::tuple<std::uint32_t, std::uint32_t>> lan_ips {
   ip_block("192.168.0.0/16"sv),
-  ip_block("172.16.0.0/12"),
+  ip_block("172.16.0.0/12"sv),
   ip_block("10.0.0.0/8"sv)
 };
 
 std::uint32_t ip(const std::string_view &ip_str) {
-  auto begin = std::begin(ip_str);
-  auto end = std::end(ip_str);
+  auto begin    = std::begin(ip_str);
+  auto end      = std::end(ip_str);
   auto temp_end = std::find(begin, end, '.');
 
   std::uint32_t ip = 0;
-  auto shift = 24;
+  auto shift       = 24;
   while(temp_end != end) {
     ip += (util::from_chars(begin, temp_end) << shift);
     shift -= 8;
 
-    begin = temp_end + 1;
+    begin    = temp_end + 1;
     temp_end = std::find(begin, end, '.');
   }
 
@@ -43,7 +43,7 @@ std::uint32_t ip(const std::string_view &ip_str) {
 // In the format "xxx.xxx.xxx.xxx/x"
 std::pair<std::uint32_t, std::uint32_t> ip_block(const std::string_view &ip_str) {
   auto begin = std::begin(ip_str);
-  auto end = std::find(begin, std::end(ip_str), '/');
+  auto end   = std::find(begin, std::end(ip_str), '/');
 
   auto addr = ip({ begin, (std::size_t)(end - begin) });
 
@@ -82,12 +82,12 @@ net_e from_address(const std::string_view &view) {
 
 std::string_view to_enum_string(net_e net) {
   switch(net) {
-    case PC:
-      return "pc"sv;
-    case LAN:
-      return "lan"sv;
-    case WAN:
-      return "wan"sv;
+  case PC:
+    return "pc"sv;
+  case LAN:
+    return "lan"sv;
+  case WAN:
+    return "wan"sv;
   }
 
   // avoid warning
@@ -112,4 +112,4 @@ void free_host(ENetHost *host) {
 
   enet_host_destroy(host);
 }
-}
+} // namespace net

sunshine/network.h

@@ -14,8 +14,8 @@
 namespace net {
 void free_host(ENetHost *host);
 
-using host_t = util::safe_ptr<ENetHost, free_host>;
-using peer_t = ENetPeer*;
+using host_t   = util::safe_ptr<ENetHost, free_host>;
+using peer_t   = ENetPeer *;
 using packet_t = util::safe_ptr<ENetPacket, enet_packet_destroy>;
 
 enum net_e : int {
@@ -30,6 +30,6 @@ std::string_view to_enum_string(net_e net);
 net_e from_address(const std::string_view &view);
 
 host_t host_create(ENetAddress &addr, std::size_t peers, std::uint16_t port);
-}
+} // namespace net
 
 #endif //SUNSHINE_NETWORK_H

sunshine/nvhttp.cpp

@@ -2,13 +2,15 @@
 // Created by loki on 6/3/19.
 //
 
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
+
 #include "process.h"
 
 #include <filesystem>
 
+#include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
-#include <boost/property_tree/json_parser.hpp>
 
 #include <boost/asio/ssl/context.hpp>
 
@@ -16,31 +18,27 @@
 #include <Simple-Web-Server/server_https.hpp>
 #include <boost/asio/ssl/context_base.hpp>
 
+
 #include "config.h"
-#include "utility.h"
-#include "rtsp.h"
 #include "crypto.h"
+#include "httpcommon.h"
+#include "main.h"
+#include "network.h"
 #include "nvhttp.h"
 #include "platform/common.h"
-#include "network.h"
+#include "rtsp.h"
+#include "utility.h"
 #include "uuid.h"
-#include "main.h"
 
-
-namespace nvhttp {
 using namespace std::literals;
-constexpr auto PORT_HTTP  = 47989;
-constexpr auto PORT_HTTPS = 47984;
+namespace nvhttp {
 
-constexpr auto VERSION     = "7.1.400.0";
-constexpr auto GFE_VERSION = "3.12.0.1";
+constexpr auto VERSION     = "7.1.431.0";
+constexpr auto GFE_VERSION = "3.23.0.74";
 
 namespace fs = std::filesystem;
 namespace pt = boost::property_tree;
 
-std::string read_file(const char *path);
-int write_file(const char *path, const std::string_view &contents);
-
 using https_server_t = SimpleWeb::Server<SimpleWeb::HTTPS>;
 using http_server_t  = SimpleWeb::Server<SimpleWeb::HTTP>;
 
@@ -69,8 +67,8 @@ struct pair_session_t {
   struct {
     util::Either<
       std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Response>,
-      std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Response>
-    > response;
+      std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Response>>
+      response;
     std::string salt;
   } async_insert_pin;
 };
@@ -78,14 +76,12 @@ struct pair_session_t {
 // uniqueID, session
 std::unordered_map<std::string, pair_session_t> map_id_sess;
 std::unordered_map<std::string, client_t> map_id_client;
-std::string unique_id;
-net::net_e origin_pin_allowed;
 
-using args_t = SimpleWeb::CaseInsensitiveMultimap;
+using args_t       = SimpleWeb::CaseInsensitiveMultimap;
 using resp_https_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Response>;
-using req_https_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Request>;
-using resp_http_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Response>;
-using req_http_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Request>;
+using req_https_t  = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Request>;
+using resp_http_t  = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Response>;
+using req_http_t   = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTP>::Request>;
 
 enum class op_e {
   ADD,
@@ -95,9 +91,21 @@ enum class op_e {
 void save_state() {
   pt::ptree root;
 
-  root.put("root.uniqueid", unique_id);
+  if(fs::exists(config::nvhttp.file_state)) {
+    try {
+      pt::read_json(config::nvhttp.file_state, root);
+    }
+    catch(std::exception &e) {
+      BOOST_LOG(error) << "Couldn't read "sv << config::nvhttp.file_state << ": "sv << e.what();
+      return;
+    }
+  }
+
+  root.erase("root"s);
+
+  root.put("root.uniqueid", http::unique_id);
   auto &nodes = root.add_child("root.devices", pt::ptree {});
-  for(auto &[_,client] : map_id_client) {
+  for(auto &[_, client] : map_id_client) {
     pt::ptree node;
 
     node.put("uniqueid"s, client.uniqueID);
@@ -113,31 +121,44 @@ void save_state() {
     nodes.push_back(std::make_pair(""s, node));
   }
 
-  pt::write_json(config::nvhttp.file_state, root);
+  try {
+    pt::write_json(config::nvhttp.file_state, root);
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(error) << "Couldn't write "sv << config::nvhttp.file_state << ": "sv << e.what();
+    return;
+  }
 }
 
 void load_state() {
-  auto file_state = fs::current_path() / config::nvhttp.file_state;
-
-  if(!fs::exists(file_state)) {
-    unique_id = util::uuid_t::generate().string();
+  if(!fs::exists(config::nvhttp.file_state)) {
+    BOOST_LOG(info) << "DOENST EXIST"sv;
+    http::unique_id = util::uuid_t::generate().string();
     return;
   }
 
   pt::ptree root;
   try {
     pt::read_json(config::nvhttp.file_state, root);
-  } catch (std::exception &e) {
-    BOOST_LOG(warning) << e.what();
+  }
+  catch(std::exception &e) {
+    BOOST_LOG(error) << "Couldn't read "sv << config::nvhttp.file_state << ": "sv << e.what();
 
     return;
   }
 
-  unique_id = root.get<std::string>("root.uniqueid");
+  auto unique_id_p = root.get_optional<std::string>("root.uniqueid");
+  if(!unique_id_p) {
+    // This file doesn't contain moonlight credentials
+    http::unique_id = util::uuid_t::generate().string();
+    return;
+  }
+  http::unique_id = std::move(*unique_id_p);
+
   auto device_nodes = root.get_child("root.devices");
 
-  for(auto &[_,device_node] : device_nodes) {
-    auto uniqID = device_node.get<std::string>("uniqueid");
+  for(auto &[_, device_node] : device_nodes) {
+    auto uniqID  = device_node.get<std::string>("uniqueid");
     auto &client = map_id_client.emplace(uniqID, client_t {}).first->second;
 
     client.uniqueID = uniqID;
@@ -150,16 +171,14 @@ void load_state() {
 
 void update_id_client(const std::string &uniqueID, std::string &&cert, op_e op) {
   switch(op) {
-    case op_e::ADD:
-    {
-      auto &client = map_id_client[uniqueID];
-      client.certs.emplace_back(std::move(cert));
-      client.uniqueID = uniqueID;
-    }
-      break;
-    case op_e::REMOVE:
-      map_id_client.erase(uniqueID);
-      break;
+  case op_e::ADD: {
+    auto &client = map_id_client[uniqueID];
+    client.certs.emplace_back(std::move(cert));
+    client.uniqueID = uniqueID;
+  } break;
+  case op_e::REMOVE:
+    map_id_client.erase(uniqueID);
+    break;
   }
 
   if(!config::sunshine.flags[config::flag::FRESH_STATE]) {
@@ -167,6 +186,20 @@ void update_id_client(const std::string &uniqueID, std::string &&cert, op_e op)
   }
 }
 
+stream::launch_session_t make_launch_session(bool host_audio, const args_t &args) {
+  stream::launch_session_t launch_session;
+
+  launch_session.host_audio = host_audio;
+  launch_session.gcm_key    = *util::from_hex<crypto::aes_t>(args.at("rikey"s), true);
+  uint32_t prepend_iv       = util::endian::big<uint32_t>(util::from_view(args.at("rikeyid"s)));
+  auto prepend_iv_p         = (uint8_t *)&prepend_iv;
+
+  auto next = std::copy(prepend_iv_p, prepend_iv_p + sizeof(prepend_iv), std::begin(launch_session.iv));
+  std::fill(next, std::end(launch_session.iv), 0);
+
+  return launch_session;
+}
+
 void getservercert(pair_session_t &sess, pt::ptree &tree, const std::string &pin) {
   if(sess.async_insert_pin.salt.size() < 32) {
     tree.put("root.paired", 0);
@@ -175,10 +208,10 @@ void getservercert(pair_session_t &sess, pt::ptree &tree, const std::string &pin
   }
 
   std::string_view salt_view { sess.async_insert_pin.salt.data(), 32 };
-  
+
   auto salt = util::from_hex<std::array<uint8_t, 16>>(salt_view, true);
 
-  auto key = crypto::gen_aes_key(*salt, pin);
+  auto key        = crypto::gen_aes_key(*salt, pin);
   sess.cipher_key = std::make_unique<crypto::aes_t>(key);
 
   tree.put("root.paired", 1);
@@ -189,15 +222,14 @@ void serverchallengeresp(pair_session_t &sess, pt::ptree &tree, const args_t &ar
   auto encrypted_response = util::from_hex_vec(args.at("serverchallengeresp"s), true);
 
   std::vector<uint8_t> decrypted;
-  crypto::cipher_t cipher(*sess.cipher_key);
-  cipher.padding = false;
+  crypto::cipher::ecb_t cipher(*sess.cipher_key, false);
 
   cipher.decrypt(encrypted_response, decrypted);
 
   sess.clienthash = std::move(decrypted);
 
   auto serversecret = sess.serversecret;
-  auto sign = crypto::sign256(crypto::pkey(conf_intern.pkey), serversecret);
+  auto sign         = crypto::sign256(crypto::pkey(conf_intern.pkey), serversecret);
 
   serversecret.insert(std::end(serversecret), std::begin(sign), std::end(sign));
 
@@ -209,20 +241,19 @@ void serverchallengeresp(pair_session_t &sess, pt::ptree &tree, const args_t &ar
 void clientchallenge(pair_session_t &sess, pt::ptree &tree, const args_t &args) {
   auto challenge = util::from_hex_vec(args.at("clientchallenge"s), true);
 
-  crypto::cipher_t cipher(*sess.cipher_key);
-  cipher.padding = false;
+  crypto::cipher::ecb_t cipher(*sess.cipher_key, false);
 
   std::vector<uint8_t> decrypted;
   cipher.decrypt(challenge, decrypted);
 
-  auto x509 = crypto::x509(conf_intern.servercert);
-  auto sign = crypto::signature(x509);
+  auto x509         = crypto::x509(conf_intern.servercert);
+  auto sign         = crypto::signature(x509);
   auto serversecret = crypto::rand(16);
 
   decrypted.insert(std::end(decrypted), std::begin(sign), std::end(sign));
   decrypted.insert(std::end(decrypted), std::begin(serversecret), std::end(serversecret));
 
-  auto hash = crypto::hash({ (char*)decrypted.data(), decrypted.size() });
+  auto hash            = crypto::hash({ (char *)decrypted.data(), decrypted.size() });
   auto serverchallenge = crypto::rand(16);
 
   std::string plaintext;
@@ -252,7 +283,7 @@ void clientpairingsecret(std::shared_ptr<safe::queue_t<crypto::x509_t>> &add_cer
 
   assert((secret.size() + sign.size()) == pairingsecret.size());
 
-  auto x509 = crypto::x509(client.cert);
+  auto x509      = crypto::x509(client.cert);
   auto x509_sign = crypto::signature(x509);
 
   std::string data;
@@ -306,8 +337,8 @@ template<class T>
 void print_req(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Request> request) {
   BOOST_LOG(debug) << "TUNNEL :: "sv << tunnel<T>::to_string;
 
-  BOOST_LOG(debug)  << "METHOD :: "sv << request->method;
-  BOOST_LOG(debug)  << "DESTINATION :: "sv << request->path;
+  BOOST_LOG(debug) << "METHOD :: "sv << request->method;
+  BOOST_LOG(debug) << "DESTINATION :: "sv << request->path;
 
   for(auto &[name, val] : request->header) {
     BOOST_LOG(debug) << name << " -- " << val;
@@ -334,37 +365,51 @@ void not_found(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> resp
   pt::write_xml(data, tree);
   response->write(data.str());
 
-  *response << "HTTP/1.1 404 NOT FOUND\r\n" << data.str();
+  *response
+    << "HTTP/1.1 404 NOT FOUND\r\n"
+    << data.str();
+
+  response->close_connection_after_response = true;
 }
 
 template<class T>
 void pair(std::shared_ptr<safe::queue_t<crypto::x509_t>> &add_cert, std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> response, std::shared_ptr<typename SimpleWeb::ServerBase<T>::Request> request) {
   print_req<T>(request);
 
+  pt::ptree tree;
+
+  auto fg = util::fail_guard([&]() {
+    std::ostringstream data;
+
+    pt::write_xml(data, tree);
+    response->write(data.str());
+    response->close_connection_after_response = true;
+  });
+
   auto args = request->parse_query_string();
+  if(args.find("uniqueid"s) == std::end(args)) {
+    tree.put("root.<xmlattr>.status_code", 400);
+
+    return;
+  }
+
   auto uniqID { std::move(args.at("uniqueid"s)) };
   auto sess_it = map_id_sess.find(uniqID);
 
-  pt::ptree tree;
-
   args_t::const_iterator it;
   if(it = args.find("phrase"); it != std::end(args)) {
     if(it->second == "getservercert"sv) {
       pair_session_t sess;
-      
+
       sess.client.uniqueID = std::move(uniqID);
-      sess.client.cert = util::from_hex_vec(args.at("clientcert"s), true);
+      sess.client.cert     = util::from_hex_vec(args.at("clientcert"s), true);
 
       BOOST_LOG(debug) << sess.client.cert;
       auto ptr = map_id_sess.emplace(sess.client.uniqueID, std::move(sess)).first;
 
       ptr->second.async_insert_pin.salt = std::move(args.at("salt"s));
 
-      if(config::sunshine.flags[config::flag::CONST_PIN]) {
-        std::string pin("6174");
-        getservercert(ptr->second, tree, pin);
-      }
-      else if(config::sunshine.flags[config::flag::PIN_STDIN]) {
+      if(config::sunshine.flags[config::flag::PIN_STDIN]) {
         std::string pin;
 
         std::cout << "Please insert pin: "sv;
@@ -375,6 +420,7 @@ void pair(std::shared_ptr<safe::queue_t<crypto::x509_t>> &add_cert, std::shared_
       else {
         ptr->second.async_insert_pin.response = std::move(response);
 
+        fg.disable();
         return;
       }
     }
@@ -395,37 +441,16 @@ void pair(std::shared_ptr<safe::queue_t<crypto::x509_t>> &add_cert, std::shared_
   else {
     tree.put("root.<xmlattr>.status_code", 404);
   }
-
-  std::ostringstream data;
-
-  pt::write_xml(data, tree);
-  response->write(data.str());
 }
 
-template<class T>
-void pin(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> response, std::shared_ptr<typename SimpleWeb::ServerBase<T>::Request> request) {
-  print_req<T>(request);
-
-  auto address = request->remote_endpoint_address();
-  auto ip_type = net::from_address(address);
-  if(ip_type > origin_pin_allowed) {
-    BOOST_LOG(info) << '[' << address << "] -- denied"sv;
-
-    response->write(SimpleWeb::StatusCode::client_error_forbidden);
-
-    return;
-  }
-
+bool pin(std::string pin) {
   pt::ptree tree;
-
   if(map_id_sess.empty()) {
-    response->write(SimpleWeb::StatusCode::client_error_im_a_teapot);
-
-    return;
+    return false;
   }
 
   auto &sess = std::begin(map_id_sess)->second;
-  getservercert(sess, tree, request->path_match[1]);
+  getservercert(sess, tree, pin);
 
   // response to the request for pin
   std::ostringstream data;
@@ -435,19 +460,42 @@ void pin(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> response,
   if(async_response.has_left() && async_response.left()) {
     async_response.left()->write(data.str());
   }
-  else if(async_response.has_right() && async_response.right()){
+  else if(async_response.has_right() && async_response.right()) {
     async_response.right()->write(data.str());
   }
   else {
-    response->write(SimpleWeb::StatusCode::client_error_im_a_teapot);
-
-    return;
+    return false;
   }
 
   // reset async_response
   async_response = std::decay_t<decltype(async_response.left())>();
   // response to the current request
-  response->write(SimpleWeb::StatusCode::success_ok);
+  return true;
+}
+
+template<class T>
+void pin(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> response, std::shared_ptr<typename SimpleWeb::ServerBase<T>::Request> request) {
+  print_req<T>(request);
+
+  response->close_connection_after_response = true;
+
+  auto address = request->remote_endpoint_address();
+  auto ip_type = net::from_address(address);
+  if(ip_type > http::origin_pin_allowed) {
+    BOOST_LOG(info) << "/pin: ["sv << address << "] -- denied"sv;
+
+    response->write(SimpleWeb::StatusCode::client_error_forbidden);
+
+    return;
+  }
+
+  bool pinResponse = pin(request->path_match[1]);
+  if(pinResponse) {
+    response->write(SimpleWeb::StatusCode::success_ok);
+  }
+  else {
+    response->write(SimpleWeb::StatusCode::client_error_im_a_teapot);
+  }
 }
 
 template<class T>
@@ -455,13 +503,13 @@ void serverinfo(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> res
   print_req<T>(request);
 
   int pair_status = 0;
-  if constexpr (std::is_same_v<SimpleWeb::HTTPS, T>) {
-    auto args = request->parse_query_string();
+  if constexpr(std::is_same_v<SimpleWeb::HTTPS, T>) {
+    auto args     = request->parse_query_string();
     auto clientID = args.find("uniqueid"s);
 
 
     if(clientID != std::end(args)) {
-      if (auto it = map_id_client.find(clientID->second); it != std::end(map_id_client)) {
+      if(auto it = map_id_client.find(clientID->second); it != std::end(map_id_client)) {
         pair_status = 1;
       }
     }
@@ -474,7 +522,9 @@ void serverinfo(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> res
 
   tree.put("root.appversion", VERSION);
   tree.put("root.GfeVersion", GFE_VERSION);
-  tree.put("root.uniqueid", unique_id);
+  tree.put("root.uniqueid", http::unique_id);
+  tree.put("root.HttpsPort", map_port(PORT_HTTPS));
+  tree.put("root.ExternalPort", map_port(PORT_HTTP));
   tree.put("root.mac", platf::get_mac_address(request->local_endpoint_address()));
   tree.put("root.MaxLumaPixelsHEVC", config::video.hevc_mode > 1 ? "1869449984" : "0");
   tree.put("root.LocalIP", request->local_endpoint_address());
@@ -493,23 +543,46 @@ void serverinfo(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> res
     tree.put("root.ExternalIP", config::nvhttp.external_ip);
   }
 
+  pt::ptree display_nodes;
+  for(auto &resolution : config::nvhttp.resolutions) {
+    auto pred = [](auto ch) { return ch == ' ' || ch == '\t' || ch == 'x'; };
+
+    auto middle = std::find_if(std::begin(resolution), std::end(resolution), pred);
+    if(middle == std::end(resolution)) {
+      BOOST_LOG(warning) << resolution << " is not in the proper format for a resolution: WIDTHxHEIGHT"sv;
+      continue;
+    }
+
+    auto width  = util::from_chars(&*std::begin(resolution), &*middle);
+    auto height = util::from_chars(&*(middle + 1), &*std::end(resolution));
+    for(auto fps : config::nvhttp.fps) {
+      pt::ptree display_node;
+      display_node.put("Width", width);
+      display_node.put("Height", height);
+      display_node.put("RefreshRate", fps);
+
+      display_nodes.add_child("DisplayMode", display_node);
+    }
+  }
+
+  if(!config::nvhttp.resolutions.empty()) {
+    tree.add_child("root.SupportedDisplayMode", display_nodes);
+  }
   auto current_appid = proc::proc.running();
   tree.put("root.PairStatus", pair_status);
   tree.put("root.currentgame", current_appid >= 0 ? current_appid + 1 : 0);
-  tree.put("root.state", current_appid >= 0 ? "_SERVER_BUSY" : "_SERVER_FREE");
+  tree.put("root.state", current_appid >= 0 ? "SUNSHINE_SERVER_BUSY" : "SUNSHINE_SERVER_FREE");
 
   std::ostringstream data;
 
   pt::write_xml(data, tree);
   response->write(data.str());
+  response->close_connection_after_response = true;
 }
 
 void applist(resp_https_t response, req_https_t request) {
   print_req<SimpleWeb::HTTPS>(request);
 
-  auto args = request->parse_query_string();
-  auto clientID = args.at("uniqueid"s);
-
   pt::ptree tree;
 
   auto g = util::fail_guard([&]() {
@@ -517,8 +590,18 @@ void applist(resp_https_t response, req_https_t request) {
 
     pt::write_xml(data, tree);
     response->write(data.str());
+    response->close_connection_after_response = true;
   });
 
+  auto args = request->parse_query_string();
+  if(args.find("uniqueid"s) == std::end(args)) {
+    tree.put("root.<xmlattr>.status_code", 400);
+
+    return;
+  }
+
+  auto clientID = args.at("uniqueid"s);
+
   auto client = map_id_client.find(clientID);
   if(client == std::end(map_id_client)) {
     tree.put("root.<xmlattr>.status_code", 501);
@@ -542,7 +625,7 @@ void applist(resp_https_t response, req_https_t request) {
   }
 }
 
-void launch(resp_https_t response, req_https_t request) {
+void launch(bool &host_audio, resp_https_t response, req_https_t request) {
   print_req<SimpleWeb::HTTPS>(request);
 
   pt::ptree tree;
@@ -551,6 +634,7 @@ void launch(resp_https_t response, req_https_t request) {
 
     pt::write_xml(data, tree);
     response->write(data.str());
+    response->close_connection_after_response = true;
   });
 
   if(stream::session_count() == config::stream.channels) {
@@ -561,7 +645,19 @@ void launch(resp_https_t response, req_https_t request) {
   }
 
   auto args = request->parse_query_string();
-  auto appid = util::from_view(args.at("appid")) -1;
+  if(
+    args.find("rikey"s) == std::end(args) ||
+    args.find("rikeyid"s) == std::end(args) ||
+    args.find("localAudioPlayMode"s) == std::end(args) ||
+    args.find("appid"s) == std::end(args)) {
+
+    tree.put("root.resume", 0);
+    tree.put("root.<xmlattr>.status_code", 400);
+
+    return;
+  }
+
+  auto appid = util::from_view(args.at("appid")) - 1;
 
   auto current_appid = proc::proc.running();
   if(current_appid != -1) {
@@ -581,23 +677,15 @@ void launch(resp_https_t response, req_https_t request) {
     }
   }
 
-  stream::launch_session_t launch_session;
-
-  auto clientID = args.at("uniqueid"s);
-  launch_session.gcm_key = *util::from_hex<crypto::aes_t>(args.at("rikey"s), true);
-  uint32_t prepend_iv = util::endian::big<uint32_t>(util::from_view(args.at("rikeyid"s)));
-  auto prepend_iv_p = (uint8_t*)&prepend_iv;
-
-  auto next = std::copy(prepend_iv_p, prepend_iv_p + sizeof(prepend_iv), std::begin(launch_session.iv));
-  std::fill(next, std::end(launch_session.iv), 0);
-
-  stream::launch_session_raise(launch_session);
+  host_audio = util::from_view(args.at("localAudioPlayMode"));
+  stream::launch_session_raise(make_launch_session(host_audio, args));
 
   tree.put("root.<xmlattr>.status_code", 200);
+  tree.put("root.sessionUrl0", "rtsp://"s + request->local_endpoint_address() + ':' + std::to_string(map_port(stream::RTSP_SETUP_PORT)));
   tree.put("root.gamesession", 1);
 }
 
-void resume(resp_https_t response, req_https_t request) {
+void resume(bool &host_audio, resp_https_t response, req_https_t request) {
   print_req<SimpleWeb::HTTPS>(request);
 
   pt::ptree tree;
@@ -606,6 +694,7 @@ void resume(resp_https_t response, req_https_t request) {
 
     pt::write_xml(data, tree);
     response->write(data.str());
+    response->close_connection_after_response = true;
   });
 
   // It is possible that due a race condition that this if-statement gives a false negative,
@@ -625,20 +714,21 @@ void resume(resp_https_t response, req_https_t request) {
     return;
   }
 
-  stream::launch_session_t launch_session;
-
   auto args = request->parse_query_string();
-  auto clientID = args.at("uniqueid"s);
-  launch_session.gcm_key = *util::from_hex<crypto::aes_t>(args.at("rikey"s), true);
-  uint32_t prepend_iv = util::endian::big<uint32_t>(util::from_view(args.at("rikeyid"s)));
-  auto prepend_iv_p = (uint8_t*)&prepend_iv;
+  if(
+    args.find("rikey"s) == std::end(args) ||
+    args.find("rikeyid"s) == std::end(args)) {
 
-  auto next = std::copy(prepend_iv_p, prepend_iv_p + sizeof(prepend_iv), std::begin(launch_session.iv));
-  std::fill(next, std::end(launch_session.iv), 0);
+    tree.put("root.resume", 0);
+    tree.put("root.<xmlattr>.status_code", 400);
 
-  stream::launch_session_raise(launch_session);
+    return;
+  }
+
+  stream::launch_session_raise(make_launch_session(host_audio, args));
 
   tree.put("root.<xmlattr>.status_code", 200);
+  tree.put("root.sessionUrl0", "rtsp://"s + request->local_endpoint_address() + ':' + std::to_string(map_port(stream::RTSP_SETUP_PORT)));
   tree.put("root.resume", 1);
 }
 
@@ -651,6 +741,7 @@ void cancel(resp_https_t response, req_https_t request) {
 
     pt::write_xml(data, tree);
     response->write(data.str());
+    response->close_connection_after_response = true;
   });
 
   // It is possible that due a race condition that this if-statement gives a false positive,
@@ -675,89 +766,22 @@ void appasset(resp_https_t response, req_https_t request) {
 
   std::ifstream in(SUNSHINE_ASSETS_DIR "/box.png");
   response->write(SimpleWeb::StatusCode::success_ok, in);
+  response->close_connection_after_response = true;
 }
 
-int create_creds(const std::string &pkey, const std::string &cert) {
-  fs::path pkey_path = pkey;
-  fs::path cert_path = cert;
+void start() {
+  auto shutdown_event = mail::man->event<bool>(mail::shutdown);
 
-  auto creds = crypto::gen_creds("Sunshine Gamestream Host"sv, 2048);
+  auto port_http  = map_port(PORT_HTTP);
+  auto port_https = map_port(PORT_HTTPS);
 
-  auto pkey_dir = pkey_path;
-  auto cert_dir = cert_path;
-  pkey_dir.remove_filename();
-  cert_dir.remove_filename();
-
-  std::error_code err_code{};
-  fs::create_directories(pkey_dir, err_code);
-  if (err_code) {
-    BOOST_LOG(fatal) << "Couldn't create directory ["sv << pkey_dir << "] :"sv << err_code.message();
-    return -1;
-  }
-
-  fs::create_directories(cert_dir, err_code);
-  if (err_code) {
-    BOOST_LOG(fatal) << "Couldn't create directory ["sv << cert_dir << "] :"sv << err_code.message();
-    return -1;
-  }
-
-  if (write_file(pkey.c_str(), creds.pkey)) {
-    BOOST_LOG(fatal) << "Couldn't open ["sv << config::nvhttp.pkey << ']';
-    return -1;
-  }
-
-  if (write_file(cert.c_str(), creds.x509)) {
-    BOOST_LOG(fatal) << "Couldn't open ["sv << config::nvhttp.cert << ']';
-    return -1;
-  }
-
-  fs::permissions(pkey_path,
-    fs::perms::owner_read | fs::perms::owner_write,
-    fs::perm_options::replace, err_code);
-
-  if (err_code) {
-    BOOST_LOG(fatal) << "Couldn't change permissions of ["sv << config::nvhttp.pkey << "] :"sv << err_code.message();
-    return -1;
-  }
-
-  fs::permissions(cert_path,
-    fs::perms::owner_read | fs::perms::group_read | fs::perms::others_read | fs::perms::owner_write,
-    fs::perm_options::replace, err_code);
-
-  if (err_code) {
-    BOOST_LOG(fatal) << "Couldn't change permissions of ["sv << config::nvhttp.cert << "] :"sv << err_code.message();
-    return -1;
-  }
-
-  return 0;
-}
-
-void start(std::shared_ptr<safe::signal_t> shutdown_event) {
   bool clean_slate = config::sunshine.flags[config::flag::FRESH_STATE];
-  if(clean_slate) {
-    unique_id = util::uuid_t::generate().string();
-
-    auto dir = std::filesystem::temp_directory_path() / "Sushine"sv;
-
-    config::nvhttp.cert = (dir / ("cert-"s + unique_id)).string();
-    config::nvhttp.pkey = (dir / ("pkey-"s + unique_id)).string();
-  }
-
-
-  if(!fs::exists(config::nvhttp.pkey) || !fs::exists(config::nvhttp.cert)) {
-    if(create_creds(config::nvhttp.pkey, config::nvhttp.cert)) {
-      shutdown_event->raise(true);
-      return;
-    }
-  }
-
-  origin_pin_allowed = net::from_enum_string(config::nvhttp.origin_pin_allowed);
 
   if(!clean_slate) {
     load_state();
   }
 
-  conf_intern.pkey = read_file(config::nvhttp.pkey.c_str());
+  conf_intern.pkey       = read_file(config::nvhttp.pkey.c_str());
   conf_intern.servercert = read_file(config::nvhttp.cert.c_str());
 
   auto ctx = std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::tls);
@@ -765,7 +789,7 @@ void start(std::shared_ptr<safe::signal_t> shutdown_event) {
   ctx->use_private_key_file(config::nvhttp.pkey, boost::asio::ssl::context::pem);
 
   crypto::cert_chain_t cert_chain;
-  for(auto &[_,client] : map_id_client) {
+  for(auto &[_, client] : map_id_client) {
     for(auto &cert : client.certs) {
       cert_chain.add(crypto::x509(cert));
     }
@@ -773,22 +797,38 @@ void start(std::shared_ptr<safe::signal_t> shutdown_event) {
 
   auto add_cert = std::make_shared<safe::queue_t<crypto::x509_t>>(30);
 
-  // Ugly hack for verifying certificates, see crypto::cert_chain_t::verify() for details
-  ctx->set_verify_callback([&cert_chain, add_cert](int verified, boost::asio::ssl::verify_context &ctx) {
+  ctx->set_verify_callback([](int verified, boost::asio::ssl::verify_context &ctx) {
+    // To respond with an error message, a connection must be established
+    return 1;
+  });
+
+  // /resume doesn't get the parameter "localAudioPlayMode"
+  // /launch will store it in host_audio
+  bool host_audio {};
+
+  https_server_t https_server { ctx, boost::asio::ssl::verify_peer | boost::asio::ssl::verify_fail_if_no_peer_cert | boost::asio::ssl::verify_client_once };
+  http_server_t http_server;
+
+  // Verify certificates after establishing connection
+  https_server.verify = [&cert_chain, add_cert](SSL *ssl) {
+    auto x509 = SSL_get_peer_certificate(ssl);
+    if(!x509) {
+      BOOST_LOG(info) << "unknown -- denied"sv;
+      return 0;
+    }
+
+    int verified = 0;
+
     auto fg = util::fail_guard([&]() {
       char subject_name[256];
 
-      auto x509 = ctx.native_handle();
-      X509_NAME_oneline(X509_get_subject_name(X509_STORE_CTX_get_current_cert(x509)), subject_name, sizeof(subject_name));
+
+      X509_NAME_oneline(X509_get_subject_name(x509), subject_name, sizeof(subject_name));
 
 
       BOOST_LOG(info) << subject_name << " -- "sv << (verified ? "verfied"sv : "denied"sv);
     });
 
-    if(verified) {
-      return 1;
-    }
-
     while(add_cert->peek()) {
       char subject_name[256];
 
@@ -799,48 +839,62 @@ void start(std::shared_ptr<safe::signal_t> shutdown_event) {
       cert_chain.add(std::move(cert));
     }
 
-    auto err_str = cert_chain.verify(X509_STORE_CTX_get_current_cert(ctx.native_handle()));
+    auto err_str = cert_chain.verify(x509);
     if(err_str) {
       BOOST_LOG(warning) << "SSL Verification error :: "sv << err_str;
-      return 0;
+
+      return verified;
     }
 
     verified = 1;
-    return 1;
-  });
 
+    return verified;
+  };
 
-  https_server_t https_server { ctx, boost::asio::ssl::verify_peer | boost::asio::ssl::verify_fail_if_no_peer_cert | boost::asio::ssl::verify_client_once };
-  http_server_t http_server;
+  https_server.on_verify_failed = [](resp_https_t resp, req_https_t req) {
+    pt::ptree tree;
+    auto g = util::fail_guard([&]() {
+      std::ostringstream data;
 
-  https_server.default_resource = not_found<SimpleWeb::HTTPS>;
-  https_server.resource["^/serverinfo$"]["GET"] = serverinfo<SimpleWeb::HTTPS>;
-  https_server.resource["^/pair$"]["GET"] = [&add_cert](auto resp, auto req) { pair<SimpleWeb::HTTPS>(add_cert, resp, req); };
-  https_server.resource["^/applist$"]["GET"] = applist;
-  https_server.resource["^/appasset$"]["GET"] = appasset;
-  https_server.resource["^/launch$"]["GET"] = launch;
+      pt::write_xml(data, tree);
+      resp->write(data.str());
+      resp->close_connection_after_response = true;
+    });
+
+    tree.put("root.<xmlattr>.status_code"s, 401);
+    tree.put("root.<xmlattr>.query"s, req->path);
+    tree.put("root.<xmlattr>.status_message"s, "The client is not authorized. Certificate verification failed."s);
+  };
+
+  https_server.default_resource                   = not_found<SimpleWeb::HTTPS>;
+  https_server.resource["^/serverinfo$"]["GET"]   = serverinfo<SimpleWeb::HTTPS>;
+  https_server.resource["^/pair$"]["GET"]         = [&add_cert](auto resp, auto req) { pair<SimpleWeb::HTTPS>(add_cert, resp, req); };
+  https_server.resource["^/applist$"]["GET"]      = applist;
+  https_server.resource["^/appasset$"]["GET"]     = appasset;
+  https_server.resource["^/launch$"]["GET"]       = [&host_audio](auto resp, auto req) { launch(host_audio, resp, req); };
   https_server.resource["^/pin/([0-9]+)$"]["GET"] = pin<SimpleWeb::HTTPS>;
-  https_server.resource["^/resume$"]["GET"] = resume;
-  https_server.resource["^/cancel$"]["GET"] = cancel;
+  https_server.resource["^/resume$"]["GET"]       = [&host_audio](auto resp, auto req) { resume(host_audio, resp, req); };
+  https_server.resource["^/cancel$"]["GET"]       = cancel;
 
   https_server.config.reuse_address = true;
-  https_server.config.address = "0.0.0.0"s;
-  https_server.config.port = PORT_HTTPS;
+  https_server.config.address       = "0.0.0.0"s;
+  https_server.config.port          = port_https;
 
-  http_server.default_resource = not_found<SimpleWeb::HTTP>;
-  http_server.resource["^/serverinfo$"]["GET"] = serverinfo<SimpleWeb::HTTP>;
-  http_server.resource["^/pair$"]["GET"] = [&add_cert](auto resp, auto req) { pair<SimpleWeb::HTTP>(add_cert, resp, req); };
+  http_server.default_resource                   = not_found<SimpleWeb::HTTP>;
+  http_server.resource["^/serverinfo$"]["GET"]   = serverinfo<SimpleWeb::HTTP>;
+  http_server.resource["^/pair$"]["GET"]         = [&add_cert](auto resp, auto req) { pair<SimpleWeb::HTTP>(add_cert, resp, req); };
   http_server.resource["^/pin/([0-9]+)$"]["GET"] = pin<SimpleWeb::HTTP>;
 
   http_server.config.reuse_address = true;
-  http_server.config.address = "0.0.0.0"s;
-  http_server.config.port = PORT_HTTP;
+  http_server.config.address       = "0.0.0.0"s;
+  http_server.config.port          = port_http;
 
   try {
     https_server.bind();
     http_server.bind();
-  } catch(boost::system::system_error &err) {
-    BOOST_LOG(fatal) << "Couldn't bind http server to ports ["sv << PORT_HTTPS << ", "sv << PORT_HTTP << "]: "sv << err.what();
+  }
+  catch(boost::system::system_error &err) {
+    BOOST_LOG(fatal) << "Couldn't bind http server to ports ["sv << port_http << ", "sv << port_http << "]: "sv << err.what();
 
     shutdown_event->raise(true);
     return;
@@ -849,13 +903,14 @@ void start(std::shared_ptr<safe::signal_t> shutdown_event) {
   auto accept_and_run = [&](auto *http_server) {
     try {
       http_server->accept_and_run();
-    } catch(boost::system::system_error &err) {
+    }
+    catch(boost::system::system_error &err) {
       // It's possible the exception gets thrown after calling http_server->stop() from a different thread
       if(shutdown_event->peek()) {
         return;
       }
 
-      BOOST_LOG(fatal) << "Couldn't start http server to ports ["sv << PORT_HTTPS << ", "sv << PORT_HTTP << "]: "sv << err.what();
+      BOOST_LOG(fatal) << "Couldn't start http server to ports ["sv << port_https << ", "sv << port_https << "]: "sv << err.what();
       shutdown_event->raise(true);
       return;
     }
@@ -872,31 +927,4 @@ void start(std::shared_ptr<safe::signal_t> shutdown_event) {
   ssl.join();
   tcp.join();
 }
-
-int write_file(const char *path, const std::string_view &contents) {
-  std::ofstream out(path);
-
-  if(!out.is_open()) {
-    return -1;
-  }
-
-  out << contents;
-
-  return 0;
-}
-
-std::string read_file(const char *path) {
-  std::ifstream in(path);
-
-  std::string input;
-  std::string base64_cert;
-
-  //FIXME:  Being unable to read file could result in infinite loop
-  while(!in.eof()) {
-    std::getline(in, input);
-    base64_cert += input + '\n';
-  }
-
-  return base64_cert;
-}
-}
+} // namespace nvhttp

sunshine/nvhttp.h

@@ -5,17 +5,15 @@
 #ifndef SUNSHINE_NVHTTP_H
 #define SUNSHINE_NVHTTP_H
 
-#include <functional>
+#include "thread_safe.h"
 #include <string>
 
-#include "thread_safe.h"
-
-#define CA_DIR SUNSHINE_ASSETS_DIR "/demoCA"
-#define PRIVATE_KEY_FILE CA_DIR    "/cakey.pem"
-#define CERTIFICATE_FILE CA_DIR    "/cacert.pem"
-
 namespace nvhttp {
-void start(std::shared_ptr<safe::signal_t> shutdown_event);
-}
+constexpr auto PORT_HTTP  = 0;
+constexpr auto PORT_HTTPS = -5;
+
+void start();
+bool pin(std::string pin);
+} // namespace nvhttp
 
 #endif //SUNSHINE_NVHTTP_H

sunshine/platform/common.h

@@ -5,11 +5,16 @@
 #ifndef SUNSHINE_COMMON_H
 #define SUNSHINE_COMMON_H
 
-#include <string>
+#include <bitset>
+#include <filesystem>
 #include <mutex>
+#include <string>
+
 #include "sunshine/utility.h"
 
 struct sockaddr;
+struct AVFrame;
+
 namespace platf {
 constexpr auto MAX_GAMEPADS = 32;
 
@@ -29,9 +34,48 @@ constexpr std::uint16_t B            = 0x2000;
 constexpr std::uint16_t X            = 0x4000;
 constexpr std::uint16_t Y            = 0x8000;
 
-enum class dev_type_e {
-  none,
+namespace speaker {
+enum speaker_e {
+  FRONT_LEFT,
+  FRONT_RIGHT,
+  FRONT_CENTER,
+  LOW_FREQUENCY,
+  BACK_LEFT,
+  BACK_RIGHT,
+  SIDE_LEFT,
+  SIDE_RIGHT,
+  MAX_SPEAKERS,
+};
+
+constexpr std::uint8_t map_stereo[] {
+  FRONT_LEFT, FRONT_RIGHT
+};
+constexpr std::uint8_t map_surround51[] {
+  FRONT_LEFT,
+  FRONT_RIGHT,
+  FRONT_CENTER,
+  LOW_FREQUENCY,
+  BACK_LEFT,
+  BACK_RIGHT,
+};
+constexpr std::uint8_t map_surround71[] {
+  FRONT_LEFT,
+  FRONT_RIGHT,
+  FRONT_CENTER,
+  LOW_FREQUENCY,
+  LOW_FREQUENCY,
+  BACK_LEFT,
+  BACK_RIGHT,
+  SIDE_LEFT,
+  SIDE_RIGHT,
+};
+} // namespace speaker
+
+enum class mem_type_e {
+  system,
+  vaapi,
   dxgi,
+  cuda,
   unknown
 };
 
@@ -44,8 +88,10 @@ enum class pix_fmt_e {
 };
 
 inline std::string_view from_pix_fmt(pix_fmt_e pix_fmt) {
-using namespace std::literals;
-#define _CONVERT(x) case pix_fmt_e:: x : return  #x ## sv
+  using namespace std::literals;
+#define _CONVERT(x)  \
+  case pix_fmt_e::x: \
+    return #x##sv
   switch(pix_fmt) {
     _CONVERT(yuv420p);
     _CONVERT(yuv420p10);
@@ -60,14 +106,8 @@ using namespace std::literals;
 
 // Dimensions for touchscreen input
 struct touch_port_t {
-  std::uint32_t offset_x, offset_y;
-  std::uint32_t width, height;
-
-  constexpr touch_port_t(
-    std::uint32_t offset_x, std::uint32_t offset_y,
-    std::uint32_t width, std::uint32_t height) noexcept :
-    offset_x { offset_x }, offset_y { offset_y },
-    width { width }, height { height } {};
+  int offset_x, offset_y;
+  int width, height;
 };
 
 struct gamepad_state_t {
@@ -87,27 +127,49 @@ public:
 
 struct img_t {
 public:
-  std::uint8_t *data  {};
-  std::int32_t width  {};
+  std::uint8_t *data {};
+  std::int32_t width {};
   std::int32_t height {};
   std::int32_t pixel_pitch {};
   std::int32_t row_pitch {};
 
-  img_t() = default;
-  img_t(const img_t&) = delete;
-  img_t(img_t&&) = delete;
+  img_t()              = default;
+  img_t(const img_t &) = delete;
+  img_t(img_t &&)      = delete;
 
   virtual ~img_t() = default;
 };
 
+struct sink_t {
+  // Play on host PC
+  std::string host;
+
+  // On Windows, it is not possible to create a virtual sink
+  // Therefore, it is optional
+  struct null_t {
+    std::string stereo;
+    std::string surround51;
+    std::string surround71;
+  };
+  std::optional<null_t> null;
+};
+
 struct hwdevice_t {
   void *data {};
-  platf::img_t *img {};
+  AVFrame *frame {};
 
   virtual int convert(platf::img_t &img) {
     return -1;
   }
 
+  /**
+   * implementations must take ownership of 'frame'
+   */
+  virtual int set_frame(AVFrame *frame) {
+    std::abort(); // ^ This function must never be called
+    return -1;
+  };
+
   virtual void set_colorspace(std::uint32_t colorspace, std::uint32_t color_range) {};
 
   virtual ~hwdevice_t() = default;
@@ -124,11 +186,11 @@ class display_t {
 public:
   display_t() noexcept : offset_x { 0 }, offset_y { 0 } {}
   virtual capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor) = 0;
-  virtual std::shared_ptr<img_t> alloc_img() = 0;
+  virtual std::shared_ptr<img_t> alloc_img()                                             = 0;
 
   virtual int dummy_img(img_t *img) = 0;
 
-  virtual std::shared_ptr<hwdevice_t> make_hwdevice(int width, int height, pix_fmt_e pix_fmt) {
+  virtual std::shared_ptr<hwdevice_t> make_hwdevice(pix_fmt_e pix_fmt) {
     return std::make_shared<hwdevice_t>();
   }
 
@@ -136,6 +198,7 @@ public:
 
   // Offsets for when streaming a specific monitor. By default, they are 0.
   int offset_x, offset_y;
+  int env_width, env_height;
 
   int width, height;
 };
@@ -147,18 +210,30 @@ public:
   virtual ~mic_t() = default;
 };
 
+class audio_control_t {
+public:
+  virtual int set_sink(const std::string &sink) = 0;
 
-void freeInput(void*);
+  virtual std::unique_ptr<mic_t> microphone(const std::uint8_t *mapping, int channels, std::uint32_t sample_rate, std::uint32_t frame_size) = 0;
+
+  virtual std::optional<sink_t> sink_info() = 0;
+
+  virtual ~audio_control_t() = default;
+};
+
+void freeInput(void *);
 
 using input_t = util::safe_ptr<void, freeInput>;
 
+std::filesystem::path appdata();
+
 std::string get_mac_address(const std::string_view &address);
 
 std::string from_sockaddr(const sockaddr *const);
 std::pair<std::uint16_t, std::string> from_sockaddr_ex(const sockaddr *const);
 
-std::unique_ptr<mic_t> microphone(std::uint32_t sample_rate);
-std::shared_ptr<display_t> display(dev_type_e hwdevice_type);
+std::unique_ptr<audio_control_t> audio_control();
+std::shared_ptr<display_t> display(mem_type_e hwdevice_type);
 
 input_t input();
 void move_mouse(input_t &input, int deltaX, int deltaY);
@@ -171,7 +246,14 @@ void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state);
 int alloc_gamepad(input_t &input, int nr);
 void free_gamepad(input_t &input, int nr);
 
-[[nodiscard]] std::unique_ptr<deinit_t> init();
+#define SERVICE_NAME "Sunshine"
+#define SERVICE_TYPE "_nvstream._tcp"
+
+namespace publish {
+[[nodiscard]] std::unique_ptr<deinit_t> start();
 }
 
+[[nodiscard]] std::unique_ptr<deinit_t> init();
+} // namespace platf
+
 #endif //SUNSHINE_COMMON_H

sunshine/platform/linux/audio.cpp

@@ -0,0 +1,437 @@
+//
+// Created by loki on 5/16/21.
+//
+#include <bitset>
+#include <sstream>
+
+#include <boost/regex.hpp>
+
+#include <pulse/error.h>
+#include <pulse/pulseaudio.h>
+#include <pulse/simple.h>
+
+#include "sunshine/platform/common.h"
+
+#include "sunshine/config.h"
+#include "sunshine/main.h"
+#include "sunshine/thread_safe.h"
+
+namespace platf {
+using namespace std::literals;
+
+constexpr pa_channel_position_t position_mapping[] {
+  PA_CHANNEL_POSITION_FRONT_LEFT,
+  PA_CHANNEL_POSITION_FRONT_RIGHT,
+  PA_CHANNEL_POSITION_FRONT_CENTER,
+  PA_CHANNEL_POSITION_LFE,
+  PA_CHANNEL_POSITION_REAR_LEFT,
+  PA_CHANNEL_POSITION_REAR_RIGHT,
+  PA_CHANNEL_POSITION_SIDE_LEFT,
+  PA_CHANNEL_POSITION_SIDE_RIGHT,
+};
+
+std::string to_string(const char *name, const std::uint8_t *mapping, int channels) {
+  std::stringstream ss;
+
+  ss << "rate=48000 sink_name="sv << name << " format=s16le channels="sv << channels << " channel_map="sv;
+  std::for_each_n(mapping, channels - 1, [&ss](std::uint8_t pos) {
+    ss << pa_channel_position_to_string(position_mapping[pos]) << ',';
+  });
+
+  ss << pa_channel_position_to_string(position_mapping[mapping[channels - 1]]);
+
+  ss << " sink_properties=device.description="sv << name;
+  auto result = ss.str();
+
+  BOOST_LOG(debug) << "null-sink args: "sv << result;
+  return result;
+}
+
+struct mic_attr_t : public mic_t {
+  util::safe_ptr<pa_simple, pa_simple_free> mic;
+
+  capture_e sample(std::vector<std::int16_t> &sample_buf) override {
+    auto sample_size = sample_buf.size();
+
+    auto buf = sample_buf.data();
+    int status;
+    if(pa_simple_read(mic.get(), buf, sample_size * 2, &status)) {
+      BOOST_LOG(error) << "pa_simple_read() failed: "sv << pa_strerror(status);
+
+      return capture_e::error;
+    }
+
+    return capture_e::ok;
+  }
+};
+
+std::unique_ptr<mic_t> microphone(const std::uint8_t *mapping, int channels, std::uint32_t sample_rate) {
+  auto mic = std::make_unique<mic_attr_t>();
+
+  pa_sample_spec ss { PA_SAMPLE_S16LE, sample_rate, (std::uint8_t)channels };
+  pa_channel_map pa_map;
+
+  pa_map.channels = channels;
+  std::for_each_n(pa_map.map, pa_map.channels, [mapping](auto &channel) mutable {
+    channel = position_mapping[*mapping++];
+  });
+
+  int status;
+
+  const char *audio_sink = "@DEFAULT_MONITOR@";
+  if(!config::audio.sink.empty()) {
+    audio_sink = config::audio.sink.c_str();
+  }
+
+  mic->mic.reset(
+    pa_simple_new(nullptr, "sunshine",
+      pa_stream_direction_t::PA_STREAM_RECORD, audio_sink,
+      "sunshine-record", &ss, &pa_map, nullptr, &status));
+
+  if(!mic->mic) {
+    auto err_str = pa_strerror(status);
+    BOOST_LOG(error) << "pa_simple_new() failed: "sv << err_str;
+
+    log_flush();
+    std::abort();
+  }
+
+  return mic;
+}
+
+namespace pa {
+template<bool B, class T>
+struct add_const_helper;
+
+template<class T>
+struct add_const_helper<true, T> {
+  using type = const std::remove_pointer_t<T> *;
+};
+
+template<class T>
+struct add_const_helper<false, T> {
+  using type = const T *;
+};
+
+template<class T>
+using add_const_t = typename add_const_helper<std::is_pointer_v<T>, T>::type;
+
+template<class T>
+void pa_free(T *p) {
+  pa_xfree(p);
+}
+using ctx_t    = util::safe_ptr<pa_context, pa_context_unref>;
+using loop_t   = util::safe_ptr<pa_mainloop, pa_mainloop_free>;
+using op_t     = util::safe_ptr<pa_operation, pa_operation_unref>;
+using string_t = util::safe_ptr<char, pa_free<char>>;
+
+template<class T>
+using cb_t = std::function<void(ctx_t::pointer, add_const_t<T> i, int eol)>;
+
+template<class T>
+void cb(ctx_t::pointer ctx, add_const_t<T> i, int eol, void *userdata) {
+  auto &f = *(cb_t<T> *)userdata;
+
+  // For some reason, pulseaudio calls this callback after disconnecting
+  if(i && eol) {
+    return;
+  }
+
+  f(ctx, i, eol);
+}
+
+void cb_i(ctx_t::pointer ctx, std::uint32_t i, void *userdata) {
+  auto alarm = (safe::alarm_raw_t<int> *)userdata;
+
+  alarm->ring(i);
+}
+
+void ctx_state_cb(ctx_t::pointer ctx, void *userdata) {
+  auto &f = *(std::function<void(ctx_t::pointer)> *)userdata;
+
+  f(ctx);
+}
+
+void success_cb(ctx_t::pointer ctx, int status, void *userdata) {
+  assert(userdata != nullptr);
+
+  auto alarm = (safe::alarm_raw_t<int> *)userdata;
+  alarm->ring(status ? 0 : 1);
+}
+
+class server_t : public audio_control_t {
+  enum ctx_event_e : int {
+    ready,
+    terminated,
+    failed
+  };
+
+public:
+  loop_t loop;
+  ctx_t ctx;
+
+  struct {
+    std::uint32_t stereo     = PA_INVALID_INDEX;
+    std::uint32_t surround51 = PA_INVALID_INDEX;
+    std::uint32_t surround71 = PA_INVALID_INDEX;
+  } index;
+
+  std::unique_ptr<safe::event_t<ctx_event_e>> events;
+  std::unique_ptr<std::function<void(ctx_t::pointer)>> events_cb;
+
+  std::thread worker;
+  int init() {
+    events = std::make_unique<safe::event_t<ctx_event_e>>();
+    loop.reset(pa_mainloop_new());
+    ctx.reset(pa_context_new(pa_mainloop_get_api(loop.get()), "sunshine"));
+
+    events_cb = std::make_unique<std::function<void(ctx_t::pointer)>>([this](ctx_t::pointer ctx) {
+      switch(pa_context_get_state(ctx)) {
+      case PA_CONTEXT_READY:
+        events->raise(ready);
+        break;
+      case PA_CONTEXT_TERMINATED:
+        BOOST_LOG(debug) << "Pulseadio context terminated"sv;
+        events->raise(terminated);
+        break;
+      case PA_CONTEXT_FAILED:
+        BOOST_LOG(debug) << "Pulseadio context failed"sv;
+        events->raise(failed);
+        break;
+      case PA_CONTEXT_CONNECTING:
+        BOOST_LOG(debug) << "Connecting to pulseaudio"sv;
+      case PA_CONTEXT_UNCONNECTED:
+      case PA_CONTEXT_AUTHORIZING:
+      case PA_CONTEXT_SETTING_NAME:
+        break;
+      }
+    });
+
+    pa_context_set_state_callback(ctx.get(), ctx_state_cb, events_cb.get());
+
+    auto status = pa_context_connect(ctx.get(), nullptr, PA_CONTEXT_NOFLAGS, nullptr);
+    if(status) {
+      BOOST_LOG(error) << "Couldn't connect to pulseaudio: "sv << pa_strerror(status);
+      return -1;
+    }
+
+    worker = std::thread {
+      [](loop_t::pointer loop) {
+        int retval;
+        auto status = pa_mainloop_run(loop, &retval);
+
+        if(status < 0) {
+          BOOST_LOG(fatal) << "Couldn't run pulseaudio main loop"sv;
+
+          log_flush();
+          std::abort();
+        }
+      },
+      loop.get()
+    };
+
+    auto event = events->pop();
+    if(event == failed) {
+      return -1;
+    }
+
+    return 0;
+  }
+
+  int load_null(const char *name, const std::uint8_t *channel_mapping, int channels) {
+    auto alarm = safe::make_alarm<int>();
+
+    op_t op {
+      pa_context_load_module(
+        ctx.get(),
+        "module-null-sink",
+        to_string(name, channel_mapping, channels).c_str(),
+        cb_i,
+        alarm.get()),
+    };
+
+    alarm->wait();
+    return *alarm->status();
+  }
+
+  int unload_null(std::uint32_t i) {
+    if(i == PA_INVALID_INDEX) {
+      return 0;
+    }
+
+    auto alarm = safe::make_alarm<int>();
+
+    op_t op {
+      pa_context_unload_module(ctx.get(), i, success_cb, alarm.get())
+    };
+
+    alarm->wait();
+
+    if(*alarm->status()) {
+      BOOST_LOG(error) << "Couldn't unload null-sink with index ["sv << i << "]: "sv << pa_strerror(pa_context_errno(ctx.get()));
+      return -1;
+    }
+
+    return 0;
+  }
+
+  std::optional<sink_t> sink_info() override {
+    constexpr auto stereo     = "sink-sunshine-stereo";
+    constexpr auto surround51 = "sink-sunshine-surround51";
+    constexpr auto surround71 = "sink-sunshine-surround71";
+
+    auto alarm = safe::make_alarm<int>();
+
+    sink_t sink;
+
+    // If hardware sink with more channels found, set that as host
+    int channels = 0;
+    // Count of all virtual sinks that are created by us
+    int nullcount = 0;
+
+    cb_t<pa_sink_info *> f = [&](ctx_t::pointer ctx, const pa_sink_info *sink_info, int eol) {
+      if(!sink_info) {
+        if(!eol) {
+          BOOST_LOG(error) << "Couldn't get pulseaudio sink info: "sv << pa_strerror(pa_context_errno(ctx));
+
+          alarm->ring(-1);
+        }
+
+        alarm->ring(0);
+        return;
+      }
+
+      if(sink_info->active_port != nullptr) {
+        sink.host = sink_info->name;
+        channels  = sink_info->channel_map.channels;
+      }
+
+      // Ensure Sunshine won't create a sink that already exists.
+      if(!std::strcmp(sink_info->name, stereo)) {
+        index.stereo = sink_info->owner_module;
+
+        ++nullcount;
+      }
+      else if(!std::strcmp(sink_info->name, surround51)) {
+        index.surround51 = sink_info->owner_module;
+
+        ++nullcount;
+      }
+      else if(!std::strcmp(sink_info->name, surround71)) {
+        index.surround71 = sink_info->owner_module;
+
+        ++nullcount;
+      }
+    };
+
+    op_t op { pa_context_get_sink_info_list(ctx.get(), cb<pa_sink_info *>, &f) };
+
+    if(!op) {
+      BOOST_LOG(error) << "Couldn't create card info operation: "sv << pa_strerror(pa_context_errno(ctx.get()));
+
+      return std::nullopt;
+    }
+
+    alarm->wait();
+
+    if(*alarm->status()) {
+      return std::nullopt;
+    }
+
+    if(!channels) {
+      BOOST_LOG(warning) << "Couldn't find an active sink"sv;
+    }
+
+    if(index.stereo == PA_INVALID_INDEX) {
+      index.stereo = load_null(stereo, speaker::map_stereo, sizeof(speaker::map_stereo));
+      if(index.stereo == PA_INVALID_INDEX) {
+        BOOST_LOG(warning) << "Couldn't create virtual sink for stereo: "sv << pa_strerror(pa_context_errno(ctx.get()));
+      }
+      else {
+        ++nullcount;
+      }
+    }
+
+    if(index.surround51 == PA_INVALID_INDEX) {
+      index.surround51 = load_null(surround51, speaker::map_surround51, sizeof(speaker::map_surround51));
+      if(index.surround51 == PA_INVALID_INDEX) {
+        BOOST_LOG(warning) << "Couldn't create virtual sink for surround-51: "sv << pa_strerror(pa_context_errno(ctx.get()));
+      }
+      else {
+        ++nullcount;
+      }
+    }
+
+    if(index.surround71 == PA_INVALID_INDEX) {
+      index.surround71 = load_null(surround71, speaker::map_surround71, sizeof(speaker::map_surround71));
+      if(index.surround71 == PA_INVALID_INDEX) {
+        BOOST_LOG(warning) << "Couldn't create virtual sink for surround-71: "sv << pa_strerror(pa_context_errno(ctx.get()));
+      }
+      else {
+        ++nullcount;
+      }
+    }
+
+    if(nullcount == 3) {
+      sink.null = std::make_optional(sink_t::null_t { stereo, surround51, surround71 });
+    }
+
+    return std::make_optional(std::move(sink));
+  }
+
+  std::unique_ptr<mic_t> microphone(const std::uint8_t *mapping, int channels, std::uint32_t sample_rate, std::uint32_t frame_size) override {
+    return ::platf::microphone(mapping, channels, sample_rate);
+  }
+
+  int set_sink(const std::string &sink) override {
+    auto alarm = safe::make_alarm<int>();
+
+    op_t op {
+      pa_context_set_default_sink(
+        ctx.get(), sink.c_str(), success_cb, alarm.get()),
+    };
+
+    if(!op) {
+      BOOST_LOG(error) << "Couldn't create set default-sink operation: "sv << pa_strerror(pa_context_errno(ctx.get()));
+      return -1;
+    }
+
+    alarm->wait();
+    if(*alarm->status()) {
+      BOOST_LOG(error) << "Couldn't set default-sink ["sv << sink << "]: "sv << pa_strerror(pa_context_errno(ctx.get()));
+
+      return -1;
+    }
+
+    return 0;
+  }
+
+  ~server_t() override {
+    unload_null(index.stereo);
+    unload_null(index.surround51);
+    unload_null(index.surround71);
+
+    if(worker.joinable()) {
+      pa_context_disconnect(ctx.get());
+
+      KITTY_WHILE_LOOP(auto event = events->pop(), event != terminated && event != failed, {
+        event = events->pop();
+      })
+
+      pa_mainloop_quit(loop.get(), 0);
+      worker.join();
+    }
+  }
+};
+} // namespace pa
+
+std::unique_ptr<audio_control_t> audio_control() {
+  auto audio = std::make_unique<pa::server_t>();
+
+  if(audio->init()) {
+    return nullptr;
+  }
+
+  return audio;
+}
+} // namespace platf

sunshine/platform/linux/display.cpp

@@ -5,46 +5,40 @@
 #include "sunshine/platform/common.h"
 
 #include <fstream>
-#include <bitset>
-
-#include <arpa/inet.h>
-#include <ifaddrs.h>
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
-#include <xcb/shm.h>
-#include <xcb/xfixes.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
+#include <xcb/shm.h>
+#include <xcb/xfixes.h>
 
-#include <pulse/simple.h>
-#include <pulse/error.h>
-
-#include "sunshine/task_pool.h"
 #include "sunshine/config.h"
 #include "sunshine/main.h"
+#include "sunshine/task_pool.h"
+
+#include "vaapi.h"
 
-namespace platf
-{
 using namespace std::literals;
 
-void freeImage(XImage*);
-void freeX(XFixesCursorImage*);
+namespace platf {
+
+void freeImage(XImage *);
+void freeX(XFixesCursorImage *);
 
-using ifaddr_t = util::safe_ptr<ifaddrs, freeifaddrs>;
 using xcb_connect_t = util::safe_ptr<xcb_connection_t, xcb_disconnect>;
-using xcb_img_t = util::c_ptr<xcb_shm_get_image_reply_t>;
+using xcb_img_t     = util::c_ptr<xcb_shm_get_image_reply_t>;
 
 using xdisplay_t = util::safe_ptr_v2<Display, int, XCloseDisplay>;
-using ximg_t = util::safe_ptr<XImage, freeImage>;
-using xcursor_t = util::safe_ptr<XFixesCursorImage, freeX>;
+using ximg_t     = util::safe_ptr<XImage, freeImage>;
+using xcursor_t  = util::safe_ptr<XFixesCursorImage, freeX>;
 
-using crtc_info_t = util::safe_ptr<_XRRCrtcInfo, XRRFreeCrtcInfo>;
+using crtc_info_t   = util::safe_ptr<_XRRCrtcInfo, XRRFreeCrtcInfo>;
 using output_info_t = util::safe_ptr<_XRROutputInfo, XRRFreeOutputInfo>;
-using screen_res_t = util::safe_ptr<_XRRScreenResources, XRRFreeScreenResources>;
+using screen_res_t  = util::safe_ptr<_XRRScreenResources, XRRFreeScreenResources>;
 
 class shm_id_t {
 public:
@@ -55,7 +49,7 @@ public:
   }
 
   ~shm_id_t() {
-    if (id != -1) {
+    if(id != -1) {
       shmctl(id, IPC_RMID, nullptr);
       id = -1;
     }
@@ -65,15 +59,15 @@ public:
 
 class shm_data_t {
 public:
-  shm_data_t() : data { (void*) -1 } {}
+  shm_data_t() : data { (void *)-1 } {}
   shm_data_t(void *data) : data { data } {}
 
   shm_data_t(shm_data_t &&other) noexcept : data(other.data) {
-    other.data = (void*)-1;
+    other.data = (void *)-1;
   }
 
   ~shm_data_t() {
-    if((std::uintptr_t) data != -1) {
+    if((std::uintptr_t)data != -1) {
       shmdt(data);
     }
   }
@@ -81,11 +75,11 @@ public:
   void *data;
 };
 
-struct x11_img_t: public img_t {
+struct x11_img_t : public img_t {
   ximg_t img;
 };
 
-struct shm_img_t: public img_t {
+struct shm_img_t : public img_t {
   ~shm_img_t() override {
     delete[] data;
     data = nullptr;
@@ -95,7 +89,7 @@ struct shm_img_t: public img_t {
 void blend_cursor(Display *display, img_t &img, int offsetX, int offsetY) {
   xcursor_t overlay { XFixesGetCursorImage(display) };
 
-  if (!overlay) {
+  if(!overlay) {
     BOOST_LOG(error) << "Couldn't get cursor from XFixesGetCursorImage"sv;
     return;
   }
@@ -109,51 +103,53 @@ void blend_cursor(Display *display, img_t &img, int offsetX, int offsetY) {
   overlay->x = std::max((short)0, overlay->x);
   overlay->y = std::max((short)0, overlay->y);
 
-  auto pixels = (int*)img.data;
+  auto pixels = (int *)img.data;
 
   auto screen_height = img.height;
-  auto screen_width = img.width;
+  auto screen_width  = img.width;
 
-  auto delta_height = std::min<uint16_t>(overlay->height,std::max(0, screen_height - overlay->y));
-  auto delta_width = std::min<uint16_t>(overlay->width,std::max(0, screen_width - overlay->x));
-  for (auto y = 0; y < delta_height; ++y) {
+  auto delta_height = std::min<uint16_t>(overlay->height, std::max(0, screen_height - overlay->y));
+  auto delta_width  = std::min<uint16_t>(overlay->width, std::max(0, screen_width - overlay->x));
+  for(auto y = 0; y < delta_height; ++y) {
     auto overlay_begin = &overlay->pixels[y * overlay->width];
-    auto overlay_end = &overlay->pixels[y * overlay->width + delta_width];
+    auto overlay_end   = &overlay->pixels[y * overlay->width + delta_width];
 
-    auto pixels_begin = &pixels[(y + overlay->y)* (img.row_pitch / img.pixel_pitch) + overlay->x];
+    auto pixels_begin = &pixels[(y + overlay->y) * (img.row_pitch / img.pixel_pitch) + overlay->x];
 
-    std::for_each(overlay_begin, overlay_end,[&](long pixel) {
-      int *pixel_p = (int*) &pixel;
+    std::for_each(overlay_begin, overlay_end, [&](long pixel) {
+      int *pixel_p = (int *)&pixel;
 
-      auto colors_in = (uint8_t*) pixels_begin;
+      auto colors_in = (uint8_t *)pixels_begin;
 
-      auto alpha = (*(uint*) pixel_p) >> 24u;
-      if (alpha == 255) {
+      auto alpha = (*(uint *)pixel_p) >> 24u;
+      if(alpha == 255) {
         *pixels_begin = *pixel_p;
       }
       else {
-        auto colors_out = (uint8_t*) pixel_p;
-        colors_in[0] = colors_out[0] + (colors_in[0] * (255 - alpha) +255 /2) / 255;
-        colors_in[1] = colors_out[1] + (colors_in[1] * (255 - alpha) + 255 / 2) / 255;
-        colors_in[2] = colors_out[2] + (colors_in[2] * (255 - alpha) + 255 / 2) / 255;
+        auto colors_out = (uint8_t *)pixel_p;
+        colors_in[0]    = colors_out[0] + (colors_in[0] * (255 - alpha) + 255 / 2) / 255;
+        colors_in[1]    = colors_out[1] + (colors_in[1] * (255 - alpha) + 255 / 2) / 255;
+        colors_in[2]    = colors_out[2] + (colors_in[2] * (255 - alpha) + 255 / 2) / 255;
       }
       ++pixels_begin;
     });
   }
 }
-struct x11_attr_t: public display_t
-{
+
+struct x11_attr_t : public display_t {
   xdisplay_t xdisplay;
   Window xwindow;
   XWindowAttributes xattr;
 
+  mem_type_e mem_type;
+
   /*
    * Last X (NOT the streamed monitor!) size.
    * This way we can trigger reinitialization if the dimensions changed while streaming
    */
-  int lastWidth, lastHeight;
+  // int env_width, env_height;
 
-  x11_attr_t() : xdisplay { XOpenDisplay(nullptr) }, xwindow { }, xattr { } {
+  x11_attr_t(mem_type_e mem_type) : xdisplay { XOpenDisplay(nullptr) }, xwindow {}, xattr {}, mem_type { mem_type } {
     XInitThreads();
   }
 
@@ -177,33 +173,39 @@ struct x11_attr_t: public display_t
       screen_res_t screenr { XRRGetScreenResources(xdisplay.get(), xwindow) };
       int output = screenr->noutput;
 
-      if(streamedMonitor >= output) {
-        BOOST_LOG(error) << "Could not stream display number ["sv << streamedMonitor << "], there are only ["sv << output << "] displays."sv;
+      output_info_t result;
+      int monitor = 0;
+      for(int x = 0; x < output; ++x) {
+        output_info_t out_info { XRRGetOutputInfo(xdisplay.get(), screenr.get(), screenr->outputs[x]) };
+        if(out_info && out_info->connection == RR_Connected) {
+          if(monitor++ == streamedMonitor) {
+            result = std::move(out_info);
+            break;
+          }
+        }
+      }
+
+      if(!result) {
+        BOOST_LOG(error) << "Could not stream display number ["sv << streamedMonitor << "], there are only ["sv << monitor << "] displays."sv;
         return -1;
       }
 
-      output_info_t out_info { XRRGetOutputInfo(xdisplay.get(), screenr.get(), screenr->outputs[streamedMonitor]) };
-      if(!out_info || out_info->connection != RR_Connected) {
-        BOOST_LOG(error) << "Could not stream selected display because it doesn't seem to be connected"sv;
-        return -1;
-      }
-
-      crtc_info_t crt_info { XRRGetCrtcInfo(xdisplay.get(), screenr.get(), out_info->crtc) };
+      crtc_info_t crt_info { XRRGetCrtcInfo(xdisplay.get(), screenr.get(), result->crtc) };
       BOOST_LOG(info)
-        << "Streaming display: "sv << out_info->name << " with res "sv << crt_info->width << 'x' << crt_info->height << " offset by "sv << crt_info->x << 'x' << crt_info->y;
+        << "Streaming display: "sv << result->name << " with res "sv << crt_info->width << 'x' << crt_info->height << " offset by "sv << crt_info->x << 'x' << crt_info->y;
 
-      width = crt_info->width;
-      height = crt_info->height;
+      width    = crt_info->width;
+      height   = crt_info->height;
       offset_x = crt_info->x;
       offset_y = crt_info->y;
     }
     else {
-      width = xattr.width;
+      width  = xattr.width;
       height = xattr.height;
     }
 
-    lastWidth = xattr.width;
-    lastHeight = xattr.height;
+    env_width  = xattr.width;
+    env_height = xattr.height;
 
     return 0;
   }
@@ -219,21 +221,21 @@ struct x11_attr_t: public display_t
     refresh();
 
     //The whole X server changed, so we gotta reinit everything
-    if (xattr.width != lastWidth || xattr.height  != lastHeight) {
-      BOOST_LOG(warning)<< "X dimensions changed in non-SHM mode, request reinit"sv;
+    if(xattr.width != env_width || xattr.height != env_height) {
+      BOOST_LOG(warning) << "X dimensions changed in non-SHM mode, request reinit"sv;
       return capture_e::reinit;
     }
     XImage *img { XGetImage(xdisplay.get(), xwindow, offset_x, offset_y, width, height, AllPlanes, ZPixmap) };
 
-    auto img_out = (x11_img_t*) img_out_base;
-    img_out->width = img->width;
-    img_out->height = img->height;
-    img_out->data = (uint8_t*) img->data;
-    img_out->row_pitch = img->bytes_per_line;
+    auto img_out         = (x11_img_t *)img_out_base;
+    img_out->width       = img->width;
+    img_out->height      = img->height;
+    img_out->data        = (uint8_t *)img->data;
+    img_out->row_pitch   = img->bytes_per_line;
     img_out->pixel_pitch = img->bits_per_pixel / 8;
     img_out->img.reset(img);
 
-    if (cursor) {
+    if(cursor) {
       blend_cursor(xdisplay.get(), *img_out_base, offset_x, offset_y);
     }
 
@@ -244,13 +246,21 @@ struct x11_attr_t: public display_t
     return std::make_shared<x11_img_t>();
   }
 
+  std::shared_ptr<hwdevice_t> make_hwdevice(pix_fmt_e pix_fmt) override {
+    if(mem_type == mem_type_e::vaapi) {
+      return egl::make_hwdevice(width, height);
+    }
+
+    return std::make_shared<hwdevice_t>();
+  }
+
   int dummy_img(img_t *img) override {
     snapshot(img, 0s, true);
     return 0;
   }
 };
 
-struct shm_attr_t: public x11_attr_t {
+struct shm_attr_t : public x11_attr_t {
   xdisplay_t shm_xdisplay; // Prevent race condition with x11_attr_t::xdisplay
   xcb_connect_t xcb;
   xcb_screen_t *display;
@@ -265,33 +275,34 @@ struct shm_attr_t: public x11_attr_t {
   void delayed_refresh() {
     refresh();
 
-    refresh_task_id = task_pool.pushDelayed(&shm_attr_t::delayed_refresh,2s, this).task_id;
+    refresh_task_id = task_pool.pushDelayed(&shm_attr_t::delayed_refresh, 2s, this).task_id;
   }
 
-  shm_attr_t() : x11_attr_t(), shm_xdisplay { XOpenDisplay(nullptr) } {
+  shm_attr_t(mem_type_e mem_type) : x11_attr_t(mem_type), shm_xdisplay { XOpenDisplay(nullptr) } {
     refresh_task_id = task_pool.pushDelayed(&shm_attr_t::delayed_refresh, 2s, this).task_id;
   }
 
   ~shm_attr_t() override {
-    while(!task_pool.cancel(refresh_task_id));
+    while(!task_pool.cancel(refresh_task_id))
+      ;
   }
 
   capture_e snapshot(img_t *img, std::chrono::milliseconds timeout, bool cursor) override {
     //The whole X server changed, so we gotta reinit everything
-    if(xattr.width != lastWidth || xattr.height  != lastHeight) {
-      BOOST_LOG(warning)<< "X dimensions changed in SHM mode, request reinit"sv;
+    if(xattr.width != env_width || xattr.height != env_height) {
+      BOOST_LOG(warning) << "X dimensions changed in SHM mode, request reinit"sv;
       return capture_e::reinit;
     }
     else {
       auto img_cookie = xcb_shm_get_image_unchecked(xcb.get(), display->root, offset_x, offset_y, width, height, ~0, XCB_IMAGE_FORMAT_Z_PIXMAP, seg, 0);
 
-      xcb_img_t img_reply { xcb_shm_get_image_reply(xcb.get(), img_cookie,nullptr) };
+      xcb_img_t img_reply { xcb_shm_get_image_reply(xcb.get(), img_cookie, nullptr) };
       if(!img_reply) {
         BOOST_LOG(error) << "Could not get image reply"sv;
         return capture_e::reinit;
       }
 
-      std::copy_n((std::uint8_t*)data.data, frame_size(), img->data);
+      std::copy_n((std::uint8_t *)data.data, frame_size(), img->data);
 
       if(cursor) {
         blend_cursor(shm_xdisplay.get(), *img, offset_x, offset_y);
@@ -302,12 +313,12 @@ struct shm_attr_t: public x11_attr_t {
   }
 
   std::shared_ptr<img_t> alloc_img() override {
-    auto img = std::make_shared<shm_img_t>();
-    img->width = width;
-    img->height = height;
+    auto img         = std::make_shared<shm_img_t>();
+    img->width       = width;
+    img->height      = height;
     img->pixel_pitch = 4;
-    img->row_pitch = img->pixel_pitch * width;
-    img->data = new std::uint8_t[height * img->row_pitch];
+    img->row_pitch   = img->pixel_pitch * width;
+    img->data        = new std::uint8_t[height * img->row_pitch];
 
     return img;
   }
@@ -334,8 +345,8 @@ struct shm_attr_t: public x11_attr_t {
     }
 
     auto iter = xcb_setup_roots_iterator(xcb_get_setup(xcb.get()));
-    display = iter.data;
-    seg = xcb_generate_id(xcb.get());
+    display   = iter.data;
+    seg       = xcb_generate_id(xcb.get());
 
     shm_id.id = shmget(IPC_PRIVATE, frame_size(), IPC_CREAT | 0777);
     if(shm_id.id == -1) {
@@ -360,36 +371,14 @@ struct shm_attr_t: public x11_attr_t {
   }
 };
 
-struct mic_attr_t: public mic_t {
-  pa_sample_spec ss;
-  util::safe_ptr<pa_simple, pa_simple_free> mic;
-
-  explicit mic_attr_t(pa_sample_format format, std::uint32_t sample_rate,
-      std::uint8_t channels) : ss { format, sample_rate, channels }, mic { } { }
-
-  capture_e sample(std::vector<std::int16_t> &sample_buf) override {
-    auto sample_size = sample_buf.size();
-
-    auto buf = sample_buf.data();
-    int status;
-    if(pa_simple_read(mic.get(), buf, sample_size *2, &status)) {
-      BOOST_LOG(error) << "pa_simple_read() failed: "sv << pa_strerror(status);
-
-      return capture_e::error;
-    }
-
-    return capture_e::ok;
-  }
-};
-
-std::shared_ptr<display_t> display(platf::dev_type_e hwdevice_type) {
-  if(hwdevice_type != platf::dev_type_e::none) {
-    BOOST_LOG(error)<< "Could not initialize display with the given hw device type."sv;
+std::shared_ptr<display_t> display(platf::mem_type_e hwdevice_type) {
+  if(hwdevice_type != platf::mem_type_e::system && hwdevice_type != platf::mem_type_e::vaapi && hwdevice_type != platf::mem_type_e::cuda) {
+    BOOST_LOG(error) << "Could not initialize display with the given hw device type."sv;
     return nullptr;
   }
 
   // Attempt to use shared memory X11 to avoid copying the frame
-  auto shm_disp = std::make_shared<shm_attr_t>();
+  auto shm_disp = std::make_shared<shm_attr_t>(hwdevice_type);
 
   auto status = shm_disp->init();
   if(status > 0) {
@@ -402,7 +391,7 @@ std::shared_ptr<display_t> display(platf::dev_type_e hwdevice_type) {
   }
 
   // Fallback
-  auto x11_disp = std::make_shared<x11_attr_t>();
+  auto x11_disp = std::make_shared<x11_attr_t>(hwdevice_type);
   if(x11_disp->init()) {
     return nullptr;
   }
@@ -410,98 +399,10 @@ std::shared_ptr<display_t> display(platf::dev_type_e hwdevice_type) {
   return x11_disp;
 }
 
-std::unique_ptr<mic_t> microphone(std::uint32_t sample_rate) {
-  auto mic = std::make_unique<mic_attr_t>(PA_SAMPLE_S16LE, sample_rate, 2);
-
-  int status;
-
-  const char *audio_sink = "@DEFAULT_MONITOR@";
-  if (!config::audio.sink.empty()) {
-    audio_sink = config::audio.sink.c_str();
-  }
-
-  mic->mic.reset(
-    pa_simple_new(nullptr, "sunshine",
-   pa_stream_direction_t::PA_STREAM_RECORD, audio_sink,
-      "sunshine-record", &mic->ss, nullptr, nullptr, &status));
-
-  if (!mic->mic) {
-    auto err_str = pa_strerror(status);
-    BOOST_LOG(error) << "pa_simple_new() failed: "sv << err_str;
-
-    log_flush();
-    std::abort();
-  }
-
-  return mic;
-}
-
-ifaddr_t get_ifaddrs() {
-  ifaddrs *p { nullptr };
-
-  getifaddrs(&p);
-
-  return ifaddr_t { p };
-}
-
-std::string from_sockaddr(const sockaddr *const ip_addr) {
-  char data[INET6_ADDRSTRLEN];
-
-  auto family = ip_addr->sa_family;
-  if (family == AF_INET6) {
-    inet_ntop(AF_INET6, &((sockaddr_in6*) ip_addr)->sin6_addr, data,
-    INET6_ADDRSTRLEN);
-  }
-
-  if (family == AF_INET) {
-    inet_ntop(AF_INET, &((sockaddr_in*) ip_addr)->sin_addr, data,
-    INET_ADDRSTRLEN);
-  }
-
-  return std::string { data };
-}
-
-std::pair<std::uint16_t, std::string> from_sockaddr_ex(const sockaddr *const ip_addr) {
-  char data[INET6_ADDRSTRLEN];
-
-  auto family = ip_addr->sa_family;
-  std::uint16_t port;
-  if(family == AF_INET6) {
-    inet_ntop(AF_INET6, &((sockaddr_in6*)ip_addr)->sin6_addr, data,
-    INET6_ADDRSTRLEN);
-    port = ((sockaddr_in6*) ip_addr)->sin6_port;
-  }
-
-  if(family == AF_INET) {
-    inet_ntop(AF_INET, &((sockaddr_in*)ip_addr)->sin_addr, data,
-    INET_ADDRSTRLEN);
-    port = ((sockaddr_in*) ip_addr)->sin_port;
-  }
-
-  return { port, std::string {data} };
-}
-
-std::string get_mac_address(const std::string_view &address) {
-  auto ifaddrs = get_ifaddrs();
-  for (auto pos = ifaddrs.get(); pos != nullptr; pos = pos->ifa_next) {
-    if (pos->ifa_addr && address == from_sockaddr(pos->ifa_addr)) {
-      std::ifstream mac_file("/sys/class/net/"s + pos->ifa_name + "/address");
-      if (mac_file.good()) {
-        std::string mac_address;
-        std::getline(mac_file, mac_address);
-        return mac_address;
-      }
-    }
-  }
-
-  BOOST_LOG(warning) << "Unable to find MAC address for "sv << address;
-  return "00:00:00:00:00:00"s;
-}
-
 void freeImage(XImage *p) {
   XDestroyImage(p);
 }
 void freeX(XFixesCursorImage *p) {
   XFree(p);
 }
-}
+} // namespace platf

sunshine/platform/linux/input.cpp

@@ -1,5 +1,5 @@
-#include <libevdev/libevdev.h>
 #include <libevdev/libevdev-uinput.h>
+#include <libevdev/libevdev.h>
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
@@ -10,8 +10,8 @@
 #include <cstring>
 #include <filesystem>
 
-#include "sunshine/platform/common.h"
 #include "sunshine/main.h"
+#include "sunshine/platform/common.h"
 #include "sunshine/utility.h"
 
 // Support older versions
@@ -25,7 +25,7 @@
 
 namespace platf {
 using namespace std::literals;
-using evdev_t = util::safe_ptr<libevdev, libevdev_free>;
+using evdev_t  = util::safe_ptr<libevdev, libevdev_free>;
 using uinput_t = util::safe_ptr<libevdev_uinput, libevdev_uinput_destroy>;
 
 using keyboard_t = util::safe_ptr_v2<Display, int, XCloseDisplay>;
@@ -66,7 +66,7 @@ public:
       std::filesystem::remove(gamepad_path);
     }
 
-    gamepads[nr] = std::make_pair(uinput_t{}, gamepad_state_t {});
+    gamepads[nr] = std::make_pair(uinput_t {}, gamepad_state_t {});
   }
 
   int create_mouse() {
@@ -143,7 +143,7 @@ public:
 };
 
 void abs_mouse(input_t &input, const touch_port_t &touch_port, float x, float y) {
-  auto touchscreen = ((input_raw_t*)input.get())->touch_input.get();
+  auto touchscreen = ((input_raw_t *)input.get())->touch_input.get();
 
   auto scaled_x = (int)std::lround((x + touch_port.offset_x) * ((float)target_touch_port.width / (float)touch_port.width));
   auto scaled_y = (int)std::lround((y + touch_port.offset_y) * ((float)target_touch_port.height / (float)touch_port.height));
@@ -157,7 +157,7 @@ void abs_mouse(input_t &input, const touch_port_t &touch_port, float x, float y)
 }
 
 void move_mouse(input_t &input, int deltaX, int deltaY) {
-  auto mouse = ((input_raw_t*)input.get())->mouse_input.get();
+  auto mouse = ((input_raw_t *)input.get())->mouse_input.get();
 
   if(deltaX) {
     libevdev_uinput_write_event(mouse, EV_REL, REL_X, deltaX);
@@ -176,26 +176,26 @@ void button_mouse(input_t &input, int button, bool release) {
 
   if(button == 1) {
     btn_type = BTN_LEFT;
-    scan = 90001;
+    scan     = 90001;
   }
   else if(button == 2) {
     btn_type = BTN_MIDDLE;
-    scan = 90003;
+    scan     = 90003;
   }
   else if(button == 3) {
     btn_type = BTN_RIGHT;
-    scan = 90002;
+    scan     = 90002;
   }
   else if(button == 4) {
     btn_type = BTN_SIDE;
-    scan = 90004;
+    scan     = 90004;
   }
   else {
     btn_type = BTN_EXTRA;
-    scan = 90005;
+    scan     = 90005;
   }
 
-  auto mouse = ((input_raw_t*)input.get())->mouse_input.get();
+  auto mouse = ((input_raw_t *)input.get())->mouse_input.get();
   libevdev_uinput_write_event(mouse, EV_MSC, MSC_SCAN, scan);
   libevdev_uinput_write_event(mouse, EV_KEY, btn_type, release ? 0 : 1);
   libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
@@ -204,7 +204,7 @@ void button_mouse(input_t &input, int button, bool release) {
 void scroll(input_t &input, int high_res_distance) {
   int distance = high_res_distance / 120;
 
-  auto mouse = ((input_raw_t*)input.get())->mouse_input.get();
+  auto mouse = ((input_raw_t *)input.get())->mouse_input.get();
   libevdev_uinput_write_event(mouse, EV_REL, REL_WHEEL, distance);
   libevdev_uinput_write_event(mouse, EV_REL, REL_WHEEL_HI_RES, high_res_distance);
   libevdev_uinput_write_event(mouse, EV_SYN, SYN_REPORT, 0);
@@ -212,7 +212,7 @@ void scroll(input_t &input, int high_res_distance) {
 
 uint16_t keysym(uint16_t modcode) {
   constexpr auto VK_NUMPAD = 0x60;
-  constexpr auto VK_F1 = 0x70;
+  constexpr auto VK_F1     = 0x70;
 
   if(modcode >= VK_NUMPAD && modcode < VK_NUMPAD + 10) {
     return XK_KP_0 + (modcode - VK_NUMPAD);
@@ -224,108 +224,108 @@ uint16_t keysym(uint16_t modcode) {
 
 
   switch(modcode) {
-    case 0x08:
-      return XK_BackSpace;
-    case 0x09:
-      return XK_Tab;
-    case 0x0D:
-      return XK_Return;
-    case 0x13:
-      return XK_Pause;
-    case 0x14:
-      return XK_Caps_Lock;
-    case 0x1B:
-      return XK_Escape;
-    case 0x21:
-      return XK_Page_Up;
-    case 0x22:
-      return XK_Page_Down;
-    case 0x23:
-      return XK_End;
-    case 0x24:
-      return XK_Home;
-    case 0x25:
-      return XK_Left;
-    case 0x26:
-      return XK_Up;
-    case 0x27:
-      return XK_Right;
-    case 0x28:
-      return XK_Down;
-    case 0x29:
-      return XK_Select;
-    case 0x2B:
-      return XK_Execute;
-    case 0x2C:
-      return XK_Print;
-    case 0x2D:
-      return XK_Insert;
-    case 0x2E:
-      return XK_Delete;
-    case 0x2F:
-      return XK_Help;
-    case 0x6A:
-      return XK_KP_Multiply;
-    case 0x6B:
-      return XK_KP_Add;
-    case 0x6C:
-      return XK_KP_Separator;
-    case 0x6D:
-      return XK_KP_Subtract;
-    case 0x6E:
-      return XK_KP_Decimal;
-    case 0x6F:
-      return XK_KP_Divide;
-    case 0x90:
-      return XK_Num_Lock;
-    case 0x91:
-      return XK_Scroll_Lock;
-    case 0xA0:
-      return XK_Shift_L;
-    case 0xA1:
-      return XK_Shift_R;
-    case 0xA2:
-      return XK_Control_L;
-    case 0xA3:
-      return XK_Control_R;
-    case 0xA4:
-      return XK_Alt_L;
-    case 0xA5: /* return XK_Alt_R; */
-      return XK_Super_L;
-    case 0x5B:
-      return XK_Super_L;
-    case 0x5C:
-      return XK_Super_R;
-    case 0xBA:
-      return XK_semicolon;
-    case 0xBB:
-      return XK_equal;
-    case 0xBC:
-      return XK_comma;
-    case 0xBD:
-      return XK_minus;
-    case 0xBE:
-      return XK_period;
-    case 0xBF:
-      return XK_slash;
-    case 0xC0:
-      return XK_grave;
-    case 0xDB:
-      return XK_bracketleft;
-    case 0xDC:
-      return XK_backslash;
-    case 0xDD:
-      return XK_bracketright;
-    case 0xDE:
-      return XK_apostrophe;
+  case 0x08:
+    return XK_BackSpace;
+  case 0x09:
+    return XK_Tab;
+  case 0x0D:
+    return XK_Return;
+  case 0x13:
+    return XK_Pause;
+  case 0x14:
+    return XK_Caps_Lock;
+  case 0x1B:
+    return XK_Escape;
+  case 0x21:
+    return XK_Page_Up;
+  case 0x22:
+    return XK_Page_Down;
+  case 0x23:
+    return XK_End;
+  case 0x24:
+    return XK_Home;
+  case 0x25:
+    return XK_Left;
+  case 0x26:
+    return XK_Up;
+  case 0x27:
+    return XK_Right;
+  case 0x28:
+    return XK_Down;
+  case 0x29:
+    return XK_Select;
+  case 0x2B:
+    return XK_Execute;
+  case 0x2C:
+    return XK_Print;
+  case 0x2D:
+    return XK_Insert;
+  case 0x2E:
+    return XK_Delete;
+  case 0x2F:
+    return XK_Help;
+  case 0x6A:
+    return XK_KP_Multiply;
+  case 0x6B:
+    return XK_KP_Add;
+  case 0x6C:
+    return XK_KP_Separator;
+  case 0x6D:
+    return XK_KP_Subtract;
+  case 0x6E:
+    return XK_KP_Decimal;
+  case 0x6F:
+    return XK_KP_Divide;
+  case 0x90:
+    return XK_Num_Lock;
+  case 0x91:
+    return XK_Scroll_Lock;
+  case 0xA0:
+    return XK_Shift_L;
+  case 0xA1:
+    return XK_Shift_R;
+  case 0xA2:
+    return XK_Control_L;
+  case 0xA3:
+    return XK_Control_R;
+  case 0xA4:
+    return XK_Alt_L;
+  case 0xA5:
+    return XK_Alt_R;
+  case 0x5B:
+    return XK_Super_L;
+  case 0x5C:
+    return XK_Super_R;
+  case 0xBA:
+    return XK_semicolon;
+  case 0xBB:
+    return XK_equal;
+  case 0xBC:
+    return XK_comma;
+  case 0xBD:
+    return XK_minus;
+  case 0xBE:
+    return XK_period;
+  case 0xBF:
+    return XK_slash;
+  case 0xC0:
+    return XK_grave;
+  case 0xDB:
+    return XK_bracketleft;
+  case 0xDC:
+    return XK_backslash;
+  case 0xDD:
+    return XK_bracketright;
+  case 0xDE:
+    return XK_apostrophe;
   }
 
   return modcode;
 }
 
 void keyboard(input_t &input, uint16_t modcode, bool release) {
-  auto &keyboard = ((input_raw_t*)input.get())->keyboard;
-  KeyCode kc = XKeysymToKeycode(keyboard.get(), keysym(modcode));
+  auto &keyboard = ((input_raw_t *)input.get())->keyboard;
+  KeyCode kc     = XKeysymToKeycode(keyboard.get(), keysym(modcode));
 
   if(!kc) {
     return;
@@ -338,18 +338,18 @@ void keyboard(input_t &input, uint16_t modcode, bool release) {
 }
 
 int alloc_gamepad(input_t &input, int nr) {
-  return ((input_raw_t*)input.get())->alloc_gamepad(nr);
+  return ((input_raw_t *)input.get())->alloc_gamepad(nr);
 }
 
 void free_gamepad(input_t &input, int nr) {
-  ((input_raw_t*)input.get())->clear_gamepad(nr);
+  ((input_raw_t *)input.get())->clear_gamepad(nr);
 }
 
 void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state) {
-  TUPLE_2D_REF(uinput, gamepad_state_old, ((input_raw_t*)input.get())->gamepads[nr]);
+  TUPLE_2D_REF(uinput, gamepad_state_old, ((input_raw_t *)input.get())->gamepads[nr]);
 
 
-  auto bf = gamepad_state.buttonFlags ^ gamepad_state_old.buttonFlags;
+  auto bf     = gamepad_state.buttonFlags ^ gamepad_state_old.buttonFlags;
   auto bf_new = gamepad_state.buttonFlags;
 
   if(bf) {
@@ -366,17 +366,17 @@ void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state) {
       libevdev_uinput_write_event(uinput.get(), EV_ABS, ABS_HAT0X, button_state);
     }
 
-    if(START & bf)        libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_START,  bf_new & START        ? 1 : 0);
-    if(BACK & bf)         libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_SELECT, bf_new & BACK         ? 1 : 0);
-    if(LEFT_STICK & bf)   libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_THUMBL, bf_new & LEFT_STICK   ? 1 : 0);
-    if(RIGHT_STICK & bf)  libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_THUMBR, bf_new & RIGHT_STICK  ? 1 : 0);
-    if(LEFT_BUTTON & bf)  libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_TL,     bf_new & LEFT_BUTTON  ? 1 : 0);
-    if(RIGHT_BUTTON & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_TR,     bf_new & RIGHT_BUTTON ? 1 : 0);
-    if(HOME & bf)         libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_MODE,   bf_new & HOME         ? 1 : 0);
-    if(A & bf)            libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_SOUTH,  bf_new & A            ? 1 : 0);
-    if(B & bf)            libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_EAST,   bf_new & B            ? 1 : 0);
-    if(X & bf)            libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_NORTH,  bf_new & X            ? 1 : 0);
-    if(Y & bf)            libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_WEST,   bf_new & Y            ? 1 : 0);
+    if(START & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_START, bf_new & START ? 1 : 0);
+    if(BACK & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_SELECT, bf_new & BACK ? 1 : 0);
+    if(LEFT_STICK & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_THUMBL, bf_new & LEFT_STICK ? 1 : 0);
+    if(RIGHT_STICK & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_THUMBR, bf_new & RIGHT_STICK ? 1 : 0);
+    if(LEFT_BUTTON & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_TL, bf_new & LEFT_BUTTON ? 1 : 0);
+    if(RIGHT_BUTTON & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_TR, bf_new & RIGHT_BUTTON ? 1 : 0);
+    if(HOME & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_MODE, bf_new & HOME ? 1 : 0);
+    if(A & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_SOUTH, bf_new & A ? 1 : 0);
+    if(B & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_EAST, bf_new & B ? 1 : 0);
+    if(X & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_NORTH, bf_new & X ? 1 : 0);
+    if(Y & bf) libevdev_uinput_write_event(uinput.get(), EV_KEY, BTN_WEST, bf_new & Y ? 1 : 0);
   }
 
   if(gamepad_state_old.lt != gamepad_state.lt) {
@@ -408,7 +408,7 @@ void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state) {
 }
 
 evdev_t mouse() {
-  evdev_t dev  { libevdev_new() };
+  evdev_t dev { libevdev_new() };
 
   libevdev_set_uniq(dev.get(), "Sunshine Mouse");
   libevdev_set_id_product(dev.get(), 0x4038);
@@ -553,7 +553,7 @@ evdev_t x360() {
 
 input_t input() {
   input_t result { new input_raw_t() };
-  auto &gp = *(input_raw_t*)result.get();
+  auto &gp = *(input_raw_t *)result.get();
 
   gp.keyboard.reset(XOpenDisplay(nullptr));
 
@@ -568,8 +568,8 @@ input_t input() {
 
   // Ensure starting from clean slate
   gp.clear();
-  gp.touch_dev = touchscreen();
-  gp.mouse_dev = mouse();
+  gp.touch_dev   = touchscreen();
+  gp.mouse_dev   = mouse();
   gp.gamepad_dev = x360();
 
   if(gp.create_mouse() || gp.create_touchscreen()) {
@@ -581,9 +581,7 @@ input_t input() {
 }
 
 void freeInput(void *p) {
-  auto *input = (input_raw_t*)p;
+  auto *input = (input_raw_t *)p;
   delete input;
 }
-
-std::unique_ptr<deinit_t> init() { return std::make_unique<deinit_t>(); }
-}
+} // namespace platf

sunshine/platform/linux/misc.cpp

@@ -0,0 +1,138 @@
+#include <arpa/inet.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <ifaddrs.h>
+#include <pwd.h>
+#include <unistd.h>
+
+#include <fstream>
+
+#include "misc.h"
+#include "sunshine/main.h"
+#include "sunshine/platform/common.h"
+
+#ifdef __GNUC__
+#define SUNSHINE_GNUC_EXTENSION __extension__
+#else
+#define SUNSHINE_GNUC_EXTENSION
+#endif
+
+using namespace std::literals;
+namespace fs = std::filesystem;
+
+namespace platf {
+using ifaddr_t = util::safe_ptr<ifaddrs, freeifaddrs>;
+
+ifaddr_t get_ifaddrs() {
+  ifaddrs *p { nullptr };
+
+  getifaddrs(&p);
+
+  return ifaddr_t { p };
+}
+
+fs::path appdata() {
+  const char *homedir;
+  if((homedir = getenv("HOME")) == nullptr) {
+    homedir = getpwuid(geteuid())->pw_dir;
+  }
+
+  return fs::path { homedir } / ".config/sunshine"sv;
+}
+
+std::string from_sockaddr(const sockaddr *const ip_addr) {
+  char data[INET6_ADDRSTRLEN];
+
+  auto family = ip_addr->sa_family;
+  if(family == AF_INET6) {
+    inet_ntop(AF_INET6, &((sockaddr_in6 *)ip_addr)->sin6_addr, data,
+      INET6_ADDRSTRLEN);
+  }
+
+  if(family == AF_INET) {
+    inet_ntop(AF_INET, &((sockaddr_in *)ip_addr)->sin_addr, data,
+      INET_ADDRSTRLEN);
+  }
+
+  return std::string { data };
+}
+
+std::pair<std::uint16_t, std::string> from_sockaddr_ex(const sockaddr *const ip_addr) {
+  char data[INET6_ADDRSTRLEN];
+
+  auto family = ip_addr->sa_family;
+  std::uint16_t port;
+  if(family == AF_INET6) {
+    inet_ntop(AF_INET6, &((sockaddr_in6 *)ip_addr)->sin6_addr, data,
+      INET6_ADDRSTRLEN);
+    port = ((sockaddr_in6 *)ip_addr)->sin6_port;
+  }
+
+  if(family == AF_INET) {
+    inet_ntop(AF_INET, &((sockaddr_in *)ip_addr)->sin_addr, data,
+      INET_ADDRSTRLEN);
+    port = ((sockaddr_in *)ip_addr)->sin_port;
+  }
+
+  return { port, std::string { data } };
+}
+
+std::string get_mac_address(const std::string_view &address) {
+  auto ifaddrs = get_ifaddrs();
+  for(auto pos = ifaddrs.get(); pos != nullptr; pos = pos->ifa_next) {
+    if(pos->ifa_addr && address == from_sockaddr(pos->ifa_addr)) {
+      std::ifstream mac_file("/sys/class/net/"s + pos->ifa_name + "/address");
+      if(mac_file.good()) {
+        std::string mac_address;
+        std::getline(mac_file, mac_address);
+        return mac_address;
+      }
+    }
+  }
+
+  BOOST_LOG(warning) << "Unable to find MAC address for "sv << address;
+  return "00:00:00:00:00:00"s;
+}
+} // namespace platf
+
+namespace dyn {
+void *handle(const std::vector<const char *> &libs) {
+  void *handle;
+
+  for(auto lib : libs) {
+    handle = dlopen(lib, RTLD_LAZY | RTLD_LOCAL);
+    if(handle) {
+      return handle;
+    }
+  }
+
+  std::stringstream ss;
+  ss << "Couldn't find any of the following libraries: ["sv << libs.front();
+  std::for_each(std::begin(libs) + 1, std::end(libs), [&](auto lib) {
+    ss << ", "sv << lib;
+  });
+
+  ss << ']';
+
+  BOOST_LOG(error) << ss.str();
+
+  return nullptr;
+}
+
+int load(void *handle, const std::vector<std::tuple<apiproc *, const char *>> &funcs, bool strict) {
+  int err = 0;
+  for(auto &func : funcs) {
+    TUPLE_2D_REF(fn, name, func);
+
+    *fn = SUNSHINE_GNUC_EXTENSION(apiproc) dlsym(handle, name);
+
+    if(!*fn && strict) {
+      BOOST_LOG(error) << "Couldn't find function: "sv << name;
+
+      err = -1;
+    }
+  }
+
+  return err;
+}
+} // namespace dyn

sunshine/platform/linux/misc.h

@@ -0,0 +1,14 @@
+#ifndef SUNSHINE_PLATFORM_MISC_H
+#define SUNSHINE_PLATFORM_MISC_H
+
+#include <vector>
+
+namespace dyn {
+typedef void (*apiproc)(void);
+
+int load(void *handle, const std::vector<std::tuple<apiproc *, const char *>> &funcs, bool strict = true);
+void *handle(const std::vector<const char *> &libs);
+
+} // namespace dyn
+
+#endif

sunshine/platform/linux/publish.cpp

@@ -0,0 +1,429 @@
+
+// adapted from https://www.avahi.org/doxygen/html/client-publish-service_8c-example.html
+#include <thread>
+
+#include "misc.h"
+#include "sunshine/main.h"
+#include "sunshine/nvhttp.h"
+#include "sunshine/platform/common.h"
+#include "sunshine/utility.h"
+
+using namespace std::literals;
+
+namespace avahi {
+
+/** Error codes used by avahi */
+enum err_e {
+  OK                      = 0,  /**< OK */
+  ERR_FAILURE             = -1, /**< Generic error code */
+  ERR_BAD_STATE           = -2, /**< Object was in a bad state */
+  ERR_INVALID_HOST_NAME   = -3, /**< Invalid host name */
+  ERR_INVALID_DOMAIN_NAME = -4, /**< Invalid domain name */
+  ERR_NO_NETWORK          = -5, /**< No suitable network protocol available */
+  ERR_INVALID_TTL         = -6, /**< Invalid DNS TTL */
+  ERR_IS_PATTERN          = -7, /**< RR key is pattern */
+  ERR_COLLISION           = -8, /**< Name collision */
+  ERR_INVALID_RECORD      = -9, /**< Invalid RR */
+
+  ERR_INVALID_SERVICE_NAME = -10, /**< Invalid service name */
+  ERR_INVALID_SERVICE_TYPE = -11, /**< Invalid service type */
+  ERR_INVALID_PORT         = -12, /**< Invalid port number */
+  ERR_INVALID_KEY          = -13, /**< Invalid key */
+  ERR_INVALID_ADDRESS      = -14, /**< Invalid address */
+  ERR_TIMEOUT              = -15, /**< Timeout reached */
+  ERR_TOO_MANY_CLIENTS     = -16, /**< Too many clients */
+  ERR_TOO_MANY_OBJECTS     = -17, /**< Too many objects */
+  ERR_TOO_MANY_ENTRIES     = -18, /**< Too many entries */
+  ERR_OS                   = -19, /**< OS error */
+
+  ERR_ACCESS_DENIED     = -20, /**< Access denied */
+  ERR_INVALID_OPERATION = -21, /**< Invalid operation */
+  ERR_DBUS_ERROR        = -22, /**< An unexpected D-Bus error occurred */
+  ERR_DISCONNECTED      = -23, /**< Daemon connection failed */
+  ERR_NO_MEMORY         = -24, /**< Memory exhausted */
+  ERR_INVALID_OBJECT    = -25, /**< The object passed to this function was invalid */
+  ERR_NO_DAEMON         = -26, /**< Daemon not running */
+  ERR_INVALID_INTERFACE = -27, /**< Invalid interface */
+  ERR_INVALID_PROTOCOL  = -28, /**< Invalid protocol */
+  ERR_INVALID_FLAGS     = -29, /**< Invalid flags */
+
+  ERR_NOT_FOUND               = -30, /**< Not found */
+  ERR_INVALID_CONFIG          = -31, /**< Configuration error */
+  ERR_VERSION_MISMATCH        = -32, /**< Verson mismatch */
+  ERR_INVALID_SERVICE_SUBTYPE = -33, /**< Invalid service subtype */
+  ERR_INVALID_PACKET          = -34, /**< Invalid packet */
+  ERR_INVALID_DNS_ERROR       = -35, /**< Invlaid DNS return code */
+  ERR_DNS_FORMERR             = -36, /**< DNS Error: Form error */
+  ERR_DNS_SERVFAIL            = -37, /**< DNS Error: Server Failure */
+  ERR_DNS_NXDOMAIN            = -38, /**< DNS Error: No such domain */
+  ERR_DNS_NOTIMP              = -39, /**< DNS Error: Not implemented */
+
+  ERR_DNS_REFUSED       = -40, /**< DNS Error: Operation refused */
+  ERR_DNS_YXDOMAIN      = -41,
+  ERR_DNS_YXRRSET       = -42,
+  ERR_DNS_NXRRSET       = -43,
+  ERR_DNS_NOTAUTH       = -44, /**< DNS Error: Not authorized */
+  ERR_DNS_NOTZONE       = -45,
+  ERR_INVALID_RDATA     = -46, /**< Invalid RDATA */
+  ERR_INVALID_DNS_CLASS = -47, /**< Invalid DNS class */
+  ERR_INVALID_DNS_TYPE  = -48, /**< Invalid DNS type */
+  ERR_NOT_SUPPORTED     = -49, /**< Not supported */
+
+  ERR_NOT_PERMITTED    = -50, /**< Operation not permitted */
+  ERR_INVALID_ARGUMENT = -51, /**< Invalid argument */
+  ERR_IS_EMPTY         = -52, /**< Is empty */
+  ERR_NO_CHANGE        = -53, /**< The requested operation is invalid because it is redundant */
+
+  ERR_MAX = -54
+};
+
+constexpr auto IF_UNSPEC = -1;
+enum proto {
+  PROTO_INET   = 0, /**< IPv4 */
+  PROTO_INET6  = 1, /**< IPv6 */
+  PROTO_UNSPEC = -1 /**< Unspecified/all protocol(s) */
+};
+
+enum ServerState {
+  SERVER_INVALID,     /**< Invalid state (initial) */
+  SERVER_REGISTERING, /**< Host RRs are being registered */
+  SERVER_RUNNING,     /**< All host RRs have been established */
+  SERVER_COLLISION,   /**< There is a collision with a host RR. All host RRs have been withdrawn, the user should set a new host name via avahi_server_set_host_name() */
+  SERVER_FAILURE      /**< Some fatal failure happened, the server is unable to proceed */
+};
+
+enum ClientState {
+  CLIENT_S_REGISTERING = SERVER_REGISTERING, /**< Server state: REGISTERING */
+  CLIENT_S_RUNNING     = SERVER_RUNNING,     /**< Server state: RUNNING */
+  CLIENT_S_COLLISION   = SERVER_COLLISION,   /**< Server state: COLLISION */
+  CLIENT_FAILURE       = 100,                /**< Some kind of error happened on the client side */
+  CLIENT_CONNECTING    = 101                 /**< We're still connecting. This state is only entered when AVAHI_CLIENT_NO_FAIL has been passed to avahi_client_new() and the daemon is not yet available. */
+};
+
+enum EntryGroupState {
+  ENTRY_GROUP_UNCOMMITED,  /**< The group has not yet been commited, the user must still call avahi_entry_group_commit() */
+  ENTRY_GROUP_REGISTERING, /**< The entries of the group are currently being registered */
+  ENTRY_GROUP_ESTABLISHED, /**< The entries have successfully been established */
+  ENTRY_GROUP_COLLISION,   /**< A name collision for one of the entries in the group has been detected, the entries have been withdrawn */
+  ENTRY_GROUP_FAILURE      /**< Some kind of failure happened, the entries have been withdrawn */
+};
+
+enum ClientFlags {
+  CLIENT_IGNORE_USER_CONFIG = 1, /**< Don't read user configuration */
+  CLIENT_NO_FAIL            = 2  /**< Don't fail if the daemon is not available when avahi_client_new() is called, instead enter CLIENT_CONNECTING state and wait for the daemon to appear */
+};
+
+/** Some flags for publishing functions */
+enum PublishFlags {
+  PUBLISH_UNIQUE         = 1,  /**< For raw records: The RRset is intended to be unique */
+  PUBLISH_NO_PROBE       = 2,  /**< For raw records: Though the RRset is intended to be unique no probes shall be sent */
+  PUBLISH_NO_ANNOUNCE    = 4,  /**< For raw records: Do not announce this RR to other hosts */
+  PUBLISH_ALLOW_MULTIPLE = 8,  /**< For raw records: Allow multiple local records of this type, even if they are intended to be unique */
+                               /** \cond fulldocs */
+  PUBLISH_NO_REVERSE = 16,     /**< For address records: don't create a reverse (PTR) entry */
+  PUBLISH_NO_COOKIE  = 32,     /**< For service records: do not implicitly add the local service cookie to TXT data */
+                               /** \endcond */
+  PUBLISH_UPDATE = 64,         /**< Update existing records instead of adding new ones */
+                               /** \cond fulldocs */
+  PUBLISH_USE_WIDE_AREA = 128, /**< Register the record using wide area DNS (i.e. unicast DNS update) */
+  PUBLISH_USE_MULTICAST = 256  /**< Register the record using multicast DNS */
+  /** \endcond */
+};
+
+using IfIndex  = int;
+using Protocol = int;
+
+struct EntryGroup;
+struct Poll;
+struct SimplePoll;
+struct Client;
+
+typedef void (*ClientCallback)(Client *, ClientState, void *userdata);
+typedef void (*EntryGroupCallback)(EntryGroup *g, EntryGroupState state, void *userdata);
+
+typedef void (*free_fn)(void *);
+
+typedef Client *(*client_new_fn)(const Poll *poll_api, ClientFlags flags, ClientCallback callback, void *userdata, int *error);
+typedef void (*client_free_fn)(Client *);
+typedef char *(*alternative_service_name_fn)(char *);
+
+typedef Client *(*entry_group_get_client_fn)(EntryGroup *);
+
+typedef EntryGroup *(*entry_group_new_fn)(Client *, EntryGroupCallback, void *userdata);
+typedef int (*entry_group_add_service_fn)(
+  EntryGroup *group,
+  IfIndex interface,
+  Protocol protocol,
+  PublishFlags flags,
+  const char *name,
+  const char *type,
+  const char *domain,
+  const char *host,
+  uint16_t port,
+  ...);
+
+typedef int (*entry_group_is_empty_fn)(EntryGroup *);
+typedef int (*entry_group_reset_fn)(EntryGroup *);
+typedef int (*entry_group_commit_fn)(EntryGroup *);
+
+typedef char *(*strdup_fn)(const char *);
+typedef char *(*strerror_fn)(int);
+typedef int (*client_errno_fn)(Client *);
+
+typedef Poll *(*simple_poll_get_fn)(SimplePoll *);
+typedef int (*simple_poll_loop_fn)(SimplePoll *);
+typedef void (*simple_poll_quit_fn)(SimplePoll *);
+typedef SimplePoll *(*simple_poll_new_fn)();
+typedef void (*simple_poll_free_fn)(SimplePoll *);
+
+free_fn free;
+client_new_fn client_new;
+client_free_fn client_free;
+alternative_service_name_fn alternative_service_name;
+entry_group_get_client_fn entry_group_get_client;
+entry_group_new_fn entry_group_new;
+entry_group_add_service_fn entry_group_add_service;
+entry_group_is_empty_fn entry_group_is_empty;
+entry_group_reset_fn entry_group_reset;
+entry_group_commit_fn entry_group_commit;
+strdup_fn strdup;
+strerror_fn strerror;
+client_errno_fn client_errno;
+simple_poll_get_fn simple_poll_get;
+simple_poll_loop_fn simple_poll_loop;
+simple_poll_quit_fn simple_poll_quit;
+simple_poll_new_fn simple_poll_new;
+simple_poll_free_fn simple_poll_free;
+
+
+int init_common() {
+  static void *handle { nullptr };
+  static bool funcs_loaded = false;
+
+  if(funcs_loaded) return 0;
+
+  if(!handle) {
+    handle = dyn::handle({ "libavahi-common.so.3", "libavahi-common.so" });
+    if(!handle) {
+      return -1;
+    }
+  }
+
+  std::vector<std::tuple<dyn::apiproc *, const char *>> funcs {
+    { (dyn::apiproc *)&alternative_service_name, "avahi_alternative_service_name" },
+    { (dyn::apiproc *)&free, "avahi_free" },
+    { (dyn::apiproc *)&strdup, "avahi_strdup" },
+    { (dyn::apiproc *)&strerror, "avahi_strerror" },
+    { (dyn::apiproc *)&simple_poll_get, "avahi_simple_poll_get" },
+    { (dyn::apiproc *)&simple_poll_loop, "avahi_simple_poll_loop" },
+    { (dyn::apiproc *)&simple_poll_quit, "avahi_simple_poll_quit" },
+    { (dyn::apiproc *)&simple_poll_new, "avahi_simple_poll_new" },
+    { (dyn::apiproc *)&simple_poll_free, "avahi_simple_poll_free" },
+  };
+
+  if(dyn::load(handle, funcs)) {
+    return -1;
+  }
+
+  funcs_loaded = true;
+  return 0;
+}
+
+int init_client() {
+  if(init_common()) {
+    return -1;
+  }
+
+  static void *handle { nullptr };
+  static bool funcs_loaded = false;
+
+  if(funcs_loaded) return 0;
+
+  if(!handle) {
+    handle = dyn::handle({ "libavahi-client.so.3", "libavahi-client.so" });
+    if(!handle) {
+      return -1;
+    }
+  }
+
+  std::vector<std::tuple<dyn::apiproc *, const char *>> funcs {
+    { (dyn::apiproc *)&client_new, "avahi_client_new" },
+    { (dyn::apiproc *)&client_free, "avahi_client_free" },
+    { (dyn::apiproc *)&entry_group_get_client, "avahi_entry_group_get_client" },
+    { (dyn::apiproc *)&entry_group_new, "avahi_entry_group_new" },
+    { (dyn::apiproc *)&entry_group_add_service, "avahi_entry_group_add_service" },
+    { (dyn::apiproc *)&entry_group_is_empty, "avahi_entry_group_is_empty" },
+    { (dyn::apiproc *)&entry_group_reset, "avahi_entry_group_reset" },
+    { (dyn::apiproc *)&entry_group_commit, "avahi_entry_group_commit" },
+    { (dyn::apiproc *)&client_errno, "avahi_client_errno" },
+  };
+
+  if(dyn::load(handle, funcs)) {
+    return -1;
+  }
+
+  funcs_loaded = true;
+  return 0;
+}
+} // namespace avahi
+
+namespace platf::publish {
+
+template<class T>
+void free(T *p) {
+  avahi::free(p);
+}
+
+template<class T>
+using ptr_t    = util::safe_ptr<T, free<T>>;
+using client_t = util::dyn_safe_ptr<avahi::Client, &avahi::client_free>;
+using poll_t   = util::dyn_safe_ptr<avahi::SimplePoll, &avahi::simple_poll_free>;
+
+avahi::EntryGroup *group = nullptr;
+
+poll_t poll;
+client_t client;
+
+ptr_t<char> name;
+
+void create_services(avahi::Client *c);
+
+void entry_group_callback(avahi::EntryGroup *g, avahi::EntryGroupState state, void *) {
+  group = g;
+
+  switch(state) {
+  case avahi::ENTRY_GROUP_ESTABLISHED:
+    BOOST_LOG(info) << "Avahi service " << name.get() << " successfully established.";
+    break;
+  case avahi::ENTRY_GROUP_COLLISION:
+    name.reset(avahi::alternative_service_name(name.get()));
+
+    BOOST_LOG(info) << "Avahi service name collision, renaming service to " << name.get();
+
+    create_services(avahi::entry_group_get_client(g));
+    break;
+  case avahi::ENTRY_GROUP_FAILURE:
+    BOOST_LOG(error) << "Avahi entry group failure: " << avahi::strerror(avahi::client_errno(avahi::entry_group_get_client(g)));
+    avahi::simple_poll_quit(poll.get());
+    break;
+  case avahi::ENTRY_GROUP_UNCOMMITED:
+  case avahi::ENTRY_GROUP_REGISTERING:;
+  }
+}
+
+void create_services(avahi::Client *c) {
+  int ret;
+
+  auto fg = util::fail_guard([]() {
+    avahi::simple_poll_quit(poll.get());
+  });
+
+  if(!group) {
+    if(!(group = avahi::entry_group_new(c, entry_group_callback, nullptr))) {
+      BOOST_LOG(error) << "avahi::entry_group_new() failed: "sv << avahi::strerror(avahi::client_errno(c));
+      return;
+    }
+  }
+
+  if(avahi::entry_group_is_empty(group)) {
+    BOOST_LOG(info) << "Adding avahi service "sv << name.get();
+
+    ret = avahi::entry_group_add_service(
+      group,
+      avahi::IF_UNSPEC, avahi::PROTO_UNSPEC,
+      avahi::PublishFlags(0),
+      name.get(),
+      SERVICE_TYPE,
+      nullptr, nullptr,
+      map_port(nvhttp::PORT_HTTP),
+      nullptr);
+
+    if(ret < 0) {
+      if(ret == avahi::ERR_COLLISION) {
+        // A service name collision with a local service happened. Let's pick a new name
+        name.reset(avahi::alternative_service_name(name.get()));
+        BOOST_LOG(info) << "Service name collision, renaming service to "sv << name.get();
+
+        avahi::entry_group_reset(group);
+
+        create_services(c);
+
+        fg.disable();
+        return;
+      }
+
+      BOOST_LOG(error) << "Failed to add "sv << SERVICE_TYPE << " service: "sv << avahi::strerror(ret);
+      return;
+    }
+
+    ret = avahi::entry_group_commit(group);
+    if(ret < 0) {
+      BOOST_LOG(error) << "Failed to commit entry group: "sv << avahi::strerror(ret);
+      return;
+    }
+  }
+
+  fg.disable();
+}
+
+void client_callback(avahi::Client *c, avahi::ClientState state, void *) {
+  switch(state) {
+  case avahi::CLIENT_S_RUNNING:
+    create_services(c);
+    break;
+  case avahi::CLIENT_FAILURE:
+    BOOST_LOG(error) << "Client failure: "sv << avahi::strerror(avahi::client_errno(c));
+    avahi::simple_poll_quit(poll.get());
+    break;
+  case avahi::CLIENT_S_COLLISION:
+  case avahi::CLIENT_S_REGISTERING:
+    if(group)
+      avahi::entry_group_reset(group);
+    break;
+  case avahi::CLIENT_CONNECTING:;
+  }
+}
+
+class deinit_t : public ::platf::deinit_t {
+public:
+  std::thread poll_thread;
+
+  deinit_t(std::thread poll_thread) : poll_thread { std::move(poll_thread) } {}
+
+  ~deinit_t() override {
+    if(avahi::simple_poll_quit && poll) {
+      avahi::simple_poll_quit(poll.get());
+    }
+
+    if(poll_thread.joinable()) {
+      poll_thread.join();
+    }
+  }
+};
+
+[[nodiscard]] std::unique_ptr<::platf::deinit_t> start() {
+  if(avahi::init_client()) {
+    return nullptr;
+  }
+
+  int avhi_error;
+
+  poll.reset(avahi::simple_poll_new());
+  if(!poll) {
+    BOOST_LOG(error) << "Failed to create simple poll object."sv;
+    return nullptr;
+  }
+
+  name.reset(avahi::strdup(SERVICE_NAME));
+
+  client.reset(
+    avahi::client_new(avahi::simple_poll_get(poll.get()), avahi::ClientFlags(0), client_callback, nullptr, &avhi_error));
+
+  if(!client) {
+    BOOST_LOG(error) << "Failed to create client: "sv << avahi::strerror(avhi_error);
+    return nullptr;
+  }
+
+  return std::make_unique<deinit_t>(std::thread { avahi::simple_poll_loop, poll.get() });
+}
+}; // namespace platf::publish

sunshine/platform/linux/vaapi.h

@@ -0,0 +1,8 @@
+#ifndef SUNSHINE_DISPLAY_H
+#define SUNSHINE_DISPLAY_H
+
+#include "sunshine/platform/common.h"
+namespace platf::egl {
+std::shared_ptr<hwdevice_t> make_hwdevice(int width, int height);
+} // namespace platf::egl
+#endif

sunshine/platform/windows/PolicyConfig.h

@@ -0,0 +1,164 @@
+// ----------------------------------------------------------------------------
+// PolicyConfig.h
+// Undocumented COM-interface IPolicyConfig.
+// Use for set default audio render endpoint
+// @author EreTIk
+// http://eretik.omegahg.com/
+// ----------------------------------------------------------------------------
+
+
+#pragma once
+
+#ifdef __MINGW32__
+#undef DEFINE_GUID
+#ifdef __cplusplus
+#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) EXTERN_C const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#endif
+
+DEFINE_GUID(IID_IPolicyConfig, 0xf8679f50, 0x850a, 0x41cf, 0x9c, 0x72, 0x43, 0x0f, 0x29, 0x02, 0x90, 0xc8);
+DEFINE_GUID(CLSID_CPolicyConfigClient, 0x870af99c, 0x171d, 0x4f9e, 0xaf, 0x0d, 0xe6, 0x3d, 0xf4, 0x0c, 0x2b, 0xc9);
+
+#endif
+
+interface DECLSPEC_UUID("f8679f50-850a-41cf-9c72-430f290290c8") IPolicyConfig;
+class DECLSPEC_UUID("870af99c-171d-4f9e-af0d-e63df40c2bc9") CPolicyConfigClient;
+// ----------------------------------------------------------------------------
+// class CPolicyConfigClient
+// {870af99c-171d-4f9e-af0d-e63df40c2bc9}
+//
+// interface IPolicyConfig
+// {f8679f50-850a-41cf-9c72-430f290290c8}
+//
+// Query interface:
+// CComPtr<IPolicyConfig> PolicyConfig;
+// PolicyConfig.CoCreateInstance(__uuidof(CPolicyConfigClient));
+//
+// @compatible: Windows 7 and Later
+// ----------------------------------------------------------------------------
+interface IPolicyConfig : public IUnknown {
+public:
+  virtual HRESULT GetMixFormat(
+    PCWSTR,
+    WAVEFORMATEX **);
+
+  virtual HRESULT STDMETHODCALLTYPE GetDeviceFormat(
+    PCWSTR,
+    INT,
+    WAVEFORMATEX **);
+
+  virtual HRESULT STDMETHODCALLTYPE ResetDeviceFormat(
+    PCWSTR);
+
+  virtual HRESULT STDMETHODCALLTYPE SetDeviceFormat(
+    PCWSTR,
+    WAVEFORMATEX *,
+    WAVEFORMATEX *);
+
+  virtual HRESULT STDMETHODCALLTYPE GetProcessingPeriod(
+    PCWSTR,
+    INT,
+    PINT64,
+    PINT64);
+
+  virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod(
+    PCWSTR,
+    PINT64);
+
+  virtual HRESULT STDMETHODCALLTYPE GetShareMode(
+    PCWSTR,
+    struct DeviceShareMode *);
+
+  virtual HRESULT STDMETHODCALLTYPE SetShareMode(
+    PCWSTR,
+    struct DeviceShareMode *);
+
+  virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(
+    PCWSTR,
+    const PROPERTYKEY &,
+    PROPVARIANT *);
+
+  virtual HRESULT STDMETHODCALLTYPE SetPropertyValue(
+    PCWSTR,
+    const PROPERTYKEY &,
+    PROPVARIANT *);
+
+  virtual HRESULT STDMETHODCALLTYPE SetDefaultEndpoint(
+    PCWSTR wszDeviceId,
+    ERole eRole);
+
+  virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility(
+    PCWSTR,
+    INT);
+};
+
+interface DECLSPEC_UUID("568b9108-44bf-40b4-9006-86afe5b5a620") IPolicyConfigVista;
+class DECLSPEC_UUID("294935CE-F637-4E7C-A41B-AB255460B862") CPolicyConfigVistaClient;
+// ----------------------------------------------------------------------------
+// class CPolicyConfigVistaClient
+// {294935CE-F637-4E7C-A41B-AB255460B862}
+//
+// interface IPolicyConfigVista
+// {568b9108-44bf-40b4-9006-86afe5b5a620}
+//
+// Query interface:
+// CComPtr<IPolicyConfigVista> PolicyConfig;
+// PolicyConfig.CoCreateInstance(__uuidof(CPolicyConfigVistaClient));
+//
+// @compatible: Windows Vista and Later
+// ----------------------------------------------------------------------------
+interface IPolicyConfigVista : public IUnknown {
+public:
+  virtual HRESULT GetMixFormat(
+    PCWSTR,
+    WAVEFORMATEX **); // not available on Windows 7, use method from IPolicyConfig
+
+  virtual HRESULT STDMETHODCALLTYPE GetDeviceFormat(
+    PCWSTR,
+    INT,
+    WAVEFORMATEX **);
+
+  virtual HRESULT STDMETHODCALLTYPE SetDeviceFormat(
+    PCWSTR,
+    WAVEFORMATEX *,
+    WAVEFORMATEX *);
+
+  virtual HRESULT STDMETHODCALLTYPE GetProcessingPeriod(
+    PCWSTR,
+    INT,
+    PINT64,
+    PINT64); // not available on Windows 7, use method from IPolicyConfig
+
+  virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod(
+    PCWSTR,
+    PINT64); // not available on Windows 7, use method from IPolicyConfig
+
+  virtual HRESULT STDMETHODCALLTYPE GetShareMode(
+    PCWSTR,
+    struct DeviceShareMode *); // not available on Windows 7, use method from IPolicyConfig
+
+  virtual HRESULT STDMETHODCALLTYPE SetShareMode(
+    PCWSTR,
+    struct DeviceShareMode *); // not available on Windows 7, use method from IPolicyConfig
+
+  virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(
+    PCWSTR,
+    const PROPERTYKEY &,
+    PROPVARIANT *);
+
+  virtual HRESULT STDMETHODCALLTYPE SetPropertyValue(
+    PCWSTR,
+    const PROPERTYKEY &,
+    PROPVARIANT *);
+
+  virtual HRESULT STDMETHODCALLTYPE SetDefaultEndpoint(
+    PCWSTR wszDeviceId,
+    ERole eRole);
+
+  virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility(
+    PCWSTR,
+    INT); // not available on Windows 7, use method from IPolicyConfig
+};
+
+// ----------------------------------------------------------------------------

sunshine/platform/windows/display.h

@@ -5,14 +5,14 @@
 #ifndef SUNSHINE_DISPLAY_H
 #define SUNSHINE_DISPLAY_H
 
-#include <dxgi.h>
 #include <d3d11.h>
 #include <d3d11_4.h>
 #include <d3dcommon.h>
+#include <dxgi.h>
 #include <dxgi1_2.h>
 
-#include "sunshine/utility.h"
 #include "sunshine/platform/common.h"
+#include "sunshine/utility.h"
 
 namespace platf::dxgi {
 extern const char *format_str[];
@@ -43,7 +43,7 @@ using processor_t      = util::safe_ptr<ID3D11VideoProcessor, Release<ID3D11Vide
 using processor_out_t  = util::safe_ptr<ID3D11VideoProcessorOutputView, Release<ID3D11VideoProcessorOutputView>>;
 using processor_in_t   = util::safe_ptr<ID3D11VideoProcessorInputView, Release<ID3D11VideoProcessorInputView>>;
 using processor_enum_t = util::safe_ptr<ID3D11VideoProcessorEnumerator, Release<ID3D11VideoProcessorEnumerator>>;
-}
+} // namespace video
 
 class hwdevice_t;
 struct cursor_t {
@@ -86,16 +86,14 @@ public:
   DXGI_FORMAT format;
   D3D_FEATURE_LEVEL feature_level;
 
-  typedef enum _D3DKMT_SCHEDULINGPRIORITYCLASS
-  {
+  typedef enum _D3DKMT_SCHEDULINGPRIORITYCLASS {
     D3DKMT_SCHEDULINGPRIORITYCLASS_IDLE,
     D3DKMT_SCHEDULINGPRIORITYCLASS_BELOW_NORMAL,
     D3DKMT_SCHEDULINGPRIORITYCLASS_NORMAL,
     D3DKMT_SCHEDULINGPRIORITYCLASS_ABOVE_NORMAL,
     D3DKMT_SCHEDULINGPRIORITYCLASS_HIGH,
     D3DKMT_SCHEDULINGPRIORITYCLASS_REALTIME
-  }
-  D3DKMT_SCHEDULINGPRIORITYCLASS;
+  } D3DKMT_SCHEDULINGPRIORITYCLASS;
 
   typedef NTSTATUS WINAPI (*PD3DKMTSetProcessSchedulingPriorityClass)(HANDLE, D3DKMT_SCHEDULINGPRIORITYCLASS);
 };
@@ -120,11 +118,11 @@ public:
   std::shared_ptr<img_t> alloc_img() override;
   int dummy_img(img_t *img_base) override;
 
-  std::shared_ptr<platf::hwdevice_t> make_hwdevice(int width, int height, pix_fmt_e pix_fmt) override;
+  std::shared_ptr<platf::hwdevice_t> make_hwdevice(pix_fmt_e pix_fmt) override;
 
   gpu_cursor_t cursor;
-  std::vector<hwdevice_t*> hwdevices;
+  std::vector<hwdevice_t *> hwdevices;
 };
-}
+} // namespace platf::dxgi
 
 #endif

sunshine/platform/windows/display_base.cpp

@@ -4,12 +4,12 @@
 
 #include <codecvt>
 
+#include "display.h"
+#include "misc.h"
 #include "sunshine/config.h"
 #include "sunshine/main.h"
 #include "sunshine/platform/common.h"
 
-#include "display.h"
-
 namespace platf {
 using namespace std::literals;
 }
@@ -23,18 +23,18 @@ capture_e duplication_t::next_frame(DXGI_OUTDUPL_FRAME_INFO &frame_info, std::ch
   auto status = dup->AcquireNextFrame(timeout.count(), &frame_info, res_p);
 
   switch(status) {
-    case S_OK:
-      has_frame = true;
-      return capture_e::ok;
-    case DXGI_ERROR_WAIT_TIMEOUT:
-      return capture_e::timeout;
-    case WAIT_ABANDONED:
-    case DXGI_ERROR_ACCESS_LOST:
-    case DXGI_ERROR_ACCESS_DENIED:
-      return capture_e::reinit;
-    default:
-      BOOST_LOG(error) << "Couldn't acquire next frame [0x"sv << util::hex(status).to_string_view();
-      return capture_e::error;
+  case S_OK:
+    has_frame = true;
+    return capture_e::ok;
+  case DXGI_ERROR_WAIT_TIMEOUT:
+    return capture_e::timeout;
+  case WAIT_ABANDONED:
+  case DXGI_ERROR_ACCESS_LOST:
+  case DXGI_ERROR_ACCESS_DENIED:
+    return capture_e::reinit;
+  default:
+    BOOST_LOG(error) << "Couldn't acquire next frame [0x"sv << util::hex(status).to_string_view();
+    return capture_e::error;
   }
 }
 
@@ -52,20 +52,20 @@ capture_e duplication_t::release_frame() {
   }
 
   auto status = dup->ReleaseFrame();
-  switch (status) {
-    case S_OK:
-      has_frame = false;
-      return capture_e::ok;
-    case DXGI_ERROR_WAIT_TIMEOUT:
-      return capture_e::timeout;
-    case WAIT_ABANDONED:
-    case DXGI_ERROR_ACCESS_LOST:
-    case DXGI_ERROR_ACCESS_DENIED:
-      has_frame = false;
-      return capture_e::reinit;
-    default:
-      BOOST_LOG(error) << "Couldn't release frame [0x"sv << util::hex(status).to_string_view();
-      return capture_e::error;
+  switch(status) {
+  case S_OK:
+    has_frame = false;
+    return capture_e::ok;
+  case DXGI_ERROR_WAIT_TIMEOUT:
+    return capture_e::timeout;
+  case WAIT_ABANDONED:
+  case DXGI_ERROR_ACCESS_LOST:
+  case DXGI_ERROR_ACCESS_DENIED:
+    has_frame = false;
+    return capture_e::reinit;
+  default:
+    BOOST_LOG(error) << "Couldn't release frame [0x"sv << util::hex(status).to_string_view();
+    return capture_e::error;
   }
 }
 
@@ -74,7 +74,7 @@ duplication_t::~duplication_t() {
 }
 
 int display_base_t::init() {
-/* Uncomment when use of IDXGIOutput5 is implemented
+  /* Uncomment when use of IDXGIOutput5 is implemented
   std::call_once(windows_cpp_once_flag, []() {
     DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
     const auto DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = ((DPI_AWARENESS_CONTEXT)-4);
@@ -91,9 +91,16 @@ int display_base_t::init() {
   });
 */
 
+  // Ensure we can duplicate the current display
+  syncThreadDesktop();
+
+  // Get rectangle of full desktop for absolute mouse coordinates
+  env_width  = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+  env_height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+
   HRESULT status;
 
-  status = CreateDXGIFactory1(IID_IDXGIFactory1, (void**)&factory);
+  status = CreateDXGIFactory1(IID_IDXGIFactory1, (void **)&factory);
   if(FAILED(status)) {
     BOOST_LOG(error) << "Failed to create DXGIFactory1 [0x"sv << util::hex(status).to_string_view() << ']';
     return -1;
@@ -102,7 +109,7 @@ int display_base_t::init() {
   std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> converter;
 
   auto adapter_name = converter.from_bytes(config::video.adapter_name);
-  auto output_name = converter.from_bytes(config::video.output_name);
+  auto output_name  = converter.from_bytes(config::video.output_name);
 
   adapter_t::pointer adapter_p;
   for(int x = 0; factory->EnumAdapters1(x, &adapter_p) != DXGI_ERROR_NOT_FOUND; ++x) {
@@ -131,8 +138,13 @@ int display_base_t::init() {
 
         offset_x = desc.DesktopCoordinates.left;
         offset_y = desc.DesktopCoordinates.top;
-        width  = desc.DesktopCoordinates.right - offset_x;
-        height = desc.DesktopCoordinates.bottom - offset_y;
+        width    = desc.DesktopCoordinates.right - offset_x;
+        height   = desc.DesktopCoordinates.bottom - offset_y;
+
+        // left and bottom may be negative, yet absolute mouse coordinates start at 0x0
+        // Ensure offset starts at 0x0
+        offset_x -= GetSystemMetrics(SM_XVIRTUALSCREEN);
+        offset_y -= GetSystemMetrics(SM_YVIRTUALSCREEN);
       }
     }
 
@@ -157,7 +169,7 @@ int display_base_t::init() {
     D3D_FEATURE_LEVEL_9_1
   };
 
-  status = adapter->QueryInterface(IID_IDXGIAdapter, (void**)&adapter_p);
+  status = adapter->QueryInterface(IID_IDXGIAdapter, (void **)&adapter_p);
   if(FAILED(status)) {
     BOOST_LOG(error) << "Failed to query IDXGIAdapter interface"sv;
     return -1;
@@ -195,7 +207,9 @@ int display_base_t::init() {
     << "Device Sys Mem     : "sv << adapter_desc.DedicatedSystemMemory / 1048576 << " MiB"sv << std::endl
     << "Share Sys Mem      : "sv << adapter_desc.SharedSystemMemory / 1048576 << " MiB"sv << std::endl
     << "Feature Level      : 0x"sv << util::hex(feature_level).to_string_view() << std::endl
-    << "Capture size       : "sv << width << 'x'  << height;
+    << "Capture size       : "sv << width << 'x' << height << std::endl
+    << "Offset             : "sv << offset_x << 'x' << offset_y << std::endl
+    << "Virtual Desktop    : "sv << env_width << 'x' << env_height;
 
   // Bump up thread priority
   {
@@ -204,13 +218,13 @@ int display_base_t::init() {
     HANDLE token;
     LUID val;
 
-    if (OpenProcessToken(GetCurrentProcess(), flags, &token) &&
+    if(OpenProcessToken(GetCurrentProcess(), flags, &token) &&
        !!LookupPrivilegeValue(NULL, SE_INC_BASE_PRIORITY_NAME, &val)) {
-      tp.PrivilegeCount = 1;
-      tp.Privileges[0].Luid = val;
+      tp.PrivilegeCount           = 1;
+      tp.Privileges[0].Luid       = val;
       tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 
-      if (!AdjustTokenPrivileges(token, false, &tp, sizeof(tp), NULL, NULL)) {
+      if(!AdjustTokenPrivileges(token, false, &tp, sizeof(tp), NULL, NULL)) {
         BOOST_LOG(warning) << "Could not set privilege to increase GPU priority";
       }
     }
@@ -218,19 +232,19 @@ int display_base_t::init() {
     CloseHandle(token);
 
     HMODULE gdi32 = GetModuleHandleA("GDI32");
-    if (gdi32) {
+    if(gdi32) {
       PD3DKMTSetProcessSchedulingPriorityClass fn =
         (PD3DKMTSetProcessSchedulingPriorityClass)GetProcAddress(gdi32, "D3DKMTSetProcessSchedulingPriorityClass");
-      if (fn) {
+      if(fn) {
         status = fn(GetCurrentProcess(), D3DKMT_SCHEDULINGPRIORITYCLASS_REALTIME);
-        if (FAILED(status)) {
+        if(FAILED(status)) {
           BOOST_LOG(warning) << "Failed to set realtime GPU priority. Please run application as administrator for optimal performance.";
         }
       }
     }
 
     dxgi::dxgi_t dxgi;
-    status = device->QueryInterface(IID_IDXGIDevice, (void**)&dxgi);
+    status = device->QueryInterface(IID_IDXGIDevice, (void **)&dxgi);
     if(FAILED(status)) {
       BOOST_LOG(warning) << "Failed to query DXGI interface from device [0x"sv << util::hex(status).to_string_view() << ']';
       return -1;
@@ -242,7 +256,7 @@ int display_base_t::init() {
   // Try to reduce latency
   {
     dxgi::dxgi1_t dxgi {};
-    status = device->QueryInterface(IID_IDXGIDevice, (void**)&dxgi);
+    status = device->QueryInterface(IID_IDXGIDevice, (void **)&dxgi);
     if(FAILED(status)) {
       BOOST_LOG(error) << "Failed to query DXGI interface from device [0x"sv << util::hex(status).to_string_view() << ']';
       return -1;
@@ -258,7 +272,7 @@ int display_base_t::init() {
   //TODO: Use IDXGIOutput5 for improved performance
   {
     dxgi::output1_t output1 {};
-    status = output->QueryInterface(IID_IDXGIOutput1, (void**)&output1);
+    status = output->QueryInterface(IID_IDXGIOutput1, (void **)&output1);
     if(FAILED(status)) {
       BOOST_LOG(error) << "Failed to query IDXGIOutput1 from the output"sv;
       return -1;
@@ -266,7 +280,7 @@ int display_base_t::init() {
 
     // We try this twice, in case we still get an error on reinitialization
     for(int x = 0; x < 2; ++x) {
-      status = output1->DuplicateOutput((IUnknown*)device.get(), &dup.dup);
+      status = output1->DuplicateOutput((IUnknown *)device.get(), &dup.dup);
       if(SUCCEEDED(status)) {
         break;
       }
@@ -414,18 +428,18 @@ const char *format_str[] = {
   "DXGI_FORMAT_V408"
 };
 
-}
+} // namespace platf::dxgi
 
 namespace platf {
-std::shared_ptr<display_t> display(dev_type_e hwdevice_type) {
-  if(hwdevice_type == dev_type_e::dxgi) {
+std::shared_ptr<display_t> display(mem_type_e hwdevice_type) {
+  if(hwdevice_type == mem_type_e::dxgi) {
     auto disp = std::make_shared<dxgi::display_vram_t>();
 
     if(!disp->init()) {
       return disp;
     }
   }
-  else if(hwdevice_type == dev_type_e::none) {
+  else if(hwdevice_type == mem_type_e::system) {
     auto disp = std::make_shared<dxgi::display_ram_t>();
 
     if(!disp->init()) {
@@ -435,4 +449,4 @@ std::shared_ptr<display_t> display(dev_type_e hwdevice_type) {
 
   return nullptr;
 }
-}
+} // namespace platf

sunshine/platform/windows/display_ram.cpp

@@ -1,12 +1,12 @@
-#include "sunshine/main.h"
 #include "display.h"
+#include "sunshine/main.h"
 
 namespace platf {
 using namespace std::literals;
 }
 
 namespace platf::dxgi {
-struct img_t : public ::platf::img_t  {
+struct img_t : public ::platf::img_t {
   ~img_t() override {
     delete[] data;
     data = nullptr;
@@ -22,29 +22,29 @@ void blend_cursor_monochrome(const cursor_t &cursor, img_t &img) {
   auto cursor_skip_y = -std::min(0, cursor.y);
   auto cursor_skip_x = -std::min(0, cursor.x);
 
-  // img cursor.{x,y} > img.{x,y}, truncate parts of the cursor.img_data 
+  // img cursor.{x,y} > img.{x,y}, truncate parts of the cursor.img_data
   auto cursor_truncate_y = std::max(0, cursor.y - img.height);
   auto cursor_truncate_x = std::max(0, cursor.x - img.width);
 
-  auto cursor_width = width - cursor_skip_x - cursor_truncate_x;
+  auto cursor_width  = width - cursor_skip_x - cursor_truncate_x;
   auto cursor_height = height - cursor_skip_y - cursor_truncate_y;
 
   if(cursor_height > height || cursor_width > width) {
     return;
   }
 
-  auto img_skip_y    = std::max(0, cursor.y);
-  auto img_skip_x    = std::max(0, cursor.x);
+  auto img_skip_y = std::max(0, cursor.y);
+  auto img_skip_x = std::max(0, cursor.x);
 
   auto cursor_img_data = cursor.img_data.data() + cursor_skip_y * pitch;
 
   int delta_height = std::min(cursor_height - cursor_truncate_y, std::max(0, img.height - img_skip_y));
-  int delta_width = std::min(cursor_width - cursor_truncate_x, std::max(0, img.width - img_skip_x));
+  int delta_width  = std::min(cursor_width - cursor_truncate_x, std::max(0, img.width - img_skip_x));
 
   auto pixels_per_byte = width / pitch;
-  auto bytes_per_row = delta_width / pixels_per_byte;
+  auto bytes_per_row   = delta_width / pixels_per_byte;
 
-  auto img_data = (int*)img.data;
+  auto img_data = (int *)img.data;
   for(int i = 0; i < delta_height; ++i) {
     auto and_mask = &cursor_img_data[i * pitch];
     auto xor_mask = &cursor_img_data[(i + height) * pitch];
@@ -76,8 +76,8 @@ void blend_cursor_monochrome(const cursor_t &cursor, img_t &img) {
 }
 
 void apply_color_alpha(int *img_pixel_p, int cursor_pixel) {
-  auto colors_out = (std::uint8_t*)&cursor_pixel;
-  auto colors_in  = (std::uint8_t*)img_pixel_p;
+  auto colors_out = (std::uint8_t *)&cursor_pixel;
+  auto colors_in  = (std::uint8_t *)img_pixel_p;
 
   //TODO: When use of IDXGIOutput5 is implemented, support different color formats
   auto alpha = colors_out[3];
@@ -85,15 +85,15 @@ void apply_color_alpha(int *img_pixel_p, int cursor_pixel) {
     *img_pixel_p = cursor_pixel;
   }
   else {
-    colors_in[0] = colors_out[0] + (colors_in[0] * (255 - alpha) + 255/2) / 255;
-    colors_in[1] = colors_out[1] + (colors_in[1] * (255 - alpha) + 255/2) / 255;
-    colors_in[2] = colors_out[2] + (colors_in[2] * (255 - alpha) + 255/2) / 255;
+    colors_in[0] = colors_out[0] + (colors_in[0] * (255 - alpha) + 255 / 2) / 255;
+    colors_in[1] = colors_out[1] + (colors_in[1] * (255 - alpha) + 255 / 2) / 255;
+    colors_in[2] = colors_out[2] + (colors_in[2] * (255 - alpha) + 255 / 2) / 255;
   }
 }
 
 void apply_color_masked(int *img_pixel_p, int cursor_pixel) {
   //TODO: When use of IDXGIOutput5 is implemented, support different color formats
-  auto alpha = ((std::uint8_t*)&cursor_pixel)[3];
+  auto alpha = ((std::uint8_t *)&cursor_pixel)[3];
   if(alpha == 0xFF) {
     *img_pixel_p ^= cursor_pixel;
   }
@@ -111,30 +111,30 @@ void blend_cursor_color(const cursor_t &cursor, img_t &img, const bool masked) {
   auto cursor_skip_y = -std::min(0, cursor.y);
   auto cursor_skip_x = -std::min(0, cursor.x);
 
-  // img cursor.{x,y} > img.{x,y}, truncate parts of the cursor.img_data 
+  // img cursor.{x,y} > img.{x,y}, truncate parts of the cursor.img_data
   auto cursor_truncate_y = std::max(0, cursor.y - img.height);
   auto cursor_truncate_x = std::max(0, cursor.x - img.width);
 
-  auto img_skip_y    = std::max(0, cursor.y);
-  auto img_skip_x    = std::max(0, cursor.x);
+  auto img_skip_y = std::max(0, cursor.y);
+  auto img_skip_x = std::max(0, cursor.x);
 
-  auto cursor_width = width - cursor_skip_x - cursor_truncate_x;
+  auto cursor_width  = width - cursor_skip_x - cursor_truncate_x;
   auto cursor_height = height - cursor_skip_y - cursor_truncate_y;
 
   if(cursor_height > height || cursor_width > width) {
     return;
   }
 
-  auto cursor_img_data = (int*)&cursor.img_data[cursor_skip_y * pitch];
+  auto cursor_img_data = (int *)&cursor.img_data[cursor_skip_y * pitch];
 
   int delta_height = std::min(cursor_height - cursor_truncate_y, std::max(0, img.height - img_skip_y));
-  int delta_width = std::min(cursor_width - cursor_truncate_x, std::max(0, img.width - img_skip_x));
+  int delta_width  = std::min(cursor_width - cursor_truncate_x, std::max(0, img.width - img_skip_x));
 
-  auto img_data = (int*)img.data;
+  auto img_data = (int *)img.data;
 
   for(int i = 0; i < delta_height; ++i) {
     auto cursor_begin = &cursor_img_data[i * cursor.shape_info.Width + cursor_skip_x];
-    auto cursor_end = &cursor_begin[delta_width];
+    auto cursor_end   = &cursor_begin[delta_width];
 
     auto img_pixel_p = &img_data[(i + img_skip_y) * (img.row_pitch / img.pixel_pitch) + img_skip_x];
     std::for_each(cursor_begin, cursor_end, [&](int cursor_pixel) {
@@ -151,22 +151,22 @@ void blend_cursor_color(const cursor_t &cursor, img_t &img, const bool masked) {
 
 void blend_cursor(const cursor_t &cursor, img_t &img) {
   switch(cursor.shape_info.Type) {
-    case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR:
-      blend_cursor_color(cursor, img, false);
-      break;
-    case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME:
-      blend_cursor_monochrome(cursor, img);
-      break;
-    case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR:
-      blend_cursor_color(cursor, img, true);
-      break;
-    default:
-      BOOST_LOG(warning) << "Unsupported cursor format ["sv << cursor.shape_info.Type << ']';
+  case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR:
+    blend_cursor_color(cursor, img, false);
+    break;
+  case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME:
+    blend_cursor_monochrome(cursor, img);
+    break;
+  case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR:
+    blend_cursor_color(cursor, img, true);
+    break;
+  default:
+    BOOST_LOG(warning) << "Unsupported cursor format ["sv << cursor.shape_info.Type << ']';
   }
 }
 
 capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::milliseconds timeout, bool cursor_visible) {
-  auto img = (img_t*)img_base;
+  auto img = (img_t *)img_base;
 
   HRESULT status;
 
@@ -174,9 +174,9 @@ capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::millise
 
   resource_t::pointer res_p {};
   auto capture_status = dup.next_frame(frame_info, timeout, &res_p);
-  resource_t res{res_p};
+  resource_t res { res_p };
 
-  if (capture_status != capture_e::ok) {
+  if(capture_status != capture_e::ok) {
     return capture_status;
   }
 
@@ -187,7 +187,7 @@ capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::millise
 
     UINT dummy;
     status = dup.dup->GetFramePointerShape(img_data.size(), img_data.data(), &dummy, &cursor.shape_info);
-    if (FAILED(status)) {
+    if(FAILED(status)) {
       BOOST_LOG(error) << "Failed to get new pointer shape [0x"sv << util::hex(status).to_string_view() << ']';
 
       return capture_e::error;
@@ -195,18 +195,18 @@ capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::millise
   }
 
   if(frame_info.LastMouseUpdateTime.QuadPart) {
-    cursor.x = frame_info.PointerPosition.Position.x;
-    cursor.y = frame_info.PointerPosition.Position.y;
+    cursor.x       = frame_info.PointerPosition.Position.x;
+    cursor.y       = frame_info.PointerPosition.Position.y;
     cursor.visible = frame_info.PointerPosition.Visible;
   }
 
   // If frame has been updated
-  if (frame_info.LastPresentTime.QuadPart != 0) {
+  if(frame_info.LastPresentTime.QuadPart != 0) {
     {
       texture2d_t src {};
       status = res->QueryInterface(IID_ID3D11Texture2D, (void **)&src);
 
-      if (FAILED(status)) {
+      if(FAILED(status)) {
         BOOST_LOG(error) << "Couldn't query interface [0x"sv << util::hex(status).to_string_view() << ']';
         return capture_e::error;
       }
@@ -221,14 +221,14 @@ capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::millise
     }
 
     status = device_ctx->Map(texture.get(), 0, D3D11_MAP_READ, 0, &img_info);
-    if (FAILED(status)) {
+    if(FAILED(status)) {
       BOOST_LOG(error) << "Failed to map texture [0x"sv << util::hex(status).to_string_view() << ']';
 
       return capture_e::error;
     }
   }
 
-  const bool mouse_update = 
+  const bool mouse_update =
     (frame_info.LastMouseUpdateTime.QuadPart || frame_info.PointerShapeBufferSize > 0) &&
     (cursor_visible && cursor.visible);
 
@@ -238,7 +238,7 @@ capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::millise
     return capture_e::timeout;
   }
 
-  std::copy_n((std::uint8_t*)img_info.pData, height * img_info.RowPitch, (std::uint8_t*)img->data);
+  std::copy_n((std::uint8_t *)img_info.pData, height * img_info.RowPitch, (std::uint8_t *)img->data);
 
   if(cursor_visible && cursor.visible) {
     blend_cursor(cursor, *img);
@@ -250,11 +250,11 @@ capture_e display_ram_t::snapshot(::platf::img_t *img_base, std::chrono::millise
 std::shared_ptr<platf::img_t> display_ram_t::alloc_img() {
   auto img = std::make_shared<img_t>();
 
-  img->pixel_pitch  = 4;
-  img->row_pitch    = img_info.RowPitch;
-  img->width        = width;
-  img->height       = height;
-  img->data         = new std::uint8_t[img->row_pitch * height];
+  img->pixel_pitch = 4;
+  img->row_pitch   = img_info.RowPitch;
+  img->width       = width;
+  img->height      = height;
+  img->data        = new std::uint8_t[img->row_pitch * height];
 
   return img;
 }
@@ -269,14 +269,14 @@ int display_ram_t::init() {
   }
 
   D3D11_TEXTURE2D_DESC t {};
-  t.Width  = width;
-  t.Height = height;
-  t.MipLevels = 1;
-  t.ArraySize = 1;
+  t.Width            = width;
+  t.Height           = height;
+  t.MipLevels        = 1;
+  t.ArraySize        = 1;
   t.SampleDesc.Count = 1;
-  t.Usage = D3D11_USAGE_STAGING;
-  t.Format = format;
-  t.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+  t.Usage            = D3D11_USAGE_STAGING;
+  t.Format           = format;
+  t.CPUAccessFlags   = D3D11_CPU_ACCESS_READ;
 
   auto status = device->CreateTexture2D(&t, nullptr, &texture);
 
@@ -294,4 +294,4 @@ int display_ram_t::init() {
 
   return 0;
 }
-}
+} // namespace platf::dxgi

sunshine/platform/windows/display_vram.cpp

@@ -1,19 +1,32 @@
+#include <cmath>
+
 #include <codecvt>
 
 #include <d3dcompiler.h>
 #include <directxmath.h>
 
-#include "sunshine/main.h"
-#include "display.h"
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavutil/hwcontext_d3d11va.h>
+}
 
-#define SUNSHINE_SHADERS_DIR SUNSHINE_ASSETS_DIR "/shaders"
+#include "display.h"
+#include "sunshine/main.h"
+#include "sunshine/video.h"
+
+
+#define SUNSHINE_SHADERS_DIR SUNSHINE_ASSETS_DIR "/shaders/directx"
 namespace platf {
 using namespace std::literals;
 }
 
-namespace platf::dxgi {
-constexpr float aquamarine[] { 0.498039246f, 1.000000000f, 0.831372619f, 1.000000000f };
+static void free_frame(AVFrame *frame) {
+  av_frame_free(&frame);
+}
 
+using frame_t = util::safe_ptr<AVFrame, free_frame>;
+
+namespace platf::dxgi {
 using input_layout_t        = util::safe_ptr<ID3D11InputLayout, Release<ID3D11InputLayout>>;
 using render_target_t       = util::safe_ptr<ID3D11RenderTargetView, Release<ID3D11RenderTargetView>>;
 using shader_res_t          = util::safe_ptr<ID3D11ShaderResourceView, Release<ID3D11ShaderResourceView>>;
@@ -27,46 +40,8 @@ using blob_t                = util::safe_ptr<ID3DBlob, Release<ID3DBlob>>;
 using depth_stencil_state_t = util::safe_ptr<ID3D11DepthStencilState, Release<ID3D11DepthStencilState>>;
 using depth_stencil_view_t  = util::safe_ptr<ID3D11DepthStencilView, Release<ID3D11DepthStencilView>>;
 
-using float4 = DirectX::XMFLOAT4;
-using float3 = DirectX::XMFLOAT3;
-using float2 = DirectX::XMFLOAT2;
-struct __attribute__ ((__aligned__ (16))) color_t {
-  float4 color_vec_y;
-  float4 color_vec_u;
-  float4 color_vec_v;
-  float2 range_y;
-  float2 range_uv;
-};
-
-color_t make_color_matrix(float Cr, float Cb, float U_max, float V_max, float add_Y, float add_UV, float2 range_Y, float2 range_UV) {
-  float Cg = 1.0f - Cr - Cb;
-
-  float Cr_i = 1.0f - Cr;
-  float Cb_i = 1.0f - Cb;
-
-  float shift_y = range_Y.x / 256.0f;
-  float shift_uv = range_UV.x / 256.0f;
-
-  float scale_y = (range_Y.y - range_Y.x) / 256.0f;
-  float scale_uv = (range_UV.y - range_UV.x) / 256.0f;
-  return {
-    { Cr, Cg, Cb, add_Y },
-    { -(Cr * U_max / Cb_i), -(Cg * U_max / Cb_i), U_max, add_UV },
-    { V_max, -(Cg * V_max / Cr_i), -(Cb * V_max / Cr_i), add_UV },
-    { scale_y, shift_y },
-    { scale_uv, shift_uv },
-  };
-}
-
-color_t colors[] {
-  make_color_matrix(0.299f, 0.114f, 0.436f, 0.615f, 0.0625, 0.5f, { 16.0f, 235.0f }, { 16.0f, 240.0f }),   // BT601 MPEG
-  make_color_matrix(0.299f, 0.114f, 0.5f, 0.5f, 0.0f, 0.5f, { 0.0f, 255.0f }, { 0.0f, 255.0f }),           // BT601 JPEG
-  make_color_matrix(0.2126f, 0.0722f, 0.436f, 0.615f, 0.0625, 0.5f, { 16.0f, 235.0f }, { 16.0f, 240.0f }), //BT701 MPEG
-  make_color_matrix(0.2126f, 0.0722f, 0.5f, 0.5f, 0.0f, 0.5f, { 0.0f, 255.0f }, { 0.0f, 255.0f }),         //BT701 JPEG
-};
-
 template<class T>
-buf_t make_buffer(device_t::pointer device, const T& t) {
+buf_t make_buffer(device_t::pointer device, const T &t) {
   static_assert(sizeof(T) % 16 == 0, "Buffer needs to be aligned on a 16-byte alignment");
 
   D3D11_BUFFER_DESC buffer_desc {
@@ -91,18 +66,18 @@ buf_t make_buffer(device_t::pointer device, const T& t) {
 
 blend_t make_blend(device_t::pointer device, bool enable) {
   D3D11_BLEND_DESC bdesc {};
-  auto &rt = bdesc.RenderTarget[0];
-  rt.BlendEnable = enable;
+  auto &rt                 = bdesc.RenderTarget[0];
+  rt.BlendEnable           = enable;
   rt.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
 
   if(enable) {
-    rt.BlendOp = D3D11_BLEND_OP_ADD;
+    rt.BlendOp      = D3D11_BLEND_OP_ADD;
     rt.BlendOpAlpha = D3D11_BLEND_OP_ADD;
 
-    rt.SrcBlend = D3D11_BLEND_SRC_ALPHA;
+    rt.SrcBlend  = D3D11_BLEND_SRC_ALPHA;
     rt.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
 
-    rt.SrcBlendAlpha = D3D11_BLEND_ZERO;
+    rt.SrcBlendAlpha  = D3D11_BLEND_ZERO;
     rt.DestBlendAlpha = D3D11_BLEND_ZERO;
   }
 
@@ -130,79 +105,79 @@ struct img_d3d_t : public platf::img_t {
   ~img_d3d_t() override = default;
 };
 
-util::buffer_t<std::uint8_t> make_cursor_image(util::buffer_t<std::uint8_t> &&img_data, DXGI_OUTDUPL_POINTER_SHAPE_INFO shape_info)  {
-  constexpr std::uint32_t black = 0xFF000000;
-  constexpr std::uint32_t white = 0xFFFFFFFF;
+util::buffer_t<std::uint8_t> make_cursor_image(util::buffer_t<std::uint8_t> &&img_data, DXGI_OUTDUPL_POINTER_SHAPE_INFO shape_info) {
+  constexpr std::uint32_t black       = 0xFF000000;
+  constexpr std::uint32_t white       = 0xFFFFFFFF;
   constexpr std::uint32_t transparent = 0;
 
   switch(shape_info.Type) {
-    case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR:
-      std::for_each((std::uint32_t*)std::begin(img_data), (std::uint32_t*)std::end(img_data), [](auto &pixel) {
-        if(pixel & 0xFF000000) {
-          pixel = transparent;
-        }
-      });
-    case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR:
-      return std::move(img_data);
-    default:
-      break;
+  case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR:
+    std::for_each((std::uint32_t *)std::begin(img_data), (std::uint32_t *)std::end(img_data), [](auto &pixel) {
+      if(pixel & 0xFF000000) {
+        pixel = transparent;
+      }
+    });
+  case DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR:
+    return std::move(img_data);
+  default:
+    break;
   }
 
   shape_info.Height /= 2;
 
   util::buffer_t<std::uint8_t> cursor_img { shape_info.Width * shape_info.Height * 4 };
 
-  auto bytes = shape_info.Pitch * shape_info.Height;
-  auto pixel_begin = (std::uint32_t*)std::begin(cursor_img);
-  auto pixel_data = pixel_begin;
-  auto and_mask = std::begin(img_data);
-  auto xor_mask = std::begin(img_data) + bytes;
+  auto bytes       = shape_info.Pitch * shape_info.Height;
+  auto pixel_begin = (std::uint32_t *)std::begin(cursor_img);
+  auto pixel_data  = pixel_begin;
+  auto and_mask    = std::begin(img_data);
+  auto xor_mask    = std::begin(img_data) + bytes;
 
-  for(auto x = 0; x < bytes; ++x)  {
+  for(auto x = 0; x < bytes; ++x) {
     for(auto c = 7; c >= 0; --c) {
-      auto bit = 1 << c;
+      auto bit        = 1 << c;
       auto color_type = ((*and_mask & bit) ? 1 : 0) + ((*xor_mask & bit) ? 2 : 0);
 
       switch(color_type) {
-        case 0: //black
-          *pixel_data = black;
-          break;
-        case 2: //white
-          *pixel_data = white;
-          break;
-        case 1: //transparent
-        {
-          *pixel_data = transparent;
+      case 0: //black
+        *pixel_data = black;
+        break;
+      case 2: //white
+        *pixel_data = white;
+        break;
+      case 1: //transparent
+      {
+        *pixel_data = transparent;
 
-          break;
+        break;
+      }
+      case 3: //inverse
+      {
+        auto top_p    = pixel_data - shape_info.Width;
+        auto left_p   = pixel_data - 1;
+        auto right_p  = pixel_data + 1;
+        auto bottom_p = pixel_data + shape_info.Width;
+
+        // Get the x coordinate of the pixel
+        auto column = (pixel_data - pixel_begin) % shape_info.Width != 0;
+
+        if(top_p >= pixel_begin && *top_p == transparent) {
+          *top_p = black;
         }
-        case 3: //inverse
-        {
-          auto top_p    = pixel_data - shape_info.Width;
-          auto left_p   = pixel_data - 1;
-          auto right_p  = pixel_data + 1;
-          auto bottom_p = pixel_data + shape_info.Width;
 
-          // Get the x coordinate of the pixel
-          auto column = (pixel_data - pixel_begin) % shape_info.Width != 0;
-
-          if(top_p >= pixel_begin && *top_p == transparent) {
-            *top_p = black;
-          }
-
-          if(column != 0 && left_p >= pixel_begin && *left_p == transparent) {
-            *left_p = black;
-          }
-
-          if(bottom_p < (std::uint32_t*)std::end(cursor_img)) {
-            *bottom_p = black;
-          }
-
-          if(column != shape_info.Width -1) {
-            *right_p = black;
-          }
-          *pixel_data = white;
+        if(column != 0 && left_p >= pixel_begin && *left_p == transparent) {
+          *left_p = black;
         }
+
+        if(bottom_p < (std::uint32_t *)std::end(cursor_img)) {
+          *bottom_p = black;
+        }
+
+        if(column != shape_info.Width - 1) {
+          *right_p = black;
+        }
+        *pixel_data = white;
+      }
       }
 
       ++pixel_data;
@@ -225,7 +200,7 @@ blob_t compile_shader(LPCSTR file, LPCSTR entrypoint, LPCSTR shader_model) {
 #endif
   std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> converter;
 
-  auto wFile = converter.from_bytes(file);
+  auto wFile  = converter.from_bytes(file);
   auto status = D3DCompileFromFile(wFile.c_str(), nullptr, nullptr, entrypoint, shader_model, flags, 0, &compiled_p, &msg_p);
 
   if(msg_p) {
@@ -251,7 +226,7 @@ blob_t compile_vertex_shader(LPCSTR file) {
 
 class hwdevice_t : public platf::hwdevice_t {
 public:
-  hwdevice_t(std::vector<hwdevice_t*> *hwdevices_p) : hwdevices_p { hwdevices_p } {}
+  hwdevice_t(std::vector<hwdevice_t *> *hwdevices_p) : hwdevices_p { hwdevices_p } {}
   hwdevice_t() = delete;
 
   void set_cursor_pos(LONG rel_x, LONG rel_y, bool visible) {
@@ -271,7 +246,7 @@ public:
   int set_cursor_texture(texture2d_t::pointer texture, LONG width, LONG height) {
     auto device = (device_t::pointer)data;
 
-    cursor_view.Width = width;
+    cursor_view.Width  = width;
     cursor_view.Height = height;
 
     D3D11_SHADER_RESOURCE_VIEW_DESC desc {
@@ -290,7 +265,7 @@ public:
   }
 
   int convert(platf::img_t &img_base) override {
-    auto &img = (img_d3d_t&)img_base;
+    auto &img = (img_d3d_t &)img_base;
 
     if(!img.input_res) {
       auto device = (device_t::pointer)data;
@@ -329,35 +304,48 @@ public:
       input_res_p = scene_sr.get();
     }
 
-    _init_view_port(out_width, out_height);
+    _init_view_port(this->img.width, this->img.height);
     device_ctx_p->OMSetRenderTargets(1, &nv12_Y_rt, nullptr);
     device_ctx_p->VSSetShader(scene_vs.get(), nullptr, 0);
     device_ctx_p->PSSetShader(convert_Y_ps.get(), nullptr, 0);
+    device_ctx_p->PSSetShaderResources(0, 1, &back_img.input_res);
+    device_ctx_p->Draw(3, 0);
+
+    device_ctx_p->RSSetViewports(1, &outY_view);
     device_ctx_p->PSSetShaderResources(0, 1, &input_res_p);
     device_ctx_p->Draw(3, 0);
 
-    _init_view_port(out_width / 2, out_height / 2);
+    // Artifacts start appearing on the rendered image if Sunshine doesn't flush
+    // before rendering on the UV part of the image.
+    device_ctx_p->Flush();
+
+    _init_view_port(this->img.width / 2, this->img.height / 2);
     device_ctx_p->OMSetRenderTargets(1, &nv12_UV_rt, nullptr);
     device_ctx_p->VSSetShader(convert_UV_vs.get(), nullptr, 0);
     device_ctx_p->PSSetShader(convert_UV_ps.get(), nullptr, 0);
+    device_ctx_p->PSSetShaderResources(0, 1, &back_img.input_res);
+    device_ctx_p->Draw(3, 0);
+
+    device_ctx_p->RSSetViewports(1, &outUV_view);
     device_ctx_p->PSSetShaderResources(0, 1, &input_res_p);
     device_ctx_p->Draw(3, 0);
+    device_ctx_p->Flush();
 
     return 0;
   }
 
   void set_colorspace(std::uint32_t colorspace, std::uint32_t color_range) override {
-    switch (colorspace) {
-      case 5: // SWS_CS_SMPTE170M
-        color_p = &colors[0];
-        break;
-      case 1: // SWS_CS_ITU709
-        color_p = &colors[2];
-        break;
-      case 9: // SWS_CS_BT2020
-      default:
-        BOOST_LOG(warning) << "Colorspace: ["sv << colorspace << "] not yet supported: switching to default"sv;
-        color_p = &colors[0];
+    switch(colorspace) {
+    case 5: // SWS_CS_SMPTE170M
+      color_p = &::video::colors[0];
+      break;
+    case 1: // SWS_CS_ITU709
+      color_p = &::video::colors[2];
+      break;
+    case 9: // SWS_CS_BT2020
+    default:
+      BOOST_LOG(warning) << "Colorspace: ["sv << colorspace << "] not yet supported: switching to default"sv;
+      color_p = &::video::colors[0];
     };
 
     if(color_range > 1) {
@@ -375,11 +363,102 @@ public:
     this->color_matrix = std::move(color_matrix);
   }
 
+  int set_frame(AVFrame *frame) {
+    this->hwframe.reset(frame);
+    this->frame = frame;
+
+    auto device_p = (device_t::pointer)data;
+
+    auto out_width  = frame->width;
+    auto out_height = frame->height;
+
+    float in_width  = img.display->width;
+    float in_height = img.display->height;
+
+    // // Ensure aspect ratio is maintained
+    auto scalar       = std::fminf(out_width / in_width, out_height / in_height);
+    auto out_width_f  = in_width * scalar;
+    auto out_height_f = in_height * scalar;
+
+    // result is always positive
+    auto offsetX = (out_width - out_width_f) / 2;
+    auto offsetY = (out_height - out_height_f) / 2;
+
+    outY_view  = D3D11_VIEWPORT { offsetX, offsetY, out_width_f, out_height_f, 0.0f, 1.0f };
+    outUV_view = D3D11_VIEWPORT { offsetX / 2, offsetY / 2, out_width_f / 2, out_height_f / 2, 0.0f, 1.0f };
+
+    D3D11_TEXTURE2D_DESC t {};
+    t.Width            = out_width;
+    t.Height           = out_height;
+    t.MipLevels        = 1;
+    t.ArraySize        = 1;
+    t.SampleDesc.Count = 1;
+    t.Usage            = D3D11_USAGE_DEFAULT;
+    t.Format           = format;
+    t.BindFlags        = D3D11_BIND_RENDER_TARGET;
+
+    auto status = device_p->CreateTexture2D(&t, nullptr, &img.texture);
+    if(FAILED(status)) {
+      BOOST_LOG(error) << "Failed to create render target texture [0x"sv << util::hex(status).to_string_view() << ']';
+      return -1;
+    }
+
+    img.width       = out_width;
+    img.height      = out_height;
+    img.data        = (std::uint8_t *)img.texture.get();
+    img.row_pitch   = out_width;
+    img.pixel_pitch = 1;
+
+    float info_in[16 / sizeof(float)] { 1.0f / (float)out_width }; //aligned to 16-byte
+    info_scene = make_buffer(device_p, info_in);
+
+    if(!info_in) {
+      BOOST_LOG(error) << "Failed to create info scene buffer"sv;
+      return -1;
+    }
+
+    D3D11_RENDER_TARGET_VIEW_DESC nv12_rt_desc {
+      DXGI_FORMAT_R8_UNORM,
+      D3D11_RTV_DIMENSION_TEXTURE2D
+    };
+
+    status = device_p->CreateRenderTargetView(img.texture.get(), &nv12_rt_desc, &nv12_Y_rt);
+    if(FAILED(status)) {
+      BOOST_LOG(error) << "Failed to create render target view [0x"sv << util::hex(status).to_string_view() << ']';
+      return -1;
+    }
+
+    nv12_rt_desc.Format = DXGI_FORMAT_R8G8_UNORM;
+    status              = device_p->CreateRenderTargetView(img.texture.get(), &nv12_rt_desc, &nv12_UV_rt);
+    if(FAILED(status)) {
+      BOOST_LOG(error) << "Failed to create render target view [0x"sv << util::hex(status).to_string_view() << ']';
+      return -1;
+    }
+
+    // Need to have something refcounted
+    if(!frame->buf[0]) {
+      frame->buf[0] = av_buffer_allocz(sizeof(AVD3D11FrameDescriptor));
+    }
+
+    auto desc     = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
+    desc->texture = (ID3D11Texture2D *)img.data;
+    desc->index   = 0;
+
+    frame->data[0] = img.data;
+    frame->data[1] = 0;
+
+    frame->linesize[0] = img.row_pitch;
+
+    frame->height = img.height;
+    frame->width  = img.width;
+
+    return 0;
+  }
+
   int init(
     std::shared_ptr<platf::display_t> display, device_t::pointer device_p, device_ctx_t::pointer device_ctx_p,
-    int in_width, int in_height, int out_width, int out_height,
-    pix_fmt_e pix_fmt
-  ) {
+    pix_fmt_e pix_fmt) {
+
     HRESULT status;
 
     device_p->AddRef();
@@ -387,15 +466,11 @@ public:
 
     this->device_ctx_p = device_ctx_p;
 
-    cursor_visible = false;
+    cursor_visible       = false;
     cursor_view.MinDepth = 0.0f;
     cursor_view.MaxDepth = 1.0f;
 
-    platf::hwdevice_t::img = &img;
-
-    this->out_width  = out_width;
-    this->out_height = out_height;
-
+    format = (pix_fmt == pix_fmt_e::nv12 ? DXGI_FORMAT_NV12 : DXGI_FORMAT_P010);
     status = device_p->CreateVertexShader(scene_vs_hlsl->GetBufferPointer(), scene_vs_hlsl->GetBufferSize(), nullptr, &scene_vs);
     if(status) {
       BOOST_LOG(error) << "Failed to create scene vertex shader [0x"sv << util::hex(status).to_string_view() << ']';
@@ -427,29 +502,22 @@ public:
     }
 
     blend_disable = make_blend(device_p, false);
-    blend_enable = make_blend(device_p, true);
+    blend_enable  = make_blend(device_p, true);
 
     if(!blend_disable || !blend_enable) {
       return -1;
     }
 
-    if(_init_rt(scene_sr, scene_rt, in_width, in_height, DXGI_FORMAT_B8G8R8A8_UNORM)) {
+    if(_init_rt(scene_sr, scene_rt, display->width, display->height, DXGI_FORMAT_B8G8R8A8_UNORM)) {
       return -1;
     }
 
-    color_matrix = make_buffer(device_p, colors[0]);
+    color_matrix = make_buffer(device_p, ::video::colors[0]);
     if(!color_matrix) {
       BOOST_LOG(error) << "Failed to create color matrix buffer"sv;
       return -1;
     }
 
-    float info_in[16 / sizeof(float)] { 1.0f / (float)out_width }; //aligned to 16-byte
-    info_scene = make_buffer(device_p, info_in);
-    if(!info_in) {
-      BOOST_LOG(error) << "Failed to create info scene buffer"sv;
-      return -1;
-    }
-
     D3D11_INPUT_ELEMENT_DESC layout_desc {
       "SV_Position", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0
     };
@@ -459,55 +527,16 @@ public:
       convert_UV_vs_hlsl->GetBufferPointer(), convert_UV_vs_hlsl->GetBufferSize(),
       &input_layout);
 
-    D3D11_TEXTURE2D_DESC t {};
-    t.Width  = out_width;
-    t.Height = out_height;
-    t.MipLevels = 1;
-    t.ArraySize = 1;
-    t.SampleDesc.Count = 1;
-    t.Usage = D3D11_USAGE_DEFAULT;
-    t.Format = pix_fmt == pix_fmt_e::nv12 ? DXGI_FORMAT_NV12 : DXGI_FORMAT_P010;
-    t.BindFlags = D3D11_BIND_RENDER_TARGET;
-
-    status = device_p->CreateTexture2D(&t, nullptr, &img.texture);
-    if(FAILED(status)) {
-      BOOST_LOG(error) << "Failed to create render target texture [0x"sv << util::hex(status).to_string_view() << ']';
-      return -1;
-    }
-
     img.display = std::move(display);
-    img.width = out_width;
-    img.height = out_height;
-    img.data = (std::uint8_t*)img.texture.get();
-    img.row_pitch = out_width;
-    img.pixel_pitch = 1;
-
-    D3D11_RENDER_TARGET_VIEW_DESC nv12_rt_desc {
-      DXGI_FORMAT_R8_UNORM,
-      D3D11_RTV_DIMENSION_TEXTURE2D
-    };
-
-    status = device_p->CreateRenderTargetView(img.texture.get(), &nv12_rt_desc, &nv12_Y_rt);
-    if(FAILED(status)) {
-      BOOST_LOG(error) << "Failed to create render target view [0x"sv << util::hex(status).to_string_view() << ']';
-      return -1;
-    }
-
-    nv12_rt_desc.Format = DXGI_FORMAT_R8G8_UNORM;
-    status = device_p->CreateRenderTargetView(img.texture.get(), &nv12_rt_desc, &nv12_UV_rt);
-    if(FAILED(status)) {
-      BOOST_LOG(error) << "Failed to create render target view [0x"sv << util::hex(status).to_string_view() << ']';
-      return -1;
-    }
 
     D3D11_SAMPLER_DESC sampler_desc {};
-    sampler_desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
-    sampler_desc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
-    sampler_desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
-    sampler_desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
+    sampler_desc.Filter         = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+    sampler_desc.AddressU       = D3D11_TEXTURE_ADDRESS_CLAMP;
+    sampler_desc.AddressV       = D3D11_TEXTURE_ADDRESS_CLAMP;
+    sampler_desc.AddressW       = D3D11_TEXTURE_ADDRESS_WRAP;
     sampler_desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
-    sampler_desc.MinLOD = 0;
-    sampler_desc.MaxLOD = D3D11_FLOAT32_MAX;
+    sampler_desc.MinLOD         = 0;
+    sampler_desc.MaxLOD         = D3D11_FLOAT32_MAX;
 
     status = device_p->CreateSamplerState(&sampler_desc, &sampler_linear);
     if(FAILED(status)) {
@@ -515,6 +544,25 @@ public:
       return -1;
     }
 
+    // Color the background black, so that the padding for keeping the aspect ratio
+    // is black
+    if(img.display->dummy_img(&back_img)) {
+      BOOST_LOG(warning) << "Couldn't create an image to set background color to black"sv;
+      return -1;
+    }
+
+    D3D11_SHADER_RESOURCE_VIEW_DESC desc {
+      DXGI_FORMAT_B8G8R8A8_UNORM,
+      D3D11_SRV_DIMENSION_TEXTURE2D
+    };
+    desc.Texture2D.MipLevels = 1;
+
+    status = device_p->CreateShaderResourceView(back_img.texture.get(), &desc, &back_img.input_res);
+    if(FAILED(status)) {
+      BOOST_LOG(error) << "Failed to create input shader resource view [0x"sv << util::hex(status).to_string_view() << ']';
+      return -1;
+    }
+
     device_ctx_p->OMSetBlendState(blend_disable.get(), nullptr, 0xFFFFFFFFu);
     device_ctx_p->PSSetSamplers(0, 1, &sampler_linear);
     device_ctx_p->PSSetConstantBuffers(0, 1, &color_matrix);
@@ -527,7 +575,7 @@ public:
 
   ~hwdevice_t() override {
     if(data) {
-      ((ID3D11Device*)data)->Release();
+      ((ID3D11Device *)data)->Release();
     }
 
     auto it = std::find(std::begin(*hwdevices_p), std::end(*hwdevices_p), this);
@@ -535,6 +583,7 @@ public:
       hwdevices_p->erase(it);
     }
   }
+
 private:
   void _init_view_port(float x, float y, float width, float height) {
     D3D11_VIEWPORT view {
@@ -599,7 +648,9 @@ private:
   }
 
 public:
-  color_t *color_p;
+  frame_t hwframe;
+
+  ::video::color_t *color_p;
 
   blend_t blend_enable;
   blend_t blend_disable;
@@ -619,25 +670,31 @@ public:
 
   img_d3d_t img;
 
+  // Clear nv12 render target to black
+  img_d3d_t back_img;
+
   vs_t convert_UV_vs;
   ps_t convert_UV_ps;
   ps_t convert_Y_ps;
   ps_t scene_ps;
   vs_t scene_vs;
 
+  D3D11_VIEWPORT outY_view;
+  D3D11_VIEWPORT outUV_view;
+
   D3D11_VIEWPORT cursor_view;
   bool cursor_visible;
 
-  float out_width, out_height;
+  DXGI_FORMAT format;
 
   device_ctx_t::pointer device_ctx_p;
 
   // The destructor will remove itself from the list of hardware devices, this is done synchronously
-  std::vector<hwdevice_t*> *hwdevices_p;
+  std::vector<hwdevice_t *> *hwdevices_p;
 };
 
 capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::milliseconds timeout, bool cursor_visible) {
-  auto img = (img_d3d_t*)img_base;
+  auto img = (img_d3d_t *)img_base;
 
   HRESULT status;
 
@@ -645,7 +702,7 @@ capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::millisec
 
   resource_t::pointer res_p {};
   auto capture_status = dup.next_frame(frame_info, timeout, &res_p);
-  resource_t res{ res_p };
+  resource_t res { res_p };
 
   if(capture_status != capture_e::ok) {
     return capture_status;
@@ -653,7 +710,7 @@ capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::millisec
 
   const bool mouse_update_flag = frame_info.LastMouseUpdateTime.QuadPart != 0 || frame_info.PointerShapeBufferSize > 0;
   const bool frame_update_flag = frame_info.AccumulatedFrames != 0 || frame_info.LastPresentTime.QuadPart != 0;
-  const bool update_flag = mouse_update_flag || frame_update_flag;
+  const bool update_flag       = mouse_update_flag || frame_update_flag;
 
   if(!update_flag) {
     return capture_e::timeout;
@@ -666,7 +723,7 @@ capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::millisec
 
     UINT dummy;
     status = dup.dup->GetFramePointerShape(img_data.size(), std::begin(img_data), &dummy, &shape_info);
-    if (FAILED(status)) {
+    if(FAILED(status)) {
       BOOST_LOG(error) << "Failed to get new pointer shape [0x"sv << util::hex(status).to_string_view() << ']';
 
       return capture_e::error;
@@ -682,14 +739,14 @@ capture_e display_vram_t::snapshot(platf::img_t *img_base, std::chrono::millisec
 
     // Create texture for cursor
     D3D11_TEXTURE2D_DESC t {};
-    t.Width  = shape_info.Width;
-    t.Height = cursor_img.size() / data.SysMemPitch;
-    t.MipLevels = 1;
-    t.ArraySize = 1;
+    t.Width            = shape_info.Width;
+    t.Height           = cursor_img.size() / data.SysMemPitch;
+    t.MipLevels        = 1;
+    t.ArraySize        = 1;
     t.SampleDesc.Count = 1;
-    t.Usage = D3D11_USAGE_DEFAULT;
-    t.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
-    t.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+    t.Usage            = D3D11_USAGE_DEFAULT;
+    t.Format           = DXGI_FORMAT_B8G8R8A8_UNORM;
+    t.BindFlags        = D3D11_BIND_SHADER_RESOURCE;
 
     texture2d_t texture;
     auto status = device->CreateTexture2D(&t, &data, &texture);
@@ -734,14 +791,14 @@ std::shared_ptr<platf::img_t> display_vram_t::alloc_img() {
   auto img = std::make_shared<img_d3d_t>();
 
   D3D11_TEXTURE2D_DESC t {};
-  t.Width  = width;
-  t.Height = height;
-  t.MipLevels = 1;
-  t.ArraySize = 1;
+  t.Width            = width;
+  t.Height           = height;
+  t.MipLevels        = 1;
+  t.ArraySize        = 1;
   t.SampleDesc.Count = 1;
-  t.Usage = D3D11_USAGE_DEFAULT;
-  t.Format = format;
-  t.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+  t.Usage            = D3D11_USAGE_DEFAULT;
+  t.Format           = format;
+  t.BindFlags        = D3D11_BIND_SHADER_RESOURCE;
 
   auto status = device->CreateTexture2D(&t, nullptr, &img->texture);
   if(FAILED(status)) {
@@ -749,7 +806,7 @@ std::shared_ptr<platf::img_t> display_vram_t::alloc_img() {
     return nullptr;
   }
 
-  img->data        = (std::uint8_t*)img->texture.get();
+  img->data        = (std::uint8_t *)img->texture.get();
   img->row_pitch   = 0;
   img->pixel_pitch = 4;
   img->width       = 0;
@@ -760,24 +817,25 @@ std::shared_ptr<platf::img_t> display_vram_t::alloc_img() {
 }
 
 int display_vram_t::dummy_img(platf::img_t *img_base) {
-  auto img = (img_d3d_t*)img_base;
+  auto img = (img_d3d_t *)img_base;
 
-  img->row_pitch = width * 4;
+  img->row_pitch  = width * 4;
   auto dummy_data = std::make_unique<int[]>(width * height);
   D3D11_SUBRESOURCE_DATA data {
     dummy_data.get(),
     (UINT)img->row_pitch
   };
+  std::fill_n(dummy_data.get(), width * height, 0);
 
   D3D11_TEXTURE2D_DESC t {};
-  t.Width  = width;
-  t.Height = height;
-  t.MipLevels = 1;
-  t.ArraySize = 1;
+  t.Width            = width;
+  t.Height           = height;
+  t.MipLevels        = 1;
+  t.ArraySize        = 1;
   t.SampleDesc.Count = 1;
-  t.Usage = D3D11_USAGE_DEFAULT;
-  t.Format = format;
-  t.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+  t.Usage            = D3D11_USAGE_DEFAULT;
+  t.Format           = format;
+  t.BindFlags        = D3D11_BIND_SHADER_RESOURCE;
 
   dxgi::texture2d_t tex;
   auto status = device->CreateTexture2D(&t, &data, &tex);
@@ -787,7 +845,7 @@ int display_vram_t::dummy_img(platf::img_t *img_base) {
   }
 
   img->texture     = std::move(tex);
-  img->data        = (std::uint8_t*)img->texture.get();
+  img->data        = (std::uint8_t *)img->texture.get();
   img->height      = height;
   img->width       = width;
   img->pixel_pitch = 4;
@@ -795,7 +853,7 @@ int display_vram_t::dummy_img(platf::img_t *img_base) {
   return 0;
 }
 
-std::shared_ptr<platf::hwdevice_t> display_vram_t::make_hwdevice(int width, int height, pix_fmt_e pix_fmt) {
+std::shared_ptr<platf::hwdevice_t> display_vram_t::make_hwdevice(pix_fmt_e pix_fmt) {
   if(pix_fmt != platf::pix_fmt_e::nv12) {
     BOOST_LOG(error) << "display_vram_t doesn't support pixel format ["sv << from_pix_fmt(pix_fmt) << ']';
 
@@ -808,8 +866,6 @@ std::shared_ptr<platf::hwdevice_t> display_vram_t::make_hwdevice(int width, int
     shared_from_this(),
     device.get(),
     device_ctx.get(),
-    this->width, this->height,
-    width, height,
     pix_fmt);
 
   if(ret) {
@@ -826,15 +882,6 @@ std::shared_ptr<platf::hwdevice_t> display_vram_t::make_hwdevice(int width, int
 }
 
 int init() {
-  for(auto &color : colors) {
-    BOOST_LOG(debug) << "Color Matrix"sv;
-    BOOST_LOG(debug) << "Y ["sv << color.color_vec_y.x << ", "sv << color.color_vec_y.y << ", "sv << color.color_vec_y.z << ", "sv << color.color_vec_y.w << ']';
-    BOOST_LOG(debug) << "U ["sv << color.color_vec_u.x << ", "sv << color.color_vec_u.y << ", "sv << color.color_vec_u.z << ", "sv << color.color_vec_u.w << ']';
-    BOOST_LOG(debug) << "V ["sv << color.color_vec_v.x << ", "sv << color.color_vec_v.y << ", "sv << color.color_vec_v.z << ", "sv << color.color_vec_v.w << ']';
-    BOOST_LOG(debug) << "range Y  ["sv << color.range_y.x << ", "sv << color.range_y.y << ']';
-    BOOST_LOG(debug) << "range UV ["sv << color.range_uv.x << ", "sv << color.range_uv.y << ']';
-  }
-
   BOOST_LOG(info) << "Compiling shaders..."sv;
   scene_vs_hlsl = compile_vertex_shader(SUNSHINE_SHADERS_DIR "/SceneVS.hlsl");
   if(!scene_vs_hlsl) {
@@ -864,4 +911,4 @@ int init() {
 
   return 0;
 }
-}
+} // namespace platf::dxgi

sunshine/platform/windows/input.cpp

@@ -1,31 +1,23 @@
-#include <sstream>
-#include <iomanip>
-#include <cmath>
-
-#include <ws2tcpip.h>
-#include <winsock2.h>
 #include <windows.h>
-#include <winuser.h>
-#include <iphlpapi.h>
+
+#include <cmath>
 
 #include <ViGEm/Client.h>
 
+#include "misc.h"
 #include "sunshine/main.h"
 #include "sunshine/platform/common.h"
 
 namespace platf {
 using namespace std::literals;
 
-using adapteraddrs_t = util::c_ptr<IP_ADAPTER_ADDRESSES>;
+thread_local HDESK _lastKnownInputDesktop = nullptr;
 
-volatile HDESK _lastKnownInputDesktop = NULL;
 constexpr touch_port_t target_touch_port {
   0, 0,
   65535, 65535
 };
 
-HDESK pairInputDesktop();
-
 class vigem_t {
 public:
   using client_t = util::safe_ptr<_VIGEM_CLIENT_T, vigem_free>;
@@ -95,75 +87,10 @@ public:
   client_t client;
 };
 
-std::string from_sockaddr(const sockaddr *const socket_address) {
-  char data[INET6_ADDRSTRLEN];
-
-  auto family = socket_address->sa_family;
-  if(family == AF_INET6) {
-    inet_ntop(AF_INET6, &((sockaddr_in6*)socket_address)->sin6_addr, data, INET6_ADDRSTRLEN);
-  }
-
-  if(family == AF_INET) {
-    inet_ntop(AF_INET, &((sockaddr_in*)socket_address)->sin_addr, data, INET_ADDRSTRLEN);
-  }
-
-  return std::string { data };
-}
-
-std::pair<std::uint16_t, std::string> from_sockaddr_ex(const sockaddr *const ip_addr) {
-  char data[INET6_ADDRSTRLEN];
-
-  auto family = ip_addr->sa_family;
-  std::uint16_t port;
-  if(family == AF_INET6) {
-    inet_ntop(AF_INET6, &((sockaddr_in6*)ip_addr)->sin6_addr, data, INET6_ADDRSTRLEN);
-    port = ((sockaddr_in6*)ip_addr)->sin6_port;
-  }
-
-  if(family == AF_INET) {
-    inet_ntop(AF_INET, &((sockaddr_in*)ip_addr)->sin_addr, data, INET_ADDRSTRLEN);
-    port = ((sockaddr_in*)ip_addr)->sin_port;
-  }
-
-  return { port, std::string { data } };
-}
-
-adapteraddrs_t get_adapteraddrs() {
-  adapteraddrs_t info { nullptr };
-  ULONG size = 0;
-
-  while(GetAdaptersAddresses(AF_UNSPEC, 0, nullptr, info.get(), &size) == ERROR_BUFFER_OVERFLOW) {
-    info.reset((PIP_ADAPTER_ADDRESSES)malloc(size));
-  }
-
-  return info;
-}
-
-std::string get_mac_address(const std::string_view &address) {
-  adapteraddrs_t info = get_adapteraddrs();
-  for(auto adapter_pos = info.get(); adapter_pos != nullptr; adapter_pos = adapter_pos->Next) {
-    for(auto addr_pos = adapter_pos->FirstUnicastAddress; addr_pos != nullptr; addr_pos = addr_pos->Next) {
-      if(adapter_pos->PhysicalAddressLength != 0 && address == from_sockaddr(addr_pos->Address.lpSockaddr)) {
-        std::stringstream mac_addr;
-        mac_addr << std::hex;
-        for(int i = 0; i < adapter_pos->PhysicalAddressLength; i++) {
-          if(i > 0) {
-            mac_addr << ':';
-          }
-          mac_addr << std::setw(2) << std::setfill('0') << (int)adapter_pos->PhysicalAddress[i];
-        }
-        return mac_addr.str();
-      }
-    }
-  }
-  BOOST_LOG(warning) << "Unable to find MAC address for "sv << address;
-  return "00:00:00:00:00:00"s;
-}
-
 input_t input() {
   input_t result { new vigem_t {} };
 
-  auto vigem = (vigem_t*)result.get();
+  auto vigem = (vigem_t *)result.get();
   if(vigem->init()) {
     return nullptr;
   }
@@ -175,18 +102,18 @@ void send_input(INPUT &i) {
 retry:
   auto send = SendInput(1, &i, sizeof(INPUT));
   if(send != 1) {
-    auto hDesk = pairInputDesktop();
-    if (_lastKnownInputDesktop != hDesk) {
+    auto hDesk = syncThreadDesktop();
+    if(_lastKnownInputDesktop != hDesk) {
       _lastKnownInputDesktop = hDesk;
       goto retry;
     }
-    BOOST_LOG(warning) << "Couldn't send input"sv;
+    BOOST_LOG(error) << "Couldn't send input"sv;
   }
 }
 void abs_mouse(input_t &input, const touch_port_t &touch_port, float x, float y) {
   INPUT i {};
 
-  i.type = INPUT_MOUSE;
+  i.type   = INPUT_MOUSE;
   auto &mi = i.mi;
 
   mi.dwFlags =
@@ -208,13 +135,13 @@ void abs_mouse(input_t &input, const touch_port_t &touch_port, float x, float y)
 void move_mouse(input_t &input, int deltaX, int deltaY) {
   INPUT i {};
 
-  i.type = INPUT_MOUSE;
+  i.type   = INPUT_MOUSE;
   auto &mi = i.mi;
 
   mi.dwFlags = MOUSEEVENTF_MOVE;
-  mi.dx = deltaX;
-  mi.dy = deltaY;
-  
+  mi.dx      = deltaX;
+  mi.dy      = deltaY;
+
   send_input(i);
 }
 
@@ -223,34 +150,34 @@ void button_mouse(input_t &input, int button, bool release) {
 
   INPUT i {};
 
-  i.type = INPUT_MOUSE;
+  i.type   = INPUT_MOUSE;
   auto &mi = i.mi;
 
   int mouse_button;
   if(button == 1) {
-    mi.dwFlags = release ? MOUSEEVENTF_LEFTUP : MOUSEEVENTF_LEFTDOWN;
+    mi.dwFlags   = release ? MOUSEEVENTF_LEFTUP : MOUSEEVENTF_LEFTDOWN;
     mouse_button = VK_LBUTTON;
   }
   else if(button == 2) {
-    mi.dwFlags = release ? MOUSEEVENTF_MIDDLEUP : MOUSEEVENTF_MIDDLEDOWN;
+    mi.dwFlags   = release ? MOUSEEVENTF_MIDDLEUP : MOUSEEVENTF_MIDDLEDOWN;
     mouse_button = VK_MBUTTON;
   }
   else if(button == 3) {
-    mi.dwFlags = release ? MOUSEEVENTF_RIGHTUP : MOUSEEVENTF_RIGHTDOWN;
+    mi.dwFlags   = release ? MOUSEEVENTF_RIGHTUP : MOUSEEVENTF_RIGHTDOWN;
     mouse_button = VK_RBUTTON;
   }
   else if(button == 4) {
-    mi.dwFlags = release ? MOUSEEVENTF_XUP : MOUSEEVENTF_XDOWN;
+    mi.dwFlags   = release ? MOUSEEVENTF_XUP : MOUSEEVENTF_XDOWN;
     mi.mouseData = XBUTTON1;
     mouse_button = VK_XBUTTON1;
   }
   else {
-    mi.dwFlags = release ? MOUSEEVENTF_XUP : MOUSEEVENTF_XDOWN;
+    mi.dwFlags   = release ? MOUSEEVENTF_XUP : MOUSEEVENTF_XDOWN;
     mi.mouseData = XBUTTON2;
     mouse_button = VK_XBUTTON2;
   }
 
-  auto key_state = GetAsyncKeyState(mouse_button);
+  auto key_state      = GetAsyncKeyState(mouse_button);
   bool key_state_down = (key_state & KEY_STATE_DOWN) != 0;
   if(key_state_down != release) {
     BOOST_LOG(warning) << "Button state of mouse_button ["sv << button << "] does not match the desired state"sv;
@@ -264,27 +191,23 @@ void button_mouse(input_t &input, int button, bool release) {
 void scroll(input_t &input, int distance) {
   INPUT i {};
 
-  i.type = INPUT_MOUSE;
+  i.type   = INPUT_MOUSE;
   auto &mi = i.mi;
 
-  mi.dwFlags = MOUSEEVENTF_WHEEL;
+  mi.dwFlags   = MOUSEEVENTF_WHEEL;
   mi.mouseData = distance;
 
   send_input(i);
 }
 
 void keyboard(input_t &input, uint16_t modcode, bool release) {
-  if(modcode == VK_RMENU) {
-    modcode = VK_LWIN;
-  }
-
   INPUT i {};
-  i.type = INPUT_KEYBOARD;
+  i.type   = INPUT_KEYBOARD;
   auto &ki = i.ki;
 
   // For some reason, MapVirtualKey(VK_LWIN, MAPVK_VK_TO_VSC) doesn't seem to work :/
   if(modcode != VK_LWIN && modcode != VK_RWIN && modcode != VK_PAUSE) {
-    ki.wScan = MapVirtualKey(modcode, MAPVK_VK_TO_VSC);
+    ki.wScan   = MapVirtualKey(modcode, MAPVK_VK_TO_VSC);
     ki.dwFlags = KEYEVENTF_SCANCODE;
   }
   else {
@@ -293,23 +216,23 @@ void keyboard(input_t &input, uint16_t modcode, bool release) {
 
   // https://docs.microsoft.com/en-us/windows/win32/inputdev/about-keyboard-input#keystroke-message-flags
   switch(modcode) {
-    case VK_RMENU:
-    case VK_RCONTROL:
-    case VK_INSERT:
-    case VK_DELETE:
-    case VK_HOME:
-    case VK_END:
-    case VK_PRIOR:
-    case VK_NEXT:
-    case VK_UP:
-    case VK_DOWN:
-    case VK_LEFT:
-    case VK_RIGHT:
-    case VK_DIVIDE:
-      ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
-      break;
-    default:
-      break;
+  case VK_RMENU:
+  case VK_RCONTROL:
+  case VK_INSERT:
+  case VK_DELETE:
+  case VK_HOME:
+  case VK_END:
+  case VK_PRIOR:
+  case VK_NEXT:
+  case VK_UP:
+  case VK_DOWN:
+  case VK_LEFT:
+  case VK_RIGHT:
+  case VK_DIVIDE:
+    ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
+    break;
+  default:
+    break;
   }
 
   if(release) {
@@ -324,7 +247,7 @@ int alloc_gamepad(input_t &input, int nr) {
     return 0;
   }
 
-  return ((vigem_t*)input.get())->alloc_x360(nr);
+  return ((vigem_t *)input.get())->alloc_x360(nr);
 }
 
 void free_gamepad(input_t &input, int nr) {
@@ -332,7 +255,7 @@ void free_gamepad(input_t &input, int nr) {
     return;
   }
 
-  ((vigem_t*)input.get())->free_target(nr);
+  ((vigem_t *)input.get())->free_target(nr);
 }
 void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state) {
   // If there is no gamepad support
@@ -340,7 +263,7 @@ void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state) {
     return;
   }
 
-  auto vigem = (vigem_t*)input.get();
+  auto vigem = (vigem_t *)input.get();
 
   auto &xusb = *(PXUSB_REPORT)&gamepad_state;
   auto &x360 = vigem->x360s[nr];
@@ -354,31 +277,9 @@ void gamepad(input_t &input, int nr, const gamepad_state_t &gamepad_state) {
   }
 }
 
-int thread_priority()  {
-  return SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST) ? 0 : 1;
-}
-
-HDESK pairInputDesktop() {
-  auto hDesk = OpenInputDesktop(DF_ALLOWOTHERACCOUNTHOOK, FALSE, GENERIC_ALL);
-  if (NULL == hDesk) {
-    auto err = GetLastError();
-    BOOST_LOG(error) << "Failed to OpenInputDesktop [0x"sv << util::hex(err).to_string_view() << ']';
-  }
-  else {
-    BOOST_LOG(info) << std::endl << "Opened desktop [0x"sv << util::hex(hDesk).to_string_view() << ']';
-    if (!SetThreadDesktop(hDesk) ) {
-      auto err = GetLastError();
-      BOOST_LOG(error) << "Failed to SetThreadDesktop [0x"sv << util::hex(err).to_string_view() << ']';
-    }
-    CloseDesktop(hDesk);
-  }
-
-  return hDesk;
-}
-
 void freeInput(void *p) {
-  auto vigem = (vigem_t*)p;
+  auto vigem = (vigem_t *)p;
 
   delete vigem;
 }
-}
+} // namespace platf

sunshine/platform/windows/misc.cpp

@@ -0,0 +1,123 @@
+#include <filesystem>
+#include <iomanip>
+#include <sstream>
+
+
+// prevent clang format from "optimizing" the header include order
+// clang-format off
+#include <winsock2.h>
+#include <iphlpapi.h>
+#include <windows.h>
+#include <winuser.h>
+#include <ws2tcpip.h>
+// clang-format on
+
+#include "sunshine/main.h"
+#include "sunshine/utility.h"
+
+using namespace std::literals;
+namespace platf {
+using adapteraddrs_t = util::c_ptr<IP_ADAPTER_ADDRESSES>;
+
+std::filesystem::path appdata() {
+  return L"."sv;
+}
+
+std::string from_sockaddr(const sockaddr *const socket_address) {
+  char data[INET6_ADDRSTRLEN];
+
+  auto family = socket_address->sa_family;
+  if(family == AF_INET6) {
+    inet_ntop(AF_INET6, &((sockaddr_in6 *)socket_address)->sin6_addr, data, INET6_ADDRSTRLEN);
+  }
+
+  if(family == AF_INET) {
+    inet_ntop(AF_INET, &((sockaddr_in *)socket_address)->sin_addr, data, INET_ADDRSTRLEN);
+  }
+
+  return std::string { data };
+}
+
+std::pair<std::uint16_t, std::string> from_sockaddr_ex(const sockaddr *const ip_addr) {
+  char data[INET6_ADDRSTRLEN];
+
+  auto family = ip_addr->sa_family;
+  std::uint16_t port;
+  if(family == AF_INET6) {
+    inet_ntop(AF_INET6, &((sockaddr_in6 *)ip_addr)->sin6_addr, data, INET6_ADDRSTRLEN);
+    port = ((sockaddr_in6 *)ip_addr)->sin6_port;
+  }
+
+  if(family == AF_INET) {
+    inet_ntop(AF_INET, &((sockaddr_in *)ip_addr)->sin_addr, data, INET_ADDRSTRLEN);
+    port = ((sockaddr_in *)ip_addr)->sin_port;
+  }
+
+  return { port, std::string { data } };
+}
+
+adapteraddrs_t get_adapteraddrs() {
+  adapteraddrs_t info { nullptr };
+  ULONG size = 0;
+
+  while(GetAdaptersAddresses(AF_UNSPEC, 0, nullptr, info.get(), &size) == ERROR_BUFFER_OVERFLOW) {
+    info.reset((PIP_ADAPTER_ADDRESSES)malloc(size));
+  }
+
+  return info;
+}
+
+std::string get_mac_address(const std::string_view &address) {
+  adapteraddrs_t info = get_adapteraddrs();
+  for(auto adapter_pos = info.get(); adapter_pos != nullptr; adapter_pos = adapter_pos->Next) {
+    for(auto addr_pos = adapter_pos->FirstUnicastAddress; addr_pos != nullptr; addr_pos = addr_pos->Next) {
+      if(adapter_pos->PhysicalAddressLength != 0 && address == from_sockaddr(addr_pos->Address.lpSockaddr)) {
+        std::stringstream mac_addr;
+        mac_addr << std::hex;
+        for(int i = 0; i < adapter_pos->PhysicalAddressLength; i++) {
+          if(i > 0) {
+            mac_addr << ':';
+          }
+          mac_addr << std::setw(2) << std::setfill('0') << (int)adapter_pos->PhysicalAddress[i];
+        }
+        return mac_addr.str();
+      }
+    }
+  }
+  BOOST_LOG(warning) << "Unable to find MAC address for "sv << address;
+  return "00:00:00:00:00:00"s;
+}
+
+HDESK syncThreadDesktop() {
+  auto hDesk = OpenInputDesktop(DF_ALLOWOTHERACCOUNTHOOK, FALSE, GENERIC_ALL);
+  if(!hDesk) {
+    auto err = GetLastError();
+    BOOST_LOG(error) << "Failed to Open Input Desktop [0x"sv << util::hex(err).to_string_view() << ']';
+
+    return nullptr;
+  }
+
+  if(!SetThreadDesktop(hDesk)) {
+    auto err = GetLastError();
+    BOOST_LOG(error) << "Failed to sync desktop to thread [0x"sv << util::hex(err).to_string_view() << ']';
+  }
+
+  CloseDesktop(hDesk);
+
+  return hDesk;
+}
+
+void print_status(const std::string_view &prefix, HRESULT status) {
+  char err_string[1024];
+
+  DWORD bytes = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+    nullptr,
+    status,
+    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+    err_string,
+    sizeof(err_string),
+    nullptr);
+
+  BOOST_LOG(error) << prefix << ": "sv << std::string_view { err_string, bytes };
+}
+} // namespace platf

sunshine/platform/windows/misc.h

@@ -0,0 +1,13 @@
+#ifndef SUNSHINE_WINDOWS_MISC_H
+#define SUNSHINE_WINDOWS_MISC_H
+
+#include <windows.h>
+#include <winnt.h>
+#include <string_view>
+
+namespace platf {
+void print_status(const std::string_view &prefix, HRESULT status);
+HDESK syncThreadDesktop();
+}
+
+#endif

sunshine/platform/windows/publish.cpp

@@ -0,0 +1,180 @@
+#include <winsock2.h>
+
+#include <windows.h>
+
+#include <windns.h>
+#include <winerror.h>
+
+#include <boost/asio/ip/host_name.hpp>
+
+#include "misc.h"
+#include "sunshine/config.h"
+#include "sunshine/main.h"
+#include "sunshine/network.h"
+#include "sunshine/nvhttp.h"
+#include "sunshine/platform/common.h"
+#include "sunshine/thread_safe.h"
+
+
+using namespace std::literals;
+
+#define __SV(quote) L##quote##sv
+#define SV(quote) __SV(quote)
+
+extern "C" {
+constexpr auto DNS_REQUEST_PENDING        = 9506L;
+constexpr auto DNS_QUERY_REQUEST_VERSION1 = 0x1;
+constexpr auto DNS_QUERY_RESULTS_VERSION1 = 0x1;
+
+#define SERVICE_DOMAIN "local"
+
+constexpr auto SERVICE_INSTANCE_NAME = SV(SERVICE_NAME "." SERVICE_TYPE "." SERVICE_DOMAIN);
+constexpr auto SERVICE_TYPE_DOMAIN   = SV(SERVICE_TYPE "." SERVICE_DOMAIN);
+
+typedef struct _DNS_SERVICE_INSTANCE {
+  LPWSTR pszInstanceName;
+  LPWSTR pszHostName;
+
+  IP4_ADDRESS *ip4Address;
+  IP6_ADDRESS *ip6Address;
+
+  WORD wPort;
+  WORD wPriority;
+  WORD wWeight;
+
+  // Property list
+  DWORD dwPropertyCount;
+
+  PWSTR *keys;
+  PWSTR *values;
+
+  DWORD dwInterfaceIndex;
+} DNS_SERVICE_INSTANCE, *PDNS_SERVICE_INSTANCE;
+
+typedef VOID WINAPI DNS_SERVICE_REGISTER_COMPLETE(
+  _In_ DWORD Status,
+  _In_ PVOID pQueryContext,
+  _In_ PDNS_SERVICE_INSTANCE pInstance);
+
+typedef DNS_SERVICE_REGISTER_COMPLETE *PDNS_SERVICE_REGISTER_COMPLETE;
+
+typedef struct _DNS_SERVICE_CANCEL {
+  PVOID reserved;
+} DNS_SERVICE_CANCEL, *PDNS_SERVICE_CANCEL;
+
+typedef struct _DNS_SERVICE_REGISTER_REQUEST {
+  ULONG Version;
+  ULONG InterfaceIndex;
+  PDNS_SERVICE_INSTANCE pServiceInstance;
+  PDNS_SERVICE_REGISTER_COMPLETE pRegisterCompletionCallback;
+  PVOID pQueryContext;
+  HANDLE hCredentials;
+  BOOL unicastEnabled;
+} DNS_SERVICE_REGISTER_REQUEST, *PDNS_SERVICE_REGISTER_REQUEST;
+
+VOID DnsServiceFreeInstance(
+  _In_ PDNS_SERVICE_INSTANCE pInstance);
+
+DWORD DnsServiceDeRegister(
+  _In_ PDNS_SERVICE_REGISTER_REQUEST pRequest,
+  _Inout_opt_ PDNS_SERVICE_CANCEL pCancel);
+
+DWORD DnsServiceRegister(
+  _In_ PDNS_SERVICE_REGISTER_REQUEST pRequest,
+  _Inout_opt_ PDNS_SERVICE_CANCEL pCancel);
+
+PDNS_SERVICE_INSTANCE DnsServiceConstructInstance(
+  _In_ PCWSTR pServiceName,
+  _In_ PCWSTR pHostName,
+  _In_opt_ PIP4_ADDRESS pIp4,
+  _In_opt_ PIP6_ADDRESS pIp6,
+  _In_ WORD wPort,
+  _In_ WORD wPriority,
+  _In_ WORD wWeight,
+  _In_ DWORD dwPropertiesCount,
+  _In_reads_(dwPropertiesCount) PCWSTR *keys,
+  _In_reads_(dwPropertiesCount) PCWSTR *values);
+} /* extern "C" */
+
+namespace platf::publish {
+VOID WINAPI register_cb(DWORD status, PVOID pQueryContext, PDNS_SERVICE_INSTANCE pInstance) {
+  auto alarm = (safe::alarm_t<DNS_STATUS>::element_type *)pQueryContext;
+
+  auto fg = util::fail_guard([&]() {
+    if(pInstance) {
+      DnsServiceFreeInstance(pInstance);
+    }
+  });
+
+  if(status) {
+    print_status("register_cb()"sv, status);
+    alarm->ring(-1);
+
+    return;
+  }
+
+  alarm->ring(0);
+}
+
+static int service(bool enable) {
+  auto alarm = safe::make_alarm<DNS_STATUS>();
+
+  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> converter;
+
+  std::wstring name { SERVICE_INSTANCE_NAME.data(), SERVICE_INSTANCE_NAME.size() };
+  std::wstring domain { SERVICE_TYPE_DOMAIN.data(), SERVICE_TYPE_DOMAIN.size() };
+
+  auto host = converter.from_bytes(boost::asio::ip::host_name() + ".local");
+
+  DNS_SERVICE_INSTANCE instance {};
+  instance.pszInstanceName = name.data();
+  instance.wPort           = map_port(nvhttp::PORT_HTTP);
+  instance.pszHostName     = host.data();
+
+  DNS_SERVICE_REGISTER_REQUEST req {};
+  req.Version                     = DNS_QUERY_REQUEST_VERSION1;
+  req.pQueryContext               = alarm.get();
+  req.pServiceInstance            = &instance;
+  req.pRegisterCompletionCallback = register_cb;
+
+  DNS_STATUS status {};
+
+  if(enable) {
+    status = DnsServiceRegister(&req, nullptr);
+  }
+  else {
+    status = DnsServiceDeRegister(&req, nullptr);
+  }
+
+  alarm->wait();
+
+  status = *alarm->status();
+  if(status) {
+    BOOST_LOG(error) << "No mDNS service"sv;
+    return -1;
+  }
+
+  return 0;
+}
+
+class deinit_t : public ::platf::deinit_t {
+public:
+  ~deinit_t() override {
+    if(service(false)) {
+      std::abort();
+    }
+
+    BOOST_LOG(info) << "Unregistered Sunshine Gamestream service"sv;
+  }
+};
+
+std::unique_ptr<::platf::deinit_t> start() {
+  if(service(true)) {
+    return nullptr;
+  }
+
+  BOOST_LOG(info) << "Registered Sunshine Gamestream service"sv;
+
+  return std::make_unique<deinit_t>();
+}
+} // namespace platf::publish

sunshine/process.cpp

@@ -2,16 +2,18 @@
 // Created by loki on 12/14/19.
 //
 
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
+
 #include "process.h"
 
-#include <vector>
 #include <string>
+#include <vector>
 
-#include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/json_parser.hpp>
+#include <boost/property_tree/ptree.hpp>
 
-#include "utility.h"
 #include "main.h"
+#include "utility.h"
 
 namespace proc {
 using namespace std::literals;
@@ -57,11 +59,11 @@ int proc_t::execute(int app_id) {
   // Ensure starting from a clean slate
   terminate();
 
-  _app_id = app_id;
+  _app_id    = app_id;
   auto &proc = _apps[app_id];
 
   _undo_begin = std::begin(proc.prep_cmds);
-  _undo_it = _undo_begin;
+  _undo_it    = _undo_begin;
 
   if(!proc.output.empty() && proc.output != "null"sv) {
     _pipe.reset(fopen(proc.output.c_str(), "a"));
@@ -147,7 +149,7 @@ void proc_t::terminate() {
     std::abort();
   }
 
-  for(;_undo_it != _undo_begin; --_undo_it) {
+  for(; _undo_it != _undo_begin; --_undo_it) {
     auto &cmd = (_undo_it - 1)->undo_cmd;
 
     if(cmd.empty()) {
@@ -192,9 +194,11 @@ std::string_view::iterator find_match(std::string_view::iterator begin, std::str
   do {
     ++begin;
     switch(*begin) {
-      case '(': ++stack;
+    case '(':
+      ++stack;
       break;
-      case ')': --stack;
+    case ')':
+      --stack;
     }
   } while(begin != end && stack != 0);
 
@@ -205,7 +209,7 @@ std::string_view::iterator find_match(std::string_view::iterator begin, std::str
 }
 
 std::string parse_env_val(bp::native_environment &env, const std::string_view &val_raw) {
-  auto pos = std::begin(val_raw);
+  auto pos    = std::begin(val_raw);
   auto dollar = std::find(pos, std::end(val_raw), '$');
 
   std::stringstream ss;
@@ -214,23 +218,23 @@ std::string parse_env_val(bp::native_environment &env, const std::string_view &v
     auto next = dollar + 1;
     if(next != std::end(val_raw)) {
       switch(*next) {
-        case '(': {
-          ss.write(pos, (dollar - pos));
-          auto var_begin = next + 1;
-          auto var_end   = find_match(next, std::end(val_raw));
+      case '(': {
+        ss.write(pos, (dollar - pos));
+        auto var_begin = next + 1;
+        auto var_end   = find_match(next, std::end(val_raw));
 
-          ss << env[std::string { var_begin, var_end }].to_string();
+        ss << env[std::string { var_begin, var_end }].to_string();
 
-          pos = var_end + 1;
-          next = var_end;
+        pos  = var_end + 1;
+        next = var_end;
 
-          break;
-        }
-        case '$':
-          ss.write(pos, (next - pos));
-          pos = next + 1;
-          ++next;
-          break;
+        break;
+      }
+      case '$':
+        ss.write(pos, (next - pos));
+        pos = next + 1;
+        ++next;
+        break;
       }
 
       dollar = std::find(next, std::end(val_raw), '$');
@@ -245,7 +249,7 @@ std::string parse_env_val(bp::native_environment &env, const std::string_view &v
   return ss.str();
 }
 
-std::optional<proc::proc_t> parse(const std::string& file_name) {
+std::optional<proc::proc_t> parse(const std::string &file_name) {
   pt::ptree tree;
 
   try {
@@ -256,19 +260,19 @@ std::optional<proc::proc_t> parse(const std::string& file_name) {
 
     auto this_env = boost::this_process::environment();
 
-    for(auto &[name,val] : env_vars) {
+    for(auto &[name, val] : env_vars) {
       this_env[name] = parse_env_val(this_env, val.get_value<std::string>());
     }
 
     std::vector<proc::ctx_t> apps;
-    for(auto &[_,app_node] : apps_node) {
+    for(auto &[_, app_node] : apps_node) {
       proc::ctx_t ctx;
 
-      auto prep_nodes_opt = app_node.get_child_optional("prep-cmd"s);
+      auto prep_nodes_opt     = app_node.get_child_optional("prep-cmd"s);
       auto detached_nodes_opt = app_node.get_child_optional("detached"s);
-      auto output = app_node.get_optional<std::string>("output"s);
-      auto name = parse_env_val(this_env, app_node.get<std::string>("name"s));
-      auto cmd = app_node.get_optional<std::string>("cmd"s);
+      auto output             = app_node.get_optional<std::string>("output"s);
+      auto name               = parse_env_val(this_env, app_node.get<std::string>("name"s));
+      auto cmd                = app_node.get_optional<std::string>("cmd"s);
 
       std::vector<proc::cmd_t> prep_cmds;
       if(prep_nodes_opt) {
@@ -276,7 +280,7 @@ std::optional<proc::proc_t> parse(const std::string& file_name) {
 
         prep_cmds.reserve(prep_nodes.size());
         for(auto &[_, prep_node] : prep_nodes) {
-          auto do_cmd = parse_env_val(this_env, prep_node.get<std::string>("do"s));
+          auto do_cmd   = parse_env_val(this_env, prep_node.get<std::string>("do"s));
           auto undo_cmd = prep_node.get_optional<std::string>("undo"s);
 
           if(undo_cmd) {
@@ -306,9 +310,9 @@ std::optional<proc::proc_t> parse(const std::string& file_name) {
         ctx.cmd = parse_env_val(this_env, *cmd);
       }
 
-      ctx.name = std::move(name);
+      ctx.name      = std::move(name);
       ctx.prep_cmds = std::move(prep_cmds);
-      ctx.detached = std::move(detached);
+      ctx.detached  = std::move(detached);
 
       apps.emplace_back(std::move(ctx));
     }
@@ -316,7 +320,8 @@ std::optional<proc::proc_t> parse(const std::string& file_name) {
     return proc::proc_t {
       std::move(this_env), std::move(apps)
     };
-  } catch (std::exception &e) {
+  }
+  catch(std::exception &e) {
     BOOST_LOG(error) << e.what();
   }
 
@@ -327,7 +332,12 @@ void refresh(const std::string &file_name) {
   auto proc_opt = proc::parse(file_name);
 
   if(proc_opt) {
+    {
+      proc::ctx_t ctx;
+      ctx.name = "Desktop"s;
+      proc_opt->get_apps().emplace(std::begin(proc_opt->get_apps()), std::move(ctx));
+    }
     proc = std::move(*proc_opt);
   }
 }
-}
+} // namespace proc

sunshine/process.h

@@ -9,8 +9,8 @@
 #define __kernel_entry
 #endif
 
-#include <unordered_map>
 #include <optional>
+#include <unordered_map>
 
 #include <boost/process.hpp>
 
@@ -61,10 +61,9 @@ public:
 
   proc_t(
     boost::process::environment &&env,
-    std::vector<ctx_t> &&apps) :
-    _app_id(-1),
-    _env(std::move(env)),
-    _apps(std::move(apps)) {}
+    std::vector<ctx_t> &&apps) : _app_id(-1),
+                                 _env(std::move(env)),
+                                 _apps(std::move(apps)) {}
 
   int execute(int app_id);
 
@@ -77,7 +76,7 @@ public:
 
   const std::vector<ctx_t> &get_apps() const;
   std::vector<ctx_t> &get_apps();
-  
+
   void terminate();
 
 private:
@@ -98,8 +97,8 @@ private:
 };
 
 void refresh(const std::string &file_name);
-std::optional<proc::proc_t> parse(const std::string& file_name);
+std::optional<proc::proc_t> parse(const std::string &file_name);
 
 extern proc_t proc;
-}
+} // namespace proc
 #endif //SUNSHINE_PROCESS_H

sunshine/round_robin.h

@@ -10,12 +10,12 @@ public:
   typedef T iterator;
   typedef typename std::iterator<std::random_access_iterator_tag, V>::value_type class_t;
 
-  typedef class_t& reference;
-  typedef class_t* pointer;
+  typedef class_t &reference;
+  typedef class_t *pointer;
 
   typedef std::ptrdiff_t diff_t;
 
-  iterator operator += (diff_t step) {
+  iterator operator+=(diff_t step) {
     while(step-- > 0) {
       ++_this();
     }
@@ -23,7 +23,7 @@ public:
     return _this();
   }
 
-  iterator operator -= (diff_t step) {
+  iterator operator-=(diff_t step) {
     while(step-- > 0) {
       --_this();
     }
@@ -31,19 +31,19 @@ public:
     return _this();
   }
 
-  iterator operator +(diff_t step) {
+  iterator operator+(diff_t step) {
     iterator new_ = _this();
 
     return new_ += step;
   }
 
-  iterator operator -(diff_t step) {
+  iterator operator-(diff_t step) {
     iterator new_ = _this();
 
     return new_ -= step;
   }
 
-  diff_t operator -(iterator first) {
+  diff_t operator-(iterator first) {
     diff_t step = 0;
     while(first != _this()) {
       ++step;
@@ -53,8 +53,14 @@ public:
     return step;
   }
 
-  iterator operator++() { _this().inc(); return _this(); }
-  iterator operator--() { _this().dec(); return _this(); }
+  iterator operator++() {
+    _this().inc();
+    return _this();
+  }
+  iterator operator--() {
+    _this().dec();
+    return _this();
+  }
 
   iterator operator++(int) {
     iterator new_ = _this();
@@ -78,35 +84,35 @@ public:
   pointer operator->() { return &*_this(); }
   const pointer operator->() const { return &*_this(); }
 
-  bool operator != (const iterator &other) const {
+  bool operator!=(const iterator &other) const {
     return !(_this() == other);
   }
 
-  bool operator < (const iterator &other) const {
+  bool operator<(const iterator &other) const {
     return !(_this() >= other);
   }
 
-  bool operator >= (const iterator &other) const {
+  bool operator>=(const iterator &other) const {
     return _this() == other || _this() > other;
   }
 
-  bool operator <= (const iterator &other) const {
+  bool operator<=(const iterator &other) const {
     return _this() == other || _this() < other;
   }
 
-  bool operator == (const iterator &other) const { return _this().eq(other); };
-  bool operator > (const iterator &other) const { return _this().gt(other); }
-private:
+  bool operator==(const iterator &other) const { return _this().eq(other); };
+  bool operator>(const iterator &other) const { return _this().gt(other); }
 
-  iterator &_this() { return *static_cast<iterator*>(this); }
-  const iterator &_this() const { return *static_cast<const iterator*>(this); }
+private:
+  iterator &_this() { return *static_cast<iterator *>(this); }
+  const iterator &_this() const { return *static_cast<const iterator *>(this); }
 };
 
 template<class V, class It>
 class round_robin_t : public it_wrap_t<V, round_robin_t<V, It>> {
 public:
   using iterator = It;
-  using pointer = V*;
+  using pointer  = V *;
 
   round_robin_t(iterator begin, iterator end) : _begin(begin), _end(end), _pos(begin) {}
 
@@ -119,10 +125,10 @@ public:
   }
 
   void dec() {
-    if(_pos == _begin)  {
+    if(_pos == _begin) {
       _pos = _end;
     }
-    
+
     --_pos;
   }
 
@@ -133,6 +139,7 @@ public:
   pointer get() const {
     return &*_pos;
   }
+
 private:
   It _begin;
   It _end;
@@ -144,6 +151,6 @@ template<class V, class It>
 round_robin_t<V, It> make_round_robin(It begin, It end) {
   return round_robin_t<V, It>(begin, end);
 }
-}
+} // namespace util
 
 #endif

sunshine/rtsp.cpp

@@ -2,15 +2,23 @@
 // Created by loki on 2/2/20.
 //
 
+#define BOOST_BIND_GLOBAL_PLACEHOLDERS
+
 extern "C" {
 #include <moonlight-common-c/src/Rtsp.h>
 }
 
+#include <array>
+#include <cctype>
+
+#include <boost/asio.hpp>
+#include <boost/bind.hpp>
+
 #include "config.h"
+#include "input.h"
 #include "main.h"
 #include "network.h"
 #include "rtsp.h"
-#include "input.h"
 #include "stream.h"
 #include "sync.h"
 
@@ -22,17 +30,6 @@ using asio::ip::udp;
 using namespace std::literals;
 
 namespace stream {
-
-//FIXME: Quick and dirty workaround for bug in MinGW 9.3 causing a linker error when using std::to_string
-template<class T>
-std::string to_string(T && t)	{
-  std::stringstream ss;
-  ss << std::forward<T>(t);
-  return ss.str();
-}
-
-constexpr auto RTSP_SETUP_PORT = 48010;
-
 void free_msg(PRTSP_MESSAGE msg) {
   freeMessage(msg);
 
@@ -41,21 +38,181 @@ void free_msg(PRTSP_MESSAGE msg) {
 
 class rtsp_server_t;
 
-using msg_t = util::safe_ptr<RTSP_MESSAGE, free_msg>;
-using cmd_func_t = std::function<void(rtsp_server_t*, net::peer_t, msg_t&&)>;
+using msg_t      = util::safe_ptr<RTSP_MESSAGE, free_msg>;
+using cmd_func_t = std::function<void(rtsp_server_t *server, tcp::socket &, msg_t &&)>;
 
 void print_msg(PRTSP_MESSAGE msg);
-void cmd_not_found(net::host_t::pointer host, net::peer_t peer, msg_t&& req);
+void cmd_not_found(tcp::socket &sock, msg_t &&req);
+void respond(tcp::socket &sock, POPTION_ITEM options, int statuscode, const char *status_msg, int seqn, const std::string_view &payload);
+
+class socket_t : public std::enable_shared_from_this<socket_t> {
+public:
+  socket_t(boost::asio::io_service &ios, std::function<void(tcp::socket &sock, msg_t &&)> &&handle_data_fn)
+      : handle_data_fn { std::move(handle_data_fn) }, sock { ios } {}
+
+  void read() {
+    if(begin == std::end(msg_buf)) {
+      BOOST_LOG(error) << "RTSP: read(): Exceeded maximum rtsp packet size: "sv << msg_buf.size();
+
+      respond(sock, nullptr, 400, "BAD REQUEST", 0, {});
+
+      sock.close();
+
+      return;
+    }
+
+    sock.async_read_some(
+      boost::asio::buffer(begin, (std::size_t)(std::end(msg_buf) - begin)),
+      boost::bind(
+        &socket_t::handle_read, shared_from_this(),
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred));
+  }
+
+  void read_payload() {
+    if(begin == std::end(msg_buf)) {
+      BOOST_LOG(error) << "RTSP: read_payload(): Exceeded maximum rtsp packet size: "sv << msg_buf.size();
+
+      respond(sock, nullptr, 400, "BAD REQUEST", 0, {});
+
+      sock.close();
+
+      return;
+    }
+
+    sock.async_read_some(
+      boost::asio::buffer(begin, (std::size_t)(std::end(msg_buf) - begin)),
+      boost::bind(
+        &socket_t::handle_payload, shared_from_this(),
+        boost::asio::placeholders::error,
+        boost::asio::placeholders::bytes_transferred));
+  }
+
+  static void handle_payload(std::shared_ptr<socket_t> &socket, const boost::system::error_code &ec, std::size_t bytes) {
+    BOOST_LOG(debug) << "handle_payload(): Handle read of size: "sv << bytes << " bytes"sv;
+
+    auto sock_close = util::fail_guard([&socket]() {
+      boost::system::error_code ec;
+      socket->sock.close(ec);
+
+      if(ec) {
+        BOOST_LOG(error) << "RTSP: handle_payload(): Couldn't close tcp socket: "sv << ec.message();
+      }
+    });
+
+    if(ec) {
+      BOOST_LOG(error) << "RTSP: handle_payload(): Couldn't read from tcp socket: "sv << ec.message();
+
+      return;
+    }
+
+    auto end = socket->begin + bytes;
+    msg_t req { new msg_t::element_type {} };
+    if(auto status = parseRtspMessage(req.get(), socket->msg_buf.data(), (std::size_t)(end - socket->msg_buf.data()))) {
+      BOOST_LOG(error) << "Malformed RTSP message: ["sv << status << ']';
+
+      respond(socket->sock, nullptr, 400, "BAD REQUEST", req->sequenceNumber, {});
+      return;
+    }
+
+    sock_close.disable();
+
+    auto fg = util::fail_guard([&socket]() {
+      socket->read_payload();
+    });
+
+    auto content_lenght = 0;
+    for(auto option = req->options; option != nullptr; option = option->next) {
+      if("Content-length"sv == option->option) {
+        BOOST_LOG(debug) << "Found Content-Length: "sv << option->content << " bytes"sv;
+
+        // If content_length > bytes read, then we need to store current data read,
+        // to be appended by the next read.
+        std::string_view content { option->content };
+        auto begin = std::find_if(std::begin(content), std::end(content), [](auto ch) { return (bool)std::isdigit(ch); });
+
+        content_lenght = util::from_chars(begin, std::end(content));
+        break;
+      }
+    }
+
+    if(end - socket->crlf >= content_lenght) {
+      if(end - socket->crlf > content_lenght) {
+        BOOST_LOG(warning) << "(end - socket->crlf) > content_lenght -- "sv << (std::size_t)(end - socket->crlf) << " > "sv << content_lenght;
+      }
+
+      fg.disable();
+      print_msg(req.get());
+
+      socket->handle_data(std::move(req));
+    }
+
+    socket->begin = end;
+  }
+
+  static void handle_read(std::shared_ptr<socket_t> &socket, const boost::system::error_code &ec, std::size_t bytes) {
+    BOOST_LOG(debug) << "handle_read(): Handle read of size: "sv << bytes << " bytes"sv;
+
+    if(ec) {
+      BOOST_LOG(error) << "RTSP: handle_read(): Couldn't read from tcp socket: "sv << ec.message();
+
+      boost::system::error_code ec;
+      socket->sock.close(ec);
+
+      if(ec) {
+        BOOST_LOG(error) << "RTSP: handle_read(): Couldn't close tcp socket: "sv << ec.message();
+      }
+
+      return;
+    }
+
+    auto fg = util::fail_guard([&socket]() {
+      socket->read();
+    });
+
+    auto begin    = std::max(socket->begin - 4, socket->begin);
+    auto buf_size = bytes + (begin - socket->begin);
+    auto end      = begin + buf_size;
+
+    constexpr auto needle = "\r\n\r\n"sv;
+
+    auto it = std::search(begin, begin + buf_size, std::begin(needle), std::end(needle));
+    if(it == end) {
+      socket->begin = end;
+
+      return;
+    }
+
+    // Emulate read completion for payload data
+    socket->begin = it + needle.size();
+    socket->crlf  = socket->begin;
+    buf_size      = end - socket->begin;
+
+    fg.disable();
+    handle_payload(socket, ec, buf_size);
+  }
+
+  void handle_data(msg_t &&req) {
+    handle_data_fn(sock, std::move(req));
+  }
+
+  std::function<void(tcp::socket &sock, msg_t &&)> handle_data_fn;
+
+  tcp::socket sock;
+
+  std::array<char, 2048> msg_buf;
+
+  char *crlf;
+  char *begin = msg_buf.data();
+};
 
 class rtsp_server_t {
 public:
   ~rtsp_server_t() {
-    if(_host) {
-      clear();
-    }
+    clear();
   }
 
-  int bind(std::uint16_t port) {
+  int bind(std::uint16_t port, boost::system::error_code &ec) {
     {
       auto lg = _session_slots.lock();
 
@@ -63,12 +220,76 @@ public:
       _slot_count = config::stream.channels;
     }
 
-    _host = net::host_create(_addr, 1, port);
+    acceptor.open(tcp::v4(), ec);
+    if(ec) {
+      return -1;
+    }
 
-    return !(bool)_host;
+    acceptor.set_option(boost::asio::socket_base::reuse_address { true });
+
+    acceptor.bind(tcp::endpoint(tcp::v4(), port), ec);
+    if(ec) {
+      return -1;
+    }
+
+    acceptor.listen(4096, ec);
+    if(ec) {
+      return -1;
+    }
+
+    next_socket = std::make_shared<socket_t>(ios, [this](tcp::socket &sock, msg_t &&msg) {
+      handle_msg(sock, std::move(msg));
+    });
+
+    acceptor.async_accept(next_socket->sock, [this](const auto &ec) {
+      handle_accept(ec);
+    });
+
+    return 0;
+  }
+
+  template<class T, class X>
+  void iterate(std::chrono::duration<T, X> timeout) {
+    ios.run_one_for(timeout);
+  }
+
+  void handle_msg(tcp::socket &sock, msg_t &&req) {
+    auto func = _map_cmd_cb.find(req->message.request.command);
+    if(func != std::end(_map_cmd_cb)) {
+      func->second(this, sock, std::move(req));
+    }
+    else {
+      cmd_not_found(sock, std::move(req));
+    }
+  }
+
+  void handle_accept(const boost::system::error_code &ec) {
+    if(ec) {
+      BOOST_LOG(error) << "Couldn't accept incoming connections: "sv << ec.message();
+
+      //Stop server
+      clear();
+      return;
+    }
+
+    auto socket = std::move(next_socket);
+    socket->read();
+
+    next_socket = std::make_shared<socket_t>(ios, [this](tcp::socket &sock, msg_t &&msg) {
+      handle_msg(sock, std::move(msg));
+    });
+
+    acceptor.async_accept(next_socket->sock, [this](const auto &ec) {
+      handle_accept(ec);
+    });
+  }
+
+  void map(const std::string_view &type, cmd_func_t cb) {
+    _map_cmd_cb.emplace(type, std::move(cb));
   }
 
   void session_raise(launch_session_t launch_session) {
+    //FIXME: If client abandons us at this stage, _slot_count won't be raised again.
     --_slot_count;
     launch_event.raise(launch_session);
   }
@@ -77,79 +298,13 @@ public:
     return config::stream.channels - _slot_count;
   }
 
-  template<class T, class X>
-  void iterate(std::chrono::duration<T, X> timeout) {
-    ENetEvent event;
-    auto res = enet_host_service(_host.get(), &event, std::chrono::floor<std::chrono::milliseconds>(timeout).count());
-
-    if (res > 0) {
-      switch (event.type) {
-        case ENET_EVENT_TYPE_RECEIVE: {
-          net::packet_t packet{event.packet};
-          net::peer_t peer{event.peer};
-
-          msg_t req { new msg_t::element_type };
-
-          //TODO: compare addresses of the peers
-          if (_queue_packet.second == nullptr) {
-            parseRtspMessage(req.get(), (char *) packet->data, packet->dataLength);
-            for (auto option = req->options; option != nullptr; option = option->next) {
-              if ("Content-length"sv == option->option) {
-                _queue_packet = std::make_pair(peer, std::move(packet));
-                return;
-              }
-            }
-          }
-          else {
-            std::vector<char> full_payload;
-
-            auto old_msg = std::move(_queue_packet);
-            auto &old_packet = old_msg.second;
-
-            std::string_view new_payload{(char *) packet->data, packet->dataLength};
-            std::string_view old_payload{(char *) old_packet->data, old_packet->dataLength};
-            full_payload.resize(new_payload.size() + old_payload.size());
-
-            std::copy(std::begin(old_payload), std::end(old_payload), std::begin(full_payload));
-            std::copy(std::begin(new_payload), std::end(new_payload), std::begin(full_payload) + old_payload.size());
-
-            parseRtspMessage(req.get(), full_payload.data(), full_payload.size());
-          }
-
-          print_msg(req.get());
-
-          msg_t resp;
-          auto func = _map_cmd_cb.find(req->message.request.command);
-          if (func != std::end(_map_cmd_cb)) {
-            func->second(this, peer, std::move(req));
-          }
-          else {
-            cmd_not_found(host(), peer, std::move(req));
-          }
-
-          return;
-        }
-        case ENET_EVENT_TYPE_CONNECT:
-          BOOST_LOG(info) << "CLIENT CONNECTED TO RTSP"sv;
-          break;
-        case ENET_EVENT_TYPE_DISCONNECT:
-          BOOST_LOG(info) << "CLIENT DISCONNECTED FROM RTSP"sv;
-          break;
-        case ENET_EVENT_TYPE_NONE:
-          break;
-      }
-    }
-  }
-
-  void map(const std::string_view &type, cmd_func_t cb) {
-    _map_cmd_cb.emplace(type, std::move(cb));
-  }
+  safe::event_t<launch_session_t> launch_event;
 
   void clear(bool all = true) {
     auto lg = _session_slots.lock();
 
     for(auto &slot : *_session_slots) {
-      if (slot && (all || session::state(*slot) == session::state_e::STOPPING)) {
+      if(slot && (all || session::state(*slot) == session::state_e::STOPPING)) {
         session::stop(*slot);
         session::join(*slot);
 
@@ -159,10 +314,8 @@ public:
       }
     }
 
-    if(all) {
-      std::for_each(_host->peers, _host->peers + _host->peerCount, [](auto &peer) {
-        enet_peer_disconnect_now(&peer, 0);
-      });
+    if(all && !ios.stopped()) {
+      ios.stop();
     }
   }
 
@@ -187,25 +340,17 @@ public:
     return nullptr;
   }
 
-  net::host_t::pointer host() const {
-    return _host.get();
-  }
-
-  safe::event_t<launch_session_t> launch_event;
-
 private:
-
-  // named _queue_packet because I want to make it an actual queue
-  // It's like this for convenience sake
-  std::pair<net::peer_t, net::packet_t> _queue_packet;
-
   std::unordered_map<std::string_view, cmd_func_t> _map_cmd_cb;
 
   util::sync_t<std::vector<std::shared_ptr<session_t>>> _session_slots;
 
   int _slot_count;
-  ENetAddress _addr;
-  net::host_t _host;
+
+  boost::asio::io_service ios;
+  tcp::acceptor acceptor { ios };
+
+  std::shared_ptr<socket_t> next_socket;
 };
 
 rtsp_server_t server;
@@ -221,15 +366,32 @@ int session_count() {
   return server.session_count();
 }
 
-void respond(net::host_t::pointer host, net::peer_t peer, msg_t &resp) {
+int send(tcp::socket &sock, const std::string_view &sv) {
+  std::size_t bytes_send = 0;
+
+  while(bytes_send != sv.size()) {
+    boost::system::error_code ec;
+    bytes_send += sock.send(boost::asio::buffer(sv.substr(bytes_send)), 0, ec);
+
+    if(ec) {
+      BOOST_LOG(error) << "RTSP: Couldn't send data over tcp socket: "sv << ec.message();
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+void respond(tcp::socket &sock, msg_t &resp) {
   auto payload = std::make_pair(resp->payload, resp->payloadLength);
 
+  // Restore response message for proper destruction
   auto lg = util::fail_guard([&]() {
-    resp->payload = payload.first;
+    resp->payload       = payload.first;
     resp->payloadLength = payload.second;
   });
 
-  resp->payload = nullptr;
+  resp->payload       = nullptr;
   resp->payloadLength = 0;
 
   int serialized_len;
@@ -241,114 +403,144 @@ void respond(net::host_t::pointer host, net::peer_t peer, msg_t &resp) {
     << "---End Response---"sv << std::endl;
 
   std::string_view tmp_resp { raw_resp.get(), (size_t)serialized_len };
-  {
-    auto packet = enet_packet_create(tmp_resp.data(), tmp_resp.size(), ENET_PACKET_FLAG_RELIABLE);
-    if(enet_peer_send(peer, 0, packet)) {
-      enet_packet_destroy(packet);
-      return;
-    }
 
-    enet_host_flush(host);
+  if(send(sock, tmp_resp)) {
+    return;
   }
 
-  if(payload.second > 0) {
-    auto packet = enet_packet_create(payload.first, payload.second, ENET_PACKET_FLAG_RELIABLE);
-    if(enet_peer_send(peer, 0, packet)) {
-      enet_packet_destroy(packet);
-      return;
-    }
-
-    enet_host_flush(host);
-  }
+  send(sock, std::string_view { payload.first, (std::size_t)payload.second });
 }
 
-void respond(net::host_t::pointer host, net::peer_t peer, POPTION_ITEM options, int statuscode, const char *status_msg, int seqn, const std::string_view &payload) {
+void respond(tcp::socket &sock, POPTION_ITEM options, int statuscode, const char *status_msg, int seqn, const std::string_view &payload) {
   msg_t resp { new msg_t::element_type };
-  createRtspResponse(resp.get(), nullptr, 0, const_cast<char*>("RTSP/1.0"), statuscode, const_cast<char*>(status_msg), seqn, options, const_cast<char*>(payload.data()), (int)payload.size());
+  createRtspResponse(resp.get(), nullptr, 0, const_cast<char *>("RTSP/1.0"), statuscode, const_cast<char *>(status_msg), seqn, options, const_cast<char *>(payload.data()), (int)payload.size());
 
-  respond(host, peer, resp);
+  respond(sock, resp);
 }
 
-void cmd_not_found(net::host_t::pointer host, net::peer_t peer, msg_t&& req) {
-  respond(host, peer, nullptr, 404, "NOT FOUND", req->sequenceNumber, {});
+void cmd_not_found(tcp::socket &sock, msg_t &&req) {
+  respond(sock, nullptr, 404, "NOT FOUND", req->sequenceNumber, {});
 }
 
-void cmd_option(rtsp_server_t *server, net::peer_t peer, msg_t&& req) {
+void cmd_option(rtsp_server_t *server, tcp::socket &sock, msg_t &&req) {
   OPTION_ITEM option {};
 
   // I know these string literals will not be modified
-  option.option = const_cast<char*>("CSeq");
+  option.option = const_cast<char *>("CSeq");
 
-  auto seqn_str = to_string(req->sequenceNumber);
-  option.content = const_cast<char*>(seqn_str.c_str());
+  auto seqn_str  = std::to_string(req->sequenceNumber);
+  option.content = const_cast<char *>(seqn_str.c_str());
 
-  respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, {});
+  respond(sock, &option, 200, "OK", req->sequenceNumber, {});
 }
 
-void cmd_describe(rtsp_server_t *server, net::peer_t peer, msg_t&& req) {
+void cmd_describe(rtsp_server_t *server, tcp::socket &sock, msg_t &&req) {
   OPTION_ITEM option {};
 
   // I know these string literals will not be modified
-  option.option = const_cast<char*>("CSeq");
+  option.option = const_cast<char *>("CSeq");
 
-  auto seqn_str = to_string(req->sequenceNumber);
-  option.content = const_cast<char*>(seqn_str.c_str());
+  auto seqn_str  = std::to_string(req->sequenceNumber);
+  option.content = const_cast<char *>(seqn_str.c_str());
 
-  std::string_view payload;
-  if(config::video.hevc_mode == 1) {
-    payload = "surround-params=NONE"sv;
-  }
-  else {
-    payload = "sprop-parameter-sets=AAAAAU;surround-params=NONE"sv;
+  std::stringstream ss;
+  if(config::video.hevc_mode != 1) {
+    ss << "sprop-parameter-sets=AAAAAU"sv << std::endl;
   }
 
-  respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, payload);
+  for(int x = 0; x < audio::MAX_STREAM_CONFIG; ++x) {
+    auto &stream_config = audio::stream_configs[x];
+    std::uint8_t mapping[platf::speaker::MAX_SPEAKERS];
+
+    auto mapping_p = stream_config.mapping;
+
+    /**
+     * GFE advertises incorrect mapping for normal quality configurations,
+     * as a result, Moonlight rotates all channels from index '3' to the right
+     * To work around this, rotate channels to the left from index '3'
+     */
+    if(x == audio::SURROUND51 || x == audio::SURROUND71) {
+      std::copy_n(mapping_p, stream_config.channelCount, mapping);
+      std::rotate(mapping + 3, mapping + 4, mapping + audio::MAX_STREAM_CONFIG);
+
+      mapping_p = mapping;
+    }
+
+    ss << "a=fmtp:97 surround-params="sv << stream_config.channelCount << stream_config.streams << stream_config.coupledStreams;
+
+    std::for_each_n(mapping_p, stream_config.channelCount, [&ss](std::uint8_t digit) {
+      ss << (char)(digit + '0');
+    });
+
+    ss << std::endl;
+  }
+
+  respond(sock, &option, 200, "OK", req->sequenceNumber, ss.str());
 }
 
-void cmd_setup(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
-  OPTION_ITEM options[2] {};
+void cmd_setup(rtsp_server_t *server, tcp::socket &sock, msg_t &&req) {
+  OPTION_ITEM options[3] {};
 
   auto &seqn           = options[0];
   auto &session_option = options[1];
+  auto &port_option    = options[2];
 
-  seqn.option = const_cast<char*>("CSeq");
+  seqn.option = const_cast<char *>("CSeq");
 
-  auto seqn_str = to_string(req->sequenceNumber);
-  seqn.content = const_cast<char*>(seqn_str.c_str());
+  auto seqn_str = std::to_string(req->sequenceNumber);
+  seqn.content  = const_cast<char *>(seqn_str.c_str());
 
   std::string_view target { req->message.request.target };
   auto begin = std::find(std::begin(target), std::end(target), '=') + 1;
   auto end   = std::find(begin, std::end(target), '/');
   std::string_view type { begin, (size_t)std::distance(begin, end) };
 
+  std::uint16_t port;
   if(type == "audio"sv) {
-    seqn.next = &session_option;
-
-    session_option.option  = const_cast<char*>("Session");
-    session_option.content = const_cast<char*>("DEADBEEFCAFE;timeout = 90");
+    port = map_port(stream::AUDIO_STREAM_PORT);
   }
-  else if(type != "video"sv && type != "control"sv) {
-    cmd_not_found(server->host(), peer, std::move(req));
+  else if(type == "video"sv) {
+    port = map_port(stream::VIDEO_STREAM_PORT);
+  }
+  else if(type == "control"sv) {
+    port = map_port(stream::CONTROL_PORT);
+  }
+  else {
+    cmd_not_found(sock, std::move(req));
 
     return;
   }
 
-  respond(server->host(), peer, &seqn, 200, "OK", req->sequenceNumber, {});
+  seqn.next = &session_option;
+
+  session_option.option  = const_cast<char *>("Session");
+  session_option.content = const_cast<char *>("DEADBEEFCAFE;timeout = 90");
+
+  session_option.next = &port_option;
+
+  // Moonlight merely requires 'server_port=<port>'
+  auto port_value = "server_port=" + std::to_string(port);
+
+  port_option.option  = const_cast<char *>("Transport");
+  port_option.content = port_value.data();
+
+
+  respond(sock, &seqn, 200, "OK", req->sequenceNumber, {});
 }
 
-void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
+void cmd_announce(rtsp_server_t *server, tcp::socket &sock, msg_t &&req) {
   OPTION_ITEM option {};
 
   // I know these string literals will not be modified
-  option.option = const_cast<char*>("CSeq");
+  option.option = const_cast<char *>("CSeq");
 
-  auto seqn_str = to_string(req->sequenceNumber);
-  option.content = const_cast<char*>(seqn_str.c_str());
+  auto seqn_str  = std::to_string(req->sequenceNumber);
+  option.content = const_cast<char *>(seqn_str.c_str());
 
   if(!server->launch_event.peek()) {
     // /launch has not been used
 
-    respond(server->host(), peer, &option, 503, "Service Unavailable", req->sequenceNumber, {});
+    respond(sock, &option, 503, "Service Unavailable", req->sequenceNumber, {});
     return;
   }
   auto launch_session { server->launch_event.pop() };
@@ -362,10 +554,10 @@ void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
   };
 
   {
-    auto pos = std::begin(payload);
+    auto pos   = std::begin(payload);
     auto begin = pos;
-    while (pos != std::end(payload)) {
-      if (whitespace(*pos++)) {
+    while(pos != std::end(payload)) {
+      if(whitespace(*pos++)) {
         lines.emplace_back(begin, pos - begin - 1);
 
         while(pos != std::end(payload) && whitespace(*pos)) { ++pos; }
@@ -386,10 +578,10 @@ void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
       auto pos = line.find(':');
 
       auto name = line.substr(2, pos - 2);
-      auto val = line.substr(pos + 1);
+      auto val  = line.substr(pos + 1);
 
-      if(val[val.size() -1] == ' ') {
-        val = val.substr(0, val.size() -1);
+      if(val[val.size() - 1] == ' ') {
+        val = val.substr(0, val.size() - 1);
       }
       args.emplace(name, val);
     }
@@ -400,14 +592,25 @@ void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
   args.try_emplace("x-nv-vqos[0].bitStreamFormat"sv, "0"sv);
   args.try_emplace("x-nv-video[0].dynamicRangeMode"sv, "0"sv);
   args.try_emplace("x-nv-aqos.packetDuration"sv, "5"sv);
+  args.try_emplace("x-nv-general.useReliableUdp"sv, "1"sv);
+  args.try_emplace("x-nv-vqos[0].fec.minRequiredFecPackets"sv, "0"sv);
+  args.try_emplace("x-nv-general.featureFlags"sv, "135"sv);
 
   config_t config;
+
+  config.audio.flags[audio::config_t::HOST_AUDIO] = launch_session->host_audio;
   try {
     config.audio.channels       = util::from_view(args.at("x-nv-audio.surround.numChannels"sv));
     config.audio.mask           = util::from_view(args.at("x-nv-audio.surround.channelMask"sv));
     config.audio.packetDuration = util::from_view(args.at("x-nv-aqos.packetDuration"sv));
 
-    config.packetsize = util::from_view(args.at("x-nv-video[0].packetSize"sv));
+    config.audio.flags[audio::config_t::HIGH_QUALITY] =
+      util::from_view(args.at("x-nv-audio.surround.AudioQuality"sv));
+
+    config.controlProtocolType   = util::from_view(args.at("x-nv-general.useReliableUdp"sv));
+    config.packetsize            = util::from_view(args.at("x-nv-video[0].packetSize"sv));
+    config.minRequiredFecPackets = util::from_view(args.at("x-nv-vqos[0].fec.minRequiredFecPackets"sv));
+    config.featureFlags          = util::from_view(args.at("x-nv-general.featureFlags"sv));
 
     config.monitor.height         = util::from_view(args.at("x-nv-video[0].clientViewportHt"sv));
     config.monitor.width          = util::from_view(args.at("x-nv-video[0].clientViewportWd"sv));
@@ -418,17 +621,17 @@ void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
     config.monitor.encoderCscMode = util::from_view(args.at("x-nv-video[0].encoderCscMode"sv));
     config.monitor.videoFormat    = util::from_view(args.at("x-nv-vqos[0].bitStreamFormat"sv));
     config.monitor.dynamicRange   = util::from_view(args.at("x-nv-video[0].dynamicRangeMode"sv));
+  }
+  catch(std::out_of_range &) {
 
-  } catch(std::out_of_range &) {
-
-    respond(server->host(), peer, &option, 400, "BAD REQUEST", req->sequenceNumber, {});
+    respond(sock, &option, 400, "BAD REQUEST", req->sequenceNumber, {});
     return;
   }
 
   if(config.monitor.videoFormat != 0 && config::video.hevc_mode == 1) {
     BOOST_LOG(warning) << "HEVC is disabled, yet the client requested HEVC"sv;
 
-    respond(server->host(), peer, &option, 400, "BAD REQUEST", req->sequenceNumber, {});
+    respond(sock, &option, 400, "BAD REQUEST", req->sequenceNumber, {});
     return;
   }
 
@@ -438,34 +641,37 @@ void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
   if(!slot) {
     BOOST_LOG(info) << "Ran out of slots for client from ["sv << ']';
 
-    respond(server->host(), peer, &option, 503, "Service Unavailable", req->sequenceNumber, {});
+    respond(sock, &option, 503, "Service Unavailable", req->sequenceNumber, {});
     return;
   }
 
-  if(session::start(*session, platf::from_sockaddr((sockaddr*)&peer->address.address))) {
+  if(session::start(*session, sock.remote_endpoint().address().to_string())) {
     BOOST_LOG(error) << "Failed to start a streaming session"sv;
 
     server->clear(slot);
-    respond(server->host(), peer, &option, 500, "Internal Server Error", req->sequenceNumber, {});
+    respond(sock, &option, 500, "Internal Server Error", req->sequenceNumber, {});
     return;
   }
 
-  respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, {});
+  respond(sock, &option, 200, "OK", req->sequenceNumber, {});
 }
 
-void cmd_play(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
+void cmd_play(rtsp_server_t *server, tcp::socket &sock, msg_t &&req) {
   OPTION_ITEM option {};
 
   // I know these string literals will not be modified
-  option.option = const_cast<char*>("CSeq");
+  option.option = const_cast<char *>("CSeq");
 
-  auto seqn_str = to_string(req->sequenceNumber);
-  option.content = const_cast<char*>(seqn_str.c_str());
+  auto seqn_str  = std::to_string(req->sequenceNumber);
+  option.content = const_cast<char *>(seqn_str.c_str());
 
-  respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, {});
+  respond(sock, &option, 200, "OK", req->sequenceNumber, {});
 }
 
-void rtpThread(std::shared_ptr<safe::signal_t> shutdown_event) {
+void rtpThread() {
+  auto shutdown_event           = mail::man->event<bool>(mail::shutdown);
+  auto broadcast_shutdown_event = mail::man->event<bool>(mail::broadcast_shutdown);
+
   server.map("OPTIONS"sv, &cmd_option);
   server.map("DESCRIBE"sv, &cmd_describe);
   server.map("SETUP"sv, &cmd_setup);
@@ -473,8 +679,9 @@ void rtpThread(std::shared_ptr<safe::signal_t> shutdown_event) {
 
   server.map("PLAY"sv, &cmd_play);
 
-  if(server.bind(RTSP_SETUP_PORT)) {
-    BOOST_LOG(fatal) << "Couldn't bind RTSP server to port ["sv << RTSP_SETUP_PORT << "], likely another process already bound to the port"sv;
+  boost::system::error_code ec;
+  if(server.bind(map_port(RTSP_SETUP_PORT), ec)) {
+    BOOST_LOG(fatal) << "Couldn't bind RTSP server to port ["sv << map_port(RTSP_SETUP_PORT) << "], " << ec.message();
     shutdown_event->raise(true);
 
     return;
@@ -483,7 +690,7 @@ void rtpThread(std::shared_ptr<safe::signal_t> shutdown_event) {
   while(!shutdown_event->peek()) {
     server.iterate(std::min(500ms, config::stream.ping_timeout));
 
-    if(broadcast_shutdown_event.peek()) {
+    if(broadcast_shutdown_event->peek()) {
       server.clear();
     }
     else {
@@ -518,7 +725,7 @@ void print_msg(PRTSP_MESSAGE msg) {
     BOOST_LOG(debug) << "status :: "sv << status;
   }
   else {
-    auto& req = msg->message.request;
+    auto &req = msg->message.request;
 
     std::string_view command { req.command };
     std::string_view target { req.target };
@@ -534,6 +741,8 @@ void print_msg(PRTSP_MESSAGE msg) {
     BOOST_LOG(debug) << name << " :: "sv << content;
   }
 
-  BOOST_LOG(debug) << "---Begin MessageBuffer---"sv << std::endl << messageBuffer << std::endl << "---End MessageBuffer---"sv << std::endl;
-}
+  BOOST_LOG(debug) << "---Begin MessageBuffer---"sv << std::endl
+                   << messageBuffer << std::endl
+                   << "---End MessageBuffer---"sv << std::endl;
 }
+} // namespace stream

sunshine/rtsp.h

@@ -11,16 +11,20 @@
 #include "thread_safe.h"
 
 namespace stream {
+constexpr auto RTSP_SETUP_PORT = 21;
+
 struct launch_session_t {
   crypto::aes_t gcm_key;
   crypto::aes_t iv;
+
+  bool host_audio;
 };
 
 void launch_session_raise(launch_session_t launch_session);
 int session_count();
 
-void rtpThread(std::shared_ptr<safe::signal_t> shutdown_event);
+void rtpThread();
 
-}
+} // namespace stream
 
 #endif //SUNSHINE_RTSP_H

sunshine/stream.h

@@ -7,18 +7,25 @@
 
 #include <boost/asio.hpp>
 
-#include "video.h"
 #include "audio.h"
 #include "crypto.h"
+#include "video.h"
 
 namespace stream {
+constexpr auto VIDEO_STREAM_PORT = 9;
+constexpr auto CONTROL_PORT      = 10;
+constexpr auto AUDIO_STREAM_PORT = 11;
+
 struct session_t;
 struct config_t {
   audio::config_t audio;
   video::config_t monitor;
-  int packetsize;
 
-  bool sops;
+  int packetsize;
+  int minRequiredFecPackets;
+  int featureFlags;
+  int controlProtocolType;
+
   std::optional<int> gcmap;
 };
 
@@ -35,9 +42,7 @@ int start(session_t &session, const std::string &addr_string);
 void stop(session_t &session);
 void join(session_t &session);
 state_e state(session_t &session);
-}
-
-extern safe::signal_t broadcast_shutdown_event;
-}
+} // namespace session
+} // namespace stream
 
 #endif //SUNSHINE_STREAM_H

sunshine/sync.h

@@ -5,9 +5,9 @@
 #ifndef SUNSHINE_SYNC_H
 #define SUNSHINE_SYNC_H
 
-#include <utility>
-#include <mutex>
 #include <array>
+#include <mutex>
+#include <utility>
 
 namespace util {
 
@@ -21,8 +21,8 @@ public:
     return std::lock_guard { _lock };
   }
 
-  template<class ...Args>
-  sync_t(Args&&... args) : raw {std::forward<Args>(args)... } {}
+  template<class... Args>
+  sync_t(Args &&...args) : raw { std::forward<Args>(args)... } {}
 
   sync_t &operator=(sync_t &&other) noexcept {
     std::lock(_lock, other._lock);
@@ -84,11 +84,12 @@ public:
   }
 
   value_t raw;
+
 private:
   mutex_t _lock;
 };
 
-}
+} // namespace util
 
 
 #endif //T_MAN_SYNC_H

sunshine/task_pool.h

@@ -1,18 +1,18 @@
 #ifndef KITTY_TASK_POOL_H
 #define KITTY_TASK_POOL_H
 
-#include <deque>
-#include <vector>
-#include <future>
 #include <chrono>
-#include <utility>
+#include <deque>
 #include <functional>
+#include <future>
 #include <mutex>
-#include <type_traits>
 #include <optional>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
-#include "utility.h"
 #include "move_by_copy.h"
+#include "utility.h"
 namespace util {
 
 class _ImplBase {
@@ -29,8 +29,7 @@ class _Impl : public _ImplBase {
   Function _func;
 
 public:
-
-  _Impl(Function&& f) : _func(std::forward<Function>(f)) { }
+  _Impl(Function &&f) : _func(std::forward<Function>(f)) {}
 
   void run() override {
     _func();
@@ -40,7 +39,7 @@ public:
 class TaskPool {
 public:
   typedef std::unique_ptr<_ImplBase> __task;
-  typedef _ImplBase* task_id_t;
+  typedef _ImplBase *task_id_t;
 
 
   typedef std::chrono::steady_clock::time_point __time_point;
@@ -53,9 +52,10 @@ public:
 
     timer_task_t(task_id_t task_id, std::future<R> &future) : task_id { task_id }, future { std::move(future) } {}
   };
+
 protected:
   std::deque<__task> _tasks;
-  std::vector<std::pair<__time_point, __task>> _timer_tasks; 
+  std::vector<std::pair<__time_point, __task>> _timer_tasks;
   std::mutex _task_mutex;
 
 public:
@@ -70,8 +70,8 @@ public:
   }
 
   template<class Function, class... Args>
-  auto push(Function && newTask, Args &&... args) {
-    static_assert(std::is_invocable_v<Function, Args&&...>, "arguments don't match the function");
+  auto push(Function &&newTask, Args &&...args) {
+    static_assert(std::is_invocable_v<Function, Args &&...>, "arguments don't match the function");
 
     using __return = std::invoke_result_t<Function, Args &&...>;
     using task_t   = std::packaged_task<__return()>;
@@ -81,12 +81,12 @@ public:
     };
 
     task_t task(std::move(bind));
-    
+
     auto future = task.get_future();
-    
+
     std::lock_guard<std::mutex> lg(_task_mutex);
     _tasks.emplace_back(toRunnable(std::move(task)));
-    
+
     return future;
   }
 
@@ -107,14 +107,14 @@ public:
    * @return an id to potentially delay the task
    */
   template<class Function, class X, class Y, class... Args>
-  auto pushDelayed(Function &&newTask, std::chrono::duration<X, Y> duration, Args &&... args) {
-    static_assert(std::is_invocable_v<Function, Args&&...>, "arguments don't match the function");
+  auto pushDelayed(Function &&newTask, std::chrono::duration<X, Y> duration, Args &&...args) {
+    static_assert(std::is_invocable_v<Function, Args &&...>, "arguments don't match the function");
 
     using __return = std::invoke_result_t<Function, Args &&...>;
     using task_t   = std::packaged_task<__return()>;
 
     __time_point time_point;
-    if constexpr (std::is_floating_point_v<X>) {
+    if constexpr(std::is_floating_point_v<X>) {
       time_point = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
     }
     else {
@@ -127,7 +127,7 @@ public:
 
     task_t task(std::move(bind));
 
-    auto future = task.get_future();
+    auto future   = task.get_future();
     auto runnable = toRunnable(std::move(task));
 
     task_id_t task_id = &*runnable;
@@ -160,13 +160,14 @@ public:
     }
 
     // smaller time goes to the back
-    auto prev = it -1;
+    auto prev = it - 1;
     while(it > _timer_tasks.cbegin()) {
       if(std::get<0>(*it) > std::get<0>(*prev)) {
         std::swap(*it, *prev);
       }
 
-      --prev; --it;
+      --prev;
+      --it;
     }
   }
 
@@ -201,20 +202,20 @@ public:
 
   std::optional<__task> pop() {
     std::lock_guard lg(_task_mutex);
-    
+
     if(!_tasks.empty()) {
       __task task = std::move(_tasks.front());
       _tasks.pop_front();
       return std::move(task);
     }
-    
+
     if(!_timer_tasks.empty() && std::get<0>(_timer_tasks.back()) <= std::chrono::steady_clock::now()) {
       __task task = std::move(std::get<1>(_timer_tasks.back()));
       _timer_tasks.pop_back();
-      
+
       return std::move(task);
     }
-    
+
     return std::nullopt;
   }
 
@@ -233,12 +234,12 @@ public:
 
     return std::get<0>(_timer_tasks.back());
   }
-private:
 
+private:
   template<class Function>
   std::unique_ptr<_ImplBase> toRunnable(Function &&f) {
-    return std::make_unique<_Impl<Function>>(std::forward<Function&&>(f));
+    return std::make_unique<_Impl<Function>>(std::forward<Function &&>(f));
   }
 };
-}
+} // namespace util
 #endif

sunshine/thread_pool.h

@@ -1,8 +1,8 @@
 #ifndef KITTY_THREAD_POOL_H
 #define KITTY_THREAD_POOL_H
 
-#include <thread>
 #include "task_pool.h"
+#include <thread>
 
 namespace util {
 /*
@@ -12,32 +12,33 @@ namespace util {
 class ThreadPool : public TaskPool {
 public:
   typedef TaskPool::__task __task;
-  
+
 private:
   std::vector<std::thread> _thread;
 
   std::condition_variable _cv;
   std::mutex _lock;
-  
+
   bool _continue;
+
 public:
   ThreadPool() : _continue { false } {}
 
   explicit ThreadPool(int threads) : _thread(threads), _continue { true } {
-    for (auto &t : _thread) {
+    for(auto &t : _thread) {
       t = std::thread(&ThreadPool::_main, this);
     }
   }
 
   ~ThreadPool() noexcept {
-    if (!_continue) return;
+    if(!_continue) return;
 
     stop();
     join();
   }
 
   template<class Function, class... Args>
-  auto push(Function && newTask, Args &&... args) {
+  auto push(Function &&newTask, Args &&...args) {
     std::lock_guard lg(_lock);
     auto future = TaskPool::push(std::forward<Function>(newTask), std::forward<Args>(args)...);
 
@@ -52,7 +53,7 @@ public:
   }
 
   template<class Function, class X, class Y, class... Args>
-  auto pushDelayed(Function &&newTask, std::chrono::duration<X, Y> duration, Args &&... args) {
+  auto pushDelayed(Function &&newTask, std::chrono::duration<X, Y> duration, Args &&...args) {
     std::lock_guard lg(_lock);
     auto future = TaskPool::pushDelayed(std::forward<Function>(newTask), duration, std::forward<Args>(args)...);
 
@@ -79,15 +80,14 @@ public:
   }
 
   void join() {
-    for (auto & t : _thread) {
+    for(auto &t : _thread) {
       t.join();
     }
   }
 
 public:
-
   void _main() {
-    while (_continue) {
+    while(_continue) {
       if(auto task = this->pop()) {
         (*task)->run();
       }
@@ -117,5 +117,5 @@ public:
     }
   }
 };
-}
+} // namespace util
 #endif

sunshine/thread_safe.h

@@ -5,28 +5,29 @@
 #ifndef SUNSHINE_THREAD_SAFE_H
 #define SUNSHINE_THREAD_SAFE_H
 
-#include <vector>
-#include <mutex>
-#include <condition_variable>
 #include <atomic>
+#include <condition_variable>
 #include <functional>
+#include <map>
+#include <mutex>
+#include <vector>
 
 #include "utility.h"
 
 namespace safe {
 template<class T>
 class event_t {
+public:
   using status_t = util::optional_t<T>;
 
-public:
-  template<class...Args>
+  template<class... Args>
   void raise(Args &&...args) {
     std::lock_guard lg { _lock };
     if(!_continue) {
       return;
     }
 
-    if constexpr (std::is_same_v<std::optional<T>, status_t>) {
+    if constexpr(std::is_same_v<std::optional<T>, status_t>) {
       _status = std::make_optional<T>(std::forward<Args>(args)...);
     }
     else {
@@ -38,42 +39,42 @@ public:
 
   // pop and view shoud not be used interchangebly
   status_t pop() {
-    std::unique_lock ul{ _lock };
+    std::unique_lock ul { _lock };
 
-    if (!_continue) {
+    if(!_continue) {
       return util::false_v<status_t>;
     }
 
-    while (!_status) {
+    while(!_status) {
       _cv.wait(ul);
 
-      if (!_continue) {
+      if(!_continue) {
         return util::false_v<status_t>;
       }
     }
 
     auto val = std::move(_status);
-    _status = util::false_v<status_t>;
+    _status  = util::false_v<status_t>;
     return val;
   }
 
   // pop and view shoud not be used interchangebly
   template<class Rep, class Period>
   status_t pop(std::chrono::duration<Rep, Period> delay) {
-    std::unique_lock ul{ _lock };
+    std::unique_lock ul { _lock };
 
-    if (!_continue) {
+    if(!_continue) {
       return util::false_v<status_t>;
     }
 
-    while (!_status) {
-      if (!_continue || _cv.wait_for(ul, delay) == std::cv_status::timeout) {
+    while(!_status) {
+      if(!_continue || _cv.wait_for(ul, delay) == std::cv_status::timeout) {
         return util::false_v<status_t>;
       }
     }
 
     auto val = std::move(_status);
-    _status = util::false_v<status_t>;
+    _status  = util::false_v<status_t>;
     return val;
   }
 
@@ -81,14 +82,14 @@ public:
   const status_t &view() {
     std::unique_lock ul { _lock };
 
-    if (!_continue) {
+    if(!_continue) {
       return util::false_v<status_t>;
     }
 
-    while (!_status) {
+    while(!_status) {
       _cv.wait(ul);
 
-      if (!_continue) {
+      if(!_continue) {
         return util::false_v<status_t>;
       }
     }
@@ -97,13 +98,11 @@ public:
   }
 
   bool peek() {
-    std::lock_guard lg { _lock };
-
     return _continue && (bool)_status;
   }
 
   void stop() {
-    std::lock_guard lg{ _lock };
+    std::lock_guard lg { _lock };
 
     _continue = false;
 
@@ -111,7 +110,7 @@ public:
   }
 
   void reset() {
-    std::lock_guard lg{ _lock };
+    std::lock_guard lg { _lock };
 
     _continue = true;
 
@@ -121,8 +120,8 @@ public:
   [[nodiscard]] bool running() const {
     return _continue;
   }
-private:
 
+private:
   bool _continue { true };
   status_t _status { util::false_v<status_t> };
 
@@ -131,14 +130,101 @@ private:
 };
 
 template<class T>
-class queue_t {
+class alarm_raw_t {
+public:
   using status_t = util::optional_t<T>;
 
+  alarm_raw_t() : _status { util::false_v<status_t> } {}
+
+  void ring(const status_t &status) {
+    std::lock_guard lg(_lock);
+
+    _status = status;
+    _cv.notify_one();
+  }
+
+  void ring(status_t &&status) {
+    std::lock_guard lg(_lock);
+
+    _status = std::move(status);
+    _cv.notify_one();
+  }
+
+  template<class Rep, class Period>
+  auto wait_for(const std::chrono::duration<Rep, Period> &rel_time) {
+    std::unique_lock ul(_lock);
+
+    return _cv.wait_for(ul, rel_time, [this]() { return (bool)status(); });
+  }
+
+  template<class Rep, class Period, class Pred>
+  auto wait_for(const std::chrono::duration<Rep, Period> &rel_time, Pred &&pred) {
+    std::unique_lock ul(_lock);
+
+    return _cv.wait_for(ul, rel_time, [this, &pred]() { return (bool)status() || pred(); });
+  }
+
+  template<class Rep, class Period>
+  auto wait_until(const std::chrono::duration<Rep, Period> &rel_time) {
+    std::unique_lock ul(_lock);
+
+    return _cv.wait_until(ul, rel_time, [this]() { return (bool)status(); });
+  }
+
+  template<class Rep, class Period, class Pred>
+  auto wait_until(const std::chrono::duration<Rep, Period> &rel_time, Pred &&pred) {
+    std::unique_lock ul(_lock);
+
+    return _cv.wait_until(ul, rel_time, [this, &pred]() { return (bool)status() || pred(); });
+  }
+
+  auto wait() {
+    std::unique_lock ul(_lock);
+    _cv.wait(ul, [this]() { return (bool)status(); });
+  }
+
+  template<class Pred>
+  auto wait(Pred &&pred) {
+    std::unique_lock ul(_lock);
+    _cv.wait(ul, [this, &pred]() { return (bool)status() || pred(); });
+  }
+
+  const status_t &status() const {
+    return _status;
+  }
+
+  status_t &status() {
+    return _status;
+  }
+
+  void reset() {
+    _status = status_t {};
+  }
+
+private:
+  std::mutex _lock;
+  std::condition_variable _cv;
+
+  status_t _status;
+};
+
+template<class T>
+using alarm_t = std::shared_ptr<alarm_raw_t<T>>;
+
+template<class T>
+alarm_t<T> make_alarm() {
+  return std::make_shared<alarm_raw_t<T>>();
+}
+
+template<class T>
+class queue_t {
 public:
+  using status_t = util::optional_t<T>;
+
   queue_t(std::uint32_t max_elements) : _max_elements { max_elements } {}
 
-  template<class ...Args>
-  void raise(Args &&... args) {
+  template<class... Args>
+  void raise(Args &&...args) {
     std::lock_guard ul { _lock };
 
     if(!_continue) {
@@ -155,8 +241,6 @@ public:
   }
 
   bool peek() {
-    std::lock_guard lg { _lock };
-
     return _continue && !_queue.empty();
   }
 
@@ -164,12 +248,12 @@ public:
   status_t pop(std::chrono::duration<Rep, Period> delay) {
     std::unique_lock ul { _lock };
 
-    if (!_continue) {
+    if(!_continue) {
       return util::false_v<status_t>;
     }
 
-    while (_queue.empty()) {
-      if (!_continue || _cv.wait_for(ul, delay) == std::cv_status::timeout) {
+    while(_queue.empty()) {
+      if(!_continue || _cv.wait_for(ul, delay) == std::cv_status::timeout) {
         return util::false_v<status_t>;
       }
     }
@@ -183,14 +267,14 @@ public:
   status_t pop() {
     std::unique_lock ul { _lock };
 
-    if (!_continue) {
+    if(!_continue) {
       return util::false_v<status_t>;
     }
 
-    while (_queue.empty()) {
+    while(_queue.empty()) {
       _cv.wait(ul);
 
-      if (!_continue) {
+      if(!_continue) {
         return util::false_v<status_t>;
       }
     }
@@ -202,7 +286,6 @@ public:
   }
 
   std::vector<T> &unsafe() {
-    std::lock_guard { _lock };
     return _queue;
   }
 
@@ -219,7 +302,6 @@ public:
   }
 
 private:
-
   bool _continue { true };
   std::uint32_t _max_elements;
 
@@ -235,7 +317,7 @@ public:
   using element_type = T;
 
   using construct_f = std::function<int(element_type &)>;
-  using destruct_f = std::function<void(element_type &)>;
+  using destruct_f  = std::function<void(element_type &)>;
 
   struct ptr_t {
     shared_t *owner;
@@ -252,7 +334,7 @@ public:
         return;
       }
 
-      auto tmp = ptr.owner->ref();
+      auto tmp  = ptr.owner->ref();
       tmp.owner = nullptr;
     }
 
@@ -282,7 +364,7 @@ public:
       }
     }
 
-    operator bool () const {
+    operator bool() const {
       return owner != nullptr;
     }
 
@@ -298,22 +380,22 @@ public:
     }
 
     element_type *get() const {
-      return reinterpret_cast<element_type*>(owner->_object_buf.data());
+      return reinterpret_cast<element_type *>(owner->_object_buf.data());
     }
 
     element_type *operator->() {
-      return reinterpret_cast<element_type*>(owner->_object_buf.data());
+      return reinterpret_cast<element_type *>(owner->_object_buf.data());
     }
   };
 
   template<class FC, class FD>
-  shared_t(FC && fc, FD &&fd) : _construct { std::forward<FC>(fc) }, _destruct { std::forward<FD>(fd) } {}
+  shared_t(FC &&fc, FD &&fd) : _construct { std::forward<FC>(fc) }, _destruct { std::forward<FD>(fd) } {}
   [[nodiscard]] ptr_t ref() {
     std::lock_guard lg { _lock };
 
     if(!_count) {
       new(_object_buf.data()) element_type;
-      if(_construct(*reinterpret_cast<element_type*>(_object_buf.data()))) {
+      if(_construct(*reinterpret_cast<element_type *>(_object_buf.data()))) {
         return ptr_t { nullptr };
       }
     }
@@ -322,6 +404,7 @@ public:
 
     return ptr_t { this };
   }
+
 private:
   construct_f _construct;
   destruct_f _destruct;
@@ -340,6 +423,89 @@ auto make_shared(F_Construct &&fc, F_Destruct &&fd) {
 }
 
 using signal_t = event_t<bool>;
+
+class mail_raw_t;
+using mail_t = std::shared_ptr<mail_raw_t>;
+
+void cleanup(mail_raw_t *);
+template<class T>
+class post_t : public T {
+public:
+  template<class... Args>
+  post_t(mail_t mail, Args &&...args) : T(std::forward<Args>(args)...), mail { std::move(mail) } {}
+
+  mail_t mail;
+
+  ~post_t() {
+    cleanup(mail.get());
+  }
+};
+
+template<class T>
+inline auto lock(const std::weak_ptr<void> &wp) {
+  return std::reinterpret_pointer_cast<typename T::element_type>(wp.lock());
 }
 
+class mail_raw_t : public std::enable_shared_from_this<mail_raw_t> {
+public:
+  template<class T>
+  using event_t = std::shared_ptr<post_t<event_t<T>>>;
+
+  template<class T>
+  using queue_t = std::shared_ptr<post_t<queue_t<T>>>;
+
+  template<class T>
+  event_t<T> event(const std::string_view &id) {
+    std::lock_guard lg { mutex };
+
+    auto it = id_to_post.find(id);
+    if(it != std::end(id_to_post)) {
+      return lock<event_t<T>>(it->second);
+    }
+
+    auto post = std::make_shared<typename event_t<T>::element_type>(shared_from_this());
+    id_to_post.emplace(std::pair<std::string, std::weak_ptr<void>> { std::string { id }, post });
+
+    return post;
+  }
+
+  template<class T>
+  queue_t<T> queue(const std::string_view &id) {
+    std::lock_guard lg { mutex };
+
+    auto it = id_to_post.find(id);
+    if(it != std::end(id_to_post)) {
+      return lock<queue_t<T>>(it->second);
+    }
+
+    auto post = std::make_shared<typename queue_t<T>::element_type>(shared_from_this(), 32);
+    id_to_post.emplace(std::pair<std::string, std::weak_ptr<void>> { std::string { id }, post });
+
+    return post;
+  }
+
+  void cleanup() {
+    std::lock_guard lg { mutex };
+
+    for(auto it = std::begin(id_to_post); it != std::end(id_to_post); ++it) {
+      auto &weak = it->second;
+
+      if(weak.expired()) {
+        id_to_post.erase(it);
+
+        return;
+      }
+    }
+  }
+
+  std::mutex mutex;
+
+  std::map<std::string, std::weak_ptr<void>, std::less<>> id_to_post;
+};
+
+inline void cleanup(mail_raw_t *mail) {
+  mail->cleanup();
+}
+} // namespace safe
+
 #endif //SUNSHINE_THREAD_SAFE_H

sunshine/upnp.cpp

@@ -0,0 +1,184 @@
+#include <miniupnpc/miniupnpc.h>
+#include <miniupnpc/upnpcommands.h>
+
+#include "config.h"
+#include "confighttp.h"
+#include "main.h"
+#include "network.h"
+#include "nvhttp.h"
+#include "rtsp.h"
+#include "stream.h"
+#include "upnp.h"
+#include "utility.h"
+
+using namespace std::literals;
+
+namespace upnp {
+constexpr auto INET6_ADDRESS_STRLEN = 46;
+
+constexpr auto IPv4 = 0;
+constexpr auto IPv6 = 1;
+
+using device_t = util::safe_ptr<UPNPDev, freeUPNPDevlist>;
+
+KITTY_USING_MOVE_T(urls_t, UPNPUrls, , {
+  FreeUPNPUrls(&el);
+});
+
+struct mapping_t {
+  struct {
+    std::string wan;
+    std::string lan;
+  } port;
+
+  std::string description;
+  bool tcp;
+};
+
+void unmap(
+  const urls_t &urls,
+  const IGDdatas &data,
+  std::vector<mapping_t>::const_reverse_iterator begin,
+  std::vector<mapping_t>::const_reverse_iterator end) {
+
+  BOOST_LOG(debug) << "Unmapping UPNP ports"sv;
+
+  for(auto it = begin; it != end; ++it) {
+    auto status = UPNP_DeletePortMapping(
+      urls->controlURL,
+      data.first.servicetype,
+      it->port.wan.c_str(),
+      it->tcp ? "TCP" : "UDP",
+      nullptr);
+
+    if(status) {
+      BOOST_LOG(warning) << "Failed to unmap port ["sv << it->port.wan << "] to port ["sv << it->port.lan << "]: error code ["sv << status << ']';
+      break;
+    }
+  }
+}
+
+class deinit_t : public platf::deinit_t {
+public:
+  using iter_t = std::vector<mapping_t>::const_reverse_iterator;
+  deinit_t(urls_t &&urls, IGDdatas data, std::vector<mapping_t> &&mapping)
+      : urls { std::move(urls) }, data { data }, mapping { std::move(mapping) } {}
+
+  ~deinit_t() {
+    BOOST_LOG(info) << "Unmapping UPNP ports..."sv;
+    unmap(urls, data, std::rbegin(mapping), std::rend(mapping));
+  }
+
+  urls_t urls;
+  IGDdatas data;
+
+  std::vector<mapping_t> mapping;
+};
+
+static std::string_view status_string(int status) {
+  switch(status) {
+  case 0:
+    return "No IGD device found"sv;
+  case 1:
+    return "Valid IGD device found"sv;
+  case 2:
+    return "A UPnP device has been found,  but it wasn't recognized as an IGD"sv;
+  }
+
+  return "Unknown status"sv;
+}
+
+std::unique_ptr<platf::deinit_t> start() {
+  int err {};
+
+  device_t device { upnpDiscover(2000, nullptr, nullptr, 0, IPv4, 2, &err) };
+  if(!device || err) {
+    BOOST_LOG(error) << "Couldn't discover any UPNP devices"sv;
+
+    return nullptr;
+  }
+
+  for(auto dev = device.get(); dev != nullptr; dev = dev->pNext) {
+    BOOST_LOG(debug) << "Found device: "sv << dev->descURL;
+  }
+
+  std::array<char, INET6_ADDRESS_STRLEN> lan_addr;
+  std::array<char, INET6_ADDRESS_STRLEN> wan_addr;
+
+  urls_t urls;
+  IGDdatas data;
+
+  auto status = UPNP_GetValidIGD(device.get(), &urls.el, &data, lan_addr.data(), lan_addr.size());
+  if(status != 1) {
+    BOOST_LOG(error) << status_string(status);
+    return nullptr;
+  }
+
+  BOOST_LOG(debug) << "Found valid IGD device: "sv << urls->rootdescURL;
+
+  if(UPNP_GetExternalIPAddress(urls->controlURL, data.first.servicetype, wan_addr.data())) {
+    BOOST_LOG(warning) << "Could not get external ip"sv;
+  }
+  else {
+    BOOST_LOG(debug) << "Found external ip: "sv << wan_addr.data();
+    if(config::nvhttp.external_ip.empty()) {
+      config::nvhttp.external_ip = wan_addr.data();
+    }
+  }
+
+  if(!config::sunshine.flags[config::flag::UPNP]) {
+    return nullptr;
+  }
+
+  auto rtsp     = std::to_string(map_port(stream::RTSP_SETUP_PORT));
+  auto video    = std::to_string(map_port(stream::VIDEO_STREAM_PORT));
+  auto audio    = std::to_string(map_port(stream::AUDIO_STREAM_PORT));
+  auto control  = std::to_string(map_port(stream::CONTROL_PORT));
+  auto gs_http  = std::to_string(map_port(nvhttp::PORT_HTTP));
+  auto gs_https = std::to_string(map_port(nvhttp::PORT_HTTPS));
+  auto wm_http  = std::to_string(map_port(confighttp::PORT_HTTPS));
+
+  std::vector<mapping_t> mappings {
+    { rtsp, rtsp, "RTSP setup port"s, true },
+    { video, video, "Video stream port"s, false },
+    { audio, audio, "Control stream port"s, false },
+    { control, control, "Audio stream port"s, false },
+    { gs_http, gs_http, "Gamestream http port"s, true },
+    { gs_https, gs_https, "Gamestream https port"s, true },
+  };
+
+  // Only map port for the Web Manager if it is configured to accept connection from WAN
+  if(net::from_enum_string(config::nvhttp.origin_web_ui_allowed) > net::LAN) {
+    mappings.emplace_back(mapping_t { wm_http, wm_http, "Sunshine Web UI port"s, true });
+  }
+
+  auto it = std::begin(mappings);
+
+  status = 0;
+  for(; it != std::end(mappings); ++it) {
+    status = UPNP_AddPortMapping(
+      urls->controlURL,
+      data.first.servicetype,
+      it->port.wan.c_str(),
+      it->port.lan.c_str(),
+      lan_addr.data(),
+      it->description.c_str(),
+      it->tcp ? "TCP" : "UDP",
+      nullptr,
+      "86400");
+
+    if(status) {
+      BOOST_LOG(error) << "Failed to map port ["sv << it->port.wan << "] to port ["sv << it->port.lan << "]: error code ["sv << status << ']';
+      break;
+    }
+  }
+
+  if(status) {
+    unmap(urls, data, std::make_reverse_iterator(it), std::rend(mappings));
+
+    return nullptr;
+  }
+
+  return std::make_unique<deinit_t>(std::move(urls), data, std::move(mappings));
+}
+} // namespace upnp

sunshine/upnp.h

@@ -0,0 +1,10 @@
+#ifndef SUNSHINE_UPNP_H
+#define SUNSHINE_UPNP_H
+
+#include "platform/common.h"
+
+namespace upnp {
+[[nodiscard]] std::unique_ptr<platf::deinit_t> start();
+}
+
+#endif

sunshine/utility.h

@@ -1,63 +1,109 @@
 #ifndef UTILITY_H
 #define UTILITY_H
 
+#include <algorithm>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string_view>
+#include <type_traits>
 #include <variant>
 #include <vector>
-#include <memory>
-#include <type_traits>
-#include <algorithm>
-#include <optional>
-#include <mutex>
-#include <condition_variable>
-#include <string_view>
 
-#define KITTY_WHILE_LOOP(x, y, z) { x;while(y) z }
-#define KITTY_DECL_CONSTR(x)\
-  x(x&&) noexcept = default;\
-  x&operator=(x&&) noexcept = default;\
+#define KITTY_WHILE_LOOP(x, y, z) \
+  {                               \
+    x;                            \
+    while(y) z                    \
+  }
+
+template<typename T>
+struct argument_type;
+
+template<typename T, typename U>
+struct argument_type<T(U)> { typedef U type; };
+
+#define KITTY_USING_MOVE_T(move_t, t, init_val, z)                 \
+  class move_t {                                                   \
+  public:                                                          \
+    using element_type = typename argument_type<void(t)>::type;    \
+                                                                   \
+    move_t() : el { init_val } {}                                  \
+    template<class... Args>                                        \
+    move_t(Args &&...args) : el { std::forward<Args>(args)... } {} \
+    move_t(const move_t &) = delete;                               \
+                                                                   \
+    move_t(move_t &&other) noexcept : el { std::move(other.el) } { \
+      other.el = element_type { init_val };                        \
+    }                                                              \
+                                                                   \
+    move_t &operator=(const move_t &) = delete;                    \
+                                                                   \
+    move_t &operator=(move_t &&other) {                            \
+      std::swap(el, other.el);                                     \
+      return *this;                                                \
+    }                                                              \
+    element_type *operator->() { return &el; }                     \
+    const element_type *operator->() const { return &el; }         \
+                                                                   \
+    ~move_t() z                                                    \
+                                                                   \
+      element_type el;                                             \
+  }
+
+#define KITTY_DECL_CONSTR(x)             \
+  x(x &&) noexcept = default;            \
+  x &operator=(x &&) noexcept = default; \
   x();
 
-#define KITTY_DEFAULT_CONSTR(x)\
-  x(x&&) noexcept = default;\
-  x&operator=(x&&) noexcept = default;\
-  x() = default;
+#define KITTY_DEFAULT_CONSTR(x)          \
+  x(x &&) noexcept = default;            \
+  x &operator=(x &&) noexcept = default; \
+  x()                         = default;
 
-#define KITTY_DEFAULT_CONSTR_THROW(x)\
-  x(x&&) = default;\
-  x&operator=(x&&) = default;\
-  x() = default;
+#define KITTY_DEFAULT_CONSTR_THROW(x) \
+  x(x &&)    = default;               \
+  x &operator=(x &&) = default;       \
+  x()                = default;
 
-#define TUPLE_2D(a,b, expr)\
-  decltype(expr) a##_##b = expr;\
-  auto &a = std::get<0>(a##_##b);\
-  auto &b = std::get<1>(a##_##b)
+#define TUPLE_2D(a, b, expr)                     \
+  decltype(expr) a##_##b = expr;                 \
+  auto &a                = std::get<0>(a##_##b); \
+  auto &b                = std::get<1>(a##_##b)
 
-#define TUPLE_2D_REF(a,b, expr)\
-  auto &a##_##b = expr;\
-  auto &a = std::get<0>(a##_##b);\
-  auto &b = std::get<1>(a##_##b)
+#define TUPLE_2D_REF(a, b, expr)        \
+  auto &a##_##b = expr;                 \
+  auto &a       = std::get<0>(a##_##b); \
+  auto &b       = std::get<1>(a##_##b)
 
-#define TUPLE_3D(a,b,c, expr)\
-  decltype(expr) a##_##b##_##c = expr;\
-  auto &a = std::get<0>(a##_##b##_##c);\
-  auto &b = std::get<1>(a##_##b##_##c);\
-  auto &c = std::get<2>(a##_##b##_##c)
+#define TUPLE_3D(a, b, c, expr)                              \
+  decltype(expr) a##_##b##_##c = expr;                       \
+  auto &a                      = std::get<0>(a##_##b##_##c); \
+  auto &b                      = std::get<1>(a##_##b##_##c); \
+  auto &c                      = std::get<2>(a##_##b##_##c)
 
-#define TUPLE_3D_REF(a,b,c, expr)\
-  auto &a##_##b##_##c = expr;\
-  auto &a = std::get<0>(a##_##b##_##c);\
-  auto &b = std::get<1>(a##_##b##_##c);\
-  auto &c = std::get<2>(a##_##b##_##c)
+#define TUPLE_3D_REF(a, b, c, expr)                 \
+  auto &a##_##b##_##c = expr;                       \
+  auto &a             = std::get<0>(a##_##b##_##c); \
+  auto &b             = std::get<1>(a##_##b##_##c); \
+  auto &c             = std::get<2>(a##_##b##_##c)
+
+#define TUPLE_EL(a, b, expr)  \
+  decltype(expr) a##_ = expr; \
+  auto &a             = std::get<b>(a##_)
+
+#define TUPLE_EL_REF(a, b, expr) \
+  auto &a = std::get<b>(expr)
 
 namespace util {
 
-template<template<typename...> class X, class...Y>
+template<template<typename...> class X, class... Y>
 struct __instantiation_of : public std::false_type {};
 
 template<template<typename...> class X, class... Y>
 struct __instantiation_of<X, X<Y...>> : public std::true_type {};
 
-template<template<typename...> class X, class T, class...Y>
+template<template<typename...> class X, class T, class... Y>
 static constexpr auto instantiation_of_v = __instantiation_of<X, T, Y...>::value;
 
 template<bool V, class X, class Y>
@@ -76,14 +122,16 @@ struct __either<false, X, Y> {
 template<bool V, class X, class Y>
 using either_t = typename __either<V, X, Y>::type;
 
-template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
-template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+template<class... Ts>
+struct overloaded : Ts... { using Ts::operator()...; };
+template<class... Ts>
+overloaded(Ts...) -> overloaded<Ts...>;
 
 template<class T>
 class FailGuard {
 public:
   FailGuard() = delete;
-  FailGuard(T && f) noexcept : _func { std::forward<T>(f) } {}
+  FailGuard(T &&f) noexcept : _func { std::forward<T>(f) } {}
   FailGuard(FailGuard &&other) noexcept : _func { std::move(other._func) } {
     this->failure = other.failure;
 
@@ -103,12 +151,13 @@ public:
 
   void disable() { failure = false; }
   bool failure { true };
+
 private:
   T _func;
 };
 
 template<class T>
-[[nodiscard]] auto fail_guard(T && f) {
+[[nodiscard]] auto fail_guard(T &&f) {
   return FailGuard<T> { std::forward<T>(f) };
 }
 
@@ -118,9 +167,9 @@ void append_struct(std::vector<uint8_t> &buf, const T &_struct) {
 
   buf.reserve(data_len);
 
-  auto *data = (uint8_t *) & _struct;
+  auto *data = (uint8_t *)&_struct;
 
-  for (size_t x = 0; x < data_len; ++x) {
+  for(size_t x = 0; x < data_len; ++x) {
     buf.push_back(data[x]);
   }
 }
@@ -129,24 +178,26 @@ template<class T>
 class Hex {
 public:
   typedef T elem_type;
+
 private:
   const char _bits[16] {
     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
   };
 
   char _hex[sizeof(elem_type) * 2];
+
 public:
   Hex(const elem_type &elem, bool rev) {
     if(!rev) {
       const uint8_t *data = reinterpret_cast<const uint8_t *>(&elem) + sizeof(elem_type) - 1;
-      for (auto it = begin(); it < cend();) {
+      for(auto it = begin(); it < cend();) {
         *it++ = _bits[*data / 16];
         *it++ = _bits[*data-- % 16];
       }
     }
     else {
       const uint8_t *data = reinterpret_cast<const uint8_t *>(&elem);
-      for (auto it = begin(); it < cend();) {
+      for(auto it = begin(); it < cend();) {
         *it++ = _bits[*data / 16];
         *it++ = _bits[*data++ % 16];
       }
@@ -178,7 +229,7 @@ Hex<T> hex(const T &elem, bool rev = false) {
 
 template<class It>
 std::string hex_vec(It begin, It end, bool rev = false) {
-  auto str_size = 2*std::distance(begin, end);
+  auto str_size = 2 * std::distance(begin, end);
 
 
   std::string hex;
@@ -189,14 +240,14 @@ std::string hex_vec(It begin, It end, bool rev = false) {
   };
 
   if(rev) {
-    for (auto it = std::begin(hex); it < std::end(hex);) {
+    for(auto it = std::begin(hex); it < std::end(hex);) {
       *it++ = _bits[((uint8_t)*begin) / 16];
       *it++ = _bits[((uint8_t)*begin++) % 16];
     }
   }
   else {
     --end;
-    for (auto it = std::begin(hex); it < std::end(hex);) {
+    for(auto it = std::begin(hex); it < std::end(hex);) {
       *it++ = _bits[((uint8_t)*end) / 16];
       *it++ = _bits[((uint8_t)*end--) % 16];
     }
@@ -207,7 +258,7 @@ std::string hex_vec(It begin, It end, bool rev = false) {
 }
 
 template<class C>
-std::string hex_vec(C&& c, bool rev = false) {
+std::string hex_vec(C &&c, bool rev = false) {
   return hex_vec(std::begin(c), std::end(c), rev);
 }
 
@@ -216,7 +267,7 @@ std::optional<T> from_hex(const std::string_view &hex, bool rev = false) {
   std::uint8_t buf[sizeof(T)];
 
   static char constexpr shift_bit = 'a' - 'A';
-  auto is_convertable = [] (char ch) -> bool {
+  auto is_convertable             = [](char ch) -> bool {
     if(isdigit(ch)) {
       return true;
     }
@@ -235,9 +286,9 @@ std::optional<T> from_hex(const std::string_view &hex, bool rev = false) {
     return std::nullopt;
   }
 
-  const char *data = hex.data() + hex.size() -1;
+  const char *data = hex.data() + hex.size() - 1;
 
-  auto convert = [] (char ch) -> std::uint8_t {
+  auto convert = [](char ch) -> std::uint8_t {
     if(ch >= '0' && ch <= '9') {
       return (std::uint8_t)ch - '0';
     }
@@ -266,7 +317,7 @@ inline std::string from_hex_vec(const std::string &hex, bool rev = false) {
   std::string buf;
 
   static char constexpr shift_bit = 'a' - 'A';
-  auto is_convertable = [] (char ch) -> bool {
+  auto is_convertable             = [](char ch) -> bool {
     if(isdigit(ch)) {
       return true;
     }
@@ -283,9 +334,9 @@ inline std::string from_hex_vec(const std::string &hex, bool rev = false) {
   auto buf_size = std::count_if(std::begin(hex), std::end(hex), is_convertable) / 2;
   buf.resize(buf_size);
 
-  const char *data = hex.data() + hex.size() -1;
+  const char *data = hex.data() + hex.size() - 1;
 
-  auto convert = [] (char ch) -> std::uint8_t {
+  auto convert = [](char ch) -> std::uint8_t {
     if(ch >= '0' && ch <= '9') {
       return (std::uint8_t)ch - '0';
     }
@@ -317,18 +368,18 @@ public:
   std::size_t operator()(const value_type &value) const {
     const auto *p = reinterpret_cast<const char *>(&value);
 
-    return std::hash<std::string_view>{}(std::string_view { p, sizeof(value_type) });
+    return std::hash<std::string_view> {}(std::string_view { p, sizeof(value_type) });
   }
 };
 
 template<class T>
-auto enm(const T& val) -> const std::underlying_type_t<T>& {
-  return *reinterpret_cast<const std::underlying_type_t<T>*>(&val);
+auto enm(const T &val) -> const std::underlying_type_t<T> & {
+  return *reinterpret_cast<const std::underlying_type_t<T> *>(&val);
 }
 
 template<class T>
-auto enm(T& val) -> std::underlying_type_t<T>& {
-  return *reinterpret_cast<std::underlying_type_t<T>*>(&val);
+auto enm(T &val) -> std::underlying_type_t<T> & {
+  return *reinterpret_cast<std::underlying_type_t<T> *>(&val);
 }
 
 inline std::int64_t from_chars(const char *begin, const char *end) {
@@ -377,11 +428,11 @@ public:
 };
 
 // Compared to std::unique_ptr, it adds the ability to get the address of the pointer itself
-template <typename T, typename D = std::default_delete<T>>
+template<typename T, typename D = std::default_delete<T>>
 class uniq_ptr {
 public:
   using element_type = T;
-  using pointer = element_type*;
+  using pointer      = element_type *;
   using deleter_type = D;
 
   constexpr uniq_ptr() noexcept : _p { nullptr } {}
@@ -436,7 +487,7 @@ public:
 
   pointer release() {
     auto tmp = _p;
-    _p = nullptr;
+    _p       = nullptr;
     return tmp;
   }
 
@@ -468,69 +519,70 @@ public:
     return &_p;
   }
 
-  deleter_type& get_deleter() {
+  deleter_type &get_deleter() {
     return _deleter;
   }
 
-  const deleter_type& get_deleter() const {
+  const deleter_type &get_deleter() const {
     return _deleter;
   }
 
   explicit operator bool() const {
     return _p != nullptr;
   }
+
 protected:
   pointer _p;
   deleter_type _deleter;
 };
 
 template<class T1, class D1, class T2, class D2>
-bool operator==(const uniq_ptr<T1, D1>& x, const uniq_ptr<T2, D2>& y) {
+bool operator==(const uniq_ptr<T1, D1> &x, const uniq_ptr<T2, D2> &y) {
   return x.get() == y.get();
 }
 
 template<class T1, class D1, class T2, class D2>
-bool operator!=(const uniq_ptr<T1, D1>& x, const uniq_ptr<T2, D2>& y) {
+bool operator!=(const uniq_ptr<T1, D1> &x, const uniq_ptr<T2, D2> &y) {
   return x.get() != y.get();
 }
 
 template<class T1, class D1, class T2, class D2>
-bool operator==(const std::unique_ptr<T1, D1>& x, const uniq_ptr<T2, D2>& y) {
+bool operator==(const std::unique_ptr<T1, D1> &x, const uniq_ptr<T2, D2> &y) {
   return x.get() == y.get();
 }
 
 template<class T1, class D1, class T2, class D2>
-bool operator!=(const std::unique_ptr<T1, D1>& x, const uniq_ptr<T2, D2>& y) {
+bool operator!=(const std::unique_ptr<T1, D1> &x, const uniq_ptr<T2, D2> &y) {
   return x.get() != y.get();
 }
 
 template<class T1, class D1, class T2, class D2>
-bool operator==(const uniq_ptr<T1, D1>& x, const std::unique_ptr<T1, D1>& y) {
+bool operator==(const uniq_ptr<T1, D1> &x, const std::unique_ptr<T1, D1> &y) {
   return x.get() == y.get();
 }
 
 template<class T1, class D1, class T2, class D2>
-bool operator!=(const uniq_ptr<T1, D1>& x, const std::unique_ptr<T1, D1>& y) {
+bool operator!=(const uniq_ptr<T1, D1> &x, const std::unique_ptr<T1, D1> &y) {
   return x.get() != y.get();
 }
 
 template<class T, class D>
-bool operator==(const uniq_ptr<T, D>& x, std::nullptr_t) {
+bool operator==(const uniq_ptr<T, D> &x, std::nullptr_t) {
   return !(bool)x;
 }
 
 template<class T, class D>
-bool operator!=(const uniq_ptr<T, D>& x, std::nullptr_t) {
+bool operator!=(const uniq_ptr<T, D> &x, std::nullptr_t) {
   return (bool)x;
 }
 
 template<class T, class D>
-bool operator==(std::nullptr_t, const uniq_ptr<T, D>& y) {
+bool operator==(std::nullptr_t, const uniq_ptr<T, D> &y) {
   return !(bool)y;
 }
 
 template<class T, class D>
-bool operator!=(std::nullptr_t, const uniq_ptr<T, D>& y) {
+bool operator!=(std::nullptr_t, const uniq_ptr<T, D> &y) {
   return (bool)y;
 }
 
@@ -538,8 +590,8 @@ template<class T>
 class wrap_ptr {
 public:
   using element_type = T;
-  using pointer = element_type*;
-  using reference = element_type&;
+  using pointer      = element_type *;
+  using reference    = element_type &;
 
   wrap_ptr() : _own_ptr { false }, _p { nullptr } {}
   wrap_ptr(pointer p) : _own_ptr { false }, _p { p } {}
@@ -555,7 +607,7 @@ public:
 
     _p = other._p;
 
-    _own_ptr = other._own_ptr;
+    _own_ptr       = other._own_ptr;
     other._own_ptr = false;
 
     return *this;
@@ -565,7 +617,7 @@ public:
   wrap_ptr &operator=(std::unique_ptr<V> &&uniq_ptr) {
     static_assert(std::is_base_of_v<element_type, V>, "element_type must be base class of V");
     _own_ptr = true;
-    _p = uniq_ptr.release();
+    _p       = uniq_ptr.release();
 
     return *this;
   }
@@ -575,7 +627,7 @@ public:
       delete _p;
     }
 
-    _p = p;
+    _p       = p;
     _own_ptr = false;
 
     return *this;
@@ -607,6 +659,13 @@ private:
   pointer _p;
 };
 
+template<class T>
+constexpr bool is_pointer_v =
+  instantiation_of_v<std::unique_ptr, T> ||
+  instantiation_of_v<std::shared_ptr, T> ||
+  instantiation_of_v<uniq_ptr, T> ||
+  std::is_pointer_v<T>;
+
 template<class T, class V = void>
 struct __false_v;
 
@@ -616,14 +675,7 @@ struct __false_v<T, std::enable_if_t<instantiation_of_v<std::optional, T>>> {
 };
 
 template<class T>
-struct __false_v<T, std::enable_if_t<
-  (
-    std::is_pointer_v<T> ||
-    instantiation_of_v<std::unique_ptr, T> ||
-    instantiation_of_v<std::shared_ptr, T> ||
-    instantiation_of_v<uniq_ptr, T>
-  )
-  >> {
+struct __false_v<T, std::enable_if_t<is_pointer_v<T>>> {
   static constexpr std::nullptr_t value = nullptr;
 };
 
@@ -637,19 +689,22 @@ static constexpr auto false_v = __false_v<T>::value;
 
 template<class T>
 using optional_t = either_t<
-  (std::is_same_v<T, bool> ||
-   instantiation_of_v<std::unique_ptr, T> ||
-   instantiation_of_v<std::shared_ptr, T> ||
-   instantiation_of_v<uniq_ptr, T> ||
-   std::is_pointer_v<T>),
+  (std::is_same_v<T, bool> || is_pointer_v<T>),
   T, std::optional<T>>;
 
 template<class T>
 class buffer_t {
 public:
   buffer_t() : _els { 0 } {};
-  buffer_t(buffer_t&&) noexcept = default;
-  buffer_t &operator=(buffer_t&& other) noexcept = default;
+  buffer_t(buffer_t &&o) noexcept : _els { o._els }, _buf { std::move(o._buf) } {
+    o._els = 0;
+  }
+  buffer_t &operator=(buffer_t &&o) noexcept {
+    std::swap(_els, o._els);
+    std::swap(_buf, o._buf);
+
+    return *this;
+  };
 
   explicit buffer_t(size_t elements) : _els { elements }, _buf { std::make_unique<T[]>(elements) } {}
   explicit buffer_t(size_t elements, const T &t) : _els { elements }, _buf { std::make_unique<T[]>(elements) } {
@@ -693,7 +748,6 @@ private:
   std::unique_ptr<T[]> _buf;
 };
 
-
 template<class T>
 T either(std::optional<T> &&l, T &&r) {
   if(l) {
@@ -703,7 +757,7 @@ T either(std::optional<T> &&l, T &&r) {
   return std::forward<T>(r);
 }
 
-template<class ReturnType, class ...Args>
+template<class ReturnType, class... Args>
 struct Function {
   typedef ReturnType (*type)(Args...);
 };
@@ -711,48 +765,69 @@ struct Function {
 template<class T, class ReturnType, typename Function<ReturnType, T>::type function>
 struct Destroy {
   typedef T pointer;
-  
+
   void operator()(pointer p) {
     function(p);
   }
 };
 
-template<class T, typename Function<void, T*>::type function>
-using safe_ptr = uniq_ptr<T, Destroy<T*, void, function>>;
+template<class T, typename Function<void, T *>::type function>
+using safe_ptr = uniq_ptr<T, Destroy<T *, void, function>>;
 
 // You cannot specialize an alias
-template<class T, class ReturnType, typename Function<ReturnType, T*>::type function>
-using safe_ptr_v2 = uniq_ptr<T, Destroy<T*, ReturnType, function>>;
+template<class T, class ReturnType, typename Function<ReturnType, T *>::type function>
+using safe_ptr_v2 = uniq_ptr<T, Destroy<T *, ReturnType, function>>;
 
 template<class T>
 void c_free(T *p) {
   free(p);
 }
 
+template<class T, class ReturnType, ReturnType (**function)(T *)>
+void dynamic(T *p) {
+  (*function)(p);
+}
+
+template<class T, void (**function)(T *)>
+using dyn_safe_ptr = safe_ptr<T, dynamic<T, void, function>>;
+
+template<class T, class ReturnType, ReturnType (**function)(T *)>
+using dyn_safe_ptr_v2 = safe_ptr<T, dynamic<T, ReturnType, function>>;
+
 template<class T>
 using c_ptr = safe_ptr<T, c_free<T>>;
 
+template<class It>
+std::string_view view(It begin, It end) {
+  return std::string_view { (const char *)begin, (std::size_t)(end - begin) };
+}
+
+template<class T>
+std::string_view view(const T &data) {
+  return std::string_view((const char *)&data, sizeof(T));
+}
+
 namespace endian {
 template<class T = void>
 struct endianness {
   enum : bool {
 #if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || \
-    defined(__BIG_ENDIAN__) || \
-    defined(__ARMEB__) || \
-    defined(__THUMBEB__) || \
-    defined(__AARCH64EB__) || \
-    defined(_MIBSEB) || defined(__MIBSEB) || defined(__MIBSEB__)
+  defined(__BIG_ENDIAN__) ||                                 \
+  defined(__ARMEB__) ||                                      \
+  defined(__THUMBEB__) ||                                    \
+  defined(__AARCH64EB__) ||                                  \
+  defined(_MIBSEB) || defined(__MIBSEB) || defined(__MIBSEB__)
     // It's a big-endian target architecture
     little = false,
 #elif defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN || \
-    defined(__LITTLE_ENDIAN__) || \
-    defined(__ARMEL__) || \
-    defined(__THUMBEL__) || \
-    defined(__AARCH64EL__) || \
-    defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || \
-    defined(_WIN32)
+  defined(__LITTLE_ENDIAN__) ||                                   \
+  defined(__ARMEL__) ||                                           \
+  defined(__THUMBEL__) ||                                         \
+  defined(__AARCH64EL__) ||                                       \
+  defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || \
+  defined(_WIN32)
     // It's a little-endian target architecture
-      little = true,
+    little = true,
 #else
 #error "Unknown Endianness"
 #endif
@@ -761,15 +836,14 @@ struct endianness {
 };
 
 template<class T, class S = void>
-struct endian_helper { };
+struct endian_helper {};
 
 template<class T>
 struct endian_helper<T, std::enable_if_t<
-  !(instantiation_of_v<std::optional, T>)
->> {
+                          !(instantiation_of_v<std::optional, T>)>> {
   static inline T big(T x) {
-    if constexpr (endianness<T>::little) {
-      uint8_t *data = reinterpret_cast<uint8_t*>(&x);
+    if constexpr(endianness<T>::little) {
+      uint8_t *data = reinterpret_cast<uint8_t *>(&x);
 
       std::reverse(data, data + sizeof(x));
     }
@@ -778,8 +852,8 @@ struct endian_helper<T, std::enable_if_t<
   }
 
   static inline T little(T x) {
-    if constexpr (endianness<T>::big) {
-      uint8_t *data = reinterpret_cast<uint8_t*>(&x);
+    if constexpr(endianness<T>::big) {
+      uint8_t *data = reinterpret_cast<uint8_t *>(&x);
 
       std::reverse(data, data + sizeof(x));
     }
@@ -790,32 +864,31 @@ struct endian_helper<T, std::enable_if_t<
 
 template<class T>
 struct endian_helper<T, std::enable_if_t<
-  instantiation_of_v<std::optional, T>
->> {
-static inline T little(T x) {
-  if(!x) return x;
+                          instantiation_of_v<std::optional, T>>> {
+  static inline T little(T x) {
+    if(!x) return x;
 
-  if constexpr (endianness<T>::big) {
-    auto *data = reinterpret_cast<uint8_t*>(&*x);
+    if constexpr(endianness<T>::big) {
+      auto *data = reinterpret_cast<uint8_t *>(&*x);
 
-    std::reverse(data, data + sizeof(*x));
+      std::reverse(data, data + sizeof(*x));
+    }
+
+    return x;
   }
 
-  return x;
-}
 
+  static inline T big(T x) {
+    if(!x) return x;
 
-static inline T big(T x) {
-  if(!x) return x;
+    if constexpr(endianness<T>::little) {
+      auto *data = reinterpret_cast<uint8_t *>(&*x);
 
-  if constexpr (endianness<T>::big) {
-    auto *data = reinterpret_cast<uint8_t*>(&*x);
+      std::reverse(data, data + sizeof(*x));
+    }
 
-    std::reverse(data, data + sizeof(*x));
+    return x;
   }
-
-  return x;
-}
 };
 
 template<class T>
@@ -823,7 +896,6 @@ inline auto little(T x) { return endian_helper<T>::little(x); }
 
 template<class T>
 inline auto big(T x) { return endian_helper<T>::big(x); }
-} /* endian */
-
-} /* util */
+} // namespace endian
+} // namespace util
 #endif

sunshine/uuid.h

@@ -18,12 +18,12 @@ union uuid_t {
     std::uniform_int_distribution<std::uint8_t> dist(0, std::numeric_limits<std::uint8_t>::max());
 
     uuid_t buf;
-    for (auto &el : buf.b8) {
+    for(auto &el : buf.b8) {
       el = dist(engine);
     }
 
-    buf.b8[7] &= (std::uint8_t) 0b00101111;
-    buf.b8[9] &= (std::uint8_t) 0b10011111;
+    buf.b8[7] &= (std::uint8_t)0b00101111;
+    buf.b8[9] &= (std::uint8_t)0b10011111;
 
     return buf;
   }
@@ -31,7 +31,7 @@ union uuid_t {
   static uuid_t generate() {
     std::random_device r;
 
-    std::default_random_engine engine{r()};
+    std::default_random_engine engine { r() };
 
     return generate(engine);
   }
@@ -41,7 +41,7 @@ union uuid_t {
 
     result.reserve(sizeof(uuid_t) * 2 + 4);
 
-    auto hex = util::hex(*this, true);
+    auto hex      = util::hex(*this, true);
     auto hex_view = hex.to_string_view();
 
     std::string_view slices[] = {
@@ -75,5 +75,5 @@ union uuid_t {
     return (b64[0] > other.b64[0] || (b64[0] == other.b64[0] && b64[1] > other.b64[1]));
   }
 };
-}
+} // namespace util
 #endif //T_MAN_UUID_H

sunshine/video.h

@@ -5,9 +5,9 @@
 #ifndef SUNSHINE_VIDEO_H
 #define SUNSHINE_VIDEO_H
 
-#include "thread_safe.h"
 #include "input.h"
 #include "platform/common.h"
+#include "thread_safe.h"
 
 extern "C" {
 #include <libavcodec/avcodec.h>
@@ -18,15 +18,15 @@ namespace video {
 
 struct packet_raw_t : public AVPacket {
   void init_packet() {
-    pts                  = AV_NOPTS_VALUE;
-    dts                  = AV_NOPTS_VALUE;
-    pos                  = -1;
-    duration             = 0;
-    flags                = 0;
-    stream_index         = 0;
-    buf                  = nullptr;
-    side_data            = nullptr;
-    side_data_elems      = 0;
+    pts             = AV_NOPTS_VALUE;
+    dts             = AV_NOPTS_VALUE;
+    pos             = -1;
+    duration        = 0;
+    flags           = 0;
+    stream_index    = 0;
+    buf             = nullptr;
+    side_data       = nullptr;
+    side_data_elems = 0;
   }
 
   template<class P>
@@ -42,13 +42,21 @@ struct packet_raw_t : public AVPacket {
     av_packet_unref(this);
   }
 
+  struct replace_t {
+    std::string_view old;
+    std::string_view _new;
+
+    KITTY_DEFAULT_CONSTR(replace_t)
+
+    replace_t(std::string_view old, std::string_view _new) noexcept : old { std::move(old) }, _new { std::move(_new) } {}
+  };
+
+  std::vector<replace_t> *replacements;
+
   void *channel_data;
 };
 
-using packet_t       = std::unique_ptr<packet_raw_t>;
-using packet_queue_t = std::shared_ptr<safe::queue_t<packet_t>>;
-using idr_event_t    = std::shared_ptr<safe::event_t<std::pair<int64_t, int64_t>>>;
-using img_event_t    = std::shared_ptr<safe::event_t<std::shared_ptr<platf::img_t>>>;
+using packet_t = std::unique_ptr<packet_raw_t>;
 
 struct config_t {
   int width;
@@ -62,14 +70,26 @@ struct config_t {
   int dynamicRange;
 };
 
+using float4 = float[4];
+using float3 = float[3];
+using float2 = float[2];
+
+struct __attribute__((__aligned__(16))) color_t {
+  float4 color_vec_y;
+  float4 color_vec_u;
+  float4 color_vec_v;
+  float2 range_y;
+  float2 range_uv;
+};
+
+extern color_t colors[4];
+
 void capture(
-  safe::signal_t *shutdown_event,
-  packet_queue_t packets,
-  idr_event_t idr_events,
+  safe::mail_t mail,
   config_t config,
   void *channel_data);
 
 int init();
-}
+} // namespace video
 
 #endif //SUNSHINE_VIDEO_H

third-party/cbs/CMakeLists.txt

@@ -0,0 +1,69 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(CBS)
+
+SET(CBS_SOURCE_FILES
+include/cbs/av1.h
+include/cbs/cbs_av1.h
+include/cbs/cbs_bsf.h
+include/cbs/cbs.h
+include/cbs/cbs_h2645.h
+include/cbs/cbs_h264.h
+include/cbs/cbs_h265.h
+include/cbs/cbs_jpeg.h
+include/cbs/cbs_mpeg2.h
+include/cbs/cbs_sei.h
+include/cbs/cbs_vp9.h
+include/cbs/h2645_parse.h
+include/cbs/h264.h
+include/cbs/hevc.h
+include/cbs/sei.h
+include/cbs/video_levels.h
+
+cbs.c
+cbs_h2645.c
+cbs_av1.c
+cbs_vp9.c
+cbs_mpeg2.c
+cbs_jpeg.c
+cbs_sei.c
+h2645_parse.c
+video_levels.c
+
+bytestream.h
+cbs_internal.h
+defs.h
+get_bits.h
+h264_ps.h
+h264_sei.h
+hevc_sei.h
+intmath.h
+mathops.h
+put_bits.h
+vlc.h
+config.h
+)
+
+include_directories(include)
+
+if(DEFINED FFMPEG_INCLUDE_DIRS)
+include_directories(${FFMPEG_INCLUDE_DIRS})
+endif()
+
+add_compile_definitions(
+    HAVE_THREADS=1
+    HAVE_FAST_UNALIGNED
+
+    PIC=1
+
+    CONFIG_CBS_AV1=1
+    CONFIG_CBS_H264=1
+    CONFIG_CBS_H265=1
+    CONFIG_CBS_JPEG=1
+    CONFIG_CBS_MPEG2=1
+    CONFIG_CBS_VP9=1
+    )
+
+
+add_library(cbs ${CBS_SOURCE_FILES})
+target_compile_options(cbs PRIVATE -Wall -Wno-incompatible-pointer-types -Wno-maybe-uninitialized -Wno-format -Wno-format-extra-args)

third-party/cbs/bytestream.h

@@ -0,0 +1,351 @@
+/*
+ * Bytestream functions
+ * copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr>
+ * Copyright (c) 2012 Aneesh Dogra (lionaneesh) <lionaneesh@gmail.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_BYTESTREAM_H
+#define AVCODEC_BYTESTREAM_H
+
+#include "config.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include <libavutil/avassert.h>
+#include <libavutil/common.h>
+#include <libavutil/intreadwrite.h>
+
+typedef struct GetByteContext {
+  const uint8_t *buffer, *buffer_end, *buffer_start;
+} GetByteContext;
+
+typedef struct PutByteContext {
+  uint8_t *buffer, *buffer_end, *buffer_start;
+  int eof;
+} PutByteContext;
+
+#define DEF(type, name, bytes, read, write)                                    \
+  static av_always_inline type bytestream_get_##name(const uint8_t **b) {      \
+    (*b) += bytes;                                                             \
+    return read(*b - bytes);                                                   \
+  }                                                                            \
+  static av_always_inline void bytestream_put_##name(uint8_t **b,              \
+    const type value) {                                                        \
+    write(*b, value);                                                          \
+    (*b) += bytes;                                                             \
+  }                                                                            \
+  static av_always_inline void bytestream2_put_##name##u(PutByteContext *p,    \
+    const type value) {                                                        \
+    bytestream_put_##name(&p->buffer, value);                                  \
+  }                                                                            \
+  static av_always_inline void bytestream2_put_##name(PutByteContext *p,       \
+    const type value) {                                                        \
+    if(!p->eof && (p->buffer_end - p->buffer >= bytes)) {                      \
+      write(p->buffer, value);                                                 \
+      p->buffer += bytes;                                                      \
+    }                                                                          \
+    else                                                                       \
+      p->eof = 1;                                                              \
+  }                                                                            \
+  static av_always_inline type bytestream2_get_##name##u(GetByteContext *g) {  \
+    return bytestream_get_##name(&g->buffer);                                  \
+  }                                                                            \
+  static av_always_inline type bytestream2_get_##name(GetByteContext *g) {     \
+    if(g->buffer_end - g->buffer < bytes) {                                    \
+      g->buffer = g->buffer_end;                                               \
+      return 0;                                                                \
+    }                                                                          \
+    return bytestream2_get_##name##u(g);                                       \
+  }                                                                            \
+  static av_always_inline type bytestream2_peek_##name##u(GetByteContext *g) { \
+    return read(g->buffer);                                                    \
+  }                                                                            \
+  static av_always_inline type bytestream2_peek_##name(GetByteContext *g) {    \
+    if(g->buffer_end - g->buffer < bytes)                                      \
+      return 0;                                                                \
+    return bytestream2_peek_##name##u(g);                                      \
+  }
+
+DEF(uint64_t, le64, 8, AV_RL64, AV_WL64)
+DEF(unsigned int, le32, 4, AV_RL32, AV_WL32)
+DEF(unsigned int, le24, 3, AV_RL24, AV_WL24)
+DEF(unsigned int, le16, 2, AV_RL16, AV_WL16)
+DEF(uint64_t, be64, 8, AV_RB64, AV_WB64)
+DEF(unsigned int, be32, 4, AV_RB32, AV_WB32)
+DEF(unsigned int, be24, 3, AV_RB24, AV_WB24)
+DEF(unsigned int, be16, 2, AV_RB16, AV_WB16)
+DEF(unsigned int, byte, 1, AV_RB8, AV_WB8)
+
+#if AV_HAVE_BIGENDIAN
+#define bytestream2_get_ne16 bytestream2_get_be16
+#define bytestream2_get_ne24 bytestream2_get_be24
+#define bytestream2_get_ne32 bytestream2_get_be32
+#define bytestream2_get_ne64 bytestream2_get_be64
+#define bytestream2_get_ne16u bytestream2_get_be16u
+#define bytestream2_get_ne24u bytestream2_get_be24u
+#define bytestream2_get_ne32u bytestream2_get_be32u
+#define bytestream2_get_ne64u bytestream2_get_be64u
+#define bytestream2_put_ne16 bytestream2_put_be16
+#define bytestream2_put_ne24 bytestream2_put_be24
+#define bytestream2_put_ne32 bytestream2_put_be32
+#define bytestream2_put_ne64 bytestream2_put_be64
+#define bytestream2_peek_ne16 bytestream2_peek_be16
+#define bytestream2_peek_ne24 bytestream2_peek_be24
+#define bytestream2_peek_ne32 bytestream2_peek_be32
+#define bytestream2_peek_ne64 bytestream2_peek_be64
+#else
+#define bytestream2_get_ne16 bytestream2_get_le16
+#define bytestream2_get_ne24 bytestream2_get_le24
+#define bytestream2_get_ne32 bytestream2_get_le32
+#define bytestream2_get_ne64 bytestream2_get_le64
+#define bytestream2_get_ne16u bytestream2_get_le16u
+#define bytestream2_get_ne24u bytestream2_get_le24u
+#define bytestream2_get_ne32u bytestream2_get_le32u
+#define bytestream2_get_ne64u bytestream2_get_le64u
+#define bytestream2_put_ne16 bytestream2_put_le16
+#define bytestream2_put_ne24 bytestream2_put_le24
+#define bytestream2_put_ne32 bytestream2_put_le32
+#define bytestream2_put_ne64 bytestream2_put_le64
+#define bytestream2_peek_ne16 bytestream2_peek_le16
+#define bytestream2_peek_ne24 bytestream2_peek_le24
+#define bytestream2_peek_ne32 bytestream2_peek_le32
+#define bytestream2_peek_ne64 bytestream2_peek_le64
+#endif
+
+static av_always_inline void bytestream2_init(GetByteContext *g,
+  const uint8_t *buf,
+  int buf_size) {
+  av_assert0(buf_size >= 0);
+  g->buffer       = buf;
+  g->buffer_start = buf;
+  g->buffer_end   = buf + buf_size;
+}
+
+static av_always_inline void bytestream2_init_writer(PutByteContext *p,
+  uint8_t *buf,
+  int buf_size) {
+  av_assert0(buf_size >= 0);
+  p->buffer       = buf;
+  p->buffer_start = buf;
+  p->buffer_end   = buf + buf_size;
+  p->eof          = 0;
+}
+
+static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g) {
+  return g->buffer_end - g->buffer;
+}
+
+static av_always_inline int bytestream2_get_bytes_left_p(PutByteContext *p) {
+  return p->buffer_end - p->buffer;
+}
+
+static av_always_inline void bytestream2_skip(GetByteContext *g,
+  unsigned int size) {
+  g->buffer += FFMIN(g->buffer_end - g->buffer, size);
+}
+
+static av_always_inline void bytestream2_skipu(GetByteContext *g,
+  unsigned int size) {
+  g->buffer += size;
+}
+
+static av_always_inline void bytestream2_skip_p(PutByteContext *p,
+  unsigned int size) {
+  int size2;
+  if(p->eof)
+    return;
+  size2 = FFMIN(p->buffer_end - p->buffer, size);
+  if(size2 != size)
+    p->eof = 1;
+  p->buffer += size2;
+}
+
+static av_always_inline int bytestream2_tell(GetByteContext *g) {
+  return (int)(g->buffer - g->buffer_start);
+}
+
+static av_always_inline int bytestream2_tell_p(PutByteContext *p) {
+  return (int)(p->buffer - p->buffer_start);
+}
+
+static av_always_inline int bytestream2_size(GetByteContext *g) {
+  return (int)(g->buffer_end - g->buffer_start);
+}
+
+static av_always_inline int bytestream2_size_p(PutByteContext *p) {
+  return (int)(p->buffer_end - p->buffer_start);
+}
+
+static av_always_inline int bytestream2_seek(GetByteContext *g,
+  int offset,
+  int whence) {
+  switch(whence) {
+  case SEEK_CUR:
+    offset = av_clip(offset, -(g->buffer - g->buffer_start),
+      g->buffer_end - g->buffer);
+    g->buffer += offset;
+    break;
+  case SEEK_END:
+    offset    = av_clip(offset, -(g->buffer_end - g->buffer_start), 0);
+    g->buffer = g->buffer_end + offset;
+    break;
+  case SEEK_SET:
+    offset    = av_clip(offset, 0, g->buffer_end - g->buffer_start);
+    g->buffer = g->buffer_start + offset;
+    break;
+  default:
+    return AVERROR(EINVAL);
+  }
+  return bytestream2_tell(g);
+}
+
+static av_always_inline int bytestream2_seek_p(PutByteContext *p,
+  int offset,
+  int whence) {
+  p->eof = 0;
+  switch(whence) {
+  case SEEK_CUR:
+    if(p->buffer_end - p->buffer < offset)
+      p->eof = 1;
+    offset = av_clip(offset, -(p->buffer - p->buffer_start),
+      p->buffer_end - p->buffer);
+    p->buffer += offset;
+    break;
+  case SEEK_END:
+    if(offset > 0)
+      p->eof = 1;
+    offset    = av_clip(offset, -(p->buffer_end - p->buffer_start), 0);
+    p->buffer = p->buffer_end + offset;
+    break;
+  case SEEK_SET:
+    if(p->buffer_end - p->buffer_start < offset)
+      p->eof = 1;
+    offset    = av_clip(offset, 0, p->buffer_end - p->buffer_start);
+    p->buffer = p->buffer_start + offset;
+    break;
+  default:
+    return AVERROR(EINVAL);
+  }
+  return bytestream2_tell_p(p);
+}
+
+static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g,
+  uint8_t *dst,
+  unsigned int size) {
+  int size2 = FFMIN(g->buffer_end - g->buffer, size);
+  memcpy(dst, g->buffer, size2);
+  g->buffer += size2;
+  return size2;
+}
+
+static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g,
+  uint8_t *dst,
+  unsigned int size) {
+  memcpy(dst, g->buffer, size);
+  g->buffer += size;
+  return size;
+}
+
+static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p,
+  const uint8_t *src,
+  unsigned int size) {
+  int size2;
+  if(p->eof)
+    return 0;
+  size2 = FFMIN(p->buffer_end - p->buffer, size);
+  if(size2 != size)
+    p->eof = 1;
+  memcpy(p->buffer, src, size2);
+  p->buffer += size2;
+  return size2;
+}
+
+static av_always_inline unsigned int bytestream2_put_bufferu(PutByteContext *p,
+  const uint8_t *src,
+  unsigned int size) {
+  memcpy(p->buffer, src, size);
+  p->buffer += size;
+  return size;
+}
+
+static av_always_inline void bytestream2_set_buffer(PutByteContext *p,
+  const uint8_t c,
+  unsigned int size) {
+  int size2;
+  if(p->eof)
+    return;
+  size2 = FFMIN(p->buffer_end - p->buffer, size);
+  if(size2 != size)
+    p->eof = 1;
+  memset(p->buffer, c, size2);
+  p->buffer += size2;
+}
+
+static av_always_inline void bytestream2_set_bufferu(PutByteContext *p,
+  const uint8_t c,
+  unsigned int size) {
+  memset(p->buffer, c, size);
+  p->buffer += size;
+}
+
+static av_always_inline unsigned int bytestream2_get_eof(PutByteContext *p) {
+  return p->eof;
+}
+
+static av_always_inline unsigned int bytestream2_copy_bufferu(PutByteContext *p,
+  GetByteContext *g,
+  unsigned int size) {
+  memcpy(p->buffer, g->buffer, size);
+  p->buffer += size;
+  g->buffer += size;
+  return size;
+}
+
+static av_always_inline unsigned int bytestream2_copy_buffer(PutByteContext *p,
+  GetByteContext *g,
+  unsigned int size) {
+  int size2;
+
+  if(p->eof)
+    return 0;
+  size  = FFMIN(g->buffer_end - g->buffer, size);
+  size2 = FFMIN(p->buffer_end - p->buffer, size);
+  if(size2 != size)
+    p->eof = 1;
+
+  return bytestream2_copy_bufferu(p, g, size2);
+}
+
+static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b,
+  uint8_t *dst,
+  unsigned int size) {
+  memcpy(dst, *b, size);
+  (*b) += size;
+  return size;
+}
+
+static av_always_inline void bytestream_put_buffer(uint8_t **b,
+  const uint8_t *src,
+  unsigned int size) {
+  memcpy(*b, src, size);
+  (*b) += size;
+}
+
+#endif /* AVCODEC_BYTESTREAM_H */

third-party/cbs/cbs_internal.h

@@ -0,0 +1,220 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CBS_INTERNAL_H
+#define AVCODEC_CBS_INTERNAL_H
+
+#include <stdint.h>
+
+#include <libavutil/buffer.h>
+#include <libavutil/log.h>
+
+#include "cbs/cbs.h"
+#include "get_bits.h"
+#include "put_bits.h"
+
+
+enum CBSContentType {
+  // Unit content is a simple structure.
+  CBS_CONTENT_TYPE_POD,
+  // Unit content contains some references to other structures, but all
+  // managed via buffer reference counting.  The descriptor defines the
+  // structure offsets of every buffer reference.
+  CBS_CONTENT_TYPE_INTERNAL_REFS,
+  // Unit content is something more complex.  The descriptor defines
+  // special functions to manage the content.
+  CBS_CONTENT_TYPE_COMPLEX,
+};
+
+enum {
+  // Maximum number of unit types described by the same unit type
+  // descriptor.
+  CBS_MAX_UNIT_TYPES = 3,
+  // Maximum number of reference buffer offsets in any one unit.
+  CBS_MAX_REF_OFFSETS = 2,
+  // Special value used in a unit type descriptor to indicate that it
+  // applies to a large range of types rather than a set of discrete
+  // values.
+  CBS_UNIT_TYPE_RANGE = -1,
+};
+
+typedef const struct CodedBitstreamUnitTypeDescriptor {
+  // Number of entries in the unit_types array, or the special value
+  // CBS_UNIT_TYPE_RANGE to indicate that the range fields should be
+  // used instead.
+  int nb_unit_types;
+
+  // Array of unit types that this entry describes.
+  const CodedBitstreamUnitType unit_types[CBS_MAX_UNIT_TYPES];
+
+  // Start and end of unit type range, used if nb_unit_types is
+  // CBS_UNIT_TYPE_RANGE.
+  const CodedBitstreamUnitType unit_type_range_start;
+  const CodedBitstreamUnitType unit_type_range_end;
+
+  // The type of content described.
+  enum CBSContentType content_type;
+  // The size of the structure which should be allocated to contain
+  // the decomposed content of this type of unit.
+  size_t content_size;
+
+  // Number of entries in the ref_offsets array.  Only used if the
+  // content_type is CBS_CONTENT_TYPE_INTERNAL_REFS.
+  int nb_ref_offsets;
+  // The structure must contain two adjacent elements:
+  //   type        *field;
+  //   AVBufferRef *field_ref;
+  // where field points to something in the buffer referred to by
+  // field_ref.  This offset is then set to offsetof(struct, field).
+  size_t ref_offsets[CBS_MAX_REF_OFFSETS];
+
+  void (*content_free)(void *opaque, uint8_t *data);
+  int (*content_clone)(AVBufferRef **ref, CodedBitstreamUnit *unit);
+} CodedBitstreamUnitTypeDescriptor;
+
+typedef struct CodedBitstreamType {
+  enum AVCodecID codec_id;
+
+  // A class for the private data, used to declare private AVOptions.
+  // This field is NULL for types that do not declare any options.
+  // If this field is non-NULL, the first member of the filter private data
+  // must be a pointer to AVClass.
+  const AVClass *priv_class;
+
+  size_t priv_data_size;
+
+  // List of unit type descriptors for this codec.
+  // Terminated by a descriptor with nb_unit_types equal to zero.
+  const CodedBitstreamUnitTypeDescriptor *unit_types;
+
+  // Split frag->data into coded bitstream units, creating the
+  // frag->units array.  Fill data but not content on each unit.
+  // The header argument should be set if the fragment came from
+  // a header block, which may require different parsing for some
+  // codecs (e.g. the AVCC header in H.264).
+  int (*split_fragment)(CodedBitstreamContext *ctx,
+    CodedBitstreamFragment *frag,
+    int header);
+
+  // Read the unit->data bitstream and decompose it, creating
+  // unit->content.
+  int (*read_unit)(CodedBitstreamContext *ctx,
+    CodedBitstreamUnit *unit);
+
+  // Write the data bitstream from unit->content into pbc.
+  // Return value AVERROR(ENOSPC) indicates that pbc was too small.
+  int (*write_unit)(CodedBitstreamContext *ctx,
+    CodedBitstreamUnit *unit,
+    PutBitContext *pbc);
+
+  // Read the data from all of frag->units and assemble it into
+  // a bitstream for the whole fragment.
+  int (*assemble_fragment)(CodedBitstreamContext *ctx,
+    CodedBitstreamFragment *frag);
+
+  // Reset the codec internal state.
+  void (*flush)(CodedBitstreamContext *ctx);
+
+  // Free the codec internal state.
+  void (*close)(CodedBitstreamContext *ctx);
+} CodedBitstreamType;
+
+
+// Helper functions for trace output.
+
+void ff_cbs_trace_header(CodedBitstreamContext *ctx,
+  const char *name);
+
+void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position,
+  const char *name, const int *subscripts,
+  const char *bitstring, int64_t value);
+
+
+// Helper functions for read/write of common bitstream elements, including
+// generation of trace output.
+
+int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc,
+  int width, const char *name,
+  const int *subscripts, uint32_t *write_to,
+  uint32_t range_min, uint32_t range_max);
+
+int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc,
+  int width, const char *name,
+  const int *subscripts, uint32_t value,
+  uint32_t range_min, uint32_t range_max);
+
+int ff_cbs_read_signed(CodedBitstreamContext *ctx, GetBitContext *gbc,
+  int width, const char *name,
+  const int *subscripts, int32_t *write_to,
+  int32_t range_min, int32_t range_max);
+
+int ff_cbs_write_signed(CodedBitstreamContext *ctx, PutBitContext *pbc,
+  int width, const char *name,
+  const int *subscripts, int32_t value,
+  int32_t range_min, int32_t range_max);
+
+// The largest unsigned value representable in N bits, suitable for use as
+// range_max in the above functions.
+#define MAX_UINT_BITS(length) ((UINT64_C(1) << (length)) - 1)
+
+// The largest signed value representable in N bits, suitable for use as
+// range_max in the above functions.
+#define MAX_INT_BITS(length) ((INT64_C(1) << ((length)-1)) - 1)
+
+// The smallest signed value representable in N bits, suitable for use as
+// range_min in the above functions.
+#define MIN_INT_BITS(length) (-(INT64_C(1) << ((length)-1)))
+
+
+#define CBS_UNIT_TYPE_POD(type, structure) \
+  {                                        \
+    .nb_unit_types = 1,                    \
+    .unit_types    = { type },             \
+    .content_type  = CBS_CONTENT_TYPE_POD, \
+    .content_size  = sizeof(structure),    \
+  }
+#define CBS_UNIT_TYPE_INTERNAL_REF(type, structure, ref_field) \
+  {                                                            \
+    .nb_unit_types  = 1,                                       \
+    .unit_types     = { type },                                \
+    .content_type   = CBS_CONTENT_TYPE_INTERNAL_REFS,          \
+    .content_size   = sizeof(structure),                       \
+    .nb_ref_offsets = 1,                                       \
+    .ref_offsets    = { offsetof(structure, ref_field) },      \
+  }
+#define CBS_UNIT_TYPE_COMPLEX(type, structure, free_func) \
+  {                                                       \
+    .nb_unit_types = 1,                                   \
+    .unit_types    = { type },                            \
+    .content_type  = CBS_CONTENT_TYPE_COMPLEX,            \
+    .content_size  = sizeof(structure),                   \
+    .content_free  = free_func,                           \
+  }
+#define CBS_UNIT_TYPE_END_OF_LIST \
+  { .nb_unit_types = 0 }
+
+
+extern const CodedBitstreamType ff_cbs_type_av1;
+extern const CodedBitstreamType ff_cbs_type_h264;
+extern const CodedBitstreamType ff_cbs_type_h265;
+extern const CodedBitstreamType ff_cbs_type_jpeg;
+extern const CodedBitstreamType ff_cbs_type_mpeg2;
+extern const CodedBitstreamType ff_cbs_type_vp9;
+
+
+#endif /* AVCODEC_CBS_INTERNAL_H */

third-party/cbs/cbs_jpeg.c

@@ -0,0 +1,482 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "cbs/cbs_jpeg.h"
+#include "cbs/cbs.h"
+
+#include "cbs_internal.h"
+
+
+#define HEADER(name)                \
+  do {                              \
+    ff_cbs_trace_header(ctx, name); \
+  } while(0)
+
+#define CHECK(call) \
+  do {              \
+    err = (call);   \
+    if(err < 0)     \
+      return err;   \
+  } while(0)
+
+#define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]) { subs, __VA_ARGS__ }) : NULL)
+
+#define u(width, name, range_min, range_max) \
+  xu(width, name, range_min, range_max, 0, )
+#define us(width, name, sub, range_min, range_max) \
+  xu(width, name, range_min, range_max, 1, sub)
+
+
+#define READ
+#define READWRITE read
+#define RWContext GetBitContext
+#define FUNC(name) cbs_jpeg_read_##name
+
+#define xu(width, name, range_min, range_max, subs, ...) \
+  do {                                                   \
+    uint32_t value;                                      \
+    CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name,    \
+      SUBSCRIPTS(subs, __VA_ARGS__),                     \
+      &value, range_min, range_max));                    \
+    current->name = value;                               \
+  } while(0)
+
+#include "cbs_jpeg_syntax_template.c"
+
+#undef READ
+#undef READWRITE
+#undef RWContext
+#undef FUNC
+#undef xu
+
+#define WRITE
+#define READWRITE write
+#define RWContext PutBitContext
+#define FUNC(name) cbs_jpeg_write_##name
+
+#define xu(width, name, range_min, range_max, subs, ...) \
+  do {                                                   \
+    uint32_t value = current->name;                      \
+    CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name,   \
+      SUBSCRIPTS(subs, __VA_ARGS__),                     \
+      value, range_min, range_max));                     \
+  } while(0)
+
+
+#include "cbs_jpeg_syntax_template.c"
+
+#undef WRITE
+#undef READWRITE
+#undef RWContext
+#undef FUNC
+#undef xu
+
+
+static void cbs_jpeg_free_application_data(void *opaque, uint8_t *content) {
+  JPEGRawApplicationData *ad = (JPEGRawApplicationData *)content;
+  av_buffer_unref(&ad->Ap_ref);
+  av_freep(&content);
+}
+
+static void cbs_jpeg_free_comment(void *opaque, uint8_t *content) {
+  JPEGRawComment *comment = (JPEGRawComment *)content;
+  av_buffer_unref(&comment->Cm_ref);
+  av_freep(&content);
+}
+
+static void cbs_jpeg_free_scan(void *opaque, uint8_t *content) {
+  JPEGRawScan *scan = (JPEGRawScan *)content;
+  av_buffer_unref(&scan->data_ref);
+  av_freep(&content);
+}
+
+static int cbs_jpeg_split_fragment(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *frag,
+  int header) {
+  AVBufferRef *data_ref;
+  uint8_t *data;
+  size_t data_size;
+  int unit, start, end, marker, next_start, next_marker;
+  int err, i, j, length;
+
+  if(frag->data_size < 4) {
+    // Definitely too short to be meaningful.
+    return AVERROR_INVALIDDATA;
+  }
+
+  for(i = 0; i + 1 < frag->data_size && frag->data[i] != 0xff; i++)
+    ;
+  if(i > 0) {
+    av_log(ctx->log_ctx, AV_LOG_WARNING, "Discarding %d bytes at "
+                                         "beginning of image.\n",
+      i);
+  }
+  for(++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++)
+    ;
+  if(i + 1 >= frag->data_size && frag->data[i]) {
+    av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
+                                       "no SOI marker found.\n");
+    return AVERROR_INVALIDDATA;
+  }
+  marker = frag->data[i];
+  if(marker != JPEG_MARKER_SOI) {
+    av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: first "
+                                       "marker is %02x, should be SOI.\n",
+      marker);
+    return AVERROR_INVALIDDATA;
+  }
+  for(++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++)
+    ;
+  if(i + 1 >= frag->data_size) {
+    av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
+                                       "no image content found.\n");
+    return AVERROR_INVALIDDATA;
+  }
+  marker = frag->data[i];
+  start  = i + 1;
+
+  for(unit = 0;; unit++) {
+    if(marker == JPEG_MARKER_EOI) {
+      break;
+    }
+    else if(marker == JPEG_MARKER_SOS) {
+      next_marker = -1;
+      end         = start;
+      for(i = start; i + 1 < frag->data_size; i++) {
+        if(frag->data[i] != 0xff)
+          continue;
+        end = i;
+        for(++i; i + 1 < frag->data_size &&
+                 frag->data[i] == 0xff;
+            i++)
+          ;
+        if(i + 1 < frag->data_size) {
+          if(frag->data[i] == 0x00)
+            continue;
+          next_marker = frag->data[i];
+          next_start  = i + 1;
+        }
+        break;
+      }
+    }
+    else {
+      i = start;
+      if(i + 2 > frag->data_size) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
+                                           "truncated at %02x marker.\n",
+          marker);
+        return AVERROR_INVALIDDATA;
+      }
+      length = AV_RB16(frag->data + i);
+      if(i + length > frag->data_size) {
+        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
+                                           "truncated at %02x marker segment.\n",
+          marker);
+        return AVERROR_INVALIDDATA;
+      }
+      end = start + length;
+
+      i = end;
+      if(frag->data[i] != 0xff) {
+        next_marker = -1;
+      }
+      else {
+        for(++i; i + 1 < frag->data_size &&
+                 frag->data[i] == 0xff;
+            i++)
+          ;
+        if(i + 1 >= frag->data_size) {
+          next_marker = -1;
+        }
+        else {
+          next_marker = frag->data[i];
+          next_start  = i + 1;
+        }
+      }
+    }
+
+    if(marker == JPEG_MARKER_SOS) {
+      length = AV_RB16(frag->data + start);
+
+      if(length > end - start)
+        return AVERROR_INVALIDDATA;
+
+      data_ref = NULL;
+      data     = av_malloc(end - start +
+                       AV_INPUT_BUFFER_PADDING_SIZE);
+      if(!data)
+        return AVERROR(ENOMEM);
+
+      memcpy(data, frag->data + start, length);
+      for(i = start + length, j = length; i < end; i++, j++) {
+        if(frag->data[i] == 0xff) {
+          while(frag->data[i] == 0xff)
+            ++i;
+          data[j] = 0xff;
+        }
+        else {
+          data[j] = frag->data[i];
+        }
+      }
+      data_size = j;
+
+      memset(data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+    }
+    else {
+      data      = frag->data + start;
+      data_size = end - start;
+      data_ref  = frag->data_ref;
+    }
+
+    err = ff_cbs_insert_unit_data(frag, unit, marker,
+      data, data_size, data_ref);
+    if(err < 0)
+      return err;
+
+    if(next_marker == -1)
+      break;
+    marker = next_marker;
+    start  = next_start;
+  }
+
+  return 0;
+}
+
+static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit) {
+  GetBitContext gbc;
+  int err;
+
+  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
+  if(err < 0)
+    return err;
+
+  if(unit->type >= JPEG_MARKER_SOF0 &&
+     unit->type <= JPEG_MARKER_SOF3) {
+    err = ff_cbs_alloc_unit_content(unit,
+      sizeof(JPEGRawFrameHeader),
+      NULL);
+    if(err < 0)
+      return err;
+
+    err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content);
+    if(err < 0)
+      return err;
+  }
+  else if(unit->type >= JPEG_MARKER_APPN &&
+          unit->type <= JPEG_MARKER_APPN + 15) {
+    err = ff_cbs_alloc_unit_content(unit,
+      sizeof(JPEGRawApplicationData),
+      &cbs_jpeg_free_application_data);
+    if(err < 0)
+      return err;
+
+    err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content);
+    if(err < 0)
+      return err;
+  }
+  else if(unit->type == JPEG_MARKER_SOS) {
+    JPEGRawScan *scan;
+    int pos;
+
+    err = ff_cbs_alloc_unit_content(unit,
+      sizeof(JPEGRawScan),
+      &cbs_jpeg_free_scan);
+    if(err < 0)
+      return err;
+    scan = unit->content;
+
+    err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header);
+    if(err < 0)
+      return err;
+
+    pos = get_bits_count(&gbc);
+    av_assert0(pos % 8 == 0);
+    if(pos > 0) {
+      scan->data_size = unit->data_size - pos / 8;
+      scan->data_ref  = av_buffer_ref(unit->data_ref);
+      if(!scan->data_ref)
+        return AVERROR(ENOMEM);
+      scan->data = unit->data + pos / 8;
+    }
+  }
+  else {
+    switch(unit->type) {
+#define SEGMENT(marker, type, func, free)                 \
+  case JPEG_MARKER_##marker: {                            \
+    err = ff_cbs_alloc_unit_content(unit,                 \
+      sizeof(type), free);                                \
+    if(err < 0)                                           \
+      return err;                                         \
+    err = cbs_jpeg_read_##func(ctx, &gbc, unit->content); \
+    if(err < 0)                                           \
+      return err;                                         \
+  } break
+      SEGMENT(DQT, JPEGRawQuantisationTableSpecification, dqt, NULL);
+      SEGMENT(DHT, JPEGRawHuffmanTableSpecification, dht, NULL);
+      SEGMENT(COM, JPEGRawComment, comment, &cbs_jpeg_free_comment);
+#undef SEGMENT
+    default:
+      return AVERROR(ENOSYS);
+    }
+  }
+
+  return 0;
+}
+
+static int cbs_jpeg_write_scan(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  PutBitContext *pbc) {
+  JPEGRawScan *scan = unit->content;
+  int err;
+
+  err = cbs_jpeg_write_scan_header(ctx, pbc, &scan->header);
+  if(err < 0)
+    return err;
+
+  if(scan->data) {
+    if(scan->data_size * 8 > put_bits_left(pbc))
+      return AVERROR(ENOSPC);
+
+    av_assert0(put_bits_count(pbc) % 8 == 0);
+
+    flush_put_bits(pbc);
+
+    memcpy(put_bits_ptr(pbc), scan->data, scan->data_size);
+    skip_put_bytes(pbc, scan->data_size);
+  }
+
+  return 0;
+}
+
+static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  PutBitContext *pbc) {
+  int err;
+
+  if(unit->type >= JPEG_MARKER_SOF0 &&
+     unit->type <= JPEG_MARKER_SOF3) {
+    err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content);
+  }
+  else if(unit->type >= JPEG_MARKER_APPN &&
+          unit->type <= JPEG_MARKER_APPN + 15) {
+    err = cbs_jpeg_write_application_data(ctx, pbc, unit->content);
+  }
+  else {
+    switch(unit->type) {
+#define SEGMENT(marker, func)                             \
+  case JPEG_MARKER_##marker:                              \
+    err = cbs_jpeg_write_##func(ctx, pbc, unit->content); \
+    break;
+      SEGMENT(DQT, dqt);
+      SEGMENT(DHT, dht);
+      SEGMENT(COM, comment);
+    default:
+      return AVERROR_PATCHWELCOME;
+    }
+  }
+
+  return err;
+}
+
+static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  PutBitContext *pbc) {
+  if(unit->type == JPEG_MARKER_SOS)
+    return cbs_jpeg_write_scan(ctx, unit, pbc);
+  else
+    return cbs_jpeg_write_segment(ctx, unit, pbc);
+}
+
+static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *frag) {
+  const CodedBitstreamUnit *unit;
+  uint8_t *data;
+  size_t size, dp, sp;
+  int i;
+
+  size = 4; // SOI + EOI.
+  for(i = 0; i < frag->nb_units; i++) {
+    unit = &frag->units[i];
+    size += 2 + unit->data_size;
+    if(unit->type == JPEG_MARKER_SOS) {
+      for(sp = 0; sp < unit->data_size; sp++) {
+        if(unit->data[sp] == 0xff)
+          ++size;
+      }
+    }
+  }
+
+  frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
+  if(!frag->data_ref)
+    return AVERROR(ENOMEM);
+  data = frag->data_ref->data;
+
+  dp = 0;
+
+  data[dp++] = 0xff;
+  data[dp++] = JPEG_MARKER_SOI;
+
+  for(i = 0; i < frag->nb_units; i++) {
+    unit = &frag->units[i];
+
+    data[dp++] = 0xff;
+    data[dp++] = unit->type;
+
+    if(unit->type != JPEG_MARKER_SOS) {
+      memcpy(data + dp, unit->data, unit->data_size);
+      dp += unit->data_size;
+    }
+    else {
+      sp = AV_RB16(unit->data);
+      av_assert0(sp <= unit->data_size);
+      memcpy(data + dp, unit->data, sp);
+      dp += sp;
+
+      for(; sp < unit->data_size; sp++) {
+        if(unit->data[sp] == 0xff) {
+          data[dp++] = 0xff;
+          data[dp++] = 0x00;
+        }
+        else {
+          data[dp++] = unit->data[sp];
+        }
+      }
+    }
+  }
+
+  data[dp++] = 0xff;
+  data[dp++] = JPEG_MARKER_EOI;
+
+  av_assert0(dp == size);
+
+  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+  frag->data      = data;
+  frag->data_size = size;
+
+  return 0;
+}
+
+const CodedBitstreamType ff_cbs_type_jpeg = {
+  .codec_id = AV_CODEC_ID_MJPEG,
+
+  .split_fragment    = &cbs_jpeg_split_fragment,
+  .read_unit         = &cbs_jpeg_read_unit,
+  .write_unit        = &cbs_jpeg_write_unit,
+  .assemble_fragment = &cbs_jpeg_assemble_fragment,
+};

third-party/cbs/cbs_jpeg_syntax_template.c

@@ -0,0 +1,189 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+static int FUNC(frame_header)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawFrameHeader *current) {
+  int err, i;
+
+  HEADER("Frame Header");
+
+  u(16, Lf, 8, 8 + 3 * JPEG_MAX_COMPONENTS);
+
+  u(8, P, 2, 16);
+  u(16, Y, 0, JPEG_MAX_HEIGHT);
+  u(16, X, 1, JPEG_MAX_WIDTH);
+  u(8, Nf, 1, JPEG_MAX_COMPONENTS);
+
+  for(i = 0; i < current->Nf; i++) {
+    us(8, C[i], i, 0, JPEG_MAX_COMPONENTS);
+    us(4, H[i], i, 1, 4);
+    us(4, V[i], i, 1, 4);
+    us(8, Tq[i], i, 0, 3);
+  }
+
+  return 0;
+}
+
+static int FUNC(quantisation_table)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawQuantisationTable *current) {
+  int err, i;
+
+  u(4, Pq, 0, 1);
+  u(4, Tq, 0, 3);
+
+  if(current->Pq) {
+    for(i = 0; i < 64; i++)
+      us(16, Q[i], i, 1, 255);
+  }
+  else {
+    for(i = 0; i < 64; i++)
+      us(8, Q[i], i, 1, 255);
+  }
+
+  return 0;
+}
+
+static int FUNC(dqt)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawQuantisationTableSpecification *current) {
+  int err, i, n;
+
+  HEADER("Quantisation Tables");
+
+  u(16, Lq, 2, 2 + 4 * 65);
+  n = current->Lq / 65;
+
+  for(i = 0; i < n; i++)
+    CHECK(FUNC(quantisation_table)(ctx, rw, &current->table[i]));
+
+  return 0;
+}
+
+static int FUNC(huffman_table)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawHuffmanTable *current) {
+  int err, i, j, ij;
+
+  u(4, Tc, 0, 1);
+  u(4, Th, 0, 3);
+
+  for(i = 0; i < 16; i++)
+    us(8, L[i], i, 0, 224);
+
+  ij = 0;
+  for(i = 0; i < 16; i++) {
+    for(j = 0; j < current->L[i]; j++) {
+      if(ij >= 224)
+        return AVERROR_INVALIDDATA;
+      us(8, V[ij], ij, 0, 255);
+      ++ij;
+    }
+  }
+
+  return 0;
+}
+
+static int FUNC(dht)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawHuffmanTableSpecification *current) {
+  int err, i, j, n;
+
+  HEADER("Huffman Tables");
+
+  u(16, Lh, 2, 2 + 8 * (1 + 16 + 256));
+
+  n = 2;
+  for(i = 0; n < current->Lh; i++) {
+    if(i >= 8)
+      return AVERROR_INVALIDDATA;
+
+    CHECK(FUNC(huffman_table)(ctx, rw, &current->table[i]));
+
+    ++n;
+    for(j = 0; j < 16; j++)
+      n += 1 + current->table[i].L[j];
+  }
+
+  return 0;
+}
+
+static int FUNC(scan_header)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawScanHeader *current) {
+  int err, j;
+
+  HEADER("Scan");
+
+  u(16, Ls, 6, 6 + 2 * JPEG_MAX_COMPONENTS);
+
+  u(8, Ns, 1, 4);
+  for(j = 0; j < current->Ns; j++) {
+    us(8, Cs[j], j, 0, JPEG_MAX_COMPONENTS);
+    us(4, Td[j], j, 0, 3);
+    us(4, Ta[j], j, 0, 3);
+  }
+
+  u(8, Ss, 0, 63);
+  u(8, Se, 0, 63);
+  u(4, Ah, 0, 13);
+  u(4, Al, 0, 15);
+
+  return 0;
+}
+
+static int FUNC(application_data)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawApplicationData *current) {
+  int err, i;
+
+  HEADER("Application Data");
+
+  u(16, Lp, 2, 65535);
+
+  if(current->Lp > 2) {
+#ifdef READ
+    current->Ap_ref = av_buffer_alloc(current->Lp - 2);
+    if(!current->Ap_ref)
+      return AVERROR(ENOMEM);
+    current->Ap = current->Ap_ref->data;
+#endif
+
+    for(i = 0; i < current->Lp - 2; i++)
+      us(8, Ap[i], i, 0, 255);
+  }
+
+  return 0;
+}
+
+static int FUNC(comment)(CodedBitstreamContext *ctx, RWContext *rw,
+  JPEGRawComment *current) {
+  int err, i;
+
+  HEADER("Comment");
+
+  u(16, Lc, 2, 65535);
+
+  if(current->Lc > 2) {
+#ifdef READ
+    current->Cm_ref = av_buffer_alloc(current->Lc - 2);
+    if(!current->Cm_ref)
+      return AVERROR(ENOMEM);
+    current->Cm = current->Cm_ref->data;
+#endif
+
+    for(i = 0; i < current->Lc - 2; i++)
+      us(8, Cm[i], i, 0, 255);
+  }
+
+  return 0;
+}

third-party/cbs/cbs_mpeg2.c

@@ -0,0 +1,469 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <libavutil/avassert.h>
+
+#include "cbs/cbs.h"
+#include "cbs/cbs_mpeg2.h"
+
+#include "cbs_internal.h"
+
+
+#define HEADER(name)                \
+  do {                              \
+    ff_cbs_trace_header(ctx, name); \
+  } while(0)
+
+#define CHECK(call) \
+  do {              \
+    err = (call);   \
+    if(err < 0)     \
+      return err;   \
+  } while(0)
+
+#define FUNC_NAME(rw, codec, name) cbs_##codec##_##rw##_##name
+#define FUNC_MPEG2(rw, name) FUNC_NAME(rw, mpeg2, name)
+#define FUNC(name) FUNC_MPEG2(READWRITE, name)
+
+#define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]) { subs, __VA_ARGS__ }) : NULL)
+
+#define ui(width, name) \
+  xui(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )
+#define uir(width, name) \
+  xui(width, name, current->name, 1, MAX_UINT_BITS(width), 0, )
+#define uis(width, name, subs, ...) \
+  xui(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
+#define uirs(width, name, subs, ...) \
+  xui(width, name, current->name, 1, MAX_UINT_BITS(width), subs, __VA_ARGS__)
+#define xui(width, name, var, range_min, range_max, subs, ...) \
+  xuia(width, #name, var, range_min, range_max, subs, __VA_ARGS__)
+#define sis(width, name, subs, ...) \
+  xsi(width, name, current->name, subs, __VA_ARGS__)
+
+#define marker_bit() \
+  bit("marker_bit", 1)
+#define bit(string, value)                   \
+  do {                                       \
+    av_unused uint32_t bit = value;          \
+    xuia(1, string, bit, value, value, 0, ); \
+  } while(0)
+
+
+#define READ
+#define READWRITE read
+#define RWContext GetBitContext
+
+#define xuia(width, string, var, range_min, range_max, subs, ...) \
+  do {                                                            \
+    uint32_t value;                                               \
+    CHECK(ff_cbs_read_unsigned(ctx, rw, width, string,            \
+      SUBSCRIPTS(subs, __VA_ARGS__),                              \
+      &value, range_min, range_max));                             \
+    var = value;                                                  \
+  } while(0)
+
+#define xsi(width, name, var, subs, ...)            \
+  do {                                              \
+    int32_t value;                                  \
+    CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
+      SUBSCRIPTS(subs, __VA_ARGS__), &value,        \
+      MIN_INT_BITS(width),                          \
+      MAX_INT_BITS(width)));                        \
+    var = value;                                    \
+  } while(0)
+
+#define nextbits(width, compare, var) \
+  (get_bits_left(rw) >= width &&      \
+    (var = show_bits(rw, width)) == (compare))
+
+#define infer(name, value) \
+  do {                     \
+    current->name = value; \
+  } while(0)
+
+#include "cbs_mpeg2_syntax_template.c"
+
+#undef READ
+#undef READWRITE
+#undef RWContext
+#undef xuia
+#undef xsi
+#undef nextbits
+#undef infer
+
+
+#define WRITE
+#define READWRITE write
+#define RWContext PutBitContext
+
+#define xuia(width, string, var, range_min, range_max, subs, ...) \
+  do {                                                            \
+    CHECK(ff_cbs_write_unsigned(ctx, rw, width, string,           \
+      SUBSCRIPTS(subs, __VA_ARGS__),                              \
+      var, range_min, range_max));                                \
+  } while(0)
+
+#define xsi(width, name, var, subs, ...)             \
+  do {                                               \
+    CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
+      SUBSCRIPTS(subs, __VA_ARGS__), var,            \
+      MIN_INT_BITS(width),                           \
+      MAX_INT_BITS(width)));                         \
+  } while(0)
+
+#define nextbits(width, compare, var) (var)
+
+#define infer(name, value)                                                              \
+  do {                                                                                  \
+    if(current->name != (value)) {                                                      \
+      av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: "                                  \
+                                           "%s does not match inferred value: "         \
+                                           "%" PRId64 ", but should be %" PRId64 ".\n", \
+        #name, (int64_t)current->name, (int64_t)(value));                               \
+    }                                                                                   \
+  } while(0)
+
+#include "cbs_mpeg2_syntax_template.c"
+
+#undef WRITE
+#undef READWRITE
+#undef RWContext
+#undef xuia
+#undef xsi
+#undef nextbits
+#undef infer
+
+static const uint8_t *avpriv_find_start_code(const uint8_t *restrict p,
+  const uint8_t *end,
+  uint32_t *restrict state) {
+  int i;
+
+  av_assert0(p <= end);
+  if(p >= end)
+    return end;
+
+  for(i = 0; i < 3; i++) {
+    uint32_t tmp = *state << 8;
+    *state       = tmp + *(p++);
+    if(tmp == 0x100 || p == end)
+      return p;
+  }
+
+  while(p < end) {
+    if(p[-1] > 1) p += 3;
+    else if(p[-2])
+      p += 2;
+    else if(p[-3] | (p[-1] - 1))
+      p++;
+    else {
+      p++;
+      break;
+    }
+  }
+
+  p      = FFMIN(p, end) - 4;
+  *state = AV_RB32(p);
+
+  return p + 4;
+}
+
+static int cbs_mpeg2_split_fragment(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *frag,
+  int header) {
+  const uint8_t *start, *end;
+  CodedBitstreamUnitType unit_type;
+  uint32_t start_code = -1;
+  size_t unit_size;
+  int err, i, final = 0;
+
+  start = avpriv_find_start_code(frag->data, frag->data + frag->data_size,
+    &start_code);
+  if(start_code >> 8 != 0x000001) {
+    // No start code found.
+    return AVERROR_INVALIDDATA;
+  }
+
+  for(i = 0;; i++) {
+    unit_type = start_code & 0xff;
+
+    if(start == frag->data + frag->data_size) {
+      // The last four bytes form a start code which constitutes
+      // a unit of its own.  In this situation avpriv_find_start_code
+      // won't modify start_code at all so modify start_code so that
+      // the next unit will be treated as the last unit.
+      start_code = 0;
+    }
+
+    end = avpriv_find_start_code(start--, frag->data + frag->data_size,
+      &start_code);
+
+    // start points to the byte containing the start_code_identifier
+    // (may be the last byte of fragment->data); end points to the byte
+    // following the byte containing the start code identifier (or to
+    // the end of fragment->data).
+    if(start_code >> 8 == 0x000001) {
+      // Unit runs from start to the beginning of the start code
+      // pointed to by end (including any padding zeroes).
+      unit_size = (end - 4) - start;
+    }
+    else {
+      // We didn't find a start code, so this is the final unit.
+      unit_size = end - start;
+      final     = 1;
+    }
+
+    err = ff_cbs_insert_unit_data(frag, i, unit_type, (uint8_t *)start,
+      unit_size, frag->data_ref);
+    if(err < 0)
+      return err;
+
+    if(final)
+      break;
+
+    start = end;
+  }
+
+  return 0;
+}
+
+static int cbs_mpeg2_read_unit(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit) {
+  GetBitContext gbc;
+  int err;
+
+  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
+  if(err < 0)
+    return err;
+
+  err = ff_cbs_alloc_unit_content2(ctx, unit);
+  if(err < 0)
+    return err;
+
+  if(MPEG2_START_IS_SLICE(unit->type)) {
+    MPEG2RawSlice *slice = unit->content;
+    int pos, len;
+
+    err = cbs_mpeg2_read_slice_header(ctx, &gbc, &slice->header);
+    if(err < 0)
+      return err;
+
+    if(!get_bits_left(&gbc))
+      return AVERROR_INVALIDDATA;
+
+    pos = get_bits_count(&gbc);
+    len = unit->data_size;
+
+    slice->data_size = len - pos / 8;
+    slice->data_ref  = av_buffer_ref(unit->data_ref);
+    if(!slice->data_ref)
+      return AVERROR(ENOMEM);
+    slice->data = unit->data + pos / 8;
+
+    slice->data_bit_start = pos % 8;
+  }
+  else {
+    switch(unit->type) {
+#define START(start_code, type, read_func, free_func)             \
+  case start_code: {                                              \
+    type *header = unit->content;                                 \
+    err          = cbs_mpeg2_read_##read_func(ctx, &gbc, header); \
+    if(err < 0)                                                   \
+      return err;                                                 \
+  } break;
+      START(MPEG2_START_PICTURE, MPEG2RawPictureHeader,
+        picture_header, &cbs_mpeg2_free_picture_header);
+      START(MPEG2_START_USER_DATA, MPEG2RawUserData,
+        user_data, &cbs_mpeg2_free_user_data);
+      START(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader,
+        sequence_header, NULL);
+      START(MPEG2_START_EXTENSION, MPEG2RawExtensionData,
+        extension_data, NULL);
+      START(MPEG2_START_GROUP, MPEG2RawGroupOfPicturesHeader,
+        group_of_pictures_header, NULL);
+      START(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd,
+        sequence_end, NULL);
+#undef START
+    default:
+      return AVERROR(ENOSYS);
+    }
+  }
+
+  return 0;
+}
+
+static int cbs_mpeg2_write_header(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  PutBitContext *pbc) {
+  int err;
+
+  switch(unit->type) {
+#define START(start_code, type, func)                      \
+  case start_code:                                         \
+    err = cbs_mpeg2_write_##func(ctx, pbc, unit->content); \
+    break;
+    START(MPEG2_START_PICTURE, MPEG2RawPictureHeader, picture_header);
+    START(MPEG2_START_USER_DATA, MPEG2RawUserData, user_data);
+    START(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader, sequence_header);
+    START(MPEG2_START_EXTENSION, MPEG2RawExtensionData, extension_data);
+    START(MPEG2_START_GROUP, MPEG2RawGroupOfPicturesHeader,
+      group_of_pictures_header);
+    START(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd, sequence_end);
+#undef START
+  default:
+    av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for start "
+                                       "code %02" PRIx32 ".\n",
+      unit->type);
+    return AVERROR_PATCHWELCOME;
+  }
+
+  return err;
+}
+
+static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  PutBitContext *pbc) {
+  MPEG2RawSlice *slice = unit->content;
+  int err;
+
+  err = cbs_mpeg2_write_slice_header(ctx, pbc, &slice->header);
+  if(err < 0)
+    return err;
+
+  if(slice->data) {
+    size_t rest  = slice->data_size - (slice->data_bit_start + 7) / 8;
+    uint8_t *pos = slice->data + slice->data_bit_start / 8;
+
+    av_assert0(slice->data_bit_start >= 0 &&
+               slice->data_size > slice->data_bit_start / 8);
+
+    if(slice->data_size * 8 + 8 > put_bits_left(pbc))
+      return AVERROR(ENOSPC);
+
+    // First copy the remaining bits of the first byte
+    if(slice->data_bit_start % 8)
+      put_bits(pbc, 8 - slice->data_bit_start % 8,
+        *pos++ & MAX_UINT_BITS(8 - slice->data_bit_start % 8));
+
+    if(put_bits_count(pbc) % 8 == 0) {
+      // If the writer is aligned at this point,
+      // memcpy can be used to improve performance.
+      // This is the normal case.
+      flush_put_bits(pbc);
+      memcpy(put_bits_ptr(pbc), pos, rest);
+      skip_put_bytes(pbc, rest);
+    }
+    else {
+      // If not, we have to copy manually:
+      for(; rest > 3; rest -= 4, pos += 4)
+        put_bits32(pbc, AV_RB32(pos));
+
+      for(; rest; rest--, pos++)
+        put_bits(pbc, 8, *pos);
+
+      // Align with zeros
+      put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);
+    }
+  }
+
+  return 0;
+}
+
+static int cbs_mpeg2_write_unit(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  PutBitContext *pbc) {
+  if(MPEG2_START_IS_SLICE(unit->type))
+    return cbs_mpeg2_write_slice(ctx, unit, pbc);
+  else
+    return cbs_mpeg2_write_header(ctx, unit, pbc);
+}
+
+static int cbs_mpeg2_assemble_fragment(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *frag) {
+  uint8_t *data;
+  size_t size, dp;
+  int i;
+
+  size = 0;
+  for(i = 0; i < frag->nb_units; i++)
+    size += 3 + frag->units[i].data_size;
+
+  frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
+  if(!frag->data_ref)
+    return AVERROR(ENOMEM);
+  data = frag->data_ref->data;
+
+  dp = 0;
+  for(i = 0; i < frag->nb_units; i++) {
+    CodedBitstreamUnit *unit = &frag->units[i];
+
+    data[dp++] = 0;
+    data[dp++] = 0;
+    data[dp++] = 1;
+
+    memcpy(data + dp, unit->data, unit->data_size);
+    dp += unit->data_size;
+  }
+
+  av_assert0(dp == size);
+
+  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+  frag->data      = data;
+  frag->data_size = size;
+
+  return 0;
+}
+
+static const CodedBitstreamUnitTypeDescriptor cbs_mpeg2_unit_types[] = {
+  CBS_UNIT_TYPE_INTERNAL_REF(MPEG2_START_PICTURE, MPEG2RawPictureHeader,
+    extra_information_picture.extra_information),
+
+  {
+    .nb_unit_types         = CBS_UNIT_TYPE_RANGE,
+    .unit_type_range_start = 0x01,
+    .unit_type_range_end   = 0xaf,
+
+    .content_type   = CBS_CONTENT_TYPE_INTERNAL_REFS,
+    .content_size   = sizeof(MPEG2RawSlice),
+    .nb_ref_offsets = 2,
+    .ref_offsets    = { offsetof(MPEG2RawSlice, header.extra_information_slice.extra_information),
+      offsetof(MPEG2RawSlice, data) },
+  },
+
+  CBS_UNIT_TYPE_INTERNAL_REF(MPEG2_START_USER_DATA, MPEG2RawUserData,
+    user_data),
+
+  CBS_UNIT_TYPE_POD(MPEG2_START_SEQUENCE_HEADER, MPEG2RawSequenceHeader),
+  CBS_UNIT_TYPE_POD(MPEG2_START_EXTENSION, MPEG2RawExtensionData),
+  CBS_UNIT_TYPE_POD(MPEG2_START_SEQUENCE_END, MPEG2RawSequenceEnd),
+  CBS_UNIT_TYPE_POD(MPEG2_START_GROUP, MPEG2RawGroupOfPicturesHeader),
+
+  CBS_UNIT_TYPE_END_OF_LIST
+};
+
+const CodedBitstreamType ff_cbs_type_mpeg2 = {
+  .codec_id = AV_CODEC_ID_MPEG2VIDEO,
+
+  .priv_data_size = sizeof(CodedBitstreamMPEG2Context),
+
+  .unit_types = cbs_mpeg2_unit_types,
+
+  .split_fragment    = &cbs_mpeg2_split_fragment,
+  .read_unit         = &cbs_mpeg2_read_unit,
+  .write_unit        = &cbs_mpeg2_write_unit,
+  .assemble_fragment = &cbs_mpeg2_assemble_fragment,
+};

third-party/cbs/cbs_mpeg2_syntax_template.c

@@ -0,0 +1,413 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+static int FUNC(sequence_header)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawSequenceHeader *current) {
+  CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
+  int err, i;
+
+  HEADER("Sequence Header");
+
+  ui(8, sequence_header_code);
+
+  uir(12, horizontal_size_value);
+  uir(12, vertical_size_value);
+
+  mpeg2->horizontal_size = current->horizontal_size_value;
+  mpeg2->vertical_size   = current->vertical_size_value;
+
+  uir(4, aspect_ratio_information);
+  uir(4, frame_rate_code);
+  ui(18, bit_rate_value);
+
+  marker_bit();
+
+  ui(10, vbv_buffer_size_value);
+  ui(1, constrained_parameters_flag);
+
+  ui(1, load_intra_quantiser_matrix);
+  if(current->load_intra_quantiser_matrix) {
+    for(i = 0; i < 64; i++)
+      uirs(8, intra_quantiser_matrix[i], 1, i);
+  }
+
+  ui(1, load_non_intra_quantiser_matrix);
+  if(current->load_non_intra_quantiser_matrix) {
+    for(i = 0; i < 64; i++)
+      uirs(8, non_intra_quantiser_matrix[i], 1, i);
+  }
+
+  return 0;
+}
+
+static int FUNC(user_data)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawUserData *current) {
+  size_t k;
+  int err;
+
+  HEADER("User Data");
+
+  ui(8, user_data_start_code);
+
+#ifdef READ
+  k = get_bits_left(rw);
+  av_assert0(k % 8 == 0);
+  current->user_data_length = k /= 8;
+  if(k > 0) {
+    current->user_data_ref = av_buffer_allocz(k + AV_INPUT_BUFFER_PADDING_SIZE);
+    if(!current->user_data_ref)
+      return AVERROR(ENOMEM);
+    current->user_data = current->user_data_ref->data;
+  }
+#endif
+
+  for(k = 0; k < current->user_data_length; k++)
+    uis(8, user_data[k], 1, k);
+
+  return 0;
+}
+
+static int FUNC(sequence_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawSequenceExtension *current) {
+  CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
+  int err;
+
+  HEADER("Sequence Extension");
+
+  ui(8, profile_and_level_indication);
+  ui(1, progressive_sequence);
+  ui(2, chroma_format);
+  ui(2, horizontal_size_extension);
+  ui(2, vertical_size_extension);
+
+  mpeg2->horizontal_size = (mpeg2->horizontal_size & 0xfff) |
+                           current->horizontal_size_extension << 12;
+  mpeg2->vertical_size = (mpeg2->vertical_size & 0xfff) |
+                         current->vertical_size_extension << 12;
+  mpeg2->progressive_sequence = current->progressive_sequence;
+
+  ui(12, bit_rate_extension);
+  marker_bit();
+  ui(8, vbv_buffer_size_extension);
+  ui(1, low_delay);
+  ui(2, frame_rate_extension_n);
+  ui(5, frame_rate_extension_d);
+
+  return 0;
+}
+
+static int FUNC(sequence_display_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawSequenceDisplayExtension *current) {
+  int err;
+
+  HEADER("Sequence Display Extension");
+
+  ui(3, video_format);
+
+  ui(1, colour_description);
+  if(current->colour_description) {
+#ifdef READ
+#define READ_AND_PATCH(name)                                                                     \
+  do {                                                                                           \
+    ui(8, name);                                                                                 \
+    if(current->name == 0) {                                                                     \
+      current->name = 2;                                                                         \
+      av_log(ctx->log_ctx, AV_LOG_WARNING, "%s in a sequence display "                           \
+                                           "extension had the invalid value 0. Setting it to 2 " \
+                                           "(meaning unknown) instead.\n",                       \
+        #name);                                                                                  \
+    }                                                                                            \
+  } while(0)
+    READ_AND_PATCH(colour_primaries);
+    READ_AND_PATCH(transfer_characteristics);
+    READ_AND_PATCH(matrix_coefficients);
+#undef READ_AND_PATCH
+#else
+    uir(8, colour_primaries);
+    uir(8, transfer_characteristics);
+    uir(8, matrix_coefficients);
+#endif
+  }
+  else {
+    infer(colour_primaries, 2);
+    infer(transfer_characteristics, 2);
+    infer(matrix_coefficients, 2);
+  }
+
+  ui(14, display_horizontal_size);
+  marker_bit();
+  ui(14, display_vertical_size);
+
+  return 0;
+}
+
+static int FUNC(group_of_pictures_header)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawGroupOfPicturesHeader *current) {
+  int err;
+
+  HEADER("Group of Pictures Header");
+
+  ui(8, group_start_code);
+
+  ui(25, time_code);
+  ui(1, closed_gop);
+  ui(1, broken_link);
+
+  return 0;
+}
+
+static int FUNC(extra_information)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawExtraInformation *current,
+  const char *element_name, const char *marker_name) {
+  int err;
+  size_t k;
+#ifdef READ
+  GetBitContext start = *rw;
+  uint8_t bit;
+
+  for(k = 0; nextbits(1, 1, bit); k++)
+    skip_bits(rw, 1 + 8);
+  current->extra_information_length = k;
+  if(k > 0) {
+    *rw = start;
+    current->extra_information_ref =
+      av_buffer_allocz(k + AV_INPUT_BUFFER_PADDING_SIZE);
+    if(!current->extra_information_ref)
+      return AVERROR(ENOMEM);
+    current->extra_information = current->extra_information_ref->data;
+  }
+#endif
+
+  for(k = 0; k < current->extra_information_length; k++) {
+    bit(marker_name, 1);
+    xuia(8, element_name,
+      current->extra_information[k], 0, 255, 1, k);
+  }
+
+  bit(marker_name, 0);
+
+  return 0;
+}
+
+static int FUNC(picture_header)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawPictureHeader *current) {
+  int err;
+
+  HEADER("Picture Header");
+
+  ui(8, picture_start_code);
+
+  ui(10, temporal_reference);
+  uir(3, picture_coding_type);
+  ui(16, vbv_delay);
+
+  if(current->picture_coding_type == 2 ||
+     current->picture_coding_type == 3) {
+    ui(1, full_pel_forward_vector);
+    ui(3, forward_f_code);
+  }
+
+  if(current->picture_coding_type == 3) {
+    ui(1, full_pel_backward_vector);
+    ui(3, backward_f_code);
+  }
+
+  CHECK(FUNC(extra_information)(ctx, rw, &current->extra_information_picture,
+    "extra_information_picture[k]", "extra_bit_picture"));
+
+  return 0;
+}
+
+static int FUNC(picture_coding_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawPictureCodingExtension *current) {
+  CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
+  int err;
+
+  HEADER("Picture Coding Extension");
+
+  uir(4, f_code[0][0]);
+  uir(4, f_code[0][1]);
+  uir(4, f_code[1][0]);
+  uir(4, f_code[1][1]);
+
+  ui(2, intra_dc_precision);
+  ui(2, picture_structure);
+  ui(1, top_field_first);
+  ui(1, frame_pred_frame_dct);
+  ui(1, concealment_motion_vectors);
+  ui(1, q_scale_type);
+  ui(1, intra_vlc_format);
+  ui(1, alternate_scan);
+  ui(1, repeat_first_field);
+  ui(1, chroma_420_type);
+  ui(1, progressive_frame);
+
+  if(mpeg2->progressive_sequence) {
+    if(current->repeat_first_field) {
+      if(current->top_field_first)
+        mpeg2->number_of_frame_centre_offsets = 3;
+      else
+        mpeg2->number_of_frame_centre_offsets = 2;
+    }
+    else {
+      mpeg2->number_of_frame_centre_offsets = 1;
+    }
+  }
+  else {
+    if(current->picture_structure == 1 || // Top field.
+       current->picture_structure == 2) { // Bottom field.
+      mpeg2->number_of_frame_centre_offsets = 1;
+    }
+    else {
+      if(current->repeat_first_field)
+        mpeg2->number_of_frame_centre_offsets = 3;
+      else
+        mpeg2->number_of_frame_centre_offsets = 2;
+    }
+  }
+
+  ui(1, composite_display_flag);
+  if(current->composite_display_flag) {
+    ui(1, v_axis);
+    ui(3, field_sequence);
+    ui(1, sub_carrier);
+    ui(7, burst_amplitude);
+    ui(8, sub_carrier_phase);
+  }
+
+  return 0;
+}
+
+static int FUNC(quant_matrix_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawQuantMatrixExtension *current) {
+  int err, i;
+
+  HEADER("Quant Matrix Extension");
+
+  ui(1, load_intra_quantiser_matrix);
+  if(current->load_intra_quantiser_matrix) {
+    for(i = 0; i < 64; i++)
+      uirs(8, intra_quantiser_matrix[i], 1, i);
+  }
+
+  ui(1, load_non_intra_quantiser_matrix);
+  if(current->load_non_intra_quantiser_matrix) {
+    for(i = 0; i < 64; i++)
+      uirs(8, non_intra_quantiser_matrix[i], 1, i);
+  }
+
+  ui(1, load_chroma_intra_quantiser_matrix);
+  if(current->load_chroma_intra_quantiser_matrix) {
+    for(i = 0; i < 64; i++)
+      uirs(8, intra_quantiser_matrix[i], 1, i);
+  }
+
+  ui(1, load_chroma_non_intra_quantiser_matrix);
+  if(current->load_chroma_non_intra_quantiser_matrix) {
+    for(i = 0; i < 64; i++)
+      uirs(8, chroma_non_intra_quantiser_matrix[i], 1, i);
+  }
+
+  return 0;
+}
+
+static int FUNC(picture_display_extension)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawPictureDisplayExtension *current) {
+  CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
+  int err, i;
+
+  HEADER("Picture Display Extension");
+
+  for(i = 0; i < mpeg2->number_of_frame_centre_offsets; i++) {
+    sis(16, frame_centre_horizontal_offset[i], 1, i);
+    marker_bit();
+    sis(16, frame_centre_vertical_offset[i], 1, i);
+    marker_bit();
+  }
+
+  return 0;
+}
+
+static int FUNC(extension_data)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawExtensionData *current) {
+  int err;
+
+  HEADER("Extension Data");
+
+  ui(8, extension_start_code);
+  ui(4, extension_start_code_identifier);
+
+  switch(current->extension_start_code_identifier) {
+  case MPEG2_EXTENSION_SEQUENCE:
+    return FUNC(sequence_extension)(ctx, rw, &current->data.sequence);
+  case MPEG2_EXTENSION_SEQUENCE_DISPLAY:
+    return FUNC(sequence_display_extension)(ctx, rw, &current->data.sequence_display);
+  case MPEG2_EXTENSION_QUANT_MATRIX:
+    return FUNC(quant_matrix_extension)(ctx, rw, &current->data.quant_matrix);
+  case MPEG2_EXTENSION_PICTURE_DISPLAY:
+    return FUNC(picture_display_extension)(ctx, rw, &current->data.picture_display);
+  case MPEG2_EXTENSION_PICTURE_CODING:
+    return FUNC(picture_coding_extension)(ctx, rw, &current->data.picture_coding);
+  default:
+    av_log(ctx->log_ctx, AV_LOG_ERROR, "Extension ID %d not supported.\n",
+      current->extension_start_code_identifier);
+    return AVERROR_PATCHWELCOME;
+  }
+}
+
+static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawSliceHeader *current) {
+  CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
+  int err;
+
+  HEADER("Slice Header");
+
+  ui(8, slice_vertical_position);
+
+  if(mpeg2->vertical_size > 2800)
+    ui(3, slice_vertical_position_extension);
+  if(mpeg2->scalable) {
+    if(mpeg2->scalable_mode == 0)
+      ui(7, priority_breakpoint);
+  }
+
+  uir(5, quantiser_scale_code);
+
+  if(nextbits(1, 1, current->slice_extension_flag)) {
+    ui(1, slice_extension_flag);
+    ui(1, intra_slice);
+    ui(1, slice_picture_id_enable);
+    ui(6, slice_picture_id);
+  }
+
+  CHECK(FUNC(extra_information)(ctx, rw, &current->extra_information_slice,
+    "extra_information_slice[k]", "extra_bit_slice"));
+
+  return 0;
+}
+
+static int FUNC(sequence_end)(CodedBitstreamContext *ctx, RWContext *rw,
+  MPEG2RawSequenceEnd *current) {
+  int err;
+
+  HEADER("Sequence End");
+
+  ui(8, sequence_end_code);
+
+  return 0;
+}

third-party/cbs/cbs_sei.c

@@ -0,0 +1,355 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "cbs/cbs_sei.h"
+#include "cbs/cbs.h"
+#include "cbs/cbs_h264.h"
+#include "cbs/cbs_h265.h"
+
+#include "cbs_internal.h"
+
+static void cbs_free_user_data_registered(void *opaque, uint8_t *data) {
+  SEIRawUserDataRegistered *udr = (SEIRawUserDataRegistered *)data;
+  av_buffer_unref(&udr->data_ref);
+  av_free(udr);
+}
+
+static void cbs_free_user_data_unregistered(void *opaque, uint8_t *data) {
+  SEIRawUserDataUnregistered *udu = (SEIRawUserDataUnregistered *)data;
+  av_buffer_unref(&udu->data_ref);
+  av_free(udu);
+}
+
+int ff_cbs_sei_alloc_message_payload(SEIRawMessage *message,
+  const SEIMessageTypeDescriptor *desc) {
+  void (*free_func)(void *, uint8_t *);
+
+  av_assert0(message->payload == NULL &&
+             message->payload_ref == NULL);
+  message->payload_type = desc->type;
+
+  if(desc->type == SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35)
+    free_func = &cbs_free_user_data_registered;
+  else if(desc->type == SEI_TYPE_USER_DATA_UNREGISTERED)
+    free_func = &cbs_free_user_data_unregistered;
+  else
+    free_func = NULL;
+
+  if(free_func) {
+    message->payload = av_mallocz(desc->size);
+    if(!message->payload)
+      return AVERROR(ENOMEM);
+    message->payload_ref =
+      av_buffer_create(message->payload, desc->size,
+        free_func, NULL, 0);
+  }
+  else {
+    message->payload_ref = av_buffer_alloc(desc->size);
+  }
+  if(!message->payload_ref) {
+    av_freep(&message->payload);
+    return AVERROR(ENOMEM);
+  }
+  message->payload = message->payload_ref->data;
+
+  return 0;
+}
+
+int ff_cbs_sei_list_add(SEIRawMessageList *list) {
+  void *ptr;
+  int old_count = list->nb_messages_allocated;
+
+  av_assert0(list->nb_messages <= old_count);
+  if(list->nb_messages + 1 > old_count) {
+    int new_count = 2 * old_count + 1;
+
+    ptr = av_realloc_array(list->messages,
+      new_count, sizeof(*list->messages));
+    if(!ptr)
+      return AVERROR(ENOMEM);
+
+    list->messages              = ptr;
+    list->nb_messages_allocated = new_count;
+
+    // Zero the newly-added entries.
+    memset(list->messages + old_count, 0,
+      (new_count - old_count) * sizeof(*list->messages));
+  }
+  ++list->nb_messages;
+  return 0;
+}
+
+void ff_cbs_sei_free_message_list(SEIRawMessageList *list) {
+  for(int i = 0; i < list->nb_messages; i++) {
+    SEIRawMessage *message = &list->messages[i];
+    av_buffer_unref(&message->payload_ref);
+    av_buffer_unref(&message->extension_data_ref);
+  }
+  av_free(list->messages);
+}
+
+static int cbs_sei_get_unit(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *au,
+  int prefix,
+  CodedBitstreamUnit **sei_unit) {
+  CodedBitstreamUnit *unit;
+  int sei_type, highest_vcl_type, err, i, position;
+
+  switch(ctx->codec->codec_id) {
+  case AV_CODEC_ID_H264:
+    // (We can ignore auxiliary slices because we only have prefix
+    // SEI in H.264 and an auxiliary picture must always follow a
+    // primary picture.)
+    highest_vcl_type = H264_NAL_IDR_SLICE;
+    if(prefix)
+      sei_type = H264_NAL_SEI;
+    else
+      return AVERROR(EINVAL);
+    break;
+  case AV_CODEC_ID_H265:
+    highest_vcl_type = HEVC_NAL_RSV_VCL31;
+    if(prefix)
+      sei_type = HEVC_NAL_SEI_PREFIX;
+    else
+      sei_type = HEVC_NAL_SEI_SUFFIX;
+    break;
+  default:
+    return AVERROR(EINVAL);
+  }
+
+  // Find an existing SEI NAL unit of the right type.
+  unit = NULL;
+  for(i = 0; i < au->nb_units; i++) {
+    if(au->units[i].type == sei_type) {
+      unit = &au->units[i];
+      break;
+    }
+  }
+
+  if(unit) {
+    *sei_unit = unit;
+    return 0;
+  }
+
+  // Need to add a new SEI NAL unit ...
+  if(prefix) {
+    // ... before the first VCL NAL unit.
+    for(i = 0; i < au->nb_units; i++) {
+      if(au->units[i].type < highest_vcl_type)
+        break;
+    }
+    position = i;
+  }
+  else {
+    // ... after the last VCL NAL unit.
+    for(i = au->nb_units - 1; i >= 0; i--) {
+      if(au->units[i].type < highest_vcl_type)
+        break;
+    }
+    if(i < 0) {
+      // No VCL units; just put it at the end.
+      position = au->nb_units;
+    }
+    else {
+      position = i + 1;
+    }
+  }
+
+  err = ff_cbs_insert_unit_content(au, position, sei_type,
+    NULL, NULL);
+  if(err < 0)
+    return err;
+  unit       = &au->units[position];
+  unit->type = sei_type;
+
+  err = ff_cbs_alloc_unit_content2(ctx, unit);
+  if(err < 0)
+    return err;
+
+  switch(ctx->codec->codec_id) {
+  case AV_CODEC_ID_H264: {
+    H264RawSEI sei = {
+      .nal_unit_header = {
+        .nal_ref_idc   = 0,
+        .nal_unit_type = sei_type,
+      },
+    };
+    memcpy(unit->content, &sei, sizeof(sei));
+  } break;
+  case AV_CODEC_ID_H265: {
+    H265RawSEI sei = {
+      .nal_unit_header = {
+        .nal_unit_type         = sei_type,
+        .nuh_layer_id          = 0,
+        .nuh_temporal_id_plus1 = 1,
+      },
+    };
+    memcpy(unit->content, &sei, sizeof(sei));
+  } break;
+  default:
+    av_assert0(0);
+  }
+
+  *sei_unit = unit;
+  return 0;
+}
+
+static int cbs_sei_get_message_list(CodedBitstreamContext *ctx,
+  CodedBitstreamUnit *unit,
+  SEIRawMessageList **list) {
+  switch(ctx->codec->codec_id) {
+  case AV_CODEC_ID_H264: {
+    H264RawSEI *sei = unit->content;
+    if(unit->type != H264_NAL_SEI)
+      return AVERROR(EINVAL);
+    *list = &sei->message_list;
+  } break;
+  case AV_CODEC_ID_H265: {
+    H265RawSEI *sei = unit->content;
+    if(unit->type != HEVC_NAL_SEI_PREFIX &&
+       unit->type != HEVC_NAL_SEI_SUFFIX)
+      return AVERROR(EINVAL);
+    *list = &sei->message_list;
+  } break;
+  default:
+    return AVERROR(EINVAL);
+  }
+
+  return 0;
+}
+
+int ff_cbs_sei_add_message(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *au,
+  int prefix,
+  uint32_t payload_type,
+  void *payload_data,
+  AVBufferRef *payload_buf) {
+  const SEIMessageTypeDescriptor *desc;
+  CodedBitstreamUnit *unit;
+  SEIRawMessageList *list;
+  SEIRawMessage *message;
+  AVBufferRef *payload_ref;
+  int err;
+
+  desc = ff_cbs_sei_find_type(ctx, payload_type);
+  if(!desc)
+    return AVERROR(EINVAL);
+
+  // Find an existing SEI unit or make a new one to add to.
+  err = cbs_sei_get_unit(ctx, au, prefix, &unit);
+  if(err < 0)
+    return err;
+
+  // Find the message list inside the codec-dependent unit.
+  err = cbs_sei_get_message_list(ctx, unit, &list);
+  if(err < 0)
+    return err;
+
+  // Add a new message to the message list.
+  err = ff_cbs_sei_list_add(list);
+  if(err < 0)
+    return err;
+
+  if(payload_buf) {
+    payload_ref = av_buffer_ref(payload_buf);
+    if(!payload_ref)
+      return AVERROR(ENOMEM);
+  }
+  else {
+    payload_ref = NULL;
+  }
+
+  message = &list->messages[list->nb_messages - 1];
+
+  message->payload_type = payload_type;
+  message->payload      = payload_data;
+  message->payload_ref  = payload_ref;
+
+  return 0;
+}
+
+int ff_cbs_sei_find_message(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *au,
+  uint32_t payload_type,
+  SEIRawMessage **iter) {
+  int err, i, j, found;
+
+  found = 0;
+  for(i = 0; i < au->nb_units; i++) {
+    CodedBitstreamUnit *unit = &au->units[i];
+    SEIRawMessageList *list;
+
+    err = cbs_sei_get_message_list(ctx, unit, &list);
+    if(err < 0)
+      continue;
+
+    for(j = 0; j < list->nb_messages; j++) {
+      SEIRawMessage *message = &list->messages[j];
+
+      if(message->payload_type == payload_type) {
+        if(!*iter || found) {
+          *iter = message;
+          return 0;
+        }
+        if(message == *iter)
+          found = 1;
+      }
+    }
+  }
+
+  return AVERROR(ENOENT);
+}
+
+static void cbs_sei_delete_message(SEIRawMessageList *list,
+  int position) {
+  SEIRawMessage *message;
+
+  av_assert0(0 <= position && position < list->nb_messages);
+
+  message = &list->messages[position];
+  av_buffer_unref(&message->payload_ref);
+  av_buffer_unref(&message->extension_data_ref);
+
+  --list->nb_messages;
+
+  if(list->nb_messages > 0) {
+    memmove(list->messages + position,
+      list->messages + position + 1,
+      (list->nb_messages - position) * sizeof(*list->messages));
+  }
+}
+
+void ff_cbs_sei_delete_message_type(CodedBitstreamContext *ctx,
+  CodedBitstreamFragment *au,
+  uint32_t payload_type) {
+  int err, i, j;
+
+  for(i = 0; i < au->nb_units; i++) {
+    CodedBitstreamUnit *unit = &au->units[i];
+    SEIRawMessageList *list;
+
+    err = cbs_sei_get_message_list(ctx, unit, &list);
+    if(err < 0)
+      continue;
+
+    for(j = list->nb_messages - 1; j >= 0; j--) {
+      if(list->messages[j].payload_type == payload_type)
+        cbs_sei_delete_message(list, j);
+    }
+  }
+}