plugin: Don't add audio encoders

This is a temporary workaround until OBS supports selecting audio format for each stream.

.github/workflows/main.yml

@@ -3,32 +3,49 @@ name: CI
 on: [push, pull_request]
 
 jobs:
-  build:
+  windows:
     strategy:
       matrix:
         os: [windows-2016, windows-2019]
         include:
           - os: windows-2016
             generator_32: "Visual Studio 15 2017"
-            generator_64: "Visual Studio 15 2017 Win64"
+            generator_64: "Visual Studio 15 2017"
             sysversion: "10.0.17763.0"
           - os: windows-2019
-            generator_32: 
+            generator_32: "Visual Studio 16 2019"
             generator_64: "Visual Studio 16 2019"
             sysversion: "10.0.18362.0"
     runs-on: ${{ matrix.os }}
     steps:
-    - name: Clone Repository
+    - name: "Clone Repository"
       uses: actions/checkout@v1
-    - name: Update Submodules
-      run: git submodule update --init --force --recursive
     - name: Install Node.JS 10.x
       uses: actions/setup-node@v1
       with:
         node-version: 10
-    - name: Build
+    - name: Configure & Compile
       env:
         CMAKE_GENERATOR_32: ${{ matrix.generator_32 }}
         CMAKE_GENERATOR_64: ${{ matrix.generator_64 }}
         CMAKE_SYSTEM_VERSION: ${{ matrix.sysversion }}
       run: node ./ci/builder.js
+    - name: Package
+      env:
+        CMAKE_GENERATOR_32: ${{ matrix.generator_32 }}
+        CMAKE_GENERATOR_64: ${{ matrix.generator_64 }}
+      run: |
+        mkdir build/package
+        node ./ci/packager.js
+    - name: "Package Installer (Prereqs)"
+      run: |
+        curl "-kL" "https://cdn.xaymar.com/ci/innosetup-6.0.3.exe" "-f" "--retry" "5" "-o" "inno.exe"
+        .\inno.exe /VERYSILENT /SP- /SUPPRESSMSGBOXES /NORESTART
+    - name: "Package Installer (Compile)"
+      run: |
+        & 'C:\Program Files (x86)\Inno Setup 6\ISCC.exe' /Qp ".\build\64\installer.iss"
+    - name: "Upload Artifacts"
+      uses: actions/upload-artifact@v1
+      with:
+        name: ${{ matrix.os }}
+        path: build/package

CMakeLists.txt

@@ -25,7 +25,7 @@ Include("cmake/util.cmake")
 
 # Automatic Versioning
 set(VERSION_MAJOR 0)
-set(VERSION_MINOR 2)
+set(VERSION_MINOR 4)
 set(VERSION_PATCH 0)
 set(VERSION_TWEAK 0)
 set(PROJECT_COMMIT "N/A")
@@ -116,18 +116,27 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")
 configure_file(
 	"${PROJECT_SOURCE_DIR}/cmake/version.hpp.in"
 	"${PROJECT_BINARY_DIR}/source/version.hpp"
+	@ONLY
 )
 configure_file(
 	"${PROJECT_SOURCE_DIR}/cmake/module.cpp.in"
 	"${PROJECT_BINARY_DIR}/source/module.cpp"
+	@ONLY
 )
 
 # Windows
 if (WIN32)
 	## Installer (InnoSetup)
+	get_filename_component(ISS_FILES_DIR "${CMAKE_INSTALL_PREFIX}" ABSOLUTE)
+	file(TO_NATIVE_PATH "${ISS_FILES_DIR}" ISS_FILES_DIR)
+	get_filename_component(ISS_PACKAGE_DIR "${CMAKE_PACKAGE_PREFIX}" ABSOLUTE)
+	file(TO_NATIVE_PATH "${ISS_PACKAGE_DIR}" ISS_PACKAGE_DIR)
+	get_filename_component(ISS_SOURCE_DIR "${PROJECT_SOURCE_DIR}" ABSOLUTE)
+	file(TO_NATIVE_PATH "${ISS_SOURCE_DIR}" ISS_SOURCE_DIR)
 	configure_file(
 		"${PROJECT_SOURCE_DIR}/cmake/installer.iss.in"
 		"${PROJECT_BINARY_DIR}/installer.iss"
+		@ONLY
 	)
 
 	# Windows Specific Resource Definition
@@ -155,7 +164,7 @@ mark_as_advanced(FORCE OBS_NATIVE OBS_PACKAGE OBS_REFERENCE OBS_DOWNLOAD)
 
 if(NOT TARGET libobs)
 	set(${PropertyPrefix}OBS_STUDIO_DIR "" CACHE PATH "OBS Studio Source/Package Directory")
-	set(${PropertyPrefix}OBS_DOWNLOAD_VERSION "24.0.0-rc2-ci" CACHE STRING "OBS Studio Version to download")
+	set(${PropertyPrefix}OBS_DOWNLOAD_VERSION "24.0.3-ci" CACHE STRING "OBS Studio Version to download")
 endif()
 
 if(NOT ${PropertyPrefix}OBS_NATIVE)
@@ -325,6 +334,7 @@ add_library(${PROJECT_NAME} MODULE
 	${PROJECT_GENERATED}
 	${PROJECT_PRIVATE}
 	${PROJECT_DATA}
+	${PROJECT_TEMPLATES}
 )
 
 # Include Directories

appveyor.yml

@@ -1,74 +0,0 @@
-# Generic Settings
-version: '{build}-{branch}'
-
-matrix:
-  fast_finish: true
-
-# Build Image & Environment
-platform: x64
-
-# Build Tags only
-skip_non_tags: true
-
-image:
-  - Visual Studio 2017
-
-environment:
-  CMAKE_SYSTEM_VERSION: 10.0.17134.0
-  CMAKE_GENERATOR_32: "Visual Studio 15 2017"
-  CMAKE_GENERATOR_64: "Visual Studio 15 2017 Win64"
-  PACKAGE_PREFIX: obs-ffmpeg-encoder
-  INNOSETUP_URL: http://www.jrsoftware.org/download.php/is.exe
-  CURL_VERSION: 7.39.0
-
-# Resource Cache
-cache:
-  - inno.exe
-  - build/32/libobs-download
-  - build/32/libobs-src
-  - build/64/libobs-download
-  - build/64/libobs-src
-
-# Building  
-install:
-- cmd: ci/appveyor-install.bat
-
-build_script:
-- cmd: node ci/builder.js
-
-after_build:
-- cmd: node ci/packager.js
-- cmd: ci/appveyor-package.bat
-
-# Testing
-test: off
-
-# Artifacts
-artifacts:
-  - path: build/obs-ffmpeg-encoder-*.zip
-  - path: build/obs-ffmpeg-encoder-*.7z
-  - path: build/obs-ffmpeg-encoder-*.exe
-
-# Deploying
-deploy:
-  - provider: GitHub
-    auth_token:
-      secure: diGN1FzupARljI1iJsiAdZHut8aXODkUC6YDDi2oDRikEp5Ic8kQd8SSRDyA4pAJ
-    draft: true
-    prerelease: false
-    force_update: true
-    on:
-      appveyor_repo_tag: true
-
-# Notifications
-notifications:
-  - provider: Webhook
-    url: 
-      secure: PTtt5ALhmK0q42jYyx4/Qa1Uf18+gLMXKGdzJjDISJt8IE/K0Zyp58UYmDDbbyLp4pBRf/Ylj8rn/zYL/mqBoDVRIH5zasPqIvBD0ZhtvNjTOxQ3QoRkAmxgpWeMowm3A3I1rLizA2H4EctPpoAJGrvQ1G2HEYn9tVsGYeetFTo=
-    on_build_success: false
-    on_build_failure: false
-    on_build_status_changed: true
-    body: >-
-      {
-        "content": "**Build {{status}}**: [{{commitId}}] {{commitMessage}}\nBy {{commitAuthor}} on {{commitDate}}\n{{buildUrl}}"
-      }

ci/appveyor-install.bat

@@ -1,9 +0,0 @@
-@ECHO OFF
-git submodule update --init --force --recursive
-
-IF EXIST inno.exe (
-	curl -kL "%INNOSETUP_URL%" -f --retry 5 -o inno.exe -z inno.exe
-) else (
-	curl -kL "%INNOSETUP_URL%" -f --retry 5 -o inno.exe
-)
-inno.exe /VERYSILENT /NORETART /SP- /SUPPRESSMSGBOXES

ci/appveyor-package.bat

@@ -1,3 +0,0 @@
-@ECHO OFF
-ECHO -- Building Installer --
-"C:\Program Files (x86)\Inno Setup 5\ISCC.exe" /Qp ".\build\64\installer.iss" > nul

ci/builder.js

@@ -13,7 +13,7 @@ if ((process.platform == "win32") || (process.platform == "win64")) {
 		`-DCMAKE_SYSTEM_VERSION=${process.env.CMAKE_SYSTEM_VERSION}`,
 		`-DCMAKE_PACKAGE_NAME=obs-ffmpeg-encoder`,
 		'-DCMAKE_INSTALL_PREFIX="build/distrib/"',
-		'-DCMAKE_PACKAGE_PREFIX="build/"',
+		'-DCMAKE_PACKAGE_PREFIX="build/package/"',
 	];
 	let extra_build = [
 
@@ -26,9 +26,8 @@ if ((process.platform == "win32") || (process.platform == "win64")) {
 	if ((process.env.CMAKE_GENERATOR_32 !== undefined) && (process.env.CMAKE_GENERATOR_32 !== "")) {
 		x32_steps.push(
 			[ 'cmake', [
-				'-H.',
-				'-Bbuild/32',
-				`-G"${process.env.CMAKE_GENERATOR_32}"`,
+				'-H.', '-Bbuild/32',
+				`-G"${process.env.CMAKE_GENERATOR_32}"`, '-AWin32', '-T"host=x64"',
 			].concat(extra_conf), env ]
 		);
 		x32_steps.push(
@@ -42,10 +41,8 @@ if ((process.platform == "win32") || (process.platform == "win64")) {
 	if ((process.env.CMAKE_GENERATOR_64 !== undefined) && (process.env.CMAKE_GENERATOR_64 !== "")) {
 		x64_steps.push(
 			[ 'cmake', [
-				'-H.',
-				'-Bbuild/64',
-				`-G"${process.env.CMAKE_GENERATOR_64}"`,
-				'-T"host=x64"'
+				'-H.', '-Bbuild/64',
+				`-G"${process.env.CMAKE_GENERATOR_64}"`, '-Ax64', '-T"host=x64"',
 			].concat(extra_conf), env ]
 		);
 		x64_steps.push(

ci/packager.js

@@ -2,20 +2,8 @@
 
 const process = require('process');
 const runner = require('./runner.js');
-
-function runRunners(runnerArray, name) {
-	return new Promise(async (resolve, reject) => {
-		let local = runnerArray.reverse();
-		while (local.length > 0) {	
-			let task = local.pop();
-			let work = new runner(name, task[0], task[1], task[2]);
-			await work.run();
-		}
-		resolve(0);
-	});
-}
-
 let env = process.env;
+
 let steps = [];
 
 if ((process.env.CMAKE_GENERATOR_64 !== undefined) && (process.env.CMAKE_GENERATOR_64 !== "")) {
@@ -50,6 +38,24 @@ if ((process.env.CMAKE_GENERATOR_64 !== undefined) && (process.env.CMAKE_GENERAT
 	);
 }
 
+function runRunners(runnerArray, name) {
+	return new Promise(async (resolve, reject) => {
+		let local = runnerArray.reverse();
+		while (local.length > 0) {	
+			try {
+				let task = local.pop();
+				let work = new runner(name, task[0], task[1], task[2]);
+				await work.run();
+			} catch (e) {
+				reject(e);
+				return;
+			}
+		}
+		resolve(0);
+	});
+}
+
+
 let promises = [];
 promises.push(runRunners(steps, "32-Bit"));
 Promise.all(promises).then(

cmake/installer.iss.in

@@ -21,8 +21,8 @@ AppUpdatesURL={#MyAppURL}
 DefaultDirName={code:GetDirName}
 DefaultGroupName={#MyAppName}
 AllowNoIcons=yes
-LicenseFile="@PROJECT_SOURCE_DIR@/LICENSE"
-OutputDir="@CMAKE_INSTALL_PREFIX@/../"
+LicenseFile="@ISS_SOURCE_DIR@/LICENSE"
+OutputDir="@ISS_PACKAGE_DIR@"
 OutputBaseFilename=obs-ffmpeg-encoder-{#MyAppVersion}
 Compression=lzma
 SolidCompression=yes
@@ -34,7 +34,7 @@ VersionInfoDescription={#MyAppName} Setup
 Name: "english"; MessagesFile: "compiler:Default.isl"
 
 [Files]
-Source: "@CMAKE_INSTALL_PREFIX@/*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+Source: "@ISS_FILES_DIR@/*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
 ; NOTE: Don't use "Flags: ignoreversion" on any shared system files
 
 [Icons]

data/locale/en-US.ini

@@ -8,7 +8,7 @@ State.Manual="Manual"
 # FFmpeg
 FFmpeg="FFmpeg Options"
 FFmpeg.CustomSettings="Custom Settings"
-FFmpeg.CustomSettings.Description="Custom settings that override any detected options above, use with caution.\nThe input should be in the format 'key=value;key=value;...'."
+FFmpeg.CustomSettings.Description="Override any options shown (or not shown) above with your own.\nThe format is similar to that of the FFmpeg command line:\n  -key=value -key2=value2 -key3='quoted value'"
 FFmpeg.Threads="Number of Threads"
 FFmpeg.Threads.Description="The number of threads to use for encoding, if supported by the encoder.\nA value of 0 is equal to 'auto-detect' and may result in excessive CPU usage."
 FFmpeg.ColorFormat="Override Color Format"
@@ -20,6 +20,9 @@ FFmpeg.StandardCompliance.Strict="Strict"
 FFmpeg.StandardCompliance.Normal="Normal"
 FFmpeg.StandardCompliance.Unofficial="Unofficial"
 FFmpeg.StandardCompliance.Experimental="Experimental"
+FFmpeg.GPU="GPU"
+FFmpeg.GPU.Description="For multiple GPU systems, selects which GPU to use as the main encoder"
+
 
 # Rate Control
 RateControl="Rate Control"
@@ -46,6 +49,8 @@ KeyFrames="Key Frames"
 KeyFrames.IntervalType="Interval Type"
 KeyFrames.IntervalType.Frames="Frames"
 KeyFrames.IntervalType.Seconds="Seconds"
+KeyFrames.IntervalType.Description="Keyframe interval type"
+KeyFrames.Interval.Description="Distance between key frames, in frames or seconds."
 KeyFrames.Interval="Interval"
 
 # Codec: H264
@@ -55,7 +60,9 @@ Codec.H264.Profile.baseline="Baseline"
 Codec.H264.Profile.main="Main"
 Codec.H264.Profile.high="High"
 Codec.H264.Profile.high444p="High 4:4:4 Predictive"
+Codec.H264.Profile.Description="H.264 profile determines which features of the codec can be used.\nHigh 4:4:4 Predictive is required for YUV 4:4:4 color space."
 Codec.H264.Level="Level"
+Codec.H264.Level.Description="Level determines the upper limits of resolution, frame rate and bitrate for the video."
 
 # Codec: HEVC
 Codec.HEVC="HEVC"
@@ -67,6 +74,7 @@ Codec.HEVC.Tier="Tier"
 Codec.HEVC.Tier.main="Main"
 Codec.HEVC.Tier.high="High"
 Codec.HEVC.Level="Level"
+Codec.HEVC.Level.Description="Level determines the upper limits of resolution, frame rate and bitrate for the video."
 
 # Codec: Apple ProRes
 Codec.ProRes.Profile="Profile"
@@ -79,6 +87,7 @@ Codec.ProRes.Profile.AP4X="4444 Extra Quality/XQ (AP4X)"
 
 # NVENC
 NVENC.Preset="Preset"
+NVENC.Preset.Description="Presets are NVIDIA's preconfigured default settings."
 NVENC.Preset.Default="Default"
 NVENC.Preset.Slow="Slow"
 NVENC.Preset.Medium="Medium"
@@ -93,19 +102,26 @@ NVENC.Preset.Lossless="Lossless"
 NVENC.Preset.LosslessHighPerformance="Lossless High Performance"
 NVENC.RateControl="Rate Control Options"
 NVENC.RateControl.Mode="Mode"
+NVENC.RateControl.Mode.Description="Rate control mode selection"
 NVENC.RateControl.Mode.CQP="Constant Quantization Parameter"
+NVENC.RateControl.Mode.CQP.Description="A flat compression ratio with no regard for bit rates."
 NVENC.RateControl.Mode.VBR="Variable Bitrate"
+NVENC.RateControl.Mode.VBR.Description="Sacrifices quality to stay below the upper bitrate limit,\nor saves bitrate where possible."
 NVENC.RateControl.Mode.VBR_HQ="High Quality Variable Bitrate"
+NVENC.RateControl.Mode.VBR_HQ.Description="Variable Bitrate with two-pass encoding enabled by default."
 NVENC.RateControl.Mode.CBR="Constant Bitrate"
+NVENC.RateControl.Mode.CBR.Description="Compresses footage so that it matches the target bitrate over the duration of\none second. This comes at a cost in quality during high motion scenes or\nscenes with flickering brightness like often seen in RPGs."
 NVENC.RateControl.Mode.CBR_HQ="High Quality Constant Bitrate"
+NVENC.RateControl.Mode.CBR_HQ.Description="Constant Bitrate with two-pass encoding enabled by default."
 NVENC.RateControl.Mode.CBR_LD_HQ="Low Delay High Quality Constant Bitrate"
+NVENC.RateControl.Mode.CBR_LD_HQ.Description="Constant Bitrate optimized for lowest encoding latency."
 NVENC.RateControl.LookAhead="Look Ahead"
 NVENC.RateControl.LookAhead.Description="Look ahead this many frames while encoding to better distribute bitrate.\nImproves quality slightly at the cost of some GPU time.\nSet to 0 to disable."
-NVENC.RateControl.AdaptiveI="Enable adaptive I-Frame insertion"
+NVENC.RateControl.AdaptiveI="Adaptive I-Frames"
 NVENC.RateControl.AdaptiveI.Description="Enables adaptive I-Frame insertion.\nOnly has an effect when look ahead is set to a value other than 0."
-NVENC.RateControl.AdaptiveB="Enable adaptive B-Frame insertion"
+NVENC.RateControl.AdaptiveB="Adaptive B-Frames"
 NVENC.RateControl.AdaptiveB.Description="Enables adaptive B-Frame insertion.\nOnly has an effect when look ahead is set to a value other than 0."
-NVENC.RateControl.TwoPass="Enable Two Pass"
+NVENC.RateControl.TwoPass="Two Pass"
 NVENC.RateControl.TwoPass.Description="Enable a secondary pass for encoding, which can help with quality and bitrate stability.\nImproves quality slightly at the cost of some GPU time.\nNvidia Turing hardware might actually see a quality degrade from this."
 NVENC.RateControl.Bitrate="Bitrate Limits"
 NVENC.RateControl.Bitrate.Target="Target Bitrate"
@@ -131,21 +147,21 @@ NVENC.RateControl.QP.B.Description="Quantization parameter for B-Frames.\nSmalle
 NVENC.RateControl.QP.B.Initial="Initial B-Frame QP"
 NVENC.RateControl.QP.B.Initial.Description="Initial B-Frame quantization parameter.\nSet to -1 to use the automatically detected value instead."
 NVENC.AQ="Adaptive Quantization"
-NVENC.AQ.Spatial="Enable Spatial Adaptive Quantization"
+NVENC.AQ.Spatial="Spatial Adaptive Quantization"
 NVENC.AQ.Spatial.Description="Enable spatial adaptive quantization, also sometimes referred to as Psychovisual Adaptive Quantization."
 NVENC.AQ.Strength="Spatial AQ Strength"
 NVENC.AQ.Strength.Description="Strength of the spatial adaptive quantization.\nValues closer to 15 mean more aggressive, while values closer to 1 mean more relaxed."
-NVENC.AQ.Temporal="Enable Temporal Adaptive Quantization"
+NVENC.AQ.Temporal="Temporal Adaptive Quantization"
 NVENC.AQ.Temporal.Description="Enable temporal adaptive quantization."
 NVENC.Other="Other Options"
 NVENC.Other.BFrames="Maximum B-Frames"
-NVENC.Other.BFrames.Description="Maximum number of B-Frames to insert into the encoded bitstream.\nActual number of B-Frames may be lower depending on content and lookahead settings."
+NVENC.Other.BFrames.Description="Maximum number of B-Frames to insert into the encoded bitstream.\nActual number of B-Frames may be lower depending on content and lookahead settings.\nOnly Turing NVENC supports B-Frames for HEVC."
 NVENC.Other.BFrameReferenceMode="B-Frame Reference Mode"
 NVENC.Other.BFrameReferenceMode.Each="Each B-Frame will be used for references"
 NVENC.Other.BFrameReferenceMode.Middle="Only (# of B-Frames)/2 will be used for references"
-NVENC.Other.ZeroLatency="Enable Zero Latency"
+NVENC.Other.ZeroLatency="Zero Latency"
 NVENC.Other.ZeroLatency.Description="Enable zero latency operation, which ensures that there is no reordering delay."
-NVENC.Other.WeightedPrediction="Enable Weighted Prediction"
+NVENC.Other.WeightedPrediction="Weighted Prediction"
 NVENC.Other.WeightedPrediction.Description="Enable weighted prediction for encoding.\nCan't be used with B-Frames."
-NVENC.Other.NonReferencePFrames="Enable non-reference P-Frames"
+NVENC.Other.NonReferencePFrames="Non-reference P-Frames"
 NVENC.Other.NonReferencePFrames.Description="Enable the automatic insertion of non-reference P-Frames."

source/codecs/hevc.cpp

@@ -197,8 +197,8 @@ void progress_parse(uint8_t*& ptr, uint8_t* end, size_t& sz)
 	sz = get_nal_size(ptr, end);
 }
 
-void obsffmpeg::codecs::hevc::extract_header_sei(uint8_t* data, size_t sz_data,
-                                                 std::vector<uint8_t>& header, std::vector<uint8_t>& sei)
+void obsffmpeg::codecs::hevc::extract_header_sei(uint8_t* data, size_t sz_data, std::vector<uint8_t>& header,
+                                                 std::vector<uint8_t>& sei)
 {
 	uint8_t* ptr = data;
 	uint8_t* end = data + sz_data;

source/codecs/hevc.hpp

@@ -61,8 +61,8 @@ namespace obsffmpeg {
 				UNKNOWN = -1,
 			};
 
-			void extract_header_sei(uint8_t* data, size_t sz_data,
-			                        std::vector<uint8_t>& header, std::vector<uint8_t>& sei);
+			void extract_header_sei(uint8_t* data, size_t sz_data, std::vector<uint8_t>& header,
+			                        std::vector<uint8_t>& sei);
 
 		} // namespace hevc
 	}         // namespace codecs

source/encoder.cpp

@@ -23,6 +23,7 @@
 #include <iomanip>
 #include <set>
 #include <sstream>
+#include <stack>
 #include <thread>
 #include <util/profiler.hpp>
 #include <vector>
@@ -63,10 +64,12 @@ extern "C" {
 #define ST_FFMPEG_THREADS "FFmpeg.Threads"
 #define ST_FFMPEG_COLORFORMAT "FFmpeg.ColorFormat"
 #define ST_FFMPEG_STANDARDCOMPLIANCE "FFmpeg.StandardCompliance"
+#define ST_FFMPEG_GPU "FFmpeg.GPU"
 
 enum class keyframe_type { SECONDS, FRAMES };
 
-static void* _create(obs_data_t* settings, obs_encoder_t* encoder) noexcept try {
+static void* _create(obs_data_t* settings, obs_encoder_t* encoder) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, settings, encoder);
 #endif
@@ -79,7 +82,8 @@ static void* _create(obs_data_t* settings, obs_encoder_t* encoder) noexcept try
 	return nullptr;
 }
 
-static void* _create_texture(obs_data_t* settings, obs_encoder_t* encoder) noexcept try {
+static void* _create_texture(obs_data_t* settings, obs_encoder_t* encoder) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, settings, encoder);
 #endif
@@ -98,7 +102,8 @@ static void* _create_texture(obs_data_t* settings, obs_encoder_t* encoder) noexc
 	return nullptr;
 }
 
-static void _destroy(void* ptr) noexcept try {
+static void _destroy(void* ptr) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX", __FUNCTION_NAME__, ptr);
 #endif
@@ -110,7 +115,8 @@ static void _destroy(void* ptr) noexcept try {
 	PLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
 }
 
-static const char* _get_name(void* type_data) noexcept try {
+static const char* _get_name(void* type_data) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX", __FUNCTION_NAME__, type_data);
 #endif
@@ -123,7 +129,8 @@ static const char* _get_name(void* type_data) noexcept try {
 	return nullptr;
 }
 
-static const char* _get_name_fallback(void* type_data) noexcept try {
+static const char* _get_name_fallback(void* type_data) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX", __FUNCTION_NAME__, type_data);
 #endif
@@ -136,7 +143,8 @@ static const char* _get_name_fallback(void* type_data) noexcept try {
 	return nullptr;
 }
 
-static void _get_defaults(obs_data_t* settings, void* type_data) noexcept try {
+static void _get_defaults(obs_data_t* settings, void* type_data) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, settings, type_data);
 #endif
@@ -147,7 +155,20 @@ static void _get_defaults(obs_data_t* settings, void* type_data) noexcept try {
 	PLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
 };
 
-static obs_properties_t* _get_properties(void* ptr, void* type_data) noexcept try {
+static void _get_defaults_texture(obs_data_t* settings, void* type_data) noexcept
+try {
+#ifdef DEBUG_CALL_ORDER
+	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, settings, type_data);
+#endif
+	reinterpret_cast<obsffmpeg::encoder_factory*>(type_data)->get_defaults(settings, true);
+} catch (const std::exception& ex) {
+	PLOG_ERROR("Unexpected exception in function '%s': %s.", __FUNCTION_NAME__, ex.what());
+} catch (...) {
+	PLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
+};
+
+static obs_properties_t* _get_properties(void* ptr, void* type_data) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, ptr, type_data);
 #endif
@@ -167,7 +188,29 @@ static obs_properties_t* _get_properties(void* ptr, void* type_data) noexcept tr
 	return reinterpret_cast<obs_properties_t*>(0);
 }
 
-static bool _update(void* ptr, obs_data_t* settings) noexcept try {
+static obs_properties_t* _get_properties_texture(void* ptr, void* type_data) noexcept
+try {
+#ifdef DEBUG_CALL_ORDER
+	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, ptr, type_data);
+#endif
+	obs_properties_t* props = obs_properties_create();
+	if (type_data != nullptr) {
+		reinterpret_cast<obsffmpeg::encoder_factory*>(type_data)->get_properties(props, true);
+	}
+	if (ptr != nullptr) {
+		reinterpret_cast<obsffmpeg::encoder*>(ptr)->get_properties(props, true);
+	}
+	return props;
+} catch (const std::exception& ex) {
+	PLOG_ERROR("Unexpected exception in function '%s': %s.", __FUNCTION_NAME__, ex.what());
+	return reinterpret_cast<obs_properties_t*>(0);
+} catch (...) {
+	PLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
+	return reinterpret_cast<obs_properties_t*>(0);
+}
+
+static bool _update(void* ptr, obs_data_t* settings) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, ptr, settings);
 #endif
@@ -180,7 +223,8 @@ static bool _update(void* ptr, obs_data_t* settings) noexcept try {
 	return false;
 }
 
-static bool _get_sei_data(void* ptr, uint8_t** sei_data, size_t* size) noexcept try {
+static bool _get_sei_data(void* ptr, uint8_t** sei_data, size_t* size) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX %llX", __FUNCTION_NAME__, ptr, sei_data, size);
 #endif
@@ -193,7 +237,8 @@ static bool _get_sei_data(void* ptr, uint8_t** sei_data, size_t* size) noexcept
 	return false;
 }
 
-static bool _get_extra_data(void* ptr, uint8_t** extra_data, size_t* size) noexcept try {
+static bool _get_extra_data(void* ptr, uint8_t** extra_data, size_t* size) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX %llX", __FUNCTION_NAME__, ptr, extra_data, size);
 #endif
@@ -206,7 +251,8 @@ static bool _get_extra_data(void* ptr, uint8_t** extra_data, size_t* size) noexc
 	return false;
 }
 
-static void _get_video_info(void* ptr, struct video_scale_info* info) noexcept try {
+static void _get_video_info(void* ptr, struct video_scale_info* info) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, ptr, info);
 #endif
@@ -218,7 +264,8 @@ static void _get_video_info(void* ptr, struct video_scale_info* info) noexcept t
 }
 
 static bool _encode(void* ptr, struct encoder_frame* frame, struct encoder_packet* packet,
-                    bool* received_packet) noexcept try {
+                    bool* received_packet) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX %llX %llX", __FUNCTION_NAME__, ptr, frame, packet, received_packet);
 #endif
@@ -232,7 +279,8 @@ static bool _encode(void* ptr, struct encoder_frame* frame, struct encoder_packe
 }
 
 static bool _encode_texture(void* ptr, uint32_t handle, int64_t pts, uint64_t lock_key, uint64_t* next_key,
-                            struct encoder_packet* packet, bool* received_packet) noexcept try {
+                            struct encoder_packet* packet, bool* received_packet) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %lI %llI %llU %llX %llX %llX", __FUNCTION_NAME__, ptr, handle, pts, lock_key, next_key, packet,
 	          received_packet);
@@ -247,7 +295,8 @@ static bool _encode_texture(void* ptr, uint32_t handle, int64_t pts, uint64_t lo
 	return false;
 }
 
-static void _get_audio_info(void* ptr, struct audio_convert_info* info) noexcept try {
+static void _get_audio_info(void* ptr, struct audio_convert_info* info) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX", __FUNCTION_NAME__, ptr, info);
 #endif
@@ -258,7 +307,8 @@ static void _get_audio_info(void* ptr, struct audio_convert_info* info) noexcept
 	PLOG_ERROR("Unexpected exception in function '%s'.", __FUNCTION_NAME__);
 }
 
-static size_t _get_frame_size(void* ptr) noexcept try {
+static size_t _get_frame_size(void* ptr) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX", __FUNCTION_NAME__, ptr);
 #endif
@@ -272,7 +322,8 @@ static size_t _get_frame_size(void* ptr) noexcept try {
 }
 
 static bool _encode_audio(void* ptr, struct encoder_frame* frame, struct encoder_packet* packet,
-                          bool* received_packet) noexcept try {
+                          bool* received_packet) noexcept
+try {
 #ifdef DEBUG_CALL_ORDER
 	PLOG_INFO("%s %llX %llX %llX %llX", __FUNCTION_NAME__, ptr, frame, packet, received_packet);
 #endif
@@ -291,7 +342,7 @@ obsffmpeg::encoder_factory::encoder_factory(const AVCodec* codec) : avcodec_ptr(
 	_handler = obsffmpeg::find_codec_handler(avcodec_ptr->name);
 
 	// Unique Id is FFmpeg name.
-	info.uid = avcodec_ptr->name;
+	info.uid = std::string("obs-ffmpeg-encoder_") + avcodec_ptr->name;
 
 	// Also generate a human readable name while we're at it.
 	{
@@ -304,10 +355,6 @@ obsffmpeg::encoder_factory::encoder_factory(const AVCodec* codec) : avcodec_ptr(
 			sstr << " (" << avcodec_ptr->name << ")";
 		}
 		info.readable_name = sstr.str();
-
-		// Allow UI Handler to replace visible name.
-		if (_handler)
-			_handler->override_visible_name(avcodec_ptr, info.readable_name);
 	}
 
 	// Assign Ids.
@@ -386,6 +433,8 @@ void obsffmpeg::encoder_factory::register_encoder()
 	if (ffmpeg::tools::can_hardware_encode(avcodec_ptr)) {
 		info.oei.create          = _create_texture;
 		info.oei.encode_texture  = _encode_texture;
+		info.oei.get_defaults2   = _get_defaults_texture;
+		info.oei.get_properties2 = _get_properties_texture;
 
 		info_fallback.oei.type            = info.oei.type;
 		info_fallback.oei.create          = _create;
@@ -400,23 +449,28 @@ void obsffmpeg::encoder_factory::register_encoder()
 		info_fallback.oei.encode          = _encode;
 		info_fallback.oei.type_data       = this;
 
-		obs_register_encoder(&info_fallback.oei);
-		PLOG_DEBUG("Registered software fallback for encoder #%llX", avcodec_ptr);
 	} else {
 		// Is not a GPU Encoder, don't implement fallback.
 		info.oei.create = _create;
 		info.oei.encode = _encode;
 	}
 
+	if (_handler)
+		_handler->adjust_encoder_info(this, &info, &info_fallback);
+
 	obs_register_encoder(&info.oei);
 	PLOG_DEBUG("Registered encoder #%llX with name '%s' and long name '%s' and caps %llX", avcodec_ptr,
 	           avcodec_ptr->name, avcodec_ptr->long_name, avcodec_ptr->capabilities);
+	if (info_fallback.uid.size() > 0) {
+		obs_register_encoder(&info_fallback.oei);
+		PLOG_DEBUG("Registered software fallback for encoder #%llX", avcodec_ptr);
+	}
 }
 
-void obsffmpeg::encoder_factory::get_defaults(obs_data_t* settings)
+void obsffmpeg::encoder_factory::get_defaults(obs_data_t* settings, bool hw_encode)
 {
 	if (_handler)
-		_handler->get_defaults(settings, avcodec_ptr, nullptr);
+		_handler->get_defaults(settings, avcodec_ptr, nullptr, hw_encode);
 
 	if ((avcodec_ptr->capabilities & AV_CODEC_CAP_INTRA_ONLY) == 0) {
 		obs_data_set_default_int(settings, S_KEYFRAMES_INTERVALTYPE, 0);
@@ -427,13 +481,18 @@ void obsffmpeg::encoder_factory::get_defaults(obs_data_t* settings)
 	{ // Integrated Options
 		// FFmpeg
 		obs_data_set_default_string(settings, ST_FFMPEG_CUSTOMSETTINGS, "");
-		obs_data_set_default_int(settings, ST_FFMPEG_COLORFORMAT, static_cast<int64_t>(AV_PIX_FMT_NONE));
+		if (!hw_encode) {
+			obs_data_set_default_int(settings, ST_FFMPEG_COLORFORMAT,
+			                         static_cast<int64_t>(AV_PIX_FMT_NONE));
 			obs_data_set_default_int(settings, ST_FFMPEG_THREADS, 0);
+			obs_data_set_default_int(settings, ST_FFMPEG_GPU, 0);
+		}
 		obs_data_set_default_int(settings, ST_FFMPEG_STANDARDCOMPLIANCE, FF_COMPLIANCE_STRICT);
 	}
 }
 
-static bool modified_keyframes(obs_properties_t* props, obs_property_t*, obs_data_t* settings) try {
+static bool modified_keyframes(obs_properties_t* props, obs_property_t*, obs_data_t* settings)
+try {
 	bool is_seconds = obs_data_get_int(settings, S_KEYFRAMES_INTERVALTYPE) == 0;
 	obs_property_set_visible(obs_properties_get(props, S_KEYFRAMES_INTERVAL_FRAMES), !is_seconds);
 	obs_property_set_visible(obs_properties_get(props, S_KEYFRAMES_INTERVAL_SECONDS), is_seconds);
@@ -446,10 +505,10 @@ static bool modified_keyframes(obs_properties_t* props, obs_property_t*, obs_dat
 	return false;
 }
 
-void obsffmpeg::encoder_factory::get_properties(obs_properties_t* props)
+void obsffmpeg::encoder_factory::get_properties(obs_properties_t* props, bool hw_encode)
 {
 	if (_handler)
-		_handler->get_properties(props, avcodec_ptr, nullptr);
+		_handler->get_properties(props, avcodec_ptr, nullptr, hw_encode);
 
 	if ((avcodec_ptr->capabilities & AV_CODEC_CAP_INTRA_ONLY) == 0) {
 		// Key-Frame Options
@@ -498,9 +557,16 @@ void obsffmpeg::encoder_factory::get_properties(obs_properties_t* props)
 			                            obs_text_type::OBS_TEXT_DEFAULT);
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_FFMPEG_CUSTOMSETTINGS)));
 		}
+		if (!hw_encode) {
+			{
+				auto p = obs_properties_add_int(grp, ST_FFMPEG_GPU, TRANSLATE(ST_FFMPEG_GPU), 0,
+				                                std::numeric_limits<uint8_t>::max(), 1);
+				obs_property_set_long_description(p, TRANSLATE(DESC(ST_FFMPEG_GPU)));
+			}
 			if (avcodec_ptr->pix_fmts) {
-			auto p = obs_properties_add_list(grp, ST_FFMPEG_COLORFORMAT, TRANSLATE(ST_FFMPEG_COLORFORMAT),
-			                                 OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+				auto p = obs_properties_add_list(grp, ST_FFMPEG_COLORFORMAT,
+				                                 TRANSLATE(ST_FFMPEG_COLORFORMAT), OBS_COMBO_TYPE_LIST,
+				                                 OBS_COMBO_FORMAT_INT);
 				obs_property_set_long_description(p, TRANSLATE(DESC(ST_FFMPEG_COLORFORMAT)));
 				obs_property_list_add_int(p, TRANSLATE(S_STATE_AUTOMATIC),
 				                          static_cast<int64_t>(AV_PIX_FMT_NONE));
@@ -510,10 +576,12 @@ void obsffmpeg::encoder_factory::get_properties(obs_properties_t* props)
 				}
 			}
 			if (avcodec_ptr->capabilities & (AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS)) {
-			auto p = obs_properties_add_int_slider(grp, ST_FFMPEG_THREADS, TRANSLATE(ST_FFMPEG_THREADS), 0,
-			                                       std::thread::hardware_concurrency() * 2, 1);
+				auto p =
+				    obs_properties_add_int_slider(grp, ST_FFMPEG_THREADS, TRANSLATE(ST_FFMPEG_THREADS),
+				                                  0, std::thread::hardware_concurrency() * 2, 1);
 				obs_property_set_long_description(p, TRANSLATE(DESC(ST_FFMPEG_THREADS)));
 			}
+		}
 		{
 			auto p = obs_properties_add_list(grp, ST_FFMPEG_STANDARDCOMPLIANCE,
 			                                 TRANSLATE(ST_FFMPEG_STANDARDCOMPLIANCE), OBS_COMBO_TYPE_LIST,
@@ -560,8 +628,7 @@ void obsffmpeg::encoder::initialize_sw(obs_data_t* settings)
 		    static_cast<AVPixelFormat>(obs_data_get_int(settings, ST_FFMPEG_COLORFORMAT));
 		if (_pixfmt_target == AV_PIX_FMT_NONE) {
 			// Find the best conversion format.
-			std::vector<AVPixelFormat> fmts = ffmpeg::tools::get_software_formats(_codec->pix_fmts);
-			_pixfmt_target = ffmpeg::tools::get_best_compatible_format(fmts.data(), _pixfmt_source);
+			_pixfmt_target = ffmpeg::tools::get_least_lossy_format(_codec->pix_fmts, _pixfmt_source);
 
 			if (_handler) // Allow Handler to override the automatic color format for sanity reasons.
 				_handler->override_colorformat(_pixfmt_target, settings, _codec, _context);
@@ -582,8 +649,8 @@ void obsffmpeg::encoder::initialize_sw(obs_data_t* settings)
 			}
 		}
 
-		_context->width  = voi->width;
-		_context->height = voi->height;
+		_context->width  = static_cast<int>(obs_encoder_get_width(_self));
+		_context->height = static_cast<int>(obs_encoder_get_height(_self));
 		ffmpeg::tools::setup_obs_color(voi->colorspace, voi->range, _context);
 
 		_context->pix_fmt                 = _pixfmt_target;
@@ -612,15 +679,10 @@ void obsffmpeg::encoder::initialize_sw(obs_data_t* settings)
 			     << (_swscale.is_source_full_range() ? "full" : "partial") << " range.";
 			throw std::runtime_error(sstr.str());
 		}
-
-		// Create Frame queue
-		_frame_queue.set_pixel_format(_context->pix_fmt);
-		_frame_queue.set_resolution(_context->width, _context->height);
-		_frame_queue.precache(2);
 	}
 }
 
-void obsffmpeg::encoder::initialize_hw(obs_data_t* settings)
+void obsffmpeg::encoder::initialize_hw(obs_data_t*)
 {
 	// Initialize Video Encoding
 	auto voi = video_output_get_info(obs_encoder_video(_self));
@@ -655,26 +717,78 @@ void obsffmpeg::encoder::initialize_hw(obs_data_t* settings)
 		throw std::runtime_error("Failed to initialize AVHWFramesContext.");
 }
 
-obsffmpeg::encoder::encoder(obs_data_t* settings, obs_encoder_t* encoder, bool is_texture_encode)
-    : _self(encoder), _lag_in_frames(0), _count_send_frames(0), _have_first_frame(false)
+void obsffmpeg::encoder::push_free_frame(std::shared_ptr<AVFrame> frame)
 {
-	// Initial set up.
-	_factory = reinterpret_cast<encoder_factory*>(obs_encoder_get_type_data(_self));
-	_codec   = _factory->get_avcodec();
+	auto now = std::chrono::high_resolution_clock::now();
+	if (_free_frames.size() > 0) {
+		if ((now - _free_frames_last_used) < std::chrono::seconds(1)) {
+			_free_frames.push(frame);
+		}
+	} else {
+		_free_frames.push(frame);
+		_free_frames_last_used = std::chrono::high_resolution_clock::now();
+	}
+}
+
+std::shared_ptr<AVFrame> obsffmpeg::encoder::pop_free_frame()
+{
+	std::shared_ptr<AVFrame> frame;
+	if (_free_frames.size() > 0) {
+		// Re-use existing frames first.
+		frame = _free_frames.top();
+		_free_frames.pop();
+	} else {
+		if (_hwinst) {
+			frame = _hwinst->allocate_frame(_context->hw_frames_ctx);
+		} else {
+			frame = std::shared_ptr<AVFrame>(av_frame_alloc(), [](AVFrame* frame) {
+				av_frame_unref(frame);
+				av_frame_free(&frame);
+			});
+
+			frame->width  = _context->width;
+			frame->height = _context->height;
+			frame->format = _context->pix_fmt;
+
+			int res = av_frame_get_buffer(frame.get(), 32);
+			if (res < 0) {
+				throw std::runtime_error(ffmpeg::tools::get_error_description(res));
+			}
+		}
+	}
+
+	return frame;
+}
+
+void obsffmpeg::encoder::push_used_frame(std::shared_ptr<AVFrame> frame)
+{
+	_used_frames.push(frame);
+}
+
+std::shared_ptr<AVFrame> obsffmpeg::encoder::pop_used_frame()
+{
+	auto frame = _used_frames.front();
+	_used_frames.pop();
+	return frame;
+}
+
+obsffmpeg::encoder::encoder(obs_data_t* settings, obs_encoder_t* encoder, bool is_texture_encode)
+    : _self(encoder), _factory(reinterpret_cast<encoder_factory*>(obs_encoder_get_type_data(_self))),
+      _codec(_factory->get_avcodec()), _context(nullptr), _lag_in_frames(0), _count_send_frames(0),
+      _have_first_frame(false)
+{
+	// Find a handler
 	_handler = obsffmpeg::find_codec_handler(_codec->name);
 
+	// Initialize GPU Stuff
 	if (is_texture_encode) {
 #ifdef WIN32
+		auto gctx = obsffmpeg::obs_graphics();
+		if (gs_get_device_type() == GS_DEVICE_DIRECT3D_11) {
 			_hwapi = std::make_shared<obsffmpeg::hwapi::d3d11>();
-#endif
-		obsffmpeg::hwapi::device dev;
-		if (_handler)
-			dev = _handler->find_hw_device(_hwapi, _codec, _context);
-		try {
-			_hwinst = _hwapi->create(dev);
-		} catch (...) {
-			throw obsffmpeg::unsupported_gpu_exception("Creating GPU context failed.");
 		}
+#endif
+		_hwinst = _hwapi->create_from_obs();
 	}
 
 	// Initialize context.
@@ -688,34 +802,17 @@ obsffmpeg::encoder::encoder(obs_data_t* settings, obs_encoder_t* encoder, bool i
 	av_init_packet(&_current_packet);
 	av_new_packet(&_current_packet, 8 * 1024 * 1024); // 8 MB precached Packet size.
 
-	if (!is_texture_encode) {
-		initialize_sw(settings);
-	} else {
-		try {
+	if (is_texture_encode) {
 		initialize_hw(settings);
-		} catch (...) {
-			throw obsffmpeg::unsupported_gpu_exception("Initializing hardware context failed.");
+	} else {
+		initialize_sw(settings);
 	}
-	}
-
-	// Log Encoder info
-	PLOG_INFO("[%s] Initializing...", _codec->name);
-	PLOG_INFO("[%s]   Video Input: %ldx%ld %s %s %s", _codec->name, _swscale.get_source_width(),
-	          _swscale.get_source_height(), ffmpeg::tools::get_pixel_format_name(_swscale.get_source_format()),
-	          ffmpeg::tools::get_color_space_name(_swscale.get_source_colorspace()),
-	          _swscale.is_source_full_range() ? "Full" : "Partial");
-	PLOG_INFO("[%s]   Video Output: %ldx%ld %s %s %s", _codec->name, _swscale.get_target_width(),
-	          _swscale.get_target_height(), ffmpeg::tools::get_pixel_format_name(_swscale.get_target_format()),
-	          ffmpeg::tools::get_color_space_name(_swscale.get_target_colorspace()),
-	          _swscale.is_target_full_range() ? "Full" : "Partial");
-	PLOG_INFO("[%s]   Framerate: %ld/%ld (%f FPS)", _codec->name, _context->time_base.den, _context->time_base.num,
-	          static_cast<double_t>(_context->time_base.den) / static_cast<double_t>(_context->time_base.num));
-	PLOG_INFO("[%s]   Custom Settings: %s", _codec->name, obs_data_get_string(settings, ST_FFMPEG_CUSTOMSETTINGS));
 
 	// Update settings
 	update(settings);
 
 	// Initialize Encoder
+	auto gctx = obsffmpeg::obs_graphics();
 	int  res  = avcodec_open2(_context, _codec, NULL);
 	if (res < 0) {
 		std::stringstream sstr;
@@ -727,6 +824,7 @@ obsffmpeg::encoder::encoder(obs_data_t* settings, obs_encoder_t* encoder, bool i
 
 obsffmpeg::encoder::~encoder()
 {
+	auto gctx = obsffmpeg::obs_graphics();
 	if (_context) {
 		// Flush encoders that require it.
 		if ((_codec->capabilities & AV_CODEC_CAP_DELAY) != 0) {
@@ -744,15 +842,13 @@ obsffmpeg::encoder::~encoder()
 
 	av_packet_unref(&_current_packet);
 
-	_frame_queue.clear();
-	_frame_queue_used.clear();
 	_swscale.finalize();
 }
 
-void obsffmpeg::encoder::get_properties(obs_properties_t* props)
+void obsffmpeg::encoder::get_properties(obs_properties_t* props, bool hw_encode)
 {
 	if (_handler)
-		_handler->get_properties(props, _codec, _context);
+		_handler->get_properties(props, _codec, _context, hw_encode);
 
 	obs_property_set_enabled(obs_properties_get(props, S_KEYFRAMES), false);
 	obs_property_set_enabled(obs_properties_get(props, S_KEYFRAMES_INTERVALTYPE), false);
@@ -762,41 +858,52 @@ void obsffmpeg::encoder::get_properties(obs_properties_t* props)
 	obs_property_set_enabled(obs_properties_get(props, ST_FFMPEG_COLORFORMAT), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_FFMPEG_THREADS), false);
 	obs_property_set_enabled(obs_properties_get(props, ST_FFMPEG_STANDARDCOMPLIANCE), false);
+	obs_property_set_enabled(obs_properties_get(props, ST_FFMPEG_GPU), false);
 }
 
 bool obsffmpeg::encoder::update(obs_data_t* settings)
 {
-	// Settings
-	/// Rate Control
-	_context->strict_std_compliance = static_cast<int>(obs_data_get_int(settings, ST_FFMPEG_STANDARDCOMPLIANCE));
+	// FFmpeg Options
 	_context->debug                 = 0;
+	_context->strict_std_compliance = static_cast<int>(obs_data_get_int(settings, ST_FFMPEG_STANDARDCOMPLIANCE));
+
 	/// Threading
-	if (_codec->capabilities
-	    & (AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS)) {
+	if (!_hwinst) {
+		_context->thread_type = 0;
 		if (_codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) {
 			_context->thread_type |= FF_THREAD_FRAME;
 		}
 		if (_codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) {
 			_context->thread_type |= FF_THREAD_SLICE;
 		}
+		if (_context->thread_type != 0) {
 			int64_t threads = obs_data_get_int(settings, ST_FFMPEG_THREADS);
 			if (threads > 0) {
 				_context->thread_count = static_cast<int>(threads);
-			_lag_in_frames         = _context->thread_count;
 			} else {
 				_context->thread_count = std::thread::hardware_concurrency();
-			_lag_in_frames         = _context->thread_count;
 			}
+		} else {
+			_context->thread_count = 1;
+		}
+		// Frame Delay (Lag In Frames)
+		_context->delay = _context->thread_count;
+	} else {
+		_context->delay = 0;
 	}
 
-	if (_handler)
-		_handler->update(settings, _codec, _context);
+	// Apply GPU Selection
+	if (!_hwinst && ffmpeg::tools::can_hardware_encode(_codec)) {
+		av_opt_set_int(_context, "gpu", (int)obs_data_get_int(settings, ST_FFMPEG_GPU), AV_OPT_SEARCH_CHILDREN);
+	}
 
-	if ((_codec->capabilities & AV_CODEC_CAP_INTRA_ONLY) == 0) {
+	// Keyframes
+	if (_handler && _handler->has_keyframe_support(this)) {
 		// Key-Frame Options
 		obs_video_info ovi;
 		if (!obs_get_video_info(&ovi)) {
-			throw std::runtime_error("no video info");
+			throw std::runtime_error(
+			    "obs_get_video_info failed, restart OBS Studio to fix it (hopefully).");
 		}
 
 		int64_t kf_type    = obs_data_get_int(settings, S_KEYFRAMES_INTERVALTYPE);
@@ -811,15 +918,67 @@ bool obsffmpeg::encoder::update(obs_data_t* settings)
 		_context->keyint_min = _context->gop_size;
 	}
 
-	{ // FFmpeg
-		// Apply custom options.
-		av_opt_set_from_string(_context->priv_data, obs_data_get_string(settings, ST_FFMPEG_CUSTOMSETTINGS),
-		                       nullptr, "=", ";");
+	// Handler Options
+	if (_handler)
+		_handler->update(settings, _codec, _context);
+
+	{ // FFmpeg Custom Options
+		const char* opts     = obs_data_get_string(settings, ST_FFMPEG_CUSTOMSETTINGS);
+		size_t      opts_len = strnlen(opts, 65535);
+
+		parse_ffmpeg_commandline(std::string{opts, opts + opts_len});
 	}
 
-	// Handler Logging
+	// Handler Overrides
 	if (_handler)
+		_handler->override_update(this, settings);
+
+	// Handler Logging
+	if (_handler) {
+		PLOG_INFO("[%s] Initializing...", _codec->name);
+		PLOG_INFO("[%s]   FFmpeg:", _codec->name);
+		PLOG_INFO("[%s]     Custom Settings: %s", _codec->name,
+		          obs_data_get_string(settings, ST_FFMPEG_CUSTOMSETTINGS));
+		PLOG_INFO("[%s]     Standard Compliance: %s", _codec->name,
+		          ffmpeg::tools::get_std_compliance_name(_context->strict_std_compliance));
+		PLOG_INFO("[%s]     Threading: %s (with %i threads)", _codec->name,
+		          ffmpeg::tools::get_thread_type_name(_context->thread_type), _context->thread_count);
+
+		PLOG_INFO("[%s]   Video:", _codec->name);
+		if (_hwinst) {
+			PLOG_INFO("[%s]     Texture: %ldx%ld %s %s %s", _codec->name, _context->width, _context->height,
+			          ffmpeg::tools::get_pixel_format_name(_context->sw_pix_fmt),
+			          ffmpeg::tools::get_color_space_name(_context->colorspace),
+			          av_color_range_name(_context->color_range));
+		} else {
+			PLOG_INFO("[%s]     Input: %ldx%ld %s %s %s", _codec->name, _swscale.get_source_width(),
+			          _swscale.get_source_height(),
+			          ffmpeg::tools::get_pixel_format_name(_swscale.get_source_format()),
+			          ffmpeg::tools::get_color_space_name(_swscale.get_source_colorspace()),
+			          _swscale.is_source_full_range() ? "Full" : "Partial");
+			PLOG_INFO("[%s]     Output: %ldx%ld %s %s %s", _codec->name, _swscale.get_target_width(),
+			          _swscale.get_target_height(),
+			          ffmpeg::tools::get_pixel_format_name(_swscale.get_target_format()),
+			          ffmpeg::tools::get_color_space_name(_swscale.get_target_colorspace()),
+			          _swscale.is_target_full_range() ? "Full" : "Partial");
+			if (!_hwinst)
+				PLOG_INFO("[%s]     On GPU Index: %lli", _codec->name,
+				          obs_data_get_int(settings, ST_FFMPEG_GPU));
+		}
+		PLOG_INFO("[%s]     Framerate: %ld/%ld (%f FPS)", _codec->name, _context->time_base.den,
+		          _context->time_base.num,
+		          static_cast<double_t>(_context->time_base.den)
+		              / static_cast<double_t>(_context->time_base.num));
+
+		PLOG_INFO("[%s]   Keyframes: ", _codec->name);
+		if (_context->keyint_min != _context->gop_size) {
+			PLOG_INFO("[%s]     Minimum: %i frames", _codec->name, _context->keyint_min);
+			PLOG_INFO("[%s]     Maximum: %i frames", _codec->name, _context->gop_size);
+		} else {
+			PLOG_INFO("[%s]     Distance: %i frames", _codec->name, _context->gop_size);
+		}
 		_handler->log_options(settings, _codec, _context);
+	}
 
 	return true;
 }
@@ -895,8 +1054,9 @@ static inline void copy_data(encoder_frame* frame, AVFrame* vframe)
 
 bool obsffmpeg::encoder::video_encode(encoder_frame* frame, encoder_packet* packet, bool* received_packet)
 {
+	std::shared_ptr<AVFrame> vframe = pop_free_frame(); // Retrieve an empty frame.
+
 	// Convert frame.
-	std::shared_ptr<AVFrame> vframe = _frame_queue.pop(); // Retrieve an empty frame.
 	{
 #ifdef _DEBUG
 		ScopeProfiler profile("convert");
@@ -929,10 +1089,6 @@ bool obsffmpeg::encoder::video_encode(encoder_frame* frame, encoder_packet* pack
 	if (!encode_avframe(vframe, packet, received_packet))
 		return false;
 
-	if (vframe != nullptr) {
-		_frame_queue.push(vframe);
-	}
-
 	return true;
 }
 
@@ -945,12 +1101,8 @@ bool obsffmpeg::encoder::video_encode_texture(uint32_t handle, int64_t pts, uint
 		return false;
 	}
 
-	std::shared_ptr<AVFrame> frame{av_frame_alloc(), [](void* ptr) {
-		                               av_frame_unref(reinterpret_cast<AVFrame*>(ptr));
-		                               av_frame_free(reinterpret_cast<AVFrame**>(&ptr));
-	                               }};
-		
-	std::shared_ptr<AVFrame> vframe = _hwinst->avframe_from_obs(_context->hw_frames_ctx, handle, lock_key, next_lock_key);
+	std::shared_ptr<AVFrame> vframe = pop_free_frame();
+	_hwinst->copy_from_obs(_context->hw_frames_ctx, handle, lock_key, next_lock_key, vframe);
 
 	vframe->color_range     = _context->color_range;
 	vframe->colorspace      = _context->colorspace;
@@ -968,10 +1120,18 @@ bool obsffmpeg::encoder::video_encode_texture(uint32_t handle, int64_t pts, uint
 
 int obsffmpeg::encoder::receive_packet(bool* received_packet, struct encoder_packet* packet)
 {
+	int res = 0;
+
 	av_packet_unref(&_current_packet);
 
-	int res = avcodec_receive_packet(_context, &_current_packet);
-	if (res == 0) {
+	{
+		auto gctx = obsffmpeg::obs_graphics();
+		res       = avcodec_receive_packet(_context, &_current_packet);
+	}
+	if (res != 0) {
+		return res;
+	}
+
 	if (!_have_first_frame) {
 		if (_codec->id == AV_CODEC_ID_H264) {
 			uint8_t* tmp_packet;
@@ -979,8 +1139,8 @@ int obsffmpeg::encoder::receive_packet(bool* received_packet, struct encoder_pac
 			uint8_t* tmp_sei;
 			size_t   sz_packet, sz_header, sz_sei;
 
-				obs_extract_avc_headers(_current_packet.data, _current_packet.size, &tmp_packet,
-				                        &sz_packet, &tmp_header, &sz_header, &tmp_sei, &sz_sei);
+			obs_extract_avc_headers(_current_packet.data, _current_packet.size, &tmp_packet, &sz_packet,
+			                        &tmp_header, &sz_header, &tmp_sei, &sz_sei);
 
 			if (sz_header) {
 				_extra_data.resize(sz_header);
@@ -1022,31 +1182,26 @@ int obsffmpeg::encoder::receive_packet(bool* received_packet, struct encoder_pac
 	packet->drop_priority = packet->keyframe ? 0 : 1;
 	*received_packet      = true;
 
-		{
-			std::shared_ptr<AVFrame> uframe = _frame_queue_used.pop_only();
-			_frame_queue.push(uframe);
-		}
-	}
+	push_free_frame(pop_used_frame());
 
 	return res;
 }
 
 int obsffmpeg::encoder::send_frame(std::shared_ptr<AVFrame> const frame)
 {
-	int res = avcodec_send_frame(_context, frame.get());
-	switch (res) {
-	case 0:
-		if (!_hwapi)
-			_frame_queue_used.push(frame);
-		_count_send_frames++;
-	case AVERROR(EAGAIN):
-	case AVERROR(EOF):
-		break;
+	int res = 0;
+	{
+		auto gctx = obsffmpeg::obs_graphics();
+		res       = avcodec_send_frame(_context, frame.get());
 	}
+	if (res == 0) {
+		push_used_frame(frame);
+	}
+
 	return res;
 }
 
-bool obsffmpeg::encoder::encode_avframe(std::shared_ptr<AVFrame>& frame, encoder_packet* packet, bool* received_packet)
+bool obsffmpeg::encoder::encode_avframe(std::shared_ptr<AVFrame> frame, encoder_packet* packet, bool* received_packet)
 {
 #ifdef _DEBUG
 	ScopeProfiler profile("loop");
@@ -1054,7 +1209,7 @@ bool obsffmpeg::encoder::encode_avframe(std::shared_ptr<AVFrame>& frame, encoder
 
 	bool sent_frame  = false;
 	bool recv_packet = false;
-	bool should_lag  = (_lag_in_frames - _count_send_frames) <= 0;
+	bool should_lag  = (_count_send_frames >= _lag_in_frames);
 
 	auto loop_begin = std::chrono::high_resolution_clock::now();
 	auto loop_end   = loop_begin + std::chrono::milliseconds(50);
@@ -1127,5 +1282,148 @@ bool obsffmpeg::encoder::encode_avframe(std::shared_ptr<AVFrame>& frame, encoder
 		}
 	}
 
+	if (!sent_frame)
+		push_free_frame(frame);
+
 	return true;
 }
+
+bool obsffmpeg::encoder::is_hardware_encode()
+{
+	return _hwinst != nullptr;
+}
+
+const AVCodec* obsffmpeg::encoder::get_avcodec()
+{
+	return _codec;
+}
+
+const AVCodecContext* obsffmpeg::encoder::get_avcodeccontext()
+{
+	return _context;
+}
+
+void obsffmpeg::encoder::parse_ffmpeg_commandline(std::string text)
+{
+	// Steps to properly parse a command line:
+	// 1. Split by space and package by quotes.
+	// 2. Parse each resulting option individually.
+
+	// First, we split by space and of course respect quotes while doing so.
+	// That means that "-foo= bar" is stored as std::string("-foo= bar"),
+	//  and things like -foo="bar" is stored as std::string("-foo=\"bar\"").
+	// However "-foo"=bar" -foo2=bar" is stored as std::string("-foo=bar -foo2=bar")
+	//  because the quote was not escaped.
+	std::list<std::string> opts;
+	std::stringstream      opt_stream{std::ios_base::in | std::ios_base::out | std::ios_base::binary};
+	std::stack<char>       quote_stack;
+	for (size_t p = 0; p <= text.size(); p++) {
+		char here = p < text.size() ? text.at(p) : 0;
+
+		if (here == '\\') {
+			size_t p2 = p + 1;
+			if (p2 < text.size()) {
+				char here2 = text.at(p2);
+				if (isdigit(here2)) { // Octal
+					// Not supported yet.
+					p++;
+				} else if (here2 == 'x') { // Hexadecimal
+					// Not supported yet.
+					p += 3;
+				} else if (here2 == 'u') { // 4 or 8 wide Unicode.
+					                   // Not supported yet.
+				} else if (here2 == 'a') {
+					opt_stream << '\a';
+					p++;
+				} else if (here2 == 'b') {
+					opt_stream << '\b';
+					p++;
+				} else if (here2 == 'f') {
+					opt_stream << '\f';
+					p++;
+				} else if (here2 == 'n') {
+					opt_stream << '\n';
+					p++;
+				} else if (here2 == 'r') {
+					opt_stream << '\r';
+					p++;
+				} else if (here2 == 't') {
+					opt_stream << '\t';
+					p++;
+				} else if (here2 == 'v') {
+					opt_stream << '\v';
+					p++;
+				} else if (here2 == '\\') {
+					opt_stream << '\\';
+					p++;
+				} else if (here2 == '\'') {
+					opt_stream << '\'';
+					p++;
+				} else if (here2 == '"') {
+					opt_stream << '"';
+					p++;
+				} else if (here2 == '?') {
+					opt_stream << '\?';
+					p++;
+				}
+			}
+		} else if ((here == '\'') || (here == '"')) {
+			if (quote_stack.size() > 1) {
+				opt_stream << here;
+			}
+			if (quote_stack.size() == 0) {
+				quote_stack.push(here);
+			} else if (quote_stack.top() == here) {
+				quote_stack.pop();
+			} else {
+				quote_stack.push(here);
+			}
+		} else if ((here == 0) || ((here == ' ') && (quote_stack.size() == 0))) {
+			std::string ropt = opt_stream.str();
+			if (ropt.size() > 0) {
+				opts.push_back(ropt);
+				opt_stream.str(std::string());
+				opt_stream.clear();
+			}
+		} else {
+			opt_stream << here;
+		}
+	}
+
+	// Now that we have a list of parameters as neatly grouped strings, and
+	//  have also dealt with escaping for the most part. We want to parse
+	//  an FFmpeg commandline option set here, so the first character in
+	//  the string must be a '-'.
+	for (std::string& opt : opts) {
+		// Skip empty options.
+		if (opt.size() == 0)
+			continue;
+
+		// Skip options that don't start with a '-'.
+		if (opt.at(0) != '-') {
+			PLOG_WARNING("Option '%s' is malformed, must start with a '-'.", opt.c_str());
+			continue;
+		}
+
+		// Skip options that don't contain a '='.
+		const char* cstr  = opt.c_str();
+		const char* eq_at = strchr(cstr, '=');
+		if (eq_at == nullptr) {
+			PLOG_WARNING("Option '%s' is malformed, must contain a '='.", opt.c_str());
+			continue;
+		}
+
+		try {
+			std::string key   = opt.substr(1, eq_at - cstr - 1);
+			std::string value = opt.substr(eq_at - cstr + 1);
+
+			int res = av_opt_set(_context, key.c_str(), value.c_str(), AV_OPT_SEARCH_CHILDREN);
+			if (res < 0) {
+				PLOG_WARNING("Option '%s' (key: '%s', value: '%s') encountered error: %s", opt.c_str(),
+				             key.c_str(), value.c_str(), ffmpeg::tools::get_error_description(res));
+			}
+		} catch (const std::exception& ex) {
+			PLOG_ERROR("Option '%s' encountered exception: %s", opt.c_str(), ex.what())
+		}
+	}
+}

source/encoder.hpp

@@ -23,6 +23,8 @@
 
 #include <condition_variable>
 #include <mutex>
+#include <queue>
+#include <stack>
 #include <thread>
 #include <vector>
 #include "ffmpeg/avframe-queue.hpp"
@@ -50,7 +52,7 @@ namespace obsffmpeg {
 		std::string      uid;
 		std::string      codec;
 		std::string      readable_name;
-		obs_encoder_info oei;
+		obs_encoder_info oei = {0};
 	};
 
 	class encoder_factory {
@@ -66,9 +68,9 @@ namespace obsffmpeg {
 
 		void register_encoder();
 
-		void get_defaults(obs_data_t* settings);
+		void get_defaults(obs_data_t* settings, bool hw_encoder = false);
 
-		void get_properties(obs_properties_t* props);
+		void get_properties(obs_properties_t* props, bool hw_encoder = false);
 
 		const AVCodec* get_avcodec();
 
@@ -83,36 +85,44 @@ namespace obsffmpeg {
 
 		const AVCodec*  _codec;
 		AVCodecContext* _context;
-		AVHWFramesContext* _hwcontext;
 
 		std::shared_ptr<obsffmpeg::ui::handler> _handler;
 
 		std::shared_ptr<obsffmpeg::hwapi::base>     _hwapi;
 		std::shared_ptr<obsffmpeg::hwapi::instance> _hwinst;
 
-		ffmpeg::avframe_queue _frame_queue;
-		ffmpeg::avframe_queue _frame_queue_used;
 		ffmpeg::swscale _swscale;
 		AVPacket        _current_packet;
 
-		int64_t _lag_in_frames;
-		int64_t _count_send_frames;
+		size_t _lag_in_frames;
+		size_t _count_send_frames;
 
 		// Extra Data
 		bool                 _have_first_frame;
 		std::vector<uint8_t> _extra_data;
 		std::vector<uint8_t> _sei_data;
 
+		// Frame Stack and Queue
+		std::stack<std::shared_ptr<AVFrame>>           _free_frames;
+		std::queue<std::shared_ptr<AVFrame>>           _used_frames;
+		std::chrono::high_resolution_clock::time_point _free_frames_last_used;
+
 		void initialize_sw(obs_data_t* settings);
 		void initialize_hw(obs_data_t* settings);
 
+		void                     push_free_frame(std::shared_ptr<AVFrame> frame);
+		std::shared_ptr<AVFrame> pop_free_frame();
+
+		void                     push_used_frame(std::shared_ptr<AVFrame> frame);
+		std::shared_ptr<AVFrame> pop_used_frame();
+
 		public:
 		encoder(obs_data_t* settings, obs_encoder_t* encoder, bool is_texture_encode = false);
 		virtual ~encoder();
 
 		public: // OBS API
 		// Shared
-		void get_properties(obs_properties_t* props);
+		void get_properties(obs_properties_t* props, bool hw_encode = false);
 
 		bool update(obs_data_t* settings);
 
@@ -139,7 +149,16 @@ namespace obsffmpeg {
 
 		int send_frame(std::shared_ptr<AVFrame> frame);
 
-		bool encode_avframe(std::shared_ptr<AVFrame>& frame, struct encoder_packet* packet,
+		bool encode_avframe(std::shared_ptr<AVFrame> frame, struct encoder_packet* packet,
 		                    bool* received_packet);
+
+		public: // Handler API
+		bool is_hardware_encode();
+
+		const AVCodec* get_avcodec();
+
+		const AVCodecContext* get_avcodeccontext();
+
+		void parse_ffmpeg_commandline(std::string text);
 	};
 } // namespace obsffmpeg

source/ffmpeg/tools.cpp

@@ -24,12 +24,15 @@
 #include <map>
 #include <sstream>
 #include <stdexcept>
+#include "plugin.hpp"
+#include "utility.hpp"
 
 extern "C" {
 #pragma warning(push)
 #pragma warning(disable : 4244)
 #include <libavcodec/avcodec.h>
 #include <libavutil/error.h>
+#include <libavutil/opt.h>
 #include <libavutil/pixdesc.h>
 #pragma warning(pop)
 }
@@ -113,52 +116,11 @@ const char* ffmpeg::tools::get_color_space_name(AVColorSpace v)
 
 const char* ffmpeg::tools::get_error_description(int error)
 {
-	switch (error) {
-	case AVERROR(EPERM):
-		return "Permission Denied";
-		//	case AVERROR(ENOENT):
-		//	case AVERROR(ESRCH):
-		//	case AVERROR(EINTR):
-		//	case AVERROR(EIO):
-		//	case AVERROR(ENXIO):
-		//	case AVERROR(E2BIG):
-		//	case AVERROR(ENOEXEC):
-		//	case AVERROR(EBADF):
-		//	case AVERROR(ECHILD):
-		//	case AVERROR(EAGAIN):
-	case AVERROR(ENOMEM):
-		return "Out Of Memory";
-		//	case AVERROR(EACCES):
-		//	case AVERROR(EFAULT):
-		//	case AVERROR(EBUSY):
-		//	case AVERROR(EEXIST):
-		//	case AVERROR(EXDEV):
-		//	case AVERROR(ENODEV):
-		//	case AVERROR(ENOTDIR):
-		//	case AVERROR(EISDIR):
-		//	case AVERROR(ENFILE):
-		//	case AVERROR(EMFILE):
-		//	case AVERROR(ENOTTY):
-		//	case AVERROR(EFBIG):
-		//	case AVERROR(ENOSPC):
-		//	case AVERROR(ESPIPE):
-		//	case AVERROR(EROFS):
-		//	case AVERROR(EMLINK):
-		//	case AVERROR(EPIPE):
-		//	case AVERROR(EDOM):
-		//	case AVERROR(EDEADLK):
-		//	case AVERROR(ENAMETOOLONG):
-		//	case AVERROR(ENOLCK):
-		//	case AVERROR(ENOSYS):
-		//	case AVERROR(ENOTEMPTY):
-	case AVERROR(EINVAL):
-		return "Invalid Value(s)";
-	case AVERROR(ERANGE):
-		return "Out of Range";
-		//	case AVERROR(EILSEQ):
-		//	case AVERROR(STRUNCATE):
+	thread_local char error_buf[AV_ERROR_MAX_STRING_SIZE + 1];
+	if (av_strerror(error, error_buf, AV_ERROR_MAX_STRING_SIZE) < 0) {
+		snprintf(error_buf, AV_ERROR_MAX_STRING_SIZE, "Unknown Error (%i)", error);
 	}
-	return "Not Translated Yet";
+	return error_buf;
 }
 
 static std::map<video_format, AVPixelFormat> obs_to_av_format_map = {
@@ -279,106 +241,6 @@ std::vector<AVPixelFormat> ffmpeg::tools::get_software_formats(const AVPixelForm
 	return std::move(fmts);
 }
 
-static std::map<std::pair<AVPixelFormat, AVPixelFormat>, double_t> format_compatibility = {
-    {{AV_PIX_FMT_NV12, AV_PIX_FMT_NV12}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_NV12, AV_PIX_FMT_NV21}, 65535.0},
-
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P}, 65535.0},
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P9}, 58981.5},
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P10}, 53083.35},
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P12}, 47775.015},
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P14}, 42997.5135},
-    {{AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV420P16}, 38697.76215},
-
-    {{AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA420P}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA420P9}, 65535.0},
-    {{AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA420P10}, 58981.5},
-    {{AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA420P16}, 53083.35},
-    {{AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P}, 32767.0},
-
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P}, 65535.0},
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P9}, 58981.5},
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P10}, 53083.35},
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P12}, 47775.015},
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P14}, 42997.5135},
-    {{AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV422P16}, 38697.76215},
-
-    {{AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA422P}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P9}, 65535.0},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P10}, 58981.5},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P16}, 53083.35},
-    {{AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P}, 32767.0},
-
-    {{AV_PIX_FMT_YVYU422, AV_PIX_FMT_YVYU422}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YVYU422, AV_PIX_FMT_YUYV422}, 65535.0},
-
-    {{AV_PIX_FMT_UYVY422, AV_PIX_FMT_UYVY422}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_UYVY422, AV_PIX_FMT_YVYU422}, 65535.0},
-
-    {{AV_PIX_FMT_YUYV422, AV_PIX_FMT_YUYV422}, std::numeric_limits<double_t>::max()},
-
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P}, 65535.0},
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P9}, 58981.5},
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P10}, 53083.35},
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P12}, 47775.015},
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P14}, 42997.5135},
-    {{AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P16}, 38697.76215},
-
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA444P}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA444P9}, 65535.0},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA444P10}, 58981.5},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA444P16}, 53083.35},
-    {{AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P}, 32767.0},
-
-    {{AV_PIX_FMT_RGBA, AV_PIX_FMT_RGBA}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB0}, 65535.0},
-    {{AV_PIX_FMT_RGBA, AV_PIX_FMT_0RGB}, 32767.0},
-    {{AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB24}, 16384.0},
-
-    {{AV_PIX_FMT_BGRA, AV_PIX_FMT_BGRA}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR0}, 65535.0},
-    {{AV_PIX_FMT_BGRA, AV_PIX_FMT_0BGR}, 32767.0},
-    {{AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR24}, 16384.0},
-
-    {{AV_PIX_FMT_BGR0, AV_PIX_FMT_BGR0}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_BGR0, AV_PIX_FMT_BGRA}, 65535.0},
-    {{AV_PIX_FMT_BGR0, AV_PIX_FMT_BGR24}, 32767.0},
-
-    {{AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9}, 65535.0},
-    {{AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY10}, 58981.5},
-    {{AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY12}, 53083.35},
-    {{AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY14}, 47775.015},
-    {{AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16}, 42997.5135},
-
-    {{AV_PIX_FMT_BGR24, AV_PIX_FMT_BGR24}, std::numeric_limits<double_t>::max()},
-    {{AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24}, 32767.0},
-};
-
-AVPixelFormat ffmpeg::tools::get_best_compatible_format(const AVPixelFormat* list, AVPixelFormat source)
-{
-	double_t      score = std::numeric_limits<double_t>::min();
-	AVPixelFormat best  = source;
-
-	for (auto fmt = list; fmt && (*fmt != AV_PIX_FMT_NONE); fmt++) {
-		auto found = format_compatibility.find(std::pair{source, *fmt});
-		if (found != format_compatibility.end() && (score < found->second)) {
-			score = found->second;
-			best  = *fmt;
-		}
-	}
-
-	if (score <= 0) {
-		int data_loss = 0;
-		return avcodec_find_best_pix_fmt_of_list(list, source, 0, &data_loss);
-	}
-
-	return best;
-}
-
 void ffmpeg::tools::setup_obs_color(video_colorspace colorspace, video_range_type range, AVCodecContext* context)
 {
 	std::map<video_colorspace, std::tuple<AVColorSpace, AVColorPrimaries, AVColorTransferCharacteristic>>
@@ -411,3 +273,81 @@ void ffmpeg::tools::setup_obs_color(video_colorspace colorspace, video_range_typ
 	// Downscaling should result in downscaling, not pixelation
 	context->chroma_sample_location = AVCHROMA_LOC_CENTER;
 }
+
+const char* ffmpeg::tools::get_std_compliance_name(int compliance)
+{
+	switch (compliance) {
+	case FF_COMPLIANCE_VERY_STRICT:
+		return "Very Strict";
+	case FF_COMPLIANCE_STRICT:
+		return "Strict";
+	case FF_COMPLIANCE_NORMAL:
+		return "Normal";
+	case FF_COMPLIANCE_UNOFFICIAL:
+		return "Unofficial";
+	case FF_COMPLIANCE_EXPERIMENTAL:
+		return "Experimental";
+	}
+	return "Invalid";
+}
+
+const char* ffmpeg::tools::get_thread_type_name(int thread_type)
+{
+	switch (thread_type) {
+	case FF_THREAD_FRAME | FF_THREAD_SLICE:
+		return "Slice & Frame";
+	case FF_THREAD_FRAME:
+		return "Frame";
+	case FF_THREAD_SLICE:
+		return "Slice";
+	default:
+		return "None";
+	}
+}
+
+void ffmpeg::tools::print_av_option_bool(AVCodecContext* context, const char* option, std::string text)
+{
+	if (av_opt_is_set_to_default_by_name(context, option, AV_OPT_SEARCH_CHILDREN) == 0) {
+		int64_t v = 0;
+		if (av_opt_get_int(context, option, AV_OPT_SEARCH_CHILDREN, &v) == 0) {
+			PLOG_INFO("[%s] %s: %s", context->codec->name, text.c_str(), v == 0 ? "Disabled" : "Enabled");
+		} else {
+			PLOG_INFO("[%s] %s: <Error>", context->codec->name, text.c_str());
+		}
+	} else {
+		PLOG_INFO("[%s] %s: <Default>", context->codec->name, text.c_str());
+	}
+}
+
+void ffmpeg::tools::print_av_option_int(AVCodecContext* context, const char* option, std::string text,
+                                        std::string suffix)
+{
+	if (av_opt_is_set_to_default_by_name(context, option, AV_OPT_SEARCH_CHILDREN) == 0) {
+		int64_t v = 0;
+		if (av_opt_get_int(context, option, AV_OPT_SEARCH_CHILDREN, &v) == 0) {
+			PLOG_INFO("[%s] %s: %lld %s", context->codec->name, text.c_str(), v, suffix.c_str());
+		} else {
+			PLOG_INFO("[%s] %s: <Error>", context->codec->name, text.c_str());
+		}
+	} else {
+		PLOG_INFO("[%s] %s: <Default>", context->codec->name, text.c_str());
+	}
+}
+
+void ffmpeg::tools::print_av_option_string(AVCodecContext* context, const char* option, std::string text,
+                                           std::function<std::string(int64_t)> decoder)
+{
+	if (av_opt_is_set_to_default_by_name(context, option, AV_OPT_SEARCH_CHILDREN) == 0) {
+		int64_t v = 0;
+		if (av_opt_get_int(context, option, AV_OPT_SEARCH_CHILDREN, &v) == 0) {
+			std::string name = "<Unknown>";
+			if (decoder)
+				name = decoder(v);
+			PLOG_INFO("[%s] %s: %s", context->codec->name, text.c_str(), name.c_str());
+		} else {
+			PLOG_INFO("[%s] %s: <Error>", context->codec->name, text.c_str());
+		}
+	} else {
+		PLOG_INFO("[%s] %s: <Default>", context->codec->name, text.c_str());
+	}
+}

source/ffmpeg/tools.hpp

@@ -23,6 +23,7 @@
 #define OBS_FFMPEG_FFMPEG_UTILITY
 #pragma once
 
+#include <functional>
 #include <obs.h>
 #include <string>
 #include <vector>
@@ -56,9 +57,20 @@ namespace ffmpeg {
 
 		std::vector<AVPixelFormat> get_software_formats(const AVPixelFormat* list);
 
-		AVPixelFormat get_best_compatible_format(const AVPixelFormat* list, AVPixelFormat source);
-
 		void setup_obs_color(video_colorspace colorspace, video_range_type range, AVCodecContext* context);
+
+		const char* get_std_compliance_name(int compliance);
+
+		const char* get_thread_type_name(int thread_type);
+
+		void print_av_option_bool(AVCodecContext* context, const char* option, std::string text);
+
+		void print_av_option_int(AVCodecContext* context, const char* option, std::string text,
+		                                std::string suffix);
+
+		void print_av_option_string(AVCodecContext* context, const char* option, std::string text,
+		                                   std::function<std::string(int64_t)> decoder);
+
 	} // namespace tools
 } // namespace ffmpeg
 

source/hwapi/base.hpp

@@ -23,6 +23,7 @@
 
 #include <cinttypes>
 #include <list>
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -48,13 +49,21 @@ namespace obsffmpeg {
 			virtual std::list<obsffmpeg::hwapi::device> enumerate_adapters() = 0;
 
 			virtual std::shared_ptr<obsffmpeg::hwapi::instance> create(obsffmpeg::hwapi::device target) = 0;
+
+			virtual std::shared_ptr<obsffmpeg::hwapi::instance> create_from_obs() = 0;
 		};
 
 		class instance {
 			public:
 			virtual AVBufferRef* create_device_context() = 0;
 
-			virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key,
+			virtual std::shared_ptr<AVFrame> allocate_frame(AVBufferRef* frames) = 0;
+
+			virtual void copy_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key,
+			                           uint64_t* next_lock_key, std::shared_ptr<AVFrame> frame) = 0;
+
+			virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, uint32_t handle,
+			                                                  uint64_t  lock_key,
 			                                                  uint64_t* next_lock_key) = 0;
 		};
 	} // namespace hwapi

source/hwapi/d3d11.cpp

@@ -22,11 +22,14 @@
 #include "d3d11.hpp"
 #include <sstream>
 #include <vector>
+#include "utility.hpp"
 
 extern "C" {
 #pragma warning(push)
 #pragma warning(disable : 4244)
+#include <graphics/graphics.h>
 #include <libavutil/hwcontext_d3d11va.h>
+#include <obs.h>
 #pragma warning(pop)
 }
 
@@ -123,6 +126,22 @@ std::shared_ptr<obsffmpeg::hwapi::instance> obsffmpeg::hwapi::d3d11::create(obsf
 	return std::make_shared<d3d11_instance>(device, context);
 }
 
+std::shared_ptr<obsffmpeg::hwapi::instance> obsffmpeg::hwapi::d3d11::create_from_obs()
+{
+	auto gctx = obsffmpeg::obs_graphics();
+
+	if (GS_DEVICE_DIRECT3D_11 != gs_get_device_type()) {
+		throw std::runtime_error("OBS Device is not a D3D11 Device.");
+	}
+
+	ATL::CComPtr<ID3D11Device> device =
+	    ATL::CComPtr<ID3D11Device>(reinterpret_cast<ID3D11Device*>(gs_get_device_obj()));
+	ATL::CComPtr<ID3D11DeviceContext> context;
+	device->GetImmediateContext(&context);
+
+	return std::make_shared<d3d11_instance>(device, context);
+}
+
 struct D3D11AVFrame {
 	ATL::CComPtr<ID3D11Texture2D> handle;
 };
@@ -150,27 +169,45 @@ AVBufferRef* obsffmpeg::hwapi::d3d11_instance::create_device_context()
 	d3d11va->device->AddRef();
 	d3d11va->device_context = _context;
 	d3d11va->device_context->AddRef();
+	d3d11va->lock   = [](void*) { obs_enter_graphics(); };
+	d3d11va->unlock = [](void*) { obs_leave_graphics(); };
 
-	if (av_hwdevice_ctx_init(dctx_ref) < 0)
+	int ret = av_hwdevice_ctx_init(dctx_ref);
+	if (ret < 0)
 		throw std::runtime_error("Failed to initialize AVHWDeviceContext.");
 
 	return dctx_ref;
 }
 
-std::shared_ptr<AVFrame> obsffmpeg::hwapi::d3d11_instance::avframe_from_obs(AVBufferRef* frames, uint32_t handle,
-                                                                            uint64_t lock_key, uint64_t* next_lock_key)
+std::shared_ptr<AVFrame> obsffmpeg::hwapi::d3d11_instance::allocate_frame(AVBufferRef* frames)
 {
-	AVFrame*                      frame = av_frame_alloc();
+	auto gctx = obsffmpeg::obs_graphics();
+
+	auto frame = std::shared_ptr<AVFrame>(av_frame_alloc(), [](AVFrame* frame) {
+		av_frame_unref(frame);
+		av_frame_free(&frame);
+	});
+
+	if (av_hwframe_get_buffer(frames, frame.get(), 0) < 0) {
+		throw std::runtime_error("Failed to create AVFrame.");
+	}
+
+	return frame;
+}
+
+void obsffmpeg::hwapi::d3d11_instance::copy_from_obs(AVBufferRef*, uint32_t handle, uint64_t lock_key,
+                                                     uint64_t* next_lock_key, std::shared_ptr<AVFrame> frame)
+{
+	auto gctx = obsffmpeg::obs_graphics();
+
 	ATL::CComPtr<IDXGIKeyedMutex> mutex;
 	ATL::CComPtr<ID3D11Texture2D> input;
-	D3D11_TEXTURE2D_DESC          input_desc;
-	D3D11_TEXTURE2D_DESC          output_desc;
-	//ATL::CComPtr<ID3D11Texture2D> output;
 
 	if (FAILED(_device->OpenSharedResource(reinterpret_cast<HANDLE>(static_cast<uintptr_t>(handle)),
 	                                       __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&input)))) {
 		throw std::runtime_error("Failed to open shared texture resource.");
 	}
+
 	if (FAILED(input->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast<void**>(&mutex)))) {
 		throw std::runtime_error("Failed to retrieve mutex for texture resource.");
 	}
@@ -182,13 +219,6 @@ std::shared_ptr<AVFrame> obsffmpeg::hwapi::d3d11_instance::avframe_from_obs(AVBu
 	// Set some parameters on the input texture, and get its description.
 	UINT evict = input->GetEvictionPriority();
 	input->SetEvictionPriority(DXGI_RESOURCE_PRIORITY_MAXIMUM);
-	input->GetDesc(&input_desc);
-
-	if (av_hwframe_get_buffer(frames, frame, 0) < 0) {
-		throw std::runtime_error("Failed to create AVFrame.");
-	}
-
-	reinterpret_cast<ID3D11Texture2D*>(frame->data[0])->GetDesc(&output_desc);
 
 	// Clone the content of the input texture.
 	_context->CopyResource(reinterpret_cast<ID3D11Texture2D*>(frame->data[0]), input);
@@ -202,9 +232,14 @@ std::shared_ptr<AVFrame> obsffmpeg::hwapi::d3d11_instance::avframe_from_obs(AVBu
 
 	// TODO: Determine if this is necessary.
 	mutex->ReleaseSync(*next_lock_key);
-
-	return std::shared_ptr<AVFrame>(frame, [](AVFrame* frame) {
-		av_frame_unref(frame);
-		av_frame_free(&frame);
-	});
+}
+
+std::shared_ptr<AVFrame> obsffmpeg::hwapi::d3d11_instance::avframe_from_obs(AVBufferRef* frames, uint32_t handle,
+                                                                            uint64_t lock_key, uint64_t* next_lock_key)
+{
+	auto gctx = obsffmpeg::obs_graphics();
+
+	auto frame = this->allocate_frame(frames);
+	this->copy_from_obs(frames, handle, lock_key, next_lock_key, frame);
+	return frame;
 }

source/hwapi/d3d11.hpp

@@ -21,13 +21,13 @@
 
 #include <atlutil.h>
 #include <d3d11.h>
+#include <d3d11_1.h>
 #include <dxgi.h>
-#include <windows.h>
 #include "base.hpp"
 
 namespace obsffmpeg {
 	namespace hwapi {
-		class d3d11 : public base {
+		class d3d11 : public ::obsffmpeg::hwapi::base {
 			typedef HRESULT(__stdcall* CreateDXGIFactory_t)(REFIID, void**);
 			typedef HRESULT(__stdcall* CreateDXGIFactory1_t)(REFIID, void**);
 			typedef HRESULT(__stdcall* D3D11CreateDevice_t)(_In_opt_ IDXGIAdapter*, D3D_DRIVER_TYPE,
@@ -53,9 +53,11 @@ namespace obsffmpeg {
 
 			virtual std::shared_ptr<obsffmpeg::hwapi::instance>
 			    create(obsffmpeg::hwapi::device target) override;
+
+			virtual std::shared_ptr<obsffmpeg::hwapi::instance> create_from_obs() override;
 		};
 
-		class d3d11_instance : public instance {
+		class d3d11_instance : public ::obsffmpeg::hwapi::instance {
 			ATL::CComPtr<ID3D11Device>        _device;
 			ATL::CComPtr<ID3D11DeviceContext> _context;
 
@@ -65,6 +67,11 @@ namespace obsffmpeg {
 
 			virtual AVBufferRef* create_device_context() override;
 
+			virtual std::shared_ptr<AVFrame> allocate_frame(AVBufferRef* frames) override;
+
+			virtual void copy_from_obs(AVBufferRef* frames, uint32_t handle, uint64_t lock_key,
+			                           uint64_t* next_lock_key, std::shared_ptr<AVFrame> frame) override;
+
 			virtual std::shared_ptr<AVFrame> avframe_from_obs(AVBufferRef* frames, uint32_t handle,
 			                                                  uint64_t  lock_key,
 			                                                  uint64_t* next_lock_key) override;

source/plugin.cpp

@@ -106,8 +106,8 @@ try {
 			if (!av_codec_is_encoder(cdc))
 				continue;
 
-			if ((cdc->type == AVMediaType::AVMEDIA_TYPE_AUDIO)
-			    || (cdc->type == AVMediaType::AVMEDIA_TYPE_VIDEO)) {
+			if (/*(cdc->type == AVMediaType::AVMEDIA_TYPE_AUDIO)
+			    || */(cdc->type == AVMediaType::AVMEDIA_TYPE_VIDEO)) {
 				auto ptr = std::make_shared<obsffmpeg::encoder_factory>(cdc);
 				ptr->register_encoder();
 				generic_factories.emplace(cdc, ptr);

source/ui/debug_handler.cpp

@@ -35,7 +35,7 @@ extern "C" {
 #pragma warning(pop)
 }
 
-void obsffmpeg::ui::debug_handler::get_defaults(obs_data_t*, const AVCodec*, AVCodecContext*) {}
+void obsffmpeg::ui::debug_handler::get_defaults(obs_data_t*, const AVCodec*, AVCodecContext*, bool) {}
 
 template<typename T>
 std::string to_string(T value){};
@@ -64,7 +64,8 @@ std::string to_string(double_t value)
 	return std::string(buf.data(), buf.data() + buf.size());
 }
 
-void obsffmpeg::ui::debug_handler::get_properties(obs_properties_t*, const AVCodec* codec, AVCodecContext* context)
+void obsffmpeg::ui::debug_handler::get_properties(obs_properties_t*, const AVCodec* codec, AVCodecContext* context,
+                                                  bool)
 {
 	if (context)
 		return;

source/ui/debug_handler.hpp

@@ -26,11 +26,11 @@ namespace obsffmpeg {
 	namespace ui {
 		class debug_handler : public handler {
 			public:
-			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec,
-			                          AVCodecContext* context) override;
+			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context,
+			                          bool hw_encode) override;
 
 			virtual void get_properties(obs_properties_t* props, const AVCodec* codec,
-			                            AVCodecContext* context) override;
+			                            AVCodecContext* context, bool hw_encode) override;
 
 			virtual void update(obs_data_t* settings, const AVCodec* codec,
 			                    AVCodecContext* context) override;

source/ui/handler.cpp

@@ -20,37 +20,27 @@
 // SOFTWARE.
 
 #include "handler.hpp"
+#include "encoder.hpp"
 
-void obsffmpeg::ui::handler::override_visible_name(const AVCodec*, std::string&) {}
-
-void obsffmpeg::ui::handler::override_info(obs_encoder_info* main, obs_encoder_info* fallback) {}
-
-void obsffmpeg::ui::handler::override_colorformat(AVPixelFormat& target_format, obs_data_t* settings,
-                                                  const AVCodec* codec, AVCodecContext* context)
+void obsffmpeg::ui::handler::adjust_encoder_info(obsffmpeg::encoder_factory*, obsffmpeg::encoder_info*,
+                                                 obsffmpeg::encoder_info*)
 {}
 
-void obsffmpeg::ui::handler::get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) {}
+void obsffmpeg::ui::handler::get_defaults(obs_data_t*, const AVCodec*, AVCodecContext*, bool) {}
 
-void obsffmpeg::ui::handler::get_properties(obs_properties_t* props, const AVCodec* codec, AVCodecContext* context) {}
-
-obsffmpeg::hwapi::device obsffmpeg::ui::handler::find_hw_device(std::shared_ptr<obsffmpeg::hwapi::base> api,
-                                                                const AVCodec* codec, AVCodecContext* context)
+bool obsffmpeg::ui::handler::has_keyframe_support(obsffmpeg::encoder* instance)
 {
-	return obsffmpeg::hwapi::device();
+	return (instance->get_avcodec()->capabilities & AV_CODEC_CAP_INTRA_ONLY) == 0;
 }
 
-void obsffmpeg::ui::handler::update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) {}
+void obsffmpeg::ui::handler::get_properties(obs_properties_t*, const AVCodec*, AVCodecContext*, bool) {}
 
-void obsffmpeg::ui::handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context) {}
+void obsffmpeg::ui::handler::update(obs_data_t*, const AVCodec*, AVCodecContext*) {}
 
-void obsffmpeg::ui::handler::import_from_ffmpeg(const std::string ffmpeg, obs_data_t* settings, const AVCodec* codec,
-                                                AVCodecContext* context)
-{}
+void obsffmpeg::ui::handler::override_update(obsffmpeg::encoder*, obs_data_t*) {}
 
-std::string obsffmpeg::ui::handler::export_for_ffmpeg(obs_data_t* settings, const AVCodec* codec,
-                                                      AVCodecContext* context)
-{
-	return std::string();
-}
+void obsffmpeg::ui::handler::log_options(obs_data_t*, const AVCodec*, AVCodecContext*) {}
 
-void obsffmpeg::ui::handler::process_avpacket(AVPacket& packet, const AVCodec* codec, AVCodecContext* context) {}
+void obsffmpeg::ui::handler::override_colorformat(AVPixelFormat&, obs_data_t*, const AVCodec*, AVCodecContext*) {}
+
+void obsffmpeg::ui::handler::process_avpacket(AVPacket&, const AVCodec*, AVCodecContext*) {}

source/ui/handler.hpp

@@ -37,33 +37,36 @@ extern "C" {
 }
 
 namespace obsffmpeg {
+	struct encoder_info;
+	class encoder_factory;
+	class encoder;
+
 	namespace ui {
 		class handler {
-			public:
-			virtual void override_visible_name(const AVCodec* codec, std::string& name);
+			public /*factory*/:
+			virtual void adjust_encoder_info(obsffmpeg::encoder_factory* factory,
+			                                 obsffmpeg::encoder_info*    main,
+			                                 obsffmpeg::encoder_info*    fallback);
 
-			virtual void override_info(obs_encoder_info* main, obs_encoder_info* fallback);
+			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context,
+			                          bool hw_encode);
 
-			virtual void override_colorformat(AVPixelFormat& target_format, obs_data_t* settings,
-			                                  const AVCodec* codec, AVCodecContext* context);
-
-			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
+			public /*settings*/:
+			virtual bool has_keyframe_support(obsffmpeg::encoder* instance);
 
 			virtual void get_properties(obs_properties_t* props, const AVCodec* codec,
-			                            AVCodecContext* context);
-
-			virtual obsffmpeg::hwapi::device find_hw_device(std::shared_ptr<obsffmpeg::hwapi::base> api,
-			                                                const AVCodec* codec, AVCodecContext* context);
+			                            AVCodecContext* context, bool hw_encode);
 
 			virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
+			virtual void override_update(obsffmpeg::encoder* instance, obs_data_t* settings);
+
 			virtual void log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
-			virtual void import_from_ffmpeg(const std::string ffmpeg, obs_data_t* settings,
-			                                const AVCodec* codec, AVCodecContext* context);
+			public /*instance*/:
 
-			virtual std::string export_for_ffmpeg(obs_data_t* settings, const AVCodec* codec,
-			                                      AVCodecContext* context);
+			virtual void override_colorformat(AVPixelFormat& target_format, obs_data_t* settings,
+			                                  const AVCodec* codec, AVCodecContext* context);
 
 			virtual void process_avpacket(AVPacket& packet, const AVCodec* codec, AVCodecContext* context);
 		};

source/ui/nvenc_h264_handler.cpp

@@ -21,6 +21,8 @@
 
 #include "nvenc_h264_handler.hpp"
 #include "codecs/h264.hpp"
+#include "encoder.hpp"
+#include "ffmpeg/tools.hpp"
 #include "nvenc_shared.hpp"
 #include "plugin.hpp"
 #include "strings.hpp"
@@ -34,30 +36,7 @@ extern "C" {
 #pragma warning(pop)
 }
 
-/* Missing Options:
-
-Seem to be covered by initQP_* instead.
-- [obs-ffmpeg-encoder]   Option 'cq' with help 'Set target quality level (0 to 51, 0 means automatic) for constant quality mode in VBR rate control' of type 'Float' with default value '0.000000', minimum '0.000000' and maximum '51.000000'.
-- [obs-ffmpeg-encoder]   Option 'qp' with help 'Constant quantization parameter rate control method' of type 'Int' with default value '-1', minimum '-1.000000' and maximum '51.000000'.
-
-Not sure what there are useful for.
-[obs-ffmpeg-encoder]   Option 'aud' with help 'Use access unit delimiters' of type 'Bool' with default value 'false', minimum '0.000000' and maximum '1.000000'.
-[obs-ffmpeg-encoder]   Option 'surfaces' with help 'Number of concurrent surfaces' of type 'Int' with default value '0', minimum '0.000000' and maximum '64.000000'.
-[obs-ffmpeg-encoder]   Option 'delay' with help 'Delay frame output by the given amount of frames' of type 'Int' with default value '2147483647', minimum '0.000000' and maximum '2147483647.000000'.
-
-Should probably add this.
-[obs-ffmpeg-encoder]   Option 'gpu' with unit (gpu) with help 'Selects which NVENC capable GPU to use. First GPU is 0, second is 1, and so on.' of type 'Int' with default value '-1', minimum '-2.000000' and maximum '2147483647.000000'.
-[obs-ffmpeg-encoder]   [gpu] Constant 'any' and help text 'Pick the first device available' with value '-1'.
-[obs-ffmpeg-encoder]   [gpu] Constant 'list' and help text 'List the available devices' with value '-2'.
-
-Useless except for strict_gop maybe?
-[obs-ffmpeg-encoder]   Option 'forced-idr' with help 'If forcing keyframes, force them as IDR frames.' of type 'Bool' with default value 'false', minimum '-1.000000' and maximum '1.000000'.
-[obs-ffmpeg-encoder]   Option 'strict_gop' with help 'Set 1 to minimize GOP-to-GOP rate fluctuations' of type 'Bool' with default value 'false', minimum '0.000000' and maximum '1.000000'.
-[obs-ffmpeg-encoder]   Option 'bluray-compat' with help 'Bluray compatibility workarounds' of type 'Bool' with default value 'false', minimum '0.000000' and maximum '1.000000'.
-*/
-
 using namespace obsffmpeg::codecs::h264;
-using namespace obsffmpeg::nvenc;
 
 std::map<profile, std::string> profiles{
     {profile::BASELINE, "baseline"},
@@ -80,13 +59,15 @@ INITIALIZER(nvenc_h264_handler_init)
 	});
 };
 
-void obsffmpeg::ui::nvenc_h264_handler::override_visible_name(const AVCodec*, std::string& name)
+void obsffmpeg::ui::nvenc_h264_handler::adjust_encoder_info(obsffmpeg::encoder_factory*, obsffmpeg::encoder_info* main,
+                                                            obsffmpeg::encoder_info* fallback)
 {
-	name = "H.264/AVC Encoder (NVidia NVENC)";
+	main->readable_name     = "H.264/AVC NVidia NVENC (Hardware)";
+	fallback->readable_name = "H.264/AVC NVidia NVENC (Software)";
 }
 
 void obsffmpeg::ui::nvenc_h264_handler::get_defaults(obs_data_t* settings, const AVCodec* codec,
-                                                     AVCodecContext* context)
+                                                     AVCodecContext* context, bool)
 {
 	nvenc::get_defaults(settings, codec, context);
 
@@ -94,8 +75,13 @@ void obsffmpeg::ui::nvenc_h264_handler::get_defaults(obs_data_t* settings, const
 	obs_data_set_default_int(settings, P_H264_LEVEL, static_cast<int64_t>(codecs::h264::level::UNKNOWN));
 }
 
+bool obsffmpeg::ui::nvenc_h264_handler::has_keyframe_support(obsffmpeg::encoder*)
+{
+	return true;
+}
+
 void obsffmpeg::ui::nvenc_h264_handler::get_properties(obs_properties_t* props, const AVCodec* codec,
-                                                       AVCodecContext* context)
+                                                       AVCodecContext* context, bool)
 {
 	if (!context) {
 		this->get_encoder_properties(props, codec);
@@ -126,20 +112,30 @@ void obsffmpeg::ui::nvenc_h264_handler::update(obs_data_t* settings, const AVCod
 	}
 }
 
+void obsffmpeg::ui::nvenc_h264_handler::override_update(obsffmpeg::encoder* instance, obs_data_t* settings)
+{
+	nvenc::override_update(instance, settings);
+}
+
 void obsffmpeg::ui::nvenc_h264_handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
 {
 	nvenc::log_options(settings, codec, context);
 
-	profile cfg_profile = static_cast<profile>(obs_data_get_int(settings, P_H264_PROFILE));
-	level   cfg_level   = static_cast<level>(obs_data_get_int(settings, P_H264_LEVEL));
-
-	auto found1 = profiles.find(cfg_profile);
-	if (found1 != profiles.end())
-		PLOG_INFO("[%s]   H.264 Profile: %s", codec->name, found1->second.c_str());
-
-	auto found2 = levels.find(cfg_level);
-	if (found2 != levels.end())
-		PLOG_INFO("[%s]   H.264 Level: %s", codec->name, found2->second.c_str());
+	PLOG_INFO("[%s]     H.265/HEVC:", codec->name);
+	ffmpeg::tools::print_av_option_string(context, "profile", "      Profile", [](int64_t v) {
+		profile val   = static_cast<profile>(v);
+		auto    index = profiles.find(val);
+		if (index != profiles.end())
+			return index->second;
+		return std::string("<Unknown>");
+	});
+	ffmpeg::tools::print_av_option_string(context, "level", "      Level", [](int64_t v) {
+		level val   = static_cast<level>(v);
+		auto  index = levels.find(val);
+		if (index != levels.end())
+			return index->second;
+		return std::string("<Unknown>");
+	});
 }
 
 void obsffmpeg::ui::nvenc_h264_handler::get_encoder_properties(obs_properties_t* props, const AVCodec* codec)

source/ui/nvenc_h264_handler.hpp

@@ -33,20 +33,28 @@ extern "C" {
 namespace obsffmpeg {
 	namespace ui {
 		class nvenc_h264_handler : public handler {
-			public:
-			virtual void override_visible_name(const AVCodec* codec, std::string& name) override;
+			public /*factory*/:
+			virtual void adjust_encoder_info(obsffmpeg::encoder_factory* factory,
+			                                 obsffmpeg::encoder_info*    main,
+			                                 obsffmpeg::encoder_info*    fallback);
 
-			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec,
-			                          AVCodecContext* context) override;
+			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context,
+			                          bool hw_encode);
+
+			public /*settings*/:
+			virtual bool has_keyframe_support(obsffmpeg::encoder* instance);
 
 			virtual void get_properties(obs_properties_t* props, const AVCodec* codec,
-			                            AVCodecContext* context) override;
+			                            AVCodecContext* context, bool hw_encode);
 
-			virtual void update(obs_data_t* settings, const AVCodec* codec,
-			                    AVCodecContext* context) override;
+			virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
-			virtual void log_options(obs_data_t* settings, const AVCodec* codec,
-			                         AVCodecContext* context) override;
+			virtual void override_update(obsffmpeg::encoder* instance, obs_data_t* settings);
+
+			virtual void log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
+
+			public /*instance*/:
+			//virtual void override_colorformat(AVPixelFormat& target_format, obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
 			private:
 			void get_encoder_properties(obs_properties_t* props, const AVCodec* codec);

source/ui/nvenc_hevc_handler.cpp

@@ -21,6 +21,8 @@
 
 #include "nvenc_hevc_handler.hpp"
 #include "codecs/hevc.hpp"
+#include "encoder.hpp"
+#include "ffmpeg/tools.hpp"
 #include "nvenc_shared.hpp"
 #include "plugin.hpp"
 #include "strings.hpp"
@@ -34,28 +36,6 @@ extern "C" {
 #pragma warning(pop)
 }
 
-/* Missing Options:
-
-Seem to be covered by initQP_* instead.
-- [obs-ffmpeg-encoder]   Option 'cq' with help 'Set target quality level (0 to 51, 0 means automatic) for constant quality mode in VBR rate control' of type 'Float' with default value '0.000000', minimum '0.000000' and maximum '51.000000'.
-- [obs-ffmpeg-encoder]   Option 'qp' with help 'Constant quantization parameter rate control method' of type 'Int' with default value '-1', minimum '-1.000000' and maximum '51.000000'.
-
-Not sure what there are useful for.
-[obs-ffmpeg-encoder]   Option 'aud' with help 'Use access unit delimiters' of type 'Bool' with default value 'false', minimum '0.000000' and maximum '1.000000'.
-[obs-ffmpeg-encoder]   Option 'surfaces' with help 'Number of concurrent surfaces' of type 'Int' with default value '0', minimum '0.000000' and maximum '64.000000'.
-[obs-ffmpeg-encoder]   Option 'delay' with help 'Delay frame output by the given amount of frames' of type 'Int' with default value '2147483647', minimum '0.000000' and maximum '2147483647.000000'.
-
-Should probably add this.
-[obs-ffmpeg-encoder]   Option 'gpu' with unit (gpu) with help 'Selects which NVENC capable GPU to use. First GPU is 0, second is 1, and so on.' of type 'Int' with default value '-1', minimum '-2.000000' and maximum '2147483647.000000'.
-[obs-ffmpeg-encoder]   [gpu] Constant 'any' and help text 'Pick the first device available' with value '-1'.
-[obs-ffmpeg-encoder]   [gpu] Constant 'list' and help text 'List the available devices' with value '-2'.
-
-Useless except for strict_gop maybe?
-[obs-ffmpeg-encoder]   Option 'forced-idr' with help 'If forcing keyframes, force them as IDR frames.' of type 'Bool' with default value 'false', minimum '-1.000000' and maximum '1.000000'.
-[obs-ffmpeg-encoder]   Option 'strict_gop' with help 'Set 1 to minimize GOP-to-GOP rate fluctuations' of type 'Bool' with default value 'false', minimum '0.000000' and maximum '1.000000'.
-[obs-ffmpeg-encoder]   Option 'bluray-compat' with help 'Bluray compatibility workarounds' of type 'Bool' with default value 'false', minimum '0.000000' and maximum '1.000000'.
-*/
-
 using namespace obsffmpeg::codecs::hevc;
 
 std::map<profile, std::string> profiles{
@@ -82,13 +62,15 @@ INITIALIZER(nvenc_hevc_handler_init)
 	});
 };
 
-void obsffmpeg::ui::nvenc_hevc_handler::override_visible_name(const AVCodec*, std::string& name)
+void obsffmpeg::ui::nvenc_hevc_handler::adjust_encoder_info(obsffmpeg::encoder_factory*, obsffmpeg::encoder_info* main,
+                                                            obsffmpeg::encoder_info* fallback)
 {
-	name = "H.265/HEVC Encoder (NVidia NVENC)";
+	main->readable_name     = "H.265/HEVC Nvidia NVENC (Hardware)";
+	fallback->readable_name = "H.265/HEVC Nvidia NVENC (Software)";
 }
 
 void obsffmpeg::ui::nvenc_hevc_handler::get_defaults(obs_data_t* settings, const AVCodec* codec,
-                                                     AVCodecContext* context)
+                                                     AVCodecContext* context, bool)
 {
 	nvenc::get_defaults(settings, codec, context);
 
@@ -97,8 +79,13 @@ void obsffmpeg::ui::nvenc_hevc_handler::get_defaults(obs_data_t* settings, const
 	obs_data_set_default_int(settings, P_HEVC_LEVEL, static_cast<int64_t>(codecs::hevc::level::UNKNOWN));
 }
 
+bool obsffmpeg::ui::nvenc_hevc_handler::has_keyframe_support(obsffmpeg::encoder*)
+{
+	return true;
+}
+
 void obsffmpeg::ui::nvenc_hevc_handler::get_properties(obs_properties_t* props, const AVCodec* codec,
-                                                       AVCodecContext* context)
+                                                       AVCodecContext* context, bool)
 {
 	if (!context) {
 		this->get_encoder_properties(props, codec);
@@ -133,25 +120,37 @@ void obsffmpeg::ui::nvenc_hevc_handler::update(obs_data_t* settings, const AVCod
 	}
 }
 
+void obsffmpeg::ui::nvenc_hevc_handler::override_update(obsffmpeg::encoder* instance, obs_data_t* settings)
+{
+	nvenc::override_update(instance, settings);
+}
+
 void obsffmpeg::ui::nvenc_hevc_handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
 {
 	nvenc::log_options(settings, codec, context);
 
-	profile cfg_profile = static_cast<profile>(obs_data_get_int(settings, P_HEVC_PROFILE));
-	tier    cfg_tier    = static_cast<tier>(obs_data_get_int(settings, P_HEVC_TIER));
-	level   cfg_level   = static_cast<level>(obs_data_get_int(settings, P_HEVC_LEVEL));
-
-	auto found1 = profiles.find(cfg_profile);
-	if (found1 != profiles.end())
-		PLOG_INFO("[%s]   H.265 Profile: %s", codec->name, found1->second.c_str());
-
-	auto found2 = levels.find(cfg_level);
-	if (found2 != levels.end())
-		PLOG_INFO("[%s]   H.265 Level: %s", codec->name, found2->second.c_str());
-
-	auto found3 = tiers.find(cfg_tier);
-	if (found3 != tiers.end())
-		PLOG_INFO("[%s]   H.265 Tier: %s", codec->name, found3->second.c_str());
+	PLOG_INFO("[%s]     H.265/HEVC:", codec->name);
+	ffmpeg::tools::print_av_option_string(context, "profile", "      Profile", [](int64_t v) {
+		profile val   = static_cast<profile>(v);
+		auto    index = profiles.find(val);
+		if (index != profiles.end())
+			return index->second;
+		return std::string("<Unknown>");
+	});
+	ffmpeg::tools::print_av_option_string(context, "level", "      Level", [](int64_t v) {
+		level val   = static_cast<level>(v);
+		auto  index = levels.find(val);
+		if (index != levels.end())
+			return index->second;
+		return std::string("<Unknown>");
+	});
+	ffmpeg::tools::print_av_option_string(context, "tier", "      Tier", [](int64_t v) {
+		tier val   = static_cast<tier>(v);
+		auto index = tiers.find(val);
+		if (index != tiers.end())
+			return index->second;
+		return std::string("<Unknown>");
+	});
 }
 
 void obsffmpeg::ui::nvenc_hevc_handler::get_encoder_properties(obs_properties_t* props, const AVCodec* codec)

source/ui/nvenc_hevc_handler.hpp

@@ -33,20 +33,28 @@ extern "C" {
 namespace obsffmpeg {
 	namespace ui {
 		class nvenc_hevc_handler : public handler {
-			public:
-			virtual void override_visible_name(const AVCodec* codec, std::string& name) override;
+			public /*factory*/:
+			virtual void adjust_encoder_info(obsffmpeg::encoder_factory* factory,
+			                                 obsffmpeg::encoder_info*    main,
+			                                 obsffmpeg::encoder_info*    fallback);
 
-			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec,
-			                          AVCodecContext* context) override;
+			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context,
+			                          bool hw_encode);
+
+			public /*settings*/:
+			virtual bool has_keyframe_support(obsffmpeg::encoder* instance);
 
 			virtual void get_properties(obs_properties_t* props, const AVCodec* codec,
-			                            AVCodecContext* context) override;
+			                            AVCodecContext* context, bool hw_encode);
 
-			virtual void update(obs_data_t* settings, const AVCodec* codec,
-			                    AVCodecContext* context) override;
+			virtual void update(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
-			virtual void log_options(obs_data_t* settings, const AVCodec* codec,
-			                         AVCodecContext* context) override;
+			virtual void override_update(obsffmpeg::encoder* instance, obs_data_t* settings);
+
+			virtual void log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
+
+			public /*instance*/:
+			//virtual void override_colorformat(AVPixelFormat& target_format, obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
 			private:
 			void get_encoder_properties(obs_properties_t* props, const AVCodec* codec);

source/ui/nvenc_shared.cpp

@@ -20,7 +20,10 @@
 // SOFTWARE.
 
 #include "nvenc_shared.hpp"
+#include <algorithm>
 #include "codecs/hevc.hpp"
+#include "encoder.hpp"
+#include "ffmpeg/tools.hpp"
 #include "plugin.hpp"
 #include "strings.hpp"
 #include "utility.hpp"
@@ -131,6 +134,36 @@ std::map<b_ref_mode, std::string> obsffmpeg::nvenc::b_ref_mode_to_opt{
     {b_ref_mode::MIDDLE, "middle"},
 };
 
+void obsffmpeg::nvenc::override_update(obsffmpeg::encoder* instance, obs_data_t*)
+{
+	AVCodecContext* context = const_cast<AVCodecContext*>(instance->get_avcodeccontext());
+
+	int64_t rclookahead = 0;
+	int64_t surfaces    = 0;
+	int64_t async_depth = 0;
+
+	av_opt_get_int(context, "rc-lookahead", AV_OPT_SEARCH_CHILDREN, &rclookahead);
+	av_opt_get_int(context, "surfaces", AV_OPT_SEARCH_CHILDREN, &surfaces);
+	av_opt_get_int(context, "async_depth", AV_OPT_SEARCH_CHILDREN, &async_depth);
+
+	// Calculate and set the number of surfaces to allocate (if not user overridden).
+	if (surfaces == 0) {
+		surfaces = std::max(4ll, (context->max_b_frames + 1ll) * 4ll);
+		if (rclookahead > 0) {
+			surfaces = std::max(1ll, std::max(surfaces, rclookahead + (context->max_b_frames + 5ll)));
+		} else if (context->max_b_frames > 0) {
+			surfaces = std::max(4ll, (context->max_b_frames + 1ll) * 4ll);
+		} else {
+			surfaces = 4;
+		}
+
+		av_opt_set_int(context, "surfaces", surfaces, AV_OPT_SEARCH_CHILDREN);
+	}
+
+	// Set delay
+	context->delay = static_cast<int>(std::min(std::max(async_depth, 3ll), surfaces - 1));
+}
+
 void obsffmpeg::nvenc::get_defaults(obs_data_t* settings, const AVCodec*, AVCodecContext*)
 {
 	obs_data_set_default_int(settings, ST_PRESET, static_cast<int64_t>(preset::DEFAULT));
@@ -138,8 +171,8 @@ void obsffmpeg::nvenc::get_defaults(obs_data_t* settings, const AVCodec*, AVCode
 	obs_data_set_default_int(settings, ST_RATECONTROL_MODE, static_cast<int64_t>(ratecontrolmode::CBR_HQ));
 	obs_data_set_default_int(settings, ST_RATECONTROL_TWOPASS, -1);
 	obs_data_set_default_int(settings, ST_RATECONTROL_LOOKAHEAD, 0);
-	obs_data_set_default_bool(settings, ST_RATECONTROL_ADAPTIVEI, true);
-	obs_data_set_default_bool(settings, ST_RATECONTROL_ADAPTIVEB, true);
+	obs_data_set_default_int(settings, ST_RATECONTROL_ADAPTIVEI, -1);
+	obs_data_set_default_int(settings, ST_RATECONTROL_ADAPTIVEB, -1);
 
 	obs_data_set_default_int(settings, ST_RATECONTROL_BITRATE_TARGET, 6000);
 	obs_data_set_default_int(settings, ST_RATECONTROL_BITRATE_MAXIMUM, 6000);
@@ -156,15 +189,18 @@ void obsffmpeg::nvenc::get_defaults(obs_data_t* settings, const AVCodec*, AVCode
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_B, 21);
 	obs_data_set_default_int(settings, ST_RATECONTROL_QP_B_INITIAL, -1);
 
-	obs_data_set_default_bool(settings, ST_AQ_SPATIAL, true);
+	obs_data_set_default_int(settings, ST_AQ_SPATIAL, -1);
 	obs_data_set_default_int(settings, ST_AQ_STRENGTH, 8);
-	obs_data_set_default_bool(settings, ST_AQ_TEMPORAL, true);
+	obs_data_set_default_int(settings, ST_AQ_TEMPORAL, -1);
 
 	obs_data_set_default_int(settings, ST_OTHER_BFRAMES, 2);
 	obs_data_set_default_int(settings, ST_OTHER_BFRAME_REFERENCEMODE, static_cast<int64_t>(b_ref_mode::DISABLED));
-	obs_data_set_default_bool(settings, ST_OTHER_ZEROLATENCY, false);
-	obs_data_set_default_bool(settings, ST_OTHER_WEIGHTED_PREDICTION, false);
-	obs_data_set_default_bool(settings, ST_OTHER_NONREFERENCE_PFRAMES, false);
+	obs_data_set_default_int(settings, ST_OTHER_ZEROLATENCY, -1);
+	obs_data_set_default_int(settings, ST_OTHER_WEIGHTED_PREDICTION, -1);
+	obs_data_set_default_int(settings, ST_OTHER_NONREFERENCE_PFRAMES, -1);
+
+	// Replay Buffer
+	obs_data_set_default_int(settings, "bitrate", 0);
 }
 
 static bool modified_ratecontrol(obs_properties_t* props, obs_property_t*, obs_data_t* settings)
@@ -227,7 +263,7 @@ static bool modified_quality(obs_properties_t* props, obs_property_t*, obs_data_
 
 static bool modified_aq(obs_properties_t* props, obs_property_t*, obs_data_t* settings)
 {
-	bool spatial_aq = obs_data_get_bool(settings, ST_AQ_SPATIAL);
+	bool spatial_aq = obs_data_get_int(settings, ST_AQ_SPATIAL) == 1;
 	obs_property_set_visible(obs_properties_get(props, ST_AQ_STRENGTH), spatial_aq);
 	return true;
 }
@@ -266,12 +302,9 @@ void obsffmpeg::nvenc::get_properties_post(obs_properties_t* props, const AVCode
 		}
 
 		{
-			auto p = obs_properties_add_list(grp, ST_RATECONTROL_TWOPASS, TRANSLATE(ST_RATECONTROL_TWOPASS),
-			                                 OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_RATECONTROL_TWOPASS,
+			                                                TRANSLATE(ST_RATECONTROL_TWOPASS));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_RATECONTROL_TWOPASS)));
-			obs_property_list_add_int(p, TRANSLATE(S_STATE_DEFAULT), -1);
-			obs_property_list_add_int(p, TRANSLATE(S_STATE_DISABLED), 0);
-			obs_property_list_add_int(p, TRANSLATE(S_STATE_ENABLED), 1);
 		}
 
 		{
@@ -281,13 +314,13 @@ void obsffmpeg::nvenc::get_properties_post(obs_properties_t* props, const AVCode
 			obs_property_int_set_suffix(p, " frames");
 		}
 		{
-			auto p =
-			    obs_properties_add_bool(grp, ST_RATECONTROL_ADAPTIVEI, TRANSLATE(ST_RATECONTROL_ADAPTIVEI));
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_RATECONTROL_ADAPTIVEI,
+			                                                TRANSLATE(ST_RATECONTROL_ADAPTIVEI));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_RATECONTROL_ADAPTIVEI)));
 		}
 		if (strcmp(codec->name, "h264_nvenc") == 0) {
-			auto p =
-			    obs_properties_add_bool(grp, ST_RATECONTROL_ADAPTIVEB, TRANSLATE(ST_RATECONTROL_ADAPTIVEB));
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_RATECONTROL_ADAPTIVEB,
+			                                                TRANSLATE(ST_RATECONTROL_ADAPTIVEB));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_RATECONTROL_ADAPTIVEB)));
 		}
 	}
@@ -403,7 +436,7 @@ void obsffmpeg::nvenc::get_properties_post(obs_properties_t* props, const AVCode
 		}
 
 		{
-			auto p = obs_properties_add_bool(grp, ST_AQ_SPATIAL, TRANSLATE(ST_AQ_SPATIAL));
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_AQ_SPATIAL, TRANSLATE(ST_AQ_SPATIAL));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_AQ_SPATIAL)));
 			obs_property_set_modified_callback(p, modified_aq);
 		}
@@ -413,7 +446,7 @@ void obsffmpeg::nvenc::get_properties_post(obs_properties_t* props, const AVCode
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_AQ_STRENGTH)));
 		}
 		{
-			auto p = obs_properties_add_bool(grp, ST_AQ_TEMPORAL, TRANSLATE(ST_AQ_TEMPORAL));
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_AQ_TEMPORAL, TRANSLATE(ST_AQ_TEMPORAL));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_AQ_TEMPORAL)));
 		}
 	}
@@ -444,18 +477,19 @@ void obsffmpeg::nvenc::get_properties_post(obs_properties_t* props, const AVCode
 		}
 
 		{
-			auto p = obs_properties_add_bool(grp, ST_OTHER_ZEROLATENCY, TRANSLATE(ST_OTHER_ZEROLATENCY));
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_OTHER_ZEROLATENCY,
+			                                                TRANSLATE(ST_OTHER_ZEROLATENCY));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_OTHER_ZEROLATENCY)));
 		}
 
 		{
-			auto p = obs_properties_add_bool(grp, ST_OTHER_WEIGHTED_PREDICTION,
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_OTHER_WEIGHTED_PREDICTION,
 			                                                TRANSLATE(ST_OTHER_WEIGHTED_PREDICTION));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_OTHER_WEIGHTED_PREDICTION)));
 		}
 
 		{
-			auto p = obs_properties_add_bool(grp, ST_OTHER_NONREFERENCE_PFRAMES,
+			auto p = obsffmpeg::obs_properties_add_tristate(grp, ST_OTHER_NONREFERENCE_PFRAMES,
 			                                                TRANSLATE(ST_OTHER_NONREFERENCE_PFRAMES));
 			obs_property_set_long_description(p, TRANSLATE(DESC(ST_OTHER_NONREFERENCE_PFRAMES)));
 		}
@@ -523,6 +557,7 @@ void obsffmpeg::nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCode
 			av_opt_set(context->priv_data, "rc", rcopt->second.c_str(), 0);
 		}
 
+		av_opt_set_int(context->priv_data, "cbr", 0, 0);
 		switch (rc) {
 		case ratecontrolmode::CQP:
 			have_qp = true;
@@ -548,20 +583,28 @@ void obsffmpeg::nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCode
 		}
 
 		int la = static_cast<int>(obs_data_get_int(settings, ST_RATECONTROL_LOOKAHEAD));
-		av_opt_set_int(context->priv_data, "lookahead", la, 0);
+		av_opt_set_int(context->priv_data, "rc-lookahead", la, 0);
 		if (la > 0) {
-			bool adapt_i = obs_data_get_bool(settings, ST_RATECONTROL_ADAPTIVEI);
-			av_opt_set_int(context->priv_data, "no-scenecut", !adapt_i ? 1 : 0, 0);
+			int64_t adapt_i = obs_data_get_int(settings, ST_RATECONTROL_ADAPTIVEI);
+			if (!is_tristate_default(adapt_i)) {
+				av_opt_set_int(context->priv_data, "no-scenecut", adapt_i, AV_OPT_SEARCH_CHILDREN);
+			}
 
 			if (strcmp(codec->name, "h264_nvenc")) {
-				bool adapt_b = obs_data_get_bool(settings, ST_RATECONTROL_ADAPTIVEB);
-				av_opt_set_int(context->priv_data, "b_adapt", adapt_b ? 1 : 0, 0);
+				int64_t adapt_b = obs_data_get_int(settings, ST_RATECONTROL_ADAPTIVEB);
+				if (!is_tristate_default(adapt_b)) {
+					av_opt_set_int(context->priv_data, "b_adapt", adapt_b, AV_OPT_SEARCH_CHILDREN);
+				}
 			}
 		}
 
-		if (have_bitrate)
+		if (have_bitrate) {
 			context->bit_rate =
 			    static_cast<int>(obs_data_get_int(settings, ST_RATECONTROL_BITRATE_TARGET) * 1000);
+			// Support for Replay Buffer
+			obs_data_set_int(settings, "bitrate",
+			                 obs_data_get_int(settings, ST_RATECONTROL_BITRATE_TARGET));
+		}
 		if (have_bitrate_max)
 			context->rc_max_rate =
 			    static_cast<int>(obs_data_get_int(settings, ST_RATECONTROL_BITRATE_MAXIMUM) * 1000);
@@ -604,37 +647,42 @@ void obsffmpeg::nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCode
 	}
 
 	{ // AQ
-		bool saq = obs_data_get_bool(settings, ST_AQ_SPATIAL);
-		bool taq = obs_data_get_bool(settings, ST_AQ_TEMPORAL);
+		int64_t saq = obs_data_get_int(settings, ST_AQ_SPATIAL);
+		int64_t taq = obs_data_get_int(settings, ST_AQ_TEMPORAL);
 
-		if (strcmp(codec->name, "h264_nvenc")) {
-			av_opt_set_int(context->priv_data, "spatial-aq", saq ? 1 : 0, 0);
-			av_opt_set_int(context->priv_data, "temporal-aq", taq ? 1 : 0, 0);
+		if (strcmp(codec->name, "h264_nvenc") == 0) {
+			if (!is_tristate_default(saq))
+				av_opt_set_int(context->priv_data, "spatial-aq", saq, 0);
+			if (!is_tristate_default(taq))
+				av_opt_set_int(context->priv_data, "temporal-aq", taq, 0);
 		} else {
-			av_opt_set_int(context->priv_data, "spatial_aq", saq ? 1 : 0, 0);
-			av_opt_set_int(context->priv_data, "temporal_aq", taq ? 1 : 0, 0);
+			if (!is_tristate_default(saq))
+				av_opt_set_int(context->priv_data, "spatial_aq", saq, 0);
+			if (!is_tristate_default(taq))
+				av_opt_set_int(context->priv_data, "temporal_aq", taq, 0);
 		}
-		if (saq) {
+		if (is_tristate_enabled(saq))
 			av_opt_set_int(context->priv_data, "aq-strength",
 			               static_cast<int>(obs_data_get_int(settings, ST_AQ_STRENGTH)), 0);
 	}
-	}
 
 	{ // Other
-		bool zl  = obs_data_get_bool(settings, ST_OTHER_ZEROLATENCY);
-		bool wp  = obs_data_get_bool(settings, ST_OTHER_WEIGHTED_PREDICTION);
-		bool nrp = obs_data_get_bool(settings, ST_OTHER_NONREFERENCE_PFRAMES);
+		int64_t zl  = obs_data_get_int(settings, ST_OTHER_ZEROLATENCY);
+		int64_t wp  = obs_data_get_int(settings, ST_OTHER_WEIGHTED_PREDICTION);
+		int64_t nrp = obs_data_get_int(settings, ST_OTHER_NONREFERENCE_PFRAMES);
 
 		context->max_b_frames = static_cast<int>(obs_data_get_int(settings, ST_OTHER_BFRAMES));
 
-		av_opt_set_int(context->priv_data, "zerolatency", zl ? 1 : 0, 0);
-		av_opt_set_int(context->priv_data, "nonref_p", nrp ? 1 : 0, 0);
+		if (!is_tristate_default(zl))
+			av_opt_set_int(context->priv_data, "zerolatency", zl, 0);
+		if (!is_tristate_default(nrp))
+			av_opt_set_int(context->priv_data, "nonref_p", nrp, 0);
 
-		if ((context->max_b_frames != 0) && wp) {
-			PLOG_WARNING(
-			    "Automatically disabled weighted prediction due to being incompatible with B-Frames.");
-		} else {
-			av_opt_set_int(context->priv_data, "weighted_pred", wp ? 1 : 0, 0);
+		if ((context->max_b_frames != 0) && is_tristate_enabled(wp)) {
+			PLOG_WARNING("[%s] Weighted Prediction disabled because of B-Frames being used.", codec->name);
+			av_opt_set_int(context->priv_data, "weighted_pred", 0, 0);
+		} else if (!is_tristate_default(wp)) {
+			av_opt_set_int(context->priv_data, "weighted_pred", wp, 0);
 		}
 
 		{
@@ -647,112 +695,73 @@ void obsffmpeg::nvenc::update(obs_data_t* settings, const AVCodec* codec, AVCode
 	}
 }
 
-void obsffmpeg::nvenc::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
+void obsffmpeg::nvenc::log_options(obs_data_t*, const AVCodec* codec, AVCodecContext* context)
 {
-	preset cfg_preset = static_cast<preset>(obs_data_get_int(settings, ST_PRESET));
+	PLOG_INFO("[%s]   Nvidia NVENC:", codec->name);
+	ffmpeg::tools::print_av_option_string(context, "preset", "    Preset", [](int64_t v) {
+		preset      val   = static_cast<preset>(v);
+		std::string name  = "<Unknown>";
+		auto        index = preset_to_opt.find(val);
+		if (index != preset_to_opt.end())
+			name = index->second;
+		return name;
+	});
+	ffmpeg::tools::print_av_option_string(context, "rc", "    Rate Control", [](int64_t v) {
+		ratecontrolmode val   = static_cast<ratecontrolmode>(v);
+		std::string     name  = "<Unknown>";
+		auto            index = ratecontrolmode_to_opt.find(val);
+		if (index != ratecontrolmode_to_opt.end())
+			name = index->second;
+		return name;
+	});
+	ffmpeg::tools::print_av_option_bool(context, "2pass", "      Two Pass");
+	ffmpeg::tools::print_av_option_int(context, "rc-lookahead", "      Look-Ahead", "Frames");
+	ffmpeg::tools::print_av_option_bool(context, "no-scenecut", "      Adaptive I-Frames");
+	if (strcmp(codec->name, "h264_nvenc") == 0)
+		ffmpeg::tools::print_av_option_bool(context, "b_adapt", "      Adaptive B-Frames");
 
-	auto found1 = preset_to_opt.find(cfg_preset);
-	if (found1 != preset_to_opt.end())
-		PLOG_INFO("[%s]   Preset: %s", codec->name, found1->second.c_str());
+	PLOG_INFO("[%s]       Bitrate:", codec->name);
+	ffmpeg::tools::print_av_option_int(context, "bitrate", "        Target", "bits/sec");
+	ffmpeg::tools::print_av_option_int(context, "rc_max_rate", "        Maximum", "bits/sec");
+	ffmpeg::tools::print_av_option_int(context, "rc_buffer_size", "        Buffer", "bits");
+	PLOG_INFO("[%s]       Quality:", codec->name);
+	ffmpeg::tools::print_av_option_int(context, "qmin", "        Minimum", "");
+	ffmpeg::tools::print_av_option_int(context, "cq", "        Target", "");
+	ffmpeg::tools::print_av_option_int(context, "qmax", "        Maximum", "");
+	PLOG_INFO("[%s]       Quantization Parameters:", codec->name);
+	ffmpeg::tools::print_av_option_int(context, "init_qpI", "        I-Frame", "");
+	ffmpeg::tools::print_av_option_int(context, "init_qpP", "        P-Frame", "");
+	ffmpeg::tools::print_av_option_int(context, "init_qpB", "        B-Frame", "");
 
-	ratecontrolmode cfg_rc_mode   = static_cast<ratecontrolmode>(obs_data_get_int(settings, ST_RATECONTROL_MODE));
-	int64_t         cfg_rc_2pass  = obs_data_get_int(settings, ST_RATECONTROL_TWOPASS);
-	int64_t         cfg_rc_lahead = obs_data_get_int(settings, ST_RATECONTROL_LOOKAHEAD);
-	bool            cfg_rc_adapti = obs_data_get_bool(settings, ST_RATECONTROL_ADAPTIVEI);
-	bool            cfg_rc_adaptb = obs_data_get_bool(settings, ST_RATECONTROL_ADAPTIVEB);
+	ffmpeg::tools::print_av_option_int(context, "max_b_frames", "    B-Frames", "Frames");
+	ffmpeg::tools::print_av_option_string(context, "b_ref_mode", "      Reference Mode", [](int64_t v) {
+		b_ref_mode  val   = static_cast<b_ref_mode>(v);
+		std::string name  = "<Unknown>";
+		auto        index = b_ref_mode_to_opt.find(val);
+		if (index != b_ref_mode_to_opt.end())
+			name = index->second;
+		return name;
+	});
 
-	auto found2 = ratecontrolmode_to_opt.find(cfg_rc_mode);
-	if (found2 != ratecontrolmode_to_opt.end())
-		PLOG_INFO("[%s]   Rate Control: %s", codec->name, found2->second.c_str());
-	PLOG_INFO("[%s]     Two Pass: %s", codec->name,
-	          cfg_rc_2pass == 1 ? "Enabled" : (cfg_rc_2pass == 0 ? "Disabled" : "Default"));
-	PLOG_INFO("[%s]     Lookahead: %" PRId64 " Frames", codec->name, cfg_rc_lahead);
-	if (cfg_rc_adapti && cfg_rc_lahead > 0)
-		PLOG_INFO("[%s]       Adaptive I-Frames Enabled", codec->name);
-	if (cfg_rc_adaptb && cfg_rc_lahead > 0)
-		PLOG_INFO("[%s]       Adaptive B-Frames Enabled", codec->name);
-
-	int64_t  cfg_rc_bitrate     = obs_data_get_int(settings, ST_RATECONTROL_BITRATE_TARGET);
-	int64_t  cfg_rc_max_bitrate = obs_data_get_int(settings, ST_RATECONTROL_BITRATE_MAXIMUM);
-	int64_t  cfg_rc_bufsize     = obs_data_get_int(settings, S_RATECONTROL_BUFFERSIZE);
-	bool     cfg_rc_quality     = obs_data_get_bool(settings, ST_RATECONTROL_QUALITY);
-	int64_t  cfg_rc_quality_min = obs_data_get_int(settings, ST_RATECONTROL_QUALITY_MINIMUM);
-	int64_t  cfg_rc_quality_max = obs_data_get_int(settings, ST_RATECONTROL_QUALITY_MAXIMUM);
-	double_t cfg_rc_quality_tgt = obs_data_get_int(settings, ST_RATECONTROL_QUALITY_TARGET);
-	int64_t  cfg_rc_qp_i        = obs_data_get_int(settings, ST_RATECONTROL_QP_I);
-	int64_t  cfg_rc_qp_p        = obs_data_get_int(settings, ST_RATECONTROL_QP_P);
-	int64_t  cfg_rc_qp_b        = obs_data_get_int(settings, ST_RATECONTROL_QP_B);
-	int64_t  cfg_rc_qp_i_init   = obs_data_get_int(settings, ST_RATECONTROL_QP_I_INITIAL);
-	int64_t  cfg_rc_qp_p_init   = obs_data_get_int(settings, ST_RATECONTROL_QP_P_INITIAL);
-	int64_t  cfg_rc_qp_b_init   = obs_data_get_int(settings, ST_RATECONTROL_QP_B_INITIAL);
-
-	{
-		bool have_bitrate     = false;
-		bool have_bitrate_max = false;
-		bool have_quality     = false;
-		bool have_qp          = false;
-		bool have_qp_init     = false;
-
-		switch (cfg_rc_mode) {
-		case ratecontrolmode::CQP:
-			have_qp = true;
-			break;
-		case ratecontrolmode::CBR:
-		case ratecontrolmode::CBR_HQ:
-		case ratecontrolmode::CBR_LD_HQ:
-			have_bitrate = true;
-			av_opt_set_int(context->priv_data, "cbr", 1, 0);
-			break;
-		case ratecontrolmode::VBR:
-		case ratecontrolmode::VBR_HQ:
-			have_bitrate_max = true;
-			have_bitrate     = true;
-			have_quality     = true;
-			have_qp_init     = true;
-			break;
+	PLOG_INFO("[%s]     Adaptive Quantization:", codec->name);
+	if (strcmp(codec->name, "h264_nvenc") == 0) {
+		ffmpeg::tools::print_av_option_bool(context, "spatial-aq", "      Spatial AQ");
+		ffmpeg::tools::print_av_option_int(context, "aq-strength", "        Strength", "");
+		ffmpeg::tools::print_av_option_bool(context, "temporal-aq", "      Temporal AQ");
+	} else {
+		ffmpeg::tools::print_av_option_bool(context, "spatial_aq", "      Spatial AQ");
+		ffmpeg::tools::print_av_option_int(context, "aq-strength", "        Strength", "");
+		ffmpeg::tools::print_av_option_bool(context, "temporal_aq", "      Temporal AQ");
 	}
 
-		PLOG_INFO("[%s]   Buffer Size: %" PRId64, codec->name, cfg_rc_bufsize);
-		if (have_bitrate)
-			PLOG_INFO("[%s]   Bitrate Target: %" PRId64, codec->name, cfg_rc_bitrate);
-		if (have_bitrate_max)
-			PLOG_INFO("[%s]   Bitrate Maximum: %" PRId64, codec->name, cfg_rc_max_bitrate);
-		if (have_quality && cfg_rc_quality) {
-			PLOG_INFO("[%s]   Quality Limits:", codec->name);
-			PLOG_INFO("[%s]     Minimum: %" PRId64, codec->name, cfg_rc_quality_min);
-			PLOG_INFO("[%s]     Maximum: %" PRId64, codec->name, cfg_rc_quality_max);
-			PLOG_INFO("[%s]     Target: %f", codec->name, cfg_rc_quality_tgt);
-		}
-		if (have_qp)
-			PLOG_INFO("[%s]   QP Values: %" PRId64 "/%" PRId64 "/%" PRId64, codec->name, cfg_rc_qp_i,
-			          cfg_rc_qp_p, cfg_rc_qp_b);
-		if (have_qp_init)
-			PLOG_INFO("[%s]   Initial QP Values: %" PRId64 "/%" PRId64 "/%" PRId64, codec->name,
-			          cfg_rc_qp_i_init, cfg_rc_qp_p_init, cfg_rc_qp_b_init);
-	}
-
-	bool    cfg_aq_spatial  = obs_data_get_bool(settings, ST_AQ_SPATIAL);
-	int64_t cfg_aq_strength = obs_data_get_int(settings, ST_AQ_STRENGTH);
-	bool    cfg_aq_temporal = obs_data_get_bool(settings, ST_AQ_TEMPORAL);
-	if (cfg_aq_spatial)
-		PLOG_INFO("[%s]   Spatial AQ Enabled: Strength %" PRId64, codec->name, cfg_aq_strength);
-	if (cfg_aq_temporal)
-		PLOG_INFO("[%s]   Temporal AQ Enabled", codec->name);
-
-	int64_t    cfg_bf          = obs_data_get_int(settings, ST_OTHER_BFRAMES);
-	b_ref_mode cfg_bf_mode     = static_cast<b_ref_mode>(obs_data_get_int(settings, ST_OTHER_BFRAME_REFERENCEMODE));
-	bool       cfg_zerolatency = obs_data_get_bool(settings, ST_OTHER_ZEROLATENCY);
-	bool       cfg_weightp     = obs_data_get_bool(settings, ST_OTHER_WEIGHTED_PREDICTION);
-	bool       cfg_nonrefp     = obs_data_get_bool(settings, ST_OTHER_NONREFERENCE_PFRAMES);
-
-	PLOG_INFO("[%s]   B-Frames: %" PRId64, codec->name, cfg_bf);
-	auto found3 = b_ref_mode_to_opt.find(cfg_bf_mode);
-	if (found3 != b_ref_mode_to_opt.end())
-		PLOG_INFO("[%s]     Reference Mode: %s", codec->name, found3->second.c_str());
-	if (cfg_zerolatency)
-		PLOG_INFO("[%s]   Zero Latency Enabled", codec->name);
-	if (cfg_weightp)
-		PLOG_INFO("[%s]   Weighted Prediction Enabled", codec->name);
-	if (cfg_nonrefp)
-		PLOG_INFO("[%s]   Non-Ref P-Frames Enabled", codec->name);
+	PLOG_INFO("[%s]     Other:", codec->name);
+	ffmpeg::tools::print_av_option_bool(context, "zerolatency", "      Zero Latency");
+	ffmpeg::tools::print_av_option_bool(context, "weighted_pred", "      Weighted Prediction");
+	ffmpeg::tools::print_av_option_bool(context, "nonref_p", "      Non-reference P-Frames");
+	ffmpeg::tools::print_av_option_bool(context, "strict_gop", "      Strict GOP");
+	ffmpeg::tools::print_av_option_bool(context, "aud", "      Access Unit Delimiters");
+	ffmpeg::tools::print_av_option_bool(context, "bluray-compat", "      Bluray Compatibility");
+	if (strcmp(codec->name, "h264_nvenc") == 0)
+		ffmpeg::tools::print_av_option_bool(context, "a53cc", "      A53 Closed Captions");
+	ffmpeg::tools::print_av_option_int(context, "dpb_size", "      DPB Size", "");
 }

source/ui/nvenc_shared.hpp

@@ -32,6 +32,8 @@ extern "C" {
 }
 
 namespace obsffmpeg {
+	class encoder;
+
 	namespace nvenc {
 		enum class preset : int64_t {
 			DEFAULT,
@@ -46,6 +48,8 @@ namespace obsffmpeg {
 			LOW_LATENCY_HIGH_QUALITY,
 			LOSSLESS,
 			LOSSLESS_HIGH_PERFORMANCE,
+			// Append things before this.
+			INVALID = -1,
 		};
 
 		enum class ratecontrolmode : int64_t {
@@ -55,12 +59,16 @@ namespace obsffmpeg {
 			CBR,
 			CBR_HQ,
 			CBR_LD_HQ,
+			// Append things before this.
+			INVALID = -1,
 		};
 
 		enum class b_ref_mode : int64_t {
 			DISABLED,
 			EACH,
 			MIDDLE,
+			// Append things before this.
+			INVALID = -1,
 		};
 
 		extern std::map<preset, std::string> presets;
@@ -75,6 +83,8 @@ namespace obsffmpeg {
 
 		extern std::map<b_ref_mode, std::string> b_ref_mode_to_opt;
 
+		void override_update(obsffmpeg::encoder* instance, obs_data_t* settings);
+
 		void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context);
 
 		void get_properties_pre(obs_properties_t* props, const AVCodec* codec);

source/ui/prores_aw_handler.cpp

@@ -21,6 +21,7 @@
 
 #include "prores_aw_handler.hpp"
 #include "codecs/prores.hpp"
+#include "ffmpeg/tools.hpp"
 #include "plugin.hpp"
 #include "utility.hpp"
 
@@ -36,7 +37,7 @@ INITIALIZER(prores_aw_handler_init)
 };
 
 void obsffmpeg::ui::prores_aw_handler::override_colorformat(AVPixelFormat& target_format, obs_data_t* settings,
-                                                            const AVCodec* codec, AVCodecContext* context)
+                                                            const AVCodec* codec, AVCodecContext*)
 {
 	std::string profile = "";
 
@@ -60,40 +61,40 @@ void obsffmpeg::ui::prores_aw_handler::override_colorformat(AVPixelFormat& targe
 	}
 }
 
-void obsffmpeg::ui::prores_aw_handler::get_defaults(obs_data_t* settings, const AVCodec*, AVCodecContext*)
+void obsffmpeg::ui::prores_aw_handler::get_defaults(obs_data_t* settings, const AVCodec*, AVCodecContext*, bool)
 {
 	obs_data_set_default_int(settings, P_PRORES_PROFILE, 0);
 }
 
+inline const char* profile_to_name(const AVProfile* ptr)
+{
+	switch (ptr->profile) {
+	case 0:
+		return TRANSLATE(P_PRORES_PROFILE_APCO);
+	case 1:
+		return TRANSLATE(P_PRORES_PROFILE_APCS);
+	case 2:
+		return TRANSLATE(P_PRORES_PROFILE_APCN);
+	case 3:
+		return TRANSLATE(P_PRORES_PROFILE_APCH);
+	case 4:
+		return TRANSLATE(P_PRORES_PROFILE_AP4H);
+	case 5:
+		return TRANSLATE(P_PRORES_PROFILE_AP4X);
+	default:
+		return ptr->name;
+	}
+}
+
 void obsffmpeg::ui::prores_aw_handler::get_properties(obs_properties_t* props, const AVCodec* codec,
-                                                      AVCodecContext* context)
+                                                      AVCodecContext* context, bool)
 {
 	if (!context) {
 		auto p = obs_properties_add_list(props, P_PRORES_PROFILE, TRANSLATE(P_PRORES_PROFILE),
 		                                 OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
 		obs_property_set_long_description(p, TRANSLATE(DESC(P_PRORES_PROFILE)));
 		for (auto ptr = codec->profiles; ptr->profile != FF_PROFILE_UNKNOWN; ptr++) {
-			if (strcmp("apco", ptr->name) == 0) {
-				obs_property_list_add_int(p, TRANSLATE(P_PRORES_PROFILE_APCO),
-				                          static_cast<int64_t>(ptr->profile));
-			} else if (strcmp("apcs", ptr->name) == 0) {
-				obs_property_list_add_int(p, TRANSLATE(P_PRORES_PROFILE_APCS),
-				                          static_cast<int64_t>(ptr->profile));
-			} else if (strcmp("apcn", ptr->name) == 0) {
-				obs_property_list_add_int(p, TRANSLATE(P_PRORES_PROFILE_APCN),
-				                          static_cast<int64_t>(ptr->profile));
-			} else if (strcmp("apch", ptr->name) == 0) {
-				obs_property_list_add_int(p, TRANSLATE(P_PRORES_PROFILE_APCH),
-				                          static_cast<int64_t>(ptr->profile));
-			} else if (strcmp("ap4h", ptr->name) == 0) {
-				obs_property_list_add_int(p, TRANSLATE(P_PRORES_PROFILE_AP4H),
-				                          static_cast<int64_t>(ptr->profile));
-			} else if (strcmp("ap4x", ptr->name) == 0) {
-				obs_property_list_add_int(p, TRANSLATE(P_PRORES_PROFILE_AP4X),
-				                          static_cast<int64_t>(ptr->profile));
-			} else {
-				obs_property_list_add_int(p, ptr->name, ptr->profile);
-			}
+			obs_property_list_add_int(p, profile_to_name(ptr), static_cast<int64_t>(ptr->profile));
 		}
 	} else {
 		obs_property_set_enabled(obs_properties_get(props, P_PRORES_PROFILE), false);
@@ -107,13 +108,19 @@ void obsffmpeg::ui::prores_aw_handler::update(obs_data_t* settings, const AVCode
 
 void obsffmpeg::ui::prores_aw_handler::log_options(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context)
 {
-	for (auto ptr = codec->profiles; ptr->profile != FF_PROFILE_UNKNOWN; ptr++) {
-		if (ptr->profile == static_cast<int>(obs_data_get_int(settings, P_PRORES_PROFILE)))
-			PLOG_INFO("[%s]   Profile: %s", codec->name, ptr->name);
+	PLOG_INFO("[%s]   Apple ProRes:", codec->name);
+	ffmpeg::tools::print_av_option_string(context, "profile", "    Profile", [&codec](int64_t v) {
+		int val = static_cast<int>(v);
+		for (auto ptr = codec->profiles; (ptr->profile != FF_PROFILE_UNKNOWN) && (ptr != nullptr); ptr++) {
+			if (ptr->profile == val) {
+				return std::string(profile_to_name(ptr));
 			}
+		}
+		return std::string("<Unknown>");
+	});
 }
 
-void obsffmpeg::ui::prores_aw_handler::process_avpacket(AVPacket& packet, const AVCodec* codec, AVCodecContext* context)
+void obsffmpeg::ui::prores_aw_handler::process_avpacket(AVPacket& packet, const AVCodec*, AVCodecContext*)
 {
 	//FFmpeg Bug:
 	// When ProRes content is stored in Matroska, FFmpeg strips the size

source/ui/prores_aw_handler.hpp

@@ -37,11 +37,11 @@ namespace obsffmpeg {
 			virtual void override_colorformat(AVPixelFormat& target_format, obs_data_t* settings,
 			                                  const AVCodec* codec, AVCodecContext* context) override;
 
-			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec,
-			                          AVCodecContext* context) override;
+			virtual void get_defaults(obs_data_t* settings, const AVCodec* codec, AVCodecContext* context,
+			                          bool hw_encode) override;
 
 			virtual void get_properties(obs_properties_t* props, const AVCodec* codec,
-			                            AVCodecContext* context) override;
+			                            AVCodecContext* context, bool hw_encode) override;
 
 			virtual void update(obs_data_t* settings, const AVCodec* codec,
 			                    AVCodecContext* context) override;
@@ -49,7 +49,8 @@ namespace obsffmpeg {
 			virtual void log_options(obs_data_t* settings, const AVCodec* codec,
 			                         AVCodecContext* context) override;
 
-			virtual void process_avpacket(AVPacket& packet, const AVCodec* codec, AVCodecContext* context) override;
+			virtual void process_avpacket(AVPacket& packet, const AVCodec* codec,
+			                              AVCodecContext* context) override;
 		};
 	} // namespace ui
 } // namespace obsffmpeg

source/utility.cpp

@@ -18,3 +18,16 @@
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
+
+#include "utility.hpp"
+#include "strings.hpp"
+#include "plugin.hpp"
+
+obs_property_t* obsffmpeg::obs_properties_add_tristate(obs_properties_t* props, const char* name, const char* desc)
+{
+	obs_property_t* p = obs_properties_add_list(props, name, desc, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_list_add_int(p, TRANSLATE(S_STATE_DEFAULT), -1);
+	obs_property_list_add_int(p, TRANSLATE(S_STATE_DISABLED), 0);
+	obs_property_list_add_int(p, TRANSLATE(S_STATE_ENABLED), 1);
+	return p;
+}

source/utility.hpp

@@ -87,4 +87,29 @@ namespace obsffmpeg {
 	{
 		return obs_get_version() < MAKE_SEMANTIC_VERSION(24, 0, 0);
 	}
+
+	struct obs_graphics {
+		obs_graphics()
+		{
+			obs_enter_graphics();
+		}
+		~obs_graphics()
+		{
+			obs_leave_graphics();
+		}
+	};
+
+	obs_property_t* obs_properties_add_tristate(obs_properties_t* props, const char* name, const char* desc);
+
+	inline bool is_tristate_enabled(int64_t tristate) {
+		return tristate == 1;
+	}
+
+	inline bool is_tristate_disabled(int64_t tristate) {
+		return tristate == 0;
+	}
+
+	inline bool is_tristate_default(int64_t tristate) {
+		return tristate == -1;
+	}
 } // namespace obsffmpeg