Request 3146 (accepted)

This request supersedes: request 3145 (Show diff)

Overview

Request 3146 (accepted)

- Update to version 0.16.6:
* UI: Add --verbose and --unfiltered_log command line options
* libobs: Duplicate filters of a scene when it is is duplicated
* obs-ffmpeg: Fix assumption about plane height with i444
* libobs: Refactor check for Windows bitness/arch
* libobs: Add Windows bitness/arch to crash handler
* enc-amf: Update to version 1.4.1.5
* UI: Add preview scaling options
* rtmp-services: Change YouTube keyint from 4 to 2
* libobs: Ensure async source sizes are always reset
* UI: Fix crash when switching encoders in advanced mode
* UI: Fix scrolling while preview is locked
* libobs: Ensure AVC priority is always highest for keyframes
* obs-outputs: Use correct variable for drop priority
* enc-amf: Update to commit which prevents crash on startup
* enc-amf: Update to temporary fix branch
* win-capture: Do not load 64bit hook offsets on 32bit systems
* win-capture: Defer hook offset loading to separate thread
* text-freetype2: Defer loading of plugin until source created
* obs-qsv11: Manually mark priority bits for QSV frames
* Revert "libobs: Ensure AVC priority is always highest for keyframes"
* libobs: Update to 0.16.6
* Update translations from CrowdIn
* UI: tray icons are redrawn for better visibility and contrast
* UI: Update settings and fix presets for simple AMD encoder
* enc-amf: Update to 1.4.2.2
* enc-amf: Update to 1.4.2.3
* cmake: Add module to find RSSDK
* cmake: Add macro to compile .tlb files via midl
* win-ivcam: Add Intel RealSense plugin
* UI: Update installer script to latest version
* libobs-opengl: Add warning when used on windows
* Update translations from Crowdin
* enc-amf: Avoid using C++17 for VS2013 compatibility

Created by boombatower about 8 years ago
In state accepted
Package maintainers: boombatower and frispete
Supersedes 3145

Submit obs-studio

Submit package home:boombatow...es:Multimedia / obs-studio to package Multimedia / obs-studio

obs-studio.changes Changed

@@ -1,4 +1,42 @@
 -------------------------------------------------------------------
+Mon Nov 21 18:55:11 UTC 2016 - jimmy@boombatower.com
+
+- Update to version 0.16.6:
+  * UI: Add --verbose and --unfiltered_log command line options
+  * libobs: Duplicate filters of a scene when it is is duplicated
+  * obs-ffmpeg: Fix assumption about plane height with i444
+  * libobs: Refactor check for Windows bitness/arch
+  * libobs: Add Windows bitness/arch to crash handler
+  * enc-amf: Update to version 1.4.1.5
+  * UI: Add preview scaling options
+  * rtmp-services: Change YouTube keyint from 4 to 2
+  * libobs: Ensure async source sizes are always reset
+  * UI: Fix crash when switching encoders in advanced mode
+  * UI: Fix scrolling while preview is locked
+  * libobs: Ensure AVC priority is always highest for keyframes
+  * obs-outputs: Use correct variable for drop priority
+  * enc-amf: Update to commit which prevents crash on startup
+  * enc-amf: Update to temporary fix branch
+  * win-capture: Do not load 64bit hook offsets on 32bit systems
+  * win-capture: Defer hook offset loading to separate thread
+  * text-freetype2: Defer loading of plugin until source created
+  * obs-qsv11: Manually mark priority bits for QSV frames
+  * Revert "libobs: Ensure AVC priority is always highest for keyframes"
+  * libobs: Update to 0.16.6
+  * Update translations from CrowdIn
+  * UI: tray icons are redrawn for better visibility and contrast
+  * UI: Update settings and fix presets for simple AMD encoder
+  * enc-amf: Update to 1.4.2.2
+  * enc-amf: Update to 1.4.2.3
+  * cmake: Add module to find RSSDK
+  * cmake: Add macro to compile .tlb files via midl
+  * win-ivcam: Add Intel RealSense plugin
+  * UI: Update installer script to latest version
+  * libobs-opengl: Add warning when used on windows
+  * Update translations from Crowdin
+  * enc-amf: Avoid using C++17 for VS2013 compatibility
+
+-------------------------------------------------------------------
 Tue Nov 08 19:39:07 UTC 2016 - jimmy@boombatower.com
 
 - Update to version 0.16.5:

obs-studio.spec Changed

_service Changed

_servicedata Changed

obs-studio-0.16.5.tar.xz/plugins/enc-amf/#Resources/HiddenParameters.md Deleted

@@ -1,67 +0,0 @@
-For an unknown reason, there are hidden parameters in the Runtime that can be set.
-
-## AVC Properties
-### Static
-* FrameSize
-* FrameRate
-* ExtraData (Read-Only)
-* Usage
-* Profile Two new profiles are in the runtime, Constrained Base and Constrained High.
-* Profile Level
-* MaxOfLTRFrames
-* ScanType
-* QualityPreset
-
-### Dynamic
-* RateControlMethod
-* TargetBitrate
-* PeakBitrate
-* RateControlSkipFrameEnable
-* MinQP
-* MaxQP
-* QPI
-* QPP
-* QPB
-* VBVBufferSize
-* VBVBufferFullness
-* EnforceHRD
-* MaxAUSize
-* FillerDataEnable
-* BPicturesDeltaQP
-* ReferenceBPicturesDeltaQP
-* HeaderInsertionSpacing
-* IDRPeriod
-* DeBlockingFilter
-* IntraRefreshMBsNumberPerSlot
-* SlicesPerFrame
-* BPicturesPattern
-* BReferenceEnable
-* HalfPixel
-* QuarterPixel
-
-### Unknown / New
-
-* **QualityEnhancementMode** So far always 0.
-* **MaxNumRefFrames** Shouldn't this be a Capability instead? Could perhaps be used to control B-Pictures more.
-* **MaxMBPerSec** Unknown value.
-* **InstanceID**
-* **EnableVBAQ** Unknown meaning.
-* **RateControlPreanalysisEnable** Is this Two-Pass encoding?
-* **GOPSize** Technically ignored, but still there in code.
-* **AspectRatio**
-* **NominalRange**
-* **IntraRefreshNumOfStripes** New, was not here before.
-* **SliceMode** New, was not here before.
-* **MaxSliceSize** New, was not here before.
-* **LowLatencyInternal**
-* **CommonLowLatencyInternal**
-* **SliceControlMode**
-* **SliceControlSize**
-* **CABACEnable** Not yet publicly available, but 16.10.3 always uses it anyway.
-* **UniqueInstance**
-* **EncoderMaxInstances**
-* **MultiInstanceMode**
-* **MultiInstanceCurrentQueue**
-* **WaitForTask**
-
-

obs-studio-0.16.5.tar.xz/plugins/enc-amf/#Resources/Installer.iss Deleted

@@ -1,114 +0,0 @@
-; Script generated by the Inno Setup Script Wizard.
-; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
-
-#define MyAppName "AMD AMF Plugin for OBS Studio"
-#define MyAppVersion "1.4.1.0"
-#define MyAppPublisher "Xaymars Technology Workshop"
-#define MyAppURL "http://www.xaymar.com/portfolio/plugin-amd-vce-plugin-for-obs-studio/"
-
-[Setup]
-; NOTE: The value of AppId uniquely identifies this application.
-; Do not use the same AppId value in installers for other applications.
-; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
-AppId={{FD6676CE-0580-4B34-9DB4-4879A0BEB31D}
-AppName={#MyAppName}
-AppVersion={#MyAppVersion}
-;AppVerName={#MyAppName} {#MyAppVersion}
-AppPublisher={#MyAppPublisher}
-AppPublisherURL={#MyAppURL}
-AppSupportURL={#MyAppURL}
-AppUpdatesURL={#MyAppURL}
-DefaultDirName={code:GetDirName}
-DefaultGroupName={#MyAppName}
-AllowNoIcons=yes
-LicenseFile=..\LICENSE
-OutputDir=.\Output
-OutputBaseFilename=OBS-AMD-AMF-Plugin-Installer
-Compression=lzma
-SolidCompression=yes
-VersionInfoVersion={#MyAppVersion}
-VersionInfoCompany={#MyAppPublisher}
-VersionInfoDescription={#MyAppName} Setup
-
-[Languages]
-Name: "english"; MessagesFile: "compiler:Default.isl"
-
-[Files]
-Source: "Package\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
-; NOTE: Don't use "Flags: ignoreversion" on any shared system files
-
-[Icons]
-Name: "{group}\{cm:ProgramOnTheWeb,{#MyAppName}}"; Filename: "{#MyAppURL}"
-Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
-
-[Code]
-function GetDirName(Value: string): string;
-var
- InstallPath: string;
-begin
- // initialize default path, which will be returned when the following registry
- // key queries fail due to missing keys or for some different reason
- Result := '{pf}\obs-studio';
- // query the first registry value; if this succeeds, return the obtained value
- if RegQueryStringValue(HKLM32, 'SOFTWARE\OBS Studio', '', InstallPath) then
- Result := InstallPath
-end;
-
-/////////////////////////////////////////////////////////////////////
-function GetUninstallString(): String;
-var
- sUnInstPath: String;
- sUnInstallString: String;
-begin
- sUnInstPath := ExpandConstant('Software\Microsoft\Windows\CurrentVersion\Uninstall\{#emit SetupSetting("AppId")}_is1');
- sUnInstallString := '';
- if not RegQueryStringValue(HKLM, sUnInstPath, 'UninstallString', sUnInstallString) then
- RegQueryStringValue(HKCU, sUnInstPath, 'UninstallString', sUnInstallString);
- Result := sUnInstallString;
-end;
-
-
-/////////////////////////////////////////////////////////////////////
-function IsUpgrade(): Boolean;
-begin
- Result := (GetUninstallString() <> '');
-end;
-
-
-/////////////////////////////////////////////////////////////////////
-function UnInstallOldVersion(): Integer;
-var
- sUnInstallString: String;
- iResultCode: Integer;
-begin
-// Return Values:
-// 1 - uninstall string is empty
-// 2 - error executing the UnInstallString
-// 3 - successfully executed the UnInstallString
-
- // default return value
- Result := 0;
-
- // get the uninstall string of the old app
- sUnInstallString := GetUninstallString();
- if sUnInstallString <> '' then begin
- sUnInstallString := RemoveQuotes(sUnInstallString);
- if Exec(sUnInstallString, '/SILENT /NORESTART /SUPPRESSMSGBOXES','', SW_HIDE, ewWaitUntilTerminated, iResultCode) then
- Result := 3
- else
- Result := 2;
- end else
- Result := 1;
-end;
-
-/////////////////////////////////////////////////////////////////////
-procedure CurStepChanged(CurStep: TSetupStep);
-begin
- if (CurStep=ssInstall) then
- begin
- if (IsUpgrade()) then
- begin
- UnInstallOldVersion();
- end;
- end;
-end;
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/#Resources/PatchNotes.txt Deleted

@@ -1,20 +0,0 @@
-# The Oversight Fix
-
-Sometimes your changes seem fine and then users happen. Have you ever had users happen? They break things in ways that you didn't think was possible before! It's insane!
-
-This update aims to fix some of the reported issues in addition to making the user interface even simpler to use.
-
-## Notes
-
-Due to the nature of changes in this update, your previous settings may end up lost or incorrect. Make sure to revalidate them before attempting to record or stream.
-
-## Changelog
-
-* Fixed: Crash with default settings being used.
-* Fixed: Properties should now show the correct tooltip when hovered over.
-* Fixed: Frame Rate should now be applied properly again.
-* Fixed: Compatibility issues with Windows 7 and older.
-* Changed: Default value for LTR Frames is now 0 for better compatibility.
-* Changed: Profile is now a Basic property.
-* Changed: Profile Level is now an Expert property to avoid user errors.
-* Changed: Min/Max QP is now considered an Advanced property to avoid user errors.
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/#Resources/package.bat Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/OBS AMF.sln Deleted

@@ -1,28 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "enc-amf", "enc-amf\enc-amf.vcxproj", "{49237B5E-655D-46B5-AA1F-780B387327A1}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Debug|x64.ActiveCfg = Debug|x64
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Debug|x64.Build.0 = Debug|x64
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Debug|x86.ActiveCfg = Debug|Win32
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Debug|x86.Build.0 = Debug|Win32
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Release|x64.ActiveCfg = Release|x64
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Release|x64.Build.0 = Release|x64
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Release|x86.ActiveCfg = Release|Win32
-		{49237B5E-655D-46B5-AA1F-780B387327A1}.Release|x86.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/amd-amf-vce-capabilities.h Deleted

@@ -1,92 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include <stdint.h>
-#include <inttypes.h>
-#include <vector>
-
-// Plugin
-#include "plugin.h"
-#include "amd-amf.h"
-#include "amd-amf-vce.h"
-
-// AMF
-#include "components\ComponentCaps.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-
-namespace Plugin {
-	namespace AMD {
-		class VCECapabilities {
-			//////////////////////////////////////////////////////////////////////////
-			// Singleton
-			//////////////////////////////////////////////////////////////////////////
-			public:
-			static std::shared_ptr<Plugin::AMD::VCECapabilities> GetInstance();
-			static void ReportCapabilities();
-
-			//////////////////////////////////////////////////////////////////////////
-			// Class
-			//////////////////////////////////////////////////////////////////////////
-			public:
-			// Structure
-			struct EncoderCaps {
-				amf::AMF_ACCELERATION_TYPE acceleration_type;
-				uint32_t maxBitrate;
-				uint32_t maxNumOfStreams;
-				uint32_t maxProfile;
-				uint32_t maxProfileLevel;
-				bool supportsBFrames;
-				uint32_t minReferenceFrames;
-				uint32_t maxReferenceFrames;
-				uint32_t maxTemporalLayers;
-				bool supportsFixedSliceMode;
-				uint32_t maxNumOfHwInstances;
-
-				struct IOCaps {
-					int32_t minWidth, maxWidth;
-					int32_t minHeight, maxHeight;
-					bool isInterlacedSupported;
-					uint32_t verticalAlignment;
-
-					std::vector<std::pair<amf::AMF_SURFACE_FORMAT, bool>> formats;
-					std::vector<std::pair<amf::AMF_MEMORY_TYPE, bool>> memoryTypes;
-				} input, output;
-			} m_AVCCaps, m_SVCCaps, m_HEVCCaps;
-			
-			VCECapabilities();
-			~VCECapabilities();
-
-			bool RefreshCapabilities();
-			EncoderCaps* GetEncoderCaps(VCEEncoderType);
-			EncoderCaps::IOCaps* GetIOCaps(VCEEncoderType, bool output);
-		};
-	}
-}
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/amd-amf-vce.h Deleted

@@ -1,487 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include <condition_variable>
-#include <algorithm>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <vector>
-#include <chrono>
-
-// Plugin
-#include "plugin.h"
-#include "amd-amf.h"
-#include "api-base.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-
-namespace Plugin {
-	namespace AMD {
-		// Internal Properties
-		enum VCEEncoderType {
-			VCEEncoderType_AVC,		// Advanced Video Coding
-			VCEEncoderType_SVC,		// Scalable Video Coding
-			VCEEncoderType_HEVC,	// High-Efficiency Video Coding (Discovered in amfrt64.dll)
-		};
-		enum VCEMemoryType {
-			VCEMemoryType_Host,			// Host-Managed Memory
-			VCEMemoryType_DirectX9,		// DirectX9
-			VCEMemoryType_DirectX11,	// DirectX11
-			VCEMemoryType_OpenGL,		// OpenGL
-
-			VCEMemoryType_Auto = -1,	// Auto-Detect
-		};
-		enum VCESurfaceFormat {
-			// 4:2:0 Formats
-			VCESurfaceFormat_NV12,	// NV12
-			VCESurfaceFormat_I420,	// YUV 4:2:0
-			// 4:2:2 Formats
-			VCESurfaceFormat_YUY2,
-			// Uncompressed
-			VCESurfaceFormat_BGRA,	// ARGB
-			VCESurfaceFormat_RGBA,	// RGBA
-			// Other
-			VCESurfaceFormat_GRAY,
-		};
-
-		// Static Properties
-		enum VCEUsage {
-			VCEUsage_Transcoding,
-			VCEUsage_UltraLowLatency,
-			VCEUsage_LowLatency,
-			VCEUsage_Webcam,			// For SVC
-		};
-		enum VCEProfile {
-			VCEProfile_Baseline = 66,
-			VCEProfile_Main = 77,
-			VCEProfile_High = 100,
-
-			VCEProfile_Unknown = -1,
-		};
-		enum VCEProfileLevel {
-			VCEProfileLevel_Automatic = 0,
-			VCEProfileLevel_10 = 10,
-			VCEProfileLevel_11,
-			VCEProfileLevel_12,
-			VCEProfileLevel_13,
-			VCEProfileLevel_20 = 20,
-			VCEProfileLevel_21,
-			VCEProfileLevel_22,
-			VCEProfileLevel_30 = 30,
-			VCEProfileLevel_31,
-			VCEProfileLevel_32,
-			VCEProfileLevel_40 = 40,
-			VCEProfileLevel_41,
-			VCEProfileLevel_42,
-			VCEProfileLevel_50 = 50,
-			VCEProfileLevel_51,
-			VCEProfileLevel_52,
-			VCEProfileLevel_Unknown = -1,
-		};
-		enum VCERateControlMethod {
-			VCERateControlMethod_ConstantQP,
-			VCERateControlMethod_ConstantBitrate,
-			VCERateControlMethod_VariableBitrate_PeakConstrained,
-			VCERateControlMethod_VariableBitrate_LatencyConstrained,
-		};
-		enum VCEBPicturePattern {
-			VCEBPicturePattern_None,
-			VCEBPicturePattern_One,
-			VCEBPicturePattern_Two,
-			VCEBPicturePattern_Three,
-		};
-		enum VCEScanType {
-			VCEScanType_Progressive,
-			VCEScanType_Interlaced,
-		};
-		enum VCEQualityPreset {
-			VCEQualityPreset_Speed,
-			VCEQualityPreset_Balanced,
-			VCEQualityPreset_Quality,
-		};
-
-		class VCEEncoder {
-			//////////////////////////////////////////////////////////////////////////
-			#pragma region Functions
-			//////////////////////////////////////////////////////////////////////////
-			private:
-			static void InputThreadMain(Plugin::AMD::VCEEncoder* p_this);
-			static void OutputThreadMain(Plugin::AMD::VCEEncoder* p_this);
-
-			#pragma endregion Functions
-			//////////////////////////////////////////////////////////////////////////
-
-			//////////////////////////////////////////////////////////////////////////
-			#pragma region Initializer & Finalizer
-			//////////////////////////////////////////////////////////////////////////
-			public:
-			VCEEncoder(VCEEncoderType p_Type,
-				VCESurfaceFormat p_SurfaceFormat = VCESurfaceFormat_NV12,
-				VCEMemoryType p_MemoryType = VCEMemoryType_Auto,
-				bool p_UseOpenCL = false,
-				std::string p_DeviceUniqueId = "");
-			~VCEEncoder();
-			#pragma endregion Initializer & Finalizer
-
-			//////////////////////////////////////////////////////////////////////////
-			#pragma region Methods
-			//////////////////////////////////////////////////////////////////////////
-			public:
-			void Start();
-			void Restart();
-			void Stop();
-			bool SendInput(struct encoder_frame* frame);
-			void GetOutput(struct encoder_packet* packet, bool* received_packet);
-			bool GetExtraData(uint8_t**& data, size_t*& size);
-			void GetVideoInfo(struct video_scale_info*& vsi);
-
-			// Threading
-			private:
-			void InputThreadLogic();
-			void OutputThreadLogic();
-
-			// Utility
-			inline amf::AMFSurfacePtr CreateSurfaceFromFrame(struct encoder_frame*& frame);
-
-			public:
-			void LogProperties();
-			
-			/************************************************************************/
-			/* Static Properties */
-			/************************************************************************/
-
-			/*	Usage Type
-			*	Sets up the entire encoder to a specific set of properties.
-			*	Must be called first if you want to override properties. */
-			void SetUsage(VCEUsage usage);
-			VCEUsage GetUsage();
-			
-			/*	H.264 Profile */
-			void SetProfile(VCEProfile profile);
-			VCEProfile GetProfile();
-
-			/*	H.264 Profile Level */
-			void SetProfileLevel(VCEProfileLevel level);
-			VCEProfileLevel GetProfileLevel();
-
-			/*	The number of long-term references controlled by the user.
-			 *
-			 *	Remarks:
-			 * - When == 0, the encoder may or may not use LTRs during encoding.
-			 *	- When >0, the user has control over all LTR.
-			 *	- With user control of LTR, B-pictures and Intra-refresh features are not supported.
-			 *	- The actual maximum number of LTRs allowed depends on H.264 Annex A Table A-1 Level limits, which defines dependencies between the H.264 Level number, encoding resolution, and DPB size. The DPB size limit impacts the maximum number of LTR allowed.
-			 **/
-			void SetMaximumLongTermReferenceFrames(uint32_t maximumLTRFrames);	// Long-Term Reference Frames. If 0, Encoder decides, if non-0 B-Pictures and Intra-Refresh are not supported.
-			uint32_t GetMaximumLongTermReferenceFrames();
-
-			/************************************************************************/
-			/* Resolution Properties */
-			/************************************************************************/
-
-			/*	Output Resolution */
-			void SetFrameSize(uint32_t width, uint32_t height);
-			std::pair<uint32_t, uint32_t> GetFrameSize();
-
-			/*	Sets the Frame Rate numerator and denumerator */
-			void SetFrameRate(uint32_t num, uint32_t den);
-			std::pair<uint32_t, uint32_t> GetFrameRate();
-
-			/************************************************************************/
-			/* Rate Control Properties */
-			/************************************************************************/
-			
-			/*	Selects the rate control method:
-			*	- CQP - Constrained QP,
-			*	- CBR - Constant Bitrate,
-			*	- VBR - Peak Constrained VBR,
-			*	- VBR_LAT - Latency Constrained VBR
-			*
-			*	Remarks:
-			*	- When SVC encoding is enabled, all Rate-control parameters (with some restrictions) can be configured differently for a particular SVC-layer. An SVC-layer is denoted by an index pair [SVC-Temporal Layer index][SVC-Quality Layer index]. E.g. The bitrate may be configured differently for SVC-layers [0][0] and [1][0].
-			*	- We restrict all SVC layers to have the same Rate Control method. Some RC parameters are not enabled with SVC encoding (e.g. all parameters related to B-pictures).
-			**/
-			void SetRateControlMethod(VCERateControlMethod method);
-			VCERateControlMethod GetRateControlMethod();
-
-			/*	Sets the target bitrate */
-			void SetTargetBitrate(uint32_t bitrate);
-			uint32_t GetTargetBitrate();
-
-			/*	Sets the peak bitrate */
-			void SetPeakBitrate(uint32_t bitrate);
-			uint32_t GetPeakBitrate();
-
-			/*	Sets the minimum QP */
-			void SetMinimumQP(uint8_t qp);
-			uint8_t GetMinimumQP();
-
-			/*	Sets the maximum QP */
-			void SetMaximumQP(uint8_t qp);
-			uint8_t GetMaximumQP();
-
-			/*	Sets the Constant QP for I-Pictures.
-			*
-			*	Remarks:
-			*	- Only available for CQP rate control method.
-			**/
-			void SetIFrameQP(uint8_t qp);
-			uint8_t GetIFrameQP();
-
-			/*	Sets the Constant QP for P-Pictures.
-			*
-			*	Remarks:
-			*	- Only available for CQP rate control method.
-			**/
-			void SetPFrameQP(uint8_t qp);
-			uint8_t GetPFrameQP();
-
-			/*	Sets the Constant QP for B-Pictures.
-			*
-			*	Remarks:
-			*	- Only available for CQP rate control method.
-			**/
-			void SetBFrameQP(uint8_t qp);
-			uint8_t GetBFrameQP();
-
-			/* Selects the delta QP of non-reference B-Pictures with respect to I pictures */
-			void SetBPictureDeltaQP(int8_t qp);
-			int8_t GetBPictureDeltaQP();
-
-			/* Selects delta QP of reference B-Pictures with respect to I pictures */
-			void SetReferenceBPictureDeltaQP(int8_t qp);
-			int8_t GetReferenceBPictureDeltaQP();
-
-			/*	Sets the VBV Buffer Size in bits */
-			void SetVBVBufferSize(uint32_t size);
-			void SetVBVBufferAutomatic(double_t strictness);
-			uint32_t GetVBVBufferSize();
-
-			/*	Sets the initial VBV Buffer Fullness */
-			void SetInitialVBVBufferFullness(double_t fullness);
-			double_t GetInitialVBVBufferFullness();
-
-			/*	Sets Maximum AU Size in bits */
-			void SetMaximumAccessUnitSize(uint32_t size);
-			uint32_t GetMaximumAccessUnitSize();
-
-			/*	Enables/Disables filler data */
-			void SetFillerDataEnabled(bool enabled);
-			bool IsFillerDataEnabled();
-
-			/*	Enables skip frame for rate control */
-			void SetFrameSkippingEnabled(bool enabled);
-			bool IsFrameSkippingEnabled();
-
-			/*	Enables/Disables constraints on QP variation within a picture to meet HRD requirement(s) */
-			void SetEnforceHRDRestrictionsEnabled(bool enforce);
-			bool IsEnforceHRDRestrictionsEnabled();
-
-			/************************************************************************/
-			/* Picture Control Properties */
-			/************************************************************************/
-
-			/*	Sets IDR period. IDRPeriod= 0 turns IDR off */
-			void SetIDRPeriod(uint32_t period);
-			uint32_t GetIDRPeriod();
-
-			/*	Sets the headers insertion spacing */
-			void SetHeaderInsertionSpacing(uint32_t spacing); // Similar to IDR Period, spacing (in frames) between headers.
-			uint32_t GetHeaderInsertionSpacing();
-
-			/*	Sets the number of consecutive B-pictures in a GOP. BPicturesPattern = 0 indicates that B-pictures are not used */
-			void SetBPicturePattern(VCEBPicturePattern pattern);
-			VCEBPicturePattern GetBPicturePattern();
-
-			/*	Enables or disables using B-pictures as references */
-			void SetBPictureReferenceEnabled(bool enabled);
-			bool IsBPictureReferenceEnabled();
-
-			/*	Turns on/off the Deblocking Filter */
-			void SetDeblockingFilterEnabled(bool enabled);
-			bool IsDeblockingFilterEnabled();
-
-			/*	Sets the number of slices per frame */
-			void SetSlicesPerFrame(uint32_t slices);
-			uint32_t GetSlicesPerFrame();
-
-			/*	Sets the number of intra-refresh macro-blocks per slot */
-			void SetIntraRefreshMBsNumberPerSlot(uint32_t mbs);
-			uint32_t GetIntraRefreshMBsNumberPerSlot();
-
-			/************************************************************************/
-			/* Miscellaneous Control Properties */
-			/************************************************************************/
-
-			/** Quality Preset
-			 * Static Property, changes cause a restart. */
-			void SetQualityPreset(VCEQualityPreset preset);
-			VCEQualityPreset GetQualityPreset();
-
-			/* Selects progressive or interlaced scan
-			 * Static Property, changes cause a restart. */
-			void SetScanType(VCEScanType scanType);
-			VCEScanType GetScanType();
-
-			/* Turns on/off half-pixel motion estimation */
-			void SetHalfPixelMotionEstimationEnabled(bool enabled);
-			bool IsHalfPixelMotionEstimationEnabled();
-
-			/* Turns on/off quarter-pixel motion estimation */
-			void SetQuarterPixelMotionEstimationEnabled(bool enabled);
-			bool IsQuarterPixelMotionEstimationEnabled();
-
-			/** Enable CABAC entropy coding instead of CALV.
-			 * CABAC is a more efficient way of compressing data and on
-			 * average 5% extra data to be stored in the same bitrate.
-			 * Static Property, changes cause a restart. */
-			void SetCABACEnabled(bool enabled);
-			bool IsCABACEnabled();
-
-			/************************************************************************/
-			/* Hidden Properties */
-			/************************************************************************/
-			void SetGOPSize(uint32_t gopSize);
-			uint32_t GetGOPSize();
-			
-			void SetNominalRange(bool enabled);
-			bool GetNominalRange();
-
-			void SetWaitForTask(bool enabled);
-			bool GetWaitForTask();
-
-			void SetAspectRatio(uint32_t x, uint32_t y);
-			std::pair<uint32_t, uint32_t> GetAspectRatio();
-
-			void SetQualityEnhancementMode(uint32_t qualityEnhancementMode);
-			uint32_t GetQualityEnhancementMode();
-
-			void SetMaximumNumberOfReferenceFrames(uint32_t frameCount);
-			uint32_t GetMaximumNumberOfReferenceFrames();
-
-			void SetMaxMBPerSec(uint32_t maxMBPerSec);
-			uint32_t GetMaxMBPerSec();
-
-			void SetInstanceID(uint32_t instanceId);
-			uint32_t GetInstanceID();
-
-			void SetVBAQEnabled(bool enabled);
-			bool IsVBAQEnabled();
-
-			void SetRateControlPreanalysisEnabled(bool enabled);
-			bool IsRateControlPreanalysisEnabled();
-
-			void SetIntraRefreshNumberOfStripes(uint32_t stripes);
-			uint32_t GetIntraRefreshNumberOfStripes();
-
-			void SetSliceMode(uint32_t mode);
-			uint32_t GetSliceMode();
-
-			void SetMaximumSliceSize(uint32_t size);
-			uint32_t GetMaximumSliceSize();
-
-			// - SliceControlMode: AMF_VIDEO_ENCODER_SLICE_CTRL_MODE_MB_ROW, AMF_VIDEO_ENCODER_SLICE_CTRL_MODE_MB
-			void SetSliceControlMode(uint32_t mode);
-			uint32_t GetSliceControlMode();
-
-			void SetSliceControlSize(uint32_t size);
-			uint32_t GetSliceControlSize();
-
-			// HEVC Parameters
-			// - MinQP_I, MaxQP_I
-			// - MinQP_P, MaxQP_P
-			// - QPCBOFFSET, QPCROFFSET
-			// - GOPPerIDR
-			// - GOPSizeMin, GOPSizeMax
-			// - EnableGOPAlignment
-
-			#pragma endregion Methods
-			//////////////////////////////////////////////////////////////////////////
-
-			//////////////////////////////////////////////////////////////////////////
-			#pragma region Members
-			//////////////////////////////////////////////////////////////////////////
-			private:
-
-			// AMF Data References
-			std::shared_ptr<Plugin::AMD::AMF> m_AMF;
-			amf::AMFFactory* m_AMFFactory;
-			amf::AMFContextPtr m_AMFContext;
-			amf::AMFComponentPtr m_AMFEncoder;
-			amf::AMFComputePtr m_AMFCompute;
-
-			// API References
-			Plugin::API::BaseAPI m_APIDevice = Plugin::API::BaseAPI(Plugin::API::Device());
-
-			// Static Buffers
-			std::vector<uint8_t> m_PacketDataBuffer;
-			std::vector<uint8_t> m_ExtraDataBuffer;
-
-			// Structured Queue
-			struct {
-				std::queue<amf::AMFSurfacePtr> queue;
-
-				// Threading
-				std::thread thread;
-				std::mutex mutex;
-				std::condition_variable condvar;
-				std::mutex queuemutex;
-			} m_Input;
-			struct {
-				std::queue<amf::AMFDataPtr> queue;
-
-				// Threading
-				std::thread thread;
-				std::mutex mutex;
-				std::condition_variable condvar;
-				std::mutex queuemutex;
-			} m_Output;
-
-			// Internal Properties
-			VCEEncoderType m_EncoderType;
-			VCEMemoryType m_MemoryType;
-			bool m_UseOpenCL;
-			VCESurfaceFormat m_SurfaceFormat;
-			bool m_Flag_IsStarted,
-				m_Flag_Threading;
-			std::pair<uint32_t, uint32_t> m_FrameSize,
-				m_FrameRate;
-			double_t m_FrameRateDivisor,
-				m_FrameRateReverseDivisor;
-			size_t m_InputQueueLimit,
-				m_InputQueueLastSize;
-			uint32_t m_TimerPeriod;
-			
-			#pragma endregion Members
-			//////////////////////////////////////////////////////////////////////////
-		};
-	}
-}
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/api-base.h Deleted

@@ -1,60 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "plugin.h"
-#include <vector>
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-namespace Plugin {
-	namespace API {
-		struct Device {
-			std::string Name;
-			std::string UniqueId;
-
-			Device();
-			Device(std::string Name, std::string UniqueId);
-			~Device();
-		};
-
-		class BaseAPI {
-			public:
-			static std::vector<Plugin::API::Device> EnumerateDevices();
-
-			BaseAPI(Device device);
-			virtual ~BaseAPI();
-
-			virtual void* GetContext();
-			Plugin::API::Device GetDevice();
-			
-			private:
-			Plugin::API::Device myDevice;
-		};
-	}
-}
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/api-d3d11.h Deleted

@@ -1,55 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-#ifdef _WIN32
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "api-base.h"
-
-#include <d3d11.h>
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-namespace Plugin {
-	namespace API {
-		class Direct3D11 : public Plugin::API::BaseAPI {
-			public:
-			static std::vector<Plugin::API::Device> EnumerateDevices();
-			static Plugin::API::Device GetDeviceForUniqueId(std::string uniqueId);
-
-			Direct3D11(Device device);
-			~Direct3D11();
-
-			void* GetContext();
-
-			private:
-			ID3D11Device* pDevice;
-			ID3D11DeviceContext* pDeviceContext;
-		};
-	}
-}
-#endif

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/api-d3d9.h Deleted

@@ -1,57 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-#ifdef _WIN32
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "api-base.h"
-
-#define D3D_DEBUG_INFO
-#include <d3d9.h>
-#pragma comment(lib, "d3d9.lib")
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-namespace Plugin {
-	namespace API {
-		class Direct3D9 : public Plugin::API::BaseAPI {
-			public:
-			static std::vector<Plugin::API::Device> EnumerateDevices();
-			static Plugin::API::Device GetDeviceForUniqueId(std::string uniqueId);
-
-			Direct3D9(Device device);
-			~Direct3D9();
-
-			void* GetContext();
-
-			private:
-			IDirect3D9* pDirect3D;
-			IDirect3DDevice9* pDirect3DDevice;
-		};
-	}
-}
-#endif

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/enc-h264.h Deleted

@@ -1,81 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-// Plugin
-#include "plugin.h"
-#include "amd-amf-vce.h"
-#include "amd-amf-vce-capabilities.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-namespace Plugin {
-	namespace Interface {
-		class H264Interface {
-			public:
-			static void encoder_register();
-			static const char* get_name(void* type_data);
-			static const char* get_name_simple(void* type_data);
-			static void get_defaults(obs_data_t *settings);
-			static obs_properties_t* get_properties(void* data);
-			
-			static bool preset_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
-			static bool maximum_ltr_frames_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
-			static bool rate_control_method_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
-			static bool bpictures_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
-			static bool view_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
-			static bool unlock_properties_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
-
-			static void* create(obs_data_t* settings, obs_encoder_t* encoder);
-			static void destroy(void* data);
-			static bool update(void *data, obs_data_t *settings);
-			static bool encode(void *data, struct encoder_frame * frame, struct encoder_packet * packet, bool * received_packet);
-			static void get_video_info(void *data, struct video_scale_info *info);
-			static bool get_extra_data(void *data, uint8_t** extra_data, size_t* size);
-
-			//////////////////////////////////////////////////////////////////////////
-			// Module Code
-			//////////////////////////////////////////////////////////////////////////
-			public:
-
-			H264Interface(obs_data_t* settings, obs_encoder_t* encoder);
-			~H264Interface();
-
-			bool update(obs_data_t* settings);
-			bool encode(struct encoder_frame * frame, struct encoder_packet * packet, bool * received_packet);
-			void get_video_info(struct video_scale_info* info);
-			bool get_extra_data(uint8_t** extra_data, size_t* size);
-
-			//////////////////////////////////////////////////////////////////////////
-			// Storage
-			//////////////////////////////////////////////////////////////////////////
-			private:
-			Plugin::AMD::VCEEncoder* m_VideoEncoder;
-		};
-	}
-}
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Include/plugin.h Deleted

@@ -1,226 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include <stdint.h>
-#include <inttypes.h>
-#include <exception>
-#include <stdexcept>
-#include <thread>
-#include <memory>
-
-// Open Broadcaster Software
-#pragma warning( disable: 4201 )
-#include "libobs/obs-module.h"
-#include "libobs/obs-encoder.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Defines
-//////////////////////////////////////////////////////////////////////////
-
-#define vstr(s) dstr(s)
-#define dstr(s) #s
-
-#define PLUGIN_VERSION_MAJOR			1
-#define PLUGIN_VERSION_MINOR			4
-#define PLUGIN_VERSION_PATCH			1
-#define PLUGIN_VERSION_BUILD			0
-#define PLUGIN_VERSION_FULL				(((uint64_t)PLUGIN_VERSION_MAJOR << 48ull) | ((uint64_t)PLUGIN_VERSION_MINOR << 32ull) | ((uint64_t)PLUGIN_VERSION_PATCH) | ((uint64_t)PLUGIN_VERSION_BUILD))
-#define PLUGIN_VERSION_TEXT				vstr(PLUGIN_VERSION_MAJOR) "." vstr(PLUGIN_VERSION_MINOR) "." vstr(PLUGIN_VERSION_PATCH) "." vstr(PLUGIN_VERSION_BUILD) "-" vstr(AMF_VERSION_MAJOR) "." vstr(AMF_VERSION_MINOR) "." vstr(AMF_VERSION_RELEASE) "." vstr(AMF_VERSION_BUILD_NUM)
-
-#define AMF_LOG(level, format, ...)		blog(level, "[AMF Encoder] " format, ##__VA_ARGS__);
-#define AMF_LOG_ERROR(format, ...)		AMF_LOG(LOG_ERROR, format, ##__VA_ARGS__)
-#define AMF_LOG_WARNING(format, ...)	AMF_LOG(LOG_WARNING, format, ##__VA_ARGS__)
-#define AMF_LOG_INFO(format, ...)		AMF_LOG(LOG_INFO, format, ##__VA_ARGS__)
-#define AMF_LOG_CONFIG(format, ...)		AMF_LOG(350, format, ##__VA_ARGS__)
-#define AMF_LOG_DEBUG(format, ...)		AMF_LOG(LOG_DEBUG, format, ##__VA_ARGS__)
-
-#define TEXT_AMF(x)						("AMF." ## x)
-#define TEXT_AMF_T(x)					obs_module_text(TEXT_AMF(x))
-#define TEXT_AMF_H264(x)				(TEXT_AMF("H264." ## x))
-#define TEXT_AMF_H264_T(x)				obs_module_text(TEXT_AMF_H264(x))
-#define TEXT_AMF_H264ADVANCED(x)		(TEXT_AMF("H264Advanced." ## x))
-#define TEXT_AMF_H264ADVANCED_T(x)		obs_module_text(TEXT_AMF_H264ADVANCED(x))
-#define TEXT_AMF_H264SIMPLE(x)			(TEXT_AMF("H264Simple." ## x))
-#define TEXT_AMF_H264SIMPLE_T(x)		obs_module_text(TEXT_AMF_H264SIMPLE(x))
-#define TEXT_AMF_UTIL(x)				(TEXT_AMF("Util." ## x))
-#define TEXT_AMF_UTIL_T(x)				obs_module_text(TEXT_AMF_UTIL(x))
-
-#define ThrowExceptionWithAMFError(format, res, ...) {\
-	std::vector<char> _throwexceptionwithamferror_buf(8192);\
-	sprintf_s(_throwexceptionwithamferror_buf.data(), _throwexceptionwithamferror_buf.size(), format, ##__VA_ARGS__, Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);\
-	AMF_LOG_ERROR("%s", _throwexceptionwithamferror_buf.data()); \
-	throw std::exception(_throwexceptionwithamferror_buf.data()); \
-}
-
-//////////////////////////////////////////////////////////////////////////
-// Defines - Translation Strings
-//////////////////////////////////////////////////////////////////////////
-
-// Presets
-#define AMF_H264_PRESET							TEXT_AMF_H264("Preset")
-#define AMF_H264_PRESET_RECORDING				TEXT_AMF_H264("Preset.Recording")
-#define AMF_H264_PRESET_HIGHQUALITY				TEXT_AMF_H264("Preset.HighQuality")
-#define AMF_H264_PRESET_INDISTINGUISHABLE		TEXT_AMF_H264("Preset.Indistinguishable")
-#define AMF_H264_PRESET_LOSSLESS				TEXT_AMF_H264("Preset.Lossless")
-#define AMF_H264_PRESET_TWITCH					TEXT_AMF_H264("Preset.Twitch")
-#define AMF_H264_PRESET_YOUTUBE					TEXT_AMF_H264("Preset.YouTube")
-
-// Static Properties
-#define AMF_H264_USAGE							TEXT_AMF_H264("Usage")
-#define AMF_H264_USAGE_DESCRIPTION				TEXT_AMF_H264("Usage.Description")
-#define AMF_H264_USAGE_TRANSCODING				TEXT_AMF_H264("Usage.Transcoding")
-#define AMF_H264_USAGE_ULTRALOWLATENCY			TEXT_AMF_H264("Usage.UltraLowLatency")
-#define AMF_H264_USAGE_LOWLATENCY				TEXT_AMF_H264("Usage.LowLatency")
-#define AMF_H264_USAGE_WEBCAM					TEXT_AMF_H264("Usage.Webcam")
-#define AMF_H264_PROFILE						TEXT_AMF_H264("Profile")
-#define AMF_H264_PROFILE_DESCRIPTION			TEXT_AMF_H264("Profile.Description")
-#define AMF_H264_PROFILELEVEL					TEXT_AMF_H264("ProfileLevel")
-#define AMF_H264_PROFILELEVEL_DESCRIPTION		TEXT_AMF_H264("ProfileLevel.Description")
-#define AMF_H264_MAXIMUMLTRFRAMES				TEXT_AMF_H264("MaximumLTRFrames")
-#define AMF_H264_MAXIMUMLTRFRAMES_DESCRIPTION	TEXT_AMF_H264("MaximumLTRFrames.Description")
-
-// Rate Control Properties
-#define AMF_H264_RATECONTROLMETHOD				TEXT_AMF_H264("RateControlMethod")
-#define AMF_H264_RATECONTROLMETHOD_DESCRIPTION	TEXT_AMF_H264("RateControlMethod.Description")
-#define AMF_H264_RATECONTROLMETHOD_CQP			TEXT_AMF_H264("RateControlMethod.CQP")
-#define AMF_H264_RATECONTROLMETHOD_CBR			TEXT_AMF_H264("RateControlMethod.CBR")
-#define AMF_H264_RATECONTROLMETHOD_VBR			TEXT_AMF_H264("RateControlMethod.VBR.Peak")
-#define AMF_H264_RATECONTROLMETHOD_VBR_LAT		TEXT_AMF_H264("RateControlMethod.VBR.Latency")
-#define AMF_H264_BITRATE_TARGET					TEXT_AMF_H264("Bitrate.Target")
-#define AMF_H264_BITRATE_TARGET_DESCRIPTION		TEXT_AMF_H264("Bitrate.Target.Description")
-#define AMF_H264_BITRATE_PEAK					TEXT_AMF_H264("Bitrate.Peak")
-#define AMF_H264_BITRATE_PEAK_DESCRIPTION		TEXT_AMF_H264("Bitrate.Peak.Description")
-#define AMF_H264_QP_MINIMUM						TEXT_AMF_H264("QP.Minimum")
-#define AMF_H264_QP_MINIMUM_DESCRIPTION			TEXT_AMF_H264("QP.Minimum.Description")
-#define AMF_H264_QP_MAXIMUM						TEXT_AMF_H264("QP.Maximum")
-#define AMF_H264_QP_MAXIMUM_DESCRIPTION			TEXT_AMF_H264("QP.Maximum.Description")
-#define AMF_H264_QP_IFRAME						TEXT_AMF_H264("QP.IFrame")
-#define AMF_H264_QP_IFRAME_DESCRIPTION			TEXT_AMF_H264("QP.IFrame.Description")
-#define AMF_H264_QP_PFRAME						TEXT_AMF_H264("QP.PFrame")
-#define AMF_H264_QP_PFRAME_DESCRIPTION			TEXT_AMF_H264("QP.PFrame.Description")
-#define AMF_H264_QP_BFRAME						TEXT_AMF_H264("QP.BFrame")
-#define AMF_H264_QP_BFRAME_DESCRIPTION			TEXT_AMF_H264("QP.BFrame.Description")
-#define AMF_H264_QP_BPICTURE_DELTA				TEXT_AMF_H264("QP.BPictureDelta")
-#define AMF_H264_QP_BPICTURE_DELTA_DESCRIPTION	TEXT_AMF_H264("QP.BPictureDelta.Description")
-#define AMF_H264_QP_REFERENCE_BPICTURE_DELTA	TEXT_AMF_H264("QP.ReferenceBPictureDelta")
-#define AMF_H264_QP_REFERENCE_BPICTURE_DELTA_DESCRIPTION	TEXT_AMF_H264("QP.ReferenceBPictureDelta.Description")
-#define AMF_H264_VBVBUFFER						TEXT_AMF_H264("VBVBuffer")
-#define AMF_H264_VBVBUFFER_DESCRIPTION			TEXT_AMF_H264("VBVBuffer.Description")
-#define AMF_H264_VBVBUFFER_STRICTNESS			TEXT_AMF_H264("VBVBuffer.Strictness")
-#define AMF_H264_VBVBUFFER_STRICTNESS_DESCRIPTION	TEXT_AMF_H264("VBVBuffer.Strictness.Description")
-#define AMF_H264_VBVBUFFER_SIZE					TEXT_AMF_H264("VBVBuffer.Size")
-#define AMF_H264_VBVBUFFER_SIZE_DESCRIPTION		TEXT_AMF_H264("VBVBuffer.Size.Description")
-#define AMF_H264_VBVBUFFER_FULLNESS				TEXT_AMF_H264("VBVBuffer.Fullness")
-#define AMF_H264_VBVBUFFER_FULLNESS_DESCRIPTION	TEXT_AMF_H264("VBVBuffer.Fullness.Description")
-#define AMF_H264_FILLERDATA						TEXT_AMF_H264("FillerData")
-#define AMF_H264_FILLERDATA_DESCRIPTION			TEXT_AMF_H264("FillerData.Description")
-#define AMF_H264_FRAMESKIPPING					TEXT_AMF_H264("FrameSkipping")
-#define AMF_H264_FRAMESKIPPING_DESCRIPTION		TEXT_AMF_H264("FrameSkipping.Description")
-#define AMF_H264_ENFORCEHRDCOMPATIBILITY		TEXT_AMF_H264("EnforceHRDCompatibility")
-#define AMF_H264_ENFORCEHRDCOMPATIBILITY_DESCRIPTION	TEXT_AMF_H264("EnforceHRDCompatibility.Description")
-#define AMF_H264_MAXIMUMACCESSUNITSIZE			TEXT_AMF_H264("MaximumAccessUnitSize")
-#define AMF_H264_MAXIMUMACCESSUNITSIZE_DESCRIPTION	TEXT_AMF_H264("MaximumAccessUnitSize.Description")
-
-// Picture Control Properties
-#define AMF_H264_KEYFRAME_INTERVAL				TEXT_AMF_H264("KeyframeInterval")
-#define AMF_H264_KEYFRAME_INTERVAL_DESCRIPTION	TEXT_AMF_H264("KeyframeInterval.Description")
-#define AMF_H264_IDR_PERIOD						TEXT_AMF_H264("IDRPeriod")
-#define AMF_H264_IDR_PERIOD_DESCRIPTION			TEXT_AMF_H264("IDRPeriod.Description")
-#define AMF_H264_HEADER_INSERTION_SPACING		TEXT_AMF_H264("HeaderInsertionSpacing")
-#define AMF_H264_HEADER_INSERTION_SPACING_DESCRIPTION	TEXT_AMF_H264("HeaderInsertionSpacing.Description")
-#define AMF_H264_BPICTURE_PATTERN				TEXT_AMF_H264("BPicture.Pattern")
-#define AMF_H264_BPICTURE_PATTERN_DESCRIPTION	TEXT_AMF_H264("BPicture.Pattern.Description")
-#define AMF_H264_BPICTURE_REFERENCE				TEXT_AMF_H264("BPicture.Reference")
-#define AMF_H264_BPICTURE_REFERENCE_DESCRIPTION	TEXT_AMF_H264("BPicture.Reference.Description")
-#define AMF_H264_DEBLOCKINGFILTER				TEXT_AMF_H264("DeblockingFilter")
-#define AMF_H264_DEBLOCKINGFILTER_DESCRIPTION	TEXT_AMF_H264("DeblockingFilter.Description")
-#define AMF_H264_SLICESPERFRAME					TEXT_AMF_H264("SlicesPerFrame")
-#define AMF_H264_SLICESPERFRAME_DESCRIPTION		TEXT_AMF_H264("SlicesPerFrame.Description")
-#define AMF_H264_INTRAREFRESHNUMMBSPERSLOT		TEXT_AMF_H264("IntraRefreshNumMBsPerSlot")
-#define AMF_H264_INTRAREFRESHNUMMBSPERSLOT_DESCRIPTION	TEXT_AMF_H264("IntraRefreshNumMBsPerSlot.Description")
-
-// Miscellaneous Properties
-#define AMF_H264_QUALITY_PRESET					TEXT_AMF_H264("QualityPreset")
-#define AMF_H264_QUALITY_PRESET_DESCRIPTION		TEXT_AMF_H264("QualityPreset.Description")
-#define AMF_H264_QUALITY_PRESET_SPEED			TEXT_AMF_H264("QualityPreset.Speed")
-#define AMF_H264_QUALITY_PRESET_BALANCED		TEXT_AMF_H264("QualityPreset.Balanced")
-#define AMF_H264_QUALITY_PRESET_QUALITY			TEXT_AMF_H264("QualityPreset.Quality")
-#define AMF_H264_SCANTYPE						TEXT_AMF_H264("ScanType")
-#define AMF_H264_SCANTYPE_DESCRIPTION			TEXT_AMF_H264("ScanType.Description")
-#define AMF_H264_SCANTYPE_PROGRESSIVE			TEXT_AMF_H264("ScanType.Progressive")
-#define AMF_H264_SCANTYPE_INTERLACED			TEXT_AMF_H264("ScanType.Interlaced")
-#define AMF_H264_MOTIONESTIMATION				TEXT_AMF_H264("MotionEstimation")
-#define AMF_H264_MOTIONESTIMATION_DESCRIPTION	TEXT_AMF_H264("MotionEstimation.Description")
-#define AMF_H264_MOTIONESTIMATION_NONE			TEXT_AMF_H264("MotionEstimation.None")
-#define AMF_H264_MOTIONESTIMATION_HALF			TEXT_AMF_H264("MotionEstimation.Half")
-#define AMF_H264_MOTIONESTIMATION_QUARTER		TEXT_AMF_H264("MotionEstimation.Quarter")
-#define AMF_H264_MOTIONESTIMATION_BOTH			TEXT_AMF_H264("MotionEstimation.Both")
-#define AMF_H264_CABAC							TEXT_AMF_H264("CABAC")
-#define AMF_H264_CABAC_DESCRIPTION				TEXT_AMF_H264("CABAC.Description")
-
-// System Properties
-#define AMF_H264_MEMORYTYPE						TEXT_AMF_H264("MemoryType")
-#define AMF_H264_MEMORYTYPE_DESCRIPTION			TEXT_AMF_H264("MemoryType.Description")
-#define AMF_H264_DEVICE							TEXT_AMF_H264("Device")
-#define AMF_H264_DEVICE_DESCRIPTION				TEXT_AMF_H264("Device.Description")
-#define AMF_H264_USE_OPENCL						TEXT_AMF_H264("UseOpenCL")
-#define AMF_H264_USE_OPENCL_DESCRIPTION			TEXT_AMF_H264("UseOpenCL.Description")
-#define AMF_H264_SURFACEFORMAT					TEXT_AMF_H264("SurfaceFormat")
-#define AMF_H264_SURFACEFORMAT_DESCRIPTION		TEXT_AMF_H264("SurfaceFormat.Description")
-#define AMF_H264_VIEW							TEXT_AMF_H264("View")
-#define AMF_H264_VIEW_DESCRIPTION				TEXT_AMF_H264("View.Description")
-#define AMF_H264_VIEW_BASIC						TEXT_AMF_H264("View.Basic")
-#define AMF_H264_VIEW_ADVANCED					TEXT_AMF_H264("View.Advanced")
-#define AMF_H264_VIEW_EXPERT					TEXT_AMF_H264("View.Expert")
-#define AMF_H264_VIEW_MASTER					TEXT_AMF_H264("View.Master")
-#define AMF_H264_UNLOCK_PROPERTIES				TEXT_AMF_H264("UnlockProperties")
-#define AMF_H264_UNLOCK_PROPERTIES_DESCRIPTION	TEXT_AMF_H264("UnlockProperties.Description")
-#define AMF_H264_DEBUG							TEXT_AMF_H264("Debug")
-#define AMF_H264_DEBUG_DESCRIPTION				TEXT_AMF_H264("Debug.Description")
-
-// Utility
-#define AMF_UTIL_DEFAULT						TEXT_AMF_UTIL("Default")
-#define AMF_UTIL_AUTOMATIC						TEXT_AMF_UTIL("Automatic")
-#define AMF_UTIL_MANUAL							TEXT_AMF_UTIL("Manual")
-#define AMF_UTIL_TOGGLE_DISABLED				TEXT_AMF_UTIL("Toggle.Disabled")
-#define AMF_UTIL_TOGGLE_ENABLED					TEXT_AMF_UTIL("Toggle.Enabled")
-
-//////////////////////////////////////////////////////////////////////////
-// Threading Specific
-//////////////////////////////////////////////////////////////////////////
-
-#if (defined _WIN32) | (defined _WIN64)
-void SetThreadName(uint32_t dwThreadID, const char* threadName);
-void SetThreadName(const char* threadName);
-void SetThreadName(std::thread* thread, const char* threadName);
-
-#else
-void SetThreadName(std::thread* thread, const char* threadName);
-void SetThreadName(const char* threadName);
-
-#endif
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/ca-ES.ini Deleted

@@ -1,40 +0,0 @@
-AMF.H264.Usage.Transcoding="Transcodificació"
-AMF.H264.Usage.UltraLowLatency="Latència ultra baixa"
-AMF.H264.Usage.LowLatency="Latència baixa"
-AMF.H264.Profile="Perfil"
-AMF.H264.ProfileLevel="Nivell de perfil"
-AMF.H264.MaximumLTRFrames="Fotogrames màxims LTR"
-AMF.H264.RateControlMethod="Mètode de control del flux"
-AMF.H264.RateControlMethod.CQP="QP constant (CQP)"
-AMF.H264.RateControlMethod.CBR="Flux constant (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Flux variable (pic restringit)(VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Flux variable (latència restringida) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Tassa de bits desitjada"
-AMF.H264.Bitrate.Peak="Pic de tassa de bits"
-AMF.H264.QP.Minimum="QP mínim"
-AMF.H264.QP.Maximum="QP màxim"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="QP Delta en B-Pictures de referencia"
-AMF.H264.FillerData="Dades a omplir"
-AMF.H264.FrameSkipping="Omissió de fotogrames"
-AMF.H264.EnforceHRDCompatibility="Força la compatibilitat amb HRD"
-AMF.H264.BPicture.Pattern="Patró B-Picture"
-AMF.H264.BPicture.Reference="Referència B-Picture"
-AMF.H264.DeblockingFilter="Filtre d'eliminació de blocs"
-AMF.H264.ScanType="Tipus d'exploració"
-AMF.H264.ScanType.Progressive="Progressiu"
-AMF.H264.ScanType.Interlaced="Entrellaçat"
-AMF.H264.QualityPreset="Qualitat del perfil"
-AMF.H264.QualityPreset.Speed="Velocitat"
-AMF.H264.QualityPreset.Balanced="Equilibrat"
-AMF.H264.QualityPreset.Quality="Qualitat"
-AMF.H264.CABAC="Codificació adaptativa segons el context binari aritmètic (CABAC)"
-AMF.H264.MemoryType="Tipus de memòria"
-AMF.H264.SurfaceFormat="Format de la superfície"
-AMF.Util.Default="Per defecte"
-AMF.Util.Automatic="Automàtic"
-AMF.Util.Toggle.Disabled="Desactivat"
-AMF.Util.Toggle.Enabled="Activat"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/cs-CZ.ini Deleted

@@ -1,60 +0,0 @@
-AMF.H264.Preset="Profil"
-AMF.H264.Preset.Recording="Nahrávání"
-AMF.H264.Preset.HighQuality="Vysoká kvalita"
-AMF.H264.Preset.Indistinguishable="Nerozeznatelné"
-AMF.H264.Preset.Lossless="Lossless"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Využití"
-AMF.H264.Usage.Transcoding="Kódování"
-AMF.H264.Usage.UltraLowLatency="Ultra nízká odezva"
-AMF.H264.Usage.LowLatency="Nízká odezva"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Úroveň profilu"
-AMF.H264.RateControlMethod="Metoda řízení"
-AMF.H264.RateControlMethod.CQP="Konstantní QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Konstantní bitrate (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Proměnný bitrate (vázán špičkou) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Proměnný bitrate (vázán odezvou) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Cílový bitrate"
-AMF.H264.Bitrate.Peak="Špičkový bitrate"
-AMF.H264.QP.Minimum="Minimální QP"
-AMF.H264.QP.Maximum="Maximální QP"
-AMF.H264.FillerData="Filtrovat data"
-AMF.H264.FrameSkipping="Přeskakování snímků"
-AMF.H264.EnforceHRDCompatibility="Vynutit kompatibilitu s HRD"
-AMF.H264.KeyframeInterval="Interval klíčový snímků"
-AMF.H264.KeyframeInterval.Description="Kolik vteřin by mělo být mezi ne-zahazovatelnými snímky.\nTaké ovládá velikost sekvence(GOP)."
-AMF.H264.IDRPeriod.Description="Kolik snímků by mělo být mezi ne-zahazovatelnými snímky.\nTaké ovládá velikost sekvence(GOP)."
-AMF.H264.ScanType="Typ skenování"
-AMF.H264.ScanType.Description="Určuje použitou metodu skenování, vždy ponechejte na 'Progresivní'."
-AMF.H264.ScanType.Progressive="Progresivní"
-AMF.H264.ScanType.Interlaced="Prokládané"
-AMF.H264.QualityPreset="Profil kvality"
-AMF.H264.QualityPreset.Speed="Rychlost"
-AMF.H264.QualityPreset.Balanced="Vyváženo"
-AMF.H264.QualityPreset.Quality="Kvalita"
-AMF.H264.MotionEstimation="Odhad pohybu"
-AMF.H264.MotionEstimation.Description="Odhad pohybu umožňuje enkodéru snížit požadovaný bitrate předpovídáním, kam se určitý pixel posunul."
-AMF.H264.MotionEstimation.None="Žádný"
-AMF.H264.MotionEstimation.Half="Polovina pixelu"
-AMF.H264.MotionEstimation.Quarter="Čtvrtina pixelu"
-AMF.H264.MotionEstimation.Both="Polovina & čtvrtina pixelu"
-AMF.H264.CABAC="CABAC"
-AMF.H264.MemoryType="Typ paměti"
-AMF.H264.SurfaceFormat="Formát povrchu"
-AMF.H264.View="Režim zobrazení"
-AMF.H264.View.Description="Které možnosti mají být zobrazeny. Nezískáte žádnou pomoc při použití módu 'Expert' či 'Master'."
-AMF.H264.View.Basic="Základní"
-AMF.H264.View.Advanced="Pokročilý"
-AMF.H264.View.Expert="Expert"
-AMF.H264.View.Master="Master"
-AMF.H264.UnlockProperties="Odblokovat vlastnosti"
-AMF.H264.UnlockProperties.Description="Odblokuje určité vlastnosti do jejich plného rozsahu místo omezování do určitého."
-AMF.H264.Debug="Ladění"
-AMF.H264.Debug.Description="Zapne rozšířené protokolování, mělo by být zapnuto, pokud pořebujete pomoci s tmto enkodérem."
-AMF.Util.Default="Výchozí"
-AMF.Util.Automatic="Automatické"
-AMF.Util.Manual="Manuální"
-AMF.Util.Toggle.Disabled="Zakázáno"
-AMF.Util.Toggle.Enabled="Povoleno"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/da-DK.ini Deleted

@@ -1,34 +0,0 @@
-AMF.H264.Usage.Transcoding="Transcoding"
-AMF.H264.Usage.UltraLowLatency="Ekstrem Lav Ventetid"
-AMF.H264.Usage.LowLatency="Lav Ventetid"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Profil Niveau"
-AMF.H264.RateControlMethod="Rate Control Method"
-AMF.H264.RateControlMethod.CQP="Constant QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Constant Bitrate (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Peak Constrained) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Latency Constrained) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Mål Bitrate"
-AMF.H264.Bitrate.Peak="Top Bitrate"
-AMF.H264.QP.Minimum="Minimum QP"
-AMF.H264.QP.Maximum="Maksimum QP"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.FillerData="Filler Data"
-AMF.H264.FrameSkipping="Billede skip"
-AMF.H264.EnforceHRDCompatibility="Tving HRD Kompatibilitet"
-AMF.H264.BPicture.Pattern="B-Picture Pattern"
-AMF.H264.BPicture.Reference="B-Picture Reference"
-AMF.H264.DeblockingFilter="Deblocking Filter"
-AMF.H264.ScanType="Scan Type"
-AMF.H264.ScanType.Progressive="Progressive"
-AMF.H264.ScanType.Interlaced="Interlaced"
-AMF.H264.QualityPreset="Kvalitets profiler"
-AMF.H264.QualityPreset.Speed="Hastighed (Dårligste kvalitet)"
-AMF.H264.QualityPreset.Balanced="Balanceret (Mellem Kvalitet)"
-AMF.H264.QualityPreset.Quality="Kvalitet (Bedste Kvalitet)"
-AMF.Util.Default="Standard"
-AMF.Util.Toggle.Disabled="Deaktiveret"
-AMF.Util.Toggle.Enabled="Aktiveret"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/de-DE.ini Deleted

@@ -1,115 +0,0 @@
-AMF.H264.Preset="Voreinstellungen"
-AMF.H264.Preset.Recording="Aufnahme"
-AMF.H264.Preset.HighQuality="Hohe Qualität"
-AMF.H264.Preset.Indistinguishable="Ununterscheidbar"
-AMF.H264.Preset.Lossless="Verlustfrei"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Nutzungsart"
-AMF.H264.Usage.Description="Auf welche Nutzungsart AMF eingestellt werden soll:\n- 'Umwandeln' für generelle umwandlung (empfohlen),\n- 'Sehr Niedrige Latenz' für codierung mit sehr niedriger latenz,\n- 'Niedrige Latenz' ist ähnlich dem oberen mit leicht erhöhter latenz.\nNur 'Umwandeln' wird für das streamen unterstützt, alle anderen können für aufnahmen verwendet werden."
-AMF.H264.Usage.Transcoding="Umwandeln"
-AMF.H264.Usage.UltraLowLatency="Sehr Niedrige Latenz"
-AMF.H264.Usage.LowLatency="Niedrige Latenz"
-AMF.H264.Profile="Profil"
-AMF.H264.Profile.Description="Welches H.264 Profil für das Codieren verwendet werden soll:\n- 'Baseline' hat die größte Unterstützung,\n- 'Main' wird von ca 95% an Geräten unterstützt (empfohlen),\n- 'High' wird nur von Hoch-Performance Geräten unterstützt."
-AMF.H264.ProfileLevel="Profillevel"
-AMF.H264.ProfileLevel.Description="Welches H.264 Profil Level für das verarbeiten verwendet werden soll:\n- 'Automatisch' errechnet das beste Profil Level für die gegeben Frame Rate und Frame Größe,\n- '4.1' unterstützt 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' unterstützt 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' unterstützt 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' unterstützt 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' unterstützt 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Maximale Langzeitreferenz-Bilder"
-AMF.H264.MaximumLTRFrames.Description="Langzeitreferenz (LTR) Bilder ist ein feature das dem Codierer erlaubt, einige Bilder innerhalb einer Sequenz als referenzierbar zu markieren.\nDies kann einen positiven Effekt auf die Qualität haben sofern B-Bilder nicht unterstützt oder gewollt sind.\nLTR Bilder können nicht zusammen mit B-Bildern verwendet werden und der encoder wird B-Bilder deaktivieren sofern diese verwendet werden."
-AMF.H264.RateControlMethod="Ratenkontrollmethode"
-AMF.H264.RateControlMethod.Description="Welche Ratenkontrollmethode verwendet werden soll:\n- CQP setzt feste QP (Quantifizierungsparameter) werte für I-/P-/B- Bilder,\n- CBR bleibt auf der Zielbitrate (mithilfe von Füllungsdaten) (empfohlen für das Streamen),\n- VBR bleibt unter der Höchstbitrate,\n- VBR_LAT bleibt nahe der Zielbitrate sofern GPU-Latenz und GPU-Benutzung dies erlauben, ansonsten wird eine höhere Bitrate verwendet (empfohlen für Aufnamen).\nAlle Methoden bis auf CQP nutzen die Minimum und Maximum QP (Quantifizierungsparameter) Begrenzungen."
-AMF.H264.RateControlMethod.CQP="Konstante QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Konstante Bitrate (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Eingeschränkt via Spitzenbitrate) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Eingeschränkt via Latenz) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Zielbitrate"
-AMF.H264.Bitrate.Target.Description="Bitrate die versucht werden soll zu erreichen in einer Sequenz.\nWird von CBR und VBR_LAT verwendet."
-AMF.H264.Bitrate.Peak="Spitzenbitrate"
-AMF.H264.Bitrate.Peak.Description="Maximale Bitrate in einer Sequenz.\nWird von VBR und VBR_LAT verwendet."
-AMF.H264.QP.Minimum="Minimale QP"
-AMF.H264.QP.Minimum.Description="Niedrigster QP wert der in einem Bild verwendet werden darf.\nWird von CBR, VBR und VBR_LAT verwendet."
-AMF.H264.QP.Maximum="Maximale QP"
-AMF.H264.QP.Maximum.Description="Größter QP wert der in einem Bild verwendet werden darf.\nWird von CBR, VBR und VBR_LAT verwendet."
-AMF.H264.QP.IFrame="I-Einzelbild QP"
-AMF.H264.QP.IFrame.Description="Festgelegter QP wert der für I-Bilder verwendet wird.\nNiedriger = größere Datei, bessere Qualität. Höher = Kleinere Datei, schlechtere Qualität.\nDer QP wert für I-Bilder sollte gleich oder höher als der für P- und B-Bilder sein.\nWird von CQP verwendet."
-AMF.H264.QP.PFrame="P-Einzelbild QP"
-AMF.H264.QP.PFrame.Description="Festgelegter QP wert der für P-Bilder verwendet wird.\nNiedriger = größere Datei, bessere Qualität. Höher = Kleinere Datei, schlechtere Qualität.\nDer QP wert für P-Bilder sollte gleich oder höher als der für B-Bilder sein.\nWird von CQP verwendet."
-AMF.H264.QP.BFrame="B-Einzelbild QP"
-AMF.H264.QP.BFrame.Description="Festgelegter QP wert der für B-Bilder verwendet wird.\nNiedriger = größere Datei, bessere Qualität. Höher = Kleinere Datei, schlechtere Qualität.\nWird von CQP verwendet."
-AMF.H264.QP.BPictureDelta="B-Bild Delta QP"
-AMF.H264.QP.BPictureDelta.Description="Delta QP wert zum letzten nicht-Referenz B-Bild."
-AMF.H264.QP.ReferenceBPictureDelta="Referenz B-Bild Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta.Description="Delta QP wert zum letzten Referenz B-Bild."
-AMF.H264.VBVBuffer="VBV Buffer"
-AMF.H264.VBVBuffer.Description="Welche methode genutzt werden soll um die VBV-Puffergröße zu bestimmen:\n- 'Automatisch' errechnet diese mithilfe einer Strengeneinschränkung,\n- 'Manuell' erlaubt es dem Nutzer die Größe zu kontrollieren.\n
-VBV (Videopufferungsverifizierer) Puffer wird von verschiedenen Ratenkontrollmethoden genutzt um die gesamte Bitrate innerhalb der Begrenzungen zu halten."
-AMF.H264.VBVBuffer.Strictness="VBV Buffer Genauigkeit"
-AMF.H264.VBVBuffer.Strictness.Description="Wie streng der VBV Buffer sein soll, wobei 100% fast exakt die Zielbitrate und 0% komplett unbeschränkt ist."
-AMF.H264.VBVBuffer.Size="VBV Buffer Größe"
-AMF.H264.VBVBuffer.Size.Description="Die Größe des VBV Buffers der für die Bitratenkontrollen in einer Sequenz verwendet wird.\nEine kleine Größe ergibt eine fast perfekte Übereinstimmung mit der Bitrate aber hat einen größeren Performanzeinfluss.\nDie ideale (100% streng) VBV Buffer Größe ist Bitrate/Framerate."
-AMF.H264.VBVBuffer.Fullness="VBV Buffer Füllung"
-AMF.H264.VBVBuffer.Fullness.Description="Wie voll der VBV Buffer anfangs ist, hat nur einen Effekt auf die erste Sequenz beim codieren."
-AMF.H264.FillerData="Füllungsdaten"
-AMF.H264.FillerData.Description="Füllungsdaten sind leere/invalide Daten die der Decodierer ignoriert.\nWenn aktiv und CBR verwendet wird, dann wird der Codierer den verbleibenden Platz in einer Sequenz mit diesen Daten füllen."
-AMF.H264.FrameSkipping="Einzelbildüberspringung"
-AMF.H264.FrameSkipping.Description="Einzelbildüberspringung erlaubt es dem Codierer selektiv Bilder auszulassen sollten diese zu ähnlich sein oder zu lange zum codieren brauchen.\nSofern dies aktiv ist nutzt die Ausgabe Variable Frameraten, was die meiste Bearbeitungssoftware nicht unterstützt."
-AMF.H264.EnforceHRDCompatibility="Erzwinge HRD Kompatiblität"
-AMF.H264.EnforceHRDCompatibility.Description="Erzwinge Hypothetischer-Referenz-Decodierer Limitierungen welches die maximale Änderung des QP werts innerhalb eines Bildes begrenzt.\nNicht empfohlen für Aufname oder Streamen und sollte nur verwendet werden sofern das Ziel sehr alte Geräte mit einem Softwarereferenz Decodierer sind."
-AMF.H264.MaximumAccessUnitSize="Maximale Zugriffseinheitsgröße"
-AMF.H264.MaximumAccessUnitSize.Description="Größte Größe einer Zugriffseinheit für einen NAL. Ein Wert von 0 erlaubt es dem Codierer die beste Größte zu wählen."
-AMF.H264.KeyframeInterval="Schlüsselbilderintervall"
-AMF.H264.KeyframeInterval.Description="Wie viele Sekunden sollen zwischen nicht-auslassbaren Bildern sein.\nKontrolliert auf die Größe einer Sequenz (GOP)."
-AMF.H264.IDRPeriod="IDR Zeitraum"
-AMF.H264.IDRPeriod.Description="Wie viele Bilder sollen zwischen nicht-auslassbaren Bildern sein.\nKontrolliert auf die Größe einer Sequenz (GOP)."
-AMF.H264.HeaderInsertionSpacing="Dateikopfeinfügungsabstand"
-AMF.H264.HeaderInsertionSpacing.Description="Wie viele Bilder zwischen NAL-kopfzeilen sein sollen. Es wird nicht empfohlen dies von 0 (automatisch) zu ändern."
-AMF.H264.BPicture.Pattern="B-Bild Muster"
-AMF.H264.BPicture.Pattern.Description="Wie viele B-Bilder sollen erlaubt sein für das codieren. Dies hat einen positiven Einfluss auf Qualität und einen negativen Einfluss auf Performanz.\nWird nur von der 2. und 3. Generation an VCE-Karten unterstützt."
-AMF.H264.BPicture.Reference="B-Bild Referenz"
-AMF.H264.BPicture.Reference.Description="Erlaube B-Bilder andere B-Bilder zu verwenden.\nSehr großer Einfluss auf Performanz, wenig Einfluss auf Qualität."
-AMF.H264.DeblockingFilter="Entblockungsfilter"
-AMF.H264.DeblockingFilter.Description="Setze die Markierung dass der Decodierer einen Entblockungsfilter verwenden darf."
-AMF.H264.SlicesPerFrame="Slices pro Frame"
-AMF.H264.SlicesPerFrame.Description="Benutze eine feste anzahl an Schnitten anstatt einer dynamischen für das codieren.\nKann mit größeren Auflösungen und Frameraten helfen da dies dem Codierer erlaubt mehr Daten mit dem selben Profil-level zu speichern, hat aber oft einen negativen Effekt auf die Qualität."
-AMF.H264.IntraRefreshNumMBsPerSlot="Intra-Refresh Anzahl der Makroblöcke pro Slot"
-AMF.H264.IntraRefreshNumMBsPerSlot.Description="Wie viele Makroblöcke sollen pro Slot in der Intra-Refresh-Kodierung erlaubt sein?\nIntra-Refresh-Kodierung erlaubt schnelleres Durchsuchen und decodieren auf Kosten einer höheren Bitrate, da zusätzliche Daten gespeichert werden.\nBeim Streamen auf der Standardeinstellung lassen."
-AMF.H264.ScanType="Abtastverfahren"
-AMF.H264.ScanType.Description="Welches Abtastverfahren verwendet werden soll. Sollte immer 'Progressiv' sein."
-AMF.H264.ScanType.Progressive="Progressiv"
-AMF.H264.ScanType.Interlaced="Zeilensprung"
-AMF.H264.QualityPreset="Qualitätsvoreinstellung"
-AMF.H264.QualityPreset.Description="Welche Qualitätsvoreinstellungen AMF versuchen soll zu verwenden:\n- 'Geschwindigkeit' ist der schnellste aber hat die schlechteste Qualität,\n- 'Balanciert' ist zwischen 'Geschwindigkeit' und 'Qualität' und ergibt eine großartige balance zwischen beiden,\n- 'Qualität' gibt die beste Qualität für eine gegebene bitrate."
-AMF.H264.QualityPreset.Speed="Geschwindigkeit"
-AMF.H264.QualityPreset.Balanced="Ausgeglichen"
-AMF.H264.QualityPreset.Quality="Qualität"
-AMF.H264.MotionEstimation="Bewegungsschätzung"
-AMF.H264.MotionEstimation.Description="Bewegungsschätzung erlaubt des dem Codierer die gebrauchte Bitrate zu reduzieren durch das herausfinden wo ein Pixel hinbewegt wurde."
-AMF.H264.MotionEstimation.None="Keine"
-AMF.H264.MotionEstimation.Half="Halb-Pixel"
-AMF.H264.MotionEstimation.Quarter="Viertel-Pixel"
-AMF.H264.MotionEstimation.Both="Halb- & Viertel-Pixel"
-AMF.H264.CABAC="Kontextbasierende adaptive Binäre Arithmetische Kodierung (CABAC)"
-AMF.H264.CABAC.Description="Benutze CABAC (Kontextbasierende Adaptive Binäre Arithmetische Kodierung) anstatt von CALV.\nKein Einfluss auf Qualität aber hilft bei der Kompression. Im Durschnitt ist eine Verbesserung von 5% zu erwarten."
-AMF.H264.MemoryType="Speichertyp"
-AMF.H264.MemoryType.Description="Wie sollen Bilder bevor der Übertragung zum Codierer gespeichert werden:\n- 'Automatisch' wählt die beste verfügbare Speicher-methode aus,\n- Host verwendet Ram,\n- DirectX 9 verwendet DirectX Texturflächen,\n- DirectX 11 verwendet DirectX Texturflächen,\n- OpenGL verwendet OpenGL Texturflächen.\n\nHost ist gut genug für die meisten Systeme, aber DirectX kann gelegentlich bei hoher Last helfen."
-AMF.H264.Device="Gerät"
-AMF.H264.Device.Description="Welches Gerät für das codieren verwendet werden soll.\nBenötigt einen anderen Speichertyp als 'Host'."
-AMF.H264.UseOpenCL="Benutze OpenCL"
-AMF.H264.UseOpenCL.Description="Soll OpenCL verwendet werden um Einzelbilder zum Codierer zu senden?"
-AMF.H264.SurfaceFormat="Oberflächenformat"
-AMF.H264.SurfaceFormat.Description="Welches Oberflächenformat für das Codieren verwendet werden soll.\nNur NV12 wird nativ unterstützt, alle anderen müssen konvertiert werden."
-AMF.H264.View="Ansichtsmodus"
-AMF.H264.View.Description="Welche Einstellungen sichtbar sein sollen. Hilfe mit Einstellungen wird abgelehnt sofern 'Experte' oder 'Meister' als Ansichtsmodus verwendet wird."
-AMF.H264.View.Basic="Grundlegend"
-AMF.H264.View.Advanced="Erweitert"
-AMF.H264.View.Expert="Experte"
-AMF.H264.View.Master="Meister"
-AMF.H264.UnlockProperties="Entsperre Einstellungen"
-AMF.H264.UnlockProperties.Description="Entsperre einige Einstellungen so dass diese die volle Reichweite haben anstatt nur eine begrenzte."
-AMF.H264.Debug="Debug"
-AMF.H264.Debug.Description="Aktiviere erweiterte debug nachrichten, sollte aktiv sein wenn man Hilfe erwartet mit diesem encoder."
-AMF.Util.Default="Standard"
-AMF.Util.Automatic="Automatisch"
-AMF.Util.Manual="Manuell"
-AMF.Util.Toggle.Disabled="Deaktiviert"
-AMF.Util.Toggle.Enabled="Aktiviert"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/en-US.ini Deleted

@@ -1,121 +0,0 @@
-# Presets
-AMF.H264.Preset="Preset"
-AMF.H264.Preset.Recording="Recording"
-AMF.H264.Preset.HighQuality="High Quality"
-AMF.H264.Preset.Indistinguishable="Indistinguishable"
-AMF.H264.Preset.Lossless="Lossless"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-# Static Properties
-AMF.H264.Usage="Usage"
-AMF.H264.Usage.Description="What usage AMF should be tuned for:\n- 'Transcoding' is general purpose transcoding (recommended),\n- 'Ultra Low Latency' is for really low latency encoding,\n- 'Low Latency' is similar to above with a slightly higher latency.\nStreaming only supports 'Transcoding', all other values can be used for recording."
-AMF.H264.Usage.Transcoding="Transcoding"
-AMF.H264.Usage.UltraLowLatency="Ultra Low Latency"
-AMF.H264.Usage.LowLatency="Low Latency"
-AMF.H264.Profile="Profile"
-AMF.H264.Profile.Description="Which H.264 Profile to use for encoding:\n- 'Baseline' has the widest support,\n- 'Main' is supported by 95% of devices (recommended),\n- 'High' is only supported by high-end devices."
-AMF.H264.ProfileLevel="Profile Level"
-AMF.H264.ProfileLevel.Description="Which H.264 Profile Level to use for encoding:\n- 'Automatic' calculates the best profile level for the given Frame Rate and Frame Size,\n- '4.1' supports 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' supports 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' supports 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' supports 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' supports 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Maximum LTR Frames"
-AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Frames are a feature that allows the encoder to flag certain frames in a sequence as referencable.\nThis can have a positive effect on quality when B-Pictures are not support or wanted.\nLTR Frames can't be used with B-Pictures and the encoder will disable B-Pictures if these are used."
-# Rate Control Properties
-AMF.H264.RateControlMethod="Rate Control Method"
-AMF.H264.RateControlMethod.Description="What rate control method should be used:\n- CQP assigns fixed I-/P-/B-Frame QP (Quantization Parameter) values,\n- CBR stays at the given Target Bitrate (using Filler Data) (recommended for streaming),\n- VBR stays below the given Peak Bitrate,\n- VBR_LAT stays close to the Target Bitrate if GPU latency and load allow for it, otherwise will use higher bitrate (recommended for recording).\nAll Methods but CQP use Minimum and Maximum QP (Quantization Parameter) constraints."
-AMF.H264.RateControlMethod.CQP="Constant QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Constant Bitrate (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Peak Constrained) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Latency Constrained) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Target Bitrate"
-AMF.H264.Bitrate.Target.Description="Bitrate to attempt to achieve in the overall sequence.\nUsed by CBR and VBR_LAT."
-AMF.H264.Bitrate.Peak="Peak Bitrate"
-AMF.H264.Bitrate.Peak.Description="Bitrate to attempt to maximally peak to in the overall sequence.\nUsed by VBR and VBR_LAT."
-AMF.H264.QP.Minimum="Minimum QP"
-AMF.H264.QP.Minimum.Description="Lowest QP (Quantization Parameter) value to use in a frame.\nUsed by CBR, VBR and VBR_LAT."
-AMF.H264.QP.Maximum="Maximum QP"
-AMF.H264.QP.Maximum.Description="Highest QP (Quantization Parameter) value to use in a frame.\nUsed by CBR, VBR and VBR_LAT."
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.IFrame.Description="Fixed QP (Quantization Parameter) value to use for I-Frames.\nLower = Bigger File, Better Quality. Higher = Smaller File, Worse Quality.\nI-Frame QP should be at or higher than P- and B-Frame QP.\nUsed by CQP."
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.PFrame.Description="Fixed QP (Quantization Parameter) value to use for P-Frames.\nLower = Bigger File, Better Quality. Higher = Smaller File, Worse Quality.\nP-Frame QP should be at or higher than B-Frame QP.\nUsed by CQP."
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BFrame.Description="Fixed QP (Quantization Parameter) value to use for B-Frames.\nLower = Bigger File, Better Quality. Higher = Smaller File, Worse Quality.\nUsed by CQP."
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.BPictureDelta.Description="Delta QP (Quantization Parameter) value to the last non-reference B-Picture."
-AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta.Description="Delta QP (Quantization Parameter) value to the last reference B-Picture."
-AMF.H264.VBVBuffer="VBV Buffer"
-AMF.H264.VBVBuffer.Description="What method should be used to determine the VBV Buffer Size:\n- 'Automatic' calculates the size using a strictness constraint,\n- 'Manual' allows the user to control the size.\nVBV (Video Buffering Verifier) Buffer is used by certain Rate Control Methods to keep the overall bitrate within the given constraints."
-AMF.H264.VBVBuffer.Strictness="VBV Buffer Strictness"
-AMF.H264.VBVBuffer.Strictness.Description="How strict the VBV Buffer is, with 100% being almost exactly the targetted Bitrate and 0% being unrestricted."
-AMF.H264.VBVBuffer.Size="VBV Buffer Size"
-AMF.H264.VBVBuffer.Size.Description="The size of the VBV Buffer which is used for Bitrate control in a sequence.\nA small size results in an almost perfect bitrate match but has a larger performance impact.\nThe ideal (100% strict) VBV Buffer size is Bitrate/Framerate."
-AMF.H264.VBVBuffer.Fullness="VBV Buffer Fullness"
-AMF.H264.VBVBuffer.Fullness.Description="How full the VBV Buffer initially is, will only affect the initial sequence of encoding."
-AMF.H264.FillerData="Filler Data"
-AMF.H264.FillerData.Description="Filler Data is empty/invalid data that the decoder ignores.\nIf enabled and using CBR the encoder will fill up the remaining space in a sequence up with this data."
-AMF.H264.FrameSkipping="Frame Skipping"
-AMF.H264.FrameSkipping.Description="Frame Skipping allows the encoder to selectively skip over frames if they are very similar or would take too long to encode.\nEnabling this will make the output file be in variable framerate, which most editing software does not support."
-AMF.H264.EnforceHRDCompatibility="Enforce HRD Compatibility"
-AMF.H264.EnforceHRDCompatibility.Description="Enforce Hypothetical Reference Decoder restrictions which limit the maximum QP value change within a frame.\nNot recommended for recording or streaming and should only be used for targeting very old devices that only have reference software decoders."
-AMF.H264.MaximumAccessUnitSize="Maximum Access Unit Size"
-AMF.H264.MaximumAccessUnitSize.Description="Largest Size of an Access Unit for a NAL. A value of 0 allows the encoder to pick the best one."
-# Picture Control Properties
-AMF.H264.KeyframeInterval="Keyframe Interval"
-AMF.H264.KeyframeInterval.Description="How many seconds should be between non-droppable Frames.\nAlso controls sequence(GOP) size."
-AMF.H264.IDRPeriod="IDR Period"
-AMF.H264.IDRPeriod.Description="How many frames should be between non-droppable Frames.\nAlso controls sequence(GOP) size."
-AMF.H264.HeaderInsertionSpacing="Header Insertion Spacing"
-AMF.H264.HeaderInsertionSpacing.Description="How many frames should be between NAL headers. It is not recommended to change this from 0 (automatic)."
-AMF.H264.BPicture.Pattern="B-Picture Pattern"
-AMF.H264.BPicture.Pattern.Description="How many B-Pictures should be allowed for encoding, has a positive impact on quality and negative impact on performance.\nSupported by 2nd and 3rd Generation VCE cards."
-AMF.H264.BPicture.Reference="B-Picture Reference"
-AMF.H264.BPicture.Reference.Description="Allow B-Pictures to reference other B-Pictures additionally to P- and I-Frames.\nHuge performance impact, low quality improvement."
-AMF.H264.DeblockingFilter="Deblocking Filter"
-AMF.H264.DeblockingFilter.Description="Sets the flag that the decoder is allowed to use a Deblocking Filter for the encoded stream."
-AMF.H264.SlicesPerFrame="Slices Per Frame"
-AMF.H264.SlicesPerFrame.Description="Use fixed slice encoding instead of dynamic slice encoding.\nCan help with large resolutions and framerates as it allows for more data to be stored in the same profile level but will have a negative effect on quality most of the time."
-AMF.H264.IntraRefreshNumMBsPerSlot="Intra-Refresh Number of Macroblocks Per Slot"
-AMF.H264.IntraRefreshNumMBsPerSlot.Description="How many Macroblocks should be allowed per slot in Intra-Refresh encoding.\nIntra-Refresh encoding allows faster seeking and decoding at the cost of a higher bitrate due to additional data being stored.\nLeave at default for streaming."
-# Miscellaneous Properties
-AMF.H264.ScanType="Scan Type"
-AMF.H264.ScanType.Description="Which scanning method to use, always leave this on 'Progressive'."
-AMF.H264.ScanType.Progressive="Progressive"
-AMF.H264.ScanType.Interlaced="Interlaced"
-AMF.H264.QualityPreset="Quality Preset"
-AMF.H264.QualityPreset.Description="What Quality Preset AMF should attempt to target:\n- 'Speed' is the fastest but has the worst quality,\n- 'Balanced' is between 'Speed' and 'Quality' and offers a great balance between both,\n- 'Quality' gives the best quality for a given bitrate."
-AMF.H264.QualityPreset.Speed="Speed"
-AMF.H264.QualityPreset.Balanced="Balanced"
-AMF.H264.QualityPreset.Quality="Quality"
-AMF.H264.MotionEstimation="Motion Estimation"
-AMF.H264.MotionEstimation.Description="Motion Estimation allows the encoder to reduce needed bitrate by estimating where a pixel went."
-AMF.H264.MotionEstimation.None="None"
-AMF.H264.MotionEstimation.Half="Half-Pixel"
-AMF.H264.MotionEstimation.Quarter="Quarter-Pixel"
-AMF.H264.MotionEstimation.Both="Half- & Quarter-Pixel"
-AMF.H264.CABAC="CABAC"
-AMF.H264.CABAC.Description="Use CABAC (Context Adaptive Binary Arithmetic Coding) instead of CALV.\nNo impact on Quality but helps with compression. On average, 5% better compression can be expected."
-# System Properties
-AMF.H264.MemoryType="Memory Type"
-AMF.H264.MemoryType.Description="How Frames should be stored before submission to the encoder:\n- 'Automatic' picks the best available memory backend type available,\n- Host uses system memory,\n- DirectX 9 uses DirectX surfaces for submission,\n- DirectX 11 uses DirectX surfaces for submission,\n- OpenGL uses OpenGL surfaces for submission.\n\n'Host' is good enough for most systems but DirectX can occasionally help with high load situations."
-AMF.H264.Device="Device"
-AMF.H264.Device.Description="Which Device to use for encoding.\nRequires Memory Type to not be set to 'Host'."
-AMF.H264.UseOpenCL="Use OpenCL"
-AMF.H264.UseOpenCL.Description="Should the Encoder use OpenCL to submit the individual frames?"
-AMF.H264.SurfaceFormat="Surface Format"
-AMF.H264.SurfaceFormat.Description="What Surface Format to use for encoding.\nOnly NV12 is natively supported, other types require conversion."
-AMF.H264.View="View Mode"
-AMF.H264.View.Description="What properties should be visible.  You will receive no support when using 'Expert' or 'Master' view mode."
-AMF.H264.View.Basic="Basic"
-AMF.H264.View.Advanced="Advanced"
-AMF.H264.View.Expert="Expert"
-AMF.H264.View.Master="Master"
-AMF.H264.UnlockProperties="Unlock Properties"
-AMF.H264.UnlockProperties.Description="Unlock certain properties to their full range instead of limiting them to a partial range."
-AMF.H264.Debug="Debug"
-AMF.H264.Debug.Description="Enable additional Debug logging, should be active whenever you need support with this encoder."
-# Utility
-AMF.Util.Default="Default"
-AMF.Util.Automatic="Automatic"
-AMF.Util.Manual="Manual"
-AMF.Util.Toggle.Disabled="Disabled"
-AMF.Util.Toggle.Enabled="Enabled"
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/es-ES.ini Deleted

@@ -1,79 +0,0 @@
-AMF.H264.Preset="Preajuste"
-AMF.H264.Preset.Recording="Grabación"
-AMF.H264.Preset.HighQuality="Alta Calidad"
-AMF.H264.Preset.Indistinguishable="Indistinguible"
-AMF.H264.Preset.Lossless="Sin pérdidas"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Uso"
-AMF.H264.Usage.Transcoding="Codificación"
-AMF.H264.Usage.UltraLowLatency="Latencia ultra baja"
-AMF.H264.Usage.LowLatency="Latencia baja"
-AMF.H264.Profile="Perfil del Códec"
-AMF.H264.ProfileLevel="Nivel del Perfil"
-AMF.H264.ProfileLevel.Description="Nivel de perfil H.264 a utilizar para la codificación:\n- 'Automático' calcula el mejor nivel de perfil para cierta velocidad y tamaño de fotogramas,\n- '4.1' soporta 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' soporta 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' soporta 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' soporta 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' soporta 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Fotogramas LTR máximos"
-AMF.H264.RateControlMethod="Método de control del flujo"
-AMF.H264.RateControlMethod.CQP="QP constante (CQP)"
-AMF.H264.RateControlMethod.CBR="Flujo constante (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Flujo variable (pico restringido) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Flujo variable (latencia restringida) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Tasa de bits deseada"
-AMF.H264.Bitrate.Peak="Pico de tasa de bits"
-AMF.H264.QP.Minimum="QP Mínimo"
-AMF.H264.QP.Maximum="QP Máximo"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="QP Delta en B-Pictures"
-AMF.H264.QP.BPictureDelta.Description="QP Delta del último B-Picture que no es de referencia."
-AMF.H264.QP.ReferenceBPictureDelta="QP Delta en B-Pictures de referencia"
-AMF.H264.QP.ReferenceBPictureDelta.Description="QP Delta del último B-Picture de referencia."
-AMF.H264.VBVBuffer="Buffer VBV"
-AMF.H264.VBVBuffer.Strictness="Estricticidad del Buffer VBV"
-AMF.H264.VBVBuffer.Size="Tamaño de buffer VBV"
-AMF.H264.VBVBuffer.Fullness="Amplitud del Buffer VBV"
-AMF.H264.FillerData="Datos de relleno"
-AMF.H264.FrameSkipping="Omisión de fotogramas"
-AMF.H264.EnforceHRDCompatibility="Forzar compatibilidad con HRD"
-AMF.H264.MaximumAccessUnitSize="Tamaño máximo de la unidad de acceso"
-AMF.H264.KeyframeInterval="Intervalo de fotogramas clave"
-AMF.H264.IDRPeriod="Periodo IDR"
-AMF.H264.HeaderInsertionSpacing="Espaciado de inserción de cabeceras (Frames)"
-AMF.H264.BPicture.Pattern="Patron de B-Pictures"
-AMF.H264.BPicture.Reference="B-Pictures de referencia"
-AMF.H264.DeblockingFilter="Filtro de eliminación de bloques"
-AMF.H264.SlicesPerFrame="Porciones por fotograma"
-AMF.H264.IntraRefreshNumMBsPerSlot="Numero de macrobloques intra-refresh por Slot"
-AMF.H264.ScanType="Tipo de escaneo"
-AMF.H264.ScanType.Progressive="Progresivo"
-AMF.H264.ScanType.Interlaced="Entrelazado"
-AMF.H264.QualityPreset="Calidad del perfil"
-AMF.H264.QualityPreset.Speed="Velocidad"
-AMF.H264.QualityPreset.Balanced="Equilibrado"
-AMF.H264.QualityPreset.Quality="Calidad"
-AMF.H264.MotionEstimation="Estimación de movimiento"
-AMF.H264.MotionEstimation.Description="Estimación de movimiento permite al codificador reducir el flujo de datos necesario estimando de donde vienen los pixeles."
-AMF.H264.MotionEstimation.None="Ninguno"
-AMF.H264.MotionEstimation.Half="Mitad de Pixel"
-AMF.H264.MotionEstimation.Quarter="Cuarto de Pixel"
-AMF.H264.MotionEstimation.Both="Mitad y cuarto de Pixel"
-AMF.H264.CABAC="Codificación adaptativa según el contexto binario aritmético (CABAC)"
-AMF.H264.CABAC.Description="Usar CABAC (Codificación aritmética binaria adaptable al contexto) en vez de CALV.\nNo afecta a la calidad pero ayuda en la compresión. De media, podemos esperar un 5% mejor compersión."
-AMF.H264.MemoryType="Tipo de memoria"
-AMF.H264.SurfaceFormat="Formato de la superficie"
-AMF.H264.View="Modo de Vista"
-AMF.H264.View.Description="Que propiedades deben ser visibles. No recibirás soporte si usas el modo de vista 'Experto' o 'Maestro'."
-AMF.H264.View.Basic="Básico"
-AMF.H264.View.Advanced="Avanzado"
-AMF.H264.View.Expert="Experto"
-AMF.H264.View.Master="Maestro"
-AMF.H264.UnlockProperties="Desbloquear propiedades"
-AMF.H264.UnlockProperties.Description="Desbloquea ciertas propiedades a su maxima capacidad en lugar de limitarlas de forma parcial."
-AMF.H264.Debug="Depurar"
-AMF.H264.Debug.Description="Habilita el registro de información de depuración adicional, debe ser activado cuando necesites ayuda con este codificador."
-AMF.Util.Default="Por defecto"
-AMF.Util.Automatic="Automático"
-AMF.Util.Manual="Manual"
-AMF.Util.Toggle.Disabled="Deshabilitado"
-AMF.Util.Toggle.Enabled="Habilitado"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/eu-ES.ini Deleted

@@ -1,75 +0,0 @@
-AMF.H264.Preset="Aurrezarrita"
-AMF.H264.Preset.Recording="Grabatzen"
-AMF.H264.Preset.HighQuality="Kalitate handia"
-AMF.H264.Preset.Indistinguishable="Sumaezina"
-AMF.H264.Preset.Lossless="Galerarik gabe"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Erabilpena"
-AMF.H264.Usage.Description="AMFrentzat zer erabilerak aukeratu behar dira:\n- 'Transcoding' oro har proposatzen da transmisiorako (gomendatua),\n- 'Ultra Low Latency' latentzia oso baxuko kodetzerako,\n- 'Low Latency' aurrekoaren antzekoa da latentzia apur bat handiagoarekin.\nStreaming bakarrik onartzen du 'Transcoding', gainerako balio guztiak erabili daitezke grabaziorako."
-AMF.H264.Usage.Transcoding="Kodeketa"
-AMF.H264.Usage.UltraLowLatency="Latentzia oso txikia"
-AMF.H264.Usage.LowLatency="Latentzia txikia"
-AMF.H264.Profile="Profila"
-AMF.H264.Profile.Description="Zein H.264 profila erabili kodetzeko:\n- 'Baseline' dauka soporterik zabalena,\n- 'Main' gailuen %95ak onartzen du (gomendatua),\n- 'High' bakarrik gama handiko gailuek onartzen dute."
-AMF.H264.ProfileLevel="Profilaren maila"
-AMF.H264.ProfileLevel.Description="H.264 profilaren zein maila erabili behar da kodetzeko:\n- 'Automatic' automatikoki kalkulatzen du emandako abiadura eta fotogramen tamainarako egokiena,\n- '4.1'-ek onartzen du 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2'-k onartzen du 1920x1080 60FPS, 1280x720 120FPS\n- '5.0'-k onartzen du 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1'-k onartzen du 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2'-k onartzen du 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Gehienezko LTR fotogramak"
-AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Fotogramak aukera ematen dio kodegailuari sekuentzia baten hainbat fotograma erreferente moduan markatzeko.\nHonek kalitatean eragin positiboa izan dezake B-Pictures onartzen ez direnean.\nLTR Fotogramak ezin dira B-Pictures-ekin erabili eta kodegailuak B-Pictures-ak desgaituko ditu hauek erabiltzean."
-AMF.H264.RateControlMethod="Emaria kontrolatzeko metodoa"
-AMF.H264.RateControlMethod.CQP="Konstantea QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Bit emari konstantea (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Bit emari aldakorra (gailur mugatuak) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Bit emari aldakorra (Latentzia mugatua) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Bit emari helburua"
-AMF.H264.Bitrate.Peak="Gehienezko gailurra"
-AMF.H264.QP.Minimum="Gutxieneko QP"
-AMF.H264.QP.Maximum="Gehienezko QP"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="B-Picture Delta QP erreferentzia"
-AMF.H264.VBVBuffer="VBV bufferra"
-AMF.H264.VBVBuffer.Strictness="VBV bufferraren zorroztasuna"
-AMF.H264.VBVBuffer.Size="VBV bufferraren tamaina"
-AMF.H264.VBVBuffer.Fullness="VBV bufferraren betetasuna"
-AMF.H264.FillerData="Datu betegarria"
-AMF.H264.FrameSkipping="Fotogramen saltoa"
-AMF.H264.EnforceHRDCompatibility="Behartu HRD bateragarritasuna"
-AMF.H264.MaximumAccessUnitSize="Sarbide unitatearen gehienezko tamaina"
-AMF.H264.KeyframeInterval="Gako fotogramen tartea"
-AMF.H264.IDRPeriod="IDR periodoa"
-AMF.H264.HeaderInsertionSpacing="Goiburuak txertatzeko tartea"
-AMF.H264.BPicture.Pattern="B-Picture eredua"
-AMF.H264.BPicture.Reference="B-Picture erreferentzia"
-AMF.H264.DeblockingFilter="Desblokeoko iragazkia"
-AMF.H264.SlicesPerFrame="Zatiak fotogramako"
-AMF.H264.IntraRefreshNumMBsPerSlot="Makroblokeen barne freskatze kopura erreteneko"
-AMF.H264.ScanType="Eskaneatze mota"
-AMF.H264.ScanType.Progressive="Progresiboa"
-AMF.H264.ScanType.Interlaced="Gurutzelarkatua"
-AMF.H264.QualityPreset="Aurrezarritako kalitatea"
-AMF.H264.QualityPreset.Speed="Abiadura"
-AMF.H264.QualityPreset.Balanced="Orekatua"
-AMF.H264.QualityPreset.Quality="Kalitatea"
-AMF.H264.MotionEstimation="Mugimenduaren estimazioa"
-AMF.H264.MotionEstimation.None="Ezer ez"
-AMF.H264.MotionEstimation.Half="Pixel erdia"
-AMF.H264.MotionEstimation.Quarter="Pixel laurdena"
-AMF.H264.MotionEstimation.Both="Pixel erdia eta laurdena"
-AMF.H264.CABAC="Testuinguru moldakorreko kodeketa bitar aritmetikoa (CABAC)"
-AMF.H264.MemoryType="Memoria mota"
-AMF.H264.SurfaceFormat="Gainazalaren formatua"
-AMF.H264.View="Ikuspegia"
-AMF.H264.View.Basic="Oinarrizkoa"
-AMF.H264.View.Advanced="Aurreratua"
-AMF.H264.View.Expert="Aditu"
-AMF.H264.View.Master="Maixu"
-AMF.H264.UnlockProperties="Desblokeatu propietateak"
-AMF.H264.Debug="Garbiketa"
-AMF.Util.Default="Lehenetsia"
-AMF.Util.Automatic="Automatikoa"
-AMF.Util.Manual="Eskuz"
-AMF.Util.Toggle.Disabled="Ezgaituta"
-AMF.Util.Toggle.Enabled="Gaituta"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/fi-FI.ini Deleted

@@ -1,59 +0,0 @@
-AMF.H264.Preset="Esiasetus"
-AMF.H264.Preset.Recording="Tallennus"
-AMF.H264.Preset.HighQuality="Korkea laatu"
-AMF.H264.Preset.Indistinguishable="Erottamaton"
-AMF.H264.Preset.Lossless="Häviötön"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Käyttö"
-AMF.H264.Usage.Transcoding="Transkoodaus"
-AMF.H264.Usage.UltraLowLatency="Erittäin alhainen latenssi"
-AMF.H264.Usage.LowLatency="Alhainen latenssi"
-AMF.H264.Profile="Profiili"
-AMF.H264.ProfileLevel="Profiilin taso"
-AMF.H264.RateControlMethod="Rate Control -tapa"
-AMF.H264.RateControlMethod.CQP="Pysyvä QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Jatkuva bitrate (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Vaihteleva bitrate (Piikkiin sidottu) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Vaihteleva bitrate (Latenssiin sidottu) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Bitrate-tavoite"
-AMF.H264.Bitrate.Peak="Bitrate-piikki"
-AMF.H264.QP.Minimum="Minimi QP"
-AMF.H264.QP.Maximum="Maksimi QP"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
-AMF.H264.VBVBuffer="VBV-puskuri"
-AMF.H264.VBVBuffer.Size="VBV-puskurin koko"
-AMF.H264.FillerData="Täyttödata"
-AMF.H264.FrameSkipping="Ruudun ohitus"
-AMF.H264.EnforceHRDCompatibility="Pakota HRD-yhteensopivuus"
-AMF.H264.BPicture.Pattern="B-Picture Pattern"
-AMF.H264.BPicture.Reference="B-Picture Reference"
-AMF.H264.DeblockingFilter="Deblocking filtteri"
-AMF.H264.ScanType="Skannaustyyppi"
-AMF.H264.ScanType.Progressive="Progressiivinen"
-AMF.H264.ScanType.Interlaced="Lomitettu"
-AMF.H264.QualityPreset="Laatuasetus"
-AMF.H264.QualityPreset.Speed="Nopeus"
-AMF.H264.QualityPreset.Balanced="Tasapainotettu"
-AMF.H264.QualityPreset.Quality="Laatu"
-AMF.H264.MotionEstimation="Liikkeen ennakointi"
-AMF.H264.MotionEstimation.None="Ei mitään"
-AMF.H264.CABAC="Context Adaptive Binary Arithmetic Coding (CABAC)"
-AMF.H264.MemoryType="Memory Type"
-AMF.H264.SurfaceFormat="Surface Format"
-AMF.H264.View="Näyttötila"
-AMF.H264.View.Basic="Yksinkertainen"
-AMF.H264.View.Advanced="Kehittynyt"
-AMF.H264.View.Expert="Expertti"
-AMF.H264.View.Master="Jumalallinen"
-AMF.H264.UnlockProperties="Avaa ominaisuudet"
-AMF.H264.Debug="Debug"
-AMF.Util.Default="Oletusarvo"
-AMF.Util.Automatic="Automaattinen"
-AMF.Util.Manual="Manuaalinen"
-AMF.Util.Toggle.Disabled="Pois käytöstä"
-AMF.Util.Toggle.Enabled="Käytössä"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/fr-FR.ini Deleted

@@ -1,63 +0,0 @@
-AMF.H264.Usage.Transcoding="Transcodage"
-AMF.H264.Usage.UltraLowLatency="Très faible latence"
-AMF.H264.Usage.LowLatency="Faible latence"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Niveau de profil"
-AMF.H264.ProfileLevel.Description="Quel niveau de profil H.264 utiliser pour l'encodage :\n- \"Automatique\" laisse l'encodeur déterminer le meilleur profil en fonction de la résolution d'image et du nombre d'images par seconde.\n- \"4.1\" supporte les formats suivants : 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- \"4.2\" supporte les formats suivants : 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- \"5.0\" supporte les formats suivants : 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- \"5.1\" supporte les formats suivants : 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- \"5.2\" supporte les formats suivants : 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Maximum de trames LTR"
-AMF.H264.RateControlMethod="Méthode de contrôle du débit"
-AMF.H264.RateControlMethod.CQP="QP constant (CQP)"
-AMF.H264.RateControlMethod.CBR="Débit constant (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Débit Variable (maximum) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Débit Variable (latence limitée) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Débit cible"
-AMF.H264.Bitrate.Peak="Débit maximal"
-AMF.H264.QP.Minimum="QP minimal"
-AMF.H264.QP.Maximum="QP maximal"
-AMF.H264.QP.IFrame="QP I-Frame"
-AMF.H264.QP.PFrame="QP P-Frame"
-AMF.H264.QP.BFrame="QP B-Frame"
-AMF.H264.QP.BPictureDelta="QP B-Image Delta"
-AMF.H264.QP.ReferenceBPictureDelta="Delta QP de l'image B de référence"
-AMF.H264.VBVBuffer="Tampon VBV"
-AMF.H264.VBVBuffer.Strictness="Respect du tampon VBV"
-AMF.H264.VBVBuffer.Size="Taille du tampon VBV"
-AMF.H264.VBVBuffer.Fullness="Remplissage du tampon VBV"
-AMF.H264.FillerData="Données de remplissage"
-AMF.H264.FrameSkipping="Saut d'images"
-AMF.H264.EnforceHRDCompatibility="Appliquer la compatibilité avec l'HRD"
-AMF.H264.MaximumAccessUnitSize="Taille max. d'une Access Unit"
-AMF.H264.KeyframeInterval="Intervalle d'images-clé"
-AMF.H264.IDRPeriod="Périodicité des trames IDR"
-AMF.H264.HeaderInsertionSpacing="Intervalle d'insertion de l'en-tête de stream"
-AMF.H264.BPicture.Pattern="Modèle d'image B"
-AMF.H264.BPicture.Reference="Référence d'image B"
-AMF.H264.DeblockingFilter="Filtre de dégroupage"
-AMF.H264.SlicesPerFrame="Tranches par image"
-AMF.H264.ScanType="Balayage"
-AMF.H264.ScanType.Progressive="Progressif"
-AMF.H264.ScanType.Interlaced="Entrelacé"
-AMF.H264.QualityPreset="Préréglages de qualité"
-AMF.H264.QualityPreset.Speed="Vitesse"
-AMF.H264.QualityPreset.Balanced="Equilibré"
-AMF.H264.QualityPreset.Quality="Qualité"
-AMF.H264.MotionEstimation="Estimation de mouvement"
-AMF.H264.MotionEstimation.None="Aucun"
-AMF.H264.MotionEstimation.Half="Demi-pixel"
-AMF.H264.MotionEstimation.Quarter="Quart de pixel"
-AMF.H264.MotionEstimation.Both="Demi-pixel & quart de pixel"
-AMF.H264.CABAC="Codage adaptif (CABAC)"
-AMF.H264.MemoryType="Type de mémoire"
-AMF.H264.SurfaceFormat="Format de la surface"
-AMF.H264.View="Mode de visualisation"
-AMF.H264.View.Basic="Basique"
-AMF.H264.View.Advanced="Avancé"
-AMF.H264.View.Expert="Expert"
-AMF.H264.View.Master="Maître"
-AMF.H264.UnlockProperties="Débloquer les propriétés"
-AMF.H264.Debug="Débogage"
-AMF.Util.Default="Défaut"
-AMF.Util.Automatic="Automatique"
-AMF.Util.Manual="Manuel"
-AMF.Util.Toggle.Disabled="Désactivé"
-AMF.Util.Toggle.Enabled="Activé"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/hr-HR.ini Deleted

@@ -1,39 +0,0 @@
-AMF.H264.Usage.Transcoding="Transkodiranje"
-AMF.H264.Usage.UltraLowLatency="Ultra nisko kašnjenje"
-AMF.H264.Usage.LowLatency="Nisko kašnjenje"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Nivo profila"
-AMF.H264.RateControlMethod="Metoda kontrole protoka"
-AMF.H264.RateControlMethod.CQP="Konstantan kvalitet (CQP)"
-AMF.H264.RateControlMethod.CBR="Konstantan protok (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Promenjivi protok (sa gornjom granicom) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Promenjivi protok (sa granicom kašnjenja) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Ciljani protok"
-AMF.H264.Bitrate.Peak="Granica protoka"
-AMF.H264.QP.Minimum="Minimalni QP"
-AMF.H264.QP.Maximum="Maksimalni QP"
-AMF.H264.QP.IFrame="I-Frejm QP"
-AMF.H264.QP.PFrame="P-Frejm QP"
-AMF.H264.QP.BFrame="B-Frejm QP"
-AMF.H264.QP.BPictureDelta="B-Promena slike QP"
-AMF.H264.QP.ReferenceBPictureDelta="Referenca B-Promena slike QP"
-AMF.H264.FillerData="Data za popunjavanje"
-AMF.H264.FrameSkipping="Preskakanje frejmova"
-AMF.H264.EnforceHRDCompatibility="Prisilna HRD kompatibilnost"
-AMF.H264.BPicture.Pattern="B-Šablonska slika"
-AMF.H264.BPicture.Reference="B-Referentna slika"
-AMF.H264.DeblockingFilter="Odblokirajući filter"
-AMF.H264.ScanType="Vrsta skeniranja"
-AMF.H264.ScanType.Progressive="Progresivno"
-AMF.H264.ScanType.Interlaced="Isprekidano"
-AMF.H264.QualityPreset="Šablon kvaliteta"
-AMF.H264.QualityPreset.Speed="Brzina"
-AMF.H264.QualityPreset.Balanced="Izbalansirano"
-AMF.H264.QualityPreset.Quality="Kvalitet"
-AMF.H264.CABAC="Binarno aritmetičko kodiranje prilagodljivo sadržaju (CABAC)"
-AMF.H264.MemoryType="Vrsta memorije"
-AMF.H264.SurfaceFormat="Format površine"
-AMF.Util.Default="Podrazumevano"
-AMF.Util.Automatic="Automatski"
-AMF.Util.Toggle.Disabled="Onemogućeno"
-AMF.Util.Toggle.Enabled="Omogućeno"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/hu-HU.ini Deleted

@@ -1,67 +0,0 @@
-AMF.H264.Preset="Készlet"
-AMF.H264.Preset.Recording="Felvétel"
-AMF.H264.Preset.HighQuality="Kiváló minőség"
-AMF.H264.Preset.Indistinguishable="Megkülönböztethetetlen"
-AMF.H264.Preset.Lossless="Veszteségmentes"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Használat"
-AMF.H264.Usage.Transcoding="Transzkódolás"
-AMF.H264.Usage.UltraLowLatency="Nagyon alacsony késleltesésű"
-AMF.H264.Usage.LowLatency="Alacsony késleltetésű"
-AMF.H264.Profile="Enkóder profil"
-AMF.H264.ProfileLevel="Profil szint"
-AMF.H264.MaximumLTRFrames="Maximális LTR képkocka"
-AMF.H264.RateControlMethod="Bitráta vezérlés"
-AMF.H264.RateControlMethod.CQP="Erőltetett QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Konstans bitráta (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Változó bitráta (Csúcsértéket betartva) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Változó bitráta (Késleltetés kényszerítése) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Bitráta (Bitben)"
-AMF.H264.Bitrate.Peak="Csúcs bitráta (Bitben)"
-AMF.H264.QP.Minimum="Minimum QP"
-AMF.H264.QP.Maximum="Maximum QP"
-AMF.H264.QP.IFrame="I-Képkocka QP"
-AMF.H264.QP.PFrame="P-Képkocka QP"
-AMF.H264.QP.BFrame="B-Képkocka QP"
-AMF.H264.QP.BPictureDelta="B-Képkocka Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="Referencia B-képkocka Delta QP"
-AMF.H264.VBVBuffer="VBV puffer"
-AMF.H264.VBVBuffer.Strictness="VBV Puffer kötöttség"
-AMF.H264.VBVBuffer.Size="VBV pufferméret"
-AMF.H264.VBVBuffer.Fullness="VBV puffer telítettség"
-AMF.H264.FillerData="Filler adat"
-AMF.H264.FrameSkipping="Képkocka kihagyás"
-AMF.H264.EnforceHRDCompatibility="HRD Kompatibilitás kényszerítése"
-AMF.H264.KeyframeInterval="Kulcsképkocka időköze"
-AMF.H264.IDRPeriod="IDR időköz"
-AMF.H264.BPicture.Pattern="B-képkockák száma"
-AMF.H264.BPicture.Reference="B-képkocka referencia"
-AMF.H264.DeblockingFilter="Deblocking Filter"
-AMF.H264.SlicesPerFrame="Szeletelés képkockánként"
-AMF.H264.ScanType="Rögzítés módja"
-AMF.H264.ScanType.Progressive="Progreszív"
-AMF.H264.ScanType.Interlaced="Interlaced (Kísérleti)"
-AMF.H264.QualityPreset="Minőségi profil"
-AMF.H264.QualityPreset.Speed="Gyors"
-AMF.H264.QualityPreset.Balanced="Kiegyenlített"
-AMF.H264.QualityPreset.Quality="Minőségi"
-AMF.H264.MotionEstimation="Mozgásbecslés"
-AMF.H264.MotionEstimation.None="Semmi"
-AMF.H264.MotionEstimation.Half="Fél-pixel"
-AMF.H264.MotionEstimation.Quarter="Negyed-pixel"
-AMF.H264.MotionEstimation.Both="Fél-&negyed-pixel"
-AMF.H264.CABAC="Kontextus adaptív bináris aritmetikus kódolás (CABAC)"
-AMF.H264.MemoryType="Memória típus"
-AMF.H264.SurfaceFormat="Felület formátum"
-AMF.H264.View="Nézet mód"
-AMF.H264.View.Basic="Alap"
-AMF.H264.View.Advanced="Haladó"
-AMF.H264.View.Expert="Szakértő"
-AMF.H264.View.Master="Mester"
-AMF.H264.Debug="Hibakeresés"
-AMF.Util.Default="Alapértelmezett"
-AMF.Util.Automatic="Automatikus"
-AMF.Util.Manual="Manuális"
-AMF.Util.Toggle.Disabled="Letiltva"
-AMF.Util.Toggle.Enabled="Engedélyezve"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/it-IT.ini Deleted

@@ -1,64 +0,0 @@
-AMF.H264.Usage.Transcoding="Transcodifica"
-AMF.H264.Usage.UltraLowLatency="Latenza ultra bassa"
-AMF.H264.Usage.LowLatency="Bassa latenza"
-AMF.H264.Profile="Profilo"
-AMF.H264.ProfileLevel="Livello profilo"
-AMF.H264.ProfileLevel.Description="Quale livello di profilo H.264 usare per l'encoding:\n- 'Automatico' calcola il miglior livello per il dato Frame Rate e Frame Size,\n- '4.1' supporta 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' supporta 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' supporta 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' supporta 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' supporta 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Fotogrammi LTR Massimi"
-AMF.H264.RateControlMethod="Metodo di controllo della frequenza"
-AMF.H264.RateControlMethod.CQP="QP Costante (QPC)"
-AMF.H264.RateControlMethod.CBR="Bitrate costante (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Bitrate Variabile (Peak Constrained) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Bitrate variabile (latenza vincolata) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Bitrate di destinazione"
-AMF.H264.Bitrate.Peak="Picco Bitrate"
-AMF.H264.QP.Minimum="QP Minimo"
-AMF.H264.QP.Maximum="QP Massimo"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="Riferimento B-Picture Delta QP"
-AMF.H264.VBVBuffer="Buffer VBV"
-AMF.H264.VBVBuffer.Strictness="Strettezza Buffer VBV"
-AMF.H264.VBVBuffer.Size="Dimensione Buffer VBV"
-AMF.H264.VBVBuffer.Fullness="Larghezza Buffer VBV"
-AMF.H264.FillerData="Dati di riempimento"
-AMF.H264.FrameSkipping="Frame Skipping"
-AMF.H264.EnforceHRDCompatibility="Forza compatibilità HRD"
-AMF.H264.MaximumAccessUnitSize="Massima dimensione di unità d'accesso"
-AMF.H264.KeyframeInterval="Intervallo Keyframe"
-AMF.H264.IDRPeriod="Periodo IDR"
-AMF.H264.HeaderInsertionSpacing="Spaziatura di inserimento di intestazione"
-AMF.H264.BPicture.Pattern="Modello B-Picture"
-AMF.H264.BPicture.Reference="Riferimento B-Picture"
-AMF.H264.DeblockingFilter="Filtro di deblock"
-AMF.H264.SlicesPerFrame="Slices Per Frame"
-AMF.H264.IntraRefreshNumMBsPerSlot="Intra-Refresh Number of Macroblocks Per Slot"
-AMF.H264.ScanType="Tipo di scansione"
-AMF.H264.ScanType.Progressive="Progressivo"
-AMF.H264.ScanType.Interlaced="Interlacciato"
-AMF.H264.QualityPreset="Qualità Preset"
-AMF.H264.QualityPreset.Speed="Velocità"
-AMF.H264.QualityPreset.Balanced="Bilanciato"
-AMF.H264.QualityPreset.Quality="Qualità"
-AMF.H264.MotionEstimation="Stima Movimento"
-AMF.H264.MotionEstimation.None="Nessuno"
-AMF.H264.MotionEstimation.Half="Metà-Pixel"
-AMF.H264.MotionEstimation.Quarter="Quarto-Pixel"
-AMF.H264.MotionEstimation.Both="Meta- & Quarto-Pixel"
-AMF.H264.CABAC="CABAC"
-AMF.H264.MemoryType="Tipo Memoria"
-AMF.H264.SurfaceFormat="Formato di superficie"
-AMF.H264.View="Modalità di visualizzazione"
-AMF.H264.View.Basic="Basico"
-AMF.H264.View.Advanced="Avanzate"
-AMF.H264.View.Expert="Esperto"
-AMF.H264.View.Master="Master"
-AMF.H264.UnlockProperties="Sblocca proprietà"
-AMF.H264.Debug="Debug"
-AMF.Util.Default="Predefinito"
-AMF.Util.Automatic="Automatico"
-AMF.Util.Manual="Manuale"
-AMF.Util.Toggle.Disabled="Disabilitato"
-AMF.Util.Toggle.Enabled="Attivo"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/ja-JP.ini Deleted

@@ -1,88 +0,0 @@
-AMF.H264.Preset="プリセット"
-AMF.H264.Preset.Recording="録画中"
-AMF.H264.Preset.HighQuality="高品質"
-AMF.H264.Preset.Indistinguishable="区別不能品質"
-AMF.H264.Preset.Lossless="無損失品質"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="用途"
-AMF.H264.Usage.Transcoding="変換"
-AMF.H264.Usage.UltraLowLatency="超低遅延"
-AMF.H264.Usage.LowLatency="低遅延"
-AMF.H264.Profile="プロファイル"
-AMF.H264.Profile.Description="エンコードに使用する H.264 プロファイル:\n- 'Baseline' は最も広くサポートされており、\n- 'Main' は95%のデバイスでサポートされており (推奨)、\n- 'High' は高性能デバイスのみでサポートされている。"
-AMF.H264.ProfileLevel="プロファイルレベル"
-AMF.H264.ProfileLevel.Description="エンコードに使用する H.264 プロファイルレベル:\n- '自動' は与えられたフレームレートと解像度に対して最適なプロファイルレベルを計算し、\n- '4.1' は 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS をサポートし、\n- '4.2' は 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS をサポートし、\n- '5.0' は 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS をサポートし、\n- '5.1' は 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS をサポートし、\n- '5.2' は 3840x2160 60FPS、1920 x 1080 172FPS, 1280 x 720 172FPS, 960 x 540 172FPS をサポートします。"
-AMF.H264.MaximumLTRFrames="最大 LTR フレーム"
-AMF.H264.RateControlMethod="レート制御方式"
-AMF.H264.RateControlMethod.CQP="固定QP (CQP)"
-AMF.H264.RateControlMethod.CBR="固定ビットレート (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="可変ビットレート (ピーク制約) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="可変ビットレート (遅延制約) (VBR_LAT)"
-AMF.H264.Bitrate.Target="目標ビットレート"
-AMF.H264.Bitrate.Target.Description="全体的なシーケンスで達成しようとするビットレート。\nCBR と VBR_LAT で使用されます。"
-AMF.H264.Bitrate.Peak="最大ビットレート"
-AMF.H264.Bitrate.Peak.Description="全体的なシーケンスでピークを最大にしようとするビットレート。\nVBR と VBR_LAT で使用されます。"
-AMF.H264.QP.Minimum="最小QP"
-AMF.H264.QP.Minimum.Description="フレームで使用する最小QP値。\nCBR, VBR および VBR_LAT で使用される。"
-AMF.H264.QP.Maximum="最大QP"
-AMF.H264.QP.Maximum.Description="フレームで使用する最大QP値。\nCBR, VBR および VBR_LAT で使用される。"
-AMF.H264.QP.IFrame="I-フレーム QP"
-AMF.H264.QP.PFrame="P-フレーム QP"
-AMF.H264.QP.BFrame="B-フレーム QP"
-AMF.H264.QP.BPictureDelta="B-画像デルタ QP"
-AMF.H264.QP.BPictureDelta.Description="最後の非参照B-画像のデルタQPです。"
-AMF.H264.QP.ReferenceBPictureDelta="B-画像参照のデルタQP"
-AMF.H264.QP.ReferenceBPictureDelta.Description="最後の参照B-画像のデルタQPです。"
-AMF.H264.VBVBuffer="VBV バッファ"
-AMF.H264.VBVBuffer.Strictness="VBV バッファ厳密性"
-AMF.H264.VBVBuffer.Size="VBV バッファサイズ"
-AMF.H264.VBVBuffer.Fullness="VBV バッファ充満"
-AMF.H264.FillerData="フィラーデータ"
-AMF.H264.FrameSkipping="フレームスキップ"
-AMF.H264.EnforceHRDCompatibility="HRD 互換性を強制"
-AMF.H264.MaximumAccessUnitSize="最大アクセスユニットサイズ"
-AMF.H264.KeyframeInterval="キーフレーム間隔"
-AMF.H264.KeyframeInterval.Description="ドロップ不可能なフレーム間の秒数。\nGOPのサイズも制御します。"
-AMF.H264.IDRPeriod="IDR 周期"
-AMF.H264.IDRPeriod.Description="ドロップ不可能なフレーム間のフレーム数。\nGOPのサイズも制御します。"
-AMF.H264.HeaderInsertionSpacing="ヘッダー挿入間隔"
-AMF.H264.BPicture.Pattern="B-画像パターン"
-AMF.H264.BPicture.Reference="B-画像参照"
-AMF.H264.DeblockingFilter="デブロックフィルタ"
-AMF.H264.DeblockingFilter.Description="デコーダがエンコードされたストリームに対してデブロックフィルタの使用を許可されているかのフラグを設定します。"
-AMF.H264.SlicesPerFrame="フレームあたりのスライス"
-AMF.H264.IntraRefreshNumMBsPerSlot="スロットごとのマクロブロックのイントラリフレッシュ数"
-AMF.H264.ScanType="スキャンの種類"
-AMF.H264.ScanType.Description="どのスキャン方法が使用されるか、'プログレッシブ'を常にこのままにしておきます。"
-AMF.H264.ScanType.Progressive="プログレッシブ"
-AMF.H264.ScanType.Interlaced="インターレース"
-AMF.H264.QualityPreset="品質プリセット"
-AMF.H264.QualityPreset.Speed="速度"
-AMF.H264.QualityPreset.Balanced="バランス"
-AMF.H264.QualityPreset.Quality="品質"
-AMF.H264.MotionEstimation="動き推定"
-AMF.H264.MotionEstimation.Description="動き推定はピクセルがどこに移動したかを推定することによってエンコーダが必要とするビットレートを削減します。"
-AMF.H264.MotionEstimation.None="未設定"
-AMF.H264.MotionEstimation.Half="1/2ピクセル"
-AMF.H264.MotionEstimation.Quarter="1/4ピクセル"
-AMF.H264.MotionEstimation.Both="ハーフ & クォーターピクセル"
-AMF.H264.CABAC="コンテキスト適応型のバイナリ演算コーディング (CABAC)"
-AMF.H264.MemoryType="メモリの種類"
-AMF.H264.Device="デバイス"
-AMF.H264.UseOpenCL="OpenCL を使用する"
-AMF.H264.SurfaceFormat="カラーフォーマット"
-AMF.H264.View="表示モード"
-AMF.H264.View.Description="どのプロパティが表示されるか。  'エキスパート' または 'マスター' の表示モードを使用する場合はサポートを受けられません。"
-AMF.H264.View.Basic="基本"
-AMF.H264.View.Advanced="詳細設定"
-AMF.H264.View.Expert="エキスパート"
-AMF.H264.View.Master="マスター"
-AMF.H264.UnlockProperties="プロパティのロック解除"
-AMF.H264.Debug="デバッグ"
-AMF.H264.Debug.Description="追加のデバッグログ出力を有効にし、これはこのエンコーダでサポートが必要なときにアクティブにする必要があります。"
-AMF.Util.Default="既定値"
-AMF.Util.Automatic="自動"
-AMF.Util.Manual="手動"
-AMF.Util.Toggle.Disabled="無効"
-AMF.Util.Toggle.Enabled="有効"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/ko-KR.ini Deleted

@@ -1,107 +0,0 @@
-AMF.H264.Preset="사전 설정"
-AMF.H264.Preset.Recording="녹화"
-AMF.H264.Preset.HighQuality="우수한 품질"
-AMF.H264.Preset.Indistinguishable="무손실과 거의 구분 불가"
-AMF.H264.Preset.Lossless="무손실"
-AMF.H264.Preset.Twitch="트위치"
-AMF.H264.Preset.YouTube="유튜브"
-AMF.H264.Usage="용도"
-AMF.H264.Usage.Description="용도에 따라 AMF을 조율합니다:\n- '트랜스코딩'은 일반적인 용도에 적합한 설정입니다(추천).\n- '매우 낮은 지연시간'은 아주 낮은 인코딩 레이턴시를 의미합니다.\n- '낮은 지연시간'은 그 수준이 조금 더 높습니다.\n방송 목적으로는 '트랜스코딩'만 지원됩니다. 모든 다른 설정값은 녹화 용도에만 사용됩니다."
-AMF.H264.Usage.Transcoding="트랜스코딩"
-AMF.H264.Usage.UltraLowLatency="매우 낮은 지연 시간"
-AMF.H264.Usage.LowLatency="낮은 지연 시간"
-AMF.H264.Profile="사전설정"
-AMF.H264.Profile.Description="인코딩에 사용하는 H.264프로파일을 설정합니다.\n- 'Baseline'은 가장 많은 환경 및 기기에서 지원가능한 수준입니다.\n- 'Main'은 시장에서 95%의 기기가 지원합니다(추천).\n- 'High'는 고급 기기에만 지원되는 설정입니다."
-AMF.H264.ProfileLevel="프로필 수준"
-AMF.H264.ProfileLevel.Description="인코딩으로 사용할 H.264 프로파일 수준을 지정합니다:\n-'자동'은 설정된 프레임과 그 크기에 맞춰 가장 좋은 수준을 계산합니다,\n-'4.1'은 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS을 지원합니다,\n-'4.2'는 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS을 지원합니다,\n- '5.0'은 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS을 지원합니다,\n- '5.1'은 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS을 지원합니다,\n- '5.2'은 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS을 지원합니다."
-AMF.H264.MaximumLTRFrames="최대 장기참조 프레임"
-AMF.H264.MaximumLTRFrames.Description="장기참조 프레임(LTR)은 인코더가 특정 프레임을 참조 가능하게 만들어 줍니다.\n이 설정은 B-화면 기능이 지원되지 않거나 필요한 경우 품질을 올리는데 도움이 될 수 있습니다.\n장기참조 프레임은 B-화면과 동시에 사용할 수 없습니다."
-AMF.H264.RateControlMethod="속도 제어 방식"
-AMF.H264.RateControlMethod.CQP="고정 QP (CQP)"
-AMF.H264.RateControlMethod.CBR="고정 비트레이트 (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="가변 비트레이트 (최대 비트레이트 제약) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="가변 비트레이트(지연율 제약) (VBR_LAT)"
-AMF.H264.Bitrate.Target="목표 비트레이트"
-AMF.H264.Bitrate.Target.Description="전반적인 영상 장면을 구성하기 위한 비트레이트.\nCBR과 VBR_LAT에 사용됨."
-AMF.H264.Bitrate.Peak="최대 비트레이트"
-AMF.H264.Bitrate.Peak.Description="전반적인 영상 장면을 구성할 때 최대로 사용할 수 있는 비트레이트.\nVBR과 VBR_LAT에 사용."
-AMF.H264.QP.Minimum="최소 QP"
-AMF.H264.QP.Minimum.Description="프레임 하나에 사용하는 최저 QP 값.\n CBR, VBR 그리고 VBR_LAT에 사용됨."
-AMF.H264.QP.Maximum="최대 QP"
-AMF.H264.QP.Maximum.Description="프레임 하나에 사용하는 최대 QP 값.\n CBR, VBR 그리고 VBR_LAT에 사용됨."
-AMF.H264.QP.IFrame="I-프레임 QP"
-AMF.H264.QP.IFrame.Description="I-화면에 사용하는 고정 QP 값.\n 낮음= 더 큰 파일, 더 좋은 품질. 높음 = 더 작은 파일, 더 나쁜 품질.\nI-화면 QP는 P-,B-화면 QP값 수치보다 높아야함.\nCQP에서 사용."
-AMF.H264.QP.PFrame="P-프레임 QP"
-AMF.H264.QP.PFrame.Description="P-화면에 사용하는 고정 QP 값.\n 낮음= 더 큰 파일, 더 좋은 품질. 높음 = 더 작은 파일, 더 나쁜 품질.\nP-화면 QP는 B-화면 QP값 수치보다 같거나 높아야함.\nCQP에서 사용."
-AMF.H264.QP.BFrame="BP-프레임 QP"
-AMF.H264.QP.BFrame.Description="B-화면에 사용하는 고정 QP 값.\n 낮음= 더 큰 파일, 더 좋은 품질. 높음 = 더 작은 파일, 더 나쁜 품질.\nCQP에서 사용."
-AMF.H264.QP.BPictureDelta="B-화면 델타 QP"
-AMF.H264.QP.BPictureDelta.Description="마지막 비참조 B-화면의 델타 QP."
-AMF.H264.QP.ReferenceBPictureDelta="참조 B-화면 델타 QP"
-AMF.H264.QP.ReferenceBPictureDelta.Description="마지막 참조 B-화면의 델타 QP."
-AMF.H264.VBVBuffer="VBV 버퍼"
-AMF.H264.VBVBuffer.Strictness="VBV 버퍼 엄격도"
-AMF.H264.VBVBuffer.Strictness.Description="VBV 버퍼가 어떤 수준으로 제어될지 결정합니다. 100%에는 목표로 정한 비트레이트와 거의 일치하도록 조절하며 0%에서는 제약이 사라집니다."
-AMF.H264.VBVBuffer.Size="VBV 버퍼 크기"
-AMF.H264.VBVBuffer.Size.Description="한 장면의 비트레이트 제어에 사용하는 VBV 버퍼 크기를 의미합니다.\n작은 크기는 지정한 비트레이트 값과 일치하는 결과를 가져오지만 작업에 더 많은 자원을 요구합니다.\n이상적인 (100% 엄격) VBV버퍼 크기는 비트레이트/프레임율입니다."
-AMF.H264.VBVBuffer.Fullness="VBV 버퍼 충만도"
-AMF.H264.VBVBuffer.Fullness.Description="초기 VBV버퍼가 얼마나 충만한지는 오로지 인코딩의 초반에만 영향을 미칩니다."
-AMF.H264.FillerData="채우기 정보"
-AMF.H264.FillerData.Description="채우기 정보는 디코더가 무시하는 빈 혹은 잘못된 데이터입니다.\n만약 이 설정이 활성화되어있고 CBR을 사용할 경우 인코더가 남은 공간을 이 것으로 채워둡니다."
-AMF.H264.FrameSkipping="프레임 생략"
-AMF.H264.FrameSkipping.Description="프레임 생략은 프레임이 아주 유사하거나 작업이 너무 오래 소요할 경우, 인코더가 선택적으로 그것을 생략할 수 있게 합니다.\n이 설정을 활성화하면 파일은 가변 프레임율로 출력이 되며 대다수 편집 소프트웨어는 지원하지 않습니다."
-AMF.H264.EnforceHRDCompatibility="HDR 호환모드 적용"
-AMF.H264.EnforceHRDCompatibility.Description="이론적 기본 디코더 강제는 프레임 하나의 최대 QP값 변화를 제한하는 설정입니다.\n녹화나 방송에는 적합하지 않고 기본 소프트웨어 디코더만 사용 가능한 매우 낡은 장치에서 영상을 재생할 때 사용합니다."
-AMF.H264.MaximumAccessUnitSize="최대 접근 유닛 크기"
-AMF.H264.MaximumAccessUnitSize.Description="NAL 장치에서 단일 접근 유닛의 가장 큰 크기를 결정합니다. 0 값은 인코더가 최적화된 수치를 결정하도록 허용합니다."
-AMF.H264.KeyframeInterval="키프레임 간격"
-AMF.H264.KeyframeInterval.Description="손실이 불가능한 프레임 사이에 얼마나 많은 시간(초)이 필요한지 설정합니다.\n또한 영상(GOP) 크기도 제어합니다."
-AMF.H264.IDRPeriod="IDR 주기"
-AMF.H264.IDRPeriod.Description="손실이 불가능한 프레임 사이에 얼마나 많은 프레임이 필요한지 설정합니다.\n또한 영상(GOP) 크기도 제어합니다."
-AMF.H264.HeaderInsertionSpacing="헤더 삽입 간격"
-AMF.H264.HeaderInsertionSpacing.Description="NAL 헤더 사이에 얼마나 많은 프레임이 필요한지 설정합니다. 0(자동)에서 바꾸는 것은 추천하지 않습니다."
-AMF.H264.BPicture.Pattern="B-화면 양식"
-AMF.H264.BPicture.Reference="B-화면 참조"
-AMF.H264.BPicture.Reference.Description="다른 B-화면뿐만 아니라 P-/I-화면에도 B-화면을 참조할 수 있도록 허용합니다.\n높은 성능이 요구되지만 품질 개선에는 그리 큰 효과가 없습니다."
-AMF.H264.DeblockingFilter="디블록 필터"
-AMF.H264.DeblockingFilter.Description="디코더가 인코딩된 작업에 디블록 필터를 사용할 수 있도록 허용합니다."
-AMF.H264.SlicesPerFrame="조각 당 프레임"
-AMF.H264.SlicesPerFrame.Description="동적 대신 고정식 분할 인코딩을 사용합니다.\n높은 해상도와 초당 프레임 환경에서 도움이 될 수 있습니다. 이 설정으로 동일한 프로파일 수준을 유지하면서 더 많은 데이터를 저장할 수 있습니다. 하지만 품질에 부정적인 영향을 미칠 수 있습니다."
-AMF.H264.IntraRefreshNumMBsPerSlot="슬롯 당 매크로블록의 인트라-리프레시 수"
-AMF.H264.IntraRefreshNumMBsPerSlot.Description="인트라-리프레시 인코딩에서 슬롯마다 얼마나 많은 수의 매크로블록이 필요한지 설정합니다.\n인트라-리프레시 인코딩은 높은 비트레이트를 기반으로 추가 정보를 저장하여 빠른 탐색과 디코딩을 허용합니다.\n방송할 때는 기본으로 두십시오."
-AMF.H264.ScanType="스캔 형식"
-AMF.H264.ScanType.Description="주사 방식을 설정합니다. 항상 '프로그레시브'로 두십시오."
-AMF.H264.ScanType.Progressive="프로그레시브"
-AMF.H264.ScanType.Interlaced="인터레이스"
-AMF.H264.QualityPreset="품질 사전 설정"
-AMF.H264.QualityPreset.Description="AMF 품질을 결정할 때 어떤 수준을 목표로 할지 결정합니다:\n-'속도'는 가장 빠르지만, 품질이 가장 나쁘며,\n- '균형'은 '속도'와 '품질' 사이의 수준을 제공합니다.\n- '품질'은 주어진 비트레이트 내에서 가장 뛰어난 품질을 제공합니다."
-AMF.H264.QualityPreset.Speed="속도"
-AMF.H264.QualityPreset.Balanced="균형"
-AMF.H264.QualityPreset.Quality="품질"
-AMF.H264.MotionEstimation="동작 예측"
-AMF.H264.MotionEstimation.Description="동작 추정은 픽셀의 움직임을 추정하여 필요한 비트레이트를 줄일 수 있게 합니다."
-AMF.H264.MotionEstimation.None="없음"
-AMF.H264.MotionEstimation.Half="1/2 화소"
-AMF.H264.MotionEstimation.Quarter="1/4 화소"
-AMF.H264.MotionEstimation.Both="1/2 & 1/4 화소"
-AMF.H264.CABAC="Context Adaptive Binary Arithmetic Coding (CABAC)"
-AMF.H264.CABAC.Description="CALV대신 CABAC (Context Adaptive Binary Arithmetic Coding)을 사용합니다.\n품질엔 영향을 주지 않지만 압축에 도움이 됩니다. 평균적으로 5% 정도 더 나은 압축률을 보여줍니다."
-AMF.H264.MemoryType="메모리 유형"
-AMF.H264.MemoryType.Description="인코더에 제출하기 전에 얼마나 많은 프레임을 저장할지 설정합니다:\n- '자동'은 후위처리 형식 내에 기억장치가 가용할 수 있는 최댓값을 선택합니다.\n- Host는 시스템 메모리를 사용합니다,\n- DirectX 9은 DirectX 표면을 제출에 사용합니다,\n- DirectX 11은 DirectX 표면을 제출에 사용합니다,\n- OpenGL은 OpenGL 표면을 제출에 사용합니다,\n\n'Host''는 대다수 시스템에서 충분하지만, DirectX는 종종 높은 부하가 일어날 때 도움이 될 수 있습니다."
-AMF.H264.SurfaceFormat="표면 형식"
-AMF.H264.SurfaceFormat.Description="인코딩에 사용할 표면 형식을 설정합니다.\n오로지 NV12만 기본적으로 지원이 되며 다른 형식은 전환 작업이 필요합니다."
-AMF.H264.View="보기 모드"
-AMF.H264.View.Description="어떤 설정을 표시할지 결정합니다. '숙련' 혹은 '달인' 표시 모드에서는 지원을 받을 수 없습니다."
-AMF.H264.View.Basic="기본"
-AMF.H264.View.Advanced="고급"
-AMF.H264.View.Expert="숙련"
-AMF.H264.View.Master="달인"
-AMF.H264.UnlockProperties="속성 잠금해제"
-AMF.H264.UnlockProperties.Description="특정 설정을 부분적이 아닌 전체 범위를 다룰 수 있도록 잠금을 해제합니다."
-AMF.H264.Debug="디버그"
-AMF.H264.Debug.Description="추가적인 디버그 기록을 활성화하여 이 인코더에 대한 지원이 필요할 때 제출하십시오."
-AMF.Util.Default="기본값"
-AMF.Util.Automatic="자동"
-AMF.Util.Manual="수동"
-AMF.Util.Toggle.Disabled="비활성화"
-AMF.Util.Toggle.Enabled="활성화"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/nb-NO.ini Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/nl-NL.ini Deleted

@@ -1,35 +0,0 @@
-AMF.H264.Usage.Transcoding="Transcoding"
-AMF.H264.Usage.UltraLowLatency="Ultra Low Latency"
-AMF.H264.Usage.LowLatency="Low Latency"
-AMF.H264.Profile="Profiel"
-AMF.H264.ProfileLevel="Profielniveau"
-AMF.H264.RateControlMethod="Rate control methode"
-AMF.H264.RateControlMethod.CQP="Constant QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Constant Bitrate (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Peak Constrained) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Latency Constrained) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Doelbitrate"
-AMF.H264.Bitrate.Peak="Maximale bitrate"
-AMF.H264.QP.Minimum="Minimale QP"
-AMF.H264.QP.Maximum="Maximale QP"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.FillerData="Opvuldata"
-AMF.H264.FrameSkipping="Frames overslaan"
-AMF.H264.EnforceHRDCompatibility="Forceer HDR compatibiliteit"
-AMF.H264.BPicture.Pattern="B-Picture patroon"
-AMF.H264.BPicture.Reference="B-Picture referentie"
-AMF.H264.DeblockingFilter="Deblocking Filter"
-AMF.H264.ScanType="Scantype"
-AMF.H264.ScanType.Progressive="Progressive"
-AMF.H264.ScanType.Interlaced="Interlaced"
-AMF.H264.QualityPreset="Kwaliteitsinstelling"
-AMF.H264.QualityPreset.Speed="Snelheid"
-AMF.H264.QualityPreset.Balanced="Gebalanceerd"
-AMF.H264.QualityPreset.Quality="Kwaliteit"
-AMF.H264.CABAC="Context Adaptive Binary Arithmetic Coding (CABAC)"
-AMF.Util.Default="Standaard"
-AMF.Util.Toggle.Disabled="Uitgeschakeld"
-AMF.Util.Toggle.Enabled="Ingeschakeld"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/pl-PL.ini Deleted

@@ -1,47 +0,0 @@
-AMF.H264.Preset="Profil"
-AMF.H264.Preset.Recording="Nagrywanie"
-AMF.H264.Preset.HighQuality="Wysoka jakość"
-AMF.H264.Preset.Indistinguishable="Nie do odróżnienia"
-AMF.H264.Preset.Lossless="Bezstratny"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Sposób użycia"
-AMF.H264.Usage.Transcoding="Konwersja"
-AMF.H264.Usage.UltraLowLatency="Bardzo niskie opóźnienie"
-AMF.H264.Usage.LowLatency="Niskie opóźnienie"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Profil"
-AMF.H264.RateControlMethod="Metoda kontroli przepływności"
-AMF.H264.RateControlMethod.CQP="Stała QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Stała przepływność (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Zmienna przepływność (z ograniczeniem górnym) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Zmienna przepływność (z ograniczeniem opóźnieniem) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Przepływność docelowa"
-AMF.H264.Bitrate.Peak="Przepływność szczytowa"
-AMF.H264.QP.Minimum="Minimalna QP"
-AMF.H264.QP.Maximum="Maksymalna QP"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="Referencyjne B-Picture Delta QP"
-AMF.H264.FillerData="Filler Data"
-AMF.H264.FrameSkipping="Pomijanie klatek"
-AMF.H264.EnforceHRDCompatibility="Wymuszanie zgodności HRD"
-AMF.H264.BPicture.Pattern="Schemat B-Picture"
-AMF.H264.BPicture.Reference="Referencyjny B-Picture"
-AMF.H264.DeblockingFilter="Filtr niwelujacy bloki obrazu"
-AMF.H264.ScanType="Metoda skanowania"
-AMF.H264.ScanType.Progressive="Progresywne"
-AMF.H264.ScanType.Interlaced="Z przeplotem"
-AMF.H264.QualityPreset="Ustawienie jakości"
-AMF.H264.QualityPreset.Speed="Szybkość"
-AMF.H264.QualityPreset.Balanced="Zrównoważone"
-AMF.H264.QualityPreset.Quality="Jakość"
-AMF.H264.CABAC="Kodowanie Context Adaptive Binary Arithmetic Coding (CABAC)"
-AMF.H264.MemoryType="Typ pamięci"
-AMF.H264.SurfaceFormat="Format powierzchni"
-AMF.Util.Default="Domyślne"
-AMF.Util.Automatic="Automatycznie"
-AMF.Util.Toggle.Disabled="Wyłączone"
-AMF.Util.Toggle.Enabled="Włączone"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/ru-RU.ini Deleted

@@ -1,98 +0,0 @@
-AMF.H264.Preset="Предустановка"
-AMF.H264.Preset.Recording="Запись"
-AMF.H264.Preset.HighQuality="Высокое качество"
-AMF.H264.Preset.Indistinguishable="Незаметные потери"
-AMF.H264.Preset.Lossless="Без потерь"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Назначение"
-AMF.H264.Usage.Description="На какой режим использования должен быть настроен AMF:\n- 'Перекодировка' — для перекодировки общего назначения (рекомендуется),\n- 'Очень низкая задержка' — для кодировки с очень низкой задержкой,\n- 'Низкая задержка' похожа на пункт выше, но с немного большей задержкой.\nТрансляции поддерживают только 'перекодировку', все остальные значения могут быть использованы для записи."
-AMF.H264.Usage.Transcoding="Транскодирование"
-AMF.H264.Usage.UltraLowLatency="Очень низкая задержка"
-AMF.H264.Usage.LowLatency="Низкая задержка"
-AMF.H264.Profile="Профиль кодирования"
-AMF.H264.Profile.Description="Какой профиль H.264 следует использовать для кодирования:\n- 'Базовый' поддерживается наибольшим количеством платформ,\n- 'Основной' поддерживается 95% устройств (рекомендуется),\n- 'Высокий' поддерживается только устройствами высокого класса."
-AMF.H264.ProfileLevel="Уровень профиля"
-AMF.H264.ProfileLevel.Description="Какой уровень профиля H.264 использовать для кодирования:\n- 'Автоматически' выбирает наиболее подходящий уровень под выбранную частоту и размер кадра,\n- '4.1' поддерживает 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' поддерживает 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' поддерживает 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' поддерживает 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' поддерживает 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="Максимум LTR-кадров"
-AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Frames - функция позволяющая кодировщику помечать определенные кадры в последовательности как ссылаемые.\nЭта функция может поднять качество, если функция B-Pictrues не поддерживается или не желательна.\nФункция LTR Frames не может использоваться вместе с функцией B-Pictrues и кодировщик отключит функцию B-Pictrues если таковая используется."
-AMF.H264.RateControlMethod="Метод кодирования"
-AMF.H264.RateControlMethod.CQP="CQP: постоянное качество"
-AMF.H264.RateControlMethod.CBR="CBR: постоянный битрейт"
-AMF.H264.RateControlMethod.VBR.Peak="VBR: переменный битрейт (Ограничение пиков)"
-AMF.H264.RateControlMethod.VBR.Latency="VBR: переменный битрейт (Ограничение задержки)"
-AMF.H264.Bitrate.Target="Битрейт"
-AMF.H264.Bitrate.Target.Description="Желаемый для получения битрейт всего потока.\nИспользуется с CBR и VBR_LAT."
-AMF.H264.Bitrate.Peak="Пиковый битрейт"
-AMF.H264.Bitrate.Peak.Description="Битрейт работает на максимально пике в общей последовательности.\nИспользуется VBR и VBR_LAT."
-AMF.H264.QP.Minimum="Минимальное QP"
-AMF.H264.QP.Minimum.Description="Наименьшее значение QP для использования в кадре.\nИспользуется CBR, VBR и VBR_LAT."
-AMF.H264.QP.Maximum="Максимальное QP"
-AMF.H264.QP.Maximum.Description="Наибольшее значение QP для использования в кадре.\nИспользуется CBR, VBR и VBR_LAT."
-AMF.H264.QP.IFrame="I-кадр QP"
-AMF.H264.QP.IFrame.Description="Фиксированное значение QP для использования в I-кадрах.\nМеньше = больше файл, лучше качество. Выше = меньше файл, хуже качество.\nQP у I-кадров должно быть больше или равно QP у P- и B-кадров.\nИспользуется CQP."
-AMF.H264.QP.PFrame="P-кадр QP"
-AMF.H264.QP.PFrame.Description="Фиксированное значение QP для использования в P-кадрах.\nМеньше = больше файл, лучше качество. Выше = меньше файл, хуже качество.\nQP у P-кадров должно быть больше или равно QP у B-кадров.\nИспользуется CQP."
-AMF.H264.QP.BFrame="B-кадр QP"
-AMF.H264.QP.BFrame.Description="Фиксированное значение QP для использования в B-кадрах.\nМеньше = больше файл, лучше качество. Больше = меньше файл, хуже качество.\nИспользуется CQP."
-AMF.H264.QP.BPictureDelta="B-кадры дельта QP"
-AMF.H264.QP.BPictureDelta.Description="Дельта QP до последнего не референсного B-кадра."
-AMF.H264.QP.ReferenceBPictureDelta="Референсные B-кадры дельта QP"
-AMF.H264.QP.ReferenceBPictureDelta.Description="Дельта QP до последнего референсного B-кадра."
-AMF.H264.VBVBuffer="Буфер VBV"
-AMF.H264.VBVBuffer.Strictness="Строгость буфера VBV"
-AMF.H264.VBVBuffer.Strictness.Description="Насколько строго должен быть ограничен буфер VBV: 100% — почти полное соответствие целевому битрейту, 0% — без ограничений."
-AMF.H264.VBVBuffer.Size="Размер буфера VBV"
-AMF.H264.VBVBuffer.Fullness="Заполнение буфера VBV"
-AMF.H264.FillerData="Данные наполнителя"
-AMF.H264.FrameSkipping="Пропуск кадров"
-AMF.H264.EnforceHRDCompatibility="Принудительная HRD совместимость"
-AMF.H264.MaximumAccessUnitSize="Максимальный Размер Блока Доступа"
-AMF.H264.KeyframeInterval="Интервал ключевых кадров"
-AMF.H264.KeyframeInterval.Description="Сколько секунд должен быть просадок кадров.\nТакже контролирует GOP Size."
-AMF.H264.IDRPeriod="Период IDR"
-AMF.H264.IDRPeriod.Description="Сколько кадров должно быть что-бы не было просадка кадров.\nТакже контролирует GOP Size."
-AMF.H264.HeaderInsertionSpacing="Расстояние вставки заголовка"
-AMF.H264.BPicture.Pattern="Патерн B-кадра"
-AMF.H264.BPicture.Reference="Референс B-кадра"
-AMF.H264.BPicture.Reference.Description="Разрешает B-Кадрам ссылаться на другие B-Кадры как и на P- и I-Кадры.\nОгромный урон производительности, исправление низкого качества."
-AMF.H264.DeblockingFilter="Фильтр деблокинга"
-AMF.H264.DeblockingFilter.Description="Устанавливает флаг, что декодер может использовать фильтр удаления блочности для прямой трансляции."
-AMF.H264.SlicesPerFrame="Количество частей на кадр"
-AMF.H264.IntraRefreshNumMBsPerSlot="Интра-обновить Количество Макроблоков в слот"
-AMF.H264.ScanType="Развертка"
-AMF.H264.ScanType.Description="Какой режим сканирования использовать; всегда оставляется этот параметр на 'прогрессивном'."
-AMF.H264.ScanType.Progressive="Прогрессивная"
-AMF.H264.ScanType.Interlaced="Чересстрочная"
-AMF.H264.QualityPreset="Предустановки качества"
-AMF.H264.QualityPreset.Description="К какому пресету качества AMF нужно стремиться:\n-'Speed' самый быстрый, но имеет самое низкое качество,\n-'Balanced' между 'Speed' и 'Quality', предоставляет хорошее соотношение между скоростью и качеством,\n-'Quality' предоставляет наилучшее качество для предоставленного битрейта."
-AMF.H264.QualityPreset.Speed="Скорость"
-AMF.H264.QualityPreset.Balanced="Баланс"
-AMF.H264.QualityPreset.Quality="Качество"
-AMF.H264.MotionEstimation="Оценка движения"
-AMF.H264.MotionEstimation.Description="Оценки движения позволяет кодировщику необходимость уменьшить Битрейт, оценивая, где пиксель прошел."
-AMF.H264.MotionEstimation.None="Нет"
-AMF.H264.MotionEstimation.Half="Пол-пиксельная"
-AMF.H264.MotionEstimation.Quarter="Четверть-пиксельная"
-AMF.H264.MotionEstimation.Both="Пол- & Четверть-пиксельная"
-AMF.H264.CABAC="Контекстно-адаптивное двоичное арифметическое кодирование (CABAC)"
-AMF.H264.CABAC.Description="Использовать CABAC (Контекстно-адаптивное двоичное арифметическое кодирование) вместо CALV.\nНе влияет на качество, но помогает со сжатием. В среднем можно ожидать улучшение сжатия на 5%."
-AMF.H264.MemoryType="Тип памяти"
-AMF.H264.MemoryType.Description="Как кадры должны быть сохранены перед передачей кодировщику:\n-'Автоматически' выбирает наилучший доступный источник памяти,\n-Host использует системную память,\n-DirectX 9 использует DirectX для передачи,\n-DirectX 11 использует DirectX для передачи,\n-OpenGL использует OpenGL для передачи.\n\n'Host' хороший выбор для большинства систем, но порой DirectX может помочь в ситуациях высокой нагрузки."
-AMF.H264.SurfaceFormat="Формат поверхности"
-AMF.H264.SurfaceFormat.Description="Какой формат использоваться для кодирования.\nТолько NV12 изначально поддерживается, другие типы требуют преобразования."
-AMF.H264.View="Режим просмотра"
-AMF.H264.View.Description="Какие параметры должны быть видны. Вы не будете получать поддержку при использовании режимов 'Эксперт' и 'Мастер'."
-AMF.H264.View.Basic="Обычный"
-AMF.H264.View.Advanced="Расширенный"
-AMF.H264.View.Expert="Эксперт"
-AMF.H264.View.Master="Мастер"
-AMF.H264.UnlockProperties="Разблокировать параметры"
-AMF.H264.UnlockProperties.Description="Разблокировать определённые параметры до их полного, неограниченного диапазона."
-AMF.H264.Debug="Отладка"
-AMF.H264.Debug.Description="Включить дополнительные логи для отладки; следует включить, если вам нужна поддержка с этим кодировщиком."
-AMF.Util.Default="По умолчанию"
-AMF.Util.Automatic="Автоматически"
-AMF.Util.Manual="Руководство"
-AMF.Util.Toggle.Disabled="Выключено"
-AMF.Util.Toggle.Enabled="Включено"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/sr-CS.ini Deleted

@@ -1,39 +0,0 @@
-AMF.H264.Usage.Transcoding="Transkodiranje"
-AMF.H264.Usage.UltraLowLatency="Ultra nisko kašnjenje"
-AMF.H264.Usage.LowLatency="Nisko kašnjenje"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Nivo profila"
-AMF.H264.RateControlMethod="Metoda kontrole protoka"
-AMF.H264.RateControlMethod.CQP="Konstantan kvalitet (CQP)"
-AMF.H264.RateControlMethod.CBR="Konstantan protok (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Promenjivi protok (sa gornjom granicom) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Promenjivi protok (sa granicom kašnjenja) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Ciljani protok"
-AMF.H264.Bitrate.Peak="Granica protoka"
-AMF.H264.QP.Minimum="Minimalni QP"
-AMF.H264.QP.Maximum="Maksimalni QP"
-AMF.H264.QP.IFrame="I-Frejm QP"
-AMF.H264.QP.PFrame="P-Frejm QP"
-AMF.H264.QP.BFrame="B-Frejm QP"
-AMF.H264.QP.BPictureDelta="B-Promena slike QP"
-AMF.H264.QP.ReferenceBPictureDelta="Referenca B-Promena slike QP"
-AMF.H264.FillerData="Podaci za popunjavanje"
-AMF.H264.FrameSkipping="Preskakanje frejmova"
-AMF.H264.EnforceHRDCompatibility="Prisilna HRD kompatibilnost"
-AMF.H264.BPicture.Pattern="B-Šablonska slika"
-AMF.H264.BPicture.Reference="B-Referentna slika"
-AMF.H264.DeblockingFilter="Odblokirajući filter"
-AMF.H264.ScanType="Vrsta skeniranja"
-AMF.H264.ScanType.Progressive="Progresivno"
-AMF.H264.ScanType.Interlaced="Isprekidano"
-AMF.H264.QualityPreset="Šablon kvaliteta"
-AMF.H264.QualityPreset.Speed="Brzina"
-AMF.H264.QualityPreset.Balanced="Izbalansirano"
-AMF.H264.QualityPreset.Quality="Kvalitet"
-AMF.H264.CABAC="Binarno aritmetičko kodiranje prilagodljivo sadržaju (CABAC)"
-AMF.H264.MemoryType="Vrsta memorije"
-AMF.H264.SurfaceFormat="Format površine"
-AMF.Util.Default="Podrazumevano"
-AMF.Util.Automatic="Automatski"
-AMF.Util.Toggle.Disabled="Onemogućeno"
-AMF.Util.Toggle.Enabled="Omogućeno"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/sr-SP.ini Deleted

@@ -1,39 +0,0 @@
-AMF.H264.Usage.Transcoding="Транскодирање"
-AMF.H264.Usage.UltraLowLatency="Ултра ниско кашњење"
-AMF.H264.Usage.LowLatency="Ниско кашњење"
-AMF.H264.Profile="Профил"
-AMF.H264.ProfileLevel="Ниво профила"
-AMF.H264.RateControlMethod="Метода контроле протока"
-AMF.H264.RateControlMethod.CQP="Константан квалитет (CQP)"
-AMF.H264.RateControlMethod.CBR="Константан проток (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Промењиви проток (са горњом границом) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Промењиви проток (са границом кашњења) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Циљани проток"
-AMF.H264.Bitrate.Peak="Граница протока"
-AMF.H264.QP.Minimum="Минимални QP"
-AMF.H264.QP.Maximum="Максимални QP"
-AMF.H264.QP.IFrame="I-Фрејм QP"
-AMF.H264.QP.PFrame="P-Фрејм QP"
-AMF.H264.QP.BFrame="B-Фрејм QP"
-AMF.H264.QP.BPictureDelta="B-Промена слике QP"
-AMF.H264.QP.ReferenceBPictureDelta="Референца B-Промена слике QP"
-AMF.H264.FillerData="Подаци за попуњавање"
-AMF.H264.FrameSkipping="Прескакање фрејмова"
-AMF.H264.EnforceHRDCompatibility="Присилна HRD компатибилност"
-AMF.H264.BPicture.Pattern="B-Шаблонска слика"
-AMF.H264.BPicture.Reference="B-Референтна слика"
-AMF.H264.DeblockingFilter="Одблокирајући филтер"
-AMF.H264.ScanType="Врста скенирања"
-AMF.H264.ScanType.Progressive="Прогресивно"
-AMF.H264.ScanType.Interlaced="Испрекидано"
-AMF.H264.QualityPreset="Шаблон квалитета"
-AMF.H264.QualityPreset.Speed="Брзина"
-AMF.H264.QualityPreset.Balanced="Избалансирано"
-AMF.H264.QualityPreset.Quality="Квалитет"
-AMF.H264.CABAC="Бинарно аритметичко кодирање прилагодљиво садржају (CABAC)"
-AMF.H264.MemoryType="Врста меморије"
-AMF.H264.SurfaceFormat="Формат површине"
-AMF.Util.Default="Подразумевано"
-AMF.Util.Automatic="Аутоматски"
-AMF.Util.Toggle.Disabled="Онемогућено"
-AMF.Util.Toggle.Enabled="Омогућено"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/sv-SE.ini Deleted

@@ -1,41 +0,0 @@
-AMF.H264.Preset="Förinställning"
-AMF.H264.Preset.HighQuality="Hög kvalitet"
-AMF.H264.Preset.Indistinguishable="Oskiljbar"
-AMF.H264.Preset.Lossless="Förlustfri"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Användning"
-AMF.H264.Usage.Transcoding="Omkodning"
-AMF.H264.Usage.UltraLowLatency="Ultralåg latens"
-AMF.H264.Usage.LowLatency="Låg latens"
-AMF.H264.Profile="Profil"
-AMF.H264.ProfileLevel="Profilnivå"
-AMF.H264.RateControlMethod.CQP="Konstant QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Konstant bithastighet (CBR)"
-AMF.H264.Bitrate.Target="Målets bithastighet"
-AMF.H264.Bitrate.Peak="Maximal bithastighet"
-AMF.H264.QP.Minimum="Minimal QP"
-AMF.H264.QP.Maximum="Maximal QP"
-AMF.H264.FrameSkipping="Hoppa över bildrutor"
-AMF.H264.EnforceHRDCompatibility="Tvinga HRD-kompatibilitet"
-AMF.H264.DeblockingFilter="Avblockningsfilter"
-AMF.H264.ScanType="Typ av skanning"
-AMF.H264.ScanType.Progressive="Progressiv"
-AMF.H264.ScanType.Interlaced="Sammanflätad"
-AMF.H264.QualityPreset="Kvalitetsförinställning"
-AMF.H264.QualityPreset.Speed="Hastighet"
-AMF.H264.QualityPreset.Balanced="Balanserad"
-AMF.H264.QualityPreset.Quality="Kvalitet"
-AMF.H264.MotionEstimation.None="Ingen"
-AMF.H264.MemoryType="Minnestyp"
-AMF.H264.View="Visningsläge"
-AMF.H264.View.Basic="Grundläggande"
-AMF.H264.View.Advanced="Avancerad"
-AMF.H264.View.Expert="Expert"
-AMF.H264.View.Master="Master"
-AMF.H264.Debug="Felsök"
-AMF.Util.Default="Standard"
-AMF.Util.Automatic="Automatisk"
-AMF.Util.Manual="Manuell"
-AMF.Util.Toggle.Disabled="Inaktiverad"
-AMF.Util.Toggle.Enabled="Aktiverad"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/uk-UA.ini Deleted

@@ -1,76 +0,0 @@
-AMF.H264.Preset="Шаблон"
-AMF.H264.Preset.Recording="Звичайний запис"
-AMF.H264.Preset.HighQuality="Висока якість"
-AMF.H264.Preset.Indistinguishable="Якість майже без втрат"
-AMF.H264.Preset.Lossless="Без втрат якості"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="Використання"
-AMF.H264.Usage.Description="Тип використання AMF або напрямок його використання, тобто:\n  'Для перекодування' - загальний тип налаштувань (рекомендований).\n  'З ультра-низькою затримкою' - тип лише для дійсно низької затримки під час кодування.\n  'З низькою затримкою' - схожий на зазначений вище, але з трохи більшою затримкою.\n\nТрансляції підтримують лише напрямок використання 'Для перекодування'."
-AMF.H264.Usage.Transcoding="Для перекодування"
-AMF.H264.Usage.UltraLowLatency="З ультра-низькою затримкою"
-AMF.H264.Usage.LowLatency="З низькою затримкою"
-AMF.H264.Profile="Профіль"
-AMF.H264.ProfileLevel="Рівень профілю"
-AMF.H264.MaximumLTRFrames="Кількість LTR-кадрів контрольованих користувачем"
-AMF.H264.MaximumLTRFrames.Description="Long-Term Reference (LTR) кадри дозволяють при кодуванні маркувати декілька кадрів як опорні для інших.\nЦе може поліпшити якість у разі відсутності підтримки B-кадрів або небажаності їх використання.\nЯкщо 'Кількість LTR-кадрів контрольованих користувачем' вказано, то енкодер не підтримуватиме B-кадри у відео."
-AMF.H264.RateControlMethod.CQP="Фіксований QP (CQP)"
-AMF.H264.RateControlMethod.CBR="Постійний бітрейт (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Змінний бітрейт (максимальний бітрейт обмежено) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Змінний бітрейт (затримку обмежено) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Бажаний бітрейт"
-AMF.H264.Bitrate.Peak="Максимальний бітрейт"
-AMF.H264.QP.Minimum="Мінімальний QP"
-AMF.H264.QP.Maximum="Максимальний QP"
-AMF.H264.QP.IFrame="QP для I-кадрів"
-AMF.H264.QP.PFrame="QP для P-кадрів"
-AMF.H264.QP.BFrame="QP для B-кадрів"
-AMF.H264.QP.BPictureDelta="B-кадри, відхил QP"
-AMF.H264.QP.ReferenceBPictureDelta="Опорні B-кадри, відхил QP"
-AMF.H264.VBVBuffer="Буфер VBV"
-AMF.H264.VBVBuffer.Size="Розмір VBV буфера"
-AMF.H264.VBVBuffer.Fullness="Початкова повнота буферу VBV"
-AMF.H264.VBVBuffer.Fullness.Description="Визначає початкову заповнюваність Буферу VBV, діє лише на початку кодування."
-AMF.H264.FillerData="Заповнювати пустоти у бітрейту"
-AMF.H264.FrameSkipping="Пропускати кадри"
-AMF.H264.EnforceHRDCompatibility="Застосувати примусову сумісність з HRD"
-AMF.H264.MaximumAccessUnitSize="Максимальний розмір Access Unit"
-AMF.H264.KeyframeInterval="Інтервал ключових кадрів"
-AMF.H264.IDRPeriod="IDR, період (кадрів)"
-AMF.H264.HeaderInsertionSpacing="Заголовки потоку, період (кадрів)"
-AMF.H264.BPicture.Pattern="Послідовні B-кадри"
-AMF.H264.BPicture.Reference="B-кадри як опорні"
-AMF.H264.DeblockingFilter="Деблокінг-фільтр"
-AMF.H264.SlicesPerFrame="Фрагментів на кадр"
-AMF.H264.IntraRefreshNumMBsPerSlot="Кількість Intra-Refresh макроблоків на слот"
-AMF.H264.ScanType="Вид розгортки"
-AMF.H264.ScanType.Progressive="Прогресивна"
-AMF.H264.ScanType.Interlaced="Черезрядкова"
-AMF.H264.QualityPreset="Шаблон якості"
-AMF.H264.QualityPreset.Speed="Швидкість"
-AMF.H264.QualityPreset.Balanced="Збалансований"
-AMF.H264.QualityPreset.Quality="Якість"
-AMF.H264.MotionEstimation="Оцінка руху"
-AMF.H264.MotionEstimation.Description="Оцінка руху дозволяє енкодеру зменшити вимоги до бітрейту завдяки розрахункам з переміщення пікселів."
-AMF.H264.MotionEstimation.None="Немає"
-AMF.H264.MotionEstimation.Half="Пів-пікселя"
-AMF.H264.MotionEstimation.Quarter="Чверть-пікселя"
-AMF.H264.MotionEstimation.Both="Пів-пікселя та Чверть-пікселя"
-AMF.H264.CABAC="CABAC кодування"
-AMF.H264.MemoryType="Пам'ять адресується"
-AMF.H264.MemoryType.Description="Визначає як кадри зберігатимуться перед надсиланням до енкодеру:\n  'Автоматично' - програма обирає найкращий спосіб самостійно;\n  'Host' - буде використано системну пам'ять;\n  'DirectX 9' - використовуються поверхні DirectX9 (Windows), пам'ять\nграфічного адаптера;\n  'DirectX 11' - використовуються поверхні DirectX11 (для Windows 8.1\nта новіших), пам'ять графічного адаптера;\n  'OpenGL' - використовуються поверхні OpenGL, пам'ять графічного\nадаптера.\n\nHost - достатньо гарний вибір для багатьох систем, хоча DirectX можна\nвикористати у край навантажених ситуаціях обміну даними (інколи допомагає)."
-AMF.H264.SurfaceFormat="Формат поверхні (або кольору)"
-AMF.H264.SurfaceFormat.Description="Визначає Формат поверхні (кольору) що використовується для кодування.\nЛише NV12 має вбудовану підтримку, інші типи потребують додаткового перетворення."
-AMF.H264.View="Вид для налаштувань"
-AMF.H264.View.Description="Визначає кількість наявних опцій для налаштування. Навряд чи розробник вам допомагатиме, якщо ви оберете рівень 'Експерт' або 'Бог енкодерів'."
-AMF.H264.View.Basic="Базовий"
-AMF.H264.View.Advanced="Розширений"
-AMF.H264.View.Expert="Експерт"
-AMF.H264.View.Master="Бог енкодерів"
-AMF.H264.Debug="Відладка"
-AMF.H264.Debug.Description="Вмикає занесення до лог-файлу додаткової інформації про процес кодування. Корисно у випадку коли ви бажаєте звернутися за допомогою до розробника енкодера."
-AMF.Util.Default="За замовчанням"
-AMF.Util.Automatic="Автоматично"
-AMF.Util.Manual="Вручну"
-AMF.Util.Toggle.Disabled="Вимкнено"
-AMF.Util.Toggle.Enabled="Увімкнено"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/vi-VN.ini Deleted

@@ -1,64 +0,0 @@
-AMF.H264.Preset="Mẫu thiết lập"
-AMF.H264.Preset.Recording="Quay video"
-AMF.H264.Preset.HighQuality="Chất lượng cao"
-AMF.H264.Preset.Indistinguishable="Không thể phân biệt"
-AMF.H264.Preset.Lossless="Lossless"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage.Transcoding="Chuyển mã"
-AMF.H264.Usage.UltraLowLatency="Độ trễ cực thấp"
-AMF.H264.Usage.LowLatency="Độ trễ thấp"
-AMF.H264.Profile="Profile"
-AMF.H264.ProfileLevel="Profile Level"
-AMF.H264.MaximumLTRFrames="LTR Frames tối đa"
-AMF.H264.RateControlMethod="Cách kiểm soát Bitrate"
-AMF.H264.RateControlMethod.CQP="QP Không thay đổi (CQP)"
-AMF.H264.RateControlMethod.CBR="Bitrate Không thay đổi (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="Bitrate Thay đổi được (Phụ thuộc vào Bitrate Cao nhất) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="Bitrate Thay đổi được (Phụ thuộc vào độ trễ) (VBR_LAT)"
-AMF.H264.Bitrate.Target="Bitrate Mục tiêu"
-AMF.H264.Bitrate.Peak="Bitrate Cao nhất"
-AMF.H264.QP.Minimum="QP Thấp nhất"
-AMF.H264.QP.Maximum="QP Cao nhất"
-AMF.H264.QP.IFrame="I-Frame QP"
-AMF.H264.QP.PFrame="P-Frame QP"
-AMF.H264.QP.BFrame="B-Frame QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
-AMF.H264.FillerData="Filler Data (Thêm data cho đủ bitrate)"
-AMF.H264.FrameSkipping="Frame Skipping"
-AMF.H264.EnforceHRDCompatibility="Enforce HRD Compatibility"
-AMF.H264.KeyframeInterval="Thời gian đặt keyframe"
-AMF.H264.BPicture.Pattern="B-Picture Pattern"
-AMF.H264.BPicture.Reference="B-Picture Reference"
-AMF.H264.DeblockingFilter="De-blocking Filter (Lọc chống nhiễu ảnh)"
-AMF.H264.SlicesPerFrame="Lát cho mỗi khung hình"
-AMF.H264.ScanType="Quét hình loại"
-AMF.H264.ScanType.Progressive="Quét nguyên ảnh (Progressive)"
-AMF.H264.ScanType.Interlaced="Quét 1/2 ảnh (Interlaced)"
-AMF.H264.QualityPreset="Quality Preset"
-AMF.H264.QualityPreset.Speed="Tốc độ"
-AMF.H264.QualityPreset.Balanced="Cân bằng"
-AMF.H264.QualityPreset.Quality="Chất lượng"
-AMF.H264.MotionEstimation="Dự đoán bù trừ chuyển động"
-AMF.H264.MotionEstimation.Description="Dự toán chuyển động cho phép bộ mã hóa giảm bitrate cần thiết bằng cách ước tính một pixel sẽ đi đâu."
-AMF.H264.MotionEstimation.None="Không"
-AMF.H264.MotionEstimation.Half="1/2 Pixel"
-AMF.H264.MotionEstimation.Quarter="1/4 Pixel"
-AMF.H264.MotionEstimation.Both="1/2 và 1/4 Pixel"
-AMF.H264.CABAC="Nén lossless theo tình huống (CABAC)"
-AMF.H264.CABAC.Description="Sử dụng CABAC (Context Adaptive Binary Arithmethic Coding) thay vì CALV.\nKhông ảnh hưởng đến chất lượng nhưng tăng khả năng nén. Trung bình có thể nén được 5% tổng dung lượng."
-AMF.H264.MemoryType="Loại bộ nhớ"
-AMF.H264.SurfaceFormat="Định dạng bề mặt"
-AMF.H264.View="Chế độ xem"
-AMF.H264.View.Basic="Cơ bản"
-AMF.H264.View.Advanced="Nâng cao"
-AMF.H264.View.Expert="Chuyên gia"
-AMF.H264.View.Master="Bật cả tính năng ẩn"
-AMF.H264.UnlockProperties="Mở khóa Properties"
-AMF.H264.Debug="Gỡ lỗi"
-AMF.Util.Default="Mặc định"
-AMF.Util.Automatic="Tự động"
-AMF.Util.Manual="Thủ công"
-AMF.Util.Toggle.Disabled="Tắt"
-AMF.Util.Toggle.Enabled="Bật"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/zh-CN.ini Deleted

@@ -1,107 +0,0 @@
-AMF.H264.Preset="预设"
-AMF.H264.Preset.Recording="录像"
-AMF.H264.Preset.HighQuality="高质量"
-AMF.H264.Preset.Indistinguishable="无法区分"
-AMF.H264.Preset.Lossless="无损"
-AMF.H264.Preset.Twitch="Twitch"
-AMF.H264.Preset.YouTube="YouTube"
-AMF.H264.Usage="使用"
-AMF.H264.Usage.Description="AMF 应调整为什么用法:\n-'转码' 是通用转码(推荐), \n '超低延迟' 对于真的低延迟编码,\n-'低延迟' 类似于上面稍高的延迟.\n 推流仅支持 '转码', 所有其他值可以用于录制."
-AMF.H264.Usage.Transcoding="转码"
-AMF.H264.Usage.UltraLowLatency="超低延迟"
-AMF.H264.Usage.LowLatency="低延迟"
-AMF.H264.Profile="配置文件"
-AMF.H264.Profile.Description="使用哪个 H.264 Profile 来编码:\n-'Baseline' 最广泛支持,\n-'Main'被 95% 设备支持(推荐),\n-'High' 只被高端设备支持."
-AMF.H264.ProfileLevel="配置等级"
-AMF.H264.ProfileLevel.Description="对于编码使用哪种 H.264 Profile Level:\n-'Automatic' 根据给定的帧率和帧大小计算最优的 profile level,\n-'4.1' 支持 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n-'4.2' 支持 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n-'5.0' 支持 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n-'5.1' 支持 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n-'5.2' 支持 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
-AMF.H264.MaximumLTRFrames="最大的 LTR 帧"
-AMF.H264.MaximumLTRFrames.Description="长期参考帧(LTR) 是一个特性允许编码器来标记在一个序列的一些帧作为参考帧.\n这会使当 B 帧不支持或者不需要时提高质量.\nLTR真不能和 B 帧一起使用, 并且当使用LTR时, 编码器会禁用 B 帧."
-AMF.H264.RateControlMethod="速率控制方法"
-AMF.H264.RateControlMethod.CQP="恒定 QP (CQP)"
-AMF.H264.RateControlMethod.CBR="固定比特率 (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="变比特率 (峰值约束) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="变比特率 (延迟约束) (VBR_LAT)"
-AMF.H264.Bitrate.Target="目标比特率"
-AMF.H264.Bitrate.Target.Description="比特率尝试在整个序列获得.\n用于 CBR 和 VBR_LAT."
-AMF.H264.Bitrate.Peak="峰值比特率"
-AMF.H264.Bitrate.Peak.Description="比特率尝试最大峰值在整个序列.\n 用于 VBR 和 VBR_LAT"
-AMF.H264.QP.Minimum="最低 QP"
-AMF.H264.QP.Minimum.Description="在一个帧中的追的 QP 值.\n 用于 CBR, VBR 和 VBR_LAT."
-AMF.H264.QP.Maximum="最高 QP"
-AMF.H264.QP.Maximum.Description="在一个帧中的最高 QP 值.\n 用于 CBR, VBR 和 VBR_LAT."
-AMF.H264.QP.IFrame="I 帧 QP"
-AMF.H264.QP.IFrame.Description="用于 I 帧的固定 QP 值.\n 较低 = 较大的文件, 较好的资料. 较高 = 较小的文件, 较差的质量.\nI 帧 QP 应该等于或者大于 P 和 B 帧的 QP 值.\n 用于 CQP."
-AMF.H264.QP.PFrame="P 帧 QP"
-AMF.H264.QP.PFrame.Description="固定的 QP 值用于 P 帧.\n 较低 = 较大的文件, 较高的质量. 较高 = 较小的文件, 较差的质量.\nP 帧 QP 值应该等于或者高于 B 帧的 QP 值.\n用于 CQP."
-AMF.H264.QP.BFrame="B 帧 QP"
-AMF.H264.QP.BFrame.Description="用于 B 帧的固定的 QP 值.\n 较小 = 较大的文件, 较好的质量. 较大 = 较小的文件, 较差的质量.\n 用于 CQP."
-AMF.H264.QP.BPictureDelta="B 图片 差值 QP"
-AMF.H264.QP.BPictureDelta.Description="相对于上一个非参考 B 帧的差值 QP 值."
-AMF.H264.QP.ReferenceBPictureDelta="参考 B 图片 差值 QP"
-AMF.H264.QP.ReferenceBPictureDelta.Description="相对于上一个参考 B 帧的差值 QP 值."
-AMF.H264.VBVBuffer="VBV 缓存"
-AMF.H264.VBVBuffer.Strictness="VBV 缓存规范性"
-AMF.H264.VBVBuffer.Strictness.Description="VBV 缓存应该怎样严格, 100% 几乎完全和目标比特率一致和 0% 不受限制的."
-AMF.H264.VBVBuffer.Size="VBV 缓存大小"
-AMF.H264.VBVBuffer.Size.Description="VBV 缓存大小用于在一个序列中的比特率控制.\n体积小会产生几乎完美的比特率控制但有较大的性能影响.\n理想的(100% 严格) VBV 缓存大小是比特率/帧率."
-AMF.H264.VBVBuffer.Fullness="VBV 缓冲满"
-AMF.H264.VBVBuffer.Fullness.Description="VBV 缓存最初应该多满, 将只会影响最初的序列的编码."
-AMF.H264.FillerData="填充数据"
-AMF.H264.FillerData.Description="填充数据是解码器忽略的空/无效数据.\n如果启用和使用 CBR, 编码器将会塞满序列中的剩余空间此数据."
-AMF.H264.FrameSkipping="跳过的帧"
-AMF.H264.FrameSkipping.Description="跳过的帧允许编码器有选择地跳过帧, 如果他们非常相似, 或太长时间编码.\n编码这个将使输出文件为可变帧率, 这样大多数编辑软件不支持."
-AMF.H264.EnforceHRDCompatibility="强制 HRD 兼容"
-AMF.H264.EnforceHRDCompatibility.Description="强制假设的参考解码器限制在一个帧内的最大的 QP 值更改.\n不推荐用于录制或推流, 并且应仅用于面向只有参考软件解码器的很老的设备."
-AMF.H264.MaximumAccessUnitSize="最大访问单元大小"
-AMF.H264.MaximumAccessUnitSize.Description="一个 NAL 的访问单元的最大大小. 值 0 允许编码器挑选最好的一个."
-AMF.H264.KeyframeInterval="关键帧间隔"
-AMF.H264.KeyframeInterval.Description="非丢弃帧之间应该多少秒.\n也控制序列(GOP) 的大小."
-AMF.H264.IDRPeriod="IDR 周期"
-AMF.H264.IDRPeriod.Description="非丢弃帧之间应该多少帧.\n也控制序列(GOP) 的大小."
-AMF.H264.HeaderInsertionSpacing="头部插入空白"
-AMF.H264.HeaderInsertionSpacing.Description="NAL 头之间应该多少帧. 不推荐改为非零(自动) 值."
-AMF.H264.BPicture.Pattern="B 图片模式"
-AMF.H264.BPicture.Reference="B 图片参考"
-AMF.H264.BPicture.Reference.Description="允许 B 帧参考 P 帧和 I 帧之外的其他 B 帧.\n 巨大的性能影响, 较小的质量提高."
-AMF.H264.DeblockingFilter="去块滤波"
-AMF.H264.DeblockingFilter.Description="设置解码器允许使用的标记, 用于编码流去块滤波器."
-AMF.H264.SlicesPerFrame="每帧的切片数"
-AMF.H264.SlicesPerFrame.Description="使用固定切片编码而不动态切片编码.\n可以帮助用大分辨率和帧率, 由于它允许更多的数据存储在相同的 profile level, 但大多时候会对质量有负面影响."
-AMF.H264.IntraRefreshNumMBsPerSlot="每个槽的内部宏块刷新数量"
-AMF.H264.IntraRefreshNumMBsPerSlot.Description="应该允许每个插槽中多少个宏块用于帧内刷新编码.\n帧内刷新编码允许更快的寻找和解码, 以一个较高的比特率为代价, 由于需要存储额外的数据.\n 推流时保持为默认值."
-AMF.H264.ScanType="扫描类型"
-AMF.H264.ScanType.Description="使用哪种扫描方法, 通常设置为'Progressive'."
-AMF.H264.ScanType.Progressive="渐进"
-AMF.H264.ScanType.Interlaced="交错"
-AMF.H264.QualityPreset="质量预设"
-AMF.H264.QualityPreset.Description="哪种质量预设 AMF 应该尝试对于目标:\n-'速度' 是最快但有最差的质量,\n-'平衡' 是 '速度' 和 '质量' 之间, 提供一个两者之间的较好的平衡,\n-'质量' 给出了最好的质量对于给定的比特率."
-AMF.H264.QualityPreset.Speed="速度"
-AMF.H264.QualityPreset.Balanced="平衡"
-AMF.H264.QualityPreset.Quality="质量"
-AMF.H264.MotionEstimation="移动侦测"
-AMF.H264.MotionEstimation.Description="运动侦测允许编码器通过估计一个像素去了哪里来降低比特率."
-AMF.H264.MotionEstimation.None="无"
-AMF.H264.MotionEstimation.Half="半像素"
-AMF.H264.MotionEstimation.Quarter="四分之一像素"
-AMF.H264.MotionEstimation.Both="半&四分之一像素"
-AMF.H264.CABAC="上下文自适应二进制算术编码 (CABAC)"
-AMF.H264.CABAC.Description="使用 CABAC(Context Adaptive Binary Arithmethic Coding) 取代 CALV.\n 不影响质量但是对压缩有帮助. 平均, 可以预期有 5% 更好的压缩率."
-AMF.H264.MemoryType="内存类型"
-AMF.H264.MemoryType.Description="在提交给编码器之前应该如何存储帧:\n-'自动' 选择最佳可用内存后端类型,\n- '主机' 使用系统内存,\n- 'DirectX 9' 使用 DirectX 接口来提交, \n- 'DirectX 11' 使用 DirectX 来提交, \n 'OpenGL' 使用 OpenGL 接口来提交.\n\n 'Host' 对于大多数系统不够好, 但 DirectX 可以偶尔缓解高负载的情况."
-AMF.H264.SurfaceFormat="表面格式"
-AMF.H264.SurfaceFormat.Description="什么接口格式用于编码.\n 只有 NV12 本地支持, 其他类型需要转换."
-AMF.H264.View="查看模式"
-AMF.H264.View.Description="哪些属性应该是可见的. 当使用 '专家' 或者 '大师' 模式时, 您将不会得到支持."
-AMF.H264.View.Basic="基本"
-AMF.H264.View.Advanced="高级"
-AMF.H264.View.Expert="专家"
-AMF.H264.View.Master="主"
-AMF.H264.UnlockProperties="解锁属性"
-AMF.H264.UnlockProperties.Description="解锁给他们完整范围的某些属性, 而不是将他们局限到一定范围内."
-AMF.H264.Debug="调试"
-AMF.H264.Debug.Description="启用附加调试日志记录, 应该是启用的, 无论何时您需要此编码器的支持."
-AMF.Util.Default="默认"
-AMF.Util.Automatic="自动"
-AMF.Util.Manual="手动"
-AMF.Util.Toggle.Disabled="禁用"
-AMF.Util.Toggle.Enabled="启用"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Resources/locale/zh-TW.ini Deleted

@@ -1,39 +0,0 @@
-AMF.H264.Usage.Transcoding="轉碼"
-AMF.H264.Usage.UltraLowLatency="超低延遲"
-AMF.H264.Usage.LowLatency="低延遲"
-AMF.H264.Profile="設定檔"
-AMF.H264.ProfileLevel="設定檔級別"
-AMF.H264.RateControlMethod="速率控制方法"
-AMF.H264.RateControlMethod.CQP="固定 QP (CQP)"
-AMF.H264.RateControlMethod.CBR="固定位元率 (CBR)"
-AMF.H264.RateControlMethod.VBR.Peak="可變位元率 (限制最大位元率) (VBR)"
-AMF.H264.RateControlMethod.VBR.Latency="可變位元率 (限制延遲) (VBR)"
-AMF.H264.Bitrate.Target="目標位元率"
-AMF.H264.Bitrate.Peak="最大位元率"
-AMF.H264.QP.Minimum="最低 QP 值"
-AMF.H264.QP.Maximum="最大 QP 值"
-AMF.H264.QP.IFrame="I-訊框 QP"
-AMF.H264.QP.PFrame="P-訊框 QP"
-AMF.H264.QP.BFrame="B-訊框 QP"
-AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
-AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
-AMF.H264.FillerData="填充資料"
-AMF.H264.FrameSkipping="省略訊框"
-AMF.H264.EnforceHRDCompatibility="與 HRD 相容"
-AMF.H264.BPicture.Pattern="B-Picture 模式"
-AMF.H264.BPicture.Reference="B-Picture 參照"
-AMF.H264.DeblockingFilter="去塊狀色斑濾鏡"
-AMF.H264.ScanType="掃描類型"
-AMF.H264.ScanType.Progressive="漸進式"
-AMF.H264.ScanType.Interlaced="交错式"
-AMF.H264.QualityPreset="預設品質"
-AMF.H264.QualityPreset.Speed="速度"
-AMF.H264.QualityPreset.Balanced="平衡"
-AMF.H264.QualityPreset.Quality="品質"
-AMF.H264.CABAC="前文參考之適應性二元算術編碼 (CABAC)"
-AMF.H264.MemoryType="記憶體類型"
-AMF.H264.SurfaceFormat="表面格式"
-AMF.Util.Default="預設"
-AMF.Util.Automatic="自動"
-AMF.Util.Toggle.Disabled="停用"
-AMF.Util.Toggle.Enabled="啟用"

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source Deleted

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/amd-amf-vce-capabilities.cpp Deleted

@@ -1,304 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include <string>
-#include <sstream>
-
-#include "amd-amf-vce-capabilities.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-
-std::shared_ptr<Plugin::AMD::VCECapabilities> Plugin::AMD::VCECapabilities::GetInstance() {
-	static std::shared_ptr<VCECapabilities> __instance = std::make_shared<VCECapabilities>();
-	static std::mutex __mutex;
-
-	try {
-		const std::lock_guard<std::mutex> lock(__mutex);
-		return __instance;
-	} catch (...) {
-		return nullptr;
-	}
-}
-
-void Plugin::AMD::VCECapabilities::ReportCapabilities() {
-	static std::vector<char> msgBuf(8192);
-
-	//////////////////////////////////////////////////////////////////////////
-	// Report Capabilities to log file first.
-	//////////////////////////////////////////////////////////////////////////
-	#pragma region Capability Reporting
-
-	AMF_LOG_INFO("Gathering Capability Information...");
-	auto caps = VCECapabilities::GetInstance();
-
-	AMF_LOG_INFO(" %4s | %8s | %11s | %8s | %11s | %9s | %7s | %11s | %7s | %3s | %10s ",
-		"Type",
-		"Acc.Type",
-		"Max Bitrate",
-		"Stream #",
-		"Max Profile",
-		"Max Level",
-		"BFrames",
-		"Ref. Frames",
-		"Layer #",
-		"FSM",
-		"Instance #");
-
-	VCECapabilities::EncoderCaps* capsEnc[] = { &caps->m_AVCCaps, &caps->m_SVCCaps, &caps->m_HEVCCaps };
-	for (uint8_t i = 0; i < 3; i++) {
-		// Encoder Acceleration
-		char* accelType = "";
-		switch (capsEnc[i]->acceleration_type) {
-			case amf::AMF_ACCEL_NOT_SUPPORTED:
-				accelType = "None";
-				break;
-			case amf::AMF_ACCEL_HARDWARE:
-				accelType = "Hardware";
-				break;
-			case amf::AMF_ACCEL_GPU:
-				accelType = "GPU";
-				break;
-			case amf::AMF_ACCEL_SOFTWARE:
-				accelType = "Software";
-				break;
-		}
-
-		// Print to log
-		sprintf_s(msgBuf.data(), msgBuf.size(),
-			" %4s | %8s | %11d | %8d | %11d | %9d | %7s | %4d - %4d | %7d | %3s | %10d ",
-			(i == 0 ? "AVC" : (i == 1 ? "SVC" : "HEVC")),
-			accelType,
-			capsEnc[i]->maxBitrate,
-			capsEnc[i]->maxNumOfStreams,
-			capsEnc[i]->maxProfile,
-			capsEnc[i]->maxProfileLevel,
-			capsEnc[i]->supportsBFrames ? "Yes" : "No",
-			capsEnc[i]->minReferenceFrames, capsEnc[i]->maxReferenceFrames,
-			capsEnc[i]->maxTemporalLayers,
-			capsEnc[i]->supportsFixedSliceMode ? "Yes" : "No",
-			capsEnc[i]->maxNumOfHwInstances);
-		AMF_LOG_INFO("%s", msgBuf.data());
-	}
-
-	// Type | Flow | Min. Res. | Max. Res. | S.I | Align | Formats | Surface Types
-	// | Input | 64x 64 | 4096x4096 | Yes | 8 | ... | ...
-	// | Output | 64x 64 | 4096x4096 | No | 8 | ... | ...
-	AMF_LOG_INFO(" %4s | %6s | %9s | %9s | %3s | %5s | %7s | %12s",
-		"Type",
-		"Flow",
-		"Min. Res.",
-		"Max. Res.",
-		"S.I",
-		"Align",
-		"Formats",
-		"Memory Types");
-	for (uint8_t i = 0; i < 3; i++) {
-		VCECapabilities::EncoderCaps::IOCaps* capsIO[2] = { &capsEnc[i]->input, &capsEnc[i]->output };
-		for (uint8_t j = 0; j < 2; j++) {
-			std::shared_ptr<AMF> t_amf = AMF::GetInstance();
-			std::stringstream formats, memtypes;
-
-			// Surface Formats
-			for (uint32_t k = 0; k < capsIO[j]->formats.size(); k++) {
-				wcstombs(msgBuf.data(), t_amf->GetTrace()->SurfaceGetFormatName(capsIO[j]->formats[k].first), 1024);
-				formats << msgBuf.data();
-				if (capsIO[j]->formats[k].second)
-					formats << " (Native)";
-				if (k < capsIO[j]->formats.size() - 1)
-					formats << ", ";
-			}
-
-			// Memory Types
-			for (uint32_t k = 0; k < capsIO[j]->memoryTypes.size(); k++) {
-				wcstombs(msgBuf.data(), t_amf->GetTrace()->GetMemoryTypeName(capsIO[j]->memoryTypes[k].first), 1024);
-				memtypes << msgBuf.data();
-				if (capsIO[j]->memoryTypes[k].second)
-					memtypes << " (Native)";
-				if (k < capsIO[j]->memoryTypes.size() - 1)
-					memtypes << ", ";
-			}
-
-			// Print to log
-			sprintf_s(msgBuf.data(), msgBuf.size(), 
-				" %4s | %6s | %4dx%4d | %4dx%4d | %3s | %5d | %7s | %12s",
-				(i == 0 ? "AVC" : (i == 1 ? "SVC" : "HEVC")),
-				(j == 0 ? "Input" : "Output"),
-				capsIO[j]->minWidth, capsIO[j]->minHeight,
-				capsIO[j]->maxWidth, capsIO[j]->maxHeight,
-				capsIO[j]->isInterlacedSupported ? "Yes" : "No",
-				capsIO[j]->verticalAlignment,
-				formats.str().c_str(),
-				memtypes.str().c_str());
-			AMF_LOG_INFO("%s", msgBuf.data());
-		}
-	}
-	#pragma endregion
-}
-
-Plugin::AMD::VCECapabilities::VCECapabilities() {
-	RefreshCapabilities();
-}
-
-Plugin::AMD::VCECapabilities::~VCECapabilities() {
-
-}
-
-bool Plugin::AMD::VCECapabilities::RefreshCapabilities() {
-	AMF_RESULT res;
-
-	std::shared_ptr<AMD::AMF> l_AMF = AMD::AMF::GetInstance();
-	amf::AMFFactory* l_AMFFactory = l_AMF->GetFactory();
-	amf::AMFContextPtr l_AMFContext;
-	res = l_AMFFactory->CreateContext(&l_AMFContext);
-	if (res != AMF_OK) {
-		AMF_LOG_ERROR("Failed to gather Capabilities, error code %d.", res);
-		return false;
-	}
-
-	//////////////////////////////////////////////////////////////////////////
-	// Get Encoder Capabilities
-	//////////////////////////////////////////////////////////////////////////
-	EncoderCaps* caps[] = { &m_AVCCaps, &m_SVCCaps, &m_HEVCCaps };
-	const wchar_t* capsString[] = { AMFVideoEncoderVCE_AVC , AMFVideoEncoderVCE_SVC, L"AMFVideoEncoderHW_HEVC" };
-	for (uint8_t capsIndex = 0; capsIndex < 3; capsIndex++) {
-		// Null Values
-		caps[capsIndex]->acceleration_type = amf::AMF_ACCEL_NOT_SUPPORTED;
-		caps[capsIndex]->maxBitrate =
-			caps[capsIndex]->maxNumOfStreams =
-			caps[capsIndex]->maxProfile =
-			caps[capsIndex]->maxProfileLevel =
-			caps[capsIndex]->minReferenceFrames =
-			caps[capsIndex]->maxReferenceFrames =
-			caps[capsIndex]->maxTemporalLayers =
-			caps[capsIndex]->maxNumOfHwInstances =
-			caps[capsIndex]->input.minWidth =
-			caps[capsIndex]->input.maxWidth =
-			caps[capsIndex]->input.minHeight =
-			caps[capsIndex]->input.maxHeight =
-			caps[capsIndex]->input.verticalAlignment =
-			caps[capsIndex]->output.minWidth =
-			caps[capsIndex]->output.maxWidth =
-			caps[capsIndex]->output.minHeight =
-			caps[capsIndex]->output.maxHeight =
-			caps[capsIndex]->output.verticalAlignment = 0;
-		caps[capsIndex]->supportsBFrames =
-			caps[capsIndex]->supportsFixedSliceMode =
-			caps[capsIndex]->input.isInterlacedSupported =
-			caps[capsIndex]->output.isInterlacedSupported = false;
-		caps[capsIndex]->input.formats.clear();
-		caps[capsIndex]->output.formats.clear();
-		caps[capsIndex]->input.memoryTypes.clear();
-		caps[capsIndex]->output.memoryTypes.clear();
-
-		// Attempt to create stuff
-		amf::AMFComponentPtr l_AMFComponent;
-		res = l_AMFFactory->CreateComponent(l_AMFContext, capsString[capsIndex], &l_AMFComponent);
-		if (res != AMF_OK) {
-			AMF_LOG_ERROR("Failed to gather Capabilities for Encoder Type %s, error code %d.", (capsIndex == 0 ? "AVC" : (capsIndex == 1 ? "AVC" : "HEVC")), res);
-			continue;
-		}
-		amf::AMFCapsPtr encCaps;
-		res = l_AMFComponent->GetCaps(&encCaps);
-		if (res != AMF_OK) {
-			AMF_LOG_ERROR("Failed to gather Capabilities for Encoder Type %s, error code %d.", (capsIndex == 0 ? "AVC" : (capsIndex == 1 ? "AVC" : "HEVC")), res);
-			l_AMFComponent->Terminate();
-			continue;
-		}
-
-		// Basic Capabilities
-		caps[capsIndex]->acceleration_type = encCaps->GetAccelerationType();
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_BITRATE, &(caps[capsIndex]->maxBitrate));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_NUM_OF_STREAMS, &(caps[capsIndex]->maxNumOfStreams));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_PROFILE, &(caps[capsIndex]->maxProfile));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_LEVEL, &(caps[capsIndex]->maxProfileLevel));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_BFRAMES, &(caps[capsIndex]->supportsBFrames));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MIN_REFERENCE_FRAMES, &(caps[capsIndex]->minReferenceFrames));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_REFERENCE_FRAMES, &(caps[capsIndex]->maxReferenceFrames));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_TEMPORAL_LAYERS, &(caps[capsIndex]->maxTemporalLayers));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_FIXED_SLICE_MODE, &(caps[capsIndex]->supportsFixedSliceMode));
-		encCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_NUM_OF_HW_INSTANCES, &(caps[capsIndex]->maxNumOfHwInstances));
-
-		// Input & Output Capabilities
-		amf::AMFIOCapsPtr capsIO[2];
-		EncoderCaps::IOCaps* capsIOS[2] = { &caps[capsIndex]->input, &caps[capsIndex]->output };
-
-		res = encCaps->GetInputCaps(&capsIO[0]);
-		res = encCaps->GetOutputCaps(&capsIO[1]);
-
-		for (uint8_t ioIndex = 0; ioIndex < 2; ioIndex++) {
-			capsIO[ioIndex]->GetWidthRange(&(capsIOS[ioIndex]->minWidth), &(capsIOS[ioIndex]->maxWidth));
-			capsIO[ioIndex]->GetHeightRange(&(capsIOS[ioIndex]->minHeight), &(capsIOS[ioIndex]->maxHeight));
-			capsIOS[ioIndex]->isInterlacedSupported = capsIO[ioIndex]->IsInterlacedSupported();
-			capsIOS[ioIndex]->verticalAlignment = capsIO[ioIndex]->GetVertAlign();
-
-			int32_t numFormats = capsIO[ioIndex]->GetNumOfFormats();
-			capsIOS[ioIndex]->formats.resize(numFormats);
-			for (int32_t formatIndex = 0; formatIndex < numFormats; formatIndex++) {
-				amf::AMF_SURFACE_FORMAT format = amf::AMF_SURFACE_UNKNOWN;
-				bool isNative = false;
-
-				capsIO[ioIndex]->GetFormatAt(formatIndex, &format, &isNative);
-				capsIOS[ioIndex]->formats[formatIndex].first = format;
-				capsIOS[ioIndex]->formats[formatIndex].second = isNative;
-			}
-
-			int32_t numMemoryTypes = capsIO[ioIndex]->GetNumOfMemoryTypes();
-			capsIOS[ioIndex]->memoryTypes.resize(numMemoryTypes);
-			for (int32_t memoryTypeIndex = 0; memoryTypeIndex < numMemoryTypes; memoryTypeIndex++) {
-				amf::AMF_MEMORY_TYPE type = amf::AMF_MEMORY_UNKNOWN;
-				bool isNative = false;
-
-				capsIO[ioIndex]->GetMemoryTypeAt(memoryTypeIndex, &type, &isNative);
-				capsIOS[ioIndex]->memoryTypes[memoryTypeIndex].first = type;
-				capsIOS[ioIndex]->memoryTypes[memoryTypeIndex].second = isNative;
-			}
-		}
-
-		l_AMFComponent->Terminate();
-	}
-	l_AMFContext->Terminate();
-
-	return true;
-}
-
-Plugin::AMD::VCECapabilities::EncoderCaps* Plugin::AMD::VCECapabilities::GetEncoderCaps(VCEEncoderType type) {
-	EncoderCaps* caps[2] = { &m_AVCCaps, &m_SVCCaps };
-	return caps[type];
-}
-
-Plugin::AMD::VCECapabilities::EncoderCaps::IOCaps* Plugin::AMD::VCECapabilities::GetIOCaps(VCEEncoderType type, bool output) {
-	EncoderCaps* caps[2] = { &m_AVCCaps, &m_SVCCaps };
-	if (output)
-		return &caps[type]->output;
-	else
-		return &caps[type]->input;
-}
-

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/amd-amf-vce.cpp Deleted

@@ -1,1825 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "amd-amf-vce.h"
-#include "amd-amf-vce-capabilities.h"
-#include "misc-util.cpp"
-
-#ifdef _WIN32
-#include <windows.h>
-#include <VersionHelpers.h>
-
-#include "api-d3d9.h"
-#include "api-d3d11.h"
-#endif
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-
-// Logging and Exception Helpers
-static void FormatTextWithAMFError(std::vector<char>* buffer, const char* format, AMF_RESULT res) {
-	sprintf(buffer->data(), format, Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);
-}
-
-template<typename _T>
-static void FormatTextWithAMFError(std::vector<char>* buffer, const char* format, _T other, AMF_RESULT res) {
-	sprintf(buffer->data(), format, other, Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);
-}
-
-// Class
-void Plugin::AMD::VCEEncoder::InputThreadMain(Plugin::AMD::VCEEncoder* p_this) {
-	p_this->InputThreadLogic();
-}
-
-void Plugin::AMD::VCEEncoder::OutputThreadMain(Plugin::AMD::VCEEncoder* p_this) {
-	p_this->OutputThreadLogic();
-}
-
-Plugin::AMD::VCEEncoder::VCEEncoder(VCEEncoderType p_Type,
-	VCESurfaceFormat p_SurfaceFormat /*= VCESurfaceFormat_NV12*/,
-	VCEMemoryType p_MemoryType /*= VCEMemoryType_Auto*/,
-	bool p_UseOpenCL /*= false*/, std::string p_DeviceUniqueId /*= ""*/) {
-	AMF_RESULT res;
-
-	AMF_LOG_INFO("<Plugin::AMD::VCEEncoder::VCEEncoder> Initializing...");
-
-	// Solve the optimized away issue.
-	m_EncoderType = p_Type;
-	m_SurfaceFormat = p_SurfaceFormat;
-	m_MemoryType = p_MemoryType;
-	m_UseOpenCL = p_UseOpenCL;
-	m_Flag_IsStarted = false;
-	m_Flag_Threading = true;
-	m_FrameSize.first = 64;	m_FrameSize.second = 64;
-	m_FrameRate.first = 30; m_FrameRate.second = 1;
-	m_FrameRateDivisor = ((double_t)m_FrameRate.first / (double_t)m_FrameRate.second);
-	m_FrameRateReverseDivisor = ((double_t)m_FrameRate.second / (double_t)m_FrameRate.first);
-	m_InputQueueLimit = (uint32_t)(m_FrameRateDivisor * 3);
-	m_InputQueueLastSize = 0;
-	m_TimerPeriod = 1;
-
-	// AMF
-	m_AMF = AMF::GetInstance();
-	m_AMFFactory = m_AMF->GetFactory();
-	/// AMF Context
-	res = m_AMFFactory->CreateContext(&m_AMFContext);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::VCEEncoder> Creating a context object failed with error %ls (code %ld).", res);
-	}
-
-	// Initialize Memory
-	if (m_MemoryType == VCEMemoryType_Auto) { /// Autodetect best setting depending on platform.
-		#if (defined _WIN32) | (defined _WIN64)
-		if (IsWindows8OrGreater()) {
-			m_MemoryType = VCEMemoryType_DirectX11;
-		} else if (IsWindowsXPOrGreater()) {
-			m_MemoryType = VCEMemoryType_DirectX9;
-		} else {
-			m_MemoryType = VCEMemoryType_Host;
-		}
-		#else
-		m_MemoryType = VCEMemoryType_OpenGL;
-		#endif
-	}
-
-	switch (m_MemoryType) {
-		case VCEMemoryType_Host:
-			res = AMF_OK;
-			break;
-			#ifdef _WIN32
-		case VCEMemoryType_OpenGL:
-			if (p_DeviceUniqueId.empty()) {
-				res = m_AMFContext->InitOpenGL(nullptr, nullptr, nullptr);
-			} else {
-				/*m_APIDevice = Plugin::API::OpenGL(Plugin::API::OpenGL::GetDeviceForUniqueId(p_DeviceUniqueId));
-				res = m_AMFContext->InitOpenGL(m_APIDevice.GetContext(), nullptr, nullptr);*/
-			}
-			break;
-		case VCEMemoryType_DirectX11:
-			if (IsWindows8OrGreater()) {
-				if (p_DeviceUniqueId.empty()) {
-					res = m_AMFContext->InitDX11(nullptr);
-				} else {
-					m_APIDevice = Plugin::API::Direct3D11(Plugin::API::Direct3D11::GetDeviceForUniqueId(p_DeviceUniqueId));
-					res = m_AMFContext->InitDX11(m_APIDevice.GetContext());
-				}
-			} else {
-				AMF_LOG_ERROR("<Plugin::AMD::VCEEncoder::VCEEncoder> DirectX 11 is only supported on Windows 8 or newer, using Host Memory Type instead.");
-				m_MemoryType = VCEMemoryType_Host;
-			}
-			break;
-		case VCEMemoryType_DirectX9:
-			if (IsWindowsXPOrGreater()) {
-				if (p_DeviceUniqueId.empty()) {
-					res = m_AMFContext->InitDX9(nullptr);
-				} else {
-					m_APIDevice = Plugin::API::Direct3D9(Plugin::API::Direct3D9::GetDeviceForUniqueId(p_DeviceUniqueId));
-					res = m_AMFContext->InitDX9(m_APIDevice.GetContext());
-				}
-			} else {
-				AMF_LOG_ERROR("<Plugin::AMD::VCEEncoder::VCEEncoder> DirectX 11 is only supported on Windows 8 or newer, using Host Memory Type instead.");
-				m_MemoryType = VCEMemoryType_Host;
-			}
-			break;
-			#endif
-	}
-	if (res != AMF_OK)
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::VCEEncoder> Initializing 3D queue failed with error %ls (code %ld).", res);
-
-	if (m_UseOpenCL) {
-		if (m_MemoryType == VCEMemoryType_Host)
-			ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::VCEEncoder> Use of OpenCL without DirectX or OpenGL is not supported, error %ls (code %d).", AMF_NOT_SUPPORTED);
-
-		res = m_AMFContext->InitOpenCL(nullptr);
-		if (res != AMF_OK)
-			ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::VCEEncoder> InitOpenCL failed with error %ls (code %ld).", res);
-		m_AMFContext->GetCompute(amf::AMF_MEMORY_OPENCL, &m_AMFCompute);
-	}
-
-	/// AMF Component (Encoder)
-	switch (p_Type) {
-		case VCEEncoderType_AVC:
-			res = m_AMFFactory->CreateComponent(m_AMFContext, AMFVideoEncoderVCE_AVC, &m_AMFEncoder);
-			break;
-		case VCEEncoderType_SVC:
-			res = m_AMFFactory->CreateComponent(m_AMFContext, AMFVideoEncoderVCE_SVC, &m_AMFEncoder);
-			break;
-		case VCEEncoderType_HEVC:
-			res = m_AMFFactory->CreateComponent(m_AMFContext, L"AMFVideoEncoderHW_HEVC", &m_AMFEncoder);
-			break;
-	}
-	if (res != AMF_OK)
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::VCEEncoder> Creating a component object failed with error %ls (code %ld).", res);
-
-	AMF_LOG_INFO("<Plugin::AMD::VCEEncoder::VCEEncoder> Initialization complete!");
-}
-
-Plugin::AMD::VCEEncoder::~VCEEncoder() {
-	if (m_Flag_IsStarted)
-		Stop();
-
-	// AMF
-	if (m_AMFEncoder) {
-		m_AMFEncoder->Terminate();
-		m_AMFEncoder = nullptr;
-	}
-	if (m_AMFContext) {
-		m_AMFContext->Terminate();
-		m_AMFContext = nullptr;
-	}
-	m_AMFFactory = nullptr;
-}
-
-void Plugin::AMD::VCEEncoder::Start() {
-	static amf::AMF_SURFACE_FORMAT surfaceFormatToAMF[] = {
-		// 4:2:0 Formats
-		amf::AMF_SURFACE_NV12,
-		amf::AMF_SURFACE_YUV420P,
-		// 4:2:2 Formats
-		amf::AMF_SURFACE_YUY2,
-		// Uncompressed
-		amf::AMF_SURFACE_BGRA,
-		amf::AMF_SURFACE_RGBA,
-		// Other
-		amf::AMF_SURFACE_GRAY8,
-	};
-
-	// Set proper Timer resolution.
-	m_TimerPeriod = 1;
-	while (timeBeginPeriod(m_TimerPeriod) == TIMERR_NOCANDO) {
-		++m_TimerPeriod;
-	}
-
-	// Create Encoder
-	AMF_RESULT res = m_AMFEncoder->Init(surfaceFormatToAMF[m_SurfaceFormat], m_FrameSize.first, m_FrameSize.second);
-	if (res != AMF_OK)
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::Start> Initialization failed with error %ls (code %ld).", res);
-
-	m_Flag_IsStarted = true;
-
-	if (m_Flag_Threading) { // Threading
-		m_Input.thread = std::thread(&(Plugin::AMD::VCEEncoder::InputThreadMain), this);
-		m_Output.thread = std::thread(&(Plugin::AMD::VCEEncoder::OutputThreadMain), this);
-	}
-}
-
-void Plugin::AMD::VCEEncoder::Restart() {
-	static amf::AMF_SURFACE_FORMAT surfaceFormatToAMF[] = {
-		// 4:2:0 Formats
-		amf::AMF_SURFACE_NV12,
-		amf::AMF_SURFACE_YUV420P,
-		// 4:2:2 Formats
-		amf::AMF_SURFACE_YUY2,
-		// Uncompressed
-		amf::AMF_SURFACE_BGRA,
-		amf::AMF_SURFACE_RGBA,
-		// Other
-		amf::AMF_SURFACE_GRAY8,
-	};
-
-	if (!m_Flag_IsStarted)
-		return;
-
-	std::unique_lock<std::mutex> ilock(m_Input.mutex);
-	std::unique_lock<std::mutex> olock(m_Output.mutex);
-
-	// Create Encoder
-	AMF_RESULT res = m_AMFEncoder->ReInit(m_FrameSize.first, m_FrameSize.second);
-	if (res != AMF_OK)
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::Start> Initialization failed with error %ls (code %ld).", res);
-}
-
-void Plugin::AMD::VCEEncoder::Stop() {
-	// Restore Timer precision.
-	if (m_TimerPeriod != 0) {
-		timeEndPeriod(m_TimerPeriod);
-	}
-
-	m_Flag_IsStarted = false;
-	if (m_Flag_Threading) { // Threading
-		m_Output.condvar.notify_all();
-		#if defined _WIN32 || defined _WIN64
-		{ // Windows: Force terminate Thread after 1 second of waiting.
-			std::thread::native_handle_type hnd = m_Output.thread.native_handle();
-
-			uint32_t res = WaitForSingleObject((HANDLE)hnd, 1000);
-			switch (res) {
-				case WAIT_OBJECT_0:
-					m_Output.thread.join();
-					break;
-				default:
-					m_Output.thread.detach();
-					TerminateThread((HANDLE)hnd, 0);
-					break;
-			}
-		}
-		#endif
-
-		m_Input.condvar.notify_all();
-		#if defined _WIN32 || defined _WIN64
-		{ // Windows: Force terminate Thread after 1 second of waiting.
-			std::thread::native_handle_type hnd = m_Input.thread.native_handle();
-
-			uint32_t res = WaitForSingleObject((HANDLE)hnd, 1000);
-			switch (res) {
-				case WAIT_OBJECT_0:
-					m_Input.thread.join();
-					break;
-				default:
-					m_Input.thread.detach();
-					TerminateThread((HANDLE)hnd, 0);
-					break;
-			}
-		}
-		#endif
-	}
-
-	// Stop AMF Encoder
-	if (m_AMFEncoder) {
-		m_AMFEncoder->Drain();
-		m_AMFEncoder->Flush();
-	}
-
-	// Clear Queues, Data
-	std::queue<amf::AMFSurfacePtr>().swap(m_Input.queue);
-	std::queue<amf::AMFDataPtr>().swap(m_Output.queue);
-	m_PacketDataBuffer.clear();
-	m_ExtraDataBuffer.clear();
-}
-
-bool Plugin::AMD::VCEEncoder::SendInput(struct encoder_frame* frame) {
-	// Early-Exception if not encoding.
-	if (!m_Flag_IsStarted) {
-		const char* error = "<Plugin::AMD::VCEEncoder::SendInput> Attempted to send input while not running.";
-		AMF_LOG_ERROR("%s", error);
-		throw std::exception(error);
-	}
-
-	// Convert Frame into a Surface and queue it.
-	if (frame != nullptr) {
-		amf::AMFSurfacePtr pAMFSurface = CreateSurfaceFromFrame(frame);
-		if (pAMFSurface) {
-			// Set Surface Properties
-			pAMFSurface->SetPts(frame->pts / m_FrameRate.second);
-			pAMFSurface->SetProperty(L"Frame", frame->pts);
-
-			// Add to Queue
-			std::unique_lock<std::mutex> qlock(m_Input.queuemutex);
-			size_t uiQueueSize = m_Input.queue.size();
-
-			if (uiQueueSize >= m_InputQueueLimit) {
-				AMF_LOG_WARNING("<Plugin::AMD::VCEEncoder::SendInput> Input Queue is full, dropping frame...");
-			} else {
-				m_Input.queue.push(pAMFSurface);
-
-				if (m_InputQueueLastSize != uiQueueSize) {
-					int32_t delta = ((int32_t)uiQueueSize - (int32_t)m_InputQueueLastSize);
-					if (uiQueueSize == 0) {
-						AMF_LOG_INFO("<Plugin::AMD::VCEEncoder::SendInput> Input Queue is empty. (%d/%d/%d)", uiQueueSize, (uiQueueSize - m_InputQueueLastSize), m_InputQueueLimit);
-						m_InputQueueLastSize = uiQueueSize;
-					} else if (delta >= 5) {
-						AMF_LOG_WARNING("<Plugin::AMD::VCEEncoder::SendInput> Input Queue is growing. (%d/%d/%d)", uiQueueSize, (uiQueueSize - m_InputQueueLastSize), m_InputQueueLimit);
-						m_InputQueueLastSize = uiQueueSize;
-					} else if (delta <= -5) {
-						AMF_LOG_INFO("<Plugin::AMD::VCEEncoder::SendInput> Input Queue is shrinking. (%d/%d/%d)", uiQueueSize, (uiQueueSize - m_InputQueueLastSize), m_InputQueueLimit);
-						m_InputQueueLastSize = uiQueueSize;
-					}
-				}
-			}
-		} else {
-			AMF_LOG_ERROR("<Plugin::AMD::VCEEncoder::SendInput> Critical error while trying to create a frame.");
-			return false;
-		}
-	}
-
-	if (m_Flag_Threading) { // Threading
-		/// Signal Thread Wakeup
-		m_Input.condvar.notify_all();
-	} else { // No Threading
-		AMF_RESULT res = AMF_OK;
-		while (res == AMF_OK) {
-			if (m_Input.queue.size() == 0) {
-				res = AMF_NEED_MORE_INPUT;
-				break;
-			}
-
-			// Dequeue a Surface.
-			amf::AMFSurfacePtr pAMFSurface = m_Input.queue.front();
-			if (pAMFSurface) {
-				res = m_AMFEncoder->SubmitInput(pAMFSurface);
-				if (res == AMF_OK) {
-					m_Input.queue.pop();
-				} else if (res == AMF_INPUT_FULL) {
-					if (frame != nullptr)
-						GetOutput(nullptr, nullptr);
-				} else {
-					AMF_LOG_ERROR("<Plugin::AMD::VCEEncoder::SendInput> SubmitInput returned error %ls (code %lld).", m_AMF->GetTrace()->GetResultText(res), res);
-				}
-			}
-		}
-	}
-
-	return true;
-}
-
-void Plugin::AMD::VCEEncoder::GetOutput(struct encoder_packet* packet, bool* received_packet) {
-	// Early-Exception if not encoding.
-	if (!m_Flag_IsStarted) {
-		const char* error = "<Plugin::AMD::VCEEncoder::GetOutput> Attempted to send input while not running.";
-		AMF_LOG_ERROR("%s", error);
-		throw std::exception(error);
-	}
-
-	if (m_Flag_Threading) { // Threading
-		// Query Output
-		m_Output.condvar.notify_all();
-	} else { // No Threading
-		int64_t __amf_repeat_count = 0;
-
-		AMF_RESULT res = AMF_OK;
-		while (res == AMF_OK) {
-			amf::AMFDataPtr pAMFData;
-			res = m_AMFEncoder->QueryOutput(&pAMFData);
-			if (res == AMF_OK) {
-				std::unique_lock<std::mutex> qlock(m_Output.queuemutex);
-				m_Output.queue.push(pAMFData);
-			} else if (res == AMF_REPEAT) {
-				if (m_Input.queue.size() == 0)
-					continue;
-				if (__amf_repeat_count < 5) {
-					if (received_packet != nullptr) {
-						SendInput(nullptr);
-
-						res = AMF_OK;
-						__amf_repeat_count++;
-					}
-				} else {
-					__amf_repeat_count = 0;
-				}
-			} else {
-				AMF_LOG_ERROR("<Plugin::AMD::VCEEncoder::GetOutput> QueryOutput returned error %ls (code %lld).", m_AMF->GetTrace()->GetResultText(res), res);
-			}
-		}
-	}
-
-	if (received_packet != nullptr) {
-		amf::AMFDataPtr pAMFData;
-		{ // Attempt to dequeue an Item.
-			std::unique_lock<std::mutex> qlock(m_Output.queuemutex);
-			if (m_Output.queue.size() == 0)
-				return;
-
-			pAMFData = m_Output.queue.front();
-			m_Output.queue.pop();
-		}
-
-		// We've got a DataPtr, let's use it.
-		amf::AMFBufferPtr pAMFBuffer = amf::AMFBufferPtr(pAMFData);
-
-		// Assemble Packet
-		packet->type = OBS_ENCODER_VIDEO;
-		/// Data
-		size_t uiBufferSize = pAMFBuffer->GetSize();
-		if (m_PacketDataBuffer.size() < uiBufferSize) {
-			size_t newSize = (size_t)exp2(ceil(log2(uiBufferSize)));
-			m_PacketDataBuffer.resize(newSize);
-			AMF_LOG_WARNING("<AMFEncoder::VCE::GetOutput> Resized Packet Buffer to %d.", newSize);
-		}
-		packet->data = m_PacketDataBuffer.data();
-		packet->size = uiBufferSize;
-		std::memcpy(packet->data, pAMFBuffer->GetNative(), packet->size);
-		/// Timestamps
-		packet->dts = (pAMFData->GetPts() - 2) * m_FrameRate.second; // Offset by 2 to support B-Pictures
-		pAMFBuffer->GetProperty(L"Frame", &packet->pts);
-		{ /// Packet Priority & Keyframe
-			uint64_t pktType;
-			pAMFData->GetProperty(AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE, &pktType);
-
-			switch ((AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_ENUM)pktType) {
-				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_IDR://
-					packet->keyframe = true;				// IDR-Frames are Key-Frames that contain a lot of information.
-					packet->priority = 3;					// Highest priority, always continue streaming with these.
-					packet->drop_priority = 3;				// Dropped IDR-Frames can only be replaced by the next IDR-Frame.
-					break;
-				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_I:	// I-Frames need only a previous I- or IDR-Frame.
-					packet->priority = 2;					// I- and IDR-Frames will most likely be present.
-					packet->drop_priority = 2;				// So we can continue with a I-Frame when streaming.
-					break;
-				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_P:	// P-Frames need either a previous P-, I- or IDR-Frame.
-					packet->priority = 1;					// We can safely assume that at least one of these is present.
-					packet->drop_priority = 1;				// So we can continue with a P-Frame when streaming.
-					break;
-				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_B:	// B-Frames need either a parent B-, P-, I- or IDR-Frame.
-					packet->priority = 0;					// We don't know if the last non-dropped frame was a B-Frame.
-					packet->drop_priority = 1;				// So require a P-Frame or better to continue streaming.
-					break;
-			}
-		}
-		*received_packet = true;
-
-		// Debug: Packet Information
-		std::vector<wchar_t> fileName(128);
-		mbstowcs(fileName.data(), __FILE__, fileName.size());
-		std::vector<wchar_t> functionName(128);
-		mbstowcs(functionName.data(), __FUNCTION__, functionName.size());
-		m_AMF->GetTrace()->TraceW(fileName.data(), __LINE__, AMF_TRACE_TRACE, L"Plugin::GetOutput", 4, L"Packet: Type(%lld), PTS(%4lld), DTS(%4lld), Size(%8lld)", (int64_t)packet->priority, (int64_t)packet->pts, (int64_t)packet->dts, (int64_t)packet->size);
-	}
-}
-
-bool Plugin::AMD::VCEEncoder::GetExtraData(uint8_t**& extra_data, size_t*& extra_data_size) {
-	if (!m_AMFContext || !m_AMFEncoder)
-		throw std::exception("<Plugin::AMD::VCEEncoder::GetExtraData> Called while not initialized.");
-
-	if (!m_Flag_IsStarted)
-		throw std::exception("<Plugin::AMD::VCEEncoder::GetExtraData> Called while not encoding.");
-
-	amf::AMFVariant var;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_EXTRADATA, &var);
-	if (res == AMF_OK && var.type == amf::AMF_VARIANT_INTERFACE) {
-		amf::AMFBufferPtr buf(var.pInterface);
-
-		*extra_data_size = buf->GetSize();
-		m_ExtraDataBuffer.resize(*extra_data_size);
-		std::memcpy(m_ExtraDataBuffer.data(), buf->GetNative(), *extra_data_size);
-		*extra_data = m_ExtraDataBuffer.data();
-
-		return true;
-	}
-	return false;
-}
-
-void Plugin::AMD::VCEEncoder::GetVideoInfo(struct video_scale_info*& vsi) {
-	if (!m_AMFContext || !m_AMFEncoder)
-		throw std::exception("<Plugin::AMD::VCEEncoder::GetVideoInfo> Called while not initialized.");
-
-	if (!m_Flag_IsStarted)
-		throw std::exception("<Plugin::AMD::VCEEncoder::GetVideoInfo> Called while not encoding.");
-
-	switch (m_SurfaceFormat) {
-		// 4:2:0 Formats
-		case VCESurfaceFormat_NV12:
-			vsi->format = VIDEO_FORMAT_NV12;
-			break;
-		case VCESurfaceFormat_I420:
-			vsi->format = VIDEO_FORMAT_I420;
-			break;
-		// 4:2:2 Formats
-		case VCESurfaceFormat_YUY2:
-			vsi->format = VIDEO_FORMAT_YUY2;
-			break;
-		// Uncompressed
-		case VCESurfaceFormat_RGBA:
-			vsi->format = VIDEO_FORMAT_RGBA;
-			break;
-		case VCESurfaceFormat_BGRA:
-			vsi->format = VIDEO_FORMAT_BGRA;
-			break;
-		// Other
-		case VCESurfaceFormat_GRAY:
-			vsi->format = VIDEO_FORMAT_Y800;
-			break;
-	}
-
-	// AMF requires Partial Range for some reason.
-	// Also Colorspace is automatic, see: https://github.com/GPUOpen-LibrariesAndSDKs/AMF/issues/6#issuecomment-243473568
-	vsi->range = VIDEO_RANGE_PARTIAL;
-	if (vsi->height <= 780)
-		vsi->colorspace = VIDEO_CS_601;
-	else
-		vsi->colorspace = VIDEO_CS_709;
-}
-
-void Plugin::AMD::VCEEncoder::InputThreadLogic() {	// Thread Loop that handles Surface Submission
-	// Assign Thread Name
-	static const char* __threadName = "enc-amf Input Thread";
-	SetThreadName(__threadName);
-	
-	// Core Loop
-	std::unique_lock<std::mutex> lock(m_Input.mutex);
-	uint32_t repeatSurfaceSubmission = 0;
-	do {
-		m_Input.condvar.wait(lock);
-
-		// Skip to check if isStarted is false.
-		if (!m_Flag_IsStarted)
-			continue;
-
-		// Dequeue Surface
-		amf::AMFSurfacePtr surface;
-		{
-			std::unique_lock<std::mutex> qlock(m_Input.queuemutex);
-			if (m_Input.queue.size() == 0)
-				continue; // Queue is empty, 
-			surface = m_Input.queue.front();
-		}
-
-		/// Submit to AMF
-		AMF_RESULT res = m_AMFEncoder->SubmitInput(surface);
-		if (res == AMF_OK) {
-			{ // Remove Surface from Queue
-				std::unique_lock<std::mutex> qlock(m_Input.queuemutex);
-				m_Input.queue.pop();
-			}
-
-			// Reset AMF_INPUT_FULL retries.
-			repeatSurfaceSubmission = 0;
-
-			// Continue with next Surface.
-			m_Input.condvar.notify_all();
-		} else if (res == AMF_INPUT_FULL) {
-			m_Output.condvar.notify_all();
-			if (repeatSurfaceSubmission < 5) {
-				repeatSurfaceSubmission++;
-
-				std::this_thread::sleep_for(std::chrono::milliseconds(1));
-				m_Input.condvar.notify_all();
-			}
-		} else if (res == AMF_EOF) {
-			// This should never happen, but on the off-chance that it does, just straight up leave the loop.
-			break;
-		} else {
-			// Unknown, unexpected return code.
-			std::vector<char> msgBuf(128);
-			FormatTextWithAMFError(&msgBuf, "%ls (code %d)", Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);
-			AMF_LOG_WARNING("<Plugin::AMD::VCEEncoder::InputThreadLogic> SubmitInput failed with error %s.", msgBuf.data());
-		}
-	} while (m_Flag_IsStarted);
-}
-
-void Plugin::AMD::VCEEncoder::OutputThreadLogic() {	// Thread Loop that handles Querying
-	// Assign Thread Name
-	static const char* __threadName = "enc-amf Output Thread";
-	SetThreadName(__threadName);
-
-	// Core Loop
-	std::unique_lock<std::mutex> lock(m_Output.mutex);
-	do {
-		m_Output.condvar.wait(lock);
-
-		// Skip to check if isStarted is false.
-		if (!m_Flag_IsStarted)
-			continue;
-
-		amf::AMFDataPtr pData;
-		AMF_RESULT res = m_AMFEncoder->QueryOutput(&pData);
-		if (res == AMF_OK) {
-			{ // Queue
-				std::unique_lock<std::mutex> qlock(m_Output.queuemutex);
-				m_Output.queue.push(pData);
-			}
-
-			// Continue querying until nothing is left.
-			m_Output.condvar.notify_all();
-		} else if (res == AMF_REPEAT) {
-			m_Input.condvar.notify_all();
-		} else if (res == AMF_EOF) {
-			// This should never happen, but on the off-chance that it does, just straight up leave the loop.
-			break;
-		} else {
-			// Unknown, unexpected return code.
-			std::vector<char> msgBuf(128);
-			FormatTextWithAMFError(&msgBuf, "%s (code %d)", res);
-			AMF_LOG_WARNING("<Plugin::AMD::VCEEncoder::OutputThreadLogic> QueryOutput failed with error %s.", msgBuf.data());
-		}
-	} while (m_Flag_IsStarted);
-}
-
-amf::AMFSurfacePtr Plugin::AMD::VCEEncoder::CreateSurfaceFromFrame(struct encoder_frame*& frame) {
-	static amf::AMF_SURFACE_FORMAT surfaceFormatToAMF[] = {
-		// 4:2:0 Formats
-		amf::AMF_SURFACE_NV12,
-		amf::AMF_SURFACE_YUV420P,
-		// 4:2:2 Formats
-		amf::AMF_SURFACE_YUY2,
-		// Uncompressed
-		amf::AMF_SURFACE_BGRA,
-		amf::AMF_SURFACE_RGBA,
-		// Other
-		amf::AMF_SURFACE_GRAY8,
-	};
-	amf::AMF_MEMORY_TYPE memoryTypeToAMF[] = {
-		amf::AMF_MEMORY_HOST,
-		amf::AMF_MEMORY_DX9,
-		amf::AMF_MEMORY_DX11,
-		amf::AMF_MEMORY_OPENGL,
-	};
-
-	AMF_RESULT res = AMF_UNEXPECTED;
-	amf::AMFSurfacePtr pSurface = nullptr;
-	if (m_UseOpenCL) {
-		amf_size l_origin[] = { 0, 0, 0 };
-		amf_size l_size0[] = { m_FrameSize.first, m_FrameSize.second, 1 };
-		amf_size l_size1[] = { m_FrameSize.first >> 1, m_FrameSize.second >> 1, 1 };
-
-		res = m_AMFContext->AllocSurface(memoryTypeToAMF[m_MemoryType], surfaceFormatToAMF[m_SurfaceFormat], m_FrameSize.first, m_FrameSize.second, &pSurface);
-		if (res != AMF_OK) // Unable to create Surface
-			ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::CreateSurfaceFromFrame> Unable to create AMFSurface, error %ls (code %d).", res);
-
-		amf::AMFComputeSyncPointPtr pSyncPoint;
-		m_AMFCompute->PutSyncPoint(&pSyncPoint);
-		pSurface->Convert(amf::AMF_MEMORY_OPENCL);
-		m_AMFCompute->CopyPlaneFromHost(frame->data[0], l_origin, l_size0, frame->linesize[0], pSurface->GetPlaneAt(0), false);
-		m_AMFCompute->CopyPlaneFromHost(frame->data[1], l_origin, l_size1, frame->linesize[1], pSurface->GetPlaneAt(1), false);
-		m_AMFCompute->FinishQueue();
-		pSurface->Convert(memoryTypeToAMF[m_MemoryType]);
-		pSyncPoint->Wait();
-	} else {
-		res = m_AMFContext->AllocSurface(amf::AMF_MEMORY_HOST, surfaceFormatToAMF[m_SurfaceFormat], m_FrameSize.first, m_FrameSize.second, &pSurface);
-		if (res != AMF_OK) // Unable to create Surface
-			ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::CreateSurfaceFromFrame> Unable to create AMFSurface, error %ls (code %d).", res);
-
-		size_t planeCount = pSurface->GetPlanesCount();
-		for (uint8_t i = 0; i < planeCount; i++) {
-			amf::AMFPlanePtr plane = pSurface->GetPlaneAt(i);
-			void* plane_nat = plane->GetNative();
-			int32_t height = plane->GetHeight();
-			int32_t hpitch = plane->GetHPitch();
-
-			for (int32_t py = 0; py < height; py++) {
-				int32_t plane_off = py * hpitch;
-				int32_t frame_off = py * frame->linesize[i];
-				std::memcpy(static_cast<void*>(static_cast<uint8_t*>(plane_nat) + plane_off), static_cast<void*>(frame->data[i] + frame_off), frame->linesize[i]);
-			}
-		}
-
-		// Convert to AMF native type.
-		pSurface->Convert(memoryTypeToAMF[m_MemoryType]);
-	}
-
-	return pSurface;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// AMF Properties
-//////////////////////////////////////////////////////////////////////////
-
-void Plugin::AMD::VCEEncoder::LogProperties() {
-	static const char* memoryTypeToString[] = {
-		"Host",
-		"DirectX9",
-		"DirectX11",
-		"OpenGL",
-	};
-	static const char* surfaceFormatToString[] = {
-		"NV12",
-		"I420",
-		"RGBA",
-	};
-	static const char* usageToString[] = {
-		"Transcoding",
-		"Ultra Low Latency",
-		"Low Latency",
-		"Webcam"
-	};
-	static const char* qualityPresetToString[] = {
-		"Speed",
-		"Balanced",
-		"Quality"
-	};
-	static const char* profileToString[] = {
-		"Baseline",
-		"Main",
-		"High"
-	};
-	static const char* rateControlMethodToString[] = {
-		"Constant Quantization Parameter (CQP)",
-		"Constant Bitrate (CBR)",
-		"Peak Constrained Variable Bitrate (VBR)",
-		"Latency Constrained Variable Bitrate (VBR_LAT)"
-	};
-
-	AMF_LOG_INFO("-- AMD Advanced Media Framework VCE Encoder --");
-	AMF_LOG_INFO("Initialization Parameters: ");
-	AMF_LOG_INFO(" Memory Type: %s", memoryTypeToString[m_MemoryType]);
-	AMF_LOG_INFO(" Device: %s", m_APIDevice.GetDevice().Name);
-	AMF_LOG_INFO(" OpenCL: %s", m_UseOpenCL ? "Disabled" : "Enabled");
-	AMF_LOG_INFO(" Surface Format: %s", surfaceFormatToString[max(m_SurfaceFormat,0)]);
-	AMF_LOG_INFO("Static Parameters: ");
-	AMF_LOG_INFO(" Usage: %s", usageToString[this->GetUsage()]);
-	AMF_LOG_INFO(" Quality Preset: %s", qualityPresetToString[this->GetQualityPreset()]);
-	AMF_LOG_INFO(" Profile: %s %d.%d", this->GetProfile() == 66 ? "Baseline" : (this->GetProfile() == 77 ? "Main" : "High"), this->GetProfileLevel() / 10, this->GetProfileLevel() % 10);
-	AMF_LOG_INFO(" Maximum Long-Term Reference Frames: %d", this->GetMaximumLongTermReferenceFrames());
-	AMF_LOG_INFO("Frame Parameters: ");
-	AMF_LOG_INFO(" Frame Size: %dx%d", this->GetFrameSize().first, this->GetFrameSize().second);
-	AMF_LOG_INFO(" Frame Rate: %d/%d", this->GetFrameRate().first, this->GetFrameRate().second);
-	AMF_LOG_INFO("Rate Control Parameters: ");
-	AMF_LOG_INFO(" Method: %s", rateControlMethodToString[this->GetRateControlMethod()]);
-	AMF_LOG_INFO(" Frame Skipping Enabled: %s", this->IsFrameSkippingEnabled() ? "Yes" : "No");
-	AMF_LOG_INFO(" Filler Data Enabled: %s", this->IsFillerDataEnabled() ? "Yes" : "No");
-	AMF_LOG_INFO(" Enforce HRD Restrictions: %s", this->IsEnforceHRDRestrictionsEnabled() ? "Yes" : "No");
-	AMF_LOG_INFO(" Maximum Access Unit Size: %d bits", this->GetMaximumAccessUnitSize());
-	AMF_LOG_INFO(" Bitrate: ");
-	AMF_LOG_INFO(" Target: %d bits", this->GetTargetBitrate());
-	AMF_LOG_INFO(" Peak: %d bits", this->GetPeakBitrate());
-	AMF_LOG_INFO(" Quantization Parameter: ");
-	AMF_LOG_INFO(" Minimum: %d", this->GetMinimumQP());
-	AMF_LOG_INFO(" Maximum: %d", this->GetMaximumQP());
-	AMF_LOG_INFO(" I-Frame: %d", this->GetIFrameQP());
-	AMF_LOG_INFO(" P-Frame: %d", this->GetPFrameQP());
-	AMF_LOG_INFO(" B-Frame: %d", this->GetBFrameQP());
-	try {
-		AMF_LOG_INFO(" B-Picture Delta QP: %d", this->GetBPictureDeltaQP());
-	} catch (...) {
-		AMF_LOG_INFO(" B-Picture Delta QP: N/A");
-	}
-	try {
-		AMF_LOG_INFO(" Reference B-Picture Delta QP: %d", this->GetReferenceBPictureDeltaQP());
-	} catch (...) {
-		AMF_LOG_INFO(" Reference B-Picture Delta QP: N/A");
-	}
-	AMF_LOG_INFO(" VBV Buffer: ");
-	AMF_LOG_INFO(" Size: %d bits", this->GetVBVBufferSize());
-	AMF_LOG_INFO(" Initial Fullness: %f%%", this->GetInitialVBVBufferFullness() * 100.0);
-	AMF_LOG_INFO("Picture Control Parameters: ");
-	AMF_LOG_INFO(" IDR Period: %d frames", this->GetIDRPeriod());
-	AMF_LOG_INFO(" Header Insertion Spacing: %d frames", this->GetHeaderInsertionSpacing());
-	AMF_LOG_INFO(" Deblocking Filter Enabled: %s", this->IsDeblockingFilterEnabled() ? "Yes" : "No");
-	AMF_LOG_INFO(" B-Picture Pattern: %d", this->GetBPicturePattern());
-	AMF_LOG_INFO(" B-Picture Reference Enabled: %s", this->IsBPictureReferenceEnabled() ? "Yes" : "No");
-	AMF_LOG_INFO(" Intra-Refresh MBs Number per Slot: %d", this->GetIntraRefreshMBsNumberPerSlot());
-	AMF_LOG_INFO(" Slices Per Frame: %d", this->GetSlicesPerFrame());
-	AMF_LOG_INFO(" Scan Type: %s", this->GetScanType() == VCEScanType_Progressive ? "Progressive" : "Interlaced");
-	AMF_LOG_INFO("Motion Estimation Parameters: ");
-	AMF_LOG_INFO(" Half Pixel: %s", this->IsHalfPixelMotionEstimationEnabled() ? "Enabled" : "Disabled");
-	AMF_LOG_INFO(" Quarter Pixel: %s", this->IsQuarterPixelMotionEstimationEnabled() ? "Enabled" : "Disabled");
-	AMF_LOG_INFO("Experimental Parameters: ");
-	AMF_LOG_INFO(" Nominal Range: %s", this->GetNominalRange() ? "Enabled" : "Disabled");
-	AMF_LOG_INFO(" Wait For Task: %s", this->GetWaitForTask() ? "Enabled" : "Disabled");
-	AMF_LOG_INFO(" Aspect Ratio: %d:%d", this->GetAspectRatio().first, this->GetAspectRatio().second);
-	AMF_LOG_INFO(" CABAC: %s", this->IsCABACEnabled() ? "Enabled" : "Disabled");
-}
-
-/************************************************************************/
-/* Static Properties */
-/************************************************************************/
-
-void Plugin::AMD::VCEEncoder::SetUsage(VCEUsage usage) {
-	static AMF_VIDEO_ENCODER_USAGE_ENUM customToAMF[] = {
-		AMF_VIDEO_ENCODER_USAGE_TRANSCONDING,
-		AMF_VIDEO_ENCODER_USAGE_ULTRA_LOW_LATENCY,
-		AMF_VIDEO_ENCODER_USAGE_LOW_LATENCY,
-		AMF_VIDEO_ENCODER_USAGE_WEBCAM,
-	};
-	static char* customToName[] = {
-		"Transcoding",
-		"Ultra Low Latency",
-		"Low Latency",
-		"WebCam"
-	};
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_USAGE, (uint32_t)customToAMF[usage]);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetUsage> Setting to %s failed with error %ls (code %d).", res, customToName[usage]);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetUsage> Set to %s.", customToName[usage]);
-}
-
-Plugin::AMD::VCEUsage Plugin::AMD::VCEEncoder::GetUsage() {
-	static VCEUsage AMFToCustom[] = {
-		VCEUsage_Transcoding,
-		VCEUsage_UltraLowLatency,
-		VCEUsage_LowLatency,
-		VCEUsage_Webcam
-	};
-	static char* customToName[] = {
-		"Transcoding",
-		"Ultra Low Latency",
-		"Low Latency",
-		"WebCam"
-	};
-
-	uint32_t usage;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_USAGE, &usage);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetUsage> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetUsage> Value is %s.", customToName[AMFToCustom[usage]]);
-	return AMFToCustom[usage];
-}
-
-void Plugin::AMD::VCEEncoder::SetProfile(VCEProfile profile) {
-	if ((profile != VCEProfile_High) && (profile != VCEProfile_Main) && (profile != VCEProfile_Baseline)) {
-		profile = VCEProfile_Baseline;
-	}
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_PROFILE, (uint32_t)profile);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetProfile> Setting to %s failed with error %ls (code %d).", res, (profile == 100 ? "High" : (profile == 77 ? "Main" : "Baseline")));
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetProfile> Set to %s.", (profile == 100 ? "High" : (profile == 77 ? "Main" : "Baseline")));
-}
-
-Plugin::AMD::VCEProfile Plugin::AMD::VCEEncoder::GetProfile() {
-	uint32_t profile;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_PROFILE, &profile);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetProfile> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetProfile> Value is %s.", (profile == 100 ? "High" : (profile == 77 ? "Main" : "Baseline")));
-	return (VCEProfile)profile;
-}
-
-void Plugin::AMD::VCEEncoder::SetProfileLevel(VCEProfileLevel level) {
-	// Automatic Detection
-	if (level == VCEProfileLevel_Automatic) {
-		auto frameSize = this->GetFrameSize();
-		auto frameRate = this->GetFrameRate();
-		level = Plugin::Utility::GetMinimumProfileLevel(frameSize, frameRate);
-	}
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_PROFILE_LEVEL, (uint32_t)level);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetProfile> Setting to %d failed with error %ls (code %d).", res, level);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetProfile> Set to %d.", level);
-}
-
-Plugin::AMD::VCEProfileLevel Plugin::AMD::VCEEncoder::GetProfileLevel() {
-	uint32_t profileLevel;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_PROFILE_LEVEL, &profileLevel);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetProfileLevel> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetProfileLevel> Value is %d.", profileLevel);
-	return (VCEProfileLevel)(profileLevel);
-}
-
-void Plugin::AMD::VCEEncoder::SetMaximumLongTermReferenceFrames(uint32_t maximumLTRFrames) {
-	// Clamp Parameter Value
-	maximumLTRFrames = max(min(maximumLTRFrames, 2), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MAX_LTR_FRAMES, (uint32_t)maximumLTRFrames);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetMaxLTRFrames> Setting to %d failed with error %ls (code %d).", res, maximumLTRFrames);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetMaxLTRFrames> Set to %d.", maximumLTRFrames);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetMaximumLongTermReferenceFrames() {
-	uint32_t maximumLTRFrames;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MAX_LTR_FRAMES, &maximumLTRFrames);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetMaxLTRFrames> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetMaxLTRFrames> Value is %d.", maximumLTRFrames);
-	return maximumLTRFrames;
-}
-
-
-/************************************************************************/
-/* Resolution Properties */
-/************************************************************************/
-
-void Plugin::AMD::VCEEncoder::SetFrameSize(uint32_t width, uint32_t height) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_FRAMESIZE, ::AMFConstructSize(width, height));
-	if (res != AMF_OK) {
-		std::vector<char> msgBuf(128);
-		sprintf(msgBuf.data(), "%dx%d", width, height);
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetFrameSize> Setting to %s failed with error %ls (code %d).", res, msgBuf.data());
-	}
-	m_FrameSize.first = width;
-	m_FrameSize.second = height;
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetFrameSize> Set to %dx%d.", width, height);
-}
-
-std::pair<uint32_t, uint32_t> Plugin::AMD::VCEEncoder::GetFrameSize() {
-	AMFSize frameSize;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_FRAMESIZE, &frameSize);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetFrameSize> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetFrameSize> Value is %dx%d.", frameSize.width, frameSize.height);
-	m_FrameSize.first = frameSize.width;
-	m_FrameSize.second = frameSize.height;
-	return std::pair<uint32_t, uint32_t>(m_FrameSize);
-}
-
-void Plugin::AMD::VCEEncoder::SetFrameRate(uint32_t num, uint32_t den) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_FRAMERATE, ::AMFConstructRate(num, den));
-	if (res != AMF_OK) {
-		std::vector<char> msgBuf;
-		sprintf(msgBuf.data(), "%d/%d", num, den);
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetFrameRate> Setting to %s failed with error %ls (code %d).", res, msgBuf.data());
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetFrameRate> Set to %d/%d.", num, den);
-	m_FrameRate.first = num;
-	m_FrameRate.second = den;
-	m_FrameRateDivisor = (double_t)m_FrameRate.first / (double_t)m_FrameRate.second;
-	m_FrameRateReverseDivisor = ((double_t)m_FrameRate.second / (double_t)m_FrameRate.first);
-	m_InputQueueLimit = (uint32_t)ceil(m_FrameRateDivisor * 3);
-
-	if (m_Flag_IsStarted) { // Change Timer precision if encoding.
-		if (m_TimerPeriod != 0) {
-			// Restore Timer precision.
-			timeEndPeriod(m_TimerPeriod);
-		}
-
-		m_TimerPeriod = 1;
-		while (timeBeginPeriod(m_TimerPeriod) == TIMERR_NOCANDO) {
-			++m_TimerPeriod;
-		}
-	}
-}
-
-std::pair<uint32_t, uint32_t> Plugin::AMD::VCEEncoder::GetFrameRate() {
-	AMFRate frameRate;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_FRAMERATE, &frameRate);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetFrameRate> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetFrameRate> Value is %d/%d.", frameRate.num, frameRate.den);
-	m_FrameRate.first = frameRate.num;
-	m_FrameRate.second = frameRate.den;
-	m_FrameRateDivisor = (double_t)frameRate.num / (double_t)frameRate.den;
-	m_InputQueueLimit = (uint32_t)ceil(m_FrameRateDivisor * 3);
-	return std::pair<uint32_t, uint32_t>(m_FrameRate);
-}
-
-/************************************************************************/
-/* Rate Control Properties */
-/************************************************************************/
-
-void Plugin::AMD::VCEEncoder::SetRateControlMethod(VCERateControlMethod method) {
-	static AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_ENUM CustomToAMF[] = {
-		AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_CONSTANT_QP,
-		AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_CBR,
-		AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR,
-		AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_LATENCY_CONSTRAINED_VBR,
-	};
-	static char* CustomToName[] = {
-		"Constant Quantization Parameter",
-		"Constant Bitrate",
-		"Peak Constrained Variable Bitrate",
-		"Latency Constrained Variable Bitrate",
-	};
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD, (uint32_t)CustomToAMF[method]);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetRateControlMethod> Setting to %s failed with error %ls (code %d).", res, CustomToName[method]);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetRateControlMethod> Set to %s.", CustomToName[method]);
-}
-
-Plugin::AMD::VCERateControlMethod Plugin::AMD::VCEEncoder::GetRateControlMethod() {
-	static VCERateControlMethod AMFToCustom[] = {
-		VCERateControlMethod_ConstantQP,
-		VCERateControlMethod_ConstantBitrate,
-		VCERateControlMethod_VariableBitrate_PeakConstrained,
-		VCERateControlMethod_VariableBitrate_LatencyConstrained,
-	};
-	static char* CustomToName[] = {
-		"Constant Quantization Parameter",
-		"Constant Bitrate",
-		"Peak Constrained Variable Bitrate",
-		"Latency Constrained Variable Bitrate",
-	};
-
-	uint32_t method;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD, &method);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetRateControlMethod> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetRateControlMethod> Value is %s.", CustomToName[AMFToCustom[method]]);
-	return AMFToCustom[method];
-}
-
-void Plugin::AMD::VCEEncoder::SetTargetBitrate(uint32_t bitrate) {
-	// Clamp Value
-	if (bitrate != 0)
-		bitrate = min(max(bitrate, 10000), Plugin::AMD::VCECapabilities::GetInstance()->GetEncoderCaps(m_EncoderType)->maxBitrate);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_TARGET_BITRATE, bitrate);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetTargetBitrate> Setting to %d bits failed with error %ls (code %d).", res, bitrate);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetTargetBitrate> Set to %d bits.", bitrate);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetTargetBitrate() {
-	uint32_t bitrate;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_TARGET_BITRATE, &bitrate);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetTargetBitrate> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetTargetBitrate> Value is %d bits.", bitrate);
-	return bitrate;
-}
-
-void Plugin::AMD::VCEEncoder::SetPeakBitrate(uint32_t bitrate) {
-	// Clamp Value
-	if (bitrate != 0)
-		bitrate = min(max(bitrate, 10000), Plugin::AMD::VCECapabilities::GetInstance()->GetEncoderCaps(m_EncoderType)->maxBitrate);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_PEAK_BITRATE, (uint32_t)bitrate);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetPeakBitrate> Setting to %d bits failed with error %ls (code %d).", res, bitrate);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetPeakBitrate> Set to %d bits.", bitrate);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetPeakBitrate() {
-	uint32_t bitrate;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_PEAK_BITRATE, &bitrate);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetPeakBitrate> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetPeakBitrate> Value is %d bits.", bitrate);
-	return bitrate;
-}
-
-void Plugin::AMD::VCEEncoder::SetMinimumQP(uint8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 51), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MIN_QP, (uint32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetMinimumQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetMinimumQP> Set to %d.", qp);
-}
-
-uint8_t Plugin::AMD::VCEEncoder::GetMinimumQP() {
-	uint32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MIN_QP, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetMinimumQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetMinimumQP> Value is %d.", qp);
-	return (uint8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetMaximumQP(uint8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 51), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MAX_QP, (uint32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetMaximumQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetMaximumQP> Set to %d.", qp);
-}
-
-uint8_t Plugin::AMD::VCEEncoder::GetMaximumQP() {
-	uint32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MAX_QP, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetMaximumQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetMaximumQP> Value is %d.", qp);
-	return (uint8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetIFrameQP(uint8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 51), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QP_I, (uint32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetIFrameQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetIFrameQP> Set to %d.", qp);
-}
-
-uint8_t Plugin::AMD::VCEEncoder::GetIFrameQP() {
-	uint32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QP_I, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetIFrameQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetIFrameQP> Value is %d.", qp);
-	return (uint8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetPFrameQP(uint8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 51), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QP_P, (uint32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetPFrameQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetPFrameQP> Set to %d.", qp);
-}
-
-uint8_t Plugin::AMD::VCEEncoder::GetPFrameQP() {
-	uint32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QP_P, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetPFrameQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetPFrameQP> Value is %d.", qp);
-	return (uint8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetBFrameQP(uint8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 51), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QP_B, (uint32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetBFrameQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetBFrameQP> Set to %d.", qp);
-}
-
-uint8_t Plugin::AMD::VCEEncoder::GetBFrameQP() {
-	uint32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QP_B, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetBFrameQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetBFrameQP> Value is %d.", qp);
-	return (uint8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetBPictureDeltaQP(int8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 10), -10);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_B_PIC_DELTA_QP, (int32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetBPictureDeltaQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetBPictureDeltaQP> Set to %d.", qp);
-}
-
-int8_t Plugin::AMD::VCEEncoder::GetBPictureDeltaQP() {
-	int32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_B_PIC_DELTA_QP, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetBPictureDeltaQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetBPictureDeltaQP> Value is %d.", qp);
-	return (int8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetReferenceBPictureDeltaQP(int8_t qp) {
-	// Clamp Value
-	qp = max(min(qp, 10), -10);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_REF_B_PIC_DELTA_QP, (int32_t)qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetReferenceBPictureDeltaQP> Setting to %d failed with error %ls (code %d).", res, qp);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetReferenceBPictureDeltaQP> Set to %d.", qp);
-}
-
-int8_t Plugin::AMD::VCEEncoder::GetReferenceBPictureDeltaQP() {
-	int32_t qp;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_REF_B_PIC_DELTA_QP, &qp);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetReferenceBPictureDeltaQP> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetReferenceBPictureDeltaQP> Value is %d.", qp);
-	return (int8_t)qp;
-}
-
-void Plugin::AMD::VCEEncoder::SetVBVBufferSize(uint32_t size) {
-	// Clamp Value
-	size = max(min(size, 100000000), 1000); // 1kbit to 100mbit.
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_VBV_BUFFER_SIZE, (uint32_t)size);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetVBVBufferSize> Setting to %d bits failed with error %ls (code %d).", res, size);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetVBVBufferSize> Set to %d bits.", size);
-}
-
-void Plugin::AMD::VCEEncoder::SetVBVBufferAutomatic(double_t strictness) {
-	uint32_t strictBitrate = 1000, looseBitrate = 100000000;
-
-	// Strict VBV Buffer Size = Bitrate / FPS
-	// Loose VBV Buffer Size = Bitrate
-
-	switch (this->GetRateControlMethod()) {
-		case VCERateControlMethod_ConstantBitrate:
-		case VCERateControlMethod_VariableBitrate_LatencyConstrained:
-			looseBitrate = this->GetTargetBitrate();
-			break;
-		case VCERateControlMethod_VariableBitrate_PeakConstrained:
-			looseBitrate = max(this->GetTargetBitrate(), this->GetPeakBitrate());
-			break;
-		case VCERateControlMethod_ConstantQP:
-			// When using Constant QP, one will have to pick a QP that is decent
-			// in both quality and bitrate. We can easily calculate both the QP
-			// required for an average bitrate and the average bitrate itself 
-			// with these formulas:
-			// BITRATE = ((1 - (QP / 51)) ^ 2) * ((Width * Height) * 1.5 * (FPSNumerator / FPSDenumerator))
-			// QP = (1 - sqrt(BITRATE / ((Width * Height) * 1.5 * (FPSNumerator / FPSDenumerator)))) * 51
-
-			auto frameSize = this->GetFrameSize();
-			auto frameRate = this->GetFrameRate();
-
-			double_t bitrate = frameSize.first * frameSize.second;
-			switch (this->m_SurfaceFormat) {
-				case VCESurfaceFormat_NV12:
-				case VCESurfaceFormat_I420:
-					bitrate *= 1.5;
-					break;
-				case VCESurfaceFormat_YUY2:
-					bitrate *= 4;
-					break;
-				case VCESurfaceFormat_BGRA:
-				case VCESurfaceFormat_RGBA:
-					bitrate *= 3;
-					break;
-				case VCESurfaceFormat_GRAY:
-					bitrate *= 1;
-					break;
-			}
-			bitrate *= frameRate.first / frameRate.second;
-
-			uint8_t qp_i, qp_p, qp_b;
-			qp_i = this->GetIFrameQP();
-			qp_p = this->GetPFrameQP();
-			try { qp_b = this->GetBFrameQP(); } catch (...) { qp_b = 51; }
-			double_t qp = 1 - ((double_t)(min(min(qp_i, qp_p), qp_b)) / 51.0);
-			qp = max(qp * qp, 0.001); // Needs to be at least 0.001.
-
-			looseBitrate = static_cast<uint32_t>(bitrate * qp);
-			break;
-	}
-	strictBitrate = static_cast<uint32_t>(looseBitrate * m_FrameRateReverseDivisor);
-
-	#define PI 3.14159265
-	double_t interpVal = (sin(max(min(strictness, 1.0), 0.0) * 90 * (PI / 180))); // sin curve?
-	uint32_t realBitrate = static_cast<uint32_t>((strictBitrate * interpVal) + (looseBitrate * (1.0 - interpVal)));
-	this->SetVBVBufferSize(realBitrate);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetVBVBufferSize() {
-	uint32_t size;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_VBV_BUFFER_SIZE, &size);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetVBVBufferSize> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetVBVBufferSize> Value is %d.", size);
-	return size;
-}
-
-void Plugin::AMD::VCEEncoder::SetInitialVBVBufferFullness(double_t fullness) {
-	// Clamp Value
-	fullness = max(min(fullness, 1), 0); // 0 to 100 %
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_INITIAL_VBV_BUFFER_FULLNESS, (uint32_t)(fullness * 64));
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetVBVBufferFullness> Setting to %f%% failed with error %ls (code %d).", res, fullness * 100);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetVBVBufferFullness> Set to %f%%.", fullness * 100);
-}
-
-double_t Plugin::AMD::VCEEncoder::GetInitialVBVBufferFullness() {
-	uint32_t vbvBufferFullness;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_INITIAL_VBV_BUFFER_FULLNESS, &vbvBufferFullness);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetInitialVBVBufferFullness> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetInitialVBVBufferFullness> Value is %f%%.", vbvBufferFullness / 64.0 * 100.0);
-	return ((double_t)vbvBufferFullness / 64.0);
-}
-
-void Plugin::AMD::VCEEncoder::SetMaximumAccessUnitSize(uint32_t size) {
-	// Clamp Value
-	size = max(min(size, 100000000), 0); // 1kbit to 100mbit.
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MAX_AU_SIZE, (uint32_t)size);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetMaxAUSize> Setting to %d bits failed with error %ls (code %d).", res, size);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetMaxAUSize> Set to %d bits.", size);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetMaximumAccessUnitSize() {
-	uint32_t size;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MAX_AU_SIZE, &size);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetMaxAUSize> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetMaxAUSize> Value is %d.", size);
-	return size;
-}
-
-void Plugin::AMD::VCEEncoder::SetFillerDataEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_FILLER_DATA_ENABLE, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetFillerDataEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetFillerDataEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsFillerDataEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_FILLER_DATA_ENABLE, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsFillerDataEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsFillerDataEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetFrameSkippingEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_SKIP_FRAME_ENABLE, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetRateControlSkipFrameEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetRateControlSkipFrameEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsFrameSkippingEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_SKIP_FRAME_ENABLE, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsRateControlSkipFrameEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsRateControlSkipFrameEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetEnforceHRDRestrictionsEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_ENFORCE_HRD, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetEnforceHRD> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetEnforceHRD> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsEnforceHRDRestrictionsEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_ENFORCE_HRD, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetEnforceHRD> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetEnforceHRD> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-/************************************************************************/
-/* Picture Control Properties */
-/************************************************************************/
-
-void Plugin::AMD::VCEEncoder::SetIDRPeriod(uint32_t period) {
-	// Clamp Value
-	period = max(min(period, m_FrameRate.second * 1000), 1); // 1-1000 so that OBS can actually quit.
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_IDR_PERIOD, (uint32_t)period);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetIDRPeriod> Setting to %d failed with error %ls (code %d).", res, period);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetIDRPeriod> Set to %d.", period);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetIDRPeriod() {
-	int32_t period;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_IDR_PERIOD, &period);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetIDRPeriod> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetIDRPeriod> Value is %d.", period);
-	return period;
-}
-
-void Plugin::AMD::VCEEncoder::SetHeaderInsertionSpacing(uint32_t spacing) {
-	// Clamp Value
-	spacing = max(min(spacing, m_FrameRate.second * 1000), 0);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_HEADER_INSERTION_SPACING, (uint32_t)spacing);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetHeaderInsertionSpacing> Setting to %d failed with error %ls (code %d).", res, spacing);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetHeaderInsertionSpacing> Set to %d.", spacing);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetHeaderInsertionSpacing() {
-	int32_t headerInsertionSpacing;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_HEADER_INSERTION_SPACING, &headerInsertionSpacing);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetHeaderInsertionSpacing> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetHeaderInsertionSpacing> Value is %d.", headerInsertionSpacing);
-	return headerInsertionSpacing;
-}
-
-void Plugin::AMD::VCEEncoder::SetBPicturePattern(VCEBPicturePattern pattern) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_B_PIC_PATTERN, (uint32_t)pattern);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetBPicturesPattern> Setting to %d failed with error %ls (code %d).", res, pattern);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetBPicturesPattern> Set to %d.", pattern);
-}
-
-Plugin::AMD::VCEBPicturePattern Plugin::AMD::VCEEncoder::GetBPicturePattern() {
-	uint32_t pattern;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_B_PIC_PATTERN, &pattern);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetBPicturesPattern> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetBPicturesPattern> Value is %d.", pattern);
-	return (Plugin::AMD::VCEBPicturePattern)pattern;
-}
-
-void Plugin::AMD::VCEEncoder::SetBPictureReferenceEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_B_REFERENCE_ENABLE, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetBReferenceEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetBReferenceEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsBPictureReferenceEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_B_REFERENCE_ENABLE, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsBReferenceEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsBReferenceEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetDeblockingFilterEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_DE_BLOCKING_FILTER, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetDeBlockingFilterEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetDeBlockingFilterEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsDeblockingFilterEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_DE_BLOCKING_FILTER, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsDeBlockingFilterEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsDeBlockingFilterEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetSlicesPerFrame(uint32_t slices) {
-	slices = max(slices, 1);
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_SLICES_PER_FRAME, (uint32_t)slices);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetSlicesPerFrame> Setting to %d failed with error %ls (code %d).", res, slices);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetSlicesPerFrame> Set to %d.", slices);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetSlicesPerFrame() {
-	uint32_t slices;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_SLICES_PER_FRAME, &slices);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetSlicesPerFrame> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetSlicesPerFrame> Value is %d.", slices);
-	return slices;
-}
-
-void Plugin::AMD::VCEEncoder::SetIntraRefreshMBsNumberPerSlot(uint32_t mbs) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_INTRA_REFRESH_NUM_MBS_PER_SLOT, (uint32_t)mbs);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetIntraRefreshMBsNumberPerSlot> Setting to %d failed with error %ls (code %d).", res, mbs);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetIntraRefreshMBsNumberPerSlot> Set to %d.", mbs);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetIntraRefreshMBsNumberPerSlot() {
-	int32_t mbs;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_INTRA_REFRESH_NUM_MBS_PER_SLOT, &mbs);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetIntraRefreshMBsNumberPerSlot> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetIntraRefreshMBsNumberPerSlot> Value is %d.", mbs);
-	return mbs;
-}
-
-/************************************************************************/
-/* Miscellaneous Control Properties */
-/************************************************************************/
-
-void Plugin::AMD::VCEEncoder::SetQualityPreset(VCEQualityPreset preset) {
-	static AMF_VIDEO_ENCODER_QUALITY_PRESET_ENUM CustomToAMF[] = {
-		AMF_VIDEO_ENCODER_QUALITY_PRESET_SPEED,
-		AMF_VIDEO_ENCODER_QUALITY_PRESET_BALANCED,
-		AMF_VIDEO_ENCODER_QUALITY_PRESET_QUALITY,
-	};
-	static char* CustomToName[] = {
-		"Speed",
-		"Balanced",
-		"Quality",
-	};
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QUALITY_PRESET, (uint32_t)CustomToAMF[preset]);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetQualityPreset> Setting to %s failed with error %ls (code %d).", res, CustomToName[preset]);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetQualityPreset> Set to %s.", CustomToName[preset]);
-}
-
-Plugin::AMD::VCEQualityPreset Plugin::AMD::VCEEncoder::GetQualityPreset() {
-	static VCEQualityPreset AMFToCustom[] = {
-		VCEQualityPreset_Balanced,
-		VCEQualityPreset_Speed,
-		VCEQualityPreset_Quality,
-	};
-	static char* CustomToName[] = {
-		"Speed",
-		"Balanced",
-		"Quality",
-	};
-
-	uint32_t preset;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QUALITY_PRESET, &preset);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetQualityPreset> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetQualityPreset> Value is %s.", CustomToName[AMFToCustom[preset]]);
-	return AMFToCustom[preset];
-}
-
-void Plugin::AMD::VCEEncoder::SetScanType(VCEScanType scanType) {
-	static AMF_VIDEO_ENCODER_SCANTYPE_ENUM CustomToAMF[] = {
-		AMF_VIDEO_ENCODER_SCANTYPE_PROGRESSIVE,
-		AMF_VIDEO_ENCODER_SCANTYPE_INTERLACED,
-	};
-	static char* CustomToName[] = {
-		"Progressive",
-		"Interlaced",
-	};
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_SCANTYPE, (uint32_t)CustomToAMF[scanType]);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetScanType> Setting to %s failed with error %ls (code %d).", res, CustomToName[scanType]);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetScanType> Set to %s.", CustomToName[scanType]);
-}
-
-Plugin::AMD::VCEScanType Plugin::AMD::VCEEncoder::GetScanType() {
-	static char* CustomToName[] = {
-		"Progressive",
-		"Interlaced",
-	};
-
-	uint32_t scanType;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_SCANTYPE, &scanType);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetScanType> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetScanType> Value is %s.", CustomToName[scanType]);
-	return (Plugin::AMD::VCEScanType)scanType;
-}
-
-void Plugin::AMD::VCEEncoder::SetHalfPixelMotionEstimationEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MOTION_HALF_PIXEL, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetHalfPixelMotionEstimationEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetHalfPixelMotionEstimationEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsHalfPixelMotionEstimationEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MOTION_HALF_PIXEL, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsHalfPixelMotionEstimationEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsHalfPixelMotionEstimationEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetQuarterPixelMotionEstimationEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MOTION_QUARTERPIXEL, enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetQuarterPixelMotionEstimationEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetQuarterPixelMotionEstimationEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsQuarterPixelMotionEstimationEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MOTION_QUARTERPIXEL, &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsQuarterPixelMotionEstimationEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsQuarterPixelMotionEstimationEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetCABACEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"CABACEnable", enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetCABACEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetCABACEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsCABACEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"CABACEnable", &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsCABACEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsCABACEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-/************************************************************************/
-/* Hidden Properties */
-/************************************************************************/
-
-void Plugin::AMD::VCEEncoder::SetGOPSize(uint32_t size) {
-	AMF_LOG_WARNING("Using unsupported SetGOPSize function. Unexpected behaviour may happen.");
-
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"GOPSize", (uint32_t)size);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetGOPSize> Setting to %d failed with error %ls (code %d).", res, size);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetGOPSize> Set to %d.", size);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetGOPSize() {
-	AMF_LOG_WARNING("Using unsupported GetGOPSize function. Unexpected behaviour may happen.");
-
-	uint32_t size;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"GOPSize", &size);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetGOPSize> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetGOPSize> Value is %d.", size);
-	return size;
-}
-
-
-void Plugin::AMD::VCEEncoder::SetNominalRange(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"NominalRange", enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetNominalRange> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetNominalRange> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::GetNominalRange() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"NominalRange", &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetNominalRange> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetNominalRange> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetWaitForTask(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"WaitForTask", enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetWaitForTask> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetWaitForTask> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::GetWaitForTask() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"WaitForTask", &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetWaitForTask> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetWaitForTask> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-
-void Plugin::AMD::VCEEncoder::SetAspectRatio(uint32_t num, uint32_t den) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"AspectRatio", ::AMFConstructRate(num, den));
-	if (res != AMF_OK) {
-		std::vector<char> msgBuf;
-		sprintf(msgBuf.data(), "%d:%d", num, den);
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetAspectRatio> Setting to %s failed with error %ls (code %d).", res, msgBuf.data());
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetAspectRatio> Set to %d:%d.", num, den);
-}
-
-std::pair<uint32_t, uint32_t> Plugin::AMD::VCEEncoder::GetAspectRatio() {
-	AMFRate aspectRatio;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"AspectRatio", &aspectRatio);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetAspectRatio> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetAspectRatio> Value is %d:%d.", aspectRatio.num, aspectRatio.den);
-	return std::pair<uint32_t, uint32_t>(aspectRatio.num, aspectRatio.den);
-}
-
-void Plugin::AMD::VCEEncoder::SetMaximumNumberOfReferenceFrames(uint32_t numFrames) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"MaxNumRefFrames", (uint32_t)numFrames);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetMaximumNumberOfReferenceFrames> Setting to %d failed with error %ls (code %d).", res, numFrames);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetMaximumNumberOfReferenceFrames> Set to %d.", numFrames);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetMaximumNumberOfReferenceFrames() {
-	uint32_t numFrames;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"MaxNumRefFrames", &numFrames);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetMaximumNumberOfReferenceFrames> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetMaximumNumberOfReferenceFrames> Value is %d.", numFrames);
-	return numFrames;
-}
-
-void Plugin::AMD::VCEEncoder::SetMaxMBPerSec(uint32_t maxMBPerSec) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"MaxMBPerSec", (uint32_t)maxMBPerSec);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetMaxMBPerSec> Setting to %d failed with error %ls (code %d).", res, maxMBPerSec);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetMaxMBPerSec> Set to %d.", maxMBPerSec);
-}
-
-uint32_t Plugin::AMD::VCEEncoder::GetMaxMBPerSec() {
-	uint32_t maxMBPerSec;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"MaxMBPerSec", &maxMBPerSec);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::GetMaxMBPerSec> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::GetMaxMBPerSec> Value is %d.", maxMBPerSec);
-	return maxMBPerSec;
-}
-
-void Plugin::AMD::VCEEncoder::SetRateControlPreanalysisEnabled(bool enabled) {
-	AMF_RESULT res = m_AMFEncoder->SetProperty(L"RateControlPreanalysisEnable", enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::SetRateControlPreanalysisEnabled> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::SetRateControlPreanalysisEnabled> Set to %s.", enabled ? "Enabled" : "Disabled");
-}
-
-bool Plugin::AMD::VCEEncoder::IsRateControlPreanalysisEnabled() {
-	bool enabled;
-	AMF_RESULT res = m_AMFEncoder->GetProperty(L"RateControlPreanalysisEnable", &enabled);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::VCEEncoder::IsRateControlPreanalysisEnabled> Failed with error %ls (code %d).", res);
-	}
-	AMF_LOG_DEBUG("<Plugin::AMD::VCEEncoder::IsRateControlPreanalysisEnabled> Value is %s.", enabled ? "Enabled" : "Disabled");
-	return enabled;
-}
-

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/amd-amf.cpp Deleted

@@ -1,236 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include <vector>
-#include <mutex>
-
-#include "amd-amf.h"
-#include "windows.h"
-
-// AMD AMF SDK
-#include "components\Component.h"
-#include "components\ComponentCaps.h"
-#include "components\VideoEncoderVCE.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-using namespace Plugin::AMD;
-
-class CustomWriter : public amf::AMFTraceWriter {
-	public:
-	virtual void Write(const wchar_t* scope, const wchar_t* message) override {
-		const wchar_t* realmsg = &(message[(33 + wcslen(scope) + 2)]); // Skip Time & Scope
-		size_t msgLen = wcslen(realmsg) - (sizeof(wchar_t));
-
-		blog(LOG_INFO, "[%ls] %.*ls", scope, msgLen, realmsg);
-	}
-
-	virtual void Flush() override {}
-};
-
-std::shared_ptr<Plugin::AMD::AMF> Plugin::AMD::AMF::GetInstance() {
-	static std::shared_ptr<AMF> __instance = std::make_shared<AMF>();
-	static std::mutex __mutex;
-
-	const std::lock_guard<std::mutex> lock(__mutex);
-	return __instance;
-}
-
-Plugin::AMD::AMF::AMF() {
-	AMF_RESULT res = AMF_OK;
-
-	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Initializing...");
-
-	// Null Values
-	m_TimerPeriod = 0;
-	m_AMFModule = nullptr;
-	m_AMFVersion_Compiler = 0;
-	m_AMFVersion_Runtime = 0;
-	m_AMFFactory = nullptr;
-	m_AMFTrace = nullptr;
-	m_AMFDebug = nullptr;
-	AMFQueryVersion = nullptr;
-	AMFInit = nullptr;
-
-	// Load Dynamic Library
-	m_AMFModule = LoadLibraryW(AMF_DLL_NAME);
-	if (!m_AMFModule) {
-		DWORD error = GetLastError();
-		std::vector<char> buf(1024);
-		sprintf(buf.data(), "Unable to load '%ls', error code %ld.", AMF_DLL_NAME, error);
-		AMF_LOG_ERROR("%s", buf.data());
-		throw std::exception(buf.data(), error);
-	} else {
-		std::vector<char> verbuf(GetFileVersionInfoSizeW(AMF_DLL_NAME, nullptr));
-		GetFileVersionInfoW(AMF_DLL_NAME, 0, (DWORD)verbuf.size(), verbuf.data());
-
-		void* pBlock = verbuf.data();
-
-		// Read the list of languages and code pages.
-		struct LANGANDCODEPAGE {
-			WORD wLanguage;
-			WORD wCodePage;
-		} *lpTranslate;
-		UINT cbTranslate = 1024;
-
-		VerQueryValueA(pBlock, "\\VarFileInfo\\Translation", (LPVOID*)&lpTranslate, &cbTranslate);
-
-		std::vector<char> buf(1024);
-		sprintf(buf.data(), "%s%04x%04x%s",
-			"\\StringFileInfo\\",
-			lpTranslate[0].wLanguage,
-			lpTranslate[0].wCodePage,
-			"\\ProductVersion");
-
-		// Retrieve file description for language and code page "i". 
-		void* lpBuffer;
-		uint32_t dwBytes;
-		VerQueryValueA(pBlock, buf.data(), &lpBuffer, &dwBytes);
-
-		AMF_LOG_INFO("Runtime Library is on Version %.*s.", dwBytes, lpBuffer);
-		AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Loaded '%ls'.", AMF_DLL_NAME);
-	}
-
-	// Find Function: Query Version
-	AMFQueryVersion = (AMFQueryVersion_Fn)GetProcAddress(m_AMFModule, AMF_QUERY_VERSION_FUNCTION_NAME);
-	if (!AMFQueryVersion) {
-		DWORD error = GetLastError();
-		std::vector<char> buf(1024);
-		sprintf(buf.data(), "<Plugin::AMD::AMF::AMF> Finding Address of Function '%s' failed with error code %ld.", AMF_QUERY_VERSION_FUNCTION_NAME, error);
-		AMF_LOG_ERROR("%s", buf.data());
-		throw std::exception(buf.data(), error);
-	}
-
-	// Query Runtime Version
-	m_AMFVersion_Compiler = AMF_FULL_VERSION;
-	res = AMFQueryVersion(&m_AMFVersion_Runtime);
-	if (res != AMF_OK)
-		ThrowExceptionWithAMFError("<Plugin::AMD::AMF::AMF> Querying Version failed with error %ls (code %ld).", res);
-	AMF_LOG_DEBUG("Runtime reports back Version %d.%d.%d.%d",
-		(uint16_t)((m_AMFVersion_Runtime >> 48ull) & 0xFFFF),
-		(uint16_t)((m_AMFVersion_Runtime >> 32ull) & 0xFFFF),
-		(uint16_t)((m_AMFVersion_Runtime >> 16ull) & 0xFFFF),
-		(uint16_t)((m_AMFVersion_Runtime & 0xFFFF)));
-
-	// Find Function: Init
-	AMFInit = (AMFInit_Fn)GetProcAddress(m_AMFModule, AMF_INIT_FUNCTION_NAME);
-	if (!AMFInit) {
-		DWORD error = GetLastError();
-		std::vector<char> buf(1024);
-		sprintf(buf.data(), "<Plugin::AMD::AMF::AMF> Finding Address of Function '%s' failed with error code %ld.", AMF_INIT_FUNCTION_NAME, error);
-		AMF_LOG_ERROR("%s", buf.data());
-		throw std::exception(buf.data(), error);
-	}
-
-	// Initialize AMF Libraries
-	res = AMFInit(m_AMFVersion_Runtime, &m_AMFFactory);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::AMF::AMF> Initializing AMF Library failed with error %ls (code %ld).", res);
-	} else {
-		AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> AMF Library initialized.");
-	}
-
-	// Retrieve Trace Object
-	res = m_AMFFactory->GetTrace(&m_AMFTrace);
-	if (res != AMF_OK) {
-		ThrowExceptionWithAMFError("<Plugin::AMD::AMF::AMF> Retrieving Trace object failed with error %ls (code %ld).", res);
-	}
-
-	// Retrieve Debug Object
-	res = m_AMFFactory->GetDebug(&m_AMFDebug);
-	if (res != AMF_OK) {
-		AMF_LOG_ERROR("<Plugin::AMD::AMF::AMF> Retrieving Debug object failed with error code %ls (code %ld).", res);
-		throw std::exception("", res);
-	}
-	m_AMFTrace->RegisterWriter(L"OBSWriter", new CustomWriter(), true);
-	this->EnableDebugTrace(false);
-	
-	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Initialized.");
-}
-
-Plugin::AMD::AMF::~AMF() {
-	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Finalizing.");
-
-	// Free Library again
-	if (m_AMFModule)
-		FreeLibrary(m_AMFModule);
-
-	// Null Values
-	m_TimerPeriod = 0;
-	m_AMFModule = nullptr;
-	m_AMFVersion_Compiler = 0;
-	m_AMFVersion_Runtime = 0;
-	m_AMFFactory = nullptr;
-	m_AMFTrace = nullptr;
-	m_AMFDebug = nullptr;
-	AMFQueryVersion = nullptr;
-	AMFInit = nullptr;
-
-	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Finalized.");
-}
-
-amf::AMFFactory* Plugin::AMD::AMF::GetFactory() {
-	return m_AMFFactory;
-}
-
-amf::AMFTrace* Plugin::AMD::AMF::GetTrace() {
-	return m_AMFTrace;
-}
-
-amf::AMFDebug* Plugin::AMD::AMF::GetDebug() {
-	return m_AMFDebug;
-}
-
-void Plugin::AMD::AMF::EnableDebugTrace(bool enable) {
-	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_CONSOLE, false);
-	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_CONSOLE, AMF_TRACE_ERROR);
-	#ifdef DEBUG
-	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_DEBUG_OUTPUT, true);
-	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_DEBUG_OUTPUT, AMF_TRACE_TEST);
-	m_AMFTrace->SetPath(L"C:/AMFTrace.log");
-	#else
-	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_DEBUG_OUTPUT, false);
-	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_DEBUG_OUTPUT, AMF_TRACE_ERROR);
-	#endif
-	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_FILE, false);
-	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_FILE, AMF_TRACE_ERROR);
-
-	if (enable) {
-		m_AMFDebug->AssertsEnable(true);
-		m_AMFDebug->EnablePerformanceMonitor(true);
-		m_AMFTrace->TraceEnableAsync(true);
-		m_AMFTrace->SetGlobalLevel(AMF_TRACE_TEST);
-		m_AMFTrace->SetWriterLevel(L"OBSWriter", AMF_TRACE_TEST);
-	} else {
-		m_AMFDebug->AssertsEnable(false);
-		m_AMFDebug->EnablePerformanceMonitor(false);
-		m_AMFTrace->TraceEnableAsync(true);
-		m_AMFTrace->SetGlobalLevel(AMF_TRACE_WARNING);
-		m_AMFTrace->SetWriterLevel(L"OBSWriter", AMF_TRACE_WARNING);
-	}
-}

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/api-base.cpp Deleted

@@ -1,66 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "api-base.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-
-Plugin::API::Device::Device() {
-	this->Name = "";
-	this->UniqueId = "";
-}
-
-Plugin::API::Device::Device(std::string Name, std::string UniqueId) {
-	this->Name = Name;
-	this->UniqueId = UniqueId;
-}
-
-Plugin::API::Device::~Device() {
-}
-
-std::vector<Plugin::API::Device> Plugin::API::BaseAPI::EnumerateDevices() {
-	return std::vector<Plugin::API::Device>();
-}
-
-Plugin::API::BaseAPI::BaseAPI(Device device) {
-	myDevice = device;
-}
-
-Plugin::API::BaseAPI::~BaseAPI() {
-
-}
-
-void* Plugin::API::BaseAPI::GetContext() {
-	return nullptr;
-}
-
-Plugin::API::Device Plugin::API::BaseAPI::GetDevice() {
-	return myDevice;
-}

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/api-d3d11.cpp Deleted

@@ -1,289 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#ifdef _WIN32
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "api-d3d11.h"
-
-#include <vector>
-#include <string>
-#include <sstream>
-
-#include <dxgi.h>
-#include <d3d11.h>
-
-#include <mutex>
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-using namespace Plugin::API;
-
-class SingletonDXGI {
-	public:
-
-	#pragma region Singleton
-	static std::shared_ptr<SingletonDXGI> GetInstance() {
-		static std::shared_ptr<SingletonDXGI> __instance = std::make_shared<SingletonDXGI>();
-		static std::mutex __mutex;
-
-		const std::lock_guard<std::mutex> lock(__mutex);
-		return __instance;
-	}
-	#pragma endregion Singleton
-
-	SingletonDXGI() {
-		hModule = LoadLibrary(TEXT("dxgi.dll"));
-		if (hModule == 0)
-			throw std::exception("Unable to load 'dxgi.dll'.");
-
-	}
-	~SingletonDXGI() {
-		if (hModule)
-			FreeLibrary(hModule);
-	}
-
-	HRESULT CreateDXGIFactory1(REFIID riid, _Out_ void **ppFactory) {
-		if (hModule == 0)
-			return S_FALSE;
-		
-		typedef HRESULT(__stdcall *t_CreateDXGIFactory1)(REFIID, void**);
-		t_CreateDXGIFactory1 pCreateDXGIFactory1 = (t_CreateDXGIFactory1)GetProcAddress(hModule, "CreateDXGIFactory1");
-
-		if (pCreateDXGIFactory1) {
-			return pCreateDXGIFactory1(riid, ppFactory);
-		}
-		return S_FALSE;
-	}
-
-	private:
-	HMODULE hModule;
-};
-class SingletonD3D11 {
-	public:
-
-	#pragma region Singleton
-	static std::shared_ptr<SingletonD3D11> GetInstance() {
-		static std::shared_ptr<SingletonD3D11> __instance = std::make_shared<SingletonD3D11>();
-		static std::mutex __mutex;
-
-		const std::lock_guard<std::mutex> lock(__mutex);
-		return __instance;
-	}
-	#pragma endregion Singleton
-
-	SingletonD3D11() {
-		hModule = LoadLibrary(TEXT("d3d11.dll"));
-		if (hModule == 0)
-			throw std::exception("Unable to load 'd3d11.dll'.");
-
-	}
-	~SingletonD3D11() {
-		if (hModule)
-			FreeLibrary(hModule);
-	}
-
-	HRESULT WINAPI D3D11CreateDevice(
-		_In_opt_ IDXGIAdapter* pAdapter,
-		D3D_DRIVER_TYPE DriverType,
-		HMODULE Software,
-		UINT Flags,
-		_In_reads_opt_(FeatureLevels) CONST D3D_FEATURE_LEVEL* pFeatureLevels,
-		UINT FeatureLevels,
-		UINT SDKVersion,
-		_Out_opt_ ID3D11Device** ppDevice,
-		_Out_opt_ D3D_FEATURE_LEVEL* pFeatureLevel,
-		_Out_opt_ ID3D11DeviceContext** ppImmediateContext) {
-
-		if (hModule == 0)
-			return S_FALSE;
-
-		typedef HRESULT(__stdcall *t_D3D11CreateDevice)(_In_opt_ IDXGIAdapter*, D3D_DRIVER_TYPE, HMODULE, UINT,
-			CONST D3D_FEATURE_LEVEL*, UINT, UINT, _Out_opt_ ID3D11Device**,
-			_Out_opt_ D3D_FEATURE_LEVEL*, _Out_opt_ ID3D11DeviceContext**);
-		t_D3D11CreateDevice pD3D11CreateDevice = (t_D3D11CreateDevice)GetProcAddress(hModule, "D3D11CreateDevice");
-
-		if (pD3D11CreateDevice) {
-			return pD3D11CreateDevice(pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels, 
-				SDKVersion, ppDevice, pFeatureLevel, ppImmediateContext);
-		}
-		return S_FALSE;
-	}
-
-	private:
-	HMODULE hModule;
-};
-
-Plugin::API::Device BuildDeviceFromAdapter(DXGI_ADAPTER_DESC1* pAdapter) {
-	if (pAdapter == nullptr)
-		return Device("INVALID DEVICE", "");
-
-	std::vector<char> uidBuf(1024);
-	sprintf(uidBuf.data(), "%ld:%ld:%ld:%ld",
-		pAdapter->VendorId,
-		pAdapter->DeviceId,
-		pAdapter->SubSysId,
-		pAdapter->Revision);
-
-	std::vector<char> nameBuf(1024);
-	wcstombs(nameBuf.data(), pAdapter->Description, 1024);
-
-	return Device(std::string(nameBuf.data()), std::string(uidBuf.data()));
-}
-
-std::vector<Plugin::API::Device> Plugin::API::Direct3D11::EnumerateDevices() {
-	std::vector<Plugin::API::Device> devices = std::vector<Plugin::API::Device>();
-
-	IDXGIFactory1* pFactory = NULL;
-	auto singletonDXGI = SingletonDXGI::GetInstance();
-	HRESULT hr = singletonDXGI->CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory));
-	if (FAILED(hr)) {
-		return devices;
-	}
-
-	IDXGIAdapter1* pAdapter = NULL;
-	for (uint32_t iAdapterIndex = 0; pFactory->EnumAdapters1(iAdapterIndex, &pAdapter) != DXGI_ERROR_NOT_FOUND; iAdapterIndex++) {
-		DXGI_ADAPTER_DESC1 adapterDesc = DXGI_ADAPTER_DESC1();
-		std::memset(&adapterDesc, 0, sizeof(DXGI_ADAPTER_DESC1));
-
-		if (pAdapter->GetDesc1(&adapterDesc) == S_OK) {
-			// Only allow AMD devices to be listed here.
-			if (adapterDesc.VendorId != 0x1002)
-				continue;
-
-			devices.push_back(BuildDeviceFromAdapter(&adapterDesc));
-		}
-	}
-
-	pFactory->Release();
-
-	return devices;
-}
-
-Plugin::API::Device Plugin::API::Direct3D11::GetDeviceForUniqueId(std::string uniqueId) {
-	Plugin::API::Device device = Device("", "");
-
-	IDXGIFactory1* pFactory = NULL;
-	auto singletonDXGI = SingletonDXGI::GetInstance();
-	HRESULT hr = singletonDXGI->CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory));
-	if (FAILED(hr)) {
-		return device;
-	}
-
-	IDXGIAdapter1* pAdapter = NULL;
-	for (uint32_t iAdapterIndex = 0; pFactory->EnumAdapters1(iAdapterIndex, &pAdapter) != DXGI_ERROR_NOT_FOUND; iAdapterIndex++) {
-		DXGI_ADAPTER_DESC1 adapterDesc = DXGI_ADAPTER_DESC1();
-		std::memset(&adapterDesc, 0, sizeof(DXGI_ADAPTER_DESC1));
-
-		if (pAdapter->GetDesc1(&adapterDesc) == S_OK) {
-			// Only allow AMD devices to be listed here.
-			if (adapterDesc.VendorId != 0x1002)
-				continue;
-
-			Plugin::API::Device device2 = BuildDeviceFromAdapter(&adapterDesc);
-
-			if (uniqueId == device2.UniqueId) {
-				device = device2;
-				break;
-			}
-		}
-	}
-
-	pFactory->Release();
-	return device;
-}
-
-Plugin::API::Direct3D11::Direct3D11(Device device) : BaseAPI(device) {
-	IDXGIFactory1 *pFactory;
-
-	auto singletonDXGI = SingletonDXGI::GetInstance();
-	if (FAILED(singletonDXGI->CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory))))
-		throw new std::exception("Unable to create D3D11 driver.");
-
-	try {
-		IDXGIAdapter1 *pAdapter = NULL,
-			*pAdapter2 = NULL;
-		for (uint32_t iAdapterIndex = 0; pFactory->EnumAdapters1(iAdapterIndex, &pAdapter2) != DXGI_ERROR_NOT_FOUND; iAdapterIndex++) {
-			DXGI_ADAPTER_DESC1 adapterDesc = DXGI_ADAPTER_DESC1();
-			std::memset(&adapterDesc, 0, sizeof(DXGI_ADAPTER_DESC1));
-
-			if (pAdapter2->GetDesc1(&adapterDesc) == S_OK) {
-				// Only allow AMD devices to be listed here.
-				if (adapterDesc.VendorId != 0x1002)
-					continue;
-
-				Plugin::API::Device device2 = BuildDeviceFromAdapter(&adapterDesc);
-
-				if (device.UniqueId == device2.UniqueId) {
-					pAdapter = pAdapter2;
-					break;
-				}
-			}
-		}
-
-		try {
-			D3D_FEATURE_LEVEL featureLevels[] = {
-				D3D_FEATURE_LEVEL_11_1,
-				D3D_FEATURE_LEVEL_11_0,
-			};
-			uint32_t flags =
-				D3D11_CREATE_DEVICE_BGRA_SUPPORT |
-				D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT |
-				D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
-
-			auto singletonD3D11 = SingletonD3D11::GetInstance();
-			HRESULT hr = singletonD3D11->D3D11CreateDevice(pAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL,
-				flags, featureLevels, 2, D3D11_SDK_VERSION,
-				&pDevice, NULL, &pDeviceContext);
-
-			if (FAILED(hr)) {
-				throw new std::exception("Unable to create D3D11 device.");
-			}
-		} catch (...) {
-			if (pAdapter)
-				pAdapter->Release();
-
-			throw;
-		}
-	} catch (...) {
-		if (pFactory)
-			pFactory->Release();
-
-		throw;
-	}
-}
-
-Plugin::API::Direct3D11::~Direct3D11() {
-	if (pDeviceContext)
-		pDeviceContext->Release();
-	if (pDevice)
-		pDevice->Release();
-}
-
-void* Plugin::API::Direct3D11::GetContext() {
-	return pDevice;
-}
-#endif

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/api-d3d9.cpp Deleted

@@ -1,197 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#ifdef _WIN32
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "api-d3d9.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-using namespace Plugin::API;
-
-Plugin::API::Device BuildDeviceFromAdapter(D3DADAPTER_IDENTIFIER9* pAdapter) {
-	if (pAdapter == nullptr)
-		return Device("INVALID DEVICE", "");
-
-	std::vector<char> uidBuf(1024);
-	sprintf(uidBuf.data(), "%ld:%ld:%ld:%ld",
-		pAdapter->VendorId,
-		pAdapter->DeviceId,
-		pAdapter->SubSysId,
-		pAdapter->Revision);
-
-	std::vector<char> nameBuf(1024);
-	sprintf(nameBuf.data(), "%s (%s)",
-		pAdapter->DeviceName,
-		pAdapter->Description);
-
-	return Device(std::string(nameBuf.data()), std::string(uidBuf.data()));
-}
-
-
-std::vector<Plugin::API::Device> Plugin::API::Direct3D9::EnumerateDevices() {
-	std::vector<Plugin::API::Device> devices = std::vector<Plugin::API::Device>();
-
-	IDirect3D9* pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
-
-	uint32_t adapterCount = pDirect3D->GetAdapterCount();
-	for (uint32_t adapterIndex = 0; adapterIndex < adapterCount; adapterIndex++) {
-		D3DADAPTER_IDENTIFIER9 adapterDesc = D3DADAPTER_IDENTIFIER9();
-		pDirect3D->GetAdapterIdentifier(adapterIndex, 0, &adapterDesc);
-
-		if (adapterDesc.VendorId != 0x1002)
-			continue;
-
-		Device device = BuildDeviceFromAdapter(&adapterDesc);
-		devices.push_back(device);
-	}
-
-	pDirect3D->Release();
-
-	return devices;
-}
-
-Plugin::API::Device Plugin::API::Direct3D9::GetDeviceForUniqueId(std::string uniqueId) {
-	Plugin::API::Device device = Device("", "");
-
-	IDirect3D9* pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
-
-	uint32_t adapterCount = pDirect3D->GetAdapterCount();
-	for (uint32_t adapterIndex = 0; adapterIndex <= adapterCount; adapterIndex++) {
-		D3DADAPTER_IDENTIFIER9 adapterDesc = D3DADAPTER_IDENTIFIER9();
-		pDirect3D->GetAdapterIdentifier(adapterIndex, 0, &adapterDesc);
-
-		if (adapterDesc.VendorId != 0x1002)
-			continue;
-
-		Device device2 = BuildDeviceFromAdapter(&adapterDesc);
-		if (device2.UniqueId == uniqueId)
-			device = device2;
-	}
-
-	pDirect3D->Release();
-
-	return device;
-}
-
-struct EnumWindowsData {
-	DWORD processId;
-	HWND bestWindowId;
-};
-
-BOOL CALLBACK EnumWindowsCallback(HWND handle, LPARAM lParam) {
-	EnumWindowsData* data = (EnumWindowsData*)lParam;
-
-	DWORD processId;
-	GetWindowThreadProcessId(handle, &processId);
-	if ((processId == data->processId)
-		&& (GetWindow(handle, GW_OWNER) == (HWND)0)
-		&& (IsWindowVisible(handle))) {
-		return TRUE;
-	}
-	data->bestWindowId = handle;
-	return FALSE;
-}
-
-Plugin::API::Direct3D9::Direct3D9(Device device) : BaseAPI(device) {
-	pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
-	if (!pDirect3D)
-		throw std::exception("Unable to create D3D9 driver.");
-
-	// Find Adapter Index
-	uint32_t usedAdapter = 0;
-	uint32_t adapterCount = pDirect3D->GetAdapterCount();
-	for (uint32_t adapterIndex = 0; adapterIndex <= adapterCount; adapterIndex++) {
-		D3DADAPTER_IDENTIFIER9 adapterDesc = D3DADAPTER_IDENTIFIER9();
-		pDirect3D->GetAdapterIdentifier(adapterIndex, 0, &adapterDesc);
-
-		if (adapterDesc.VendorId != 0x1002)
-			continue;
-
-		Device device2 = BuildDeviceFromAdapter(&adapterDesc);
-		if (device2.UniqueId == device.UniqueId) {
-			usedAdapter = adapterIndex++;
-			break;
-		}
-	}
-
-	EnumWindowsData data = EnumWindowsData();
-	data.processId = GetCurrentProcessId();
-	EnumWindows(EnumWindowsCallback, (LPARAM)&data);
-
-	D3DPRESENT_PARAMETERS pPresentParameter = D3DPRESENT_PARAMETERS();
-	pPresentParameter.BackBufferWidth = 1280;
-	pPresentParameter.BackBufferHeight = 720;
-	pPresentParameter.BackBufferFormat = D3DFORMAT::D3DFMT_R8G8B8;
-	pPresentParameter.BackBufferCount = 2;
-	pPresentParameter.MultiSampleType = D3DMULTISAMPLE_TYPE::D3DMULTISAMPLE_NONE;
-	pPresentParameter.MultiSampleQuality = 0;
-	pPresentParameter.SwapEffect = D3DSWAPEFFECT::D3DSWAPEFFECT_DISCARD;
-	pPresentParameter.hDeviceWindow = data.bestWindowId;
-	pPresentParameter.Windowed = TRUE;
-	pPresentParameter.EnableAutoDepthStencil = FALSE;
-	pPresentParameter.AutoDepthStencilFormat = D3DFORMAT::D3DFMT_A1;
-	pPresentParameter.Flags = D3DPRESENTFLAG_VIDEO;
-	pPresentParameter.FullScreen_RefreshRateInHz = 0;
-	pPresentParameter.PresentationInterval = 1;
-		
-	HRESULT hr = pDirect3D->CreateDevice(usedAdapter,
-		D3DDEVTYPE_HAL,
-		data.bestWindowId,
-		D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX | D3DCREATE_MULTITHREADED | D3DCREATE_PUREDEVICE | D3DCREATE_MIXED_VERTEXPROCESSING | D3DCREATE_NOWINDOWCHANGES,
-		&pPresentParameter,
-		&pDirect3DDevice);
-	switch (hr) {
-		case D3DERR_DEVICELOST:
-			throw std::exception("D3DERR_DEVICELOST");
-			break;
-		case D3DERR_INVALIDCALL:
-			throw std::exception("D3DERR_INVALIDCALL");
-			break;
-		case D3DERR_NOTAVAILABLE:
-			throw std::exception("D3DERR_NOTAVAILABLE");
-			break;
-		case D3DERR_OUTOFVIDEOMEMORY:
-			throw std::exception("D3DERR_OUTOFVIDEOMEMORY");
-			break;
-	}
-	if (FAILED(hr))
-		throw std::exception("Unable to create D3D9 device.");
-}
-
-Plugin::API::Direct3D9::~Direct3D9() {
-	if (pDirect3DDevice)
-		pDirect3DDevice->Release();
-
-	if (pDirect3D)
-		pDirect3D->Release();
-}
-
-void* Plugin::API::Direct3D9::GetContext() {
-	return pDirect3DDevice;
-}
-#endif

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/enc-h264.cpp Deleted

@@ -1,1525 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include "enc-h264.h"
-#include "misc-util.cpp"
-
-#if (defined _WIN32) | (defined _WIN64)
-#include <VersionHelpers.h>
-
-#include "api-d3d9.h"
-#include "api-d3d11.h"
-#endif
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-using namespace Plugin;
-using namespace Plugin::AMD;
-using namespace Plugin::Interface;
-
-enum Presets {
-	None = -1,
-	Default = 0,
-	Recording,
-	HighQuality,
-	Indistinguishable,
-	Lossless,
-	Twitch,
-	YouTube,
-};
-enum ViewMode {
-	Basic,
-	Advanced,
-	Expert,
-	Master
-};
-
-void Plugin::Interface::H264Interface::encoder_register() {
-	static obs_encoder_info* encoder_info = new obs_encoder_info();
-	static const char* encoder_name = "amd_amf_h264";
-	static const char* encoder_codec = "h264";
-
-	std::memset(encoder_info, 0, sizeof(obs_encoder_info));
-
-	// Initialize Structure
-	encoder_info->id = encoder_name;
-	encoder_info->type = obs_encoder_type::OBS_ENCODER_VIDEO;
-	encoder_info->codec = encoder_codec;
-
-	// Functions
-	encoder_info->get_name = &get_name;
-	encoder_info->get_defaults = &get_defaults;
-	encoder_info->get_properties = &get_properties;
-	encoder_info->create = &create;
-	encoder_info->destroy = &destroy;
-	encoder_info->encode = &encode;
-	encoder_info->update = &update;
-	encoder_info->get_video_info = &get_video_info;
-	encoder_info->get_extra_data = &get_extra_data;
-
-	obs_register_encoder(encoder_info);
-
-	//////////////////////////////////////////////////////////////////////////
-	// Deprecated old Encoder
-	static obs_encoder_info* encoder_info_simple = new obs_encoder_info();
-	static const char* encoder_name_simple = "amd_amf_h264_simple";
-
-	std::memset(encoder_info_simple, 0, sizeof(obs_encoder_info));
-
-	// Initialize Structure
-	encoder_info_simple->id = encoder_name_simple;
-	encoder_info_simple->type = obs_encoder_type::OBS_ENCODER_VIDEO;
-	encoder_info_simple->codec = encoder_codec;
-
-	// Functions
-	encoder_info_simple->get_name = &get_name_simple;
-	encoder_info_simple->get_defaults = &get_defaults;
-	encoder_info_simple->get_properties = &get_properties;
-	encoder_info_simple->create = &create;
-	encoder_info_simple->destroy = &destroy;
-	encoder_info_simple->encode = &encode;
-	encoder_info_simple->update = &update;
-	encoder_info_simple->get_video_info = &get_video_info;
-	encoder_info_simple->get_extra_data = &get_extra_data;
-
-	obs_register_encoder(encoder_info_simple);
-	//////////////////////////////////////////////////////////////////////////
-}
-
-const char* Plugin::Interface::H264Interface::get_name(void*) {
-	static const char* name = "H264 Encoder (AMD Advanced Media Framework)";
-	return name;
-}
-
-//////////////////////////////////////////////////////////////////////////
-// Deprecated old Encoder
-const char* Plugin::Interface::H264Interface::get_name_simple(void*) {
-	static const char* name = "[DEPRECATED] H264 Encoder (AMD Advanced Media Framework)";
-	return name;
-}
-//////////////////////////////////////////////////////////////////////////
-void* Plugin::Interface::H264Interface::create(obs_data_t* settings, obs_encoder_t* encoder) {
-	try {
-		AMF_LOG_INFO("Starting up...");
-		Plugin::Interface::H264Interface* enc = new Plugin::Interface::H264Interface(settings, encoder);
-		return enc;
-	} catch (std::exception e) {
-		AMF_LOG_ERROR("Exception: %s", e.what());
-		AMF_LOG_ERROR("Unable to create Encoder, see log for more information.");
-		return NULL;
-	} catch (...) {
-		AMF_LOG_ERROR("Unhandled Exception during start up.");
-		return NULL;
-	}
-}
-
-#pragma warning( push )
-#pragma warning( disable: 4702 )
-void Plugin::Interface::H264Interface::destroy(void* data) {
-	try {
-		AMF_LOG_INFO("Shutting down...");
-		Plugin::Interface::H264Interface* enc = static_cast<Plugin::Interface::H264Interface*>(data);
-		delete enc;
-		data = nullptr;
-	} catch (std::exception e) {
-		AMF_LOG_ERROR("Exception: %s", e.what());
-		AMF_LOG_ERROR("Unable to destroy Encoder, see log for more information.");
-	} catch (...) {
-		AMF_LOG_ERROR("Unhandled Exception during shut down.");
-	}
-}
-#pragma warning( pop )
-
-bool Plugin::Interface::H264Interface::encode(void *data, struct encoder_frame *frame, struct encoder_packet *packet, bool *received_packet) {
-	try {
-		return static_cast<Plugin::Interface::H264Interface*>(data)->encode(frame, packet, received_packet);
-	} catch (std::exception e) {
-		AMF_LOG_ERROR("Exception: %s", e.what());
-		AMF_LOG_ERROR("Unable to encode, see log for more information.");
-		return false;
-	} catch (...) {
-		throw;
-	}
-}
-
-void Plugin::Interface::H264Interface::get_defaults(obs_data_t *data) {
-	#pragma region OBS - Enforce Streaming Service Restrictions
-	// OBS - Enforce Streaming Service Restrictions
-	obs_data_set_default_int(data, "bitrate", -1);
-	obs_data_set_default_int(data, "keyint_sec", -1);
-	obs_data_set_default_string(data, "rate_control", "");
-	obs_data_set_default_string(data, "profile", "");
-	obs_data_set_default_string(data, "preset", "");
-	obs_data_set_int(data, "bitrate", -1);
-	obs_data_set_int(data, "keyint_sec", -1);
-	obs_data_set_string(data, "rate_control", "");
-	obs_data_set_string(data, "profile", "");
-	obs_data_set_string(data, "preset", "");
-	#pragma endregion OBS - Enforce Streaming Service Restrictions
-
-	obs_data_set_default_int(data, AMF_H264_PRESET, -1);
-
-	// Static Properties
-	obs_data_set_default_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-	obs_data_set_default_int(data, AMF_H264_PROFILE, VCEProfile_Main);
-	obs_data_set_default_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-	obs_data_set_default_int(data, AMF_H264_MAXIMUMLTRFRAMES, 0);
-
-	// Rate Control Properties
-	obs_data_set_default_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantBitrate);
-	obs_data_set_default_int(data, AMF_H264_BITRATE_TARGET, 3500);
-	obs_data_set_default_int(data, AMF_H264_BITRATE_PEAK, 9000);
-	obs_data_set_default_int(data, AMF_H264_QP_MINIMUM, 1);
-	obs_data_set_default_int(data, AMF_H264_QP_MAXIMUM, 51);
-	obs_data_set_default_int(data, AMF_H264_QP_IFRAME, 22);
-	obs_data_set_default_int(data, AMF_H264_QP_PFRAME, 22);
-	obs_data_set_default_int(data, AMF_H264_QP_BFRAME, 22);
-	obs_data_set_default_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
-	obs_data_set_default_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
-	obs_data_set_default_int(data, AMF_H264_VBVBUFFER, 0);
-	obs_data_set_default_int(data, AMF_H264_VBVBUFFER_SIZE, 3500);
-	obs_data_set_default_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 100);
-	obs_data_set_default_double(data, AMF_H264_VBVBUFFER_FULLNESS, 100);
-	obs_data_set_default_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-	obs_data_set_default_int(data, AMF_H264_FILLERDATA, 1);
-	obs_data_set_default_int(data, AMF_H264_FRAMESKIPPING, 0);
-	obs_data_set_default_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-	// Picture Control Properties
-	obs_data_set_default_double(data, AMF_H264_KEYFRAME_INTERVAL, 2);
-	obs_data_set_default_int(data, AMF_H264_IDR_PERIOD, 60);
-	obs_data_set_default_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-	obs_data_set_default_int(data, AMF_H264_BPICTURE_PATTERN, (VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->supportsBFrames ? VCEBPicturePattern_Three : VCEBPicturePattern_None));
-	obs_data_set_default_int(data, AMF_H264_BPICTURE_REFERENCE, (VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->supportsBFrames ? 1 : 0));
-	obs_data_set_default_int(data, AMF_H264_DEBLOCKINGFILTER, 1);
-	obs_data_set_default_int(data, AMF_H264_SLICESPERFRAME, 0);
-	obs_data_set_default_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-	// Miscellaneous Control Properties
-	obs_data_set_default_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-	obs_data_set_default_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-	obs_data_set_default_int(data, AMF_H264_MOTIONESTIMATION, 3);
-	obs_data_set_default_int(data, AMF_H264_CABAC, 0);
-
-	// System Properties
-	obs_data_set_default_int(data, AMF_H264_MEMORYTYPE, VCEMemoryType_Host);
-	obs_data_set_default_int(data, AMF_H264_USE_OPENCL, 0);
-	obs_data_set_default_int(data, AMF_H264_SURFACEFORMAT, -1);
-	obs_data_set_default_int(data, AMF_H264_VIEW, ViewMode::Basic);
-	obs_data_set_default_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-	obs_data_set_default_bool(data, AMF_H264_DEBUG, 0);
-}
-
-void fill_device_list(obs_property_t* p, obs_data_t* data) {
-	std::vector<Plugin::API::Device> devices;
-
-	switch ((VCEMemoryType)obs_data_get_int(data, AMF_H264_MEMORYTYPE)) {
-		case VCEMemoryType_Auto:
-			#ifdef _WIN32
-			if (IsWindows8OrGreater()) {
-				// DirectX 11
-				devices = Plugin::API::Direct3D11::EnumerateDevices();
-			} else if (IsWindowsXPOrGreater()) {
-				// DirectX 9
-				//devices = Plugin::API::Direct3D9::EnumerateDevices();
-			} else
-				#endif
-			{
-				// OpenGL
-			}
-			break;
-
-			#ifdef _WIN32
-		case VCEMemoryType_DirectX9:
-			if (IsWindowsXPOrGreater()) // DirectX 9
-				//devices = Plugin::API::Direct3D9::EnumerateDevices();
-				break;
-		case VCEMemoryType_DirectX11:
-			if (IsWindows8OrGreater()) // DirectX 11
-				devices = Plugin::API::Direct3D11::EnumerateDevices();
-			break;
-			#endif
-		case VCEMemoryType_OpenGL:
-			// OpenGL
-			break;
-		/*case VCEMemoryType_Host:
-			break;*/
-	}
-
-	obs_property_list_clear(p);
-	obs_property_list_add_string(p, obs_module_text(AMF_UTIL_DEFAULT), "");
-	for (Plugin::API::Device device : devices) {
-		obs_property_list_add_string(p, device.Name.c_str(), device.UniqueId.c_str());
-	}
-}
-
-obs_properties_t* Plugin::Interface::H264Interface::get_properties(void*) {
-	obs_properties* props = obs_properties_create();
-	obs_property_t* p;
-
-	#pragma region Preset
-	p = obs_properties_add_list(props, AMF_H264_PRESET, obs_module_text(AMF_H264_PRESET), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_modified_callback(p, preset_modified);
-	obs_property_list_add_int(p, "", -1);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_DEFAULT), Presets::Default);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_PRESET_RECORDING), Presets::Recording);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_PRESET_HIGHQUALITY), Presets::HighQuality);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_PRESET_INDISTINGUISHABLE), Presets::Indistinguishable);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_PRESET_LOSSLESS), Presets::Lossless);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_PRESET_TWITCH), Presets::Twitch);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_PRESET_YOUTUBE), Presets::YouTube);
-	#pragma endregion Preset
-
-	#pragma region Static Properties
-	#pragma region Usage
-	p = obs_properties_add_list(props, AMF_H264_USAGE, obs_module_text(AMF_H264_USAGE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_USAGE_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_USAGE_TRANSCODING), VCEUsage_Transcoding);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_USAGE_ULTRALOWLATENCY), VCEUsage_UltraLowLatency);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_USAGE_LOWLATENCY), VCEUsage_LowLatency);
-	//obs_property_list_add_int(list, obs_module_text(AMF_H264_USAGE_WEBCAM), VCEUsage_Webcam); // Requires SVC? SVC is not implemented by default.
-	#pragma endregion Usage
-	#pragma region Profile
-	p = obs_properties_add_list(props, AMF_H264_PROFILE, obs_module_text(AMF_H264_PROFILE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_PROFILE_DESCRIPTION));
-	switch (VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxProfile) {
-		case 100:
-			obs_property_list_add_int(p, "High", VCEProfile_High);
-		case 77:
-			obs_property_list_add_int(p, "Main", VCEProfile_Main);
-		case 66:
-			obs_property_list_add_int(p, "Baseline", VCEProfile_Baseline);
-			break;
-	}
-	#pragma endregion Profile
-	#pragma region Profile Level
-	p = obs_properties_add_list(props, AMF_H264_PROFILELEVEL, obs_module_text(AMF_H264_PROFILELEVEL), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_PROFILELEVEL_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_AUTOMATIC), VCEProfileLevel_Automatic);
-	switch (VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxProfileLevel) {
-		case 52:
-			obs_property_list_add_int(p, "5.2", VCEProfileLevel_52);
-		case 51:
-			obs_property_list_add_int(p, "5.1", VCEProfileLevel_51);
-		case 50:
-			obs_property_list_add_int(p, "5.0", VCEProfileLevel_50);
-		case 42: // Some VCE 2.0 Cards.
-			obs_property_list_add_int(p, "4.2", VCEProfileLevel_42);
-		case 41: // Some APUs and VCE 1.0 Cards.
-			obs_property_list_add_int(p, "4.1", VCEProfileLevel_41);
-		case 40: // These should in theory be supported by all VCE 1.0 devices and APUs.
-			obs_property_list_add_int(p, "4.0", VCEProfileLevel_40);
-		case 32:
-			obs_property_list_add_int(p, "3.2", VCEProfileLevel_32);
-		case 31:
-			obs_property_list_add_int(p, "3.1", VCEProfileLevel_31);
-		case 30:
-			obs_property_list_add_int(p, "3.0", VCEProfileLevel_30);
-		case 22:
-			obs_property_list_add_int(p, "2.2", VCEProfileLevel_22);
-		case 21:
-			obs_property_list_add_int(p, "2.1", VCEProfileLevel_21);
-		case 20:
-			obs_property_list_add_int(p, "2.0", VCEProfileLevel_20);
-		case 13:
-			obs_property_list_add_int(p, "1.3", VCEProfileLevel_13);
-		case 12:
-			obs_property_list_add_int(p, "1.2", VCEProfileLevel_12);
-		case 11:
-			obs_property_list_add_int(p, "1.1", VCEProfileLevel_11);
-		case 10:
-		default:
-			obs_property_list_add_int(p, "1.0", VCEProfileLevel_10);
-	}
-	#pragma endregion Profile Levels
-	#pragma region Long Term Reference Frames
-	p = obs_properties_add_int_slider(props, AMF_H264_MAXIMUMLTRFRAMES, obs_module_text(AMF_H264_MAXIMUMLTRFRAMES), 0, 2, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_MAXIMUMLTRFRAMES_DESCRIPTION));
-	obs_property_set_modified_callback(p, maximum_ltr_frames_modified);
-	#pragma endregion Long Term Reference Frames
-	#pragma endregion Static Properties
-
-	#pragma region Rate Control Properties
-	//p = obs_properties_add_bool(props, "rcp_delimiter", "------ Rate Control Properties ------");
-	#pragma region Method
-	p = obs_properties_add_list(props, AMF_H264_RATECONTROLMETHOD, obs_module_text(AMF_H264_RATECONTROLMETHOD), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_RATECONTROLMETHOD_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_RATECONTROLMETHOD_CQP), VCERateControlMethod_ConstantQP);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_RATECONTROLMETHOD_CBR), VCERateControlMethod_ConstantBitrate);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_RATECONTROLMETHOD_VBR), VCERateControlMethod_VariableBitrate_PeakConstrained);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_RATECONTROLMETHOD_VBR_LAT), VCERateControlMethod_VariableBitrate_LatencyConstrained);
-	obs_property_set_modified_callback(p, rate_control_method_modified);
-	#pragma endregion Method
-	#pragma region Method Parameters
-	/// Bitrate Constraints
-	p = obs_properties_add_int(props, AMF_H264_BITRATE_TARGET, obs_module_text(AMF_H264_BITRATE_TARGET), 0, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_BITRATE_TARGET_DESCRIPTION));
-	p = obs_properties_add_int(props, AMF_H264_BITRATE_PEAK, obs_module_text(AMF_H264_BITRATE_PEAK), 0, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_BITRATE_PEAK_DESCRIPTION));
-	/// Minimum QP, Maximum QP
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_MINIMUM, obs_module_text(AMF_H264_QP_MINIMUM), 0, 51, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_MINIMUM_DESCRIPTION));
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_MAXIMUM, obs_module_text(AMF_H264_QP_MAXIMUM), 0, 51, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_MAXIMUM_DESCRIPTION));
-	/// Method: Constant QP
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_IFRAME, obs_module_text(AMF_H264_QP_IFRAME), 0, 51, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_IFRAME_DESCRIPTION));
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_PFRAME, obs_module_text(AMF_H264_QP_PFRAME), 0, 51, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_PFRAME_DESCRIPTION));
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_BFRAME, obs_module_text(AMF_H264_QP_BFRAME), 0, 51, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_BFRAME_DESCRIPTION));
-	/// B-Picture Related
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_BPICTURE_DELTA, obs_module_text(AMF_H264_QP_BPICTURE_DELTA), -10, 10, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_BPICTURE_DELTA_DESCRIPTION));
-	p = obs_properties_add_int_slider(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, obs_module_text(AMF_H264_QP_REFERENCE_BPICTURE_DELTA), -10, 10, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QP_REFERENCE_BPICTURE_DELTA_DESCRIPTION));
-	#pragma endregion Method Parameters
-	#pragma region VBV Buffer
-	p = obs_properties_add_list(props, AMF_H264_VBVBUFFER, obs_module_text(AMF_H264_VBVBUFFER), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_VBVBUFFER_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_AUTOMATIC), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_MANUAL), 1);
-	obs_property_set_modified_callback(p, view_modified);
-	p = obs_properties_add_float_slider(props, AMF_H264_VBVBUFFER_STRICTNESS, obs_module_text(AMF_H264_VBVBUFFER_STRICTNESS), 0.0, 100.0, 0.1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_VBVBUFFER_STRICTNESS_DESCRIPTION));
-	p = obs_properties_add_int_slider(props, AMF_H264_VBVBUFFER_SIZE, obs_module_text(AMF_H264_VBVBUFFER_SIZE), 1, 1000000, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_VBVBUFFER_SIZE_DESCRIPTION));
-	p = obs_properties_add_float_slider(props, AMF_H264_VBVBUFFER_FULLNESS, obs_module_text(AMF_H264_VBVBUFFER_FULLNESS), 0.0, 100.0, 100.0 / 64.0);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_VBVBUFFER_FULLNESS_DESCRIPTION));
-	#pragma endregion VBV Buffer
-	/// Max Access Unit Size
-	p = obs_properties_add_int_slider(props, AMF_H264_MAXIMUMACCESSUNITSIZE, obs_module_text(AMF_H264_MAXIMUMACCESSUNITSIZE), 0, 100000000, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_MAXIMUMACCESSUNITSIZE_DESCRIPTION));
-	#pragma region Flags
-	/// Filler Data (Only supported by CBR so far)
-	p = obs_properties_add_list(props, AMF_H264_FILLERDATA, obs_module_text(AMF_H264_FILLERDATA), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_FILLERDATA_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	/// Frame Skipping
-	p = obs_properties_add_list(props, AMF_H264_FRAMESKIPPING, obs_module_text(AMF_H264_FRAMESKIPPING), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_FRAMESKIPPING_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	/// Enforce Hypothetical Reference Decoder Compatibility
-	p = obs_properties_add_list(props, AMF_H264_ENFORCEHRDCOMPATIBILITY, obs_module_text(AMF_H264_ENFORCEHRDCOMPATIBILITY), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_ENFORCEHRDCOMPATIBILITY_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	#pragma endregion Flags
-	#pragma endregion Rate Control Properties
-
-	#pragma region Picture Control Properties
-	//p = obs_properties_add_bool(props, "pcp_delimiter", "------ Picture Control Properties ------");
-	#pragma region IDR Period / Keyframe Interval / Header Insertion Spacing
-	p = obs_properties_add_float(props, AMF_H264_KEYFRAME_INTERVAL, obs_module_text(AMF_H264_KEYFRAME_INTERVAL), 0, 100, 0.001);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_KEYFRAME_INTERVAL_DESCRIPTION));
-	p = obs_properties_add_int(props, AMF_H264_IDR_PERIOD, obs_module_text(AMF_H264_IDR_PERIOD), 1, 1000, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_IDR_PERIOD_DESCRIPTION));
-	p = obs_properties_add_int(props, AMF_H264_HEADER_INSERTION_SPACING, obs_module_text(AMF_H264_HEADER_INSERTION_SPACING), 0, 1000, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_HEADER_INSERTION_SPACING_DESCRIPTION));
-	#pragma endregion IDR Period / Keyframe Interval / Header Insertion Spacing
-	#pragma region B-Pictures
-	/// B-Pictures Pattern
-	p = obs_properties_add_int_slider(props, AMF_H264_BPICTURE_PATTERN, obs_module_text(AMF_H264_BPICTURE_PATTERN), 0, (VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->supportsBFrames ? 3 : 0), 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_BPICTURE_PATTERN_DESCRIPTION));
-	obs_property_set_modified_callback(p, bpictures_modified);
-	/// Enable Reference to B-Frames (2nd Generation GCN and newer)
-	p = obs_properties_add_list(props, AMF_H264_BPICTURE_REFERENCE, obs_module_text(AMF_H264_BPICTURE_REFERENCE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_BPICTURE_REFERENCE_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	#pragma endregion B-Pictures
-	/// De-Blocking Filter
-	p = obs_properties_add_list(props, AMF_H264_DEBLOCKINGFILTER, obs_module_text(AMF_H264_DEBLOCKINGFILTER), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_DEBLOCKINGFILTER_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	/// Number of Slices Per Frame 
-	p = obs_properties_add_int_slider(props, AMF_H264_SLICESPERFRAME, obs_module_text(AMF_H264_SLICESPERFRAME), 0, 65535, 1);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_SLICESPERFRAME_DESCRIPTION));
-	/// Intra Refresh Number of Macro Blocks per Slot
-	obs_properties_add_int_slider(props, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, obs_module_text(AMF_H264_INTRAREFRESHNUMMBSPERSLOT), 0, 65535, 1);
-	#pragma endregion Picture Control Properties
-
-	#pragma region Miscellaneous Control Properties
-	//p = obs_properties_add_bool(props, "msc_delimiter", "------ Miscellaneous Properties ------");
-	/// Quality Preset
-	p = obs_properties_add_list(props, AMF_H264_QUALITY_PRESET, obs_module_text(AMF_H264_QUALITY_PRESET), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_QUALITY_PRESET_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_QUALITY_PRESET_SPEED), VCEQualityPreset_Speed);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_QUALITY_PRESET_BALANCED), VCEQualityPreset_Balanced);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_QUALITY_PRESET_QUALITY), VCEQualityPreset_Quality);
-	/// Scan Type
-	p = obs_properties_add_list(props, AMF_H264_SCANTYPE, obs_module_text(AMF_H264_SCANTYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_SCANTYPE_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_SCANTYPE_PROGRESSIVE), VCEScanType_Progressive);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_SCANTYPE_INTERLACED), VCEScanType_Interlaced);
-	/// Motion Estimation
-	p = obs_properties_add_list(props, AMF_H264_MOTIONESTIMATION, obs_module_text(AMF_H264_MOTIONESTIMATION), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_MOTIONESTIMATION_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_MOTIONESTIMATION_NONE), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_MOTIONESTIMATION_HALF), 1);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_MOTIONESTIMATION_QUARTER), 2);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_MOTIONESTIMATION_BOTH), 3);
-	/// CABAC
-	p = obs_properties_add_list(props, AMF_H264_CABAC, obs_module_text(AMF_H264_CABAC), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_CABAC_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	#pragma endregion Miscellaneous Control Properties
-
-	#pragma region System Properties
-	//p = obs_properties_add_bool(props, "sys_delimiter", "------ System Properties ------");
-	/// Memory Type
-	p = obs_properties_add_list(props, AMF_H264_MEMORYTYPE, obs_module_text(AMF_H264_MEMORYTYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_MEMORYTYPE_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_AUTOMATIC), VCEMemoryType_Auto);
-	obs_property_list_add_int(p, "Host", VCEMemoryType_Host);
-	#ifdef _WIN32
-	if (IsWindowsXPOrGreater()) {
-		obs_property_list_add_int(p, "DirectX 9", VCEMemoryType_DirectX9);
-		if (IsWindows8OrGreater()) {
-			obs_property_list_add_int(p, "DirectX 11", VCEMemoryType_DirectX11);
-		}
-	}
-	#endif
-	obs_property_list_add_int(p, "OpenGL", VCEMemoryType_OpenGL);
-	obs_property_set_modified_callback(p, view_modified);
-	/// Device
-	p = obs_properties_add_list(props, AMF_H264_DEVICE, obs_module_text(AMF_H264_DEVICE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_DEVICE_DESCRIPTION));
-	/// Compute Type
-	p = obs_properties_add_list(props, AMF_H264_USE_OPENCL, obs_module_text(AMF_H264_USE_OPENCL), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_USE_OPENCL_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_DISABLED), 0);
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_TOGGLE_ENABLED), 1);
-	/// Surface Format
-	p = obs_properties_add_list(props, AMF_H264_SURFACEFORMAT, obs_module_text(AMF_H264_SURFACEFORMAT), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_SURFACEFORMAT_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_UTIL_AUTOMATIC), -1);
-	auto formats = Plugin::AMD::VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->input.formats;
-	for (auto format = formats.begin(); format != formats.end(); format++) {
-		switch (format->first) {
-			case amf::AMF_SURFACE_NV12:
-				obs_property_list_add_int(p, "NV12 (4:2:0)", VCESurfaceFormat_NV12);
-				break;
-			case amf::AMF_SURFACE_YUV420P:
-				obs_property_list_add_int(p, "I420 (4:2:0)", VCESurfaceFormat_I420);
-				break;
-			case amf::AMF_SURFACE_YUY2:
-				obs_property_list_add_int(p, "YUY2 (4:2:2)", VCESurfaceFormat_YUY2);
-				break;
-			case amf::AMF_SURFACE_BGRA:
-				obs_property_list_add_int(p, "BGRA (Uncompressed)", VCESurfaceFormat_BGRA);
-				break;
-			case amf::AMF_SURFACE_RGBA:
-				obs_property_list_add_int(p, "RGBA (Uncompressed)", VCESurfaceFormat_RGBA);
-				break;
-			case amf::AMF_SURFACE_GRAY8:
-				obs_property_list_add_int(p, "Y800 (Gray)", VCESurfaceFormat_GRAY);
-				break;
-		}
-	}
-
-	/// View Mode
-	p = obs_properties_add_list(props, AMF_H264_VIEW, obs_module_text(AMF_H264_VIEW), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_VIEW_DESCRIPTION));
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_VIEW_BASIC), ViewMode::Basic);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_VIEW_ADVANCED), ViewMode::Advanced);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_VIEW_EXPERT), ViewMode::Expert);
-	obs_property_list_add_int(p, obs_module_text(AMF_H264_VIEW_MASTER), ViewMode::Master);
-	obs_property_set_modified_callback(p, view_modified);
-	/// Unlock Properties to full range.
-	p = obs_properties_add_bool(props, AMF_H264_UNLOCK_PROPERTIES, obs_module_text(AMF_H264_UNLOCK_PROPERTIES));
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_UNLOCK_PROPERTIES_DESCRIPTION));
-	obs_property_set_modified_callback(p, unlock_properties_modified);
-
-	/// Debug
-	p = obs_properties_add_bool(props, AMF_H264_DEBUG, obs_module_text(AMF_H264_DEBUG));
-	obs_property_set_long_description(p, obs_module_text(AMF_H264_DEBUG_DESCRIPTION));
-	#pragma endregion System Properties
-
-	return props;
-}
-
-bool Plugin::Interface::H264Interface::preset_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
-	auto caps = VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC);
-	Presets preset = (Presets)obs_data_get_int(data, AMF_H264_PRESET);
-	switch (preset) {
-		case Default:
-			#pragma region Default
-		{
-			obs_property_t* pn = obs_properties_first(props);
-			while (pn) {
-				const char* name = obs_property_name(pn);
-				switch (obs_property_get_type(pn)) {
-					case obs_property_type::OBS_PROPERTY_BOOL:
-						obs_data_set_bool(data, name, obs_data_get_default_bool(data, name));
-						break;
-					case obs_property_type::OBS_PROPERTY_FLOAT:
-						obs_data_set_double(data, name, obs_data_get_default_double(data, name));
-						break;
-					case obs_property_type::OBS_PROPERTY_INT:
-						obs_data_set_int(data, name, obs_data_get_default_int(data, name));
-						break;
-					case obs_property_type::OBS_PROPERTY_TEXT:
-						obs_data_set_string(data, name, obs_data_get_default_string(data, name));
-						break;
-					case obs_property_type::OBS_PROPERTY_LIST:
-						switch (obs_property_list_format(pn)) {
-							case obs_combo_format::OBS_COMBO_FORMAT_INT:
-								obs_data_set_int(data, name, obs_data_get_default_int(data, name));
-								break;
-							case obs_combo_format::OBS_COMBO_FORMAT_FLOAT:
-								obs_data_set_double(data, name, obs_data_get_default_double(data, name));
-								break;
-							case obs_combo_format::OBS_COMBO_FORMAT_STRING:
-								obs_data_set_string(data, name, obs_data_get_default_string(data, name));
-								break;
-						}
-						break;
-				}
-				obs_property_next(&pn);
-			}
-		}
-		break;
-		#pragma endregion Default
-		case Recording:
-			#pragma region Recording
-			// Static Properties
-			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
-			switch (caps->maxProfileLevel) {
-				case 52:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_52);
-					break;
-				case 51:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_51);
-					break;
-				case 50:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_50);
-					break;
-				default:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-					break;
-			}
-			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
-
-			// Rate Control Properties
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_VariableBitrate_LatencyConstrained);
-			obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
-			obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
-			obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
-			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);
-			/*obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);*/
-			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-			obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
-			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
-			obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-			// Picture Control Properties
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
-			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 60);
-			obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
-			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
-			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
-			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-			// Miscellaneous Properties
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
-			obs_data_set_int(data, AMF_H264_CABAC, 0);
-
-			// System Properties
-			obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-
-			break;
-			#pragma endregion Recording
-		case HighQuality:
-			#pragma region High Quality
-			// Static Properties
-			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
-			switch (caps->maxProfileLevel) {
-				case 52:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_52);
-					break;
-				case 51:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_51);
-					break;
-				case 50:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_50);
-					break;
-				default:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-					break;
-			}
-			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
-
-			// Rate Control Properties
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantQP);
-			//obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
-			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
-			/*obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
-			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);*/
-			obs_data_set_int(data, AMF_H264_QP_IFRAME, 21);
-			obs_data_set_int(data, AMF_H264_QP_PFRAME, 18);
-			obs_data_set_int(data, AMF_H264_QP_BFRAME, 16);
-			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-			//obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
-			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
-			obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-			// Picture Control Properties
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
-			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 60);
-			obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
-			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
-			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
-			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-			// Miscellaneous Properties
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
-			obs_data_set_int(data, AMF_H264_CABAC, 0);
-
-			// System Properties
-			obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-
-			break;
-			#pragma endregion High Quality
-		case Indistinguishable:
-			#pragma region Indistinguishable
-			// Static Properties
-			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
-			switch (caps->maxProfileLevel) {
-				case 52:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_52);
-					break;
-				case 51:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_51);
-					break;
-				case 50:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_50);
-					break;
-				default:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-					break;
-			}
-			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
-
-			// Rate Control Properties
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantQP);
-			//obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
-			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
-			/*obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
-			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);*/
-			obs_data_set_int(data, AMF_H264_QP_IFRAME, 16);
-			obs_data_set_int(data, AMF_H264_QP_PFRAME, 13);
-			obs_data_set_int(data, AMF_H264_QP_BFRAME, 11);
-			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, -4);
-			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, -2);
-			obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-			//obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
-			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
-			obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-			// Picture Control Properties
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
-			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 60);
-			obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
-			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
-			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
-			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-			// Miscellaneous Properties
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
-			obs_data_set_int(data, AMF_H264_CABAC, 0);
-
-			// System Properties
-			obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-
-			break;
-			#pragma endregion Indistinguishable
-		case Lossless:
-			#pragma region Lossless
-			// Static Properties
-			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
-			switch (caps->maxProfileLevel) {
-				case 52:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_52);
-					break;
-				case 51:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_51);
-					break;
-				case 50:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_50);
-					break;
-				default:
-					obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-					break;
-			}
-			obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, 0);
-
-			// Rate Control Properties
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantQP);
-			//obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
-			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
-			/*obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
-			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);*/
-			obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, -10);
-			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, -10);
-			obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-			//obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
-			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
-			obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-			// Picture Control Properties
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 0);
-			obs_data_set_int(data, AMF_H264_IDR_PERIOD, 1);
-			obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-			obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, 0);
-			obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
-			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
-			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-			// Miscellaneous Properties
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
-			obs_data_set_int(data, AMF_H264_CABAC, 0);
-
-			// System Properties
-			obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-
-			break;
-			#pragma endregion Lossless
-		case Twitch:
-			#pragma region Twitch
-			// Static Properties
-			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_Main);
-			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get);
-
-			// Rate Control Properties
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantBitrate);
-			obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 3500);
-			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
-			obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
-			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);
-			/*obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);*/
-			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 90);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 100);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-			obs_data_set_int(data, AMF_H264_FILLERDATA, 1);
-			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
-			obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-			// Picture Control Properties
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 2);
-			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 120);
-			obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
-			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
-			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-			// Miscellaneous Properties
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
-			obs_data_set_int(data, AMF_H264_CABAC, 0);
-
-			// System Properties
-			obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-
-			break;
-			#pragma endregion Twitch
-		case YouTube:
-			#pragma region YouTube
-			// Static Properties
-			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
-			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_Main);
-			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get);
-
-			// Rate Control Properties
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantBitrate);
-			obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 6000);
-			obs_data_set_int(data, AMF_H264_BITRATE_PEAK, 9000);
-			obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
-			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);
-			/*obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
-			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);*/
-			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
-			obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 75);
-			obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 100);
-			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
-			obs_data_set_int(data, AMF_H264_FILLERDATA, 1);
-			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
-			obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
-
-			// Picture Control Properties
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 2);
-			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 120);
-			obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, 0);
-			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
-			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
-			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
-
-			// Miscellaneous Properties
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
-			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
-			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
-			obs_data_set_int(data, AMF_H264_CABAC, 0);
-
-			// System Properties
-			obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, 0);
-
-			break;
-			#pragma endregion YouTube
-	}
-	return view_modified(props, nullptr, data);
-}
-
-bool Plugin::Interface::H264Interface::maximum_ltr_frames_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
-	return view_modified(props, nullptr, data);
-}
-
-bool Plugin::Interface::H264Interface::rate_control_method_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
-	return view_modified(props, nullptr, data);
-}
-
-bool Plugin::Interface::H264Interface::bpictures_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
-	view_modified(props, nullptr, data);
-	return false;
-}
-
-bool Plugin::Interface::H264Interface::view_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
-	uint32_t view = (uint32_t)obs_data_get_int(data, AMF_H264_VIEW);
-	bool vis_basic = view >= ViewMode::Basic,
-		vis_advanced = view >= ViewMode::Advanced,
-		vis_expert = view >= ViewMode::Expert,
-		vis_master = view >= ViewMode::Master,
-		vis_rcm_bitrate_target = false,
-		vis_rcm_bitrate_peak = false,
-		vis_rcm_qp = false,
-		vis_rcm_qp_b = false,
-		vis_rcm_fillerdata = false;
-
-	// Static Properties
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_USAGE), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_USAGE, obs_data_get_default_int(data, AMF_H264_USAGE));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_PROFILE), vis_advanced);
-	if (!vis_basic)
-		obs_data_set_int(data, AMF_H264_PROFILE, obs_data_get_default_int(data, AMF_H264_PROFILE));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_PROFILELEVEL), vis_expert);
-	if (!vis_expert)
-		obs_data_set_int(data, AMF_H264_PROFILELEVEL, obs_data_get_default_int(data, AMF_H264_PROFILELEVEL));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_MAXIMUMLTRFRAMES), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
-	bool using_ltr_frames = obs_data_get_int(data, AMF_H264_MAXIMUMLTRFRAMES) > 0;
-
-	// Rate Control Properties
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), vis_basic);
-	if (!vis_basic)
-		obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, obs_data_get_default_int(data, AMF_H264_RATECONTROLMETHOD));
-	switch ((VCERateControlMethod)obs_data_get_int(data, AMF_H264_RATECONTROLMETHOD)) {
-		case VCERateControlMethod_ConstantBitrate:
-			vis_rcm_bitrate_target = true;
-			vis_rcm_fillerdata = true;
-			break;
-		case VCERateControlMethod_VariableBitrate_PeakConstrained:
-			vis_rcm_bitrate_target = true;
-			vis_rcm_bitrate_peak = true;
-			break;
-		case VCERateControlMethod_VariableBitrate_LatencyConstrained:
-			vis_rcm_bitrate_target = true;
-			break;
-		case VCERateControlMethod_ConstantQP:
-			vis_rcm_qp = true;
-			vis_rcm_qp_b = VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->supportsBFrames
-				&& (using_ltr_frames == false);
-			break;
-	}
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_BITRATE_TARGET), (vis_basic && vis_rcm_bitrate_target));
-	if (!((vis_basic && vis_rcm_bitrate_target)))
-		obs_data_set_int(data, AMF_H264_BITRATE_TARGET, obs_data_get_default_int(data, AMF_H264_BITRATE_TARGET));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_BITRATE_PEAK), (vis_basic && vis_rcm_bitrate_peak));
-	if (!((vis_basic && vis_rcm_bitrate_peak)))
-		obs_data_set_int(data, AMF_H264_BITRATE_PEAK, obs_data_get_default_int(data, AMF_H264_BITRATE_PEAK));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_MINIMUM), vis_advanced && !vis_rcm_qp);
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_MAXIMUM), vis_advanced && !vis_rcm_qp);
-	if (!(vis_advanced && !vis_rcm_qp)) {
-		obs_data_set_int(data, AMF_H264_QP_MINIMUM, obs_data_get_default_int(data, AMF_H264_QP_MINIMUM));
-		obs_data_set_int(data, AMF_H264_QP_MAXIMUM, obs_data_get_default_int(data, AMF_H264_QP_MAXIMUM));
-	}
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_IFRAME), (vis_basic && vis_rcm_qp));
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_PFRAME), (vis_basic && vis_rcm_qp));
-	if (!(vis_basic && vis_rcm_qp)) {
-		obs_data_set_int(data, AMF_H264_QP_IFRAME, obs_data_get_default_int(data, AMF_H264_QP_IFRAME));
-		obs_data_set_int(data, AMF_H264_QP_PFRAME, obs_data_get_default_int(data, AMF_H264_QP_PFRAME));
-	}
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_BFRAME), (vis_basic && vis_rcm_qp_b));
-	if (!(vis_basic && vis_rcm_qp_b))
-		obs_data_set_int(data, AMF_H264_QP_BFRAME, obs_data_get_default_int(data, AMF_H264_QP_BFRAME));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), (vis_advanced && vis_rcm_qp_b));
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), (vis_advanced && vis_rcm_qp_b));
-	if (!(vis_advanced && vis_rcm_qp_b)) {
-		obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, obs_data_get_default_int(data, AMF_H264_QP_BPICTURE_DELTA));
-		obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, obs_data_get_default_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA));
-	}
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_VBVBUFFER), vis_advanced);
-	if (!vis_advanced)
-		obs_data_set_int(data, AMF_H264_VBVBUFFER, obs_data_get_default_int(data, AMF_H264_VBVBUFFER));
-	uint32_t vbvBuffer = (uint32_t)obs_data_get_int(data, AMF_H264_VBVBUFFER);
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), (vis_advanced && (vbvBuffer == 0)));
-	if (!(vis_advanced && (vbvBuffer == 0)))
-		obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, obs_data_get_default_double(data, AMF_H264_VBVBUFFER_STRICTNESS));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_VBVBUFFER_SIZE), vis_advanced && (vbvBuffer == 1));
-	if (!(vis_advanced && (vbvBuffer == 1)))
-		obs_data_set_int(data, AMF_H264_VBVBUFFER_SIZE, obs_data_get_default_int(data, AMF_H264_VBVBUFFER_SIZE));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), vis_expert);
-	if (!vis_expert)
-		obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, obs_data_get_default_double(data, AMF_H264_VBVBUFFER_FULLNESS));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_FILLERDATA), vis_rcm_fillerdata);
-	if (!vis_rcm_fillerdata)
-		obs_data_set_int(data, AMF_H264_FILLERDATA, obs_data_get_default_int(data, AMF_H264_FILLERDATA));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_FRAMESKIPPING), vis_advanced);
-	if (!vis_advanced)
-		obs_data_set_int(data, AMF_H264_FRAMESKIPPING, obs_data_get_default_int(data, AMF_H264_FRAMESKIPPING));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_ENFORCEHRDCOMPATIBILITY), vis_expert);
-	if (!vis_expert)
-		obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, obs_data_get_default_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_MAXIMUMACCESSUNITSIZE), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, obs_data_get_default_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE));
-
-	// Picture Control Properties
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), !vis_master);
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_IDR_PERIOD), vis_master);
-	if (vis_master)
-		obs_data_set_int(data, AMF_H264_KEYFRAME_INTERVAL, obs_data_get_default_int(data, AMF_H264_KEYFRAME_INTERVAL));
-	else
-		obs_data_set_int(data, AMF_H264_IDR_PERIOD, obs_data_get_default_int(data, AMF_H264_IDR_PERIOD));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_HEADER_INSERTION_SPACING), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, obs_data_get_default_int(data, AMF_H264_HEADER_INSERTION_SPACING));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_DEBLOCKINGFILTER), vis_advanced);
-	if (!vis_advanced)
-		obs_data_set_int(data, AMF_H264_DEBLOCKINGFILTER, obs_data_get_default_int(data, AMF_H264_DEBLOCKINGFILTER));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_INTRAREFRESHNUMMBSPERSLOT), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, obs_data_get_default_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_SLICESPERFRAME), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_SLICESPERFRAME, obs_data_get_default_int(data, AMF_H264_SLICESPERFRAME));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_BPICTURE_PATTERN), vis_advanced && !using_ltr_frames);
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_BPICTURE_REFERENCE), vis_advanced && !using_ltr_frames);
-	if (!vis_advanced) {
-		obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
-		obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
-	}
-	if (using_ltr_frames) {
-		obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, VCEBPicturePattern_None);
-		obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
-	}
-
-	// Miscellaneous Properties
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_SCANTYPE), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_SCANTYPE, obs_data_get_default_int(data, AMF_H264_SCANTYPE));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_QUALITY_PRESET), vis_basic);
-	if (!vis_basic)
-		obs_data_set_int(data, AMF_H264_QUALITY_PRESET, obs_data_get_default_int(data, AMF_H264_QUALITY_PRESET));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), vis_expert);
-	if (!vis_expert)
-		obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, obs_data_get_default_int(data, AMF_H264_MOTIONESTIMATION));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_CABAC), vis_expert);
-	if (!vis_expert)
-		obs_data_set_int(data, AMF_H264_CABAC, obs_data_get_default_int(data, AMF_H264_CABAC));
-
-	// System Properties
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_MEMORYTYPE), vis_expert);
-	if (!vis_expert)
-		obs_data_set_int(data, AMF_H264_MEMORYTYPE, obs_data_get_default_int(data, AMF_H264_MEMORYTYPE));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_DEVICE), vis_expert && (obs_data_get_int(data, AMF_H264_MEMORYTYPE) != 0));
-	if (vis_expert && (obs_data_get_int(data, AMF_H264_MEMORYTYPE) != 0)) {
-		fill_device_list(obs_properties_get(props, AMF_H264_DEVICE), data);
-	} else {
-		obs_data_set_string(data, AMF_H264_DEVICE, "");
-	}
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_USE_OPENCL), vis_expert);
-	if (!vis_expert)
-		obs_data_set_int(data, AMF_H264_USE_OPENCL, obs_data_get_default_int(data, AMF_H264_USE_OPENCL));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_SURFACEFORMAT), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_SURFACEFORMAT, obs_data_get_default_int(data, AMF_H264_SURFACEFORMAT));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_VIEW), vis_basic);
-	if (!vis_basic)
-		obs_data_set_int(data, AMF_H264_VIEW, obs_data_get_default_int(data, AMF_H264_VIEW));
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_UNLOCK_PROPERTIES), vis_master);
-	if (!vis_master)
-		obs_data_set_int(data, AMF_H264_UNLOCK_PROPERTIES, obs_data_get_default_int(data, AMF_H264_UNLOCK_PROPERTIES));
-	unlock_properties_modified(props, nullptr, data);
-
-	obs_property_set_visible(obs_properties_get(props, AMF_H264_DEBUG), vis_basic);
-	if (!vis_basic)
-		obs_data_set_int(data, AMF_H264_DEBUG, obs_data_get_default_int(data, AMF_H264_DEBUG));
-
-	return true;
-}
-
-bool Plugin::Interface::H264Interface::unlock_properties_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
-	bool unlocked = obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES);
-	bool last_unlocked = obs_data_get_bool(data, "last_" vstr(AMF_H264_UNLOCK_PROPERTIES));
-
-	if (last_unlocked != unlocked) {
-		uint32_t multiplier = (unlocked == true ? 1000 : 1),
-			divisor = (unlocked == false ? 1000 : 1);
-		obs_data_set_int(data, AMF_H264_BITRATE_TARGET, (obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * multiplier) / divisor);
-		obs_data_set_int(data, AMF_H264_BITRATE_PEAK, (obs_data_get_int(data, AMF_H264_BITRATE_PEAK) * multiplier) / divisor);
-		obs_data_set_int(data, AMF_H264_VBVBUFFER_SIZE, (obs_data_get_int(data, AMF_H264_VBVBUFFER_SIZE) * multiplier) / divisor);
-
-		obs_data_set_bool(data, "last_" vstr(AMF_H264_UNLOCK_PROPERTIES), unlocked);
-	}
-
-	if (unlocked) {
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_TARGET), 1000, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate, 1);
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_PEAK), 1000, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate, 1);
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_VBVBUFFER_SIZE), 1000, 100000000, 1);
-		obs_property_float_set_limits(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), 0, 100, 1);
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_IDR_PERIOD), 0, 1000, 1);
-	} else {
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_TARGET), 1, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / 1000, 1);
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_PEAK), 1, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / 1000, 1);
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_VBVBUFFER_SIZE), 1, 100000, 1);
-		obs_property_float_set_limits(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), 1, 100, 1);
-		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_IDR_PERIOD), 1, 1000, 1);
-	}
-
-	return true;
-}
-
-bool Plugin::Interface::H264Interface::update(void *data, obs_data_t *settings) {
-	try {
-		return static_cast<Plugin::Interface::H264Interface*>(data)->update(settings);
-	} catch (...) {
-		AMF_LOG_ERROR("Unable to update Encoder, see log for more information.");
-		return false;
-	}
-}
-
-void Plugin::Interface::H264Interface::get_video_info(void *data, struct video_scale_info *info) {
-	try {
-		return static_cast<Plugin::Interface::H264Interface*>(data)->get_video_info(info);
-	} catch (...) {
-		AMF_LOG_ERROR("Unable to get video info, see log for more information.");
-	}
-}
-
-bool Plugin::Interface::H264Interface::get_extra_data(void *data, uint8_t** extra_data, size_t* size) {
-	try {
-		return static_cast<Plugin::Interface::H264Interface*>(data)->get_extra_data(extra_data, size);
-	} catch (...) {
-		AMF_LOG_ERROR("Unable to get extra data, see log for more information.");
-		return false;
-	}
-}
-
-//////////////////////////////////////////////////////////////////////////
-// Module Code
-//////////////////////////////////////////////////////////////////////////
-Plugin::Interface::H264Interface::H264Interface(obs_data_t* data, obs_encoder_t* encoder) {
-	AMF_LOG_DEBUG("<AMFEncoder::H264Interface::H264Interface> Initializing...");
-
-	// OBS Settings
-	uint32_t m_cfgWidth = obs_encoder_get_width(encoder);
-	uint32_t m_cfgHeight = obs_encoder_get_height(encoder);
-	video_t *video = obs_encoder_video(encoder);
-	const struct video_output_info *voi = video_output_get_info(video);
-	uint32_t m_cfgFPSnum = voi->fps_num;
-	uint32_t m_cfgFPSden = voi->fps_den;
-
-	//////////////////////////////////////////////////////////////////////////
-	/// Initialize Encoder
-	bool debug = obs_data_get_bool(data, AMF_H264_DEBUG);
-	Plugin::AMD::AMF::GetInstance()->EnableDebugTrace(debug);
-	VCESurfaceFormat surfFormat = (VCESurfaceFormat)obs_data_get_int(data, AMF_H264_SURFACEFORMAT);
-	if (surfFormat == -1) {
-		switch (voi->format) {
-			case VIDEO_FORMAT_NV12:
-				surfFormat = VCESurfaceFormat_NV12;
-				break;
-			case VIDEO_FORMAT_I420:
-				surfFormat = VCESurfaceFormat_I420;
-				break;
-			case VIDEO_FORMAT_RGBA:
-				surfFormat = VCESurfaceFormat_RGBA;
-				break;
-			case VIDEO_FORMAT_BGRA:
-				surfFormat = VCESurfaceFormat_BGRA;
-				break;
-			case VIDEO_FORMAT_Y800:
-				surfFormat = VCESurfaceFormat_GRAY;
-				break;
-			default:
-				surfFormat = VCESurfaceFormat_NV12;
-				break;
-		}
-	}
-	m_VideoEncoder = new VCEEncoder(VCEEncoderType_AVC, surfFormat,
-		(VCEMemoryType)obs_data_get_int(data, AMF_H264_MEMORYTYPE),
-		!!obs_data_get_int(data, AMF_H264_USE_OPENCL),
-		std::string(obs_data_get_string(data, AMF_H264_DEVICE)));
-
-	/// Static Properties
-	m_VideoEncoder->SetUsage((VCEUsage)obs_data_get_int(data, AMF_H264_USAGE));
-	m_VideoEncoder->SetProfile((VCEProfile)obs_data_get_int(data, AMF_H264_PROFILE));
-	m_VideoEncoder->SetProfileLevel((VCEProfileLevel)obs_data_get_int(data, AMF_H264_PROFILELEVEL));
-	m_VideoEncoder->SetMaximumLongTermReferenceFrames((uint32_t)obs_data_get_int(data, AMF_H264_MAXIMUMLTRFRAMES));
-
-	/// Framesize & Framerate
-	m_VideoEncoder->SetFrameSize(m_cfgWidth, m_cfgHeight);
-	m_VideoEncoder->SetFrameRate(m_cfgFPSnum, m_cfgFPSden);
-
-	/// Miscellaneous Properties
-	m_VideoEncoder->SetScanType((VCEScanType)obs_data_get_int(data, AMF_H264_SCANTYPE));
-	m_VideoEncoder->SetQualityPreset((VCEQualityPreset)obs_data_get_int(data, AMF_H264_QUALITY_PRESET));
-	m_VideoEncoder->SetCABACEnabled(!!obs_data_get_int(data, AMF_H264_CABAC));
-
-	// OBS - Enforce Streaming Service Restrictions
-	#pragma region OBS - Enforce Streaming Service Restrictions
-	{
-		// Profile
-		const char* p_str = obs_data_get_string(data, "profile");
-		if (strcmp(p_str, "") != 0) {
-			if (strcmp(p_str, "baseline")) {
-				m_VideoEncoder->SetProfile(VCEProfile_Baseline);
-			} else if (strcmp(p_str, "main")) {
-				m_VideoEncoder->SetProfile(VCEProfile_Main);
-			} else if (strcmp(p_str, "high")) {
-				m_VideoEncoder->SetProfile(VCEProfile_High);
-			}
-		} else {
-			switch (m_VideoEncoder->GetProfile()) {
-				case VCEProfile_Baseline:
-					obs_data_set_string(data, "profile", "baseline");
-					break;
-				case VCEProfile_Main:
-					obs_data_set_string(data, "profile", "main");
-					break;
-				case VCEProfile_High:
-					obs_data_set_string(data, "profile", "high");
-					break;
-			}
-		}
-
-		// Preset
-		const char* preset = obs_data_get_string(data, "preset");
-		if (strcmp(preset, "") != 0) {
-			if (strcmp(preset, "speed") == 0) {
-				m_VideoEncoder->SetQualityPreset(VCEQualityPreset_Speed);
-			} else if (strcmp(preset, "balanced") == 0) {
-				m_VideoEncoder->SetQualityPreset(VCEQualityPreset_Balanced);
-			} else if (strcmp(preset, "quality") == 0) {
-				m_VideoEncoder->SetQualityPreset(VCEQualityPreset_Quality);
-			}
-			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, m_VideoEncoder->GetQualityPreset());
-		} else {
-			switch (m_VideoEncoder->GetQualityPreset()) {
-				case VCEQualityPreset_Speed:
-					obs_data_set_string(data, "preset", "speed");
-					break;
-				case VCEQualityPreset_Balanced:
-					obs_data_set_string(data, "preset", "balanced");
-					break;
-				case VCEQualityPreset_Quality:
-					obs_data_set_string(data, "preset", "quality");
-					break;
-			}
-		}
-	}
-	#pragma endregion OBS - Enforce Streaming Service Restrictions
-	
-	// Initialize (locks static properties)
-	try {
-		m_VideoEncoder->Start();
-	} catch (...) {
-		throw;
-	}
-
-	// Dynamic Properties (Can be changed during Encoding)
-	this->update(data);
-
-	AMF_LOG_DEBUG("<AMFEncoder::H264Interface::H264Interface> Complete.");
-}
-
-Plugin::Interface::H264Interface::~H264Interface() {
-	AMF_LOG_DEBUG("<AMFEncoder::H264Interface::~H264Interface> Finalizing...");
-	m_VideoEncoder->Stop();
-	delete m_VideoEncoder;
-	AMF_LOG_DEBUG("<AMFEncoder::H264Interface::~H264Interface> Complete.");
-}
-
-bool Plugin::Interface::H264Interface::update(obs_data_t* data) {
-	double_t framerate = (double_t)m_VideoEncoder->GetFrameRate().first / (double_t)m_VideoEncoder->GetFrameRate().second;
-	int32_t bitrateMultiplier = obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000;
-
-	// Rate Control Properties
-	switch ((VCERateControlMethod)obs_data_get_int(data, AMF_H264_RATECONTROLMETHOD)) {
-		case VCERateControlMethod_ConstantBitrate:
-			m_VideoEncoder->SetTargetBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * bitrateMultiplier);
-			m_VideoEncoder->SetPeakBitrate(m_VideoEncoder->GetTargetBitrate());
-			m_VideoEncoder->SetFillerDataEnabled(obs_data_get_int(data, AMF_H264_FILLERDATA) == 1);
-			break;
-		case VCERateControlMethod_VariableBitrate_PeakConstrained:
-			m_VideoEncoder->SetTargetBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * bitrateMultiplier);
-			m_VideoEncoder->SetPeakBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_PEAK) * bitrateMultiplier);
-			m_VideoEncoder->SetFillerDataEnabled(false);
-			break;
-		case VCERateControlMethod_VariableBitrate_LatencyConstrained:
-			m_VideoEncoder->SetTargetBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * bitrateMultiplier);
-			m_VideoEncoder->SetPeakBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_PEAK) * bitrateMultiplier);
-			m_VideoEncoder->SetFillerDataEnabled(false);
-			break;
-		case VCERateControlMethod_ConstantQP:
-			m_VideoEncoder->SetIFrameQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_IFRAME));
-			m_VideoEncoder->SetPFrameQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_PFRAME));
-			try {
-				m_VideoEncoder->SetBFrameQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_BFRAME));
-			} catch (...) {}
-			m_VideoEncoder->SetTargetBitrate(0);
-			m_VideoEncoder->SetPeakBitrate(0);
-			m_VideoEncoder->SetFillerDataEnabled(false);
-			break;
-	}
-	m_VideoEncoder->SetRateControlMethod((VCERateControlMethod)obs_data_get_int(data, AMF_H264_RATECONTROLMETHOD));
-	m_VideoEncoder->SetMinimumQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_MINIMUM));
-	m_VideoEncoder->SetMaximumQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_MAXIMUM));
-	if (obs_data_get_int(data, AMF_H264_VBVBUFFER) == 0) {
-		m_VideoEncoder->SetVBVBufferAutomatic(obs_data_get_double(data, AMF_H264_VBVBUFFER_STRICTNESS) / 100.0);
-	} else {
-		m_VideoEncoder->SetVBVBufferSize((uint32_t)obs_data_get_int(data, AMF_H264_VBVBUFFER_SIZE) * bitrateMultiplier);
-	}
-	m_VideoEncoder->SetInitialVBVBufferFullness(obs_data_get_double(data, AMF_H264_VBVBUFFER_FULLNESS) / 100.0);
-	m_VideoEncoder->SetFrameSkippingEnabled(obs_data_get_int(data, AMF_H264_FRAMESKIPPING) == 1);
-	m_VideoEncoder->SetEnforceHRDRestrictionsEnabled(obs_data_get_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY) == 1);
-	if (obs_data_get_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE) != 0)
-		m_VideoEncoder->SetMaximumAccessUnitSize((uint32_t)obs_data_get_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE));
-
-	// Picture Control Properties
-	if (obs_data_get_int(data, AMF_H264_VIEW) == ViewMode::Master)
-		m_VideoEncoder->SetIDRPeriod((uint32_t)obs_data_get_int(data, AMF_H264_IDR_PERIOD));
-	else
-		m_VideoEncoder->SetIDRPeriod(max((uint32_t)(obs_data_get_double(data, AMF_H264_KEYFRAME_INTERVAL) * framerate), 1));
-	if (obs_data_get_int(data, AMF_H264_HEADER_INSERTION_SPACING) != 0)
-		m_VideoEncoder->SetHeaderInsertionSpacing((uint32_t)obs_data_get_int(data, AMF_H264_HEADER_INSERTION_SPACING));
-	m_VideoEncoder->SetDeblockingFilterEnabled(!!obs_data_get_int(data, AMF_H264_DEBLOCKINGFILTER));
-	if (VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->supportsBFrames) {
-		try {
-			m_VideoEncoder->SetBPicturePattern((VCEBPicturePattern)obs_data_get_int(data, AMF_H264_BPICTURE_PATTERN));
-			m_VideoEncoder->SetBPictureReferenceEnabled(!!obs_data_get_int(data, AMF_H264_BPICTURE_REFERENCE));
-		} catch (...) {}
-		try {
-			if (m_VideoEncoder->GetBPicturePattern() != VCEBPicturePattern_None) {
-				m_VideoEncoder->SetBPictureDeltaQP((int8_t)obs_data_get_int(data, AMF_H264_QP_BPICTURE_DELTA));
-				m_VideoEncoder->SetReferenceBPictureDeltaQP((int8_t)obs_data_get_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA));
-			}
-		} catch (...) {}
-	}
-
-	// Miscellaneous Properties
-	m_VideoEncoder->SetHalfPixelMotionEstimationEnabled(!!(obs_data_get_int(data, AMF_H264_MOTIONESTIMATION) & 1));
-	m_VideoEncoder->SetQuarterPixelMotionEstimationEnabled(!!(obs_data_get_int(data, AMF_H264_MOTIONESTIMATION) & 2));
-
-	// OBS - Enforce Streaming Service Stuff
-	{
-		// Rate Control Method
-		const char* t_str = obs_data_get_string(data, "rate_control");
-		if (strcmp(t_str, "") != 0) {
-			if (strcmp(t_str, "CBR") == 0) {
-				m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_ConstantBitrate);
-				m_VideoEncoder->SetFillerDataEnabled(true);
-			} else if (strcmp(t_str, "VBR") == 0) {
-				m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_VariableBitrate_PeakConstrained);
-			} else if (strcmp(t_str, "VBR_LAT") == 0) {
-				m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_VariableBitrate_LatencyConstrained);
-			} else if (strcmp(t_str, "CQP") == 0) {
-				m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_ConstantQP);
-			}
-
-			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, m_VideoEncoder->GetRateControlMethod());
-		} else {
-			switch (m_VideoEncoder->GetRateControlMethod()) {
-				case VCERateControlMethod_ConstantBitrate:
-					obs_data_set_string(data, "rate_control", "CBR");
-					break;
-				case VCERateControlMethod_VariableBitrate_PeakConstrained:
-					obs_data_set_string(data, "rate_control", "VBR");
-					break;
-				case VCERateControlMethod_VariableBitrate_LatencyConstrained:
-					obs_data_set_string(data, "rate_control", "VBR_LAT");
-					break;
-				case VCERateControlMethod_ConstantQP:
-					obs_data_set_string(data, "rate_control", "CQP");
-					break;
-			}
-		}
-
-		// Bitrate
-		uint64_t bitrateOvr = obs_data_get_int(data, "bitrate") * 1000;
-		if (bitrateOvr != -1) {
-			if (m_VideoEncoder->GetTargetBitrate() > bitrateOvr)
-				m_VideoEncoder->SetTargetBitrate((uint32_t)bitrateOvr);
-
-			if (m_VideoEncoder->GetPeakBitrate() > bitrateOvr)
-				m_VideoEncoder->SetPeakBitrate((uint32_t)bitrateOvr);
-
-			obs_data_set_int(data, "bitrate", m_VideoEncoder->GetTargetBitrate() / 1000);
-
-			obs_data_set_int(data, AMF_H264_BITRATE_TARGET, m_VideoEncoder->GetTargetBitrate() / bitrateMultiplier);
-			obs_data_set_int(data, AMF_H264_BITRATE_PEAK, m_VideoEncoder->GetPeakBitrate() / bitrateMultiplier);
-		} else {
-			obs_data_set_int(data, "bitrate", m_VideoEncoder->GetTargetBitrate() / 1000);
-		}
-
-		// IDR-Period (Keyframes)
-		uint32_t fpsNum = m_VideoEncoder->GetFrameRate().first;
-		uint32_t fpsDen = m_VideoEncoder->GetFrameRate().second;
-		if (obs_data_get_int(data, "keyint_sec") != -1) {
-			m_VideoEncoder->SetIDRPeriod((uint32_t)(obs_data_get_int(data, "keyint_sec") * ((double_t)fpsNum / (double_t)fpsDen)));
-
-			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, (double_t)obs_data_get_int(data, "keyint_sec"));
-			obs_data_set_int(data, AMF_H264_IDR_PERIOD, (uint32_t)(obs_data_get_int(data, "keyint_sec") * ((double_t)fpsNum / (double_t)fpsDen)));
-		} else {
-			obs_data_set_int(data, "keyint_sec", (uint64_t)(m_VideoEncoder->GetIDRPeriod() / ((double_t)fpsNum / (double_t)fpsDen)));
-		}
-	}
-
-	// Verify
-	m_VideoEncoder->LogProperties();
-	if (obs_data_get_int(data, AMF_H264_VIEW) >= ViewMode::Master)
-		AMF_LOG_ERROR("View Mode 'Master' is active, avoid giving anything but basic support. Error is most likely caused by user settings themselves.");
-
-	return true;
-}
-
-bool Plugin::Interface::H264Interface::encode(struct encoder_frame * frame, struct encoder_packet * packet, bool * received_packet) {
-	if (!frame || !packet || !received_packet)
-		return false;
-
-	bool retVal = true;
-
-	retVal = m_VideoEncoder->SendInput(frame);
-	m_VideoEncoder->GetOutput(packet, received_packet);
-
-	return retVal;
-}
-
-void Plugin::Interface::H264Interface::get_video_info(struct video_scale_info* info) {
-	m_VideoEncoder->GetVideoInfo(info);
-}
-
-bool Plugin::Interface::H264Interface::get_extra_data(uint8_t** extra_data, size_t* size) {
-	return m_VideoEncoder->GetExtraData(extra_data, size);
-}

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/misc-util.cpp Deleted

@@ -1,85 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-
-// Plugin
-#include "plugin.h"
-#include "amd-amf.h"
-#include "amd-amf-vce.h"
-#include "amd-amf-vce-capabilities.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-using namespace Plugin::AMD;
-
-namespace Plugin {
-	namespace Utility {
-		VCEProfileLevel inline GetMinimumProfileLevel(std::pair<uint32_t, uint32_t> frameSize, std::pair<uint32_t, uint32_t> frameRate) {
-			typedef std::pair<uint32_t, uint32_t> levelRestriction;
-			typedef std::pair<VCEProfileLevel, levelRestriction> level;
-
-			static const level profileLevelLimit[] = { // [Level, [Samples, Samples_Per_Sec]]
-				level(VCEProfileLevel_10, levelRestriction(25344, 380160)),
-				level(VCEProfileLevel_11, levelRestriction(101376, 768000)),
-				level(VCEProfileLevel_12, levelRestriction(101376, 1536000)),
-				level(VCEProfileLevel_13, levelRestriction(101376, 3041280)),
-				level(VCEProfileLevel_20, levelRestriction(101376, 3041280)),
-				level(VCEProfileLevel_21, levelRestriction(202752, 5068800)),
-				level(VCEProfileLevel_22, levelRestriction(414720, 5184000)),
-				level(VCEProfileLevel_30, levelRestriction(414720, 10368000)),
-				level(VCEProfileLevel_31, levelRestriction(921600, 27648000)),
-				level(VCEProfileLevel_32, levelRestriction(1310720, 55296000)),
-				//level(VCEProfileLevel_40, levelRestriction(2097152, 62914560)), // Technically identical to 4.1, but backwards compatible.
-				level(VCEProfileLevel_41, levelRestriction(2097152, 62914560)),
-				level(VCEProfileLevel_42, levelRestriction(2228224, 133693440)),
-				level(VCEProfileLevel_50, levelRestriction(5652480, 150994944)),
-				level(VCEProfileLevel_51, levelRestriction(9437184, 251658240)),
-				level(VCEProfileLevel_52, levelRestriction(9437184, 530841600)),
-				level((VCEProfileLevel)-1, levelRestriction(0, 0))
-			};
-
-			uint32_t samples = frameSize.first * frameSize.second;
-			uint32_t samples_sec = (uint32_t)ceil((double_t)samples * ((double_t)frameRate.first / (double_t)frameRate.second));
-
-			level curLevel = profileLevelLimit[0];
-			for (uint32_t index = 0; curLevel.first != -1; index++) {
-				curLevel = profileLevelLimit[index];
-
-				if (samples > curLevel.second.first)
-					continue;
-
-				if (samples_sec > curLevel.second.second)
-					continue;
-
-				return curLevel.first;
-			}
-			return VCEProfileLevel_52;
-		}
-	}
-}
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/Source/plugin.cpp Deleted

@@ -1,137 +0,0 @@
-/*
-MIT License
-
-Copyright (c) 2016 Michael Fabian Dirks
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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.
-*/
-
-#pragma once
-//////////////////////////////////////////////////////////////////////////
-// Includes
-//////////////////////////////////////////////////////////////////////////
-#include <windows.h>
-
-// Plugin
-#include "plugin.h"
-#include "amd-amf.h"
-#include "amd-amf-vce-capabilities.h"
-#include "enc-h264.h"
-
-//////////////////////////////////////////////////////////////////////////
-// Code
-//////////////////////////////////////////////////////////////////////////
-BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) {
-	return TRUE;
-}
-
-OBS_DECLARE_MODULE();
-OBS_MODULE_AUTHOR("Michael Fabian Dirks");
-OBS_MODULE_USE_DEFAULT_LOCALE("enc-amf", "en-US");
-
-/**
-* Required: Called when the module is loaded. Use this function to load all
-* the sources/encoders/outputs/services for your module, or anything else that
-* may need loading.
-*
-* @return Return true to continue loading the module, otherwise
-* false to indicate failure and unload the module
-*/
-MODULE_EXPORT bool obs_module_load(void) {
-	try {
-		AMF_LOG_INFO("Version " PLUGIN_VERSION_TEXT);
-
-		// Load AMF Runtime
-		auto instance = Plugin::AMD::AMF::GetInstance();
-
-		// Report AMF Capabilities
-		Plugin::AMD::VCECapabilities::ReportCapabilities();
-
-		// Register Encoders
-		Plugin::Interface::H264Interface::encoder_register();
-	} catch (...) {
-	}
-	return true;
-}
-
-/** Optional: Called when the module is unloaded. */
-MODULE_EXPORT void obs_module_unload(void) {}
-
-/** Optional: Returns the full name of the module */
-MODULE_EXPORT const char* obs_module_name() {
-	return "AMD Media Framework Plugin";
-}
-
-/** Optional: Returns a description of the module */
-MODULE_EXPORT const char* obs_module_description() {
-	return "AMD Media Framework Plugin";
-}
-
-//////////////////////////////////////////////////////////////////////////
-// Threading Specific
-//////////////////////////////////////////////////////////////////////////
-
-#if (defined _WIN32) | (defined _WIN64) // Windows
-#include <windows.h>
-
-const DWORD MS_VC_EXCEPTION = 0x406D1388;
-
-#pragma pack(push,8)
-typedef struct tagTHREADNAME_INFO {
-	DWORD dwType; // Must be 0x1000.
-	LPCSTR szName; // Pointer to name (in user addr space).
-	DWORD dwThreadID; // Thread ID (-1=caller thread).
-	DWORD dwFlags; // Reserved for future use, must be zero.
-} THREADNAME_INFO;
-#pragma pack(pop)
-
-void SetThreadName(uint32_t dwThreadID, const char* threadName) {
-
-	// DWORD dwThreadID = ::GetThreadId( static_cast<HANDLE>( t.native_handle() ) );
-
-	THREADNAME_INFO info;
-	info.dwType = 0x1000;
-	info.szName = threadName;
-	info.dwThreadID = dwThreadID;
-	info.dwFlags = 0;
-
-	__try {
-		RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
-	} __except (EXCEPTION_EXECUTE_HANDLER) {}
-}
-void SetThreadName(const char* threadName) {
-	SetThreadName(GetCurrentThreadId(), threadName);
-}
-void SetThreadName(std::thread* thread, const char* threadName) {
-	DWORD threadId = ::GetThreadId(static_cast<HANDLE>(thread->native_handle()));
-	SetThreadName(threadId, threadName);
-}
-
-#else // Linux, Mac
-#include <sys/prctl.h>
-
-void SetThreadName(std::thread* thread, const char* threadName) {
-	auto handle = thread->native_handle();
-	pthread_setname_np(handle, threadName);
-}
-void SetThreadName(const char* threadName) {
-	prctl(PR_SET_NAME, threadName, 0, 0, 0);
-}
-
-#endif
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/enc-amf.vcxproj Deleted

@@ -1,209 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup Label="ProjectConfigurations">
- <ProjectConfiguration Include="Debug|Win32">
- <Configuration>Debug</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Debug|x64">
- <Configuration>Debug</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|Win32">
- <Configuration>Release</Configuration>
- <Platform>Win32</Platform>
- </ProjectConfiguration>
- <ProjectConfiguration Include="Release|x64">
- <Configuration>Release</Configuration>
- <Platform>x64</Platform>
- </ProjectConfiguration>
- </ItemGroup>
- <PropertyGroup Label="Globals">
- <ProjectGuid>{49237B5E-655D-46B5-AA1F-780B387327A1}</ProjectGuid>
- <RootNamespace>winamf</RootNamespace>
- <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
- <ProjectName>enc-amf</ProjectName>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <UseDebugLibraries>true</UseDebugLibraries>
- <PlatformToolset>v140</PlatformToolset>
- <CharacterSet>MultiByte</CharacterSet>
- </PropertyGroup>
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <UseDebugLibraries>true</UseDebugLibraries>
- <PlatformToolset>v140</PlatformToolset>
- <CharacterSet>MultiByte</CharacterSet>
- </PropertyGroup>
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <UseDebugLibraries>false</UseDebugLibraries>
- <PlatformToolset>v140</PlatformToolset>
- <CharacterSet>MultiByte</CharacterSet>
- <WholeProgramOptimization>true</WholeProgramOptimization>
- </PropertyGroup>
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
- <ConfigurationType>DynamicLibrary</ConfigurationType>
- <UseDebugLibraries>false</UseDebugLibraries>
- <PlatformToolset>v140</PlatformToolset>
- <CharacterSet>MultiByte</CharacterSet>
- <WholeProgramOptimization>true</WholeProgramOptimization>
- </PropertyGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
- <ImportGroup Label="ExtensionSettings">
- </ImportGroup>
- <ImportGroup Label="Shared">
- </ImportGroup>
- <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- </ImportGroup>
- <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- </ImportGroup>
- <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- </ImportGroup>
- <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
- <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
- </ImportGroup>
- <PropertyGroup Label="UserMacros" />
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
- <IncludePath>$(SolutionDir)#ThirdParty\AMD-AMF-SDK\amf\public\include;$(SolutionDir)#ThirdParty\OBS-Studio;$(SolutionDir)#ThirdParty;$(ProjectDir)Include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath>
- <SourcePath>$(ProjectDir)Source;$(VC_SourcePath)</SourcePath>
- <OutDir>$(ProjectDir)#Build\$(Configuration)\obs-plugins\$(PlatformArchitecture)bit\</OutDir>
- <IntDir>$(ProjectDir)#Intermediate\$(Configuration)\$(PlatformArchitecture)\</IntDir>
- <LibraryPath>$(SolutionDir)#ThirdParty\OBS-Studio\build$(PlatformArchitecture)\libobs\$(Configuration)\;$(LibraryPath)</LibraryPath>
- </PropertyGroup>
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
- <IncludePath>$(SolutionDir)#ThirdParty\AMD-AMF-SDK\amf\public\include;$(SolutionDir)#ThirdParty\OBS-Studio;$(SolutionDir)#ThirdParty;$(ProjectDir)Include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath>
- <SourcePath>$(ProjectDir)Source;$(VC_SourcePath)</SourcePath>
- <OutDir>$(ProjectDir)#Build\$(Configuration)\obs-plugins\$(PlatformArchitecture)bit\</OutDir>
- <IntDir>$(ProjectDir)#Intermediate\$(Configuration)\$(PlatformArchitecture)\</IntDir>
- <LibraryPath>$(SolutionDir)#ThirdParty\OBS-Studio\build$(PlatformArchitecture)\libobs\$(Configuration)\;$(LibraryPath)</LibraryPath>
- </PropertyGroup>
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
- <IncludePath>$(SolutionDir)#ThirdParty\AMD-AMF-SDK\amf\public\include;$(SolutionDir)#ThirdParty\OBS-Studio;$(SolutionDir)#ThirdParty;$(ProjectDir)Include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath>
- <SourcePath>$(ProjectDir)Source;$(VC_SourcePath)</SourcePath>
- <OutDir>$(ProjectDir)#Build\$(Configuration)\obs-plugins\$(PlatformArchitecture)bit\</OutDir>
- <IntDir>$(ProjectDir)#Intermediate\$(Configuration)\$(PlatformArchitecture)\</IntDir>
- <LibraryPath>$(SolutionDir)#ThirdParty\OBS-Studio\build$(PlatformArchitecture)\libobs\$(Configuration)\;$(LibraryPath)</LibraryPath>
- </PropertyGroup>
- <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
- <IncludePath>$(SolutionDir)#ThirdParty\AMD-AMF-SDK\amf\public\include;$(SolutionDir)#ThirdParty\OBS-Studio;$(SolutionDir)#ThirdParty;$(ProjectDir)Include;$(VC_IncludePath);$(WindowsSDK_IncludePath)</IncludePath>
- <SourcePath>$(ProjectDir)Source;$(VC_SourcePath)</SourcePath>
- <OutDir>$(ProjectDir)#Build\$(Configuration)\obs-plugins\$(PlatformArchitecture)bit\</OutDir>
- <IntDir>$(ProjectDir)#Intermediate\$(Configuration)\$(PlatformArchitecture)\</IntDir>
- <LibraryPath>$(SolutionDir)#ThirdParty\OBS-Studio\build$(PlatformArchitecture)\libobs\$(Configuration)\;$(LibraryPath)</LibraryPath>
- </PropertyGroup>
- <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
- <ClCompile>
- <WarningLevel>Level4</WarningLevel>
- <Optimization>Disabled</Optimization>
- <SDLCheck>true</SDLCheck>
- <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;DEBUG;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <EnableCOMDATFolding>false</EnableCOMDATFolding>
- <AdditionalDependencies>obs.lib;version.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;dxgi.lib;%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
- <ClCompile>
- <WarningLevel>Level4</WarningLevel>
- <Optimization>Disabled</Optimization>
- <SDLCheck>true</SDLCheck>
- <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;DEBUG;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- </ClCompile>
- <Link>
- <EnableCOMDATFolding>false</EnableCOMDATFolding>
- <AdditionalDependencies>obs.lib;version.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- </Link>
- </ItemDefinitionGroup>
- <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
- <ClCompile>
- <WarningLevel>Level4</WarningLevel>
- <IntrinsicFunctions>true</IntrinsicFunctions>
- <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
- <FloatingPointModel>Fast</FloatingPointModel>
- <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
- <FunctionLevelLinking>false</FunctionLevelLinking>
- <FloatingPointExceptions>false</FloatingPointExceptions>
- <StringPooling>true</StringPooling>
- <CreateHotpatchableImage>false</CreateHotpatchableImage>
- <MinimalRebuild>true</MinimalRebuild>
- <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
- <BufferSecurityCheck>false</BufferSecurityCheck>
- <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
- <OmitFramePointers>false</OmitFramePointers>
- </ClCompile>
- <Link>
- <EnableCOMDATFolding>true</EnableCOMDATFolding>
- <AdditionalDependencies>obs.lib;version.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;dxgi.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <ProfileGuidedDatabase>$(IntDir)$(TargetName).pgd</ProfileGuidedDatabase>
- <LinkTimeCodeGeneration>UseFastLinkTimeCodeGeneration</LinkTimeCodeGeneration>
- </Link>
- </ItemDefinitionGroup>
- <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
- <ClCompile>
- <WarningLevel>Level4</WarningLevel>
- <IntrinsicFunctions>true</IntrinsicFunctions>
- <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
- <FloatingPointModel>Fast</FloatingPointModel>
- <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_WINDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
- <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
- <FunctionLevelLinking>false</FunctionLevelLinking>
- <FloatingPointExceptions>false</FloatingPointExceptions>
- <StringPooling>true</StringPooling>
- <CreateHotpatchableImage>false</CreateHotpatchableImage>
- <MinimalRebuild>true</MinimalRebuild>
- <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
- <BufferSecurityCheck>false</BufferSecurityCheck>
- <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
- </ClCompile>
- <Link>
- <EnableCOMDATFolding>true</EnableCOMDATFolding>
- <AdditionalDependencies>obs.lib;version.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
- <LinkTimeCodeGeneration>UseFastLinkTimeCodeGeneration</LinkTimeCodeGeneration>
- </Link>
- </ItemDefinitionGroup>
- <ItemGroup>
- <ClInclude Include="Include\amd-amf-vce.h" />
- <ClInclude Include="Include\amd-amf.h" />
- <ClInclude Include="Include\amd-amf-vce-capabilities.h" />
- <ClInclude Include="Include\api-base.h" />
- <ClInclude Include="Include\api-d3d11.h" />
- <ClInclude Include="Include\api-d3d9.h" />
- <ClInclude Include="Include\enc-h264.h" />
- <ClInclude Include="Include\plugin.h" />
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="Source\amd-amf-vce.cpp" />
- <ClCompile Include="Source\amd-amf.cpp" />
- <ClCompile Include="Source\amd-amf-vce-capabilities.cpp" />
- <ClCompile Include="Source\api-base.cpp" />
- <ClCompile Include="Source\api-d3d11.cpp" />
- <ClCompile Include="Source\api-d3d9.cpp" />
- <ClCompile Include="Source\enc-h264.cpp" />
- <ClCompile Include="Source\misc-util.cpp" />
- <ClCompile Include="Source\plugin.cpp" />
- </ItemGroup>
- <ItemGroup>
- <None Include="Resources\locale\en-US.ini" />
- </ItemGroup>
- <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
- <ImportGroup Label="ExtensionTargets">
- </ImportGroup>
- <Target Name="CopyBinaries" AfterTargets="Build">
- <ItemGroup>
- <Resources Include="$(ProjectDir)\Resources\**\*.*" />
- <Binaries Include="$(ProjectDir)#Build\$(Configuration)\obs-plugins\$(PlatformArchitecture)bit\*.dll" />
- <Binaries Include="$(ProjectDir)#Build\$(Configuration)\obs-plugins\$(PlatformArchitecture)bit\*.pdb" />
- </ItemGroup>
- <Copy SourceFiles="@(Resources)" DestinationFiles="@(Resources->'$(ProjectDir)#Build\$(Configuration)\data\obs-plugins\$(ProjectName)\%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="False" UseHardlinksIfPossible="False" />
- <Copy SourceFiles="@(Resources)" DestinationFiles="@(Resources->'$(SolutionDir)\#Resources\Package\data\obs-plugins\$(ProjectName)\%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="False" UseHardlinksIfPossible="False" />
- <Copy SourceFiles="@(Binaries)" DestinationFiles="@(Binaries->'$(SolutionDir)\#Resources\Package\obs-plugins\$(PlatformArchitecture)bit\%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="False" UseHardlinksIfPossible="False" />
- </Target>
-</Project>
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/enc-amf/enc-amf/enc-amf.vcxproj.filters Deleted

@@ -1,80 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <ItemGroup>
- <Filter Include="Source Files">
- <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
- <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
- </Filter>
- <Filter Include="Header Files">
- <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
- <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
- </Filter>
- <Filter Include="Resource Files">
- <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
- <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
- </Filter>
- <Filter Include="Resource Files\locale">
- <UniqueIdentifier>{da92c87c-c5fd-4c93-a09c-af3071784a7c}</UniqueIdentifier>
- </Filter>
- </ItemGroup>
- <ItemGroup>
- <ClInclude Include="Include\enc-h264.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\amd-amf.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\plugin.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\amd-amf-vce.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\amd-amf-vce-capabilities.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\api-d3d11.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\api-base.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- <ClInclude Include="Include\api-d3d9.h">
- <Filter>Header Files</Filter>
- </ClInclude>
- </ItemGroup>
- <ItemGroup>
- <ClCompile Include="Source\enc-h264.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\amd-amf.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\plugin.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\amd-amf-vce-capabilities.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\amd-amf-vce.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\misc-util.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\api-d3d11.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\api-base.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- <ClCompile Include="Source\api-d3d9.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
- </ItemGroup>
- <ItemGroup>
- <None Include="Resources\locale\en-US.ini">
- <Filter>Resource Files\locale</Filter>
- </None>
- </ItemGroup>
-</Project>
\ No newline at end of file

obs-studio-0.16.5.tar.xz/UI/data/locale/cs-CZ.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/cs-CZ.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/da-DK.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/da-DK.ini Changed

@@ -52,6 +52,7 @@
 Hours="Timer"
 Minutes="Minutter"
 Seconds="Sekunder"
+Deprecated="Ophørt"
 
 QuickTransitions.SwapScenes="Byt om på forhåndsvisning/output scener efter overgang"
 QuickTransitions.SwapScenesTT="Ombytter uddrag- og output-scener efter omskiftning (hvis oprindelige output-scene stadig eksisterer).\nDette vil ikke omgøre eventuelle ændringer, der måtte været udført på den oprindelige output-scene."
@@ -159,8 +160,13 @@
 Deinterlacing.Discard="Kassér"
 Deinterlacing.Retro="Retro"
 Deinterlacing.Blend="Bland"
+Deinterlacing.Blend2x="Blend 2x"
 Deinterlacing.Linear="Lineær"
 Deinterlacing.Linear2x="Lineær 2x"
+Deinterlacing.Yadif="Yadif"
+Deinterlacing.Yadif2x="Yadif 2x"
+Deinterlacing.TopFieldFirst="Øverste felt først"
+Deinterlacing.BottomFieldFirst="Nederste felt først"
 
 Basic.Main.AddSceneDlg.Title="Tilføje scene"
 Basic.Main.AddSceneDlg.Text="Angiv navnet på scene"
@@ -280,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="Fortryd $1 (&U)"
 Basic.MainMenu.Edit.RedoAction="&Redo $1"
 Basic.MainMenu.Edit.LockPreview="&Lås forhåndsvisning"
+Basic.MainMenu.Edit.Scale="Forhåndsvisning & Skalering"
+Basic.MainMenu.Edit.Scale.Window="Skalér til vindue"
+Basic.MainMenu.Edit.Scale.Canvas="Lærred (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Output (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Transformering"
 Basic.MainMenu.Edit.Transform.EditTransform="Rediger transformering... (&E)"
 Basic.MainMenu.Edit.Transform.ResetTransform="Nulstille transformering (&R)"
@@ -358,16 +368,27 @@
 Basic.Settings.Output.Simple.RecordingQuality.Small="Høj kvalitet, medium filstørrelse"
 Basic.Settings.Output.Simple.RecordingQuality.HQ="Samme kvalitet, stor filstørrelse"
 Basic.Settings.Output.Simple.RecordingQuality.Lossless="Tabsfri kvalitet, utrolig stor filstørrelse"
+Basic.Settings.Output.Simple.Warn.VideoBitrate="Advarsel: Video-streaming bitraten sættes til %1, som er den øvre grænse for den aktuelle streaming-tjeneste.  Er du sikker på, at du vil at gå over %1, så aktivér venligst avancerede valg for encoder og afmarkér \"Gennemtving streaming-tjenestes bitratebegrænsninger\"."
+Basic.Settings.Output.Simple.Warn.AudioBitrate="Advarsel: Audio-streaming bitraten sættes til %1, som er den øvre grænse for den aktuelle streaming-tjeneste.  Er du sikker på, at du vil at gå over %1, så aktivér venligst avancerede valg for encoder og afmarkér \"Gennemtving streaming-tjenestes bitratebegrænsninger\"."
+Basic.Settings.Output.Simple.Warn.Encoder="Advarsel: Optagelse med en software-encoder i en anden kvalitet end det streamede vil medføre ekstra CPU-forbrug, hvis du streamer og optager samtidigt."
+Basic.Settings.Output.Simple.Warn.Lossless="Advarsel: Tabsfri kvalitet genererer gevaldigt store filstørrelser!  Tabsfri kvalitet kan bruge op til 7 GB diskplads pr. minut ved høje opløsninger og billedhastigheder.  Tabsfri tilstand anbefales ikke til lange optagelser, medmindre du har en meget stor mængde tilgængelig diskplads."
+Basic.Settings.Output.Simple.Warn.Lossless.Msg="Sikker på, at du vil benytte tabsfri kvalitet?"
+Basic.Settings.Output.Simple.Warn.Lossless.Title="Tabsfri kvalitet-advarsel!"
+Basic.Settings.Output.Simple.Warn.MultipleQSV="Advarsel: Du kan ikke benytte flere særskilte QSV-encoders ved streaming og optagelse på samme tid.  Ønsker du at streame og optage samtidig, bedes du ændre enten optagelses- eller stream-encoder."
 Basic.Settings.Output.Simple.Encoder.Software="Software (x264)"
 Basic.Settings.Output.Simple.Encoder.Hardware.QSV="Hardware (QSV)"
 Basic.Settings.Output.Simple.Encoder.Hardware.AMD="Hardware (AMD)"
 Basic.Settings.Output.Simple.Encoder.Hardware.NVENC="Hardware (NVENC)"
+Basic.Settings.Output.Simple.Encoder.SoftwareLowCPU="Software (x264 lav, forudindstillet CPU-forbrug, øger filstørrelsen)"
 Basic.Settings.Output.VideoBitrate="Video Bitrate"
 Basic.Settings.Output.AudioBitrate="Audio Bitrate"
 Basic.Settings.Output.Reconnect="Automatisk Reconnect"
 Basic.Settings.Output.RetryDelay="Retry forsinkelse (sekunder)"
 Basic.Settings.Output.MaxRetries="Maksimum forsøg"
 Basic.Settings.Output.Advanced="Aktiver avancerede Encoder indstillinger"
+Basic.Settings.Output.EncoderPreset="Encoder forudindstilling (hurtigere= mindre CPU-kraft)"
+Basic.Settings.Output.CustomEncoderSettings="Tilpasset Encoder-indstillinger"
+Basic.Settings.Output.CustomMuxerSettings="Tilpasset Muxer-indstillinger"
 Basic.Settings.Output.NoSpaceFileName="Opret filnavne uden mellemrum"
 
 Basic.Settings.Output.Adv.Rescale="Om-skalere output"
@@ -389,12 +410,15 @@
 Basic.Settings.Output.Adv.FFmpeg.Type="FFmpeg outputtype"
 Basic.Settings.Output.Adv.FFmpeg.Type.URL="Output til URL"
 Basic.Settings.Output.Adv.FFmpeg.Type.RecordToFile="Output til fil"
+Basic.Settings.Output.Adv.FFmpeg.SaveFilter.Common="Almindelige optagelsesformater"
 Basic.Settings.Output.Adv.FFmpeg.SaveFilter.All="Alle filer"
 Basic.Settings.Output.Adv.FFmpeg.SavePathURL="Filsti eller URL"
 Basic.Settings.Output.Adv.FFmpeg.Format="Containerformat"
 Basic.Settings.Output.Adv.FFmpeg.FormatAudio="Lyd"
 Basic.Settings.Output.Adv.FFmpeg.FormatVideo="Video"
 Basic.Settings.Output.Adv.FFmpeg.FormatDefault="Standard format"
+Basic.Settings.Output.Adv.FFmpeg.FormatDesc="Container-format beskrivelse"
+Basic.Settings.Output.Adv.FFmpeg.FormatDescDef="Lyd/Video-codec gættet fra filsti eller URL"
 Basic.Settings.Output.Adv.FFmpeg.AVEncoderDefault="Standard encoder"
 Basic.Settings.Output.Adv.FFmpeg.AVEncoderDisable="Deaktiver encoder"
 Basic.Settings.Output.Adv.FFmpeg.VEncoder="Video encoder"
@@ -437,7 +461,9 @@
 Basic.Settings.Audio.AuxDevice2="Mic/Auxiliary lydenhed 2"
 Basic.Settings.Audio.AuxDevice3="Mic/Auxiliary lydenhed 3"
 Basic.Settings.Audio.EnablePushToMute="Aktiver tryk-for-stilhed"
+Basic.Settings.Audio.PushToMuteDelay="Tryk for at gøre tavs-forsinkelse"
 Basic.Settings.Audio.EnablePushToTalk="Aktiver tryk-for-tale"
+Basic.Settings.Audio.PushToTalkDelay="Tryk for at gøre hørbar-forsinkelse"
 Basic.Settings.Audio.UnknownAudioDevice="[Enhed ikke tilsluttet eller ikke tilgængelig]"
 
 Basic.Settings.Advanced="Avanceret"
@@ -446,6 +472,8 @@
 Basic.Settings.Advanced.General.ProcessPriority.AboveNormal="Over normal"
 Basic.Settings.Advanced.General.ProcessPriority.Normal="Normal"
 Basic.Settings.Advanced.General.ProcessPriority.Idle="Ikke aktiv"
+Basic.Settings.Advanced.FormatWarning="Advarsel: Farveformater ud over NV12 er primært beregnet til optagelse, og de anbefales ikke under streaming. Streaming kan medføre øget CPU-forbrug grundet farveformatkonvertering."
+Basic.Settings.Advanced.Audio.BufferingTime="Lyd-bufferinterval"
 Basic.Settings.Advanced.Video.ColorFormat="Farveformat"
 Basic.Settings.Advanced.Video.ColorSpace="YUV farverum"
 Basic.Settings.Advanced.Video.ColorRange="YUV farveområde"
@@ -453,6 +481,7 @@
 Basic.Settings.Advanced.Video.ColorRange.Full="Fuld"
 Basic.Settings.Advanced.StreamDelay="Stream forsinkelse"
 Basic.Settings.Advanced.StreamDelay.Duration="Varighed (sekunder)"
+Basic.Settings.Advanced.StreamDelay.Preserve="Bevar afskæringspunkt (forøg forsinkelse) ved forbindelsesgendannelse"
 Basic.Settings.Advanced.StreamDelay.MemoryUsage="Anslået hukommelsesbrug: %1 MB"
 Basic.Settings.Advanced.Network="Netværk"
 Basic.Settings.Advanced.Network.BindToIP="Bind til IP"
@@ -460,10 +489,13 @@
 Basic.AdvAudio="Avancerede lydegenskaber"
 Basic.AdvAudio.Name="Navn"
 Basic.AdvAudio.Volume="Volumen (%)"
+Basic.AdvAudio.Mono="Nedmix til Mono"
 Basic.AdvAudio.Panning="Panorering"
+Basic.AdvAudio.SyncOffset="Synkr-forskydning (ms)"
 Basic.AdvAudio.AudioTracks="Spor"
 
 Basic.Settings.Hotkeys="Genvejstaster"
+Basic.Settings.Hotkeys.Pair="Tastekombinationer delt med '%1' fungerer som omskiftere"
 
 Basic.Hotkeys.StartStreaming="Start streaming"
 Basic.Hotkeys.StopStreaming="Stop streaming"
@@ -520,4 +552,6 @@
 SceneItemShow="Vis '%1'"
 SceneItemHide="Skjul '%1'"
 
+OutputWarnings.NoTracksSelected="Du skal vælge minimum ét spor"
+OutputWarnings.MultiTrackRecording="Advarsel: Visse formater (såsom FLV) understøtter ikke flere spor pr. optagelse"

obs-studio-0.16.5.tar.xz/UI/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/de-DE.ini Changed

@@ -41,7 +41,7 @@
 Enable="Aktivieren"
 DisableOSXVSync="OSX V-Sync deaktivieren"
 ResetOSXVSyncOnExit="OSX V-Sync beim Beenden zurücksetzen"
-HighResourceUsage="Kodierung überlastet! Erwägen Sie Ihre Video-Einstellungen zu verringern, oder benutzen Sie eine schnellere Encoder-Voreinstellung."
+HighResourceUsage="Codierung überlastet! Erwägen Sie Ihre Video-Einstellungen zu verringern, oder benutzen Sie eine schnellere Codierer-Voreinstellung."
 Transition="Übergang"
 QuickTransitions="Schnelle Übergänge"
 Left="Links"
@@ -52,6 +52,7 @@
 Hours="Stunde(n)"
 Minutes="Minute(n)"
 Seconds="Sekunde(n)"
+Deprecated="Veraltet"
 
 QuickTransitions.SwapScenes="Tausche Vorschau/Ausgabe-Szenen nach dem Übergang"
 QuickTransitions.SwapScenesTT="Vertauscht die Vorschau- und Ausgabe-Szenen nach dem Übergang (falls die ursprüngliche Ausgabe-Szene noch vorhanden ist).\nEventuelle Änderungen an der original Ausgabe-Szene werden hierbei nicht rückgängig gemacht."
@@ -285,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="$1 rückgängig machen (&U)"
 Basic.MainMenu.Edit.RedoAction="$1 Wiede&rherstellen"
 Basic.MainMenu.Edit.LockPreview="Vorschau sperren (&L)"
+Basic.MainMenu.Edit.Scale="Vorschau&skalierung"
+Basic.MainMenu.Edit.Scale.Window="An Fenstergröße anpassen"
+Basic.MainMenu.Edit.Scale.Canvas="Leinwand (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Ausgabe (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Transformieren"
 Basic.MainMenu.Edit.Transform.EditTransform="Transformation b&earbeiten..."
 Basic.MainMenu.Edit.Transform.ResetTransform="Transformation zu&rücksetzen"
@@ -349,7 +354,7 @@
 
 Basic.Settings.Output="Ausgabe"
 Basic.Settings.Output.Format="Aufnahmeformat"
-Basic.Settings.Output.Encoder="Encoder"
+Basic.Settings.Output.Encoder="Codierer"
 Basic.Settings.Output.SelectDirectory="Wählen Sie das Aufnahmeverzeichnis"
 Basic.Settings.Output.SelectFile="Wählen Sie die Aufnahmedatei"
 Basic.Settings.Output.EnforceBitrate="Erzwinge Bitratenlimit des Streamingdiensts"
@@ -363,13 +368,13 @@
 Basic.Settings.Output.Simple.RecordingQuality.Small="Hohe Qualität, mittelgroße Dateien"
 Basic.Settings.Output.Simple.RecordingQuality.HQ="Ununterscheidbare Qualität, große Dateien"
 Basic.Settings.Output.Simple.RecordingQuality.Lossless="Verlustfreie Qualität, enorm große Dateien"
-Basic.Settings.Output.Simple.Warn.VideoBitrate="Warnung: Die Videobitrate beim streamen wird auf %1 festlegt, was der Obergrenze des aktuellen Streamingdiensts entspricht.  Falls Sie sicher sind, dass Sie %1 überschreiten wollen, deaktivieren Sie \"Erzwinge Bitratenlimit des Streamingdiensts\" in den erweiterten Encodereinstellungen."
-Basic.Settings.Output.Simple.Warn.AudioBitrate="Warnung: Die Audiobitrate beim streamen wird auf %1 festlegt, was der Obergrenze des aktuellen Streamingdiensts entspricht.  Falls Sie sicher sind, dass Sie %1 überschreiten wollen, deaktivieren Sie \"Erzwinge Bitratenlimit des Streamingdiensts\" in den erweiterten Encodereinstellungen."
-Basic.Settings.Output.Simple.Warn.Encoder="Warnung: Mit einem Software-Encoder in einer anderen Qualität als der des Stream aufzunehmen wird zusätzliche CPU-Auslastung erzeugen, wenn Sie gleichzeitig streamen und aufzeichnen."
+Basic.Settings.Output.Simple.Warn.VideoBitrate="Warnung: Die Videobitrate beim streamen wird auf %1 festlegt, was der Obergrenze des aktuellen Streamingdiensts entspricht.  Falls Sie sicher sind, dass Sie %1 überschreiten wollen, deaktivieren Sie \"Erzwinge Bitratenlimit des Streamingdiensts\" in den erweiterten Codierereinstellungen."
+Basic.Settings.Output.Simple.Warn.AudioBitrate="Warnung: Die Audiobitrate beim streamen wird auf %1 festlegt, was der Obergrenze des aktuellen Streamingdiensts entspricht.  Falls Sie sicher sind, dass Sie %1 überschreiten wollen, deaktivieren Sie \"Erzwinge Bitratenlimit des Streamingdiensts\" in den erweiterten Codierereinstellungen."
+Basic.Settings.Output.Simple.Warn.Encoder="Warnung: Mit einem Software-Codierer in einer anderen Qualität als der des Stream aufzunehmen wird zusätzliche CPU-Auslastung erzeugen, wenn Sie gleichzeitig streamen und aufzeichnen."
 Basic.Settings.Output.Simple.Warn.Lossless="Warnung: Verlustfreie Qualität erzeugt enorm große Dateien!  Verlustfreie Qualität, kann mehr als 7 Gigabyte Speicherplatz pro Minute, bei hohen Auflösungen und Frameraten in Anspruch nehmen.  Verlustfrei ist für lange Aufnahmen nicht empfohlen, es sei denn, Sie haben eine sehr große Menge an Speicherplatz zur Verfügung."
 Basic.Settings.Output.Simple.Warn.Lossless.Msg="Sind Sie sicher, dass Sie verlustfreie Qualität verwenden möchten?"
 Basic.Settings.Output.Simple.Warn.Lossless.Title="Verlustfreie Qualität-Warnung!"
-Basic.Settings.Output.Simple.Warn.MultipleQSV="Achtung: Sie können nicht mehrere separate QSV-Encoder beim streamen und aufnehmen gleichzeitig verwenden.  Wenn Sie zur gleichen Zeit streamen und aufnehmen möchten, dann ändern Sie bitte entweder den Aufnahme-Encoder oder den Stream-Encoder."
+Basic.Settings.Output.Simple.Warn.MultipleQSV="Achtung: Sie können nicht mehrere separate QSV-Codierer beim streamen und aufnehmen gleichzeitig verwenden.  Wenn Sie zur gleichen Zeit streamen und aufnehmen möchten, dann ändern Sie bitte entweder den Aufnahmecodierer oder den Streamcodierer."
 Basic.Settings.Output.Simple.Encoder.Software="Software (x264)"
 Basic.Settings.Output.Simple.Encoder.Hardware.QSV="Hardware (QSV)"
 Basic.Settings.Output.Simple.Encoder.Hardware.AMD="Hardware (AMD)"
@@ -380,16 +385,16 @@
 Basic.Settings.Output.Reconnect="Automatisch wiederverbinden"
 Basic.Settings.Output.RetryDelay="Wiederverbindungsverzögerung (Sekunden)"
 Basic.Settings.Output.MaxRetries="Maximale Wiederholungsversuche"
-Basic.Settings.Output.Advanced="Erweiterte Encodereinstellungen aktivieren"
-Basic.Settings.Output.EncoderPreset="Encoder-Voreinstellung (höher = weniger CPU Auslastung)"
-Basic.Settings.Output.CustomEncoderSettings="Benutzerdefinierte Encoder-Einstellungen"
+Basic.Settings.Output.Advanced="Erweiterte Codierereinstellungen aktivieren"
+Basic.Settings.Output.EncoderPreset="Codierer-Voreinstellung (höher = weniger CPU Auslastung)"
+Basic.Settings.Output.CustomEncoderSettings="Benutzerdefinierte Codierer-Einstellungen"
 Basic.Settings.Output.CustomMuxerSettings="Benutzerdefinierte Muxereinstellungen"
 Basic.Settings.Output.NoSpaceFileName="Dateinamen ohne Leerzeichen generieren"
 
 Basic.Settings.Output.Adv.Rescale="Ausgabe umskalieren"
 Basic.Settings.Output.Adv.AudioTrack="Audiospur"
 Basic.Settings.Output.Adv.Streaming="Streamen"
-Basic.Settings.Output.Adv.ApplyServiceSettings="Erzwinge Streamingdienst-Encodereinstellungen"
+Basic.Settings.Output.Adv.ApplyServiceSettings="Erzwinge Streamingdienst-Codierereinstellungen"
 Basic.Settings.Output.Adv.Audio.Track1="Spur 1"
 Basic.Settings.Output.Adv.Audio.Track2="Spur 2"
 Basic.Settings.Output.Adv.Audio.Track3="Spur 3"
@@ -399,7 +404,7 @@
 Basic.Settings.Output.Adv.Recording.Type="Art"
 Basic.Settings.Output.Adv.Recording.Type.Standard="Normal"
 Basic.Settings.Output.Adv.Recording.Type.FFmpegOutput="Benutzerdefinierte Ausgabe (FFmpeg)"
-Basic.Settings.Output.Adv.Recording.UseStreamEncoder="(Benutze Streamencoder)"
+Basic.Settings.Output.Adv.Recording.UseStreamEncoder="(Benutze Streamcodierer)"
 Basic.Settings.Output.Adv.Recording.Filename="Dateinameformatierung"
 Basic.Settings.Output.Adv.Recording.OverwriteIfExists="Überschreiben, wenn die Datei vorhanden ist"
 Basic.Settings.Output.Adv.FFmpeg.Type="FFmpeg-Ausgabetyp"
@@ -414,12 +419,12 @@
 Basic.Settings.Output.Adv.FFmpeg.FormatDefault="Standardformat"
 Basic.Settings.Output.Adv.FFmpeg.FormatDesc="Container-Formatbeschreibung"
 Basic.Settings.Output.Adv.FFmpeg.FormatDescDef="Audio- / Videocodec wird aus Dateipfad oder URL erraten."
-Basic.Settings.Output.Adv.FFmpeg.AVEncoderDefault="Standard-Encoder"
-Basic.Settings.Output.Adv.FFmpeg.AVEncoderDisable="Encoder deaktivieren"
-Basic.Settings.Output.Adv.FFmpeg.VEncoder="Video-Encoder"
-Basic.Settings.Output.Adv.FFmpeg.VEncoderSettings="Video Encoder-Einstellungen (falls gewünscht)"
-Basic.Settings.Output.Adv.FFmpeg.AEncoder="Audio-Encoder"
-Basic.Settings.Output.Adv.FFmpeg.AEncoderSettings="Audio Encoder-Einstellungen (falls gewünscht)"
+Basic.Settings.Output.Adv.FFmpeg.AVEncoderDefault="Standard-Codierer"
+Basic.Settings.Output.Adv.FFmpeg.AVEncoderDisable="Codierer deaktivieren"
+Basic.Settings.Output.Adv.FFmpeg.VEncoder="Video-Codierer"
+Basic.Settings.Output.Adv.FFmpeg.VEncoderSettings="Video Codierer-Einstellungen (falls gewünscht)"
+Basic.Settings.Output.Adv.FFmpeg.AEncoder="Audio-Codierer"
+Basic.Settings.Output.Adv.FFmpeg.AEncoderSettings="Audio Codierer-Einstellungen (falls gewünscht)"
 Basic.Settings.Output.Adv.FFmpeg.MuxerSettings="Muxer Einstellungen (falls vorhanden)"
 
 FilenameFormatting.completer="%DD-%MM-%CCYY %hh-%mm-%ss\n%DD-%MM-%YY %hh-%mm-%ss\n%d-%m-%Y %H-%M-%S\n%d-%m-%y %H-%M-%S\n%a %d-%m-%Y %H-%M-%S\n%A %d-%m-%Y %H-%M-%S\n%d-%b-%Y %H-%M-%S\n%d-%B-%Y %H-%M-%S"

obs-studio-0.16.5.tar.xz/UI/data/locale/en-US.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/en-US.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/es-ES.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/es-ES.ini Changed

@@ -52,6 +52,7 @@
 Hours="Horas"
 Minutes="Minutos"
 Seconds="Segundos"
+Deprecated="Obsoleto"
 
 QuickTransitions.SwapScenes="Cambiar vista previa y salida escenas después de la transición"
 QuickTransitions.SwapScenesTT="Cambia la vista previa y salida escenas después de la transición (si todavía existe la escena original de la salida). \nEsto no deshará cualquier cambio que pueda haber hecho a la escena original de la salida."
@@ -285,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="&Deshacer $1"
 Basic.MainMenu.Edit.RedoAction="&Rehacer $1"
 Basic.MainMenu.Edit.LockPreview="&Bloquear vista previa"
+Basic.MainMenu.Edit.Scale="Vista previa y escala"
+Basic.MainMenu.Edit.Scale.Window="Ajustar a la ventana"
+Basic.MainMenu.Edit.Scale.Canvas="Lienzo (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Salida (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Transformar"
 Basic.MainMenu.Edit.Transform.EditTransform="&Editar Transformación..."
 Basic.MainMenu.Edit.Transform.ResetTransform="&Restablecer transformación"

obs-studio-0.16.5.tar.xz/UI/data/locale/eu-ES.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/eu-ES.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/fi-FI.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/fi-FI.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/fr-FR.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/fr-FR.ini Changed

@@ -27,7 +27,7 @@
 Browse="Parcourir"
 Mono="Mono"
 Stereo="Stéréo"
-DroppedFrames="Images Perdues %1 (%2%)"
+DroppedFrames="Images perdues : %1 (%2%)"
 PreviewProjector="Projecteur plein écran (aperçu)"
 SceneProjector="Projecteur plein écran (scène)"
 SourceProjector="Projecteur plein écran (source)"
@@ -52,6 +52,7 @@
 Hours="Heures"
 Minutes="Minutes"
 Seconds="Secondes"
+Deprecated="Obsolète"
 
 QuickTransitions.SwapScenes="Permuter les scènes d'aperçu et de sortie après la transition"
 QuickTransitions.SwapScenesTT="Permute les scènes d'aperçu et de sortie après la transition (si la scène d'origine de la sortie existe toujours). \nCela n'annulera pas les modifications qui auront pu être faites sur la scène d'origine de la sortie."
@@ -285,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="&Annuler $1"
 Basic.MainMenu.Edit.RedoAction="&Rétablir $1"
 Basic.MainMenu.Edit.LockPreview="Verrouiller la prévisualisation"
+Basic.MainMenu.Edit.Scale="Mi&se à l'échelle de l'aperçu"
+Basic.MainMenu.Edit.Scale.Window="Adapter à la fenêtre"
+Basic.MainMenu.Edit.Scale.Canvas="Canvas (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Sortie (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Transformer"
 Basic.MainMenu.Edit.Transform.EditTransform="Éditer la transformation..."
 Basic.MainMenu.Edit.Transform.ResetTransform="Réinitialiser la transformation"

obs-studio-0.16.5.tar.xz/UI/data/locale/hu-HU.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/hu-HU.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/it-IT.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/it-IT.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/ja-JP.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/ja-JP.ini Changed

@@ -52,6 +52,7 @@
 Hours="時間"
 Minutes="分"
 Seconds="秒"
+Deprecated="非推奨"
 
 QuickTransitions.SwapScenes="トランジション後にプレビュー/出力シーンを入れ替え"
 QuickTransitions.SwapScenesTT="(出力のオリジナルシーンがまだ存在する場合)、トランジション後のプレビューと出力シーンを入れ替えます。\nこれは出力のオリジナルシーンに加えられた可能性があるすべての変更を元に戻しません。"
@@ -263,9 +264,9 @@
 Basic.Main.StartRecording="録画開始"
 Basic.Main.StartStreaming="配信開始"
 Basic.Main.StopRecording="録画終了"
-Basic.Main.StoppingRecording="録画を停止しています..."
+Basic.Main.StoppingRecording="録画停止処理中..."
 Basic.Main.StopStreaming="配信終了"
-Basic.Main.StoppingStreaming="配信を停止しています..."
+Basic.Main.StoppingStreaming="配信停止処理中..."
 Basic.Main.ForceStopStreaming="配信停止 (遅延破棄)"
 
 Basic.MainMenu.File="ファイル(&F)"
@@ -285,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="$1 を元に戻す(&U)"
 Basic.MainMenu.Edit.RedoAction="$1 をやり直す(&R)"
 Basic.MainMenu.Edit.LockPreview="ロックプレビュー(&L)"
+Basic.MainMenu.Edit.Scale="プレビュースケーリング(&S)"
+Basic.MainMenu.Edit.Scale.Window="ウィンドウサイズにスケーリング表示"
+Basic.MainMenu.Edit.Scale.Canvas="基本(キャンバス) (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="出力(スケーリング) (%1x%2)"
 Basic.MainMenu.Edit.Transform="変換(&T)"
 Basic.MainMenu.Edit.Transform.EditTransform="変換の編集...(&E)"
 Basic.MainMenu.Edit.Transform.ResetTransform="変換をリセット(&R)"

obs-studio-0.16.5.tar.xz/UI/data/locale/ko-KR.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/ko-KR.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/nl-NL.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/nl-NL.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/pt-BR.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/pt-BR.ini Changed

@@ -48,7 +48,7 @@
 Right="Direita"
 Top="Topo"
 Bottom="Baixo"
-Reset="Repor"
+Reset="Redefinir"
 Hours="Horas"
 Minutes="Minutos"
 Seconds="Segundos"
@@ -284,6 +284,10 @@
 Basic.MainMenu.Edit.UndoAction="&Desfazer $1"
 Basic.MainMenu.Edit.RedoAction="&Refazer $1"
 Basic.MainMenu.Edit.LockPreview="&Bloquear pré-visualização"
+Basic.MainMenu.Edit.Scale="Visualização e dimensionamento"
+Basic.MainMenu.Edit.Scale.Window="Escala para janela"
+Basic.MainMenu.Edit.Scale.Canvas="Lona (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Saída (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Transformar"
 Basic.MainMenu.Edit.Transform.EditTransform="&Editar Transformação..."
 Basic.MainMenu.Edit.Transform.ResetTransform="&Limpar Transformação"
@@ -371,6 +375,7 @@
 Basic.Settings.Output.Simple.Warn.MultipleQSV="Aviso: Você não pode usar vários codificadores QSV separados quando estiver transmitindo e gravando ao mesmo tempo.  Se você deseja transmitir e gravar ao mesmo tempo, por favor altere o codificador de gravação ou o de transmissão."
 Basic.Settings.Output.Simple.Encoder.Software="Software (x264)"
 Basic.Settings.Output.Simple.Encoder.Hardware.QSV="Hardware (QSV)"
+Basic.Settings.Output.Simple.Encoder.Hardware.AMD="Hardware (AMD)"
 Basic.Settings.Output.Simple.Encoder.Hardware.NVENC="Hardware (NVENC)"
 Basic.Settings.Output.Simple.Encoder.SoftwareLowCPU="Software (preset x264 de baixa utilização de CPU, aumenta o tamanho do arquivo)"
 Basic.Settings.Output.VideoBitrate="Taxa de Bits do Vídeo"
@@ -420,7 +425,7 @@
 Basic.Settings.Output.Adv.FFmpeg.AEncoderSettings="Configurações do codificador de áudio(se houver)"
 Basic.Settings.Output.Adv.FFmpeg.MuxerSettings="Configurações do Muxer (se houver)"
 
-FilenameFormatting.completer="%CCYY-%MM-%DD %hh-%mm-%ss\n%YY-%MM-%DD %hh-%mm-%ss\n%Y-%m-%d %H-%M-%S\n%y-%m-%d %H-%M-%S\n%a %Y-%m-%d %H-%M-%S\n%A %Y-%m-%d %H-%M-%S\n%Y-%b-%d %H-%M-%S\n%Y-%B-%d %H-%M-%S\n%Y-%m-%d %I-%M-%S-%p\n%Y-%m-%d %H-%M-%S-%z\n%Y-%m-%d %H-%M-%S-%Z"
+FilenameFormatting.completer="%CCYY-% MM-%DD %hh-%mm-%ss\n%YY-%MM-%DD %hh-%mm-%ss\n%Y-%m-%d %H-%M-%S\n%y-%m-%d %H-%M-%S\n%a %H-%M-%S\n%A %d-%Y-%m %Y-%m-%d %H-%M-%S\n%Y-%b-123_2_ 16_321 %H-%M-%S\n%Y-%B-%d %H-%M-%S\n%Y-%m-%d %I-%M-%S-%p\n%Y-%m-%d %H-%M-%S-%z\n%Y-%m-%d %H %M - %S-%Z"
 
 FilenameFormatting.TT="%CCYY		Ano, quatro dígitos\n%YY		Ano, dois dígitos (00-99)\n%MM		Mês como um número decimal (01-12)\n%DD		Dia do mês, começando com 0 (01-31)\n%hh		Hora, em formato de 24h (00-23)\n%mm		Minuto (00-59)\n%ss		Segundo (00-61)\n%%		A % sign\n%a		Dia da Semana abreviado\n%A		Nome da Semana completo\n%b		Nome do Mês abreviado\n%B		Nome do Mês completo\n%d		Dia do Mês, começando com 0 (01-31)\n%H		Hora, no formato de 24h (00-23)\n%I		Hora no formato de 12h (01-12)\n%m		Mês como um número decimal (01-12)\n%M		Minuto (00-59)\n%p		Designação AM ou PM\n%S		Segundo (00-61)\n%y		Ano, últimos dois dígitos (00-99)\n%Y		Ano\n%z		ISO 8601 diferença de fuso horário ou de UTC\n		nome ou abreviação\n%Z		Nome do Fuso Horário ou abreviação\n"

obs-studio-0.16.5.tar.xz/UI/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/sk-SK.ini Changed

@@ -14,6 +14,7 @@
 Add="Pridať"
 Remove="Odobrať"
 Rename="Premenovať"
+Filters="Filtre"
 Properties="Vlastnosti"
 MoveUp="Posunúť vyššie"
 MoveDown="Posunúť nižšie"
@@ -34,13 +35,18 @@
 New="Nový"
 Duplicate="Duplikovať"
 Enable="Povoliť"
+Transition="Prechod"
+QuickTransitions="Rýchle prechody"
 Left="Vľavo"
 Right="Vpravo"
+Top="Hore"
+Bottom="Dole"
 Reset="Vynulovať"
 Hours="Hodín"
 Minutes="Minúty"
 Seconds="Sekundy"
 
+QuickTransitions.DuplicateScene="Duplikovať scénu"
 
 Basic.TransitionDuration="Trvanie"
 Basic.TogglePreviewProgramMode="Štúdiový režim"
@@ -194,7 +200,9 @@
 Basic.MainMenu.Edit.Order.MoveToBottom="Premiestniť naspodok (&B)"
 
 
+Basic.MainMenu.Profile="&Profil"
 
+Basic.MainMenu.Tools="Nás&troje"
 
 Basic.MainMenu.Help="Pomoc (&H)"
 Basic.MainMenu.Help.Logs="&Log súbory"
@@ -206,12 +214,15 @@
 Basic.Settings.Confirm="Máte neuložené zmeny. Chcete uložiť zmeny?"
 
 Basic.Settings.General="Všeobecné"
+Basic.Settings.General.Theme="Vzhľad"
+Basic.Settings.General.Language="Jazyk"
 
 Basic.Settings.Stream="Stream"
 Basic.Settings.Stream.StreamType="Typ streamu"
 
 Basic.Settings.Output="Výstup"
 Basic.Settings.Output.Mode="Režim výstupu"
+Basic.Settings.Output.Mode.Simple="Jednoduchý"
 Basic.Settings.Output.VideoBitrate="Bitrate videa"
 Basic.Settings.Output.AudioBitrate="Bitrate zvuku"
 Basic.Settings.Output.Reconnect="Automaticky znovupripájať"
@@ -219,7 +230,12 @@
 Basic.Settings.Output.MaxRetries="Maximálny počet pokusov"
 Basic.Settings.Output.Advanced="Povoliť pokročilé nastavenia enkodéra"
 
+Basic.Settings.Output.Adv.Audio.Track1="Stopa 1"
+Basic.Settings.Output.Adv.Audio.Track2="Stopa 2"
+Basic.Settings.Output.Adv.Audio.Track3="Stopa 3"
+Basic.Settings.Output.Adv.Audio.Track4="Stopa 4"
 
+Basic.Settings.Output.Adv.Recording.Type="Typ"

obs-studio-0.16.5.tar.xz/UI/data/locale/sv-SE.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/sv-SE.ini Changed

@@ -49,11 +49,17 @@
 Top="Överkant"
 Bottom="Nederkant"
 Reset="Återställ"
+Hours="timmar"
+Minutes="minuter"
+Seconds="sekunder"
+Deprecated="Föråldrat"
 
 QuickTransitions.SwapScenes="Byt plats på Förhandsvisnings-/utdatascenerna efter skifte"
 QuickTransitions.SwapScenesTT="Byter plats på förhandsvisnings- och utdatascenerna efter övergång (om utdatans originalscen fortfarande finns). \nDet här kommer inte att ångra några förändringar i utdatans originalscen."
 QuickTransitions.DuplicateScene="Duplicera scen"
-QuickTransitions.EditProperties="Duplicera källa"
+QuickTransitions.DuplicateSceneTT="När du redigerar samma scen kan du redigera transformering/synligheten för källor utan att modifiera utmatningen.\nFör att redigera egenskaper för källor utan att modifiera utmatningen aktiverar du 'Duplicera källor'.\nNär detta värde ändras kommer den aktuella utmatningsscenen återställas (om den fortfarande finns)."
+QuickTransitions.EditProperties="Duplicera källor"
+QuickTransitions.EditPropertiesTT="När du redigerar samma scen kan du redigera egenskaperna för källor utan att modifiera utmatningen.\nDetta fungerar endast om 'Duplicera scen' är aktiverad.\nVissa källor (som mediakällor) stöder inte detta och kan inte redigeras separat.\nNär detta värde ändras kommer den aktuella utmatningsscenen återställas (om den fortfarande finns).\n\nVarning: Eftersom källor kommer att dupliceras kan detta kräva extra system- eller videoresurser."
 QuickTransitions.HotkeyName="Snabba övergång: %1"
 
 Basic.AddTransition="Lägg till konfigurerbar övergång"
@@ -280,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="&Ångra $1"
 Basic.MainMenu.Edit.RedoAction="&Gör om $1"
 Basic.MainMenu.Edit.LockPreview="&Lås förhandsvisning"
+Basic.MainMenu.Edit.Scale="Förhandsvisa &skalning"
+Basic.MainMenu.Edit.Scale.Window="Skala till fönster"
+Basic.MainMenu.Edit.Scale.Canvas="Kanvas (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Utmatning (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Omvandla"
 Basic.MainMenu.Edit.Transform.EditTransform="&Redigera omvandling..."
 Basic.MainMenu.Edit.Transform.ResetTransform="&Återställ omvandling"

obs-studio-0.16.5.tar.xz/UI/data/locale/uk-UA.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/uk-UA.ini Changed

@@ -52,13 +52,14 @@
 Hours="Годин"
 Minutes="Хвилин"
 Seconds="Секунд"
+Deprecated="Припинено підтримку"
 
 QuickTransitions.SwapScenes="Поміняти місцями сцени Перегляд/Вивід після Відео-переходу"
 QuickTransitions.SwapScenesTT="Міняє місцями сцени Перегляд та Вивід після закінчення Відео-переходу (якщо сцена Вивід ще існує).\nЗміни внесені до обох сцен залишаються."
 QuickTransitions.DuplicateScene="Використовувати копію сцени"
 QuickTransitions.DuplicateSceneTT="Під час редагування поточної сцени дозволяє зберегти Вивід без змін.\nДля можливості редагувати властивості Джерел, увімкніть також 'Використовувати копію Джерел'.\nЗміна цієї опції призведе до оновлення поточної сцени, яка йде на Вивід (якщо вона ще існує)."
 QuickTransitions.EditProperties="Використовувати копію Джерел"
-QuickTransitions.EditPropertiesTT="Під час редагування поточної сцени, дозволяє редагувати властивості Джерел не змінюючи Вивід.\nЦя опція можлива якщо 'Використовувати копію сцени' вибрана.\nДеякі джерела (наприклад медіа або прилади захвату зображень) не підтримують копіювання, тобто не можна внести окремі зміни у джерело.\nЗміна властивостей таких джерел миттєво змінить Вивід (якщо він ще існує).\n\nУвага: Так як джерела внутрішньо копіюються, то це може призвести до додаткового навантаження на систему та використання відео ресурсів."
+QuickTransitions.EditPropertiesTT="Під час редагування поточної сцени, дозволяє редагувати властивості Джерел не змінюючи Вивід.\nЦя опція можлива якщо 'Використовувати копію сцени' вибрана.\nДеякі джерела (наприклад медіа або пристрої захвату зображень) не підтримують копіювання, тобто не можна внести окремі зміни у джерело.\nЗміна властивостей таких джерел миттєво змінить Вивід (якщо він ще існує).\n\nУвага: Так як джерела внутрішньо копіюються, то це може призвести до додаткового навантаження на систему та використання відео ресурсів."
 QuickTransitions.HotkeyName="Швидкий відео-перехід: %1"
 
 Basic.AddTransition="Додати Відео-перехід що конфігурується"
@@ -285,6 +286,10 @@
 Basic.MainMenu.Edit.UndoAction="&Відмінити $1"
 Basic.MainMenu.Edit.RedoAction="Від&новити $1"
 Basic.MainMenu.Edit.LockPreview="&Зафіксувати вікно Перегляду"
+Basic.MainMenu.Edit.Scale="&Масштабувати вікно Перегляду"
+Basic.MainMenu.Edit.Scale.Window="В розмір вікна"
+Basic.MainMenu.Edit.Scale.Canvas="Як Полотно (%1x%2)"
+Basic.MainMenu.Edit.Scale.Output="Як Вивід (%1x%2)"
 Basic.MainMenu.Edit.Transform="&Розміри"
 Basic.MainMenu.Edit.Transform.EditTransform="Редагуват&и Розміри..."
 Basic.MainMenu.Edit.Transform.ResetTransform="Розміри за &замовчуванням"

obs-studio-0.16.5.tar.xz/UI/data/locale/zh-CN.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/zh-CN.ini Changed

obs-studio-0.16.5.tar.xz/UI/data/locale/zh-TW.ini -> obs-studio-0.16.6.tar.xz/UI/data/locale/zh-TW.ini Changed

obs-studio-0.16.5.tar.xz/UI/display-helpers.hpp -> obs-studio-0.16.6.tar.xz/UI/display-helpers.hpp Changed

obs-studio-0.16.5.tar.xz/UI/forms/OBSBasic.ui -> obs-studio-0.16.6.tar.xz/UI/forms/OBSBasic.ui Changed

@@ -873,8 +873,17 @@
 <addaction name="actionMoveToTop"/>
 <addaction name="actionMoveToBottom"/>
 </widget>
+ <widget class="QMenu" name="scalingMenu">
+ <property name="title">
+ <string>Basic.MainMenu.Edit.Scale</string>
+ </property>
+ <addaction name="actionScaleWindow"/>
+ <addaction name="actionScaleCanvas"/>
+ <addaction name="actionScaleOutput"/>
+ </widget>
 <addaction name="transformMenu"/>
 <addaction name="orderMenu"/>
+ <addaction name="scalingMenu"/>
 <addaction name="actionLockPreview"/>
 <addaction name="separator"/>
 <addaction name="actionAdvAudioProperties"/>
@@ -1328,6 +1337,30 @@
 <string>Basic.MainMenu.Edit.LockPreview</string>
 </property>
 </action>
+ <action name="actionScaleWindow">
+ <property name="checkable">
+ <bool>true</bool>
+ </property>
+ <property name="text">
+ <string>Basic.MainMenu.Edit.Scale.Window</string>
+ </property>
+ </action>
+ <action name="actionScaleCanvas">
+ <property name="checkable">
+ <bool>true</bool>
+ </property>
+ <property name="text">
+ <string>Basic.MainMenu.Edit.Scale.Canvas</string>
+ </property>
+ </action>
+ <action name="actionScaleOutput">
+ <property name="checkable">
+ <bool>true</bool>
+ </property>
+ <property name="text">
+ <string>Basic.MainMenu.Edit.Scale.Output</string>
+ </property>
+ </action>
 </widget>
 <customwidgets>
 <customwidget>

obs-studio-0.16.5.tar.xz/UI/forms/images/obs.png -> obs-studio-0.16.6.tar.xz/UI/forms/images/obs.png Changed

obs-studio-0.16.5.tar.xz/UI/forms/images/tray_active.png -> obs-studio-0.16.6.tar.xz/UI/forms/images/tray_active.png Changed

obs-studio-0.16.5.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/da-DK.ini -> obs-studio-0.16.6.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/da-DK.ini Changed

obs-studio-0.16.5.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/nl-NL.ini -> obs-studio-0.16.6.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/nl-NL.ini Changed

obs-studio-0.16.5.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/pt-BR.ini -> obs-studio-0.16.6.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/pt-BR.ini Changed

obs-studio-0.16.6.tar.xz/UI/frontend-plugins/frontend-tools/data/locale/sk-SK.ini Added

obs-studio-0.16.5.tar.xz/UI/installer/mp-installer.nsi -> obs-studio-0.16.6.tar.xz/UI/installer/mp-installer.nsi Changed

@@ -2,9 +2,10 @@
 
 ; Define your application name
 !define APPNAME "OBS Studio"
-!define APPVERSION "0.13.4"
+!define APPVERSION "0.16.5"
 !define APPNAMEANDVERSION "OBS Studio ${APPVERSION}"
-; !define BROWSER
+; !define FULL
+; !define REALSENSE_PLUGIN
 
 ; Additional script dependencies
 !include WinVer.nsh
@@ -14,10 +15,10 @@
 Name "${APPNAMEANDVERSION}"
 InstallDir "$PROGRAMFILES32\obs-studio"
 InstallDirRegKey HKLM "Software\${APPNAME}" ""
-!ifdef BROWSER
-OutFile "OBS-Studio-${APPVERSION}-With-Browser-Installer.exe"
+!ifdef FULL
+OutFile "OBS-Studio-${APPVERSION}-Full-Installer.exe"
 !else
-OutFile "OBS-Studio-${APPVERSION}-Installer.exe"
+OutFile "OBS-Studio-${APPVERSION}-Small-Installer.exe"
 !endif
 
 ; Use compression
@@ -37,6 +38,9 @@
 !insertmacro MUI_PAGE_WELCOME
 !insertmacro MUI_PAGE_LICENSE "data\obs-studio\license\gplv2.txt"
 !insertmacro MUI_PAGE_DIRECTORY
+!ifdef FULL
+	!insertmacro MUI_PAGE_COMPONENTS
+!endif
 !insertmacro MUI_PAGE_INSTFILES
 !insertmacro MUI_PAGE_FINISH
 
@@ -177,14 +181,15 @@
 
 Var outputErrors
 
-Section "OBS Studio" Section1
+Section "OBS Studio" SecCore
 
 	; Set Section properties
+	SectionIn RO
 	SetOverwrite on
 	AllowSkipFiles off
 
-	FindProcDLL::KillProc "obs-plugins\32bit\cef-bootstrap.exe"
-	FindProcDLL::KillProc "obs-plugins\64bit\cef-bootstrap.exe"
+	KillProcDLL::KillProc "obs-plugins\32bit\cef-bootstrap.exe"
+	KillProcDLL::KillProc "obs-plugins\64bit\cef-bootstrap.exe"
 
 	SetShellVarContext all
 
@@ -235,6 +240,62 @@
 		Call filesInUse
 SectionEnd
 
+!ifdef FULL
+SectionGroup /e "Plugins" SecPlugins
+	Section "Browser plugin" SecPlugins_Browser
+		; Set Section properties
+		SetOverwrite on
+		AllowSkipFiles off
+		SetShellVarContext all
+
+		SetOutPath "$INSTDIR\obs-plugins"
+		File /r "obs-browser\obs-plugins\32bit"
+
+		${if} ${RunningX64}
+			File /r "obs-browser\obs-plugins\64bit"
+		${endif}
+
+		SetOutPath "$INSTDIR\bin\32bit"
+	SectionEnd
+
+	!ifdef REALSENSE_PLUGIN
+	Section /o "Realsense plugin" SecPlugins_Realsense
+		SetOverwrite on
+		AllowSkipFiles off
+		SetShellVarContext all
+
+		SetOutPath "$INSTDIR\obs-plugins"
+		File /r "realsense\32bit"
+
+		${if} ${RunningX64}
+			File /r "realsense\64bit"
+		${endif}
+
+		SetOutPath "$INSTDIR\data\obs-plugins"
+		File /r "realsense\actual_data\obs-plugins\win-ivcam"
+
+		ExecWait '"$INSTDIR\data\obs-plugins\win-ivcam\seg_service.exe" /UnregServer'
+		ExecWait '"$INSTDIR\data\obs-plugins\win-ivcam\seg_service.exe" /RegServer'
+
+		ReadRegStr $0 HKLM "Software\Intel\RSSDK\Dispatch" "Core"
+		${if} ${Errors}
+			ReadRegStr $0 HKLM "Software\Intel\RSSDK\v10\Dispatch" "Core"
+		${endif}
+
+		${if} ${Errors}
+			InitPluginsDir
+			SetOutPath "$PLUGINSDIR\realsense"
+
+			File "intel_rs_sdk_runtime_websetup_10.0.26.0396.exe"
+			ExecWait '"$PLUGINSDIR\realsense\intel_rs_sdk_runtime_websetup_10.0.26.0396.exe" --finstall=personify --fnone=all'
+		{endif}
+
+		SetOutPath "$INSTDIR\bin\32bit"
+	SectionEnd
+	!endif
+SectionGroupEnd
+!endif
+
 Section -FinishSection
 
 	WriteRegStr HKLM "Software\${APPNAME}" "" "$INSTDIR"
@@ -250,11 +311,18 @@
 
 ; Modern install component descriptions
 !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
-	!insertmacro MUI_DESCRIPTION_TEXT ${Section1} ""
+	!insertmacro MUI_DESCRIPTION_TEXT ${SecCore} "Core OBS Studio files"
+	!ifdef FULL
+		!insertmacro MUI_DESCRIPTION_TEXT ${SecPlugins} "Optional Plugins"
+		!insertmacro MUI_DESCRIPTION_TEXT ${SecPlugins_Browser} "Browser plugin (a source you can add to your scenes that displays web pages)"
+		!ifdef REALSENSE_PLUGIN
+			!insertmacro MUI_DESCRIPTION_TEXT ${SecPlugins_Realsense} "Plugin for Realsense cameras"
+		!endif
+	!endif
 !insertmacro MUI_FUNCTION_DESCRIPTION_END
 
 ;Uninstall section
-Section "un.obs-studio Program Files"
+Section "un.obs-studio Program Files" UninstallSection1
 
 	SectionIn RO
 
@@ -273,6 +341,11 @@
 		Delete "$SMPROGRAMS\OBS Studio\OBS Studio (64bit).lnk"
 	${endif}
 
+	IfFileExists "$INSTDIR\data\obs-plugins\win-ivcam\seg_service.exe" UnregisterSegService SkipUnreg
+	UnregisterSegService:
+	ExecWait '"$INSTDIR\data\obs-plugins\win-ivcam\seg_service.exe" /UnregServer'
+	SkipUnreg:
+
 	; Clean up OBS Studio
 	RMDir /r "$INSTDIR\bin"
 	RMDir /r "$INSTDIR\data"
@@ -284,13 +357,13 @@
 	RMDir "$INSTDIR\OBS Studio"
 SectionEnd
 
-Section /o "un.User Settings" Section2
+Section /o "un.User Settings" UninstallSection2
 	RMDir /R "$APPDATA\obs-studio"
 SectionEnd
 
 !insertmacro MUI_UNFUNCTION_DESCRIPTION_BEGIN
-	!insertmacro MUI_DESCRIPTION_TEXT ${Section1} "Remove the OBS program files."
-	!insertmacro MUI_DESCRIPTION_TEXT ${Section2} "Removes all settings, plugins, scenes and sources, profiles, log files and other application data."
+	!insertmacro MUI_DESCRIPTION_TEXT ${UninstallSection1} "Remove the OBS program files."
+	!insertmacro MUI_DESCRIPTION_TEXT ${UninstallSection2} "Removes all settings, plugins, scenes and sources, profiles, log files and other application data."
 !insertmacro MUI_UNFUNCTION_DESCRIPTION_END
 
 ; Version information

obs-studio-0.16.5.tar.xz/UI/obs-app.cpp -> obs-studio-0.16.6.tar.xz/UI/obs-app.cpp Changed

@@ -59,6 +59,8 @@
 static string lastLogFile;
 
 static bool portable_mode = false;
+static bool log_verbose = false;
+static bool unfiltered_log = false;
 bool opt_start_streaming = false;
 bool opt_start_recording = false;
 string opt_starting_collection;
@@ -270,6 +272,10 @@
 
 	lock_guard<mutex> guard(log_mutex);
 
+	if (unfiltered_log) {
+		return false;
+	}
+
 	if (last_msg_ptr == msg) {
 		int diff = std::abs(new_sum - last_char_sum);
 		if (diff < MAX_CHAR_VARIATION) {
@@ -314,7 +320,7 @@
 	if (too_many_repeated_entries(logFile, msg, str))
 		return;
 
-	if (log_level <= LOG_INFO)
+	if (log_level <= LOG_INFO || log_verbose)
 		LogStringChunk(logFile, str);
 
 #if defined(_WIN32) && defined(OBS_DEBUGBREAK_ON_ERROR)
@@ -1796,6 +1802,12 @@
 		if (arg_is(argv[i], "--portable", "-p")) {
 			portable_mode = true;
 
+		} else if (arg_is(argv[i], "--verbose", nullptr)) {
+			log_verbose = true;
+
+		} else if (arg_is(argv[i], "--unfiltered_log", nullptr)) {
+			unfiltered_log = true;
+
 		} else if (arg_is(argv[i], "--startstreaming", nullptr)) {
 			opt_start_streaming = true;

obs-studio-0.16.5.tar.xz/UI/window-basic-main-outputs.cpp -> obs-studio-0.16.6.tar.xz/UI/window-basic-main-outputs.cpp Changed

@@ -505,7 +505,6 @@
 	obs_data_set_int(settings, "AMF.H264.Usage", 0);
 	obs_data_set_int(settings, "AMF.H264.Profile", 100); // High
 	obs_data_set_string(settings, "profile", "high"); // High
-	obs_data_set_int(settings, "AMF.H264.ProfileLevel", 0); // Automatic
 	
 	// Rate Control Properties
 	obs_data_set_int(settings, "AMF.H264.RateControlMethod", 1);
@@ -513,8 +512,6 @@
 	obs_data_set_int(settings, "AMF.H264.Bitrate.Target", bitrate);
 	obs_data_set_int(settings, "bitrate", bitrate);
 	obs_data_set_int(settings, "AMF.H264.FillerData", 1);
-	obs_data_set_int(settings, "AMF.H264.VBVBuffer", 0); // Automatic VBV Buffer
-	obs_data_set_double(settings, "AMF.H264.VBVBuffer.Strictness", 0.9);
 	
 	// Picture Control Properties
 	obs_data_set_double(settings, "AMF.H264.KeyframeInterval", 2.0);
@@ -529,9 +526,8 @@
 	obs_data_set_int(settings, "AMF.H264.Usage", 0);
 	obs_data_set_int(settings, "AMF.H264.Profile", 100); // High
 	obs_data_set_string(settings, "profile", "high"); // High
-	obs_data_set_int(settings, "AMF.H264.ProfileLevel", 0); // Automatic
 
-															// Rate Control Properties
+	// Rate Control Properties
 	obs_data_set_int(settings, "AMF.H264.RateControlMethod", 0);
 	obs_data_set_string(settings, "rate_control", "CQP");
 	obs_data_set_int(settings, "AMF.H264.QP.IFrame", cqp);

obs-studio-0.16.5.tar.xz/UI/window-basic-main.cpp -> obs-studio-0.16.6.tar.xz/UI/window-basic-main.cpp Changed

@@ -375,6 +375,8 @@
 			scene, curProgramScene);
 
 	obs_data_set_bool(saveData, "preview_locked", ui->preview->Locked());
+	obs_data_set_int(saveData, "scaling_mode",
+			static_cast<uint32_t>(ui->preview->GetScalingMode()));
 
 	if (api) {
 		obs_data_t *moduleObj = obs_data_create();
@@ -665,6 +667,19 @@
 	ui->preview->SetLocked(previewLocked);
 	ui->actionLockPreview->setChecked(previewLocked);
 
+	ScalingMode previewScaling = static_cast<ScalingMode>(
+			obs_data_get_int(data, "scaling_mode"));
+	switch (previewScaling) {
+	case ScalingMode::Window:
+	case ScalingMode::Canvas:
+	case ScalingMode::Output:
+		break;
+	default:
+		previewScaling = ScalingMode::Window;
+	}
+
+	ui->preview->SetScaling(previewScaling);
+
 	if (api) {
 		obs_data_t *modulesObj = obs_data_get_obj(data, "modules");
 		api->on_load(modulesObj);
@@ -1567,6 +1582,17 @@
 	return GetSceneItem(GetTopSelectedSourceItem());
 }
 
+void OBSBasic::UpdatePreviewScalingMenu()
+{
+	ScalingMode scalingMode = ui->preview->GetScalingMode();
+	ui->actionScaleWindow->setChecked(
+			scalingMode == ScalingMode::Window);
+	ui->actionScaleCanvas->setChecked(
+			scalingMode == ScalingMode::Canvas);
+	ui->actionScaleOutput->setChecked(
+			scalingMode == ScalingMode::Output);
+}
+
 void OBSBasic::UpdateSources(OBSScene scene)
 {
 	ClearListItems(ui->sources);
@@ -2570,13 +2596,39 @@
 void OBSBasic::ResizePreview(uint32_t cx, uint32_t cy)
 {
 	QSize targetSize;
+	ScalingMode scalingMode;
+	obs_video_info ovi;
 
 	/* resize preview panel to fix to the top section of the window */
 	targetSize = GetPixelSize(ui->preview);
-	GetScaleAndCenterPos(int(cx), int(cy),
-			targetSize.width() - PREVIEW_EDGE_SIZE * 2,
-			targetSize.height() - PREVIEW_EDGE_SIZE * 2,
-			previewX, previewY, previewScale);
+
+	scalingMode = ui->preview->GetScalingMode();
+	obs_get_video_info(&ovi);
+
+	if (scalingMode == ScalingMode::Canvas) {
+		previewScale = 1.0f;
+		GetCenterPosFromFixedScale(int(cx), int(cy),
+				targetSize.width() - PREVIEW_EDGE_SIZE * 2,
+				targetSize.height() - PREVIEW_EDGE_SIZE * 2,
+				previewX, previewY, previewScale);
+		previewX += ui->preview->ScrollX();
+		previewY += ui->preview->ScrollY();
+
+	} else if (scalingMode == ScalingMode::Output) {
+		previewScale = float(ovi.output_width) / float(ovi.base_width);
+		GetCenterPosFromFixedScale(int(cx), int(cy),
+				targetSize.width() - PREVIEW_EDGE_SIZE * 2,
+				targetSize.height() - PREVIEW_EDGE_SIZE * 2,
+				previewX, previewY, previewScale);
+		previewX += ui->preview->ScrollX();
+		previewY += ui->preview->ScrollY();
+
+	} else {
+		GetScaleAndCenterPos(int(cx), int(cy),
+				targetSize.width() - PREVIEW_EDGE_SIZE * 2,
+				targetSize.height() - PREVIEW_EDGE_SIZE * 2,
+				previewX, previewY, previewScale);
+	}
 
 	previewX += float(PREVIEW_EDGE_SIZE);
 	previewY += float(PREVIEW_EDGE_SIZE);
@@ -3083,11 +3135,8 @@
 		if (IsPreviewProgramMode())
 			action->setEnabled(false);
 
-		action = popup.addAction(
-				QTStr("Basic.MainMenu.Edit.LockPreview"),
-				this, SLOT(on_actionLockPreview_triggered()));
-		action->setCheckable(true);
-		action->setChecked(ui->preview->Locked());
+		popup.addAction(ui->actionLockPreview);
+		popup.addMenu(ui->scalingMenu);
 
 		previewProjector = new QMenu(QTStr("PreviewProjector"));
 		AddProjectorMenuMonitors(previewProjector, this,
@@ -4565,6 +4614,45 @@
 	ui->actionLockPreview->setChecked(ui->preview->Locked());
 }
 
+void OBSBasic::on_scalingMenu_aboutToShow()
+{
+	obs_video_info ovi;
+	obs_get_video_info(&ovi);
+
+	QAction *action = ui->actionScaleCanvas;
+	QString text = QTStr("Basic.MainMenu.Edit.Scale.Canvas");
+	text = text.arg(QString::number(ovi.base_width),
+			QString::number(ovi.base_height));
+	action->setText(text);
+
+	action = ui->actionScaleOutput;
+	text = QTStr("Basic.MainMenu.Edit.Scale.Output");
+	text = text.arg(QString::number(ovi.output_width),
+			QString::number(ovi.output_height));
+	action->setText(text);
+
+	UpdatePreviewScalingMenu();
+}
+
+void OBSBasic::on_actionScaleWindow_triggered()
+{
+	ui->preview->SetScaling(ScalingMode::Window);
+	ui->preview->ResetScrollingOffset();
+	emit ui->preview->DisplayResized();
+}
+
+void OBSBasic::on_actionScaleCanvas_triggered()
+{
+	ui->preview->SetScaling(ScalingMode::Canvas);
+	emit ui->preview->DisplayResized();
+}
+
+void OBSBasic::on_actionScaleOutput_triggered()
+{
+	ui->preview->SetScaling(ScalingMode::Output);
+	emit ui->preview->DisplayResized();
+}
+
 void OBSBasic::SetShowing(bool showing)
 {
 	if (!showing && isVisible()) {

obs-studio-0.16.5.tar.xz/UI/window-basic-main.hpp -> obs-studio-0.16.6.tar.xz/UI/window-basic-main.hpp Changed

obs-studio-0.16.5.tar.xz/UI/window-basic-preview.cpp -> obs-studio-0.16.6.tar.xz/UI/window-basic-preview.cpp Changed

@@ -17,6 +17,7 @@
 OBSBasicPreview::OBSBasicPreview(QWidget *parent, Qt::WindowFlags flags)
 	: OBSQTDisplay(parent, flags)
 {
+	ResetScrollingOffset();
 	setMouseTracking(true);
 }
 
@@ -377,8 +378,56 @@
 	}
 }
 
+void OBSBasicPreview::keyPressEvent(QKeyEvent *event)
+{
+	if (GetScalingMode() == ScalingMode::Window ||
+	    event->isAutoRepeat()) {
+		OBSQTDisplay::keyPressEvent(event);
+		return;
+	}
+
+	switch (event->key()) {
+	case Qt::Key_Space:
+		setCursor(Qt::OpenHandCursor);
+		scrollMode = true;
+		break;
+	}
+
+	OBSQTDisplay::keyPressEvent(event);
+}
+
+void OBSBasicPreview::keyReleaseEvent(QKeyEvent *event)
+{
+	if (event->isAutoRepeat()) {
+		OBSQTDisplay::keyReleaseEvent(event);
+		return;
+	}
+
+	switch (event->key()) {
+	case Qt::Key_Space:
+		scrollMode = false;
+		setCursor(Qt::ArrowCursor);
+		break;
+	}
+
+	OBSQTDisplay::keyReleaseEvent(event);
+}
+
 void OBSBasicPreview::mousePressEvent(QMouseEvent *event)
 {
+	if (scrollMode && GetScalingMode() != ScalingMode::Window &&
+	    event->button() == Qt::LeftButton) {
+		setCursor(Qt::ClosedHandCursor);
+		scrollingFrom.x = event->x();
+		scrollingFrom.y = event->y();
+		return;
+	}
+
+	if (event->button() == Qt::RightButton) {
+		scrollMode = false;
+		setCursor(Qt::ArrowCursor);
+	}
+
 	if (locked) {
 		OBSQTDisplay::mousePressEvent(event);
 		return;
@@ -456,6 +505,9 @@
 
 void OBSBasicPreview::mouseReleaseEvent(QMouseEvent *event)
 {
+	if (scrollMode)
+		setCursor(Qt::OpenHandCursor);
+
 	if (locked) {
 		OBSQTDisplay::mouseReleaseEvent(event);
 		return;
@@ -951,6 +1003,15 @@
 
 void OBSBasicPreview::mouseMoveEvent(QMouseEvent *event)
 {
+	if (scrollMode && event->buttons() == Qt::LeftButton) {
+		scrollingOffset.x += event->x() - scrollingFrom.x;
+		scrollingOffset.y += event->y() - scrollingFrom.y;
+		scrollingFrom.x = event->x();
+		scrollingFrom.y = event->y();
+		emit DisplayResized();
+		return;
+	}
+
 	if (locked)
 		return;
 
@@ -1113,3 +1174,8 @@
 	gs_technique_end_pass(tech);
 	gs_technique_end(tech);
 }
+
+void OBSBasicPreview::ResetScrollingOffset()
+{
+	vec2_zero(&scrollingOffset);
+}

obs-studio-0.16.5.tar.xz/UI/window-basic-preview.hpp -> obs-studio-0.16.6.tar.xz/UI/window-basic-preview.hpp Changed

@@ -26,6 +26,12 @@
 	BottomRight  = ITEM_BOTTOM | ITEM_RIGHT
 };
 
+enum class ScalingMode : uint32_t {
+	Window = 0,
+	Canvas = 1,
+	Output = 2
+};
+
 class OBSBasicPreview : public OBSQTDisplay {
 	Q_OBJECT
 
@@ -35,17 +41,21 @@
 	vec2         cropSize;
 	OBSSceneItem stretchItem;
 	ItemHandle   stretchHandle = ItemHandle::None;
+	ScalingMode  scale = ScalingMode::Window;
 	vec2         stretchItemSize;
 	matrix4      screenToItem;
 	matrix4      itemToScreen;
 
 	vec2         startPos;
 	vec2         lastMoveOffset;
+	vec2         scrollingFrom;
+	vec2         scrollingOffset;
 	bool         mouseDown      = false;
 	bool         mouseMoved     = false;
 	bool         mouseOverItems = false;
 	bool         cropping       = false;
 	bool         locked         = false;
+	bool         scrollMode     = false;
 
 	static vec2 GetMouseEventPos(QMouseEvent *event);
 	static bool DrawSelectedItem(obs_scene_t *scene, obs_sceneitem_t *item,
@@ -75,16 +85,26 @@
 public:
 	OBSBasicPreview(QWidget *parent, Qt::WindowFlags flags = 0);
 
+	virtual void keyPressEvent(QKeyEvent *event) override;
+	virtual void keyReleaseEvent(QKeyEvent *event) override;
+
 	virtual void mousePressEvent(QMouseEvent *event) override;
 	virtual void mouseReleaseEvent(QMouseEvent *event) override;
 	virtual void mouseMoveEvent(QMouseEvent *event) override;
 
 	void DrawSceneEditing();
+	void ResetScrollingOffset();
 
 	inline void SetLocked(bool newLockedVal) {locked = newLockedVal;}
 	inline void ToggleLocked() {locked = !locked;}
 	inline bool Locked() const {return locked;}
 
+	inline void SetScaling(ScalingMode newScaledVal) {scale = newScaledVal;}
+	inline ScalingMode GetScalingMode() const {return scale;}
+
+	inline float ScrollX() const {return scrollingOffset.x;}
+	inline float ScrollY() const {return scrollingOffset.y;}
+
 	/* use libobs allocator for alignment because the matrices itemToScreen
 	 * and screenToItem may contain SSE data, which will cause SSE
 	 * instructions to crash if the data is not aligned to at least a 16

obs-studio-0.16.5.tar.xz/UI/window-basic-settings.cpp -> obs-studio-0.16.6.tar.xz/UI/window-basic-settings.cpp Changed

@@ -1206,6 +1206,8 @@
 			"QSVPreset");
 	const char *nvPreset = config_get_string(main->Config(), "SimpleOutput",
 			"NVENCPreset");
+	const char* amdPreset = config_get_string(main->Config(), "SimpleOutput",
+			"AMDPreset");
 	const char *custom = config_get_string(main->Config(), "SimpleOutput",
 			"x264Settings");
 	const char *recQual = config_get_string(main->Config(), "SimpleOutput",
@@ -1218,6 +1220,7 @@
 	curPreset = preset;
 	curQSVPreset = qsvPreset;
 	curNVENCPreset = nvPreset;
+	curAMDPreset = amdPreset;
 
 	audioBitrate = FindClosestAvailableAACBitrate(audioBitrate);
 
@@ -1290,14 +1293,16 @@
 	obs_data_t *settings = obs_encoder_defaults(encoder);
 	OBSPropertiesView *view;
 
-	char encoderJsonPath[512];
-	int ret = GetProfilePath(encoderJsonPath, sizeof(encoderJsonPath),
-			path);
-	if (ret > 0) {
-		obs_data_t *data = obs_data_create_from_json_file_safe(
-				encoderJsonPath, "bak");
-		obs_data_apply(settings, data);
-		obs_data_release(data);
+	if (path) {
+		char encoderJsonPath[512];
+		int ret = GetProfilePath(encoderJsonPath,
+				sizeof(encoderJsonPath), path);
+		if (ret > 0) {
+			obs_data_t *data = obs_data_create_from_json_file_safe(
+					encoderJsonPath, "bak");
+			obs_data_apply(settings, data);
+			obs_data_release(data);
+		}
 	}
 
 	view = new OBSPropertiesView(settings, encoder,

obs-studio-0.16.6.tar.xz/cmake/Modules/FindRSSDK.cmake Added

obs-studio-0.16.5.tar.xz/cmake/Modules/IDLFileHelper.cmake -> obs-studio-0.16.6.tar.xz/cmake/Modules/IDLFileHelper.cmake Changed

@@ -1,4 +1,4 @@
-macro(add_idl_files generated_files)
+macro(add_idl_files_base generated_files with_tlb)
 	foreach(filename ${ARGN})
 		get_filename_component(file_we ${filename} NAME_WE)
 		get_filename_component(file_path ${filename} PATH)
@@ -9,10 +9,18 @@
 		set(bin_file_c ${CMAKE_CURRENT_BINARY_DIR}/${file_c})
 
 		if(MSVC)
+			if(${with_tlb})
+				set(file_tlb ${file_we}.tlb)
+				set(bin_file_tlb ${CMAKE_CURRENT_BINARY_DIR}/${file_tlb})
+				set(tlb_opt "")
+			else()
+				set(tlb_opt "/notlb")
+			endif()
+
 			add_custom_command(
 				OUTPUT ${bin_file_h} ${bin_file_c}
 				DEPENDS ${filename}
-				COMMAND midl /h ${file_h} /iid ${file_c} /notlb ${CMAKE_CURRENT_SOURCE_DIR}/${filename}
+				COMMAND midl /h ${file_h} /iid ${file_c} ${tlb_opt} ${CMAKE_CURRENT_SOURCE_DIR}/${filename}
 				WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 		else()
 			execute_process(COMMAND echo
@@ -62,4 +70,12 @@
 			PROPERTIES
 			HEADER_FILE_ONLY TRUE)
 	endforeach(filename ${ARGN})
+endmacro(add_idl_files_base)
+
+macro(add_idl_files generated_files)
+	add_idl_files_base(${generated_files} FALSE ${ARGN})
 endmacro(add_idl_files)
+
+macro(add_idl_files_with_tlb generated_files)
+	add_idl_files_base(${generated_files} TRUE ${ARGN})
+endmacro(add_idl_files_with_tlb)

obs-studio-0.16.5.tar.xz/libobs-opengl/gl-subsystem.c -> obs-studio-0.16.6.tar.xz/libobs-opengl/gl-subsystem.c Changed

obs-studio-0.16.5.tar.xz/libobs/obs-config.h -> obs-studio-0.16.6.tar.xz/libobs/obs-config.h Changed

obs-studio-0.16.5.tar.xz/libobs/obs-internal.h -> obs-studio-0.16.6.tar.xz/libobs/obs-internal.h Changed

obs-studio-0.16.5.tar.xz/libobs/obs-source.c -> obs-studio-0.16.6.tar.xz/libobs/obs-source.c Changed

@@ -410,7 +410,9 @@
 		obs_scene_t *new_scene = obs_scene_duplicate(scene, new_name,
 				create_private ? OBS_SCENE_DUP_PRIVATE_COPY :
 					OBS_SCENE_DUP_COPY);
-		return obs_scene_get_source(new_scene);
+		obs_source_t *new_source = obs_scene_get_source(new_scene);
+		duplicate_filters(new_source, source, create_private);
+		return new_source;
 	}
 
 	settings = obs_data_create();
@@ -919,6 +921,35 @@
 
 static inline struct obs_source_frame *get_closest_frame(obs_source_t *source,
 		uint64_t sys_time);
+bool set_async_texture_size(struct obs_source *source,
+		const struct obs_source_frame *frame);
+
+static void async_tick(obs_source_t *source)
+{
+	uint64_t sys_time = obs->video.video_time;
+
+	pthread_mutex_lock(&source->async_mutex);
+
+	if (deinterlacing_enabled(source)) {
+		deinterlace_process_last_frame(source, sys_time);
+	} else {
+		if (source->cur_async_frame) {
+			remove_async_frame(source,
+					source->cur_async_frame);
+			source->cur_async_frame = NULL;
+		}
+
+		source->cur_async_frame = get_closest_frame(source,
+				sys_time);
+	}
+
+	source->last_sys_timestamp = sys_time;
+	pthread_mutex_unlock(&source->async_mutex);
+
+	if (source->cur_async_frame)
+		source->async_update_texture = set_async_texture_size(source,
+				source->cur_async_frame);
+}
 
 void obs_source_video_tick(obs_source_t *source, float seconds)
 {
@@ -930,27 +961,8 @@
 	if (source->info.type == OBS_SOURCE_TYPE_TRANSITION)
 		obs_transition_tick(source);
 
-	if ((source->info.output_flags & OBS_SOURCE_ASYNC) != 0) {
-		uint64_t sys_time = obs->video.video_time;
-
-		pthread_mutex_lock(&source->async_mutex);
-
-		if (deinterlacing_enabled(source)) {
-			deinterlace_process_last_frame(source, sys_time);
-		} else {
-			if (source->cur_async_frame) {
-				remove_async_frame(source,
-						source->cur_async_frame);
-				source->cur_async_frame = NULL;
-			}
-
-			source->cur_async_frame = get_closest_frame(source,
-					sys_time);
-		}
-
-		source->last_sys_timestamp = sys_time;
-		pthread_mutex_unlock(&source->async_mutex);
-	}
+	if ((source->info.output_flags & OBS_SOURCE_ASYNC) != 0)
+		async_tick(source);
 
 	if (source->defer_update)
 		obs_source_deferred_update(source);
@@ -1331,6 +1343,8 @@
 	source->async_height = frame->height;
 	source->async_format = frame->format;
 
+	gs_enter_context(obs->video.graphics);
+
 	gs_texture_destroy(source->async_texture);
 	gs_texture_destroy(source->async_prev_texture);
 	gs_texrender_destroy(source->async_texrender);
@@ -1365,6 +1379,8 @@
 	if (deinterlacing_enabled(source))
 		set_deinterlace_texture_size(source);
 
+	gs_leave_context();
+
 	return !!source->async_texture;
 }
 
@@ -1612,10 +1628,11 @@
 				os_gettime_ns() - frame->timestamp;
 			source->timing_set = true;
 
-			if (set_async_texture_size(source, frame)) {
+			if (source->async_update_texture) {
 				update_async_texture(source, frame,
 						source->async_texture,
 						source->async_texrender);
+				source->async_update_texture = false;
 			}
 
 			obs_source_release_frame(source, frame);

obs-studio-0.16.5.tar.xz/libobs/obs-win-crash-handler.c -> obs-studio-0.16.6.tar.xz/libobs/obs-win-crash-handler.c Changed

obs-studio-0.16.5.tar.xz/libobs/obs-windows.c -> obs-studio-0.16.6.tar.xz/libobs/obs-windows.c Changed

obs-studio-0.16.5.tar.xz/libobs/util/platform-windows.c -> obs-studio-0.16.6.tar.xz/libobs/util/platform-windows.c Changed

obs-studio-0.16.5.tar.xz/libobs/util/windows/win-version.h -> obs-studio-0.16.6.tar.xz/libobs/util/windows/win-version.h Changed

obs-studio-0.16.5.tar.xz/plugins/CMakeLists.txt -> obs-studio-0.16.6.tar.xz/plugins/CMakeLists.txt Changed

obs-studio-0.16.5.tar.xz/plugins/coreaudio-encoder/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/plugins/coreaudio-encoder/data/locale/de-DE.ini Changed

obs-studio-0.16.6.tar.xz/plugins/enc-amf/#Resources/HIDDEN_PARAMETERS.md Added

@@ -0,0 +1,1330 @@
+For an unknown reason, there are hidden parameters in the Runtime that can be set.
+
+## AVC Properties
+### Static
+* FrameSize
+* FrameRate
+* ExtraData (Read-Only)
+* Usage
+* Profile Two new profiles are in the runtime, Constrained Base and Constrained High.
+* Profile Level
+* MaxOfLTRFrames
+* ScanType
+* QualityPreset
+
+### Dynamic
+* RateControlMethod
+* TargetBitrate
+* PeakBitrate
+* RateControlSkipFrameEnable
+* MinQP
+* MaxQP
+* QPI
+* QPP
+* QPB
+* VBVBufferSize
+* VBVBufferFullness
+* EnforceHRD
+* MaxAUSize
+* FillerDataEnable
+* BPicturesDeltaQP
+* ReferenceBPicturesDeltaQP
+* HeaderInsertionSpacing
+* IDRPeriod
+* DeBlockingFilter
+* IntraRefreshMBsNumberPerSlot
+* SlicesPerFrame
+* BPicturesPattern
+* BReferenceEnable
+* HalfPixel
+* QuarterPixel
+
+### Unknown / New
+
+* **QualityEnhancementMode** So far always 0.
+* **MaxNumRefFrames** Shouldn't this be a Capability instead? Could perhaps be used to control B-Pictures more.
+* **MaxMBPerSec** Unknown value.
+* **InstanceID**
+* **EnableVBAQ** Unknown meaning.
+* **RateControlPreanalysisEnable** Is this Two-Pass encoding?
+* **GOPSize** Technically ignored, but still there in code.
+* **AspectRatio**
+* **NominalRange**
+* **IntraRefreshNumOfStripes** New, was not here before.
+* **SliceMode** New, was not here before.
+* **MaxSliceSize** New, was not here before.
+* **LowLatencyInternal**
+* **CommonLowLatencyInternal**
+* **SliceControlMode**
+* **SliceControlSize**
+* **CABACEnable** Not yet publicly available, but 16.10.3 always uses it anyway.
+* **UniqueInstance**
+* **EncoderMaxInstances**
+* **MultiInstanceMode**
+* **MultiInstanceCurrentQueue**
+* **WaitForTask**
+
+23:23:47.388: [AMF Encoder] [CodecId] CodecId (Type: Int64, Index 0)
+23:23:47.389: [AMF Encoder] Content Type: 0
+23:23:47.389: [AMF Encoder] Access: RW
+23:23:47.389: [AMF Encoder] Values:
+23:23:47.389: [AMF Encoder] Current: 5
+23:23:47.389: [AMF Encoder] Default: 5
+23:23:47.389: [AMF Encoder] Minimum: Empty
+23:23:47.389: [AMF Encoder] Maximum: Empty
+23:23:47.389: [AMF Encoder] Enumeration: 
+23:23:47.391: [AMF Encoder] H264 (5)
+23:23:47.391: [AMF Encoder] UNKNOWN (0)
+23:23:47.391: [AMF Encoder] H264SVC (8)
+23:23:47.391: [AMF Encoder] UNKNOWN (0)
+23:23:47.392: [AMF Encoder] [EngineType] EngineType (Type: Int64, Index 1)
+23:23:47.392: [AMF Encoder] Content Type: 0
+23:23:47.392: [AMF Encoder] Access: RW
+23:23:47.392: [AMF Encoder] Values:
+23:23:47.393: [AMF Encoder] Current: 0
+23:23:47.393: [AMF Encoder] Default: 0
+23:23:47.393: [AMF Encoder] Minimum: Empty
+23:23:47.393: [AMF Encoder] Maximum: Empty
+23:23:47.393: [AMF Encoder] Enumeration: 
+23:23:47.393: [AMF Encoder] Auto (0)
+23:23:47.394: [AMF Encoder] DX9 (1)
+23:23:47.394: [AMF Encoder] DX11 (2)
+23:23:47.395: [AMF Encoder] XVBA (3)
+23:23:47.395: [AMF Encoder] [Usage] Usage (Type: Int64, Index 2)
+23:23:47.395: [AMF Encoder] Content Type: 0
+23:23:47.395: [AMF Encoder] Access: RW
+23:23:47.395: [AMF Encoder] Values:
+23:23:47.395: [AMF Encoder] Current: 0
+23:23:47.396: [AMF Encoder] Default: 0
+23:23:47.396: [AMF Encoder] Minimum: Empty
+23:23:47.396: [AMF Encoder] Maximum: Empty
+23:23:47.397: [AMF Encoder] Enumeration: 
+23:23:47.397: [AMF Encoder] Transcoding (0)
+23:23:47.397: [AMF Encoder] Ultra Low Latency (1)
+23:23:47.397: [AMF Encoder] Low Latency (2)
+23:23:47.397: [AMF Encoder] Webcam (3)
+23:23:47.398: [AMF Encoder] [FrameSize] Width (Type: Size, Index 3)
+23:23:47.398: [AMF Encoder] Content Type: 0
+23:23:47.398: [AMF Encoder] Access: RWX
+23:23:47.398: [AMF Encoder] Values:
+23:23:47.398: [AMF Encoder] Current: 1920x1080
+23:23:47.398: [AMF Encoder] Default: 1920x1080
+23:23:47.398: [AMF Encoder] Minimum: 64x64
+23:23:47.398: [AMF Encoder] Maximum: 4096x2160
+23:23:47.399: [AMF Encoder] [Profile] Profile (Type: Int64, Index 4)
+23:23:47.399: [AMF Encoder] Content Type: 0
+23:23:47.399: [AMF Encoder] Access: RWX
+23:23:47.400: [AMF Encoder] Values:
+23:23:47.400: [AMF Encoder] Current: 77
+23:23:47.400: [AMF Encoder] Default: 77
+23:23:47.401: [AMF Encoder] Minimum: Empty
+23:23:47.401: [AMF Encoder] Maximum: Empty
+23:23:47.401: [AMF Encoder] Enumeration: 
+23:23:47.401: [AMF Encoder] Contrained Base (256)
+23:23:47.401: [AMF Encoder] Baseline (66)
+23:23:47.401: [AMF Encoder] Main (77)
+23:23:47.401: [AMF Encoder] Contrained High (257)
+23:23:47.402: [AMF Encoder] High (100)
+23:23:47.402: [AMF Encoder] [ProfileLevel] Profile-Level (Type: Int64, Index 5)
+23:23:47.402: [AMF Encoder] Content Type: 0
+23:23:47.402: [AMF Encoder] Access: RW
+23:23:47.402: [AMF Encoder] Values:
+23:23:47.402: [AMF Encoder] Current: 42
+23:23:47.402: [AMF Encoder] Default: 42
+23:23:47.402: [AMF Encoder] Minimum: Empty
+23:23:47.403: [AMF Encoder] Maximum: Empty
+23:23:47.403: [AMF Encoder] Enumeration: 
+23:23:47.403: [AMF Encoder] 1 (10)
+23:23:47.403: [AMF Encoder] 1.1 (11)
+23:23:47.403: [AMF Encoder] 1.2 (12)
+23:23:47.403: [AMF Encoder] 1.3 (13)
+23:23:47.404: [AMF Encoder] 2 (20)
+23:23:47.404: [AMF Encoder] 2.1 (21)
+23:23:47.404: [AMF Encoder] 2.2 (22)
+23:23:47.404: [AMF Encoder] 3 (30)
+23:23:47.404: [AMF Encoder] 3.1 (31)
+23:23:47.404: [AMF Encoder] 3.2 (32)
+23:23:47.404: [AMF Encoder] 4 (40)
+23:23:47.404: [AMF Encoder] 4.1 (41)
+23:23:47.405: [AMF Encoder] 4.2 (42)
+23:23:47.405: [AMF Encoder] 5.0 (50)
+23:23:47.405: [AMF Encoder] 5.1 (51)
+23:23:47.405: [AMF Encoder] 5.2 (52)
+23:23:47.405: [AMF Encoder] [QualityEnhancementMode] Quality Enhancement Mode (Type: Int64, Index 6)
+23:23:47.405: [AMF Encoder] Content Type: 0
+23:23:47.405: [AMF Encoder] Access: 
+23:23:47.405: [AMF Encoder] Values:
+23:23:47.406: [AMF Encoder] Current: Empty
+23:23:47.406: [AMF Encoder] Default: 0
+23:23:47.406: [AMF Encoder] Minimum: Empty
+23:23:47.406: [AMF Encoder] Maximum: Empty
+23:23:47.409: [AMF Encoder] Enumeration: 
+23:23:47.410: [AMF Encoder] Disable (0)
+23:23:47.410: [AMF Encoder] CGS (1)
+23:23:47.410: [AMF Encoder] CGS Rewrite (2)
+23:23:47.411: [AMF Encoder] MGS (3)
+23:23:47.411: [AMF Encoder] [MaxOfLTRFrames] Max Of LTR (Type: Int64, Index 7)
+23:23:47.411: [AMF Encoder] Content Type: 0
+23:23:47.412: [AMF Encoder] Access: RWX
+23:23:47.412: [AMF Encoder] Values:
+23:23:47.412: [AMF Encoder] Current: 0
+23:23:47.412: [AMF Encoder] Default: 0
+23:23:47.413: [AMF Encoder] Minimum: 0
+23:23:47.414: [AMF Encoder] Maximum: 2
+23:23:47.415: [AMF Encoder] [MaxNumRefFrames] MaxNumRefFrames (Type: Int64, Index 8)
+23:23:47.415: [AMF Encoder] Content Type: 0
+23:23:47.416: [AMF Encoder] Access: RWX
+23:23:47.416: [AMF Encoder] Values:
+23:23:47.417: [AMF Encoder] Current: 4
+23:23:47.418: [AMF Encoder] Default: 4
+23:23:47.418: [AMF Encoder] Minimum: 1
+23:23:47.419: [AMF Encoder] Maximum: 16
+23:23:47.419: [AMF Encoder] [ConstraintSetFlags] ConstraintSetFlags (Type: Int64, Index 9)
+23:23:47.419: [AMF Encoder] Content Type: 0
+23:23:47.419: [AMF Encoder] Access: RW
+23:23:47.420: [AMF Encoder] Values:
+23:23:47.420: [AMF Encoder] Current: 0
+23:23:47.420: [AMF Encoder] Default: 0
+23:23:47.420: [AMF Encoder] Minimum: 0
+23:23:47.420: [AMF Encoder] Maximum: 255
+23:23:47.420: [AMF Encoder] [MaxMBPerSec] MaxMBPerSec (Type: Int64, Index 10)
+23:23:47.421: [AMF Encoder] Content Type: 0
+23:23:47.421: [AMF Encoder] Access: R
+23:23:47.421: [AMF Encoder] Values:
+23:23:47.421: [AMF Encoder] Current: 638704
+23:23:47.421: [AMF Encoder] Default: 638704
+23:23:47.421: [AMF Encoder] Minimum: 0
+23:23:47.421: [AMF Encoder] Maximum: 2147483647
+23:23:47.421: [AMF Encoder] [InstanceID] InstanceID (Type: Int64, Index 11)
+23:23:47.421: [AMF Encoder] Content Type: 0
+23:23:47.422: [AMF Encoder] Access: RW
+23:23:47.422: [AMF Encoder] Values:
+23:23:47.422: [AMF Encoder] Current: -1
+23:23:47.422: [AMF Encoder] Default: -1
+23:23:47.422: [AMF Encoder] Minimum: -1
+23:23:47.422: [AMF Encoder] Maximum: 15
+23:23:47.422: [AMF Encoder] [TargetBitrate] Bitrate (Type: Int64, Index 12)
+23:23:47.422: [AMF Encoder] Content Type: 0
+23:23:47.423: [AMF Encoder] Access: RWX
+23:23:47.423: [AMF Encoder] Values:
+23:23:47.423: [AMF Encoder] Current: 20000000
+23:23:47.423: [AMF Encoder] Default: 20000000
+23:23:47.423: [AMF Encoder] Minimum: 10000
+23:23:47.423: [AMF Encoder] Maximum: 100000000
+23:23:47.423: [AMF Encoder] [PeakBitrate] Peak Bitrate (Type: Int64, Index 13)
+23:23:47.423: [AMF Encoder] Content Type: 0
+23:23:47.424: [AMF Encoder] Access: RWX
+23:23:47.424: [AMF Encoder] Values:
+23:23:47.424: [AMF Encoder] Current: 20000000
+23:23:47.424: [AMF Encoder] Default: 20000000
+23:23:47.424: [AMF Encoder] Minimum: 10000
+23:23:47.424: [AMF Encoder] Maximum: 100000000
+23:23:47.424: [AMF Encoder] [RateControlMethod] Rate Control Method (Type: Int64, Index 14)
+23:23:47.424: [AMF Encoder] Content Type: 0
+23:23:47.424: [AMF Encoder] Access: RWX
+23:23:47.425: [AMF Encoder] Values:
+23:23:47.425: [AMF Encoder] Current: 2
+23:23:47.425: [AMF Encoder] Default: 2
+23:23:47.425: [AMF Encoder] Minimum: Empty
+23:23:47.425: [AMF Encoder] Maximum: Empty
+23:23:47.425: [AMF Encoder] Enumeration: 
+23:23:47.425: [AMF Encoder] Constant QP (0)
+23:23:47.425: [AMF Encoder] CBR (1)
+23:23:47.425: [AMF Encoder] Peak constrained VBR (2)
+23:23:47.425: [AMF Encoder] Latency constrained VBR (3)
+23:23:47.425: [AMF Encoder] [EanbleVBAQ] Eanble VBAQ (Type: Boolean, Index 15)
+23:23:47.426: [AMF Encoder] Content Type: 0
+23:23:47.426: [AMF Encoder] Access: RWX
+23:23:47.426: [AMF Encoder] Values:
+23:23:47.426: [AMF Encoder] Current: false
+23:23:47.426: [AMF Encoder] Default: false
+23:23:47.426: [AMF Encoder] Minimum: Empty
+23:23:47.426: [AMF Encoder] Maximum: Empty
+23:23:47.426: [AMF Encoder] [RateControlPreanalysisEnable] Rate Control Preanalysis Enable (Type: Boolean, Index 16)
+23:23:47.427: [AMF Encoder] Content Type: 0
+23:23:47.427: [AMF Encoder] Access: RWX
+23:23:47.427: [AMF Encoder] Values:
+23:23:47.427: [AMF Encoder] Current: false
+23:23:47.427: [AMF Encoder] Default: false
+23:23:47.427: [AMF Encoder] Minimum: Empty
+23:23:47.427: [AMF Encoder] Maximum: Empty
+23:23:47.428: [AMF Encoder] [RateControlSkipFrameEnable] Rate Control Based Frame Skip (Type: Boolean, Index 17)
+23:23:47.428: [AMF Encoder] Content Type: 0
+23:23:47.428: [AMF Encoder] Access: RWX
+23:23:47.428: [AMF Encoder] Values:
+23:23:47.428: [AMF Encoder] Current: false
+23:23:47.429: [AMF Encoder] Default: false
+23:23:47.429: [AMF Encoder] Minimum: Empty
+23:23:47.429: [AMF Encoder] Maximum: Empty
+23:23:47.429: [AMF Encoder] [MinQP] Min QP (Type: Int64, Index 18)
+23:23:47.429: [AMF Encoder] Content Type: 0
+23:23:47.429: [AMF Encoder] Access: RWX
+23:23:47.430: [AMF Encoder] Values:
+23:23:47.430: [AMF Encoder] Current: 18
+23:23:47.430: [AMF Encoder] Default: 18
+23:23:47.430: [AMF Encoder] Minimum: 0
+23:23:47.430: [AMF Encoder] Maximum: 51
+23:23:47.430: [AMF Encoder] [MaxQP] Max QP (Type: Int64, Index 19)
+23:23:47.430: [AMF Encoder] Content Type: 0
+23:23:47.430: [AMF Encoder] Access: RWX
+23:23:47.430: [AMF Encoder] Values:
+23:23:47.431: [AMF Encoder] Current: 51
+23:23:47.431: [AMF Encoder] Default: 51
+23:23:47.431: [AMF Encoder] Minimum: 0
+23:23:47.431: [AMF Encoder] Maximum: 51
+23:23:47.431: [AMF Encoder] [QPI] QP I (Type: Int64, Index 20)
+23:23:47.431: [AMF Encoder] Content Type: 0
+23:23:47.431: [AMF Encoder] Access: RWX
+23:23:47.431: [AMF Encoder] Values:
+23:23:47.431: [AMF Encoder] Current: 22
+23:23:47.431: [AMF Encoder] Default: 22
+23:23:47.432: [AMF Encoder] Minimum: 0
+23:23:47.432: [AMF Encoder] Maximum: 51
+23:23:47.432: [AMF Encoder] [QPP] QP P (Type: Int64, Index 21)
+23:23:47.432: [AMF Encoder] Content Type: 0
+23:23:47.432: [AMF Encoder] Access: RWX
+23:23:47.432: [AMF Encoder] Values:
+23:23:47.432: [AMF Encoder] Current: 22
+23:23:47.432: [AMF Encoder] Default: 22
+23:23:47.432: [AMF Encoder] Minimum: 0
+23:23:47.433: [AMF Encoder] Maximum: 51
+23:23:47.433: [AMF Encoder] [QPB] QP B (Type: Int64, Index 22)
+23:23:47.433: [AMF Encoder] Content Type: 0
+23:23:47.433: [AMF Encoder] Access: RWX
+23:23:47.433: [AMF Encoder] Values:
+23:23:47.433: [AMF Encoder] Current: 22
+23:23:47.433: [AMF Encoder] Default: 22
+23:23:47.433: [AMF Encoder] Minimum: 0
+23:23:47.433: [AMF Encoder] Maximum: 51
+23:23:47.434: [AMF Encoder] [GOPSize] GOP Size (Type: Int64, Index 23)
+23:23:47.434: [AMF Encoder] Content Type: 0
+23:23:47.434: [AMF Encoder] Access: RWX
+23:23:47.434: [AMF Encoder] Values:
+23:23:47.434: [AMF Encoder] Current: 0
+23:23:47.434: [AMF Encoder] Default: 0
+23:23:47.434: [AMF Encoder] Minimum: 0
+23:23:47.434: [AMF Encoder] Maximum: 2147483647
+23:23:47.434: [AMF Encoder] [FrameRate] Frame Rate (Type: Rate, Index 24)
+23:23:47.435: [AMF Encoder] Content Type: 0
+23:23:47.435: [AMF Encoder] Access: RWX
+23:23:47.435: [AMF Encoder] Values:
+23:23:47.435: [AMF Encoder] Current: 30/1
+23:23:47.435: [AMF Encoder] Default: 30/1
+23:23:47.435: [AMF Encoder] Minimum: Empty
+23:23:47.435: [AMF Encoder] Maximum: Empty
+23:23:47.435: [AMF Encoder] [AspectRatio] AspectRatio (Type: Rate, Index 25)
+23:23:47.435: [AMF Encoder] Content Type: 0
+23:23:47.436: [AMF Encoder] Access: RWX
+23:23:47.436: [AMF Encoder] Values:
+23:23:47.436: [AMF Encoder] Current: 1/1
+23:23:47.436: [AMF Encoder] Default: 1/1
+23:23:47.436: [AMF Encoder] Minimum: Empty
+23:23:47.436: [AMF Encoder] Maximum: Empty
+23:23:47.436: [AMF Encoder] [NominalRange] NominalRange (Type: Boolean, Index 26)
+23:23:47.436: [AMF Encoder] Content Type: 0
+23:23:47.436: [AMF Encoder] Access: RWX
+23:23:47.436: [AMF Encoder] Values:
+23:23:47.437: [AMF Encoder] Current: false
+23:23:47.437: [AMF Encoder] Default: false
+23:23:47.437: [AMF Encoder] Minimum: Empty
+23:23:47.438: [AMF Encoder] Maximum: Empty
+23:23:47.438: [AMF Encoder] [VBVBufferSize] VBV Buffer Size (Type: Int64, Index 27)
+23:23:47.438: [AMF Encoder] Content Type: 0
+23:23:47.438: [AMF Encoder] Access: RWX
+23:23:47.438: [AMF Encoder] Values:
+23:23:47.438: [AMF Encoder] Current: 20000000
+23:23:47.438: [AMF Encoder] Default: 20000000
+23:23:47.439: [AMF Encoder] Minimum: 1000
+23:23:47.439: [AMF Encoder] Maximum: 100000000
+23:23:47.439: [AMF Encoder] [InitialVBVBufferFullness] Initial VBV Buffer Fullness (Type: Int64, Index 28)
+23:23:47.439: [AMF Encoder] Content Type: 0
+23:23:47.439: [AMF Encoder] Access: RWX
+23:23:47.439: [AMF Encoder] Values:
+23:23:47.440: [AMF Encoder] Current: 64
+23:23:47.440: [AMF Encoder] Default: 64
+23:23:47.440: [AMF Encoder] Minimum: 0
+23:23:47.440: [AMF Encoder] Maximum: 64
+23:23:47.440: [AMF Encoder] [EnforceHRD] Enforce HRD (Type: Boolean, Index 29)
+23:23:47.440: [AMF Encoder] Content Type: 0
+23:23:47.440: [AMF Encoder] Access: RWX
+23:23:47.440: [AMF Encoder] Values:
+23:23:47.441: [AMF Encoder] Current: false
+23:23:47.441: [AMF Encoder] Default: false
+23:23:47.441: [AMF Encoder] Minimum: Empty
+23:23:47.441: [AMF Encoder] Maximum: Empty
+23:23:47.441: [AMF Encoder] [MaxAUSize] Max AU Size (Type: Int64, Index 30)
+23:23:47.441: [AMF Encoder] Content Type: 0
+23:23:47.441: [AMF Encoder] Access: RWX
+23:23:47.441: [AMF Encoder] Values:
+23:23:47.441: [AMF Encoder] Current: 0
+23:23:47.441: [AMF Encoder] Default: 0
+23:23:47.442: [AMF Encoder] Minimum: 0
+23:23:47.442: [AMF Encoder] Maximum: 100000000
+23:23:47.442: [AMF Encoder] [FillerDataEnable] Filler Data Enable (Type: Boolean, Index 31)
+23:23:47.442: [AMF Encoder] Content Type: 0
+23:23:47.442: [AMF Encoder] Access: RWX
+23:23:47.442: [AMF Encoder] Values:
+23:23:47.442: [AMF Encoder] Current: false
+23:23:47.442: [AMF Encoder] Default: false
+23:23:47.442: [AMF Encoder] Minimum: Empty
+23:23:47.442: [AMF Encoder] Maximum: Empty
+23:23:47.443: [AMF Encoder] [BPicturesDeltaQP] B-picture Delta (Type: Int64, Index 32)
+23:23:47.443: [AMF Encoder] Content Type: 0
+23:23:47.443: [AMF Encoder] Access: RWX
+23:23:47.443: [AMF Encoder] Values:
+23:23:47.443: [AMF Encoder] Current: 4
+23:23:47.443: [AMF Encoder] Default: 4
+23:23:47.443: [AMF Encoder] Minimum: -10
+23:23:47.443: [AMF Encoder] Maximum: 10
+23:23:47.443: [AMF Encoder] [ReferenceBPicturesDeltaQP] Reference B-picture Delta (Type: Int64, Index 33)
+23:23:47.443: [AMF Encoder] Content Type: 0
+23:23:47.444: [AMF Encoder] Access: RWX
+23:23:47.444: [AMF Encoder] Values:
+23:23:47.444: [AMF Encoder] Current: 2
+23:23:47.444: [AMF Encoder] Default: 2
+23:23:47.444: [AMF Encoder] Minimum: -10
+23:23:47.444: [AMF Encoder] Maximum: 10
+23:23:47.444: [AMF Encoder] [HeaderInsertionSpacing] Header Insertion Spacing (Type: Int64, Index 34)
+23:23:47.444: [AMF Encoder] Content Type: 0
+23:23:47.445: [AMF Encoder] Access: RWX
+23:23:47.445: [AMF Encoder] Values:
+23:23:47.445: [AMF Encoder] Current: 0
+23:23:47.445: [AMF Encoder] Default: 0
+23:23:47.445: [AMF Encoder] Minimum: 0
+23:23:47.445: [AMF Encoder] Maximum: 2147483647
+23:23:47.445: [AMF Encoder] [IDRPeriod] IDR Period (Type: Int64, Index 35)
+23:23:47.445: [AMF Encoder] Content Type: 0
+23:23:47.446: [AMF Encoder] Access: RWX
+23:23:47.446: [AMF Encoder] Values:
+23:23:47.446: [AMF Encoder] Current: 30
+23:23:47.446: [AMF Encoder] Default: 30
+23:23:47.446: [AMF Encoder] Minimum: 0
+23:23:47.446: [AMF Encoder] Maximum: 2147483647
+23:23:47.446: [AMF Encoder] [DeBlockingFilter] De-blocking Filter (Type: Boolean, Index 36)
+23:23:47.446: [AMF Encoder] Content Type: 0
+23:23:47.446: [AMF Encoder] Access: RWX
+23:23:47.447: [AMF Encoder] Values:
+23:23:47.447: [AMF Encoder] Current: true
+23:23:47.447: [AMF Encoder] Default: true
+23:23:47.447: [AMF Encoder] Minimum: Empty
+23:23:47.447: [AMF Encoder] Maximum: Empty
+23:23:47.447: [AMF Encoder] [IntraRefreshMBsNumberPerSlot] Intra Refresh MBs Number Per Slot (Type: Int64, Index 37)
+23:23:47.447: [AMF Encoder] Content Type: 0
+23:23:47.447: [AMF Encoder] Access: RWX
+23:23:47.447: [AMF Encoder] Values:
+23:23:47.448: [AMF Encoder] Current: 0
+23:23:47.448: [AMF Encoder] Default: 0
+23:23:47.448: [AMF Encoder] Minimum: 0
+23:23:47.448: [AMF Encoder] Maximum: 8160
+23:23:47.448: [AMF Encoder] [IntraRefreshNumOfStripes] IntraRefreshNumOfStripes (Type: Int64, Index 38)
+23:23:47.448: [AMF Encoder] Content Type: 0
+23:23:47.448: [AMF Encoder] Access: RWX
+23:23:47.448: [AMF Encoder] Values:
+23:23:47.448: [AMF Encoder] Current: 0
+23:23:47.448: [AMF Encoder] Default: 0
+23:23:47.448: [AMF Encoder] Minimum: 0
+23:23:47.449: [AMF Encoder] Maximum: 2147483647
+23:23:47.449: [AMF Encoder] [SliceMode] Slice Mode (Type: Int64, Index 39)
+23:23:47.449: [AMF Encoder] Content Type: 0
+23:23:47.449: [AMF Encoder] Access: RWX
+23:23:47.449: [AMF Encoder] Values:
+23:23:47.449: [AMF Encoder] Current: 1
+23:23:47.449: [AMF Encoder] Default: 1
+23:23:47.450: [AMF Encoder] Minimum: 1
+23:23:47.450: [AMF Encoder] Maximum: 2
+23:23:47.450: [AMF Encoder] [SlicesPerFrame] Slices Per Frame (Type: Int64, Index 40)
+23:23:47.450: [AMF Encoder] Content Type: 0
+23:23:47.450: [AMF Encoder] Access: RWX
+23:23:47.450: [AMF Encoder] Values:
+23:23:47.450: [AMF Encoder] Current: 1
+23:23:47.450: [AMF Encoder] Default: 1
+23:23:47.451: [AMF Encoder] Minimum: 1
+23:23:47.451: [AMF Encoder] Maximum: 8160
+23:23:47.451: [AMF Encoder] [MaxSliceSize] Max Slice Size (Type: Int64, Index 41)
+23:23:47.451: [AMF Encoder] Content Type: 0
+23:23:47.451: [AMF Encoder] Access: RWX
+23:23:47.451: [AMF Encoder] Values:
+23:23:47.451: [AMF Encoder] Current: 2147483647
+23:23:47.451: [AMF Encoder] Default: 2147483647
+23:23:47.452: [AMF Encoder] Minimum: 1
+23:23:47.452: [AMF Encoder] Maximum: 2147483647
+23:23:47.452: [AMF Encoder] [BPicturesPattern] B-picture Pattern (Type: Int64, Index 42)
+23:23:47.452: [AMF Encoder] Content Type: 0
+23:23:47.452: [AMF Encoder] Access: RWX
+23:23:47.452: [AMF Encoder] Values:
+23:23:47.452: [AMF Encoder] Current: 3
+23:23:47.452: [AMF Encoder] Default: 3
+23:23:47.453: [AMF Encoder] Minimum: 0
+23:23:47.453: [AMF Encoder] Maximum: 3
+23:23:47.454: [AMF Encoder] [BReferenceEnable] Enable B Refrence (Type: Boolean, Index 43)
+23:23:47.454: [AMF Encoder] Content Type: 0
+23:23:47.454: [AMF Encoder] Access: RWX
+23:23:47.454: [AMF Encoder] Values:
+23:23:47.454: [AMF Encoder] Current: true
+23:23:47.454: [AMF Encoder] Default: true
+23:23:47.454: [AMF Encoder] Minimum: Empty
+23:23:47.454: [AMF Encoder] Maximum: Empty
+23:23:47.454: [AMF Encoder] [LowLatencyInternal] LowLatencyInternal (Type: Boolean, Index 44)
+23:23:47.454: [AMF Encoder] Content Type: 0
+23:23:47.454: [AMF Encoder] Access: RWX
+23:23:47.455: [AMF Encoder] Values:
+23:23:47.455: [AMF Encoder] Current: false
+23:23:47.455: [AMF Encoder] Default: false
+23:23:47.455: [AMF Encoder] Minimum: Empty
+23:23:47.455: [AMF Encoder] Maximum: Empty
+23:23:47.455: [AMF Encoder] [CommonLowLatencyInternal] CommonLowLatencyInternal (Type: Boolean, Index 45)
+23:23:47.455: [AMF Encoder] Content Type: 0
+23:23:47.455: [AMF Encoder] Access: RWX
+23:23:47.455: [AMF Encoder] Values:
+23:23:47.455: [AMF Encoder] Current: false
+23:23:47.456: [AMF Encoder] Default: false
+23:23:47.456: [AMF Encoder] Minimum: Empty
+23:23:47.456: [AMF Encoder] Maximum: Empty
+23:23:47.456: [AMF Encoder] [EnableGOPAlignment] EnableGOPAlignment (Type: Boolean, Index 46)
+23:23:47.456: [AMF Encoder] Content Type: 0
+23:23:47.456: [AMF Encoder] Access: RWX
+23:23:47.456: [AMF Encoder] Values:
+23:23:47.456: [AMF Encoder] Current: true
+23:23:47.457: [AMF Encoder] Default: true
+23:23:47.457: [AMF Encoder] Minimum: Empty
+23:23:47.457: [AMF Encoder] Maximum: Empty
+23:23:47.457: [AMF Encoder] [SliceControlMode] SliceControlMode (Type: Int64, Index 47)
+23:23:47.457: [AMF Encoder] Content Type: 0
+23:23:47.457: [AMF Encoder] Access: RWX
+23:23:47.457: [AMF Encoder] Values:
+23:23:47.457: [AMF Encoder] Current: 0
+23:23:47.457: [AMF Encoder] Default: 0
+23:23:47.457: [AMF Encoder] Minimum: 0
+23:23:47.457: [AMF Encoder] Maximum: 3
+23:23:47.458: [AMF Encoder] [SliceControlSize] SliceControlSize (Type: Int64, Index 48)
+23:23:47.458: [AMF Encoder] Content Type: 0
+23:23:47.458: [AMF Encoder] Access: RWX
+23:23:47.458: [AMF Encoder] Values:
+23:23:47.458: [AMF Encoder] Current: 0
+23:23:47.458: [AMF Encoder] Default: 0
+23:23:47.458: [AMF Encoder] Minimum: 0
+23:23:47.458: [AMF Encoder] Maximum: 2147483647
+23:23:47.458: [AMF Encoder] [CABACEnable] CABACEnable (Type: Int64, Index 49)
+23:23:47.458: [AMF Encoder] Content Type: 0
+23:23:47.459: [AMF Encoder] Access: RWX
+23:23:47.459: [AMF Encoder] Values:
+23:23:47.459: [AMF Encoder] Current: 0
+23:23:47.459: [AMF Encoder] Default: 0
+23:23:47.459: [AMF Encoder] Minimum: Empty
+23:23:47.459: [AMF Encoder] Maximum: Empty
+23:23:47.459: [AMF Encoder] Enumeration: 
+23:23:47.459: [AMF Encoder] Undefined (0)
+23:23:47.460: [AMF Encoder] Cabac (1)
+23:23:47.460: [AMF Encoder] Calv (2)
+23:23:47.460: [AMF Encoder] [ScanType] Scan Type (Type: Int64, Index 50)
+23:23:47.460: [AMF Encoder] Content Type: 0
+23:23:47.460: [AMF Encoder] Access: RWX
+23:23:47.460: [AMF Encoder] Values:
+23:23:47.460: [AMF Encoder] Current: 0
+23:23:47.460: [AMF Encoder] Default: 0
+23:23:47.460: [AMF Encoder] Minimum: Empty
+23:23:47.461: [AMF Encoder] Maximum: Empty
+23:23:47.461: [AMF Encoder] Enumeration: 
+23:23:47.461: [AMF Encoder] Progressive (0)
+23:23:47.461: [AMF Encoder] Interlaced (1)
+23:23:47.461: [AMF Encoder] [QualityPreset] Quality Preset (Type: Int64, Index 51)
+23:23:47.461: [AMF Encoder] Content Type: 0
+23:23:47.461: [AMF Encoder] Access: RWX
+23:23:47.461: [AMF Encoder] Values:
+23:23:47.461: [AMF Encoder] Current: 0
+23:23:47.461: [AMF Encoder] Default: 0
+23:23:47.461: [AMF Encoder] Minimum: Empty
+23:23:47.462: [AMF Encoder] Maximum: Empty
+23:23:47.462: [AMF Encoder] Enumeration: 
+23:23:47.462: [AMF Encoder] Balanced (0)
+23:23:47.462: [AMF Encoder] Speed (1)
+23:23:47.462: [AMF Encoder] Quality (2)
+23:23:47.462: [AMF Encoder] [HalfPixel] Half Pixel (Type: Boolean, Index 52)
+23:23:47.462: [AMF Encoder] Content Type: 0
+23:23:47.462: [AMF Encoder] Access: RWX
+23:23:47.462: [AMF Encoder] Values:
+23:23:47.462: [AMF Encoder] Current: true
+23:23:47.463: [AMF Encoder] Default: true
+23:23:47.463: [AMF Encoder] Minimum: Empty
+23:23:47.463: [AMF Encoder] Maximum: Empty
+23:23:47.463: [AMF Encoder] [QuarterPixel] Quarter Pixel (Type: Boolean, Index 53)
+23:23:47.463: [AMF Encoder] Content Type: 0
+23:23:47.463: [AMF Encoder] Access: RWX
+23:23:47.463: [AMF Encoder] Values:
+23:23:47.463: [AMF Encoder] Current: true
+23:23:47.463: [AMF Encoder] Default: true
+23:23:47.464: [AMF Encoder] Minimum: Empty
+23:23:47.464: [AMF Encoder] Maximum: Empty
+23:23:47.464: [AMF Encoder] [ExtraData] ExtraData (Type: Interface, Index 54)
+23:23:47.464: [AMF Encoder] Content Type: 0
+23:23:47.464: [AMF Encoder] Access: RWX
+23:23:47.464: [AMF Encoder] Values:
+23:23:47.465: [AMF Encoder] 
+23:23:47.465: [AMF Encoder] Default: Empty
+23:23:47.465: [AMF Encoder] Minimum: Empty
+23:23:47.465: [AMF Encoder] Maximum: ''
+23:23:47.465: [AMF Encoder] [UniqueInstance] Unique Instance (Type: Int64, Index 55)
+23:23:47.466: [AMF Encoder] Content Type: 0
+23:23:47.466: [AMF Encoder] Access: RWX
+23:23:47.466: [AMF Encoder] Values:
+23:23:47.466: [AMF Encoder] Current: 0
+23:23:47.466: [AMF Encoder] Default: 0
+23:23:47.466: [AMF Encoder] Minimum: 0
+23:23:47.466: [AMF Encoder] Maximum: 2147483647
+23:23:47.466: [AMF Encoder] [EncoderMaxInstances] EncoderMaxInstances (Type: Int64, Index 56)
+23:23:47.466: [AMF Encoder] Content Type: 0
+23:23:47.466: [AMF Encoder] Access: RWX
+23:23:47.467: [AMF Encoder] Values:
+23:23:47.467: [AMF Encoder] Current: 1
+23:23:47.467: [AMF Encoder] Default: 1
+23:23:47.467: [AMF Encoder] Minimum: 1
+23:23:47.467: [AMF Encoder] Maximum: 2
+23:23:47.467: [AMF Encoder] [MultiInstanceMode] MultiInstanceMode (Type: Boolean, Index 57)
+23:23:47.467: [AMF Encoder] Content Type: 0
+23:23:47.467: [AMF Encoder] Access: RWX
+23:23:47.467: [AMF Encoder] Values:
+23:23:47.467: [AMF Encoder] Current: false
+23:23:47.467: [AMF Encoder] Default: false
+23:23:47.468: [AMF Encoder] Minimum: Empty
+23:23:47.468: [AMF Encoder] Maximum: Empty
+23:23:47.468: [AMF Encoder] [MultiInstanceCurrentQueue] MultiInstanceCurrentQueue (Type: Int64, Index 58)
+23:23:47.468: [AMF Encoder] Content Type: 0
+23:23:47.468: [AMF Encoder] Access: RWX
+23:23:47.468: [AMF Encoder] Values:
+23:23:47.468: [AMF Encoder] Current: 0
+23:23:47.468: [AMF Encoder] Default: 0
+23:23:47.468: [AMF Encoder] Minimum: 0
+23:23:47.468: [AMF Encoder] Maximum: 1
+23:23:47.468: [AMF Encoder] [WaitForTask] WaitForTask (Type: Boolean, Index 59)
+23:23:47.469: [AMF Encoder] Content Type: 0
+23:23:47.469: [AMF Encoder] Access: RWX
+23:23:47.469: [AMF Encoder] Values:
+23:23:47.469: [AMF Encoder] Current: false
+23:23:47.469: [AMF Encoder] Default: false
+23:23:47.469: [AMF Encoder] Minimum: Empty
+23:23:47.470: [AMF Encoder] Maximum: Empty
+23:23:47.470: [AMF Encoder] [TL0.QL0.BPicturesDeltaQP] TL0.QL0 B-picture Delta (Type: Int64, Index 60)
+23:23:47.470: [AMF Encoder] Content Type: 0
+23:23:47.470: [AMF Encoder] Access: 
+23:23:47.470: [AMF Encoder] Values:
+23:23:47.470: [AMF Encoder] Current: Empty
+23:23:47.470: [AMF Encoder] Default: 4
+23:23:47.470: [AMF Encoder] Minimum: -10
+23:23:47.471: [AMF Encoder] Maximum: 10
+23:23:47.471: [AMF Encoder] [TL1.QL0.BPicturesDeltaQP] TL1.QL0 B-picture Delta (Type: Int64, Index 61)
+23:23:47.471: [AMF Encoder] Content Type: 0
+23:23:47.471: [AMF Encoder] Access: 
+23:23:47.471: [AMF Encoder] Values:
+23:23:47.471: [AMF Encoder] Current: Empty
+23:23:47.471: [AMF Encoder] Default: 4
+23:23:47.471: [AMF Encoder] Minimum: -10
+23:23:47.471: [AMF Encoder] Maximum: 10
+23:23:47.472: [AMF Encoder] [TL2.QL0.BPicturesDeltaQP] TL2.QL0 B-picture Delta (Type: Int64, Index 62)
+23:23:47.472: [AMF Encoder] Content Type: 0
+23:23:47.472: [AMF Encoder] Access: 
+23:23:47.472: [AMF Encoder] Values:
+23:23:47.472: [AMF Encoder] Current: Empty
+23:23:47.472: [AMF Encoder] Default: 4
+23:23:47.473: [AMF Encoder] Minimum: -10
+23:23:47.473: [AMF Encoder] Maximum: 10
+23:23:47.473: [AMF Encoder] [TL3.QL0.BPicturesDeltaQP] TL3.QL0 B-picture Delta (Type: Int64, Index 63)
+23:23:47.474: [AMF Encoder] Content Type: 0
+23:23:47.474: [AMF Encoder] Access: 
+23:23:47.474: [AMF Encoder] Values:
+23:23:47.474: [AMF Encoder] Current: Empty
+23:23:47.474: [AMF Encoder] Default: 4
+23:23:47.475: [AMF Encoder] Minimum: -10
+23:23:47.475: [AMF Encoder] Maximum: 10
+23:23:47.475: [AMF Encoder] [TL0.QL0.EanbleVBAQ] TL0.QL0 Eanble VBAQ (Type: Boolean, Index 64)
+23:23:47.475: [AMF Encoder] Content Type: 0
+23:23:47.475: [AMF Encoder] Access: 
+23:23:47.475: [AMF Encoder] Values:
+23:23:47.475: [AMF Encoder] Current: Empty
+23:23:47.475: [AMF Encoder] Default: false
+23:23:47.475: [AMF Encoder] Minimum: Empty
+23:23:47.476: [AMF Encoder] Maximum: Empty
+23:23:47.476: [AMF Encoder] [TL1.QL0.EanbleVBAQ] TL1.QL0 Eanble VBAQ (Type: Boolean, Index 65)
+23:23:47.476: [AMF Encoder] Content Type: 0
+23:23:47.476: [AMF Encoder] Access: 
+23:23:47.476: [AMF Encoder] Values:
+23:23:47.476: [AMF Encoder] Current: Empty
+23:23:47.476: [AMF Encoder] Default: false
+23:23:47.476: [AMF Encoder] Minimum: Empty
+23:23:47.476: [AMF Encoder] Maximum: Empty
+23:23:47.477: [AMF Encoder] [TL2.QL0.EanbleVBAQ] TL2.QL0 Eanble VBAQ (Type: Boolean, Index 66)
+23:23:47.477: [AMF Encoder] Content Type: 0
+23:23:47.477: [AMF Encoder] Access: 
+23:23:47.477: [AMF Encoder] Values:
+23:23:47.477: [AMF Encoder] Current: Empty
+23:23:47.477: [AMF Encoder] Default: false
+23:23:47.477: [AMF Encoder] Minimum: Empty
+23:23:47.477: [AMF Encoder] Maximum: Empty
+23:23:47.477: [AMF Encoder] [TL3.QL0.EanbleVBAQ] TL3.QL0 Eanble VBAQ (Type: Boolean, Index 67)
+23:23:47.477: [AMF Encoder] Content Type: 0
+23:23:47.477: [AMF Encoder] Access: 
+23:23:47.477: [AMF Encoder] Values:
+23:23:47.477: [AMF Encoder] Current: Empty
+23:23:47.478: [AMF Encoder] Default: false
+23:23:47.478: [AMF Encoder] Minimum: Empty
+23:23:47.478: [AMF Encoder] Maximum: Empty
+23:23:47.478: [AMF Encoder] [TL0.QL0.EnforceHRD] TL0.QL0 Enforce HRD (Type: Boolean, Index 68)
+23:23:47.478: [AMF Encoder] Content Type: 0
+23:23:47.478: [AMF Encoder] Access: 
+23:23:47.478: [AMF Encoder] Values:
+23:23:47.478: [AMF Encoder] Current: Empty
+23:23:47.478: [AMF Encoder] Default: true
+23:23:47.478: [AMF Encoder] Minimum: Empty
+23:23:47.478: [AMF Encoder] Maximum: Empty
+23:23:47.478: [AMF Encoder] [TL1.QL0.EnforceHRD] TL1.QL0 Enforce HRD (Type: Boolean, Index 69)
+23:23:47.479: [AMF Encoder] Content Type: 0
+23:23:47.479: [AMF Encoder] Access: 
+23:23:47.479: [AMF Encoder] Values:
+23:23:47.479: [AMF Encoder] Current: Empty
+23:23:47.479: [AMF Encoder] Default: true
+23:23:47.479: [AMF Encoder] Minimum: Empty
+23:23:47.479: [AMF Encoder] Maximum: Empty
+23:23:47.479: [AMF Encoder] [TL2.QL0.EnforceHRD] TL2.QL0 Enforce HRD (Type: Boolean, Index 70)
+23:23:47.479: [AMF Encoder] Content Type: 0
+23:23:47.479: [AMF Encoder] Access: 
+23:23:47.479: [AMF Encoder] Values:
+23:23:47.479: [AMF Encoder] Current: Empty
+23:23:47.480: [AMF Encoder] Default: true
+23:23:47.480: [AMF Encoder] Minimum: Empty
+23:23:47.480: [AMF Encoder] Maximum: Empty
+23:23:47.480: [AMF Encoder] [TL3.QL0.EnforceHRD] TL3.QL0 Enforce HRD (Type: Boolean, Index 71)
+23:23:47.480: [AMF Encoder] Content Type: 0
+23:23:47.480: [AMF Encoder] Access: 
+23:23:47.480: [AMF Encoder] Values:
+23:23:47.480: [AMF Encoder] Current: Empty
+23:23:47.480: [AMF Encoder] Default: true
+23:23:47.480: [AMF Encoder] Minimum: Empty
+23:23:47.480: [AMF Encoder] Maximum: Empty
+23:23:47.481: [AMF Encoder] [TL0.QL0.FillerDataEnable] TL0.QL0 Filler Data Enable (Type: Boolean, Index 72)
+23:23:47.481: [AMF Encoder] Content Type: 0
+23:23:47.481: [AMF Encoder] Access: 
+23:23:47.481: [AMF Encoder] Values:
+23:23:47.481: [AMF Encoder] Current: Empty
+23:23:47.481: [AMF Encoder] Default: false
+23:23:47.481: [AMF Encoder] Minimum: Empty
+23:23:47.481: [AMF Encoder] Maximum: Empty
+23:23:47.481: [AMF Encoder] [TL1.QL0.FillerDataEnable] TL1.QL0 Filler Data Enable (Type: Boolean, Index 73)
+23:23:47.481: [AMF Encoder] Content Type: 0
+23:23:47.481: [AMF Encoder] Access: 
+23:23:47.481: [AMF Encoder] Values:
+23:23:47.482: [AMF Encoder] Current: Empty
+23:23:47.482: [AMF Encoder] Default: false
+23:23:47.482: [AMF Encoder] Minimum: Empty
+23:23:47.482: [AMF Encoder] Maximum: Empty
+23:23:47.482: [AMF Encoder] [TL2.QL0.FillerDataEnable] TL2.QL0 Filler Data Enable (Type: Boolean, Index 74)
+23:23:47.482: [AMF Encoder] Content Type: 0
+23:23:47.482: [AMF Encoder] Access: 
+23:23:47.482: [AMF Encoder] Values:
+23:23:47.482: [AMF Encoder] Current: Empty
+23:23:47.482: [AMF Encoder] Default: false
+23:23:47.482: [AMF Encoder] Minimum: Empty
+23:23:47.483: [AMF Encoder] Maximum: Empty
+23:23:47.483: [AMF Encoder] [TL3.QL0.FillerDataEnable] TL3.QL0 Filler Data Enable (Type: Boolean, Index 75)
+23:23:47.483: [AMF Encoder] Content Type: 0
+23:23:47.483: [AMF Encoder] Access: 
+23:23:47.483: [AMF Encoder] Values:
+23:23:47.483: [AMF Encoder] Current: Empty
+23:23:47.483: [AMF Encoder] Default: false
+23:23:47.483: [AMF Encoder] Minimum: Empty
+23:23:47.483: [AMF Encoder] Maximum: Empty
+23:23:47.483: [AMF Encoder] [TL0.QL0.FrameRate] TL0.QL0 Frame Rate (Type: Rate, Index 76)
+23:23:47.483: [AMF Encoder] Content Type: 0
+23:23:47.484: [AMF Encoder] Access: 
+23:23:47.484: [AMF Encoder] Values:
+23:23:47.484: [AMF Encoder] Current: Empty
+23:23:47.484: [AMF Encoder] Default: 30/1
+23:23:47.484: [AMF Encoder] Minimum: Empty
+23:23:47.484: [AMF Encoder] Maximum: Empty
+23:23:47.484: [AMF Encoder] [TL1.QL0.FrameRate] TL1.QL0 Frame Rate (Type: Rate, Index 77)
+23:23:47.485: [AMF Encoder] Content Type: 0
+23:23:47.485: [AMF Encoder] Access: 
+23:23:47.485: [AMF Encoder] Values:
+23:23:47.485: [AMF Encoder] Current: Empty
+23:23:47.485: [AMF Encoder] Default: 30/1
+23:23:47.485: [AMF Encoder] Minimum: Empty
+23:23:47.485: [AMF Encoder] Maximum: Empty
+23:23:47.485: [AMF Encoder] [TL2.QL0.FrameRate] TL2.QL0 Frame Rate (Type: Rate, Index 78)
+23:23:47.485: [AMF Encoder] Content Type: 0
+23:23:47.485: [AMF Encoder] Access: 
+23:23:47.485: [AMF Encoder] Values:
+23:23:47.485: [AMF Encoder] Current: Empty
+23:23:47.486: [AMF Encoder] Default: 30/1
+23:23:47.486: [AMF Encoder] Minimum: Empty
+23:23:47.486: [AMF Encoder] Maximum: Empty
+23:23:47.486: [AMF Encoder] [TL3.QL0.FrameRate] TL3.QL0 Frame Rate (Type: Rate, Index 79)
+23:23:47.486: [AMF Encoder] Content Type: 0
+23:23:47.486: [AMF Encoder] Access: 
+23:23:47.486: [AMF Encoder] Values:
+23:23:47.486: [AMF Encoder] Current: Empty
+23:23:47.486: [AMF Encoder] Default: 30/1
+23:23:47.486: [AMF Encoder] Minimum: Empty
+23:23:47.486: [AMF Encoder] Maximum: Empty
+23:23:47.486: [AMF Encoder] [TL0.QL0.GOPSize] TL0.QL0 GOP Size (Type: Int64, Index 80)
+23:23:47.487: [AMF Encoder] Content Type: 0
+23:23:47.487: [AMF Encoder] Access: 
+23:23:47.487: [AMF Encoder] Values:
+23:23:47.487: [AMF Encoder] Current: Empty
+23:23:47.487: [AMF Encoder] Default: 0
+23:23:47.487: [AMF Encoder] Minimum: 0
+23:23:47.487: [AMF Encoder] Maximum: 2147483647
+23:23:47.487: [AMF Encoder] [TL1.QL0.GOPSize] TL1.QL0 GOP Size (Type: Int64, Index 81)
+23:23:47.487: [AMF Encoder] Content Type: 0
+23:23:47.487: [AMF Encoder] Access: 
+23:23:47.487: [AMF Encoder] Values:
+23:23:47.487: [AMF Encoder] Current: Empty
+23:23:47.488: [AMF Encoder] Default: 0
+23:23:47.488: [AMF Encoder] Minimum: 0
+23:23:47.488: [AMF Encoder] Maximum: 2147483647
+23:23:47.488: [AMF Encoder] [TL2.QL0.GOPSize] TL2.QL0 GOP Size (Type: Int64, Index 82)
+23:23:47.488: [AMF Encoder] Content Type: 0
+23:23:47.488: [AMF Encoder] Access: 
+23:23:47.488: [AMF Encoder] Values:
+23:23:47.488: [AMF Encoder] Current: Empty
+23:23:47.488: [AMF Encoder] Default: 0
+23:23:47.488: [AMF Encoder] Minimum: 0
+23:23:47.488: [AMF Encoder] Maximum: 2147483647
+23:23:47.488: [AMF Encoder] [TL3.QL0.GOPSize] TL3.QL0 GOP Size (Type: Int64, Index 83)
+23:23:47.489: [AMF Encoder] Content Type: 0
+23:23:47.489: [AMF Encoder] Access: 
+23:23:47.489: [AMF Encoder] Values:
+23:23:47.489: [AMF Encoder] Current: Empty
+23:23:47.489: [AMF Encoder] Default: 0
+23:23:47.489: [AMF Encoder] Minimum: 0
+23:23:47.489: [AMF Encoder] Maximum: 2147483647
+23:23:47.489: [AMF Encoder] [TL0.QL0.InitialVBVBufferFullness] TL0.QL0 Initial VBV Buffer Fullness (Type: Int64, Index 84)
+23:23:47.489: [AMF Encoder] Content Type: 0
+23:23:47.489: [AMF Encoder] Access: 
+23:23:47.489: [AMF Encoder] Values:
+23:23:47.489: [AMF Encoder] Current: Empty
+23:23:47.489: [AMF Encoder] Default: 64
+23:23:47.490: [AMF Encoder] Minimum: 0
+23:23:47.490: [AMF Encoder] Maximum: 64
+23:23:47.490: [AMF Encoder] [TL1.QL0.InitialVBVBufferFullness] TL1.QL0 Initial VBV Buffer Fullness (Type: Int64, Index 85)
+23:23:47.490: [AMF Encoder] Content Type: 0
+23:23:47.490: [AMF Encoder] Access: 
+23:23:47.490: [AMF Encoder] Values:
+23:23:47.490: [AMF Encoder] Current: Empty
+23:23:47.490: [AMF Encoder] Default: 64
+23:23:47.490: [AMF Encoder] Minimum: 0
+23:23:47.490: [AMF Encoder] Maximum: 64
+23:23:47.490: [AMF Encoder] [TL2.QL0.InitialVBVBufferFullness] TL2.QL0 Initial VBV Buffer Fullness (Type: Int64, Index 86)
+23:23:47.490: [AMF Encoder] Content Type: 0
+23:23:47.491: [AMF Encoder] Access: 
+23:23:47.491: [AMF Encoder] Values:
+23:23:47.491: [AMF Encoder] Current: Empty
+23:23:47.491: [AMF Encoder] Default: 64
+23:23:47.491: [AMF Encoder] Minimum: 0
+23:23:47.491: [AMF Encoder] Maximum: 64
+23:23:47.491: [AMF Encoder] [TL3.QL0.InitialVBVBufferFullness] TL3.QL0 Initial VBV Buffer Fullness (Type: Int64, Index 87)
+23:23:47.491: [AMF Encoder] Content Type: 0
+23:23:47.491: [AMF Encoder] Access: 
+23:23:47.491: [AMF Encoder] Values:
+23:23:47.491: [AMF Encoder] Current: Empty
+23:23:47.491: [AMF Encoder] Default: 64
+23:23:47.492: [AMF Encoder] Minimum: 0
+23:23:47.492: [AMF Encoder] Maximum: 64
+23:23:47.492: [AMF Encoder] [TL0.QL0.MaxAUSize] TL0.QL0 Max AU Size (Type: Int64, Index 88)
+23:23:47.492: [AMF Encoder] Content Type: 0
+23:23:47.492: [AMF Encoder] Access: 
+23:23:47.492: [AMF Encoder] Values:
+23:23:47.492: [AMF Encoder] Current: Empty
+23:23:47.492: [AMF Encoder] Default: 0
+23:23:47.492: [AMF Encoder] Minimum: 0
+23:23:47.492: [AMF Encoder] Maximum: 100000000
+23:23:47.492: [AMF Encoder] [TL1.QL0.MaxAUSize] TL1.QL0 Max AU Size (Type: Int64, Index 89)
+23:23:47.492: [AMF Encoder] Content Type: 0
+23:23:47.493: [AMF Encoder] Access: 
+23:23:47.493: [AMF Encoder] Values:
+23:23:47.493: [AMF Encoder] Current: Empty
+23:23:47.493: [AMF Encoder] Default: 0
+23:23:47.493: [AMF Encoder] Minimum: 0
+23:23:47.493: [AMF Encoder] Maximum: 100000000
+23:23:47.493: [AMF Encoder] [TL2.QL0.MaxAUSize] TL2.QL0 Max AU Size (Type: Int64, Index 90)
+23:23:47.493: [AMF Encoder] Content Type: 0
+23:23:47.494: [AMF Encoder] Access: 
+23:23:47.494: [AMF Encoder] Values:
+23:23:47.494: [AMF Encoder] Current: Empty
+23:23:47.494: [AMF Encoder] Default: 0
+23:23:47.494: [AMF Encoder] Minimum: 0
+23:23:47.494: [AMF Encoder] Maximum: 100000000
+23:23:47.494: [AMF Encoder] [TL3.QL0.MaxAUSize] TL3.QL0 Max AU Size (Type: Int64, Index 91)
+23:23:47.494: [AMF Encoder] Content Type: 0
+23:23:47.494: [AMF Encoder] Access: 
+23:23:47.494: [AMF Encoder] Values:
+23:23:47.494: [AMF Encoder] Current: Empty
+23:23:47.495: [AMF Encoder] Default: 0
+23:23:47.495: [AMF Encoder] Minimum: 0
+23:23:47.495: [AMF Encoder] Maximum: 100000000
+23:23:47.495: [AMF Encoder] [TL0.QL0.MaxQP] TL0.QL0 Max QP (Type: Int64, Index 92)
+23:23:47.495: [AMF Encoder] Content Type: 0
+23:23:47.495: [AMF Encoder] Access: 
+23:23:47.495: [AMF Encoder] Values:
+23:23:47.495: [AMF Encoder] Current: Empty
+23:23:47.495: [AMF Encoder] Default: 51
+23:23:47.495: [AMF Encoder] Minimum: 0
+23:23:47.495: [AMF Encoder] Maximum: 51
+23:23:47.496: [AMF Encoder] [TL1.QL0.MaxQP] TL1.QL0 Max QP (Type: Int64, Index 93)
+23:23:47.496: [AMF Encoder] Content Type: 0
+23:23:47.496: [AMF Encoder] Access: 
+23:23:47.496: [AMF Encoder] Values:
+23:23:47.496: [AMF Encoder] Current: Empty
+23:23:47.496: [AMF Encoder] Default: 51
+23:23:47.496: [AMF Encoder] Minimum: 0
+23:23:47.496: [AMF Encoder] Maximum: 51
+23:23:47.496: [AMF Encoder] [TL2.QL0.MaxQP] TL2.QL0 Max QP (Type: Int64, Index 94)
+23:23:47.496: [AMF Encoder] Content Type: 0
+23:23:47.496: [AMF Encoder] Access: 
+23:23:47.496: [AMF Encoder] Values:
+23:23:47.496: [AMF Encoder] Current: Empty
+23:23:47.497: [AMF Encoder] Default: 51
+23:23:47.497: [AMF Encoder] Minimum: 0
+23:23:47.497: [AMF Encoder] Maximum: 51
+23:23:47.497: [AMF Encoder] [TL3.QL0.MaxQP] TL3.QL0 Max QP (Type: Int64, Index 95)
+23:23:47.497: [AMF Encoder] Content Type: 0
+23:23:47.497: [AMF Encoder] Access: 
+23:23:47.497: [AMF Encoder] Values:
+23:23:47.497: [AMF Encoder] Current: Empty
+23:23:47.497: [AMF Encoder] Default: 51
+23:23:47.497: [AMF Encoder] Minimum: 0
+23:23:47.497: [AMF Encoder] Maximum: 51
+23:23:47.497: [AMF Encoder] [TL0.QL0.MinQP] TL0.QL0 Min QP (Type: Int64, Index 96)
+23:23:47.497: [AMF Encoder] Content Type: 0
+23:23:47.498: [AMF Encoder] Access: 
+23:23:47.498: [AMF Encoder] Values:
+23:23:47.498: [AMF Encoder] Current: Empty
+23:23:47.498: [AMF Encoder] Default: 22
+23:23:47.498: [AMF Encoder] Minimum: 0
+23:23:47.498: [AMF Encoder] Maximum: 51
+23:23:47.498: [AMF Encoder] [TL1.QL0.MinQP] TL1.QL0 Min QP (Type: Int64, Index 97)
+23:23:47.498: [AMF Encoder] Content Type: 0
+23:23:47.498: [AMF Encoder] Access: 
+23:23:47.498: [AMF Encoder] Values:
+23:23:47.498: [AMF Encoder] Current: Empty
+23:23:47.498: [AMF Encoder] Default: 22
+23:23:47.499: [AMF Encoder] Minimum: 0
+23:23:47.499: [AMF Encoder] Maximum: 51
+23:23:47.499: [AMF Encoder] [TL2.QL0.MinQP] TL2.QL0 Min QP (Type: Int64, Index 98)
+23:23:47.499: [AMF Encoder] Content Type: 0
+23:23:47.499: [AMF Encoder] Access: 
+23:23:47.499: [AMF Encoder] Values:
+23:23:47.499: [AMF Encoder] Current: Empty
+23:23:47.499: [AMF Encoder] Default: 22
+23:23:47.499: [AMF Encoder] Minimum: 0
+23:23:47.499: [AMF Encoder] Maximum: 51
+23:23:47.499: [AMF Encoder] [TL3.QL0.MinQP] TL3.QL0 Min QP (Type: Int64, Index 99)
+23:23:47.500: [AMF Encoder] Content Type: 0
+23:23:47.500: [AMF Encoder] Access: 
+23:23:47.500: [AMF Encoder] Values:
+23:23:47.500: [AMF Encoder] Current: Empty
+23:23:47.500: [AMF Encoder] Default: 22
+23:23:47.500: [AMF Encoder] Minimum: 0
+23:23:47.500: [AMF Encoder] Maximum: 51
+23:23:47.500: [AMF Encoder] [TL0.QL0.PeakBitrate] TL0.QL0 Peak Bitrate (Type: Int64, Index 100)
+23:23:47.500: [AMF Encoder] Content Type: 0
+23:23:47.500: [AMF Encoder] Access: 
+23:23:47.501: [AMF Encoder] Values:
+23:23:47.501: [AMF Encoder] Current: Empty
+23:23:47.501: [AMF Encoder] Default: 10000000
+23:23:47.501: [AMF Encoder] Minimum: 10000
+23:23:47.501: [AMF Encoder] Maximum: 100000000
+23:23:47.501: [AMF Encoder] [TL1.QL0.PeakBitrate] TL1.QL0 Peak Bitrate (Type: Int64, Index 101)
+23:23:47.501: [AMF Encoder] Content Type: 0
+23:23:47.501: [AMF Encoder] Access: 
+23:23:47.501: [AMF Encoder] Values:
+23:23:47.501: [AMF Encoder] Current: Empty
+23:23:47.502: [AMF Encoder] Default: 10000000
+23:23:47.502: [AMF Encoder] Minimum: 10000
+23:23:47.502: [AMF Encoder] Maximum: 100000000
+23:23:47.502: [AMF Encoder] [TL2.QL0.PeakBitrate] TL2.QL0 Peak Bitrate (Type: Int64, Index 102)
+23:23:47.502: [AMF Encoder] Content Type: 0
+23:23:47.502: [AMF Encoder] Access: 
+23:23:47.502: [AMF Encoder] Values:
+23:23:47.502: [AMF Encoder] Current: Empty
+23:23:47.502: [AMF Encoder] Default: 10000000
+23:23:47.502: [AMF Encoder] Minimum: 10000
+23:23:47.502: [AMF Encoder] Maximum: 100000000
+23:23:47.502: [AMF Encoder] [TL3.QL0.PeakBitrate] TL3.QL0 Peak Bitrate (Type: Int64, Index 103)
+23:23:47.502: [AMF Encoder] Content Type: 0
+23:23:47.503: [AMF Encoder] Access: 
+23:23:47.503: [AMF Encoder] Values:
+23:23:47.503: [AMF Encoder] Current: Empty
+23:23:47.503: [AMF Encoder] Default: 10000000
+23:23:47.503: [AMF Encoder] Minimum: 10000
+23:23:47.503: [AMF Encoder] Maximum: 100000000
+23:23:47.503: [AMF Encoder] [TL0.QL0.QPB] TL0.QL0 QP B (Type: Int64, Index 104)
+23:23:47.503: [AMF Encoder] Content Type: 0
+23:23:47.503: [AMF Encoder] Access: 
+23:23:47.503: [AMF Encoder] Values:
+23:23:47.503: [AMF Encoder] Current: Empty
+23:23:47.503: [AMF Encoder] Default: 22
+23:23:47.504: [AMF Encoder] Minimum: 0
+23:23:47.504: [AMF Encoder] Maximum: 51
+23:23:47.504: [AMF Encoder] [TL1.QL0.QPB] TL1.QL0 QP B (Type: Int64, Index 105)
+23:23:47.504: [AMF Encoder] Content Type: 0
+23:23:47.504: [AMF Encoder] Access: 
+23:23:47.504: [AMF Encoder] Values:
+23:23:47.504: [AMF Encoder] Current: Empty
+23:23:47.504: [AMF Encoder] Default: 22
+23:23:47.504: [AMF Encoder] Minimum: 0
+23:23:47.504: [AMF Encoder] Maximum: 51
+23:23:47.504: [AMF Encoder] [TL2.QL0.QPB] TL2.QL0 QP B (Type: Int64, Index 106)
+23:23:47.504: [AMF Encoder] Content Type: 0
+23:23:47.504: [AMF Encoder] Access: 
+23:23:47.504: [AMF Encoder] Values:
+23:23:47.505: [AMF Encoder] Current: Empty
+23:23:47.505: [AMF Encoder] Default: 22
+23:23:47.505: [AMF Encoder] Minimum: 0
+23:23:47.505: [AMF Encoder] Maximum: 51
+23:23:47.505: [AMF Encoder] [TL3.QL0.QPB] TL3.QL0 QP B (Type: Int64, Index 107)
+23:23:47.505: [AMF Encoder] Content Type: 0
+23:23:47.505: [AMF Encoder] Access: 
+23:23:47.505: [AMF Encoder] Values:
+23:23:47.505: [AMF Encoder] Current: Empty
+23:23:47.505: [AMF Encoder] Default: 22
+23:23:47.505: [AMF Encoder] Minimum: 0
+23:23:47.505: [AMF Encoder] Maximum: 51
+23:23:47.505: [AMF Encoder] [TL0.QL0.QPI] TL0.QL0 QP I (Type: Int64, Index 108)
+23:23:47.506: [AMF Encoder] Content Type: 0
+23:23:47.506: [AMF Encoder] Access: 
+23:23:47.506: [AMF Encoder] Values:
+23:23:47.506: [AMF Encoder] Current: Empty
+23:23:47.506: [AMF Encoder] Default: 22
+23:23:47.506: [AMF Encoder] Minimum: 0
+23:23:47.506: [AMF Encoder] Maximum: 51
+23:23:47.506: [AMF Encoder] [TL1.QL0.QPI] TL1.QL0 QP I (Type: Int64, Index 109)
+23:23:47.506: [AMF Encoder] Content Type: 0
+23:23:47.506: [AMF Encoder] Access: 
+23:23:47.506: [AMF Encoder] Values:
+23:23:47.506: [AMF Encoder] Current: Empty
+23:23:47.506: [AMF Encoder] Default: 22
+23:23:47.507: [AMF Encoder] Minimum: 0
+23:23:47.507: [AMF Encoder] Maximum: 51
+23:23:47.507: [AMF Encoder] [TL2.QL0.QPI] TL2.QL0 QP I (Type: Int64, Index 110)
+23:23:47.507: [AMF Encoder] Content Type: 0
+23:23:47.507: [AMF Encoder] Access: 
+23:23:47.507: [AMF Encoder] Values:
+23:23:47.507: [AMF Encoder] Current: Empty
+23:23:47.507: [AMF Encoder] Default: 22
+23:23:47.507: [AMF Encoder] Minimum: 0
+23:23:47.507: [AMF Encoder] Maximum: 51
+23:23:47.507: [AMF Encoder] [TL3.QL0.QPI] TL3.QL0 QP I (Type: Int64, Index 111)
+23:23:47.507: [AMF Encoder] Content Type: 0
+23:23:47.507: [AMF Encoder] Access: 
+23:23:47.507: [AMF Encoder] Values:
+23:23:47.508: [AMF Encoder] Current: Empty
+23:23:47.508: [AMF Encoder] Default: 22
+23:23:47.508: [AMF Encoder] Minimum: 0
+23:23:47.508: [AMF Encoder] Maximum: 51
+23:23:47.508: [AMF Encoder] [TL0.QL0.QPP] TL0.QL0 QP P (Type: Int64, Index 112)
+23:23:47.508: [AMF Encoder] Content Type: 0
+23:23:47.508: [AMF Encoder] Access: 
+23:23:47.508: [AMF Encoder] Values:
+23:23:47.508: [AMF Encoder] Current: Empty
+23:23:47.508: [AMF Encoder] Default: 22
+23:23:47.508: [AMF Encoder] Minimum: 0
+23:23:47.508: [AMF Encoder] Maximum: 51
+23:23:47.508: [AMF Encoder] [TL1.QL0.QPP] TL1.QL0 QP P (Type: Int64, Index 113)
+23:23:47.509: [AMF Encoder] Content Type: 0
+23:23:47.509: [AMF Encoder] Access: 
+23:23:47.509: [AMF Encoder] Values:
+23:23:47.509: [AMF Encoder] Current: Empty
+23:23:47.509: [AMF Encoder] Default: 22
+23:23:47.509: [AMF Encoder] Minimum: 0
+23:23:47.509: [AMF Encoder] Maximum: 51
+23:23:47.509: [AMF Encoder] [TL2.QL0.QPP] TL2.QL0 QP P (Type: Int64, Index 114)
+23:23:47.509: [AMF Encoder] Content Type: 0
+23:23:47.509: [AMF Encoder] Access: 
+23:23:47.509: [AMF Encoder] Values:
+23:23:47.509: [AMF Encoder] Current: Empty
+23:23:47.509: [AMF Encoder] Default: 22
+23:23:47.509: [AMF Encoder] Minimum: 0
+23:23:47.509: [AMF Encoder] Maximum: 51
+23:23:47.510: [AMF Encoder] [TL3.QL0.QPP] TL3.QL0 QP P (Type: Int64, Index 115)
+23:23:47.510: [AMF Encoder] Content Type: 0
+23:23:47.510: [AMF Encoder] Access: 
+23:23:47.510: [AMF Encoder] Values:
+23:23:47.510: [AMF Encoder] Current: Empty
+23:23:47.510: [AMF Encoder] Default: 22
+23:23:47.510: [AMF Encoder] Minimum: 0
+23:23:47.510: [AMF Encoder] Maximum: 51
+23:23:47.510: [AMF Encoder] [TL0.QL0.RateControlMethod] TL0.QL0 Rate Control Method (Type: Int64, Index 116)
+23:23:47.510: [AMF Encoder] Content Type: 0
+23:23:47.510: [AMF Encoder] Access: 
+23:23:47.510: [AMF Encoder] Values:
+23:23:47.510: [AMF Encoder] Current: Empty
+23:23:47.510: [AMF Encoder] Default: 2
+23:23:47.511: [AMF Encoder] Minimum: Empty
+23:23:47.511: [AMF Encoder] Maximum: Empty
+23:23:47.511: [AMF Encoder] Enumeration: 
+23:23:47.511: [AMF Encoder] Constant QP (0)
+23:23:47.511: [AMF Encoder] CBR (1)
+23:23:47.511: [AMF Encoder] Peak constrained VBR (2)
+23:23:47.511: [AMF Encoder] Latency constrained VBR (3)
+23:23:47.511: [AMF Encoder] [TL1.QL0.RateControlMethod] TL1.QL0 Rate Control Method (Type: Int64, Index 117)
+23:23:47.511: [AMF Encoder] Content Type: 0
+23:23:47.511: [AMF Encoder] Access: 
+23:23:47.511: [AMF Encoder] Values:
+23:23:47.511: [AMF Encoder] Current: Empty
+23:23:47.511: [AMF Encoder] Default: 2
+23:23:47.511: [AMF Encoder] Minimum: Empty
+23:23:47.512: [AMF Encoder] Maximum: Empty
+23:23:47.512: [AMF Encoder] Enumeration: 
+23:23:47.512: [AMF Encoder] Constant QP (0)
+23:23:47.512: [AMF Encoder] CBR (1)
+23:23:47.512: [AMF Encoder] Peak constrained VBR (2)
+23:23:47.512: [AMF Encoder] Latency constrained VBR (3)
+23:23:47.512: [AMF Encoder] [TL2.QL0.RateControlMethod] TL2.QL0 Rate Control Method (Type: Int64, Index 118)
+23:23:47.512: [AMF Encoder] Content Type: 0
+23:23:47.512: [AMF Encoder] Access: 
+23:23:47.512: [AMF Encoder] Values:
+23:23:47.512: [AMF Encoder] Current: Empty
+23:23:47.512: [AMF Encoder] Default: 2
+23:23:47.512: [AMF Encoder] Minimum: Empty
+23:23:47.513: [AMF Encoder] Maximum: Empty
+23:23:47.513: [AMF Encoder] Enumeration: 
+23:23:47.513: [AMF Encoder] Constant QP (0)
+23:23:47.513: [AMF Encoder] CBR (1)
+23:23:47.513: [AMF Encoder] Peak constrained VBR (2)
+23:23:47.513: [AMF Encoder] Latency constrained VBR (3)
+23:23:47.513: [AMF Encoder] [TL3.QL0.RateControlMethod] TL3.QL0 Rate Control Method (Type: Int64, Index 119)
+23:23:47.513: [AMF Encoder] Content Type: 0
+23:23:47.513: [AMF Encoder] Access: 
+23:23:47.513: [AMF Encoder] Values:
+23:23:47.513: [AMF Encoder] Current: Empty
+23:23:47.513: [AMF Encoder] Default: 2
+23:23:47.513: [AMF Encoder] Minimum: Empty
+23:23:47.513: [AMF Encoder] Maximum: Empty
+23:23:47.514: [AMF Encoder] Enumeration: 
+23:23:47.514: [AMF Encoder] Constant QP (0)
+23:23:47.514: [AMF Encoder] CBR (1)
+23:23:47.514: [AMF Encoder] Peak constrained VBR (2)
+23:23:47.514: [AMF Encoder] Latency constrained VBR (3)
+23:23:47.514: [AMF Encoder] [TL0.QL0.RateControlPreanalysisEnable] TL0.QL0 Rate Control Preanalysis Enable (Type: Boolean, Index 120)
+23:23:47.514: [AMF Encoder] Content Type: 0
+23:23:47.514: [AMF Encoder] Access: 
+23:23:47.514: [AMF Encoder] Values:
+23:23:47.514: [AMF Encoder] Current: Empty
+23:23:47.514: [AMF Encoder] Default: false
+23:23:47.514: [AMF Encoder] Minimum: Empty
+23:23:47.514: [AMF Encoder] Maximum: Empty
+23:23:47.514: [AMF Encoder] [TL1.QL0.RateControlPreanalysisEnable] TL1.QL0 Rate Control Preanalysis Enable (Type: Boolean, Index 121)
+23:23:47.515: [AMF Encoder] Content Type: 0
+23:23:47.515: [AMF Encoder] Access: 
+23:23:47.515: [AMF Encoder] Values:
+23:23:47.515: [AMF Encoder] Current: Empty
+23:23:47.515: [AMF Encoder] Default: false
+23:23:47.515: [AMF Encoder] Minimum: Empty
+23:23:47.515: [AMF Encoder] Maximum: Empty
+23:23:47.515: [AMF Encoder] [TL2.QL0.RateControlPreanalysisEnable] TL2.QL0 Rate Control Preanalysis Enable (Type: Boolean, Index 122)
+23:23:47.515: [AMF Encoder] Content Type: 0
+23:23:47.515: [AMF Encoder] Access: 
+23:23:47.516: [AMF Encoder] Values:
+23:23:47.516: [AMF Encoder] Current: Empty
+23:23:47.516: [AMF Encoder] Default: false
+23:23:47.516: [AMF Encoder] Minimum: Empty
+23:23:47.516: [AMF Encoder] Maximum: Empty
+23:23:47.516: [AMF Encoder] [TL3.QL0.RateControlPreanalysisEnable] TL3.QL0 Rate Control Preanalysis Enable (Type: Boolean, Index 123)
+23:23:47.516: [AMF Encoder] Content Type: 0
+23:23:47.516: [AMF Encoder] Access: 
+23:23:47.516: [AMF Encoder] Values:
+23:23:47.517: [AMF Encoder] Current: Empty
+23:23:47.517: [AMF Encoder] Default: false
+23:23:47.517: [AMF Encoder] Minimum: Empty
+23:23:47.517: [AMF Encoder] Maximum: Empty
+23:23:47.517: [AMF Encoder] [TL0.QL0.RateControlSkipFrameEnable] TL0.QL0 Rate Control Based Frame Skip (Type: Boolean, Index 124)
+23:23:47.517: [AMF Encoder] Content Type: 0
+23:23:47.517: [AMF Encoder] Access: 
+23:23:47.517: [AMF Encoder] Values:
+23:23:47.517: [AMF Encoder] Current: Empty
+23:23:47.517: [AMF Encoder] Default: true
+23:23:47.517: [AMF Encoder] Minimum: Empty
+23:23:47.517: [AMF Encoder] Maximum: Empty
+23:23:47.517: [AMF Encoder] [TL1.QL0.RateControlSkipFrameEnable] TL1.QL0 Rate Control Based Frame Skip (Type: Boolean, Index 125)
+23:23:47.518: [AMF Encoder] Content Type: 0
+23:23:47.518: [AMF Encoder] Access: 
+23:23:47.518: [AMF Encoder] Values:
+23:23:47.518: [AMF Encoder] Current: Empty
+23:23:47.518: [AMF Encoder] Default: true
+23:23:47.518: [AMF Encoder] Minimum: Empty
+23:23:47.518: [AMF Encoder] Maximum: Empty
+23:23:47.518: [AMF Encoder] [TL2.QL0.RateControlSkipFrameEnable] TL2.QL0 Rate Control Based Frame Skip (Type: Boolean, Index 126)
+23:23:47.518: [AMF Encoder] Content Type: 0
+23:23:47.518: [AMF Encoder] Access: 
+23:23:47.518: [AMF Encoder] Values:
+23:23:47.518: [AMF Encoder] Current: Empty
+23:23:47.518: [AMF Encoder] Default: true
+23:23:47.518: [AMF Encoder] Minimum: Empty
+23:23:47.519: [AMF Encoder] Maximum: Empty
+23:23:47.519: [AMF Encoder] [TL3.QL0.RateControlSkipFrameEnable] TL3.QL0 Rate Control Based Frame Skip (Type: Boolean, Index 127)
+23:23:47.519: [AMF Encoder] Content Type: 0
+23:23:47.519: [AMF Encoder] Access: 
+23:23:47.519: [AMF Encoder] Values:
+23:23:47.519: [AMF Encoder] Current: Empty
+23:23:47.519: [AMF Encoder] Default: true
+23:23:47.519: [AMF Encoder] Minimum: Empty
+23:23:47.519: [AMF Encoder] Maximum: Empty
+23:23:47.519: [AMF Encoder] [TL0.QL0.ReferenceBPicturesDeltaQP] TL0.QL0 Reference B-picture Delta (Type: Int64, Index 128)
+23:23:47.519: [AMF Encoder] Content Type: 0
+23:23:47.519: [AMF Encoder] Access: 
+23:23:47.520: [AMF Encoder] Values:
+23:23:47.520: [AMF Encoder] Current: Empty
+23:23:47.520: [AMF Encoder] Default: 2
+23:23:47.520: [AMF Encoder] Minimum: -10
+23:23:47.520: [AMF Encoder] Maximum: 10
+23:23:47.520: [AMF Encoder] [TL1.QL0.ReferenceBPicturesDeltaQP] TL1.QL0 Reference B-picture Delta (Type: Int64, Index 129)
+23:23:47.520: [AMF Encoder] Content Type: 0
+23:23:47.520: [AMF Encoder] Access: 
+23:23:47.520: [AMF Encoder] Values:
+23:23:47.520: [AMF Encoder] Current: Empty
+23:23:47.520: [AMF Encoder] Default: 2
+23:23:47.520: [AMF Encoder] Minimum: -10
+23:23:47.521: [AMF Encoder] Maximum: 10
+23:23:47.521: [AMF Encoder] [TL2.QL0.ReferenceBPicturesDeltaQP] TL2.QL0 Reference B-picture Delta (Type: Int64, Index 130)
+23:23:47.521: [AMF Encoder] Content Type: 0
+23:23:47.521: [AMF Encoder] Access: 
+23:23:47.521: [AMF Encoder] Values:
+23:23:47.521: [AMF Encoder] Current: Empty
+23:23:47.521: [AMF Encoder] Default: 2
+23:23:47.521: [AMF Encoder] Minimum: -10
+23:23:47.521: [AMF Encoder] Maximum: 10
+23:23:47.521: [AMF Encoder] [TL3.QL0.ReferenceBPicturesDeltaQP] TL3.QL0 Reference B-picture Delta (Type: Int64, Index 131)
+23:23:47.521: [AMF Encoder] Content Type: 0
+23:23:47.521: [AMF Encoder] Access: 
+23:23:47.522: [AMF Encoder] Values:
+23:23:47.522: [AMF Encoder] Current: Empty
+23:23:47.522: [AMF Encoder] Default: 2
+23:23:47.522: [AMF Encoder] Minimum: -10
+23:23:47.522: [AMF Encoder] Maximum: 10
+23:23:47.522: [AMF Encoder] [TL0.QL0.TargetBitrate] TL0.QL0 Bitrate (Type: Int64, Index 132)
+23:23:47.522: [AMF Encoder] Content Type: 0
+23:23:47.522: [AMF Encoder] Access: 
+23:23:47.522: [AMF Encoder] Values:
+23:23:47.522: [AMF Encoder] Current: Empty
+23:23:47.522: [AMF Encoder] Default: 10000000
+23:23:47.522: [AMF Encoder] Minimum: 10000
+23:23:47.523: [AMF Encoder] Maximum: 100000000
+23:23:47.523: [AMF Encoder] [TL1.QL0.TargetBitrate] TL1.QL0 Bitrate (Type: Int64, Index 133)
+23:23:47.523: [AMF Encoder] Content Type: 0
+23:23:47.523: [AMF Encoder] Access: 
+23:23:47.523: [AMF Encoder] Values:
+23:23:47.523: [AMF Encoder] Current: Empty
+23:23:47.523: [AMF Encoder] Default: 10000000
+23:23:47.523: [AMF Encoder] Minimum: 10000
+23:23:47.523: [AMF Encoder] Maximum: 100000000
+23:23:47.523: [AMF Encoder] [TL2.QL0.TargetBitrate] TL2.QL0 Bitrate (Type: Int64, Index 134)
+23:23:47.523: [AMF Encoder] Content Type: 0
+23:23:47.523: [AMF Encoder] Access: 
+23:23:47.523: [AMF Encoder] Values:
+23:23:47.524: [AMF Encoder] Current: Empty
+23:23:47.524: [AMF Encoder] Default: 10000000
+23:23:47.524: [AMF Encoder] Minimum: 10000
+23:23:47.524: [AMF Encoder] Maximum: 100000000
+23:23:47.524: [AMF Encoder] [TL3.QL0.TargetBitrate] TL3.QL0 Bitrate (Type: Int64, Index 135)
+23:23:47.524: [AMF Encoder] Content Type: 0
+23:23:47.524: [AMF Encoder] Access: 
+23:23:47.524: [AMF Encoder] Values:
+23:23:47.524: [AMF Encoder] Current: Empty
+23:23:47.524: [AMF Encoder] Default: 10000000
+23:23:47.524: [AMF Encoder] Minimum: 10000
+23:23:47.525: [AMF Encoder] Maximum: 100000000
+23:23:47.525: [AMF Encoder] [TL0.QL0.VBVBufferSize] TL0.QL0 VBV Buffer Size (Type: Int64, Index 136)
+23:23:47.525: [AMF Encoder] Content Type: 0
+23:23:47.525: [AMF Encoder] Access: 
+23:23:47.525: [AMF Encoder] Values:
+23:23:47.525: [AMF Encoder] Current: Empty
+23:23:47.525: [AMF Encoder] Default: 1000000
+23:23:47.525: [AMF Encoder] Minimum: 1000
+23:23:47.525: [AMF Encoder] Maximum: 100000000
+23:23:47.525: [AMF Encoder] [TL1.QL0.VBVBufferSize] TL1.QL0 VBV Buffer Size (Type: Int64, Index 137)
+23:23:47.525: [AMF Encoder] Content Type: 0
+23:23:47.525: [AMF Encoder] Access: 
+23:23:47.526: [AMF Encoder] Values:
+23:23:47.526: [AMF Encoder] Current: Empty
+23:23:47.526: [AMF Encoder] Default: 1000000
+23:23:47.526: [AMF Encoder] Minimum: 1000
+23:23:47.526: [AMF Encoder] Maximum: 100000000
+23:23:47.526: [AMF Encoder] [TL2.QL0.VBVBufferSize] TL2.QL0 VBV Buffer Size (Type: Int64, Index 138)
+23:23:47.526: [AMF Encoder] Content Type: 0
+23:23:47.528: [AMF Encoder] Access: 
+23:23:47.529: [AMF Encoder] Values:
+23:23:47.529: [AMF Encoder] Current: Empty
+23:23:47.529: [AMF Encoder] Default: 1000000
+23:23:47.530: [AMF Encoder] Minimum: 1000
+23:23:47.530: [AMF Encoder] Maximum: 100000000
+23:23:47.530: [AMF Encoder] [TL3.QL0.VBVBufferSize] TL3.QL0 VBV Buffer Size (Type: Int64, Index 139)
+23:23:47.530: [AMF Encoder] Content Type: 0
+23:23:47.530: [AMF Encoder] Access: 
+23:23:47.530: [AMF Encoder] Values:
+23:23:47.530: [AMF Encoder] Current: Empty
+23:23:47.530: [AMF Encoder] Default: 1000000
+23:23:47.530: [AMF Encoder] Minimum: 1000
+23:23:47.531: [AMF Encoder] Maximum: 100000000
+23:23:47.531: [AMF Encoder] [NumOfTemporalEnhancmentLayers] Num Of Temporal Enhancment Layers (Type: Int64, Index 140)
+23:23:47.531: [AMF Encoder] Content Type: 0
+23:23:47.531: [AMF Encoder] Access: 
+23:23:47.531: [AMF Encoder] Values:
+23:23:47.531: [AMF Encoder] Current: Empty
+23:23:47.531: [AMF Encoder] Default: 0
+23:23:47.531: [AMF Encoder] Minimum: 0
+23:23:47.531: [AMF Encoder] Maximum: 3
+23:23:47.531: [AMF Encoder] [NumOfQualityLayers] Num Of Quality Layers (Type: Int64, Index 141)
+23:23:47.531: [AMF Encoder] Content Type: 0
+23:23:47.532: [AMF Encoder] Access: 
+23:23:47.533: [AMF Encoder] Values:
+23:23:47.533: [AMF Encoder] Current: Empty
+23:23:47.533: [AMF Encoder] Default: 0
+23:23:47.534: [AMF Encoder] Minimum: 0
+23:23:47.534: [AMF Encoder] Maximum: 0
+23:23:47.534: [AMF Encoder] [MGSVectorMode] MGS Vector Mode (Type: Boolean, Index 142)
+23:23:47.534: [AMF Encoder] Content Type: 0
+23:23:47.534: [AMF Encoder] Access: 
+23:23:47.534: [AMF Encoder] Values:
+23:23:47.534: [AMF Encoder] Current: Empty
+23:23:47.534: [AMF Encoder] Default: false
+23:23:47.534: [AMF Encoder] Minimum: Empty
+23:23:47.534: [AMF Encoder] Maximum: Empty
+23:23:47.535: [AMF Encoder] [MGSVector0] MGS Vector 0 (Type: Int64, Index 143)
+23:23:47.535: [AMF Encoder] Content Type: 0
+23:23:47.535: [AMF Encoder] Access: 
+23:23:47.535: [AMF Encoder] Values:
+23:23:47.535: [AMF Encoder] Current: Empty
+23:23:47.535: [AMF Encoder] Default: 0
+23:23:47.535: [AMF Encoder] Minimum: 0
+23:23:47.535: [AMF Encoder] Maximum: 16
+23:23:47.535: [AMF Encoder] [MGSVector1] MGS Vector 1 (Type: Int64, Index 144)
+23:23:47.535: [AMF Encoder] Content Type: 0
+23:23:47.535: [AMF Encoder] Access: 
+23:23:47.536: [AMF Encoder] Values:
+23:23:47.536: [AMF Encoder] Current: Empty
+23:23:47.536: [AMF Encoder] Default: 0
+23:23:47.536: [AMF Encoder] Minimum: 0
+23:23:47.536: [AMF Encoder] Maximum: 16
+23:23:47.536: [AMF Encoder] [MGSVector2] MGS Vector 2 (Type: Int64, Index 145)
+23:23:47.536: [AMF Encoder] Content Type: 0
+23:23:47.536: [AMF Encoder] Access: 
+23:23:47.536: [AMF Encoder] Values:
+23:23:47.536: [AMF Encoder] Current: Empty
+23:23:47.537: [AMF Encoder] Default: 0
+23:23:47.537: [AMF Encoder] Minimum: 0
+23:23:47.537: [AMF Encoder] Maximum: 16
+23:23:47.537: [AMF Encoder] [MGSVector3] MGS Vector 3 (Type: Int64, Index 146)
+23:23:47.537: [AMF Encoder] Content Type: 0
+23:23:47.537: [AMF Encoder] Access: 
+23:23:47.537: [AMF Encoder] Values:
+23:23:47.537: [AMF Encoder] Current: Empty
+23:23:47.537: [AMF Encoder] Default: 0
+23:23:47.537: [AMF Encoder] Minimum: 0
+23:23:47.537: [AMF Encoder] Maximum: 16
+23:23:47.538: [AMF Encoder] [MGSKeyPicturePeriod] MGS Key Picture Period (Type: Int64, Index 147)
+23:23:47.538: [AMF Encoder] Content Type: 0
+23:23:47.538: [AMF Encoder] Access: 
+23:23:47.538: [AMF Encoder] Values:
+23:23:47.538: [AMF Encoder] Current: Empty
+23:23:47.538: [AMF Encoder] Default: 0
+23:23:47.538: [AMF Encoder] Minimum: 0
+23:23:47.538: [AMF Encoder] Maximum: 1000
+

obs-studio-0.16.6.tar.xz/plugins/enc-amf/#Resources/Installer.in.iss Added

@@ -0,0 +1,114 @@
+; Script generated by the Inno Setup Script Wizard.
+; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
+
+#define MyAppName "AMD Encoder for OBS Studio"
+#define MyAppVersion "@enc-amf_VERSION_MAJOR@.@enc-amf_VERSION_MINOR@.@enc-amf_VERSION_PATCH@.@enc-amf_VERSION_BUILD@"
+#define MyAppPublisher "Xaymars Technology Workshop"
+#define MyAppURL "http://www.xaymar.com/portfolio/plugin-amd-vce-plugin-for-obs-studio/"
+
+[Setup]
+; NOTE: The value of AppId uniquely identifies this application.
+; Do not use the same AppId value in installers for other applications.
+; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
+AppId={{FD6676CE-0580-4B34-9DB4-4879A0BEB31D}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+;AppVerName={#MyAppName} {#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+AppPublisherURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
+DefaultDirName={code:GetDirName}
+DefaultGroupName={#MyAppName}
+AllowNoIcons=yes
+LicenseFile=..\LICENSE
+OutputDir=.\Output
+OutputBaseFilename=AMD-Encoder-for-OBS-Studio.{#MyAppVersion}
+Compression=lzma
+SolidCompression=yes
+VersionInfoVersion={#MyAppVersion}
+VersionInfoCompany={#MyAppPublisher}
+VersionInfoDescription={#MyAppName} Setup
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Files]
+Source: "..\#Build\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+; NOTE: Don't use "Flags: ignoreversion" on any shared system files
+
+[Icons]
+Name: "{group}\{cm:ProgramOnTheWeb,{#MyAppName}}"; Filename: "{#MyAppURL}"
+Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
+
+[Code]
+function GetDirName(Value: string): string;
+var
+ InstallPath: string;
+begin
+ // initialize default path, which will be returned when the following registry
+ // key queries fail due to missing keys or for some different reason
+ Result := '{pf}\obs-studio';
+ // query the first registry value; if this succeeds, return the obtained value
+ if RegQueryStringValue(HKLM32, 'SOFTWARE\OBS Studio', '', InstallPath) then
+ Result := InstallPath
+end;
+
+/////////////////////////////////////////////////////////////////////
+function GetUninstallString(): String;
+var
+ sUnInstPath: String;
+ sUnInstallString: String;
+begin
+ sUnInstPath := ExpandConstant('Software\Microsoft\Windows\CurrentVersion\Uninstall\{#emit SetupSetting("AppId")}_is1');
+ sUnInstallString := '';
+ if not RegQueryStringValue(HKLM, sUnInstPath, 'UninstallString', sUnInstallString) then
+ RegQueryStringValue(HKCU, sUnInstPath, 'UninstallString', sUnInstallString);
+ Result := sUnInstallString;
+end;
+
+
+/////////////////////////////////////////////////////////////////////
+function IsUpgrade(): Boolean;
+begin
+ Result := (GetUninstallString() <> '');
+end;
+
+
+/////////////////////////////////////////////////////////////////////
+function UnInstallOldVersion(): Integer;
+var
+ sUnInstallString: String;
+ iResultCode: Integer;
+begin
+// Return Values:
+// 1 - uninstall string is empty
+// 2 - error executing the UnInstallString
+// 3 - successfully executed the UnInstallString
+
+ // default return value
+ Result := 0;
+
+ // get the uninstall string of the old app
+ sUnInstallString := GetUninstallString();
+ if sUnInstallString <> '' then begin
+ sUnInstallString := RemoveQuotes(sUnInstallString);
+ if Exec(sUnInstallString, '/SILENT /NORESTART /SUPPRESSMSGBOXES','', SW_HIDE, ewWaitUntilTerminated, iResultCode) then
+ Result := 3
+ else
+ Result := 2;
+ end else
+ Result := 1;
+end;
+
+/////////////////////////////////////////////////////////////////////
+procedure CurStepChanged(CurStep: TSetupStep);
+begin
+ if (CurStep=ssInstall) then
+ begin
+ if (IsUpgrade()) then
+ begin
+ UnInstallOldVersion();
+ end;
+ end;
+end;
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/#Resources/PATCH_NOTES.md Added

@@ -0,0 +1,29 @@
+# Multi-GPU Support And Filler Data Fix (Hotfix 2)
+With this update the encoder plugin now supports multi-GPU setups, such as RX 480 + R9 390, R9 285 + R9 290, and others. You can select which GPU to use with the Advanced View Mode. The UI will also now update according to the supported features of the selected GPU and by default uses the primary GPU. Unsupported features will be hidden, just like unused features.
+
+The 'Filler Data' property has now been fixed, Delta QP for B-Pictures is now visible when not using Constant QP, 'Memory Type' and 'Surface Format' have been removed and 'CABAC' has been replaced with 'Coding Type'. 'Memory Type' is now automatically using the best available and 'Surface Format' is taken from OBS settings.
+
+Additionally a crash with AMD Hybrid/Switchable GPU setups was fixed and these systems should now be able to use the encoder. It will now default to using the best available AMD GPU in the system if it can detect it.
+
+Hotfix 2: Fixed a potential crash when opening settings.
+Hotfix 1: Fixed Presets not being applied properly
+
+## Notes
+
+Due to the nature of changes since 1.3 users might experience that their settings have vanished or are incorrect. Please revalidate your settings or even create a clean profile to work off of.
+
+## Changelog
+
+* (Hotfix 2) Fixed: Potential crash when opening the settings.
+* (Hotfix 1) Fixed: Presets were not being applied properly.
+* Added: Full multi-GPU encoding support.
+* Added: 'Coding Type' property which replaces 'CABAC'.
+* Fixed: Filler Data was always being forced on for CBR.
+* Fixed: Users should now be able to modify Delta QP for B-Pictures even when not using Constant QP.
+* Fixed: Crash on OBS start on AMD Hybrid/Switchable GPU systems.
+* Changed: Default device is always the primary/best available AMD GPU in the system.
+* Changed: B-Picture properties will be properly hidden now if not in use.
+* Changed: B-Pictures defaults to 0 and B-Picture Reference defaults to Disabled.
+* Removed: 'Memory Type' property as the plugin will now always use the best available API.
+* Removed: 'Surface Format' property as the plugin will now use the OBS settings for this.
+* Removed: Deprecated encoder entry has been fully removed now.
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/#Resources/package.in.bat Added

obs-studio-0.16.5.tar.xz/plugins/enc-amf/CMakeLists.txt -> obs-studio-0.16.6.tar.xz/plugins/enc-amf/CMakeLists.txt Changed

@@ -1,60 +1,154 @@
-OPTION(AMDAMF_Disable "Disable AMD Advanced Media Framework support" OFF)
-SET(AMDAMF_SDKDir "" CACHE PATH "AMD Advanced Media Framework SDK Directory")
+cmake_minimum_required(VERSION 2.8.12)
 
-if(AMDAMF_Disable)
-	message(STATUS "AMD AMF support disabled")
-	return()
-endif()
+# Shared (OBS Studio & Standalone)
+PROJECT(enc-amf)
+SET(enc-amf_HEADERS
+	"Include/amd-amf.h"
+	"Include/amd-amf-vce.h"
+	"Include/amd-amf-vce-capabilities.h"
+	"Include/api-base.h"
+	"Include/api-d3d9.h"
+	"Include/api-d3d11.h"
+	"Include/enc-h264.h"
+	"Include/plugin.h"
+	"${PROJECT_BINARY_DIR}/Include/Version.h"
+)
+SET(enc-amf_SOURCES
+	"Source/amd-amf.cpp"
+	"Source/amd-amf-vce.cpp"
+	"Source/amd-amf-vce-capabilities.cpp"
+	"Source/api-base.cpp"
+	"Source/api-d3d9.cpp"
+	"Source/api-d3d11.cpp"
+	"Source/enc-h264.cpp"
+	"Source/plugin.cpp"
+	"Source/misc-util.cpp"
+)
+SET(enc-amf_LIBRARIES
+	version
+	winmm
+)
 
-if(AMDAMF_SDKDir STREQUAL "")
-	message(STATUS "AMDAMF_SDKDir not set! enc-amf plugin disabled.")
-	return()
-endif()
+# Version
+SET(enc-amf_VERSION_MAJOR 1)
+SET(enc-amf_VERSION_MINOR 4)
+SET(enc-amf_VERSION_PATCH 2)
+SET(enc-amf_VERSION_BUILD 3)
+configure_file(
+	"${PROJECT_SOURCE_DIR}/#Resources/package.in.bat"
+	"${PROJECT_SOURCE_DIR}/#Resources/package.bat"
+)
+configure_file(
+	"${PROJECT_SOURCE_DIR}/#Resources/Installer.in.iss"
+	"${PROJECT_SOURCE_DIR}/#Resources/Installer.iss"
+)
+configure_file(
+	"${PROJECT_SOURCE_DIR}/Include/Version.h.in"
+	"${PROJECT_BINARY_DIR}/Include/Version.h"
+)
 
-if(NOT EXISTS "${AMDAMF_SDKDir}/amf/public/include/components/VideoEncoderVCE.h")
-	message(STATUS "AMDAMF_SDKDir invalid! enc-amf plugin disabled.")
-	return()
-endif()
+# OBS Studio Specific
+if(BUILD_AMF_ENCODER)
+	OPTION(AMDAMF_Disable "Disable AMD Advanced Media Framework support" OFF)
+	SET(AMDAMF_SDKDir "" CACHE PATH "AMD Advanced Media Framework SDK Directory")
 
-PROJECT(enc-amf)
+	if(AMDAMF_Disable)
+		message(STATUS "AMD AMF support disabled")
+		return()
+	endif()
 
-INCLUDE_DIRECTORIES(
-	SYSTEM "${CMAKE_SOURCE_DIR}"
-	SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/enc-amf/Include"
-	SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/enc-amf/Source"
-	SYSTEM "${AMDAMF_SDKDir}/amf/public/include"
-)
+	if(AMDAMF_SDKDir STREQUAL "")
+		message(STATUS "AMDAMF_SDKDir not set! enc-amf plugin disabled.")
+		return()
+	endif()
 
-SET(enc-amf_HEADERS
-	"enc-amf/Include/amd-amf.h"
-	"enc-amf/Include/amd-amf-vce.h"
-	"enc-amf/Include/amd-amf-vce-capabilities.h"
-	"enc-amf/Include/api-base.h"
-	"enc-amf/Include/api-d3d9.h"
-	"enc-amf/Include/api-d3d11.h"
-	"enc-amf/Include/enc-h264.h"
-	"enc-amf/Include/plugin.h"
-)
+	if(NOT EXISTS "${AMDAMF_SDKDir}/amf/public/include/components/VideoEncoderVCE.h")
+		message(STATUS "AMDAMF_SDKDir invalid! enc-amf plugin disabled.")
+		return()
+	endif()
+	
+	INCLUDE_DIRECTORIES(
+		"${CMAKE_SOURCE_DIR}"
+		"${PROJECT_BINARY_DIR}"
+		"${PROJECT_BINARY_DIR}/Include"
+		"${PROJECT_BINARY_DIR}/Source"
+		"${PROJECT_SOURCE_DIR}"
+		"${PROJECT_SOURCE_DIR}/Include"
+		"${PROJECT_SOURCE_DIR}/Source"
+		"${AMDAMF_SDKDir}/amf/public/include"
+	)
+	SET(LIBOBS_LIBRARIES libobs)
+else()
+# Standlone Specific
 
-SET(enc-amf_SOURCES
-	"enc-amf/Source/amd-amf.cpp"
-	"enc-amf/Source/amd-amf-vce.cpp"
-	"enc-amf/Source/amd-amf-vce-capabilities.cpp"
-	"enc-amf/Source/api-base.cpp"
-	"enc-amf/Source/api-d3d9.cpp"
-	"enc-amf/Source/api-d3d11.cpp"
-	"enc-amf/Source/enc-h264.cpp"
-	"enc-amf/Source/plugin.cpp"
-)
+	# Variables
+	SET(PATH_AMDAMFSDK "" CACHE PATH "AMD Advanced Media Framework SDK Directory")
+	SET(PATH_OBSStudio "" CACHE PATH "OBS Studio Source Code Directory")
+	#SET(PATH_libobs "" CACHE PATH "Path to obs.lib from OBS Studio")
+	
+	if(PATH_AMDAMFSDK STREQUAL "")
+		message(STATUS "PATH_AMDAMFSDK not set!")
+		return()
+	endif()
 
-add_library(enc-amf MODULE
+	if(NOT EXISTS "${PATH_AMDAMFSDK}/amf/public/include/components/VideoEncoderVCE.h")
+		message(STATUS "PATH_AMDAMFSDK invalid!")
+		return()
+	endif()
+	
+	if(PATH_OBSStudio STREQUAL "")
+		message(STATUS "PATH_OBSStudio not set!")
+		return()
+	endif()
+
+	if(NOT EXISTS "${PATH_OBSStudio}/libobs/obs-module.h")
+		message(STATUS "PATH_OBSStudio invalid!")
+		return()
+	endif()
+	
+	# Stuff
+	SET(obsPath "${PATH_OBSStudio}")
+	INCLUDE("${PATH_OBSStudio}/cmake/external/Findlibobs.cmake")
+	
+	# Compiling
+	INCLUDE_DIRECTORIES(
+		"${PROJECT_BINARY_DIR}"
+		"${PROJECT_BINARY_DIR}/Include"
+		"${PROJECT_BINARY_DIR}/Source"
+		"${PROJECT_SOURCE_DIR}"
+		"${PROJECT_SOURCE_DIR}/Include"
+		"${PROJECT_SOURCE_DIR}/Source"
+		"${PATH_AMDAMFSDK}/amf/public/include"
+		"${PATH_OBSStudio}/"
+	)
+endif()
+
+ADD_LIBRARY(enc-amf MODULE
 	${enc-amf_HEADERS}
 	${enc-amf_SOURCES}
 )
-target_link_libraries(enc-amf
-	libobs
-	version
-	winmm
+TARGET_LINK_LIBRARIES(enc-amf
+	${LIBOBS_LIBRARIES}
+	${enc-amf_LIBRARIES}
 )
 
-install_obs_plugin_with_data(enc-amf enc-amf/Resources)
+if(BUILD_AMF_ENCODER)
+	install_obs_plugin_with_data(enc-amf Resources)
+else()
+	math(EXPR BITS "8*${CMAKE_SIZEOF_VOID_P}")
+	add_custom_command(TARGET enc-amf POST_BUILD
+		COMMAND ${CMAKE_COMMAND} -E copy_directory
+		"${PROJECT_SOURCE_DIR}/Resources/locale"
+		"${PROJECT_SOURCE_DIR}/#Build/data/obs-plugins/enc-amf/locale"
+	)	
+	add_custom_command(TARGET enc-amf POST_BUILD
+		COMMAND ${CMAKE_COMMAND} -E copy
+		"$<TARGET_FILE:enc-amf>"
+		"${PROJECT_SOURCE_DIR}/#Build/obs-plugins/${BITS}bit/$<TARGET_FILE_NAME:enc-amf>"
+	)	
+	add_custom_command(TARGET enc-amf POST_BUILD
+		COMMAND ${CMAKE_COMMAND} -E copy
+		"$<TARGET_FILE_DIR:enc-amf>/enc-amf.pdb"
+		"${PROJECT_SOURCE_DIR}/#Build/obs-plugins/${BITS}bit/enc-amf.pdb"
+	)
+endif()

obs-studio-0.16.5.tar.xz/plugins/enc-amf/CONTRIBUTING.md -> obs-studio-0.16.6.tar.xz/plugins/enc-amf/CONTRIBUTING.md Changed

@@ -15,42 +15,34 @@
 
 # Building
 
-## Getting Started
-This plugin is included in the Open Broadcaster Studio project itself. 
-This is only necessary if you wish to verify functionality with a standalone build.
+## Step 1: Get the pre-requisites
+This plugin is included in the Open Broadcaster Studio project itself. This is only necessary if you wish to verify functionality with a standalone build.
 
-## Pre-Requisites
+### Pre-Requisites
 * [Visual Studio® 2013 or Visual Studio® 2015 (Community or better)](http://visualstudio.com/)
 * Windows 10 SDK (Version 10586 or better, bundled with Visual Studio)
 * [OBS Studio](https://github.com/jp9000/obs-studio)
 * [AMF SDK](https://github.com/GPUOpen-LibrariesAndSDKs/AMF)
 * [InnoSetup](http://www.jrsoftware.org/isinfo.php)
+* CMake
 
-### Step 1: Third Party Headers
+## Step 2: Configure with CMake
+Point CMake at the source code and use either /build32 for 32-bit or /build64 for 64-bit as the binaries path.
 
-#### Open Broadcaster Studio
-1. Clone the [Open Broadcaster Studio Source Code](https://github.com/jp9000/obs-studio).
-2. Build both x86 and x64 with the same Visual Studio version you indent to use for the plugin.
-3. Create a *Soft Link* (Directory Junction) in /#ThirdParty/ to the cloned repository, call it 'OBS-Studio'. 
-Ex (Windows): mklink /J ./#ThirdParty/OBS-Studio C:/Src/OBS/
-4. Verify that it works by visiting the ./#ThirdParty/OBS-Studio directory.
+The following variables are needed to be set for a successful build:
 
-#### AMD Advanced Media Framework SDK (AMF SDK)
-1. Clone the [AMF SDK](https://github.com/GPUOpen-LibrariesAndSDKs/AMF).
-2. Create a *Soft Link* (Directory Junction) in /#ThirdParty/ to the cloned repository, call it 'AMD-AMF-SDK'. 
-Ex (Windows): mklink /J ./#ThirdParty/AMD-AMF-SDK C:/Src/AMF/
-3. Verify that it works by visiting the ./#ThirdParty/AMD-AMF-SDK directory.
+* PATH_AMDAMFSDK - Path to the cloned AMF SDK repository.
+* PATH_OBSStudio - Path to the cloned OBS Studio repository.
 
-### Step 2: Build the Project
+Once you have set these, you can generate the project files.
 
-1. Open the Visual Studio Solution file.
-2. Build for both x86 and x64 (Normal or Batch Build).
-3. Binaries should be located in /#Build/$(Configuration)/
-4. (Optional) Create Archives and an Installer with the package.bat in /#Resources/.
+## Step 3: Build with CMake
+1. Open the project file 
+2. Build
 
-If any errors during building or creating the archives and installer, start again from Step 1.
+Binaries will be located in /#Build and in the chosen binary path. An Installer can be created using the package.bat in /#Resources.
 
-### Step 3: Verify Functionality
+## Step 3: Verify Functionality
 
 *[You can only do this with an AMD APU or GPU installed](https://github.com/Xaymar/obs-studio_amf-encoder-plugin/wiki/Hardware,-GCN-and-VCE-Limits)*. 
 Install the plugin into your OBS Studio installation or test environment and select it in either Simple Output Mode or Advanced Output Mode. It should encode fine without crashing at any point.

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/Version.h.in Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/amd-amf-vce-capabilities.h Added

@@ -0,0 +1,105 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <stdint.h>
+#include <inttypes.h>
+#include <vector>
+#include <list>
+#include <map>
+
+// Plugin
+#include "plugin.h"
+#include "amd-amf.h"
+#include "amd-amf-vce.h"
+#include "api-base.h"
+
+// AMF
+#include "components\ComponentCaps.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+
+namespace Plugin {
+	namespace AMD {
+		struct VCEDeviceCapabilities {
+			amf::AMF_ACCELERATION_TYPE acceleration_type;
+			uint32_t maxProfile;
+			uint32_t maxProfileLevel;
+			uint32_t maxBitrate;
+			uint32_t minReferenceFrames;
+			uint32_t maxReferenceFrames;
+			bool supportsBFrames;
+			bool supportsFixedSliceMode;
+			uint32_t maxTemporalLayers;
+			uint32_t maxNumOfStreams;
+			uint32_t maxNumOfHwInstances;
+
+			struct IOCaps {
+				int32_t minWidth, maxWidth;
+				int32_t minHeight, maxHeight;
+				bool isInterlacedSupported;
+				uint32_t verticalAlignment;
+
+				std::vector<std::pair<amf::AMF_SURFACE_FORMAT, bool>> formats;
+				std::vector<std::pair<amf::AMF_MEMORY_TYPE, bool>> memoryTypes;
+			} input, output;
+		};
+
+		class VCECapabilities {
+			//////////////////////////////////////////////////////////////////////////
+			// Singleton
+			//////////////////////////////////////////////////////////////////////////
+			public:
+			static std::shared_ptr<Plugin::AMD::VCECapabilities> GetInstance();
+			static void ReportCapabilities();
+			static void ReportDeviceCapabilities(Plugin::API::Device device);
+			static void ReportDeviceIOCapabilities(Plugin::API::Device device, VCEEncoderType type, bool output);
+
+			//////////////////////////////////////////////////////////////////////////
+			// Class
+			//////////////////////////////////////////////////////////////////////////
+			public:
+			VCECapabilities();
+			~VCECapabilities();
+
+			//void QueryCapabilitiesForDevice(VCEMemoryType type, Plugin::API::Device device = Plugin::API::Device());
+
+			bool Refresh();
+			std::vector<Plugin::API::Device> GetDevices();
+			VCEDeviceCapabilities GetDeviceCaps(Plugin::API::Device device, VCEEncoderType type);
+			VCEDeviceCapabilities::IOCaps GetDeviceIOCaps(Plugin::API::Device device, VCEEncoderType type, bool output);
+
+			private:
+			//std::map<VCEMemoryType, std::map<Plugin::API::Device, std::map<VCEEncoderType, VCEDeviceCapabilities>>> tstMap;
+
+			std::vector<Plugin::API::Device> devices;
+			std::map<std::pair<Plugin::API::Device, Plugin::AMD::VCEEncoderType>, VCEDeviceCapabilities> deviceToCapabilities;
+		};
+	}
+}
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/amd-amf-vce.h Added

@@ -0,0 +1,500 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <condition_variable>
+#include <algorithm>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <vector>
+#include <chrono>
+
+// Plugin
+#include "plugin.h"
+#include "amd-amf.h"
+#include "api-base.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+
+namespace Plugin {
+	namespace AMD {
+		// Internal Properties
+		enum VCEEncoderType {
+			VCEEncoderType_AVC,		// Advanced Video Coding
+			VCEEncoderType_SVC,		// Scalable Video Coding
+			VCEEncoderType_HEVC,	// High-Efficiency Video Coding (Discovered in amfrt64.dll)
+		};
+		enum VCEMemoryType {
+			VCEMemoryType_Host,			// Host-Managed Memory
+			VCEMemoryType_DirectX9,		// DirectX9
+			VCEMemoryType_DirectX11,	// DirectX11
+			VCEMemoryType_OpenGL,		// OpenGL
+		};
+		enum VCEColorFormat {
+			// 4:2:0 Formats
+			VCEColorFormat_NV12,	// NV12
+			VCEColorFormat_I420,	// YUV 4:2:0
+			// 4:2:2 Formats
+			VCEColorFormat_YUY2,
+			// Uncompressed
+			VCEColorFormat_BGRA,	// ARGB
+			VCEColorFormat_RGBA,	// RGBA
+			// Other
+			VCEColorFormat_GRAY,
+		};
+		enum VCEColorProfile {
+			VCEColorProfile_601,
+			VCEColorProfile_709,
+			VCEColorProfile_2020, // HDR
+		};
+
+		// Static Properties
+		enum VCEUsage {
+			VCEUsage_Transcoding,
+			VCEUsage_UltraLowLatency,
+			VCEUsage_LowLatency,
+			VCEUsage_Webcam,			// For SVC
+		};
+		enum VCEQualityPreset {
+			VCEQualityPreset_Speed,
+			VCEQualityPreset_Balanced,
+			VCEQualityPreset_Quality,
+		};
+		enum VCEProfile {
+			VCEProfile_Baseline = 66,
+			VCEProfile_Main = 77,
+			VCEProfile_High = 100,
+			VCEProfile_ConstrainedBaseline = 256,
+			VCEProfile_ConstrainedHigh = 257
+		};
+		enum VCEProfileLevel {
+			VCEProfileLevel_Automatic = 0,
+			VCEProfileLevel_10 = 10,
+			VCEProfileLevel_11,
+			VCEProfileLevel_12,
+			VCEProfileLevel_13,
+			VCEProfileLevel_20 = 20,
+			VCEProfileLevel_21,
+			VCEProfileLevel_22,
+			VCEProfileLevel_30 = 30,
+			VCEProfileLevel_31,
+			VCEProfileLevel_32,
+			VCEProfileLevel_40 = 40,
+			VCEProfileLevel_41,
+			VCEProfileLevel_42,
+			VCEProfileLevel_50 = 50,
+			VCEProfileLevel_51,
+			VCEProfileLevel_52,
+			VCEProfileLevel_60 = 60,
+			VCEProfileLevel_61,
+			VCEProfileLevel_62,
+		};
+		enum VCEScanType {
+			VCEScanType_Progressive,
+			VCEScanType_Interlaced,
+		};
+		enum VCECodingType {
+			VCECodingType_Default,
+			VCECodingType_CALV,
+			VCECodingType_CABAC,
+		};
+
+		// Dynamic Properties
+		enum VCERateControlMethod {
+			VCERateControlMethod_ConstantQP,
+			VCERateControlMethod_ConstantBitrate,
+			VCERateControlMethod_VariableBitrate_PeakConstrained,
+			VCERateControlMethod_VariableBitrate_LatencyConstrained,
+		};
+		enum VCEBPicturePattern {
+			VCEBPicturePattern_None,
+			VCEBPicturePattern_One,
+			VCEBPicturePattern_Two,
+			VCEBPicturePattern_Three,
+		};
+
+		class VCEEncoder {
+			//////////////////////////////////////////////////////////////////////////
+			#pragma region Functions
+			//////////////////////////////////////////////////////////////////////////
+			private:
+			static void InputThreadMain(Plugin::AMD::VCEEncoder* p_this);
+			static void OutputThreadMain(Plugin::AMD::VCEEncoder* p_this);
+
+			#pragma endregion Functions
+			//////////////////////////////////////////////////////////////////////////
+
+			//////////////////////////////////////////////////////////////////////////
+			#pragma region Initializer & Finalizer
+			//////////////////////////////////////////////////////////////////////////
+			public:
+			VCEEncoder(VCEEncoderType p_Type,
+				std::string p_DeviceId = "",
+				bool p_OpenCL = false,
+				VCEColorFormat p_SurfaceFormat = VCEColorFormat_NV12
+			);
+			~VCEEncoder();
+			#pragma endregion Initializer & Finalizer
+
+			//////////////////////////////////////////////////////////////////////////
+			#pragma region Methods
+			//////////////////////////////////////////////////////////////////////////
+			public:
+			void Start();
+			void Restart();
+			void Stop();
+			bool IsStarted();
+			bool SendInput(struct encoder_frame* frame);
+			bool GetOutput(struct encoder_packet* packet, bool* received_packet);
+			bool GetExtraData(uint8_t**& data, size_t*& size);
+			void GetVideoInfo(struct video_scale_info*& vsi);
+
+			// Threading
+			private:
+			void InputThreadLogic();
+			void OutputThreadLogic();
+
+			// Utility
+			inline amf::AMFSurfacePtr CreateSurfaceFromFrame(struct encoder_frame*& frame);
+
+			public:
+			void LogProperties();
+			
+			/************************************************************************/
+			/* Static Properties */
+			/************************************************************************/
+
+			/*	Usage Type
+			*	Sets up the entire encoder to a specific set of properties.
+			*	Must be called first if you want to override properties. */
+			void SetUsage(VCEUsage usage);
+			VCEUsage GetUsage();
+
+			/** Quality Preset
+			* Static Property, changes cause a restart. */
+			void SetQualityPreset(VCEQualityPreset preset);
+			VCEQualityPreset GetQualityPreset();
+			
+			/*	H.264 Profile */
+			void SetProfile(VCEProfile profile);
+			VCEProfile GetProfile();
+
+			/*	H.264 Profile Level */
+			void SetProfileLevel(VCEProfileLevel level);
+			VCEProfileLevel GetProfileLevel();
+
+			/*	The number of long-term references controlled by the user.
+			 *
+			 *	Remarks:
+			 * - When == 0, the encoder may or may not use LTRs during encoding.
+			 *	- When >0, the user has control over all LTR.
+			 *	- With user control of LTR, B-pictures and Intra-refresh features are not supported.
+			 *	- The actual maximum number of LTRs allowed depends on H.264 Annex A Table A-1 Level limits, which defines dependencies between the H.264 Level number, encoding resolution, and DPB size. The DPB size limit impacts the maximum number of LTR allowed.
+			 **/
+			void SetMaximumLongTermReferenceFrames(uint32_t maximumLTRFrames);	// Long-Term Reference Frames. If 0, Encoder decides, if non-0 B-Pictures and Intra-Refresh are not supported.
+			uint32_t GetMaximumLongTermReferenceFrames();
+
+			/* Coding Type */
+			void SetCodingType(VCECodingType type);
+			VCECodingType GetCodingType();
+
+			/************************************************************************/
+			/* Frame Properties */
+			/************************************************************************/
+
+			void SetColorProfile(VCEColorProfile profile);
+			VCEColorProfile GetColorProfile();
+
+			void SetFullColorRangeEnabled(bool enabled);
+			bool IsFullColorRangeEnabled();
+
+			/* Selects progressive or interlaced scan
+			* Static Property, changes cause a restart. */
+			void SetScanType(VCEScanType scanType);
+			VCEScanType GetScanType();
+
+			/*	Output Resolution */
+			void SetFrameSize(uint32_t width, uint32_t height);
+			std::pair<uint32_t, uint32_t> GetFrameSize();
+
+			/*	Sets the Frame Rate numerator and denumerator */
+			void SetFrameRate(uint32_t num, uint32_t den);
+			std::pair<uint32_t, uint32_t> GetFrameRate();
+
+			/************************************************************************/
+			/* Rate Control Properties */
+			/************************************************************************/
+			
+			/*	Selects the rate control method:
+			*	- CQP - Constrained QP,
+			*	- CBR - Constant Bitrate,
+			*	- VBR - Peak Constrained VBR,
+			*	- VBR_LAT - Latency Constrained VBR
+			*
+			*	Remarks:
+			*	- When SVC encoding is enabled, all Rate-control parameters (with some restrictions) can be configured differently for a particular SVC-layer. An SVC-layer is denoted by an index pair [SVC-Temporal Layer index][SVC-Quality Layer index]. E.g. The bitrate may be configured differently for SVC-layers [0][0] and [1][0].
+			*	- We restrict all SVC layers to have the same Rate Control method. Some RC parameters are not enabled with SVC encoding (e.g. all parameters related to B-pictures).
+			**/
+			void SetRateControlMethod(VCERateControlMethod method);
+			VCERateControlMethod GetRateControlMethod();
+
+			/*	Sets the target bitrate */
+			void SetTargetBitrate(uint32_t bitrate);
+			uint32_t GetTargetBitrate();
+
+			/*	Sets the peak bitrate */
+			void SetPeakBitrate(uint32_t bitrate);
+			uint32_t GetPeakBitrate();
+
+			/*	Sets the minimum QP */
+			void SetMinimumQP(uint8_t qp);
+			uint8_t GetMinimumQP();
+
+			/*	Sets the maximum QP */
+			void SetMaximumQP(uint8_t qp);
+			uint8_t GetMaximumQP();
+
+			/*	Sets the Constant QP for I-Pictures.
+			*
+			*	Remarks:
+			*	- Only available for CQP rate control method.
+			**/
+			void SetIFrameQP(uint8_t qp);
+			uint8_t GetIFrameQP();
+
+			/*	Sets the Constant QP for P-Pictures.
+			*
+			*	Remarks:
+			*	- Only available for CQP rate control method.
+			**/
+			void SetPFrameQP(uint8_t qp);
+			uint8_t GetPFrameQP();
+
+			/*	Sets the Constant QP for B-Pictures.
+			*
+			*	Remarks:
+			*	- Only available for CQP rate control method.
+			**/
+			void SetBFrameQP(uint8_t qp);
+			uint8_t GetBFrameQP();
+
+			/* Selects the delta QP of non-reference B-Pictures with respect to I pictures */
+			void SetBPictureDeltaQP(int8_t qp);
+			int8_t GetBPictureDeltaQP();
+
+			/* Selects delta QP of reference B-Pictures with respect to I pictures */
+			void SetReferenceBPictureDeltaQP(int8_t qp);
+			int8_t GetReferenceBPictureDeltaQP();
+
+			/*	Sets the VBV Buffer Size in bits */
+			void SetVBVBufferSize(uint32_t size);
+			void SetVBVBufferAutomatic(double_t strictness);
+			uint32_t GetVBVBufferSize();
+
+			/*	Sets the initial VBV Buffer Fullness */
+			void SetInitialVBVBufferFullness(double_t fullness);
+			double_t GetInitialVBVBufferFullness();
+
+			/*	Sets Maximum AU Size in bits */
+			void SetMaximumAccessUnitSize(uint32_t size);
+			uint32_t GetMaximumAccessUnitSize();
+
+			/*	Enables/Disables filler data */
+			void SetFillerDataEnabled(bool enabled);
+			bool IsFillerDataEnabled();
+
+			/*	Enables skip frame for rate control */
+			void SetFrameSkippingEnabled(bool enabled);
+			bool IsFrameSkippingEnabled();
+
+			/*	Enables/Disables constraints on QP variation within a picture to meet HRD requirement(s) */
+			void SetEnforceHRDRestrictionsEnabled(bool enforce);
+			bool IsEnforceHRDRestrictionsEnabled();
+
+			/************************************************************************/
+			/* Picture Control Properties */
+			/************************************************************************/
+
+			/*	Sets IDR period. IDRPeriod= 0 turns IDR off */
+			void SetIDRPeriod(uint32_t period);
+			uint32_t GetIDRPeriod();
+
+			/*	Sets the headers insertion spacing */
+			void SetHeaderInsertionSpacing(uint32_t spacing); // Similar to IDR Period, spacing (in frames) between headers.
+			uint32_t GetHeaderInsertionSpacing();
+
+			/*	Sets the number of consecutive B-pictures in a GOP. BPicturesPattern = 0 indicates that B-pictures are not used */
+			void SetBPicturePattern(VCEBPicturePattern pattern);
+			VCEBPicturePattern GetBPicturePattern();
+
+			/*	Enables or disables using B-pictures as references */
+			void SetBPictureReferenceEnabled(bool enabled);
+			bool IsBPictureReferenceEnabled();
+
+			/*	Turns on/off the Deblocking Filter */
+			void SetDeblockingFilterEnabled(bool enabled);
+			bool IsDeblockingFilterEnabled();
+
+			/*	Sets the number of slices per frame */
+			void SetSlicesPerFrame(uint32_t slices);
+			uint32_t GetSlicesPerFrame();
+
+			/*	Sets the number of intra-refresh macro-blocks per slot */
+			void SetIntraRefreshMBsNumberPerSlot(uint32_t mbs);
+			uint32_t GetIntraRefreshMBsNumberPerSlot();
+
+			/************************************************************************/
+			/* Miscellaneous Control Properties */
+			/************************************************************************/
+			
+			/* Turns on/off half-pixel motion estimation */
+			void SetHalfPixelMotionEstimationEnabled(bool enabled);
+			bool IsHalfPixelMotionEstimationEnabled();
+
+			/* Turns on/off quarter-pixel motion estimation */
+			void SetQuarterPixelMotionEstimationEnabled(bool enabled);
+			bool IsQuarterPixelMotionEstimationEnabled();
+
+			/************************************************************************/
+			/* Hidden Properties */
+			/************************************************************************/
+			
+			void SetGOPSize(uint32_t gopSize);
+			uint32_t GetGOPSize();
+
+			void SetWaitForTaskEnabled(bool enabled);
+			bool IsWaitForTaskEnabled();
+
+			void SetAspectRatio(uint32_t x, uint32_t y);
+			std::pair<uint32_t, uint32_t> GetAspectRatio();
+
+			void SetMaximumNumberOfReferenceFrames(uint32_t frameCount);
+			uint32_t GetMaximumNumberOfReferenceFrames();
+
+			uint32_t GetMaxMBPerSec();
+
+			void SetInstanceID(uint32_t instanceId);
+			uint32_t GetInstanceID();
+
+			void SetVBAQEnabled(bool enabled);
+			bool IsVBAQEnabled();
+
+			void SetRateControlPreanalysisEnabled(bool enabled);
+			bool IsRateControlPreanalysisEnabled();
+
+			void SetIntraRefreshNumberOfStripes(uint32_t stripes); // 0 - INT_MAX
+			uint32_t GetIntraRefreshNumberOfStripes();
+
+			void SetSliceMode(uint32_t mode); // 1 or 2
+			uint32_t GetSliceMode();
+
+			void SetMaximumSliceSize(uint32_t size); // 0 - INT_MAX
+			uint32_t GetMaximumSliceSize();
+
+			// - SliceControlMode: AMF_VIDEO_ENCODER_SLICE_CTRL_MODE_MB_ROW, AMF_VIDEO_ENCODER_SLICE_CTRL_MODE_MB
+			void SetSliceControlMode(uint32_t mode); // 0, 1, 2, 3
+			uint32_t GetSliceControlMode();
+
+			void SetSliceControlSize(uint32_t size); // 0 - INT_MAX
+			uint32_t GetSliceControlSize();
+
+			// HEVC Parameters
+			// - MinQP_I, MaxQP_I
+			// - MinQP_P, MaxQP_P
+			// - QPCBOFFSET, QPCROFFSET
+			// - GOPPerIDR
+			// - GOPSizeMin, GOPSizeMax
+			// - EnableGOPAlignment
+
+			#pragma endregion Methods
+			//////////////////////////////////////////////////////////////////////////
+
+			//////////////////////////////////////////////////////////////////////////
+			#pragma region Members
+			//////////////////////////////////////////////////////////////////////////
+			private:
+
+			// AMF Data References
+			std::shared_ptr<Plugin::AMD::AMF> m_AMF;
+			amf::AMFFactory* m_AMFFactory;
+			amf::AMFContextPtr m_AMFContext;
+			amf::AMFComponentPtr m_AMFConverter;
+			amf::AMFComponentPtr m_AMFEncoder;
+			amf::AMFComputePtr m_AMFCompute;
+
+			// API References
+			std::unique_ptr<Plugin::API::APIBase> m_APIDevice;
+
+			// Static Buffers
+			std::vector<uint8_t> m_PacketDataBuffer;
+			std::vector<uint8_t> m_ExtraDataBuffer;
+
+			// Structured Queue
+			struct {
+				std::queue<amf::AMFSurfacePtr> queue;
+
+				// Threading
+				std::thread thread;
+				std::mutex mutex;
+				std::condition_variable condvar;
+				std::mutex queuemutex;
+			} m_Input;
+			struct {
+				std::queue<amf::AMFDataPtr> queue;
+
+				// Threading
+				std::thread thread;
+				std::mutex mutex;
+				std::condition_variable condvar;
+				std::mutex queuemutex;
+			} m_Output;
+
+			// Internal Properties
+			VCEEncoderType m_EncoderType;
+			VCEMemoryType m_MemoryType;
+			bool m_UseOpenCL;
+			VCEColorFormat m_SurfaceFormat;
+			bool m_Flag_IsStarted,
+				m_Flag_FirstFrameSubmitted,
+				m_Flag_FirstFrameReceived;
+			std::pair<uint32_t, uint32_t> m_FrameSize,
+				m_FrameRate;
+			double_t m_FrameRateDivisor,
+				m_FrameRateReverseDivisor;
+			size_t m_InputQueueLimit,
+				m_InputQueueLastSize;
+			uint32_t m_TimerPeriod;
+			VCEColorProfile m_ColorProfile;
+			
+			#pragma endregion Members
+			//////////////////////////////////////////////////////////////////////////
+		};
+	}
+}
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/amd-amf.h Changed

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/api-base.h Added

@@ -0,0 +1,87 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "plugin.h"
+#include <vector>
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+namespace Plugin {
+	namespace API {
+		struct Device {
+			std::string Name;
+			std::string UniqueId;
+
+			Device();
+			Device(std::string Name, std::string UniqueId);
+			~Device();
+
+
+			friend bool operator<(const Plugin::API::Device& left, const Plugin::API::Device& right);
+			friend bool operator>(const Plugin::API::Device& left, const Plugin::API::Device& right);
+			friend bool operator<=(const Plugin::API::Device& left, const Plugin::API::Device& right);
+			friend bool operator>=(const Plugin::API::Device& left, const Plugin::API::Device& right);
+
+			friend bool operator==(const Plugin::API::Device& left, const Plugin::API::Device& right);
+			friend bool operator!=(const Plugin::API::Device& left, const Plugin::API::Device& right);
+		};
+
+		enum APIType {
+			APIType_Base,
+			APIType_Direct3D9,
+			APIType_Direct3D11,
+			APIType_OpenGL,
+		};
+
+		class APIBase {
+			public:
+			static std::vector<Plugin::API::Device> EnumerateDevices();
+			static Plugin::API::Device GetDeviceForUniqueId(std::string uniqueId);
+
+			static Plugin::API::APIType GetBestAvailableAPI();
+			static std::unique_ptr<Plugin::API::APIBase>
+				CreateBestAvailableAPI(Plugin::API::Device device);
+
+			APIBase();
+			APIBase(Device device);
+			virtual ~APIBase();
+
+			Plugin::API::Device GetDevice();
+
+			virtual Plugin::API::APIType GetType();
+			virtual void* GetContext();
+			
+			protected:
+			Plugin::API::APIType myType;
+
+			private:
+			Plugin::API::Device myDevice;
+		};
+	}
+}
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/api-d3d11.h Added

@@ -0,0 +1,55 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+#ifdef _WIN32
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "api-base.h"
+
+#include <d3d11.h>
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+namespace Plugin {
+	namespace API {
+		class Direct3D11 : public APIBase {
+			public:
+			static std::vector<Plugin::API::Device> EnumerateDevices();
+			static Plugin::API::Device GetDeviceForUniqueId(std::string uniqueId);
+
+			Direct3D11(Device device);
+			~Direct3D11();
+
+			virtual void* GetContext() override;
+
+			private:
+			ID3D11Device* pDevice;
+			ID3D11DeviceContext* pDeviceContext;
+		};
+	}
+}
+#endif

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/api-d3d9.h Added

@@ -0,0 +1,57 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+#ifdef _WIN32
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "api-base.h"
+
+#define D3D_DEBUG_INFO
+#include <d3d9.h>
+#pragma comment(lib, "d3d9.lib")
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+namespace Plugin {
+	namespace API {
+		class Direct3D9 : public APIBase {
+			public:
+			static std::vector<Plugin::API::Device> EnumerateDevices();
+			static Plugin::API::Device GetDeviceForUniqueId(std::string uniqueId);
+
+			Direct3D9(Device device);
+			~Direct3D9();
+
+			virtual void* GetContext() override;
+
+			private:
+			IDirect3D9* pDirect3D;
+			IDirect3DDevice9* pDirect3DDevice;
+		};
+	}
+}
+#endif

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/enc-h264.h Added

@@ -0,0 +1,76 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+// Plugin
+#include "plugin.h"
+#include "amd-amf-vce.h"
+#include "amd-amf-vce-capabilities.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+namespace Plugin {
+	namespace Interface {
+		class H264Interface {
+			public:
+			static void encoder_register();
+			static const char* get_name(void* type_data);
+			static const char* get_name_simple(void* type_data);
+			static void get_defaults(obs_data_t *settings);
+			static obs_properties_t* get_properties(void* data);
+			
+			static bool properties_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data);
+
+			static void* create(obs_data_t* settings, obs_encoder_t* encoder);
+			static void destroy(void* data);
+			static bool update(void *data, obs_data_t *settings);
+			static bool encode(void *data, struct encoder_frame * frame, struct encoder_packet * packet, bool * received_packet);
+			static void get_video_info(void *data, struct video_scale_info *info);
+			static bool get_extra_data(void *data, uint8_t** extra_data, size_t* size);
+
+			//////////////////////////////////////////////////////////////////////////
+			// Module Code
+			//////////////////////////////////////////////////////////////////////////
+			public:
+
+			H264Interface(obs_data_t* settings, obs_encoder_t* encoder);
+			~H264Interface();
+
+			bool update(obs_data_t* settings);
+			bool encode(struct encoder_frame * frame, struct encoder_packet * packet, bool * received_packet);
+			void get_video_info(struct video_scale_info* info);
+			bool get_extra_data(uint8_t** extra_data, size_t* size);
+
+			//////////////////////////////////////////////////////////////////////////
+			// Storage
+			//////////////////////////////////////////////////////////////////////////
+			private:
+			Plugin::AMD::VCEEncoder* m_VideoEncoder;
+		};
+	}
+}
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Include/plugin.h Added

@@ -0,0 +1,226 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <stdint.h>
+#include <inttypes.h>
+#include <exception>
+#include <stdexcept>
+#include <thread>
+#include <memory>
+
+// Open Broadcaster Software
+#pragma warning( disable: 4201 )
+#include "libobs/obs-module.h"
+#include "libobs/obs-encoder.h"
+
+MODULE_EXTERN const char *obs_module_text_multi(const char *val, uint8_t depth = (uint8_t)1);
+
+//////////////////////////////////////////////////////////////////////////
+// Defines
+//////////////////////////////////////////////////////////////////////////
+
+#define vstr(s) dstr(s)
+#define dstr(s) #s
+
+#define clamp(a,b,c) (a > c ? c : (a < b ? b : a))
+
+#include "Version.h"
+#define PLUGIN_VERSION_FULL				(((uint64_t)PLUGIN_VERSION_MAJOR << 48ull) | ((uint64_t)PLUGIN_VERSION_MINOR << 32ull) | ((uint64_t)PLUGIN_VERSION_PATCH) | ((uint64_t)PLUGIN_VERSION_BUILD))
+#define PLUGIN_VERSION_TEXT				vstr(PLUGIN_VERSION_MAJOR) "." vstr(PLUGIN_VERSION_MINOR) "." vstr(PLUGIN_VERSION_PATCH) "." vstr(PLUGIN_VERSION_BUILD)
+
+#define AMF_LOG(level, format, ...)		blog(level, "[AMF Encoder] " format, ##__VA_ARGS__);
+#define AMF_LOG_ERROR(format, ...)		AMF_LOG(LOG_ERROR, format, ##__VA_ARGS__)
+#define AMF_LOG_WARNING(format, ...)	AMF_LOG(LOG_WARNING, format, ##__VA_ARGS__)
+#define AMF_LOG_INFO(format, ...)		AMF_LOG(LOG_INFO, format, ##__VA_ARGS__)
+#define AMF_LOG_CONFIG(format, ...)		AMF_LOG(350, format, ##__VA_ARGS__)
+#define AMF_LOG_DEBUG(format, ...)		AMF_LOG(LOG_DEBUG, format, ##__VA_ARGS__)
+
+#define TEXT_T(x)						obs_module_text_multi(x)
+#define TEXT_AMF(x)						("AMF." ## x)
+#define TEXT_AMF_H264(x)				(TEXT_AMF("H264." ## x))
+#define TEXT_AMF_UTIL(x)				(TEXT_AMF("Util." ## x))
+
+#define ThrowExceptionWithAMFError(format, res, ...) {\
+	std::vector<char> _throwexceptionwithamferror_buf(8192);\
+	sprintf_s(_throwexceptionwithamferror_buf.data(), _throwexceptionwithamferror_buf.size(), format, ##__VA_ARGS__, Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);\
+	AMF_LOG_WARNING("%s", _throwexceptionwithamferror_buf.data()); \
+	throw std::exception(_throwexceptionwithamferror_buf.data()); \
+}
+
+#ifndef __FUNCTION_NAME__
+	#if defined(_WIN32) || defined(_WIN64) //WINDOWS
+		#define __FUNCTION_NAME__ __FUNCTION__ 
+	#else //*NIX
+		#define __FUNCTION_NAME__ __func__ 
+	#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// Defines - Translation Strings
+//////////////////////////////////////////////////////////////////////////
+
+// Presets
+#define AMF_H264_PRESET							TEXT_AMF_H264("Preset")
+#define AMF_H264_PRESET_RESETTODEFAULTS			TEXT_AMF_H264("Preset.ResetToDefaults")
+#define AMF_H264_PRESET_RECORDING				TEXT_AMF_H264("Preset.Recording")
+#define AMF_H264_PRESET_HIGHQUALITY				TEXT_AMF_H264("Preset.HighQuality")
+#define AMF_H264_PRESET_INDISTINGUISHABLE		TEXT_AMF_H264("Preset.Indistinguishable")
+#define AMF_H264_PRESET_LOSSLESS				TEXT_AMF_H264("Preset.Lossless")
+#define AMF_H264_PRESET_TWITCH					TEXT_AMF_H264("Preset.Twitch")
+#define AMF_H264_PRESET_YOUTUBE					TEXT_AMF_H264("Preset.YouTube")
+
+// Static Properties
+#define AMF_H264_USAGE							TEXT_AMF_H264("Usage")
+#define AMF_H264_USAGE_DESCRIPTION				TEXT_AMF_H264("Usage.Description")
+#define AMF_H264_USAGE_TRANSCODING				TEXT_AMF_H264("Usage.Transcoding")
+#define AMF_H264_USAGE_ULTRALOWLATENCY			TEXT_AMF_H264("Usage.UltraLowLatency")
+#define AMF_H264_USAGE_LOWLATENCY				TEXT_AMF_H264("Usage.LowLatency")
+#define AMF_H264_USAGE_WEBCAM					TEXT_AMF_H264("Usage.Webcam")
+#define AMF_H264_QUALITY_PRESET					TEXT_AMF_H264("QualityPreset")
+#define AMF_H264_QUALITY_PRESET_DESCRIPTION		TEXT_AMF_H264("QualityPreset.Description")
+#define AMF_H264_QUALITY_PRESET_SPEED			TEXT_AMF_H264("QualityPreset.Speed")
+#define AMF_H264_QUALITY_PRESET_BALANCED		TEXT_AMF_H264("QualityPreset.Balanced")
+#define AMF_H264_QUALITY_PRESET_QUALITY			TEXT_AMF_H264("QualityPreset.Quality")
+#define AMF_H264_PROFILE						TEXT_AMF_H264("Profile")
+#define AMF_H264_PROFILE_DESCRIPTION			TEXT_AMF_H264("Profile.Description")
+#define AMF_H264_PROFILELEVEL					TEXT_AMF_H264("ProfileLevel")
+#define AMF_H264_PROFILELEVEL_DESCRIPTION		TEXT_AMF_H264("ProfileLevel.Description")
+#define AMF_H264_MAXIMUMLTRFRAMES				TEXT_AMF_H264("MaximumLTRFrames")
+#define AMF_H264_MAXIMUMLTRFRAMES_DESCRIPTION	TEXT_AMF_H264("MaximumLTRFrames.Description")
+#define AMF_H264_CODINGTYPE						TEXT_AMF_H264("CodingType")
+#define AMF_H264_CODINGTYPE_DESCRIPTION			TEXT_AMF_H264("CodingType.Description")
+
+// Rate Control Properties
+#define AMF_H264_RATECONTROLMETHOD				TEXT_AMF_H264("RateControlMethod")
+#define AMF_H264_RATECONTROLMETHOD_DESCRIPTION	TEXT_AMF_H264("RateControlMethod.Description")
+#define AMF_H264_RATECONTROLMETHOD_CQP			TEXT_AMF_H264("RateControlMethod.CQP")
+#define AMF_H264_RATECONTROLMETHOD_CBR			TEXT_AMF_H264("RateControlMethod.CBR")
+#define AMF_H264_RATECONTROLMETHOD_VBR			TEXT_AMF_H264("RateControlMethod.VBR.Peak")
+#define AMF_H264_RATECONTROLMETHOD_VBR_LAT		TEXT_AMF_H264("RateControlMethod.VBR.Latency")
+#define AMF_H264_BITRATE_TARGET					TEXT_AMF_H264("Bitrate.Target")
+#define AMF_H264_BITRATE_TARGET_DESCRIPTION		TEXT_AMF_H264("Bitrate.Target.Description")
+#define AMF_H264_BITRATE_PEAK					TEXT_AMF_H264("Bitrate.Peak")
+#define AMF_H264_BITRATE_PEAK_DESCRIPTION		TEXT_AMF_H264("Bitrate.Peak.Description")
+#define AMF_H264_QP_MINIMUM						TEXT_AMF_H264("QP.Minimum")
+#define AMF_H264_QP_MINIMUM_DESCRIPTION			TEXT_AMF_H264("QP.Minimum.Description")
+#define AMF_H264_QP_MAXIMUM						TEXT_AMF_H264("QP.Maximum")
+#define AMF_H264_QP_MAXIMUM_DESCRIPTION			TEXT_AMF_H264("QP.Maximum.Description")
+#define AMF_H264_QP_IFRAME						TEXT_AMF_H264("QP.IFrame")
+#define AMF_H264_QP_IFRAME_DESCRIPTION			TEXT_AMF_H264("QP.IFrame.Description")
+#define AMF_H264_QP_PFRAME						TEXT_AMF_H264("QP.PFrame")
+#define AMF_H264_QP_PFRAME_DESCRIPTION			TEXT_AMF_H264("QP.PFrame.Description")
+#define AMF_H264_QP_BFRAME						TEXT_AMF_H264("QP.BFrame")
+#define AMF_H264_QP_BFRAME_DESCRIPTION			TEXT_AMF_H264("QP.BFrame.Description")
+#define AMF_H264_QP_BPICTURE_DELTA				TEXT_AMF_H264("QP.BPictureDelta")
+#define AMF_H264_QP_BPICTURE_DELTA_DESCRIPTION	TEXT_AMF_H264("QP.BPictureDelta.Description")
+#define AMF_H264_QP_REFERENCE_BPICTURE_DELTA	TEXT_AMF_H264("QP.ReferenceBPictureDelta")
+#define AMF_H264_QP_REFERENCE_BPICTURE_DELTA_DESCRIPTION	TEXT_AMF_H264("QP.ReferenceBPictureDelta.Description")
+#define AMF_H264_VBVBUFFER						TEXT_AMF_H264("VBVBuffer")
+#define AMF_H264_VBVBUFFER_DESCRIPTION			TEXT_AMF_H264("VBVBuffer.Description")
+#define AMF_H264_VBVBUFFER_STRICTNESS			TEXT_AMF_H264("VBVBuffer.Strictness")
+#define AMF_H264_VBVBUFFER_STRICTNESS_DESCRIPTION	TEXT_AMF_H264("VBVBuffer.Strictness.Description")
+#define AMF_H264_VBVBUFFER_SIZE					TEXT_AMF_H264("VBVBuffer.Size")
+#define AMF_H264_VBVBUFFER_SIZE_DESCRIPTION		TEXT_AMF_H264("VBVBuffer.Size.Description")
+#define AMF_H264_VBVBUFFER_FULLNESS				TEXT_AMF_H264("VBVBuffer.Fullness")
+#define AMF_H264_VBVBUFFER_FULLNESS_DESCRIPTION	TEXT_AMF_H264("VBVBuffer.Fullness.Description")
+#define AMF_H264_FILLERDATA						TEXT_AMF_H264("FillerData")
+#define AMF_H264_FILLERDATA_DESCRIPTION			TEXT_AMF_H264("FillerData.Description")
+#define AMF_H264_FRAMESKIPPING					TEXT_AMF_H264("FrameSkipping")
+#define AMF_H264_FRAMESKIPPING_DESCRIPTION		TEXT_AMF_H264("FrameSkipping.Description")
+#define AMF_H264_ENFORCEHRDCOMPATIBILITY		TEXT_AMF_H264("EnforceHRDCompatibility")
+#define AMF_H264_ENFORCEHRDCOMPATIBILITY_DESCRIPTION	TEXT_AMF_H264("EnforceHRDCompatibility.Description")
+#define AMF_H264_MAXIMUMACCESSUNITSIZE			TEXT_AMF_H264("MaximumAccessUnitSize")
+#define AMF_H264_MAXIMUMACCESSUNITSIZE_DESCRIPTION	TEXT_AMF_H264("MaximumAccessUnitSize.Description")
+
+// Picture Control Properties
+#define AMF_H264_KEYFRAME_INTERVAL				TEXT_AMF_H264("KeyframeInterval")
+#define AMF_H264_KEYFRAME_INTERVAL_DESCRIPTION	TEXT_AMF_H264("KeyframeInterval.Description")
+#define AMF_H264_IDR_PERIOD						TEXT_AMF_H264("IDRPeriod")
+#define AMF_H264_IDR_PERIOD_DESCRIPTION			TEXT_AMF_H264("IDRPeriod.Description")
+#define AMF_H264_HEADER_INSERTION_SPACING		TEXT_AMF_H264("HeaderInsertionSpacing")
+#define AMF_H264_HEADER_INSERTION_SPACING_DESCRIPTION	TEXT_AMF_H264("HeaderInsertionSpacing.Description")
+#define AMF_H264_BPICTURE_PATTERN				TEXT_AMF_H264("BPicture.Pattern")
+#define AMF_H264_BPICTURE_PATTERN_DESCRIPTION	TEXT_AMF_H264("BPicture.Pattern.Description")
+#define AMF_H264_BPICTURE_REFERENCE				TEXT_AMF_H264("BPicture.Reference")
+#define AMF_H264_BPICTURE_REFERENCE_DESCRIPTION	TEXT_AMF_H264("BPicture.Reference.Description")
+#define AMF_H264_DEBLOCKINGFILTER				TEXT_AMF_H264("DeblockingFilter")
+#define AMF_H264_DEBLOCKINGFILTER_DESCRIPTION	TEXT_AMF_H264("DeblockingFilter.Description")
+#define AMF_H264_SLICESPERFRAME					TEXT_AMF_H264("SlicesPerFrame")
+#define AMF_H264_SLICESPERFRAME_DESCRIPTION		TEXT_AMF_H264("SlicesPerFrame.Description")
+#define AMF_H264_INTRAREFRESHNUMMBSPERSLOT		TEXT_AMF_H264("IntraRefreshNumMBsPerSlot")
+#define AMF_H264_INTRAREFRESHNUMMBSPERSLOT_DESCRIPTION	TEXT_AMF_H264("IntraRefreshNumMBsPerSlot.Description")
+
+// Miscellaneous Properties
+#define AMF_H264_SCANTYPE						TEXT_AMF_H264("ScanType")
+#define AMF_H264_SCANTYPE_DESCRIPTION			TEXT_AMF_H264("ScanType.Description")
+#define AMF_H264_SCANTYPE_PROGRESSIVE			TEXT_AMF_H264("ScanType.Progressive")
+#define AMF_H264_SCANTYPE_INTERLACED			TEXT_AMF_H264("ScanType.Interlaced")
+#define AMF_H264_MOTIONESTIMATION				TEXT_AMF_H264("MotionEstimation")
+#define AMF_H264_MOTIONESTIMATION_DESCRIPTION	TEXT_AMF_H264("MotionEstimation.Description")
+#define AMF_H264_MOTIONESTIMATION_NONE			TEXT_AMF_H264("MotionEstimation.None")
+#define AMF_H264_MOTIONESTIMATION_HALF			TEXT_AMF_H264("MotionEstimation.Half")
+#define AMF_H264_MOTIONESTIMATION_QUARTER		TEXT_AMF_H264("MotionEstimation.Quarter")
+#define AMF_H264_MOTIONESTIMATION_BOTH			TEXT_AMF_H264("MotionEstimation.Both")
+
+// System Properties
+#define AMF_H264_DEVICE							TEXT_AMF_H264("Device")
+#define AMF_H264_DEVICE_DESCRIPTION				TEXT_AMF_H264("Device.Description")
+#define AMF_H264_USE_OPENCL						TEXT_AMF_H264("UseOpenCL")
+#define AMF_H264_USE_OPENCL_DESCRIPTION			TEXT_AMF_H264("UseOpenCL.Description")
+#define AMF_H264_VIEW							TEXT_AMF_H264("View")
+#define AMF_H264_VIEW_DESCRIPTION				TEXT_AMF_H264("View.Description")
+#define AMF_H264_VIEW_BASIC						TEXT_AMF_H264("View.Basic")
+#define AMF_H264_VIEW_ADVANCED					TEXT_AMF_H264("View.Advanced")
+#define AMF_H264_VIEW_EXPERT					TEXT_AMF_H264("View.Expert")
+#define AMF_H264_VIEW_MASTER					TEXT_AMF_H264("View.Master")
+#define AMF_H264_UNLOCK_PROPERTIES				TEXT_AMF_H264("UnlockProperties")
+#define AMF_H264_UNLOCK_PROPERTIES_DESCRIPTION	TEXT_AMF_H264("UnlockProperties.Description")
+#define AMF_H264_DEBUG							TEXT_AMF_H264("Debug")
+#define AMF_H264_DEBUG_DESCRIPTION				TEXT_AMF_H264("Debug.Description")
+
+// Utility
+#define AMF_UTIL_DEFAULT						TEXT_AMF_UTIL("Default")
+#define AMF_UTIL_AUTOMATIC						TEXT_AMF_UTIL("Automatic")
+#define AMF_UTIL_MANUAL							TEXT_AMF_UTIL("Manual")
+#define AMF_UTIL_TOGGLE_DISABLED				TEXT_AMF_UTIL("Toggle.Disabled")
+#define AMF_UTIL_TOGGLE_ENABLED					TEXT_AMF_UTIL("Toggle.Enabled")
+
+//////////////////////////////////////////////////////////////////////////
+// Threading Specific
+//////////////////////////////////////////////////////////////////////////
+
+#if (defined _WIN32) || (defined _WIN64)
+void SetThreadName(uint32_t dwThreadID, const char* threadName);
+void SetThreadName(const char* threadName);
+void SetThreadName(std::thread* thread, const char* threadName);
+
+#else
+void SetThreadName(std::thread* thread, const char* threadName);
+void SetThreadName(const char* threadName);
+
+#endif
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/bg-BG.ini Changed

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/ca-ES.ini Added

@@ -0,0 +1,61 @@
+AMF.H264.Preset="Configuració preestablerta"
+AMF.H264.Preset.Recording="S'està enregistrant"
+AMF.H264.Preset.HighQuality="Alta qualitat"
+AMF.H264.Preset.Indistinguishable="Indistinguible"
+AMF.H264.Preset.Lossless="Sense pèrdues"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Ús"
+AMF.H264.Usage.Description="Quin ús s'ha d'ajustar AMF:\n- 'Codificació' és per a ús generalitzat (recomanat),\n- 'Latència Ultra Baixa' és per a una codificació de molt baixa latència,\n- 'Latència Baixa' és similar a l'anterior amb alguna cosa mes de latència.\nLes retransmissions en directe només suporten 'Codificació', tots els valors poden ser utilitzats per a enregistrar."
+AMF.H264.Usage.Transcoding="Transcodificació"
+AMF.H264.Usage.UltraLowLatency="Latència ultra baixa"
+AMF.H264.Usage.LowLatency="Latència baixa"
+AMF.H264.QualityPreset="Qualitat del perfil"
+AMF.H264.QualityPreset.Speed="Velocitat"
+AMF.H264.QualityPreset.Balanced="Equilibrat"
+AMF.H264.QualityPreset.Quality="Qualitat"
+AMF.H264.Profile="Perfil"
+AMF.H264.ProfileLevel="Nivell de perfil"
+AMF.H264.MaximumLTRFrames="Fotogrames màxims LTR"
+AMF.H264.ScanType="Tipus d'exploració"
+AMF.H264.ScanType.Progressive="Progressiu"
+AMF.H264.ScanType.Interlaced="Entrellaçat"
+AMF.H264.RateControlMethod="Mètode de control del flux"
+AMF.H264.RateControlMethod.CQP="QP constant (CQP)"
+AMF.H264.RateControlMethod.CBR="Flux constant (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Flux variable (pic restringit)(VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Flux variable (latència restringida) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Tassa de bits desitjada"
+AMF.H264.Bitrate.Peak="Pic de tassa de bits"
+AMF.H264.QP.Minimum="QP mínim"
+AMF.H264.QP.Maximum="QP màxim"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta="QP Delta en B-Pictures de referencia"
+AMF.H264.FillerData="Dades a omplir"
+AMF.H264.FrameSkipping="Omissió de fotogrames"
+AMF.H264.EnforceHRDCompatibility="Força la compatibilitat amb HRD"
+AMF.H264.BPicture.Pattern="Patró B-Picture"
+AMF.H264.BPicture.Reference="Referència B-Picture"
+AMF.H264.DeblockingFilter="Filtre d'eliminació de blocs"
+AMF.H264.MotionEstimation.None="Cap"
+AMF.H264.MotionEstimation.Half="Meitat de píxel"
+AMF.H264.MotionEstimation.Quarter="Quart de Píxel"
+AMF.H264.Device="Dispositiu"
+AMF.H264.View="Mode de visualització"
+AMF.H264.View.Description="Quines propietats han de ser visibles. No rebreu suport si feu servir el mode de vista 'Expert' o 'Màster'."
+AMF.H264.View.Basic="Bàsic"
+AMF.H264.View.Advanced="Avançat"
+AMF.H264.View.Expert="Expert"
+AMF.H264.View.Master="Màster"
+AMF.H264.UnlockProperties="Desbloqueja les propietats"
+AMF.H264.UnlockProperties.Description="Desbloqueja algunes propietats a la seva màxima capacitat en lloc de limitar-les de forma parcial."
+AMF.H264.Debug="Depuració"
+AMF.H264.Debug.Description="Habilita el registre d'informació de depuració addicional, ha de ser activat quan necessiteu ajuda amb aquest codificador."
+AMF.Util.Default="Per defecte"
+AMF.Util.Automatic="Automàtic"
+AMF.Util.Manual="Manual"
+AMF.Util.Toggle.Disabled="Desactivat"
+AMF.Util.Toggle.Enabled="Activat"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/cs-CZ.ini Added

@@ -0,0 +1,63 @@
+AMF.H264.Preset="Profil"
+AMF.H264.Preset.ResetToDefaults="Obnovit výchozí"
+AMF.H264.Preset.Recording="Nahrávání"
+AMF.H264.Preset.HighQuality="Vysoká kvalita"
+AMF.H264.Preset.Indistinguishable="Nerozeznatelné"
+AMF.H264.Preset.Lossless="Lossless"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Využití"
+AMF.H264.Usage.Transcoding="Kódování"
+AMF.H264.Usage.UltraLowLatency="Ultra nízká odezva"
+AMF.H264.Usage.LowLatency="Nízká odezva"
+AMF.H264.QualityPreset="Profil kvality"
+AMF.H264.QualityPreset.Speed="Rychlost"
+AMF.H264.QualityPreset.Balanced="Vyváženo"
+AMF.H264.QualityPreset.Quality="Kvalita"
+AMF.H264.Profile="Profil"
+AMF.H264.ProfileLevel="Úroveň profilu"
+AMF.H264.MaximumLTRFrames="Maximální počet LTR snímků"
+AMF.H264.ScanType="Typ skenování"
+AMF.H264.ScanType.Description="Určuje použitou metodu skenování, vždy ponechejte na 'Progresivní'."
+AMF.H264.ScanType.Progressive="Progresivní"
+AMF.H264.ScanType.Interlaced="Prokládané"
+AMF.H264.RateControlMethod="Metoda řízení"
+AMF.H264.RateControlMethod.CQP="Konstantní QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Konstantní bitrate (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Proměnný bitrate (vázán špičkou) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Proměnný bitrate (vázán odezvou) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Cílový bitrate"
+AMF.H264.Bitrate.Target.Description="Bitrate, kterého se máme snažit dosáhnout v celé sekvenci."
+AMF.H264.Bitrate.Peak="Špičkový bitrate"
+AMF.H264.Bitrate.Peak.Description="Bitrate, kterého se máme snažit nepřekročit v celé sekvenci."
+AMF.H264.QP.Minimum="Minimální QP"
+AMF.H264.QP.Maximum="Maximální QP"
+AMF.H264.FillerData="Filtrovat data"
+AMF.H264.FrameSkipping="Přeskakování snímků"
+AMF.H264.EnforceHRDCompatibility="Vynutit kompatibilitu s HRD"
+AMF.H264.KeyframeInterval="Interval klíčový snímků"
+AMF.H264.KeyframeInterval.Description="Kolik vteřin by mělo být mezi ne-zahazovatelnými snímky.\nTaké ovládá velikost sekvence(GOP)."
+AMF.H264.MotionEstimation="Odhad pohybu"
+AMF.H264.MotionEstimation.Description="Odhad pohybu umožňuje enkodéru snížit požadovaný bitrate předpovídáním, kam se určitý pixel posunul."
+AMF.H264.MotionEstimation.None="Žádný"
+AMF.H264.MotionEstimation.Half="Polovina pixelu"
+AMF.H264.MotionEstimation.Quarter="Čtvrtina pixelu"
+AMF.H264.MotionEstimation.Both="Polovina & čtvrtina pixelu"
+AMF.H264.Device="Zařízení"
+AMF.H264.UseOpenCL="Použít OpenCL"
+AMF.H264.UseOpenCL.Description="Měl by enkodér použít OpenCL pro potvrzování samostatných snímků?"
+AMF.H264.View="Režim zobrazení"
+AMF.H264.View.Description="Které možnosti mají být zobrazeny. Nezískáte žádnou pomoc při použití módu 'Expert' či 'Master'."
+AMF.H264.View.Basic="Základní"
+AMF.H264.View.Advanced="Pokročilý"
+AMF.H264.View.Expert="Expert"
+AMF.H264.View.Master="Master"
+AMF.H264.UnlockProperties="Odblokovat vlastnosti"
+AMF.H264.UnlockProperties.Description="Odblokuje určité vlastnosti do jejich plného rozsahu místo omezování do určitého."
+AMF.H264.Debug="Ladění"
+AMF.H264.Debug.Description="Zapne rozšířené protokolování, mělo by být zapnuto, pokud pořebujete pomoci s tmto enkodérem."
+AMF.Util.Default="Výchozí"
+AMF.Util.Automatic="Automatické"
+AMF.Util.Manual="Manuální"
+AMF.Util.Toggle.Disabled="Zakázáno"
+AMF.Util.Toggle.Enabled="Povoleno"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/da-DK.ini Added

@@ -0,0 +1,34 @@
+AMF.H264.Usage.Transcoding="Transcoding"
+AMF.H264.Usage.UltraLowLatency="Ekstrem Lav Ventetid"
+AMF.H264.Usage.LowLatency="Lav Ventetid"
+AMF.H264.QualityPreset="Kvalitets profiler"
+AMF.H264.QualityPreset.Speed="Hastighed (Dårligste kvalitet)"
+AMF.H264.QualityPreset.Balanced="Balanceret (Mellem Kvalitet)"
+AMF.H264.QualityPreset.Quality="Kvalitet (Bedste Kvalitet)"
+AMF.H264.Profile="Profil"
+AMF.H264.ProfileLevel="Profil Niveau"
+AMF.H264.ScanType="Scan Type"
+AMF.H264.ScanType.Progressive="Progressive"
+AMF.H264.ScanType.Interlaced="Interlaced"
+AMF.H264.RateControlMethod="Rate Control Method"
+AMF.H264.RateControlMethod.CQP="Constant QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Constant Bitrate (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Peak Constrained) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Latency Constrained) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Mål Bitrate"
+AMF.H264.Bitrate.Peak="Top Bitrate"
+AMF.H264.QP.Minimum="Minimum QP"
+AMF.H264.QP.Maximum="Maksimum QP"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.FillerData="Filler Data"
+AMF.H264.FrameSkipping="Billede skip"
+AMF.H264.EnforceHRDCompatibility="Tving HRD Kompatibilitet"
+AMF.H264.BPicture.Pattern="B-Picture Pattern"
+AMF.H264.BPicture.Reference="B-Picture Reference"
+AMF.H264.DeblockingFilter="Deblocking Filter"
+AMF.Util.Default="Standard"
+AMF.Util.Toggle.Disabled="Deaktiveret"
+AMF.Util.Toggle.Enabled="Aktiveret"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/de-DE.ini Added

@@ -0,0 +1,112 @@
+AMF.H264.Preset="Voreinstellungen"
+AMF.H264.Preset.ResetToDefaults="Standardeinstellungen wiederherstellen"
+AMF.H264.Preset.Recording="Aufnahme"
+AMF.H264.Preset.HighQuality="Hohe Qualität"
+AMF.H264.Preset.Indistinguishable="Ununterscheidbar"
+AMF.H264.Preset.Lossless="Verlustfrei"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Nutzungsart"
+AMF.H264.Usage.Description="Auf welche Nutzungsart AMF eingestellt werden soll:\n- '\@AMF.H264.Usage.Transcoding\@' für generelle Codierung (empfohlen),\n- '\@AMF.H264.Usage.UltraLowLatency\@' für Codierung mit sehr niedriger Latenz,\n- '\@AMF.H264.Usage.LowLatency\@' ist ähnlich dem oberen mit leicht erhöhter Latenz.\nNur '\@AMF.H264.Usage.Transcoding\@' wird für das Streamen unterstützt, alle anderen können für Aufnahmen verwendet werden."
+AMF.H264.Usage.Transcoding="Umwandeln"
+AMF.H264.Usage.UltraLowLatency="Sehr Niedrige Latenz"
+AMF.H264.Usage.LowLatency="Niedrige Latenz"
+AMF.H264.QualityPreset="Qualitätsvoreinstellung"
+AMF.H264.QualityPreset.Description="Welche Qualitätsvoreinstellungen AMF versuchen soll zu verwenden:\n- '\@AMF.H264.QualityPreset.Speed\@' ist die schnellste aber hat die schlechteste Qualität,\n- '\@AMF.H264.QualityPreset.Balanced\@' ist ein balancierter Mix aus beiden,\n- '\@AMF.H264.QualityPreset.Quality\@' gibt die beste Qualität für eine gegebene Bitrate."
+AMF.H264.QualityPreset.Speed="Geschwindigkeit"
+AMF.H264.QualityPreset.Balanced="Ausgeglichen"
+AMF.H264.QualityPreset.Quality="Qualität"
+AMF.H264.Profile="Profil"
+AMF.H264.Profile.Description="Welches H.264 Profil soll für das codieren verwendet werden:\n- 'Baseline' hat die größte Betriebssystemunterstützung,\n- 'Main' wird von älteren Geräten unterstützt (empfohlen sofern das Ziel mobile Geräte sind),\n- 'High' wird von neueren Geräten unterstützt (empfohlen)."
+AMF.H264.ProfileLevel="Profillevel"
+AMF.H264.ProfileLevel.Description="Welches H.264 Profil Level für das verarbeiten verwendet werden soll:\n- '\@AMF.Util.Automatic\@' errechnet das beste Profil Level für die gegebene Frame Rate und Frame Größe,\n- '4.1' unterstützt 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' unterstützt 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' unterstützt 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' unterstützt 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' unterstützt 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Maximale Langzeitreferenz-Bilder"
+AMF.H264.MaximumLTRFrames.Description="Langzeitreferenz (LTR) Bilder ist ein Feature das dem Codierer erlaubt, einige Bilder innerhalb einer Sequenz als referenzierbar zu markieren.\nDies kann einen positiven Effekt auf die Qualität haben sofern B-Bilder nicht unterstützt oder gewollt sind.\nLTR Bilder können nicht zusammen mit B-Bildern verwendet werden und der Codierer wird B-Bilder deaktivieren sofern diese verwendet werden."
+AMF.H264.CodingType="Codierungstyp"
+AMF.H264.CodingType.Description="Welcher Codierungstyp verwendet werden soll:\n* \@AMF.Util.Default\@ lässt AMF entscheiden (empfohlen).\n* CALVC (Context-Adaptive Variable-Length Coding) ist schneller aber größer.\n* CABAC (Context-Adaptive Binary Arithmetic Coding) ist langsamer aber kleiner."
+AMF.H264.ScanType="Abtastverfahren"
+AMF.H264.ScanType.Description="Welches Abtastverfahren verwendet werden soll. Sollte immer '\@AMF.H264.ScanType.Progressive\@' sein."
+AMF.H264.ScanType.Progressive="Progressiv"
+AMF.H264.ScanType.Interlaced="Zeilensprung"
+AMF.H264.RateControlMethod="Ratenkontrollmethode"
+AMF.H264.RateControlMethod.Description="Welche Ratenkontrollmethode verwendet werden soll:\n- '\@AMF.H264.RateControlMethod.CQP\@' setzt feste QP (Quantifizierungsparameter) Werte für I-/P-/B- Bilder,\n- '\@AMF.H264.RateControlMethod.CBR\@' bleibt auf der Zielbitrate (mithilfe von Füllungsdaten) (empfohlen für das Streamen),\n- '\@AMF.H264.RateControlMethod.VBR\@' bleibt unter der Spitzenbitrate,\n- '\@AMF.H264.RateControlMethod.VBR_LAT\@' bleibt nahe der Zielbitrate sofern GPU-Latenz und GPU-Benutzung dies erlauben, ansonsten wird eine höhere Bitrate verwendet (empfohlen für Aufnahmen)."
+AMF.H264.RateControlMethod.CQP="Konstante QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Konstante Bitrate (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Eingeschränkt via Spitzenbitrate) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Eingeschränkt via Latenz) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Zielbitrate"
+AMF.H264.Bitrate.Target.Description="Zielbitrate die in der ganzen Sequenz erreicht werden soll."
+AMF.H264.Bitrate.Peak="Spitzenbitrate"
+AMF.H264.Bitrate.Peak.Description="Spitzenbitrate die in der ganzen Sequenz erreicht werden darf."
+AMF.H264.QP.Minimum="Minimale QP"
+AMF.H264.QP.Minimum.Description="Niedrigster QP (Quantifizierungsparameter) wert der in einem Bild verwendet wird."
+AMF.H264.QP.Maximum="Maximale QP"
+AMF.H264.QP.Maximum.Description="Höchster QP (Quantifizierungsparameter) wert der in einem Bild verwendet wird."
+AMF.H264.QP.IFrame="I-Einzelbild QP"
+AMF.H264.QP.IFrame.Description="Fester QP (Quantifizierungsparameter) wert der für I-Bilder genutzt wird.\nI-Bild QP sollte höher oder gleich wie der von P- und B-Bildern sein."
+AMF.H264.QP.PFrame="P-Einzelbild QP"
+AMF.H264.QP.PFrame.Description="Fester QP (Quantifizierungsparameter) wert der für P-Bilder genutzt wird.\nI-Bild QP sollte höher oder gleich wie der von B-Bildern sein."
+AMF.H264.QP.BFrame="B-Einzelbild QP"
+AMF.H264.QP.BFrame.Description="Fester QP (Quantifizierungsparameter) wert der für B-Bilder genutzt wird."
+AMF.H264.QP.BPictureDelta="B-Bild Delta QP"
+AMF.H264.QP.BPictureDelta.Description="Delta QP wert zum letzten nicht-Referenz B-Bild."
+AMF.H264.QP.ReferenceBPictureDelta="Referenz B-Bild Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="Delta QP wert zum letzten Referenz B-Bild."
+AMF.H264.VBVBuffer="VBV Buffer"
+AMF.H264.VBVBuffer.Description="Welche Methode genutzt werden soll um die VBV-Puffergröße zu bestimmen:\n- '\@AMF.Util.Automatic\@' errechnet diese mithilfe einer Strengeneinschränkung,\n- '\@AMF.Util.Manual\@' erlaubt es dem Nutzer die Größe zu kontrollieren.\n
+VBV (Videopufferungsverifizierer) Puffer wird von verschiedenen Ratenkontrollmethoden genutzt um die gesamte Bitrate innerhalb der Begrenzungen zu halten."
+AMF.H264.VBVBuffer.Strictness="VBV Buffer Genauigkeit"
+AMF.H264.VBVBuffer.Strictness.Description="Wie streng der VBV Buffer sein soll, wobei 100% fast exakt die Zielbitrate und 0% komplett unbeschränkt ist."
+AMF.H264.VBVBuffer.Size="VBV Buffer Größe"
+AMF.H264.VBVBuffer.Size.Description="Die Größe des VBV Buffers der für die Bitratenkontrollen in einer Sequenz verwendet wird.\nEine kleine Größe ergibt eine fast perfekte Übereinstimmung mit der Bitrate aber hat einen größeren Performanzeinfluss."
+AMF.H264.VBVBuffer.Fullness="VBV Buffer Füllung"
+AMF.H264.VBVBuffer.Fullness.Description="Wie voll der VBV Buffer anfangs ist, hat nur einen Effekt auf die erste Sequenz beim codieren."
+AMF.H264.FillerData="Füllungsdaten"
+AMF.H264.FillerData.Description="Das aktivieren von Füllungsdaten erlaubt es dem Codierer mindestens die Zielbitrate zu erreichen in dem dieser den verbleibenden Platz mit leeren Informationen füllt."
+AMF.H264.FrameSkipping="Bildüberspringung"
+AMF.H264.FrameSkipping.Description="Bildüberspringung erlaubt es dem Codierer, Bilder zu überspringen um die Zielbitrate einzuhalten.\nWenn der Codierer ein Bild überspringt, fügt dieser stattdessen ein repeat-last-frame NAL in den Stream ein.\nKann bei sehr niedrigen Zielbitraten helfen."
+AMF.H264.EnforceHRDCompatibility="Erzwinge HRD Kompatiblität"
+AMF.H264.EnforceHRDCompatibility.Description="Erzwinge Hypothetischer-Referenz-Decodierer Limitierungen welches die maximale Änderung des QP werts innerhalb eines Bildes begrenzt.\nNicht empfohlen für Aufname oder Streamen und sollte nur verwendet werden sofern das Ziel sehr alte Geräte mit einem Softwarereferenz Decodierer sind."
+AMF.H264.MaximumAccessUnitSize="Maximale Zugriffseinheitsgröße"
+AMF.H264.MaximumAccessUnitSize.Description="Größte Größe einer Zugriffseinheit für einen NAL. Ein Wert von 0 erlaubt es dem Codierer die beste Größte zu wählen."
+AMF.H264.KeyframeInterval="Keyframeintervall"
+AMF.H264.KeyframeInterval.Description="Definiert die Distanz zwischen Keyframes in Sekunden. Setzt auch die Größe einer GOP-Sequenz fest."
+AMF.H264.IDRPeriod="IDR Zeitraum"
+AMF.H264.IDRPeriod.Description="Definiert die Distanz zwischen Sofortigen-Decodierer-Aktualisierungen (IDR) in Frames. Setzt auch die Größe einer GOP-Sequenz fest."
+AMF.H264.HeaderInsertionSpacing="Dateikopfeinfügungsabstand"
+AMF.H264.HeaderInsertionSpacing.Description="Wie viele Bilder zwischen NAL-Kopfzeilen sein sollen. Es wird nicht empfohlen dies von 0 (automatisch) zu ändern."
+AMF.H264.BPicture.Pattern="B-Bild Muster"
+AMF.H264.BPicture.Pattern.Description="Wie viele B-Bilder sollen erlaubt sein für das codieren. Dies hat einen positiven Einfluss auf Qualität und einen negativen Einfluss auf Performanz.\nWird nur von der 2. und 3. Generation an VCE-Karten unterstützt."
+AMF.H264.BPicture.Reference="B-Bild Referenz"
+AMF.H264.BPicture.Reference.Description="Erlaube B-Bilder andere B-Bilder zu verwenden.\nSehr großer Einfluss auf Performanz, wenig Einfluss auf Qualität."
+AMF.H264.DeblockingFilter="Entblockungsfilter"
+AMF.H264.DeblockingFilter.Description="Setze die Markierung dass der Decodierer einen Entblockungsfilter verwenden darf."
+AMF.H264.SlicesPerFrame="Slices pro Frame"
+AMF.H264.SlicesPerFrame.Description="Wie viele I-Bild-Schnitte sollen mit jedem Bild gespeichert werden?\nEin Wert von Null erlaubt es dem Codierer während dem codieren die Entscheidung zu treffen.\nIntra-Erneuerungs-Codieren wird genutzt für schnelleres abspielen und suchen."
+AMF.H264.IntraRefreshNumMBsPerSlot="Intra-Refresh Anzahl der Makroblöcke pro Slot"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="Wie viele Makroblöcke sollen pro Slot gespeichert werden?\nEin Wert von Null erlaubt es dem Codierer während dem codieren die Entscheidung zu treffen.\nIntra-Erneuerungs-Codieren wird genutzt für schnelleres abspielen und suchen."
+AMF.H264.MotionEstimation="Bewegungsschätzung"
+AMF.H264.MotionEstimation.Description="Bewegungsschätzung erlaubt des dem Codierer die benötigte Bitrate zu reduzieren durch das herausfinden, wo ein Pixel hinbewegt wurde."
+AMF.H264.MotionEstimation.None="Keine"
+AMF.H264.MotionEstimation.Half="Halb-Pixel"
+AMF.H264.MotionEstimation.Quarter="Viertel-Pixel"
+AMF.H264.MotionEstimation.Both="Halb- & Viertel-Pixel"
+AMF.H264.Device="Gerät"
+AMF.H264.Device.Description="Welches Gerät für das codieren verwendet werden soll.\nBenötigt einen anderen Speichertyp als 'Host'."
+AMF.H264.UseOpenCL="Benutze OpenCL"
+AMF.H264.UseOpenCL.Description="Soll OpenCL verwendet werden, um Einzelbilder zum Codierer zu senden?"
+AMF.H264.View="Ansichtsmodus"
+AMF.H264.View.Description="Welche Eigenschaften sollen sichtbar sein?\nDas benutzen von '\@AMF.H264.View.Master\@' disqualifiziert dich von jeglichen Support."
+AMF.H264.View.Basic="Grundlegend"
+AMF.H264.View.Advanced="Erweitert"
+AMF.H264.View.Expert="Experte"
+AMF.H264.View.Master="Meister"
+AMF.H264.UnlockProperties="Entsperre Einstellungen"
+AMF.H264.UnlockProperties.Description="Entsperre einige Einstellungen, sodass diese die volle Reichweite haben, anstatt nur eine begrenzte."
+AMF.H264.Debug="Debug"
+AMF.H264.Debug.Description="Aktiviere erweiterte Debug-Nachrichten, sollte aktiv sein wenn man Hilfe erwartet mit diesem Codierer."
+AMF.Util.Default="Standard"
+AMF.Util.Automatic="Automatisch"
+AMF.Util.Manual="Manuell"
+AMF.Util.Toggle.Disabled="Deaktiviert"
+AMF.Util.Toggle.Enabled="Aktiviert"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/el-GR.ini Changed

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/en-US.ini Added

@@ -0,0 +1,118 @@
+# Presets
+AMF.H264.Preset="Preset"
+AMF.H264.Preset.ResetToDefaults="Reset to Defaults"
+AMF.H264.Preset.Recording="Recording"
+AMF.H264.Preset.HighQuality="High Quality"
+AMF.H264.Preset.Indistinguishable="Indistinguishable"
+AMF.H264.Preset.Lossless="Lossless"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+# Static Properties
+AMF.H264.Usage="Usage"
+AMF.H264.Usage.Description="What usage AMF should be tuned for:\n- '\@AMF.H264.Usage.Transcoding\@' is general purpose transcoding (recommended),\n- '\@AMF.H264.Usage.UltraLowLatency\@' is for really low latency encoding,\n- '\@AMF.H264.Usage.LowLatency\@' is similar to above with a slightly higher latency.\nStreaming only supports '\@AMF.H264.Usage.Transcoding\@', all other values can be used for recording."
+AMF.H264.Usage.Transcoding="Transcoding"
+AMF.H264.Usage.UltraLowLatency="Ultra Low Latency"
+AMF.H264.Usage.LowLatency="Low Latency"
+AMF.H264.QualityPreset="Quality Preset"
+AMF.H264.QualityPreset.Description="What Quality Preset AMF should attempt to target:\n- '\@AMF.H264.QualityPreset.Speed\@' is the fastest but has the worst quality,\n- '\@AMF.H264.QualityPreset.Balanced\@' is a balanced mix of both,\n- '\@AMF.H264.QualityPreset.Quality\@' gives the best quality for a given bitrate."
+AMF.H264.QualityPreset.Speed="Speed"
+AMF.H264.QualityPreset.Balanced="Balanced"
+AMF.H264.QualityPreset.Quality="Quality"
+AMF.H264.Profile="Profile"
+AMF.H264.Profile.Description="Which H.264 Profile to use for encoding:\n- 'Baseline' has the biggest platform support,\n- 'Main' is supported by older devices (recommended if targeting mobile devices),\n- 'High' is supported by current devices (recommended)."
+AMF.H264.ProfileLevel="Profile Level"
+AMF.H264.ProfileLevel.Description="Which H.264 Profile Level to use for encoding:\n- '\@AMF.Util.Automatic\@' calculates the best profile level for the given Frame Rate and Frame Size,\n- '4.1' supports 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' supports 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' supports 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' supports 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' supports 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Maximum LTR Frames"
+AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Frames are a feature that allows the encoder to flag certain frames in a sequence as referencable.\nThis can have a positive effect on quality when B-Pictures are not supported or wanted.\nLTR Frames can't be used with B-Pictures and the encoder will disable B-Pictures if these are used."
+AMF.H264.CodingType="Coding Type"
+AMF.H264.CodingType.Description="Which type of coding to use:\n* \@AMF.Util.Default\@ lets AMF decide (recommended).\n* CALVC (Context-Adaptive Variable-Length Coding) is faster, but larger.\n* CABAC (Context-Adaptive Binary Arithmetic Coding) is slower, but smaller."
+AMF.H264.ScanType="Scan Type"
+AMF.H264.ScanType.Description="Which scanning method to use, always leave this on '\@AMF.H264.ScanType.Progressive\@'."
+AMF.H264.ScanType.Progressive="Progressive"
+AMF.H264.ScanType.Interlaced="Interlaced"
+# Rate Control Properties
+AMF.H264.RateControlMethod="Rate Control Method"
+AMF.H264.RateControlMethod.Description="What rate control method should be used:\n- '\@AMF.H264.RateControlMethod.CQP\@' assigns fixed I-/P-/B-Frame QP (Quantization Parameter) values,\n- '\@AMF.H264.RateControlMethod.CBR\@' stays at the given Target Bitrate (using Filler Data) (recommended for streaming),\n- '\@AMF.H264.RateControlMethod.VBR\@' stays below the given Peak Bitrate,\n- '\@AMF.H264.RateControlMethod.VBR_LAT\@' stays close to the Target Bitrate if GPU latency and load allow for it, otherwise will use higher bitrate (recommended for recording)."
+AMF.H264.RateControlMethod.CQP="Constant QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Constant Bitrate (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Peak Constrained) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Latency Constrained) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Target Bitrate"
+AMF.H264.Bitrate.Target.Description="Bitrate to attempt to achieve in the overall sequence."
+AMF.H264.Bitrate.Peak="Peak Bitrate"
+AMF.H264.Bitrate.Peak.Description="Bitrate to attempt to maximally peak to in the overall sequence."
+AMF.H264.QP.Minimum="Minimum QP"
+AMF.H264.QP.Minimum.Description="Lowest QP (Quantization Parameter) value to use in a frame."
+AMF.H264.QP.Maximum="Maximum QP"
+AMF.H264.QP.Maximum.Description="Highest QP (Quantization Parameter) value to use in a frame."
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.IFrame.Description="Fixed QP (Quantization Parameter) value to use for I-Frames.\nI-Frame QP should be at or higher than P- and B-Frame QP."
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.PFrame.Description="Fixed QP (Quantization Parameter) value to use for P-Frames.\nP-Frame QP should be at or higher than B-Frame QP."
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BFrame.Description="Fixed QP (Quantization Parameter) value to use for B-Frames."
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.BPictureDelta.Description="Delta QP (Quantization Parameter) value to the last non-reference B-Picture."
+AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="Delta QP (Quantization Parameter) value to the last reference B-Picture."
+AMF.H264.VBVBuffer="VBV Buffer"
+AMF.H264.VBVBuffer.Description="What method should be used to determine the VBV Buffer Size:\n- '\@AMF.Util.Automatic\@' calculates the size using a strictness constraint,\n- '\@AMF.Util.Manual\@' allows the user to control the size.\nVBV (Video Buffering Verifier) Buffer is used by certain Rate Control Methods to keep the overall bitrate within the given constraints."
+AMF.H264.VBVBuffer.Strictness="VBV Buffer Strictness"
+AMF.H264.VBVBuffer.Strictness.Description="How strict the VBV Buffer is, with 100% being almost exactly the targetted Bitrate and 0% being unrestricted."
+AMF.H264.VBVBuffer.Size="VBV Buffer Size"
+AMF.H264.VBVBuffer.Size.Description="The size of the VBV Buffer which is used for Bitrate control in a sequence.\nA small size results in an almost perfect bitrate match but has a larger performance impact."
+AMF.H264.VBVBuffer.Fullness="VBV Buffer Fullness"
+AMF.H264.VBVBuffer.Fullness.Description="How full the VBV Buffer initially is, will only affect the initial sequence of encoding."
+AMF.H264.FillerData="Filler Data"
+AMF.H264.FillerData.Description="Enabling Filler Data allows the encoder to keep at least the Target Bitrate by filling up the remaining space in a sequence with empty information."
+AMF.H264.FrameSkipping="Frame Skipping"
+AMF.H264.FrameSkipping.Description="Frame Skipping allows the encoder to drop frames in order to meet Target Bitrate requirements.\nWhen the encoder drops a frame it instead insert a repeat-last-frame NAL into the stream.\nCan help with very low Target Bitrates."
+AMF.H264.EnforceHRDCompatibility="Enforce HRD Compatibility"
+AMF.H264.EnforceHRDCompatibility.Description="Enforce Hypothetical Reference Decoder restrictions which limit the maximum QP value change within a frame.\nNot recommended for recording or streaming and should only be used for targeting very old devices that only have reference software decoders."
+AMF.H264.MaximumAccessUnitSize="Maximum Access Unit Size"
+AMF.H264.MaximumAccessUnitSize.Description="Largest Size of an Access Unit for a NAL. A value of 0 allows the encoder to pick the best one."
+# Picture Control Properties
+AMF.H264.KeyframeInterval="Keyframe Interval"
+AMF.H264.KeyframeInterval.Description="Defines the distance between Keyframes in seconds. Also controls GOP-sequence size."
+AMF.H264.IDRPeriod="IDR Period"
+AMF.H264.IDRPeriod.Description="Defines the distance between Instantaneous Decoding Refreshes (IDR) in frames. Also controls GOP-sequence size."
+AMF.H264.HeaderInsertionSpacing="Header Insertion Spacing"
+AMF.H264.HeaderInsertionSpacing.Description="How many frames should be between NAL headers. It is not recommended to change this from 0 (automatic)."
+AMF.H264.BPicture.Pattern="B-Picture Pattern"
+AMF.H264.BPicture.Pattern.Description="How many B-Pictures should be allowed for encoding, has a positive impact on quality and negative impact on performance.\nSupported by 2nd and 3rd Generation VCE cards."
+AMF.H264.BPicture.Reference="B-Picture Reference"
+AMF.H264.BPicture.Reference.Description="Allow B-Pictures to reference other B-Pictures additionally to P- and I-Frames.\nImproves quality slightly but lowers encoding performance."
+AMF.H264.DeblockingFilter="Deblocking Filter"
+AMF.H264.DeblockingFilter.Description="Sets the flag that the decoder is allowed to use a Deblocking Filter for the encoded stream."
+AMF.H264.SlicesPerFrame="Slices Per Frame"
+AMF.H264.SlicesPerFrame.Description="How many I-Frame slices should be stored with each frame?\nA value of zero lets the encoder decide on the fly.\nIntra-Refresh encoding is used for faster playback and seeking."
+AMF.H264.IntraRefreshNumMBsPerSlot="Intra-Refresh Number of Macroblocks Per Slot"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="How many Macroblocks should be stored in each slot?\nA value of zero lets the encoder decide on the fly.\nIntra-Refresh encoding is used for faster playback and seeking."
+# Miscellaneous Properties
+AMF.H264.MotionEstimation="Motion Estimation"
+AMF.H264.MotionEstimation.Description="Motion Estimation allows the encoder to reduce needed bitrate by estimating where a pixel went."
+AMF.H264.MotionEstimation.None="None"
+AMF.H264.MotionEstimation.Half="Half-Pixel"
+AMF.H264.MotionEstimation.Quarter="Quarter-Pixel"
+AMF.H264.MotionEstimation.Both="Half- & Quarter-Pixel"
+# System Properties
+AMF.H264.Device="Device"
+AMF.H264.Device.Description="Which Device to use for encoding.\nRequires Memory Type to not be set to 'Host'."
+AMF.H264.UseOpenCL="Use OpenCL"
+AMF.H264.UseOpenCL.Description="Should the Encoder use OpenCL to submit the individual frames?"
+AMF.H264.View="View Mode"
+AMF.H264.View.Description="What properties should be shown?\nUsing '\@AMF.H264.View.Master\@' will disqualify you from receiving support."
+AMF.H264.View.Basic="Basic"
+AMF.H264.View.Advanced="Advanced"
+AMF.H264.View.Expert="Expert"
+AMF.H264.View.Master="Master"
+AMF.H264.UnlockProperties="Unlock Properties"
+AMF.H264.UnlockProperties.Description="Unlock certain properties to their full range instead of limiting them to a partial range."
+AMF.H264.Debug="Debug"
+AMF.H264.Debug.Description="Enable additional debug logging, should be active whenever you need support with this encoder."
+# Utility
+AMF.Util.Default="Default"
+AMF.Util.Automatic="Automatic"
+AMF.Util.Manual="Manual"
+AMF.Util.Toggle.Disabled="Disabled"
+AMF.Util.Toggle.Enabled="Enabled"
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/es-ES.ini Added

@@ -0,0 +1,109 @@
+AMF.H264.Preset="Preajuste"
+AMF.H264.Preset.ResetToDefaults="Restablecer por defecto"
+AMF.H264.Preset.Recording="Grabación"
+AMF.H264.Preset.HighQuality="Alta Calidad"
+AMF.H264.Preset.Indistinguishable="Indistinguible"
+AMF.H264.Preset.Lossless="Sin pérdidas"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Uso"
+AMF.H264.Usage.Description="A que uso debe ajustarse AMF:\n- 'Codificación' es para uso generalizado (recomendado),\n- 'Ultra Baja Latencia' es para codificación de muy baja latencia,\n- 'Baja Latencia' es similar a la anterior con algo mas de latencia.\nLas emisiones en directo solo soportan 'Codificación', todos los valores pueden ser usados para grabar."
+AMF.H264.Usage.Transcoding="Codificación"
+AMF.H264.Usage.UltraLowLatency="Latencia ultra baja"
+AMF.H264.Usage.LowLatency="Latencia baja"
+AMF.H264.QualityPreset="Calidad del perfil"
+AMF.H264.QualityPreset.Description="Que calidad del perfil de AMD se debe intentar conseguir:\n- 'Velocidad' es la mas rápida pero la que peor calidad obtiene,\n- 'Equilibrado' está entre 'Velocidad' y 'Calidad' ofreciendo un balance entre los dos,\n- 'Calidad' ofrece la mejor calidad posible para una determinada tasa de bits."
+AMF.H264.QualityPreset.Speed="Velocidad"
+AMF.H264.QualityPreset.Balanced="Equilibrado"
+AMF.H264.QualityPreset.Quality="Calidad"
+AMF.H264.Profile="Perfil del Códec"
+AMF.H264.Profile.Description="Que perfil H.264 a utilizar para la codificación:\n- 'Baseline' tiene el mayor soporte en las plataformas,\n- 'Main' es compatible con dispositivos algo mas anticuados (recomendado si la emisión va dirigida a dispositivos móviles),\n- 'High' es compatible con los dispositivos actuales (recomendado)."
+AMF.H264.ProfileLevel="Nivel del Perfil"
+AMF.H264.ProfileLevel.Description="Nivel de perfil H.264 a utilizar para la codificación:\n- 'Automático' calcula el mejor nivel de perfil para cierta velocidad y tamaño de fotogramas,\n- '4.1' soporta 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' soporta 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' soporta 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' soporta 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' soporta 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Fotogramas LTR máximos"
+AMF.H264.MaximumLTRFrames.Description="Fotogramas de referencia a largo plazo (LTR) son una caracteristica que permite al codificador marcar ciertos frames en una secuencia como referentes.\nEsto puede tener un efecto positivo en la calidad cuando los B-Pictures no estan soportados.\nLos fotogramas LTR no pueden ser usados con B-Pictures y el codificador deshabilitará B-Pictures si se usa."
+AMF.H264.ScanType="Tipo de escaneo"
+AMF.H264.ScanType.Description="Que método de escaneo usar, dejar siempre en 'Progresivo'."
+AMF.H264.ScanType.Progressive="Progresivo"
+AMF.H264.ScanType.Interlaced="Entrelazado"
+AMF.H264.RateControlMethod="Método de control del flujo"
+AMF.H264.RateControlMethod.Description="Qué método de control de flujo debe ser usado:\n- '\@AMF.H264.RateControlMethod.CQP\@' asigna valores fijos de QP en I-/P-/B-Frames (Parámetro de cuantización),\n- '\@AMF.H264.RateControlMethod.CBR\@' se mantiene en la tasa de bits objetivo (usando Datos de relleno) (recomendado para emisiones en directo),\n- '\@AMF.H264.RateControlMethod.VBR\@' se mantiene por debajo de un pico de tasa de bits,\n- '\@AMF.H264.RateControlMethod.VBR_LAT\@' se mantiene cerca de la tasa de bits deseada si la latencia y carga de la GPU lo permite, si no se aumentará la tasa de bits (recomendado para grabaciones)."
+AMF.H264.RateControlMethod.CQP="QP constante (CQP)"
+AMF.H264.RateControlMethod.CBR="Flujo constante (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Flujo variable (pico restringido) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Flujo variable (latencia restringida) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Tasa de bits deseada"
+AMF.H264.Bitrate.Target.Description="Tasa de bits a intentar alcanzar en la secuencia general."
+AMF.H264.Bitrate.Peak="Pico de tasa de bits"
+AMF.H264.Bitrate.Peak.Description="Tasa de bits a intentar alcanzar como pico máximo en la secuencia general."
+AMF.H264.QP.Minimum="QP Mínimo"
+AMF.H264.QP.Minimum.Description="Valor mínimo de QP (parámetro de cuantización) a utilizar en un fotograma."
+AMF.H264.QP.Maximum="QP Máximo"
+AMF.H264.QP.Maximum.Description="Valor máximo de QP (parámetro de cuantización) a utilizar en un fotograma."
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.IFrame.Description="Valor de QP Fijo (parámetro de cuantización) a usar por I-Frames.\n-El valor QP de un I-Frame debe ser igual o superior al valor QP de P- y B-Frames."
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.PFrame.Description="Valor de QP Fijo (parámetro de cuantización) a usar por P-Frames.\n-El valor QP de un P-Frame debe ser igual o superior al valor QP de un B-Frame."
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BFrame.Description="Valor de QP Fijo (parámetro de cuantización) a usar por B-Frames."
+AMF.H264.QP.BPictureDelta="QP Delta en B-Pictures"
+AMF.H264.QP.BPictureDelta.Description="QP Delta del último B-Picture que no es de referencia."
+AMF.H264.QP.ReferenceBPictureDelta="QP Delta en B-Pictures de referencia"
+AMF.H264.QP.ReferenceBPictureDelta.Description="QP Delta del último B-Picture de referencia."
+AMF.H264.VBVBuffer="Buffer VBV"
+AMF.H264.VBVBuffer.Description="Que método se debe usar para determinar el tamaño del buffer VBV:\n- 'Automático' calcula el tamaño usando una restricción estricta,\n- 'Manual' permite al usuario controlar el tamaño.\nEl buffer VBV (Verificador de Buffering de Video) es usado por ciertos métodos de control del flujo para mantener la tasa de bits dentro de los parámetros establecidos."
+AMF.H264.VBVBuffer.Strictness="Estricticidad del Buffer VBV"
+AMF.H264.VBVBuffer.Strictness.Description="Como de estricto es el buffer VBV, con 100% siendo casi exactamente la tasa de bits deseada y 0% siendo sin restricción."
+AMF.H264.VBVBuffer.Size="Tamaño de buffer VBV"
+AMF.H264.VBVBuffer.Size.Description="El tamaño del Buffer VBV que es usado para el control de la tasa de bits en una secuencia.\nUn tamaño pequeño ofrece una tasa de bits con una coincidencia casi perfecta pero tiene un gran impacto en el rendimiento."
+AMF.H264.VBVBuffer.Fullness="Amplitud del Buffer VBV"
+AMF.H264.VBVBuffer.Fullness.Description="Como de lleno es el buffer VMV inicialmente, solo afectará a la secuencia inicial de la codificación."
+AMF.H264.FillerData="Datos de relleno"
+AMF.H264.FillerData.Description="Habilitando Datos de relleno se permite al codificador mantener por lo menos la tasa de bits deseada rellenando el espacio que falta con información sin valor."
+AMF.H264.FrameSkipping="Omisión de fotogramas"
+AMF.H264.FrameSkipping.Description="Omisión de fotogramas permite al codificador saltar fotogramas para cumplir con el requerimiento de la tasa de bits objetivo.\nCuando el codificador salta un fotograma insertará un NAL que repetirá el ultimo fotograma codificado en el stream.\nPuede ayudar con tasa de bits objetivo muy bajas."
+AMF.H264.EnforceHRDCompatibility="Forzar compatibilidad con HRD"
+AMF.H264.EnforceHRDCompatibility.Description="Forzar las restricciones del decodificador hipotético de referencia que limitan el cambio de valor máximo de QP dentro de un fotograma.\nNo recomendado para grabación o emisión en directo y solo se debe usar cuando el objetivo son dispositivos antiguos que solo tienen decodificadores de referencia por software."
+AMF.H264.MaximumAccessUnitSize="Tamaño máximo de la unidad de acceso"
+AMF.H264.MaximumAccessUnitSize.Description="Mayor tamaño de una unidad de acceso para una NAL. Un valor de 0 permite al codificador elegir el mejor."
+AMF.H264.KeyframeInterval="Intervalo de fotogramas clave"
+AMF.H264.KeyframeInterval.Description="Cuantos segundos deben haber entre fotogramas que no se pueden descartar.\nTambién controla el tamaño de la secuencia (GOP)."
+AMF.H264.IDRPeriod="Periodo IDR"
+AMF.H264.IDRPeriod.Description="Define la distancia entre Instantaneous Decoding Refreshes (IDR) en Fotogramas. También controla el tamaño de la secuencia del GOP."
+AMF.H264.HeaderInsertionSpacing="Espaciado de inserción de cabeceras (Frames)"
+AMF.H264.HeaderInsertionSpacing.Description="Cuantos fotogramas deben haber entre cabeceras NAL. No se recomienda cambiar de 0 (automatico)."
+AMF.H264.BPicture.Pattern="Patron de B-Pictures"
+AMF.H264.BPicture.Pattern.Description="Cuantas B-Pictures deben ser permitidos en la codificación, tiene un impacto positivo en la calidad y negativo en rendimiento.\nSoportado por la segunda y tercera generación de VCE."
+AMF.H264.BPicture.Reference="B-Pictures de referencia"
+AMF.H264.BPicture.Reference.Description="Permitir B-Pictures referenciar otras B-Pictures adicionalmente a P- y I-Frames.\nGran impacto en el rendimiento, poca mejora de calidad."
+AMF.H264.DeblockingFilter="Filtro de eliminación de bloques"
+AMF.H264.DeblockingFilter.Description="Establece el indicador de que el decodificador está permitido a usar el Filtro de eliminación de bloques para el stream codificado."
+AMF.H264.SlicesPerFrame="Porciones por fotograma"
+AMF.H264.SlicesPerFrame.Description="Cuantas porciones I-Frame deben ser almacenados en cada fotograma?\nUn valor de 0 permite al codificador decidir al vuelo.\nLa codificación Intra-Refresh es usada para una reproducción y exploración mas fluida."
+AMF.H264.IntraRefreshNumMBsPerSlot="Numero de macrobloques intra-refresh por Slot"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="Cuantos macrobloques deben ser almacenados en cada slot?\nUn valor de 0 permite al codificador decidir al vuelo.\nLa codificación Intra-Refresh es usada para una reproducción y exploración mas fluida."
+AMF.H264.MotionEstimation="Estimación de movimiento"
+AMF.H264.MotionEstimation.Description="Estimación de movimiento permite al codificador reducir el flujo de datos necesario estimando de donde vienen los pixeles."
+AMF.H264.MotionEstimation.None="Ninguno"
+AMF.H264.MotionEstimation.Half="Mitad de Pixel"
+AMF.H264.MotionEstimation.Quarter="Cuarto de Pixel"
+AMF.H264.MotionEstimation.Both="Mitad y cuarto de Pixel"
+AMF.H264.Device="Dispositivo"
+AMF.H264.Device.Description="Que dispositivo usar para codificar.\nRequiere que el tipo de memoria seleccionado no sea 'Host'."
+AMF.H264.UseOpenCL="Usar OpenCL"
+AMF.H264.UseOpenCL.Description="Debe el codificador usar OpenCL para entregar los fotogramas individuales?"
+AMF.H264.View="Modo de Vista"
+AMF.H264.View.Description="Que propiedades deben ser visibles. No recibirás soporte si usas el modo de vista 'Experto' o 'Maestro'."
+AMF.H264.View.Basic="Básico"
+AMF.H264.View.Advanced="Avanzado"
+AMF.H264.View.Expert="Experto"
+AMF.H264.View.Master="Maestro"
+AMF.H264.UnlockProperties="Desbloquear propiedades"
+AMF.H264.UnlockProperties.Description="Desbloquea ciertas propiedades a su maxima capacidad en lugar de limitarlas de forma parcial."
+AMF.H264.Debug="Depurar"
+AMF.H264.Debug.Description="Habilita el registro de información de depuración adicional, debe ser activado cuando necesites ayuda con este codificador."
+AMF.Util.Default="Por defecto"
+AMF.Util.Automatic="Automático"
+AMF.Util.Manual="Manual"
+AMF.Util.Toggle.Disabled="Deshabilitado"
+AMF.Util.Toggle.Enabled="Habilitado"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/eu-ES.ini Added

@@ -0,0 +1,77 @@
+AMF.H264.Preset="Aurrezarrita"
+AMF.H264.Preset.ResetToDefaults="Berrezarri balio lehenetsiak"
+AMF.H264.Preset.Recording="Grabatzen"
+AMF.H264.Preset.HighQuality="Kalitate handia"
+AMF.H264.Preset.Indistinguishable="Sumaezina"
+AMF.H264.Preset.Lossless="Galerarik gabe"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Erabilpena"
+AMF.H264.Usage.Description="AMFrentzat zer erabilerak aukeratu behar dira:\n- 'Transcoding' oro har proposatzen da transmisiorako (gomendatua),\n- 'Ultra Low Latency' latentzia oso baxuko kodetzerako,\n- 'Low Latency' aurrekoaren antzekoa da latentzia apur bat handiagoarekin.\nStreaming bakarrik onartzen du 'Transcoding', gainerako balio guztiak erabili daitezke grabaziorako."
+AMF.H264.Usage.Transcoding="Kodeketa"
+AMF.H264.Usage.UltraLowLatency="Latentzia oso txikia"
+AMF.H264.Usage.LowLatency="Latentzia txikia"
+AMF.H264.QualityPreset="Aurrezarritako kalitatea"
+AMF.H264.QualityPreset.Speed="Abiadura"
+AMF.H264.QualityPreset.Balanced="Orekatua"
+AMF.H264.QualityPreset.Quality="Kalitatea"
+AMF.H264.Profile="Profila"
+AMF.H264.ProfileLevel="Profilaren maila"
+AMF.H264.ProfileLevel.Description="H.264 profilaren zein maila erabili behar da kodetzeko:\n- 'Automatic' automatikoki kalkulatzen du emandako abiadura eta fotogramen tamainarako egokiena,\n- '4.1'-ek onartzen du 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2'-k onartzen du 1920x1080 60FPS, 1280x720 120FPS\n- '5.0'-k onartzen du 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1'-k onartzen du 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2'-k onartzen du 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Gehienezko LTR fotogramak"
+AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Fotogramak aukera ematen dio kodegailuari sekuentzia baten hainbat fotograma erreferente moduan markatzeko.\nHonek kalitatean eragin positiboa izan dezake B-Pictures onartzen ez direnean.\nLTR Fotogramak ezin dira B-Pictures-ekin erabili eta kodegailuak B-Pictures-ak desgaituko ditu hauek erabiltzean."
+AMF.H264.ScanType="Eskaneatze mota"
+AMF.H264.ScanType.Progressive="Progresiboa"
+AMF.H264.ScanType.Interlaced="Gurutzelarkatua"
+AMF.H264.RateControlMethod="Emaria kontrolatzeko metodoa"
+AMF.H264.RateControlMethod.CQP="Konstantea QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Bit emari konstantea (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Bit emari aldakorra (gailur mugatuak) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Bit emari aldakorra (Latentzia mugatua) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Bit emari helburua"
+AMF.H264.Bitrate.Peak="Gehienezko gailurra"
+AMF.H264.QP.Minimum="Gutxieneko QP"
+AMF.H264.QP.Maximum="Gehienezko QP"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta="B-Picture Delta QP erreferentzia"
+AMF.H264.VBVBuffer="VBV bufferra"
+AMF.H264.VBVBuffer.Strictness="VBV bufferraren zorroztasuna"
+AMF.H264.VBVBuffer.Size="VBV bufferraren tamaina"
+AMF.H264.VBVBuffer.Fullness="VBV bufferraren betetasuna"
+AMF.H264.FillerData="Datu betegarria"
+AMF.H264.FrameSkipping="Fotogramen saltoa"
+AMF.H264.EnforceHRDCompatibility="Behartu HRD bateragarritasuna"
+AMF.H264.MaximumAccessUnitSize="Sarbide unitatearen gehienezko tamaina"
+AMF.H264.KeyframeInterval="Gako fotogramen tartea"
+AMF.H264.IDRPeriod="IDR periodoa"
+AMF.H264.HeaderInsertionSpacing="Goiburuak txertatzeko tartea"
+AMF.H264.BPicture.Pattern="B-Picture eredua"
+AMF.H264.BPicture.Reference="B-Picture erreferentzia"
+AMF.H264.DeblockingFilter="Desblokeoko iragazkia"
+AMF.H264.SlicesPerFrame="Zatiak fotogramako"
+AMF.H264.IntraRefreshNumMBsPerSlot="Makroblokeen barne freskatze kopura erreteneko"
+AMF.H264.MotionEstimation="Mugimenduaren estimazioa"
+AMF.H264.MotionEstimation.None="Ezer ez"
+AMF.H264.MotionEstimation.Half="Pixel erdia"
+AMF.H264.MotionEstimation.Quarter="Pixel laurdena"
+AMF.H264.MotionEstimation.Both="Pixel erdia eta laurdena"
+AMF.H264.Device="Gailua"
+AMF.H264.Device.Description="Zein gailu erabili kodeketarako.\nHautatutako memoria mota ez du 'Host' izan behar."
+AMF.H264.UseOpenCL="Erabili OpenCL"
+AMF.H264.UseOpenCL.Description="Kodifikagailuak OpenCL erabili behar du banakako fotogramak bidaltzeko?"
+AMF.H264.View="Ikuspegia"
+AMF.H264.View.Description="Zein propietate ikusi behar dira. Ez duzu laguntzarik jasoko 'Aditu' edo 'Maisu' ikuspegian."
+AMF.H264.View.Basic="Oinarrizkoa"
+AMF.H264.View.Advanced="Aurreratua"
+AMF.H264.View.Expert="Aditu"
+AMF.H264.View.Master="Maixu"
+AMF.H264.UnlockProperties="Desblokeatu propietateak"
+AMF.H264.Debug="Garbiketa"
+AMF.Util.Default="Lehenetsia"
+AMF.Util.Automatic="Automatikoa"
+AMF.Util.Manual="Eskuz"
+AMF.Util.Toggle.Disabled="Ezgaituta"
+AMF.Util.Toggle.Enabled="Gaituta"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/fi-FI.ini Added

@@ -0,0 +1,57 @@
+AMF.H264.Preset="Esiasetus"
+AMF.H264.Preset.ResetToDefaults="Palauta oletukset"
+AMF.H264.Preset.Recording="Tallennus"
+AMF.H264.Preset.HighQuality="Korkea laatu"
+AMF.H264.Preset.Indistinguishable="Erottamaton"
+AMF.H264.Preset.Lossless="Häviötön"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Käyttö"
+AMF.H264.Usage.Transcoding="Transkoodaus"
+AMF.H264.Usage.UltraLowLatency="Erittäin alhainen latenssi"
+AMF.H264.Usage.LowLatency="Alhainen latenssi"
+AMF.H264.QualityPreset="Laatuasetus"
+AMF.H264.QualityPreset.Speed="Nopeus"
+AMF.H264.QualityPreset.Balanced="Tasapainotettu"
+AMF.H264.QualityPreset.Quality="Laatu"
+AMF.H264.Profile="Profiili"
+AMF.H264.ProfileLevel="Profiilin taso"
+AMF.H264.ScanType="Skannaustyyppi"
+AMF.H264.ScanType.Progressive="Progressiivinen"
+AMF.H264.ScanType.Interlaced="Lomitettu"
+AMF.H264.RateControlMethod="Rate Control -tapa"
+AMF.H264.RateControlMethod.CQP="Pysyvä QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Jatkuva bitrate (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Vaihteleva bitrate (Piikkiin sidottu) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Vaihteleva bitrate (Latenssiin sidottu) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Bitrate-tavoite"
+AMF.H264.Bitrate.Peak="Bitrate-piikki"
+AMF.H264.QP.Minimum="Minimi QP"
+AMF.H264.QP.Maximum="Maksimi QP"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
+AMF.H264.VBVBuffer="VBV-puskuri"
+AMF.H264.VBVBuffer.Size="VBV-puskurin koko"
+AMF.H264.FillerData="Täyttödata"
+AMF.H264.FrameSkipping="Ruudun ohitus"
+AMF.H264.EnforceHRDCompatibility="Pakota HRD-yhteensopivuus"
+AMF.H264.BPicture.Pattern="B-Picture Pattern"
+AMF.H264.BPicture.Reference="B-Picture Reference"
+AMF.H264.DeblockingFilter="Deblocking filtteri"
+AMF.H264.MotionEstimation="Liikkeen ennakointi"
+AMF.H264.MotionEstimation.None="Ei mitään"
+AMF.H264.View="Näyttötila"
+AMF.H264.View.Basic="Yksinkertainen"
+AMF.H264.View.Advanced="Kehittynyt"
+AMF.H264.View.Expert="Expertti"
+AMF.H264.View.Master="Jumalallinen"
+AMF.H264.UnlockProperties="Avaa ominaisuudet"
+AMF.H264.Debug="Debug"
+AMF.Util.Default="Oletusarvo"
+AMF.Util.Automatic="Automaattinen"
+AMF.Util.Manual="Manuaalinen"
+AMF.Util.Toggle.Disabled="Pois käytöstä"
+AMF.Util.Toggle.Enabled="Käytössä"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/fr-FR.ini Added

@@ -0,0 +1,82 @@
+AMF.H264.Preset="Préréglage"
+AMF.H264.Preset.ResetToDefaults="Valeurs par défaut"
+AMF.H264.Preset.Recording="Enregistrement"
+AMF.H264.Preset.HighQuality="Qualité élevée"
+AMF.H264.Preset.Indistinguishable="Indifférenciable"
+AMF.H264.Preset.Lossless="Sans pertes"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Mode"
+AMF.H264.Usage.Description="Le mode d'optimisation utilisé par AMF :\n- '\@AMF.H264.Usage.Transcoding\@' : utilisation pour du transcodage (réglage recommandé),\n- '\@AMF.H264.Usage.UltraLowLatency\@' : encodage à très faible latence,\n- '\@AMF.H264.Usage.LowLatency\@' : quasiment identique au réglage ci-dessus, avec une latence légèrement plus élevée.\nLe streaming n'est possible qu'en mode '\@AMF.H264.Usage.Transcoding\@', l'enregistrement est possible avec tous les autres modes."
+AMF.H264.Usage.Transcoding="Transcodage"
+AMF.H264.Usage.UltraLowLatency="Très faible latence"
+AMF.H264.Usage.LowLatency="Faible latence"
+AMF.H264.QualityPreset="Préréglages de qualité"
+AMF.H264.QualityPreset.Description="Le préréglage de qualité qu'AMF doit cibler :\n- \"\@AMF.H264.QualityPreset.Speed\@\" est le plus rapide, au détriment d'une qualité déplorable,\n- \"\@AMF.H264.QualityPreset.Balanced\@\" est un compromis entre \"\@AMF.H264.QualityPreset.Speed\@\" et \"\@AMF.H264.QualityPreset.Quality\@\",\n- \"\@AMF.H264.QualityPreset.Quality\@\" délivre la meilleure qualité pour un débit donné."
+AMF.H264.QualityPreset.Speed="Vitesse"
+AMF.H264.QualityPreset.Balanced="Equilibré"
+AMF.H264.QualityPreset.Quality="Qualité"
+AMF.H264.Profile="Profil"
+AMF.H264.Profile.Description="Le profil H.264 utilisé pour l'encodage :\n- 'Baseline' est compatible avec la majorité des lecteurs,\n-'Main' est compatible avec les lecteurs d'ancienne génération (recommandé pour les lecteurs mobiles),\n- 'High' est compatible avec la plupart des lecteurs récents (réglage recommandé pour la plupart des cas)."
+AMF.H264.ProfileLevel="Niveau de profil"
+AMF.H264.ProfileLevel.Description="Quel niveau de profil H.264 utiliser pour l'encodage :\n- \"Automatique\" laisse l'encodeur déterminer le meilleur profil en fonction de la résolution d'image et du nombre d'images par seconde.\n- \"4.1\" supporte les formats suivants : 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- \"4.2\" supporte les formats suivants : 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- \"5.0\" supporte les formats suivants : 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- \"5.1\" supporte les formats suivants : 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- \"5.2\" supporte les formats suivants : 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Maximum de trames LTR"
+AMF.H264.MaximumLTRFrames.Description="Les trames LTR (Long Term Reference) sont une fonctionnalité de l'encodeur qui l'autorise à marquer certaines trames comme étant des trames de référence au sein d'une séquence d'images.\nUtiliser cette fonctionnalité peut apporter un gain de qualité dans le cas où les images B (B-Pictures) ne sont pas supportées ou activées.\nLes trames LTR ne sont pas utilisables en conjonction des images B, et l'encodeur désactivera les images B si cette fonctionnalité (trames LTR) est activée."
+AMF.H264.ScanType="Balayage"
+AMF.H264.ScanType.Description="La méthode de balayage à utiliser (laissez cette valeur sur \"\@AMF.H264.ScanType.Progressive\@\")."
+AMF.H264.ScanType.Progressive="Progressif"
+AMF.H264.ScanType.Interlaced="Entrelacé"
+AMF.H264.RateControlMethod="Méthode de contrôle du débit"
+AMF.H264.RateControlMethod.CQP="QP constant (CQP)"
+AMF.H264.RateControlMethod.CBR="Débit constant (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Débit Variable (maximum) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Débit Variable (latence limitée) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Débit cible"
+AMF.H264.Bitrate.Peak="Débit maximal"
+AMF.H264.QP.Minimum="QP minimal"
+AMF.H264.QP.Maximum="QP maximal"
+AMF.H264.QP.IFrame="QP I-Frame"
+AMF.H264.QP.PFrame="QP P-Frame"
+AMF.H264.QP.BFrame="QP B-Frame"
+AMF.H264.QP.BPictureDelta="QP B-Image Delta"
+AMF.H264.QP.ReferenceBPictureDelta="Delta QP de l'image B de référence"
+AMF.H264.VBVBuffer="Tampon VBV"
+AMF.H264.VBVBuffer.Strictness="Respect du tampon VBV"
+AMF.H264.VBVBuffer.Size="Taille du tampon VBV"
+AMF.H264.VBVBuffer.Fullness="Remplissage du tampon VBV"
+AMF.H264.FillerData="Données de remplissage"
+AMF.H264.FrameSkipping="Saut d'images"
+AMF.H264.EnforceHRDCompatibility="Appliquer la compatibilité avec l'HRD"
+AMF.H264.MaximumAccessUnitSize="Taille max. d'une Access Unit"
+AMF.H264.KeyframeInterval="Intervalle d'images-clé"
+AMF.H264.IDRPeriod="Périodicité des trames IDR"
+AMF.H264.HeaderInsertionSpacing="Intervalle d'insertion de l'en-tête de stream"
+AMF.H264.BPicture.Pattern="Modèle d'image B"
+AMF.H264.BPicture.Reference="Référence d'image B"
+AMF.H264.DeblockingFilter="Filtre de dégroupage"
+AMF.H264.SlicesPerFrame="Tranches par image"
+AMF.H264.MotionEstimation="Estimation de mouvement"
+AMF.H264.MotionEstimation.Description="L'estimation du mouvement permet à l'encodeur de réduire le débit en calculant le déplacement des pixels."
+AMF.H264.MotionEstimation.None="Aucun"
+AMF.H264.MotionEstimation.Half="Demi-pixel"
+AMF.H264.MotionEstimation.Quarter="Quart de pixel"
+AMF.H264.MotionEstimation.Both="Demi-pixel & quart de pixel"
+AMF.H264.Device="Périphérique"
+AMF.H264.Device.Description="Quel périphérique utiliser pour l'encodage.\n<Seulement dans le cas où \"Type de mémoire\" n'est pas réglé sur \"Hôte\"."
+AMF.H264.UseOpenCL="OpenCL"
+AMF.H264.UseOpenCL.Description="L'encodeur doit-il utiliser OpenCL pour transmettre chaque image ?"
+AMF.H264.View="Mode de visualisation"
+AMF.H264.View.Description="Quels paramètres afficher ?\nChoisir '\@AMF.H264.View.Master\@' est réservé aux utilisateurs avancés, et vous exclus d'office de toute possibilité d'assistance de la part du développeur."
+AMF.H264.View.Basic="Basique"
+AMF.H264.View.Advanced="Avancé"
+AMF.H264.View.Expert="Expert"
+AMF.H264.View.Master="Maître"
+AMF.H264.UnlockProperties="Débloquer les propriétés"
+AMF.H264.UnlockProperties.Description="Sur certains paramètres, débloque au maximum la plage des valeurs possibles plutôt que de la limiter à une plage partielle."
+AMF.H264.Debug="Débogage"
+AMF.H264.Debug.Description="Activer le débogage avancé dans le fichier journal (dans le cas où vous souhaitez solliciter une assistance auprès du développeur de l'encodeur)."
+AMF.Util.Default="Défaut"
+AMF.Util.Automatic="Automatique"
+AMF.Util.Manual="Manuel"
+AMF.Util.Toggle.Disabled="Désactivé"
+AMF.Util.Toggle.Enabled="Activé"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/hr-HR.ini Added

@@ -0,0 +1,36 @@
+AMF.H264.Usage.Transcoding="Transkodiranje"
+AMF.H264.Usage.UltraLowLatency="Ultra nisko kašnjenje"
+AMF.H264.Usage.LowLatency="Nisko kašnjenje"
+AMF.H264.QualityPreset="Šablon kvaliteta"
+AMF.H264.QualityPreset.Speed="Brzina"
+AMF.H264.QualityPreset.Balanced="Izbalansirano"
+AMF.H264.QualityPreset.Quality="Kvalitet"
+AMF.H264.Profile="Profil"
+AMF.H264.ProfileLevel="Nivo profila"
+AMF.H264.ScanType="Vrsta skeniranja"
+AMF.H264.ScanType.Progressive="Progresivno"
+AMF.H264.ScanType.Interlaced="Isprekidano"
+AMF.H264.RateControlMethod="Metoda kontrole protoka"
+AMF.H264.RateControlMethod.CQP="Konstantan kvalitet (CQP)"
+AMF.H264.RateControlMethod.CBR="Konstantan protok (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Promenjivi protok (sa gornjom granicom) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Promenjivi protok (sa granicom kašnjenja) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Ciljani protok"
+AMF.H264.Bitrate.Peak="Granica protoka"
+AMF.H264.QP.Minimum="Minimalni QP"
+AMF.H264.QP.Maximum="Maksimalni QP"
+AMF.H264.QP.IFrame="I-Frejm QP"
+AMF.H264.QP.PFrame="P-Frejm QP"
+AMF.H264.QP.BFrame="B-Frejm QP"
+AMF.H264.QP.BPictureDelta="B-Promena slike QP"
+AMF.H264.QP.ReferenceBPictureDelta="Referenca B-Promena slike QP"
+AMF.H264.FillerData="Data za popunjavanje"
+AMF.H264.FrameSkipping="Preskakanje frejmova"
+AMF.H264.EnforceHRDCompatibility="Prisilna HRD kompatibilnost"
+AMF.H264.BPicture.Pattern="B-Šablonska slika"
+AMF.H264.BPicture.Reference="B-Referentna slika"
+AMF.H264.DeblockingFilter="Odblokirajući filter"
+AMF.Util.Default="Podrazumevano"
+AMF.Util.Automatic="Automatski"
+AMF.Util.Toggle.Disabled="Onemogućeno"
+AMF.Util.Toggle.Enabled="Omogućeno"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/hu-HU.ini Added

@@ -0,0 +1,80 @@
+AMF.H264.Preset="Készlet"
+AMF.H264.Preset.ResetToDefaults="Alapértelmezett beállítások visszaállítása"
+AMF.H264.Preset.Recording="Felvétel"
+AMF.H264.Preset.HighQuality="Kiváló minőség"
+AMF.H264.Preset.Indistinguishable="Megkülönböztethetetlen"
+AMF.H264.Preset.Lossless="Veszteségmentes"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Használat"
+AMF.H264.Usage.Transcoding="Transzkódolás"
+AMF.H264.Usage.UltraLowLatency="Nagyon alacsony késleltesésű"
+AMF.H264.Usage.LowLatency="Alacsony késleltetésű"
+AMF.H264.QualityPreset="Minőségi profil"
+AMF.H264.QualityPreset.Speed="Gyors"
+AMF.H264.QualityPreset.Balanced="Kiegyenlített"
+AMF.H264.QualityPreset.Quality="Minőségi"
+AMF.H264.Profile="Enkóder profil"
+AMF.H264.Profile.Description="Mely H.264 Profilt használja kódoláshoz:\n- 'Baseline' a legnagyobb platform támogatottsággal,\n- 'Main' a régebbi eszközök támogatják (ajánlott ha mobil eszköz tulajdonosokat céloz meg),\n- 'High' a jelenlegi eszközök támogatják (ajánlott)."
+AMF.H264.ProfileLevel="Profil szint"
+AMF.H264.MaximumLTRFrames="Maximális LTR képkocka"
+AMF.H264.ScanType="Rögzítés módja"
+AMF.H264.ScanType.Progressive="Progreszív"
+AMF.H264.ScanType.Interlaced="Interlaced (Kísérleti)"
+AMF.H264.RateControlMethod="Bitráta vezérlés"
+AMF.H264.RateControlMethod.CQP="Erőltetett QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Konstans bitráta (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Változó bitráta (Csúcsértéket betartva) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Változó bitráta (Késleltetés kényszerítése) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Bitráta (Bitben)"
+AMF.H264.Bitrate.Target.Description="Bitráta amelyet szeretne elérni a konvertálás során."
+AMF.H264.Bitrate.Peak="Csúcs bitráta (Bitben)"
+AMF.H264.Bitrate.Peak.Description="Bitráta amelyet maximálisan elérhet a konvertálás során."
+AMF.H264.QP.Minimum="Minimum QP"
+AMF.H264.QP.Minimum.Description="Legalacsonyabb QP (Quantization Parameter) képkockában használható érték."
+AMF.H264.QP.Maximum="Maximum QP"
+AMF.H264.QP.Maximum.Description="Legmagasabb QP (Quantization Parameter) képkockában használható érték."
+AMF.H264.QP.IFrame="I-Képkocka QP"
+AMF.H264.QP.IFrame.Description="Rögzített QP (Quantization Parameter) érték használata az I-Képkockákhoz.\nI-Képkocka QP értéknek nagyobbnak kell lennie a P- és B-Képkocka QP értéknél."
+AMF.H264.QP.PFrame="P-Képkocka QP"
+AMF.H264.QP.PFrame.Description="Rögzített QP (Quantization Parameter) érték használata a P-Képkockákhoz.\nIPKépkocka QP értéknek nagyobbnak kell lennie a B-Képkocka QP értéknél."
+AMF.H264.QP.BFrame="B-Képkocka QP"
+AMF.H264.QP.BFrame.Description="Rögzített QP (Quantization Parameter) érték a B-Képkockák használatához."
+AMF.H264.QP.BPictureDelta="B-Képkocka Delta QP"
+AMF.H264.QP.BPictureDelta.Description="Delta QP (Quantization Parameter) érték az utolsó nem referencia a B-Képhez."
+AMF.H264.QP.ReferenceBPictureDelta="Referencia B-képkocka Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="Delta QP (Quantization Parameter) érték az utolsó referencia a B-Képhez."
+AMF.H264.VBVBuffer="VBV puffer"
+AMF.H264.VBVBuffer.Strictness="VBV Puffer kötöttség"
+AMF.H264.VBVBuffer.Size="VBV pufferméret"
+AMF.H264.VBVBuffer.Fullness="VBV puffer telítettség"
+AMF.H264.FillerData="Filler adat"
+AMF.H264.FrameSkipping="Képkocka kihagyás"
+AMF.H264.EnforceHRDCompatibility="HRD Kompatibilitás kényszerítése"
+AMF.H264.MaximumAccessUnitSize="Hozzáférési egység maximális mérete"
+AMF.H264.KeyframeInterval="Kulcsképkocka időköze"
+AMF.H264.IDRPeriod="IDR időköz"
+AMF.H264.BPicture.Pattern="B-képkockák száma"
+AMF.H264.BPicture.Reference="B-képkocka referencia"
+AMF.H264.DeblockingFilter="Deblocking Filter"
+AMF.H264.SlicesPerFrame="Szeletelés képkockánként"
+AMF.H264.MotionEstimation="Mozgásbecslés"
+AMF.H264.MotionEstimation.None="Semmi"
+AMF.H264.MotionEstimation.Half="Fél-pixel"
+AMF.H264.MotionEstimation.Quarter="Negyed-pixel"
+AMF.H264.MotionEstimation.Both="Fél-&negyed-pixel"
+AMF.H264.Device="Eszköz"
+AMF.H264.UseOpenCL="OpenCL Használata"
+AMF.H264.View="Nézet mód"
+AMF.H264.View.Basic="Alap"
+AMF.H264.View.Advanced="Haladó"
+AMF.H264.View.Expert="Szakértő"
+AMF.H264.View.Master="Mester"
+AMF.H264.UnlockProperties="Tulajdonságok feloldása"
+AMF.H264.Debug="Hibakeresés"
+AMF.H264.Debug.Description="További hibakeresési naplózás engedélyezése, aktiválja amennyiben tanácsadásra van szüksége a kódolóval kapcsolatban."
+AMF.Util.Default="Alapértelmezett"
+AMF.Util.Automatic="Automatikus"
+AMF.Util.Manual="Manuális"
+AMF.Util.Toggle.Disabled="Letiltva"
+AMF.Util.Toggle.Enabled="Engedélyezve"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/it-IT.ini Added

@@ -0,0 +1,72 @@
+AMF.H264.Preset="Preset"
+AMF.H264.Preset.ResetToDefaults="Ripristina a Predefiniti"
+AMF.H264.Preset.Recording="Registrazione"
+AMF.H264.Preset.HighQuality="Alta Qualità"
+AMF.H264.Preset.Indistinguishable="Indistinguibili"
+AMF.H264.Preset.Lossless="Lossless"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Utilizzo"
+AMF.H264.Usage.Transcoding="Transcodifica"
+AMF.H264.Usage.UltraLowLatency="Latenza ultra bassa"
+AMF.H264.Usage.LowLatency="Bassa latenza"
+AMF.H264.QualityPreset="Qualità Preset"
+AMF.H264.QualityPreset.Speed="Velocità"
+AMF.H264.QualityPreset.Balanced="Bilanciato"
+AMF.H264.QualityPreset.Quality="Qualità"
+AMF.H264.Profile="Profilo"
+AMF.H264.ProfileLevel="Livello profilo"
+AMF.H264.ProfileLevel.Description="Quale livello di profilo H.264 usare per l'encoding:\n- 'Automatico' calcola il miglior livello per il dato Frame Rate e Frame Size,\n- '4.1' supporta 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' supporta 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' supporta 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' supporta 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' supporta 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Fotogrammi LTR Massimi"
+AMF.H264.ScanType="Tipo di scansione"
+AMF.H264.ScanType.Progressive="Progressivo"
+AMF.H264.ScanType.Interlaced="Interlacciato"
+AMF.H264.RateControlMethod="Metodo di controllo della frequenza"
+AMF.H264.RateControlMethod.CQP="QP Costante (QPC)"
+AMF.H264.RateControlMethod.CBR="Bitrate costante (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Bitrate Variabile (Peak Constrained) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Bitrate variabile (latenza vincolata) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Bitrate di destinazione"
+AMF.H264.Bitrate.Peak="Picco Bitrate"
+AMF.H264.QP.Minimum="QP Minimo"
+AMF.H264.QP.Maximum="QP Massimo"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta="Riferimento B-Picture Delta QP"
+AMF.H264.VBVBuffer="Buffer VBV"
+AMF.H264.VBVBuffer.Strictness="Strettezza Buffer VBV"
+AMF.H264.VBVBuffer.Size="Dimensione Buffer VBV"
+AMF.H264.VBVBuffer.Fullness="Larghezza Buffer VBV"
+AMF.H264.FillerData="Dati di riempimento"
+AMF.H264.FrameSkipping="Frame Skipping"
+AMF.H264.EnforceHRDCompatibility="Forza compatibilità HRD"
+AMF.H264.MaximumAccessUnitSize="Massima dimensione di unità d'accesso"
+AMF.H264.KeyframeInterval="Intervallo Keyframe"
+AMF.H264.IDRPeriod="Periodo IDR"
+AMF.H264.HeaderInsertionSpacing="Spaziatura di inserimento di intestazione"
+AMF.H264.BPicture.Pattern="Modello B-Picture"
+AMF.H264.BPicture.Reference="Riferimento B-Picture"
+AMF.H264.DeblockingFilter="Filtro di deblock"
+AMF.H264.SlicesPerFrame="Slices Per Frame"
+AMF.H264.IntraRefreshNumMBsPerSlot="Intra-Refresh Number of Macroblocks Per Slot"
+AMF.H264.MotionEstimation="Stima Movimento"
+AMF.H264.MotionEstimation.None="Nessuno"
+AMF.H264.MotionEstimation.Half="Metà-Pixel"
+AMF.H264.MotionEstimation.Quarter="Quarto-Pixel"
+AMF.H264.MotionEstimation.Both="Meta- & Quarto-Pixel"
+AMF.H264.Device="Dispositivo"
+AMF.H264.UseOpenCL="OpenCL"
+AMF.H264.View="Modalità di visualizzazione"
+AMF.H264.View.Basic="Basico"
+AMF.H264.View.Advanced="Avanzate"
+AMF.H264.View.Expert="Esperto"
+AMF.H264.View.Master="Master"
+AMF.H264.UnlockProperties="Sblocca proprietà"
+AMF.H264.Debug="Debug"
+AMF.Util.Default="Predefinito"
+AMF.Util.Automatic="Automatico"
+AMF.Util.Manual="Manuale"
+AMF.Util.Toggle.Disabled="Disabilitato"
+AMF.Util.Toggle.Enabled="Attivo"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/ja-JP.ini Added

@@ -0,0 +1,83 @@
+AMF.H264.Preset="プリセット"
+AMF.H264.Preset.ResetToDefaults="既定値に戻す"
+AMF.H264.Preset.Recording="録画中"
+AMF.H264.Preset.HighQuality="高品質"
+AMF.H264.Preset.Indistinguishable="区別不能品質"
+AMF.H264.Preset.Lossless="無損失品質"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="用途"
+AMF.H264.Usage.Transcoding="変換"
+AMF.H264.Usage.UltraLowLatency="超低遅延"
+AMF.H264.Usage.LowLatency="低遅延"
+AMF.H264.QualityPreset="品質プリセット"
+AMF.H264.QualityPreset.Speed="速度"
+AMF.H264.QualityPreset.Balanced="バランス"
+AMF.H264.QualityPreset.Quality="品質"
+AMF.H264.Profile="プロファイル"
+AMF.H264.ProfileLevel="プロファイルレベル"
+AMF.H264.ProfileLevel.Description="エンコードに使用する H.264 プロファイルレベル:\n- '自動' は与えられたフレームレートと解像度に対して最適なプロファイルレベルを計算し、\n- '4.1' は 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS をサポートし、\n- '4.2' は 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS をサポートし、\n- '5.0' は 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS をサポートし、\n- '5.1' は 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS をサポートし、\n- '5.2' は 3840x2160 60FPS、1920 x 1080 172FPS, 1280 x 720 172FPS, 960 x 540 172FPS をサポートします。"
+AMF.H264.MaximumLTRFrames="最大 LTR フレーム"
+AMF.H264.ScanType="スキャンの種類"
+AMF.H264.ScanType.Description="どのスキャン方法が使用されるか、'プログレッシブ'を常にこのままにしておきます。"
+AMF.H264.ScanType.Progressive="プログレッシブ"
+AMF.H264.ScanType.Interlaced="インターレース"
+AMF.H264.RateControlMethod="レート制御方式"
+AMF.H264.RateControlMethod.CQP="固定QP (CQP)"
+AMF.H264.RateControlMethod.CBR="固定ビットレート (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="可変ビットレート (ピーク制約) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="可変ビットレート (遅延制約) (VBR_LAT)"
+AMF.H264.Bitrate.Target="目標ビットレート"
+AMF.H264.Bitrate.Peak="最大ビットレート"
+AMF.H264.Bitrate.Peak.Description="全体的なシーケンスでピークを最大にしようとするビットレート。"
+AMF.H264.QP.Minimum="最小QP"
+AMF.H264.QP.Minimum.Description="フレームで使用する最低 QP (量子化パラメーター) の値です。"
+AMF.H264.QP.Maximum="最大QP"
+AMF.H264.QP.Maximum.Description="フレームで使用する最高 QP (量子化パラメーター) の値です。"
+AMF.H264.QP.IFrame="I-フレーム QP"
+AMF.H264.QP.PFrame="P-フレーム QP"
+AMF.H264.QP.BFrame="B-フレーム QP"
+AMF.H264.QP.BPictureDelta="B-画像デルタ QP"
+AMF.H264.QP.BPictureDelta.Description="最後の非参照B-画像のデルタQPです。"
+AMF.H264.QP.ReferenceBPictureDelta="B-画像参照のデルタQP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="最後の参照B-画像のデルタQPです。"
+AMF.H264.VBVBuffer="VBV バッファ"
+AMF.H264.VBVBuffer.Strictness="VBV バッファ厳密性"
+AMF.H264.VBVBuffer.Size="VBV バッファサイズ"
+AMF.H264.VBVBuffer.Fullness="VBV バッファ充満"
+AMF.H264.FillerData="フィラーデータ"
+AMF.H264.FrameSkipping="フレームスキップ"
+AMF.H264.EnforceHRDCompatibility="HRD 互換性を強制"
+AMF.H264.MaximumAccessUnitSize="最大アクセスユニットサイズ"
+AMF.H264.KeyframeInterval="キーフレーム間隔"
+AMF.H264.KeyframeInterval.Description="ドロップ不可能なフレーム間の秒数。\nGOPのサイズも制御します。"
+AMF.H264.IDRPeriod="IDR 周期"
+AMF.H264.HeaderInsertionSpacing="ヘッダー挿入間隔"
+AMF.H264.BPicture.Pattern="B-画像パターン"
+AMF.H264.BPicture.Reference="B-画像参照"
+AMF.H264.DeblockingFilter="デブロックフィルタ"
+AMF.H264.DeblockingFilter.Description="デコーダがエンコードされたストリームに対してデブロックフィルタの使用を許可されているかのフラグを設定します。"
+AMF.H264.SlicesPerFrame="フレームあたりのスライス"
+AMF.H264.IntraRefreshNumMBsPerSlot="スロットごとのマクロブロックのイントラリフレッシュ数"
+AMF.H264.MotionEstimation="動き推定"
+AMF.H264.MotionEstimation.Description="動き推定はピクセルがどこに移動したかを推定することによってエンコーダが必要とするビットレートを削減します。"
+AMF.H264.MotionEstimation.None="未設定"
+AMF.H264.MotionEstimation.Half="1/2ピクセル"
+AMF.H264.MotionEstimation.Quarter="1/4ピクセル"
+AMF.H264.MotionEstimation.Both="ハーフ & クォーターピクセル"
+AMF.H264.Device="デバイス"
+AMF.H264.UseOpenCL="OpenCL を使用する"
+AMF.H264.View="表示モード"
+AMF.H264.View.Description="どのプロパティが表示されるか。  'エキスパート' または 'マスター' の表示モードを使用する場合はサポートを受けられません。"
+AMF.H264.View.Basic="基本"
+AMF.H264.View.Advanced="詳細設定"
+AMF.H264.View.Expert="エキスパート"
+AMF.H264.View.Master="マスター"
+AMF.H264.UnlockProperties="プロパティのロック解除"
+AMF.H264.Debug="デバッグ"
+AMF.H264.Debug.Description="追加のデバッグログ出力を有効にし、これはこのエンコーダでサポートが必要なときにアクティブにする必要があります。"
+AMF.Util.Default="既定値"
+AMF.Util.Automatic="自動"
+AMF.Util.Manual="手動"
+AMF.Util.Toggle.Disabled="無効"
+AMF.Util.Toggle.Enabled="有効"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/ko-KR.ini Added

@@ -0,0 +1,109 @@
+AMF.H264.Preset="사전 설정"
+AMF.H264.Preset.ResetToDefaults="기본값으로 복구"
+AMF.H264.Preset.Recording="녹화"
+AMF.H264.Preset.HighQuality="우수한 품질"
+AMF.H264.Preset.Indistinguishable="무손실과 거의 구분 불가"
+AMF.H264.Preset.Lossless="무손실"
+AMF.H264.Preset.Twitch="트위치"
+AMF.H264.Preset.YouTube="유튜브"
+AMF.H264.Usage="용도"
+AMF.H264.Usage.Description="용도에 따라 AMF을 조율합니다:\n- '트랜스코딩'은 일반적인 용도에 적합한 설정입니다(추천).\n- '매우 낮은 지연시간'은 아주 낮은 인코딩 레이턴시를 의미합니다.\n- '낮은 지연시간'은 그 수준이 조금 더 높습니다.\n방송 목적으로는 '트랜스코딩'만 지원됩니다. 모든 다른 설정값은 녹화 용도에만 사용됩니다."
+AMF.H264.Usage.Transcoding="트랜스코딩"
+AMF.H264.Usage.UltraLowLatency="매우 낮은 지연 시간"
+AMF.H264.Usage.LowLatency="낮은 지연 시간"
+AMF.H264.QualityPreset="품질 사전 설정"
+AMF.H264.QualityPreset.Description="AMF 품질을 결정할 때 어떤 수준을 목표로 할지 결정합니다:\n-'속도'는 가장 빠르지만, 품질이 가장 나쁘며,\n- '균형'은 '속도'와 '품질' 사이의 수준을 제공합니다.\n- '품질'은 주어진 비트레이트 내에서 가장 뛰어난 품질을 제공합니다."
+AMF.H264.QualityPreset.Speed="속도"
+AMF.H264.QualityPreset.Balanced="균형"
+AMF.H264.QualityPreset.Quality="품질"
+AMF.H264.Profile="프로파일"
+AMF.H264.Profile.Description="인코딩에 사용할 H.264 프로파일을 선택합니다:\n- 'Baseline'은 지원하는 플랫폼이 가장 많습니다,\n- 'Main'은 비교적 오래된 장치에서 지원합니다. (모바일 장치를 대상으로 한다면 추천하는 설정입니다),\n- 'High'는 현재 장치에서 지원하는 설정입니다 (추천)."
+AMF.H264.ProfileLevel="프로필 수준"
+AMF.H264.ProfileLevel.Description="인코딩으로 사용할 H.264 프로파일 수준을 지정합니다:\n-'자동'은 설정된 프레임과 그 크기에 맞춰 가장 좋은 수준을 계산합니다,\n-'4.1'은 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS을 지원합니다,\n-'4.2'는 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS을 지원합니다,\n- '5.0'은 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS을 지원합니다,\n- '5.1'은 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS을 지원합니다,\n- '5.2'은 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS을 지원합니다."
+AMF.H264.MaximumLTRFrames="최대 장기참조 프레임"
+AMF.H264.MaximumLTRFrames.Description="장기참조 프레임(LTR)은 인코더가 특정 프레임을 참조 가능하게 만들어 줍니다.\n이 설정은 B-화면 기능이 지원되지 않거나 필요한 경우 품질을 올리는데 도움이 될 수 있습니다.\n장기참조 프레임은 B-화면과 동시에 사용할 수 없습니다."
+AMF.H264.ScanType="스캔 형식"
+AMF.H264.ScanType.Description="주사 방식을 설정합니다. 항상 '프로그레시브'로 두십시오."
+AMF.H264.ScanType.Progressive="프로그레시브"
+AMF.H264.ScanType.Interlaced="인터레이스"
+AMF.H264.RateControlMethod="속도 제어 방식"
+AMF.H264.RateControlMethod.Description="속도 제어 동작 방식을 설정합니다:\n- '\@AMF.H264.RateControlMethod.CQP\@'는 고정된 I-/P-/B- 프레임 QP (양자화 매개변수) 값을 할당합니다, \n- '\@AMF.H264.RateControlMethod.CBR\@'은 주어진 목표 비트레이트를 유지합니다. (채우기 정보를 사용)(방송에 추천함),\n- '\@AMF.H264.RateControlMethod.VBR\@'은 주어진 최대 비트레이트보다 낮은 수준을 유지합니다,\n- '\@AMF.H264.RateControlMethod.VBR_LAT\@'는 GPU의 지연시간과 부하가 허용한다면 목표 비트레이트에 가까운 수준을 유지하며, 그렇지 않은 상황에서는 그보다 높은 비트레이트를 사용합니다. (녹화에 추천)."
+AMF.H264.RateControlMethod.CQP="고정 QP (CQP)"
+AMF.H264.RateControlMethod.CBR="고정 비트레이트 (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="가변 비트레이트 (최대 비트레이트 제약) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="가변 비트레이트(지연율 제약) (VBR_LAT)"
+AMF.H264.Bitrate.Target="목표 비트레이트"
+AMF.H264.Bitrate.Target.Description="전체 장면에서 달성하려는 비트레이트"
+AMF.H264.Bitrate.Peak="최대 비트레이트"
+AMF.H264.Bitrate.Peak.Description="전체 장면에서 달성하려는 비트레이트 최고조"
+AMF.H264.QP.Minimum="최소 QP"
+AMF.H264.QP.Minimum.Description="하나의 프레임에 사용하는 최저 QP (양자화 매개변수) 값"
+AMF.H264.QP.Maximum="최대 QP"
+AMF.H264.QP.Maximum.Description="하나의 프레임에 사용하는 최고 QP (양자화 매개변수) 값"
+AMF.H264.QP.IFrame="I-프레임 QP"
+AMF.H264.QP.IFrame.Description="I-화면에 사용하는 고정 QP (양자화 매개변수) 값.\nI-화면 QP는 P-와 B-화면 QP값과 같거나 커야 함."
+AMF.H264.QP.PFrame="P-프레임 QP"
+AMF.H264.QP.PFrame.Description="P-화면에 사용하는 고정 QP (양자화 매개변수) 값.\nP-화면 QP는 B-화면 QP값과 같거나 혹은 커야 함."
+AMF.H264.QP.BFrame="BP-프레임 QP"
+AMF.H264.QP.BFrame.Description="B-화면에 사용하는 고정 QP (양자화 매개변수) 값."
+AMF.H264.QP.BPictureDelta="B-화면 델타 QP"
+AMF.H264.QP.BPictureDelta.Description="마지막 비참조 B-화면의 델타 QP."
+AMF.H264.QP.ReferenceBPictureDelta="참조 B-화면 델타 QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="마지막 참조 B-화면의 델타 QP."
+AMF.H264.VBVBuffer="VBV 버퍼"
+AMF.H264.VBVBuffer.Description="VBV 버퍼 크기를 결정하는 방식을 설정합니다:\n-'자동'은 엄격도의 제약하에 크기를 계산합니다.\n-'수동'은 사용자가 크기를 조절할 수 있도록 허용합니다.\n일부 특정 속도제어 방식이 사용하는 VBV (Video Buffering Verifier) 버퍼는 제공된 제약 안에서 전반적인 비트레이트를 유지합니다."
+AMF.H264.VBVBuffer.Strictness="VBV 버퍼 엄격도"
+AMF.H264.VBVBuffer.Strictness.Description="VBV 버퍼가 어떤 수준으로 제어될지 결정합니다. 100%에는 목표로 정한 비트레이트와 거의 일치하도록 조절하며 0%에서는 제약이 사라집니다."
+AMF.H264.VBVBuffer.Size="VBV 버퍼 크기"
+AMF.H264.VBVBuffer.Size.Description="한 장면의 비트레이트 제어에 사용하는 VBV 버퍼의 크기를 설정합니다.\n크기를 작게 설정하면 거의 완벽하게 비트레이트 수준에 일치하는 결과를 얻지만, 작업을 하는데 더 많은 자원을 요구합니다."
+AMF.H264.VBVBuffer.Fullness="VBV 버퍼 충만도"
+AMF.H264.VBVBuffer.Fullness.Description="초기 VBV버퍼가 얼마나 충만한지는 오로지 인코딩의 초반에만 영향을 미칩니다."
+AMF.H264.FillerData="채우기 정보"
+AMF.H264.FillerData.Description="데이터 채우기는 인코더가 한 장면에 남은 공간을 빈 정보로 채워 목표 비트레이트를 유지할 수 있도록 합니다."
+AMF.H264.FrameSkipping="프레임 생략"
+AMF.H264.FrameSkipping.Description="프레임 생략은 인코더가 목표로 하는 비트레이트 요건을 맞추기 위해 프레임을 떨어뜨릴 수 있습니다.\n인코더가 프레임 하나를 떨어뜨리면 마지막 프레임 NAL을 대신 전송합니다.\n목표 비트레이트가 아주 낮을 때 도움이 될 수 있습니다."
+AMF.H264.EnforceHRDCompatibility="HDR 호환모드 적용"
+AMF.H264.EnforceHRDCompatibility.Description="이론적 기본 디코더 강제는 프레임 하나의 최대 QP값 변화를 제한하는 설정입니다.\n녹화나 방송에는 적합하지 않고 기본 소프트웨어 디코더만 사용 가능한 매우 낡은 장치에서 영상을 재생할 때 사용합니다."
+AMF.H264.MaximumAccessUnitSize="최대 접근 유닛 크기"
+AMF.H264.MaximumAccessUnitSize.Description="NAL 장치에서 단일 접근 유닛의 가장 큰 크기를 결정합니다. 0 값은 인코더가 최적화된 수치를 결정하도록 허용합니다."
+AMF.H264.KeyframeInterval="키프레임 간격"
+AMF.H264.KeyframeInterval.Description="손실이 불가능한 프레임 사이에 얼마나 많은 시간(초)이 필요한지 설정합니다.\n또한 영상(GOP) 크기도 제어합니다."
+AMF.H264.IDRPeriod="IDR 주기"
+AMF.H264.IDRPeriod.Description="프레임 내에서 순간 복호 갱신(nstantaneous Decoding Refreshes) 사이의 거리를 설정합니다. 또한, GOP-장면 크기를 제어합니다."
+AMF.H264.HeaderInsertionSpacing="헤더 삽입 간격"
+AMF.H264.HeaderInsertionSpacing.Description="NAL 헤더 사이에 얼마나 많은 프레임이 필요한지 설정합니다. 0(자동)에서 바꾸는 것은 추천하지 않습니다."
+AMF.H264.BPicture.Pattern="B-화면 양식"
+AMF.H264.BPicture.Pattern.Description="인코딩에서 얼마나 많은 B-화면이 필요한지 결정합니다. 수치가 늘어날수록 품질은 올라가고 필요한 성능은 높아집니다.\n2세대와 3 세대 VCE 카드에서만 지원이 됩니다."
+AMF.H264.BPicture.Reference="B-화면 참조"
+AMF.H264.BPicture.Reference.Description="다른 B-화면뿐만 아니라 P-/I-화면에도 B-화면을 참조할 수 있도록 허용합니다.\n높은 성능이 요구되지만 품질 개선에는 그리 큰 효과가 없습니다."
+AMF.H264.DeblockingFilter="디블록 필터"
+AMF.H264.DeblockingFilter.Description="디코더가 인코딩된 작업에 디블록 필터를 사용할 수 있도록 허용합니다."
+AMF.H264.SlicesPerFrame="조각 당 프레임"
+AMF.H264.SlicesPerFrame.Description="프레임마다 얼마나 많은 I-화면 조각을 저장할지 결정합니다.\n0값은 인코더가 상태에 따라 맞춰 조절합니다.\n인트라-리프레시 인코딩은 더 빠른 재생과 탐색을 위해 사용합니다."
+AMF.H264.IntraRefreshNumMBsPerSlot="슬롯 당 매크로블록의 인트라-리프레시 수"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="슬롯마다 얼마나 많은 매크로 블록을 저장할지 결정합니다.\n\0값은 인코더가 상태에 따라 맞춰 조절합니다.\n인인트라-리프레시 인코딩은 더 빠른 재생과 탐색을 위해 사용합니다."
+AMF.H264.MotionEstimation="동작 예측"
+AMF.H264.MotionEstimation.Description="동작 추정은 픽셀의 움직임을 추정하여 필요한 비트레이트를 줄일 수 있게 합니다."
+AMF.H264.MotionEstimation.None="없음"
+AMF.H264.MotionEstimation.Half="1/2 화소"
+AMF.H264.MotionEstimation.Quarter="1/4 화소"
+AMF.H264.MotionEstimation.Both="1/2 & 1/4 화소"
+AMF.H264.Device="장치"
+AMF.H264.Device.Description="인코덩에 사용할 장치를 설정합니다.\n메모리 형식에서 'Host'를 선택하면 안됩니다."
+AMF.H264.UseOpenCL="OpenCL 사용"
+AMF.H264.UseOpenCL.Description="해당 인코더가 개별 프레임을 제출할 때 OpenCL을 사용하겠습니까?"
+AMF.H264.View="보기 모드"
+AMF.H264.View.Description="어떤 설정을 표시할지 결정합니다. '숙련' 혹은 '달인' 표시 모드에서는 지원을 받을 수 없습니다."
+AMF.H264.View.Basic="기본"
+AMF.H264.View.Advanced="고급"
+AMF.H264.View.Expert="숙련"
+AMF.H264.View.Master="달인"
+AMF.H264.UnlockProperties="속성 잠금해제"
+AMF.H264.UnlockProperties.Description="특정 설정을 부분적이 아닌 전체 범위를 다룰 수 있도록 잠금을 해제합니다."
+AMF.H264.Debug="디버그"
+AMF.H264.Debug.Description="추가적인 디버그 기록을 활성화하여 이 인코더에 대한 지원이 필요할 때 제출하십시오."
+AMF.Util.Default="기본값"
+AMF.Util.Automatic="자동"
+AMF.Util.Manual="수동"
+AMF.Util.Toggle.Disabled="비활성화"
+AMF.Util.Toggle.Enabled="활성화"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/nb-NO.ini Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/nl-NL.ini Added

@@ -0,0 +1,51 @@
+AMF.H264.Preset="Voorkeursinstelling"
+AMF.H264.Preset.Recording="Opname"
+AMF.H264.Preset.HighQuality="Hoge kwaliteit"
+AMF.H264.Preset.Indistinguishable="Ononderscheidbaar"
+AMF.H264.Preset.Lossless="Lossless"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Gebruik"
+AMF.H264.Usage.Description="Voor welk gebruik moet AMF ingesteld worden:\n- 'Transcoden' is standaard transcoden (aanbevolen),\n- 'Ultra Low Latency' is voor erg lage latency encoding,\n- 'Low Latency' is vergelijkbaar met bovenstaande met een iets hogere latency.\nVoor streamen is alleen 'Transcoden' mogelijk, alle andere waarden kunnen worden gebruikt voor opnemen."
+AMF.H264.Usage.Transcoding="Transcoding"
+AMF.H264.Usage.UltraLowLatency="Ultra Low Latency"
+AMF.H264.Usage.LowLatency="Low Latency"
+AMF.H264.QualityPreset="Kwaliteitsinstelling"
+AMF.H264.QualityPreset.Speed="Snelheid"
+AMF.H264.QualityPreset.Balanced="Gebalanceerd"
+AMF.H264.QualityPreset.Quality="Kwaliteit"
+AMF.H264.Profile="Profiel"
+AMF.H264.ProfileLevel="Profielniveau"
+AMF.H264.ProfileLevel.Description="Welk H.264 profielniveau moet worden gebruikt voor encoden:\n- 'Automatisch' berekent het beste profielniveau voor de gebruikte framerate en framegrootte.\n- '4.1' ondersteunt 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' ondersteunt 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' ondersteunt1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' ondersteunt3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' ondersteunt 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Maximale LTR Frames"
+AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Frames zijn een functie waarmee de encoder bepaalde frames achter elkaar als refereerbaar kan markern.\nDit kan een positief effect hebben op de kwaliteit wanneer B-Pictures niet ondersteund of gewild zijn.\nLTR Frames kunnen niet samen met B-Pictures gebruikt worden en deencoder zal B-Pictures uitschakelen als deze worden gebruikt."
+AMF.H264.ScanType="Scantype"
+AMF.H264.ScanType.Progressive="Progressive"
+AMF.H264.ScanType.Interlaced="Interlaced"
+AMF.H264.RateControlMethod="Rate control methode"
+AMF.H264.RateControlMethod.CQP="Constant QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Constant Bitrate (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Variable Bitrate (Peak Constrained) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Variable Bitrate (Latency Constrained) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Doelbitrate"
+AMF.H264.Bitrate.Peak="Maximale bitrate"
+AMF.H264.QP.Minimum="Minimale QP"
+AMF.H264.QP.Maximum="Maximale QP"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.BPictureDelta.Description="Delta QP (Quantization Parameter) waarde tot de laatste niet-reference B-Picture."
+AMF.H264.QP.ReferenceBPictureDelta="Referentie B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="Delta QP (Quantization Parameter) waarde tot de laatste referentie B-Picture,."
+AMF.H264.VBVBuffer="VBV Buffer"
+AMF.H264.FillerData="Opvuldata"
+AMF.H264.FrameSkipping="Frames overslaan"
+AMF.H264.EnforceHRDCompatibility="Forceer HDR compatibiliteit"
+AMF.H264.BPicture.Pattern="B-Picture patroon"
+AMF.H264.BPicture.Reference="B-Picture referentie"
+AMF.H264.DeblockingFilter="Deblocking Filter"
+AMF.Util.Default="Standaard"
+AMF.Util.Automatic="Automatisch"
+AMF.Util.Toggle.Disabled="Uitgeschakeld"
+AMF.Util.Toggle.Enabled="Ingeschakeld"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/pl-PL.ini Added

@@ -0,0 +1,44 @@
+AMF.H264.Preset="Profil"
+AMF.H264.Preset.Recording="Nagrywanie"
+AMF.H264.Preset.HighQuality="Wysoka jakość"
+AMF.H264.Preset.Indistinguishable="Nie do odróżnienia"
+AMF.H264.Preset.Lossless="Bezstratny"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Sposób użycia"
+AMF.H264.Usage.Transcoding="Konwersja"
+AMF.H264.Usage.UltraLowLatency="Bardzo niskie opóźnienie"
+AMF.H264.Usage.LowLatency="Niskie opóźnienie"
+AMF.H264.QualityPreset="Ustawienie jakości"
+AMF.H264.QualityPreset.Speed="Szybkość"
+AMF.H264.QualityPreset.Balanced="Zrównoważone"
+AMF.H264.QualityPreset.Quality="Jakość"
+AMF.H264.Profile="Profil"
+AMF.H264.ProfileLevel="Profil"
+AMF.H264.ScanType="Metoda skanowania"
+AMF.H264.ScanType.Progressive="Progresywne"
+AMF.H264.ScanType.Interlaced="Z przeplotem"
+AMF.H264.RateControlMethod="Metoda kontroli przepływności"
+AMF.H264.RateControlMethod.CQP="Stała QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Stała przepływność (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Zmienna przepływność (z ograniczeniem górnym) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Zmienna przepływność (z ograniczeniem opóźnieniem) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Przepływność docelowa"
+AMF.H264.Bitrate.Peak="Przepływność szczytowa"
+AMF.H264.QP.Minimum="Minimalna QP"
+AMF.H264.QP.Maximum="Maksymalna QP"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta="Referencyjne B-Picture Delta QP"
+AMF.H264.FillerData="Filler Data"
+AMF.H264.FrameSkipping="Pomijanie klatek"
+AMF.H264.EnforceHRDCompatibility="Wymuszanie zgodności HRD"
+AMF.H264.BPicture.Pattern="Schemat B-Picture"
+AMF.H264.BPicture.Reference="Referencyjny B-Picture"
+AMF.H264.DeblockingFilter="Filtr niwelujacy bloki obrazu"
+AMF.Util.Default="Domyślne"
+AMF.Util.Automatic="Automatycznie"
+AMF.Util.Toggle.Disabled="Wyłączone"
+AMF.Util.Toggle.Enabled="Włączone"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/ru-RU.ini Added

@@ -0,0 +1,103 @@
+AMF.H264.Preset="Предустановка"
+AMF.H264.Preset.ResetToDefaults="Сброс по умолчанию"
+AMF.H264.Preset.Recording="Запись"
+AMF.H264.Preset.HighQuality="Высокое качество"
+AMF.H264.Preset.Indistinguishable="Незаметные потери"
+AMF.H264.Preset.Lossless="Без потерь"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Назначение"
+AMF.H264.Usage.Description="На какой режим использования должен быть настроен AMF:\n- 'Перекодировка' — для перекодировки общего назначения (рекомендуется),\n- 'Очень низкая задержка' — для кодировки с очень низкой задержкой,\n- 'Низкая задержка' похожа на пункт выше, но с немного большей задержкой.\nТрансляции поддерживают только 'перекодировку', все остальные значения могут быть использованы для записи."
+AMF.H264.Usage.Transcoding="Транскодирование"
+AMF.H264.Usage.UltraLowLatency="Очень низкая задержка"
+AMF.H264.Usage.LowLatency="Низкая задержка"
+AMF.H264.QualityPreset="Предустановки качества"
+AMF.H264.QualityPreset.Description="К какому пресету качества AMF нужно стремиться:\n-'Speed' самый быстрый, но имеет самое низкое качество,\n-'Balanced' между 'Speed' и 'Quality', предоставляет хорошее соотношение между скоростью и качеством,\n-'Quality' предоставляет наилучшее качество для предоставленного битрейта."
+AMF.H264.QualityPreset.Speed="Скорость"
+AMF.H264.QualityPreset.Balanced="Баланс"
+AMF.H264.QualityPreset.Quality="Качество"
+AMF.H264.Profile="Профиль кодирования"
+AMF.H264.ProfileLevel="Уровень профиля"
+AMF.H264.ProfileLevel.Description="Какой уровень профиля H.264 использовать для кодирования:\n- 'Автоматически' выбирает наиболее подходящий уровень под выбранную частоту и размер кадра,\n- '4.1' поддерживает 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2' поддерживает 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0' поддерживает 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1' поддерживает 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2' поддерживает 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="Максимум LTR-кадров"
+AMF.H264.MaximumLTRFrames.Description="Long Term Reference (LTR) Frames - функция позволяющая кодировщику помечать определенные кадры в последовательности как ссылаемые.\nЭта функция может поднять качество, если функция B-Pictrues не поддерживается или не желательна.\nФункция LTR Frames не может использоваться вместе с функцией B-Pictrues и кодировщик отключит функцию B-Pictrues если таковая используется."
+AMF.H264.ScanType="Развертка"
+AMF.H264.ScanType.Description="Какой режим сканирования использовать; всегда оставляется этот параметр на 'прогрессивном'."
+AMF.H264.ScanType.Progressive="Прогрессивная"
+AMF.H264.ScanType.Interlaced="Чересстрочная"
+AMF.H264.RateControlMethod="Метод кодирования"
+AMF.H264.RateControlMethod.CQP="CQP: постоянное качество"
+AMF.H264.RateControlMethod.CBR="CBR: постоянный битрейт"
+AMF.H264.RateControlMethod.VBR.Peak="VBR: переменный битрейт (Ограничение пиков)"
+AMF.H264.RateControlMethod.VBR.Latency="VBR: переменный битрейт (Ограничение задержки)"
+AMF.H264.Bitrate.Target="Битрейт"
+AMF.H264.Bitrate.Target.Description="Битрейт желаемый для получения во всей последовательности."
+AMF.H264.Bitrate.Peak="Пиковый битрейт"
+AMF.H264.Bitrate.Peak.Description="Максимальный пиковый битрейт желаемый для получения во всей последовательности."
+AMF.H264.QP.Minimum="Минимальное QP"
+AMF.H264.QP.Minimum.Description="Наименьшее значение QP (Параметр квантования) для использования в кадре."
+AMF.H264.QP.Maximum="Максимальное QP"
+AMF.H264.QP.Maximum.Description="Наибольшее значение QP (Параметр квантования) для использования в кадре."
+AMF.H264.QP.IFrame="I-кадр QP"
+AMF.H264.QP.IFrame.Description="Фиксированное значение QP (Параметр квантования) для использования в I-Кадрах.\nQP I-Кадров должен быть равен или больше чем QP P- и B-Кадров."
+AMF.H264.QP.PFrame="P-кадр QP"
+AMF.H264.QP.PFrame.Description="Фиксированное значение QP (Параметр квантования) для использования в P-Кадрах.\nQP P-Кадров должен быть равен или больше чем QP B-Кадров."
+AMF.H264.QP.BFrame="B-кадр QP"
+AMF.H264.QP.BFrame.Description="Фиксированное значение QP (Параметр квантования) для использования в B-Кадрах."
+AMF.H264.QP.BPictureDelta="B-кадры дельта QP"
+AMF.H264.QP.BPictureDelta.Description="Дельта QP до последнего не референсного B-кадра."
+AMF.H264.QP.ReferenceBPictureDelta="Референсные B-кадры дельта QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="Дельта QP до последнего референсного B-кадра."
+AMF.H264.VBVBuffer="Буфер VBV"
+AMF.H264.VBVBuffer.Description="Какой метод следует использовать для определения Размера буфера VBV:\n- '\@AMF.Util.Automatic\@' рассчитывает размер ограничивающийся строгостью,\n- '\@AMF.Util.Manual\@' позволяет пользователю контролировать размер буфера.\nVBV (Верификатор буферизации видео) буфер используется некоторыми Методами управления скоростью, чтобы сохранить общий битрейт в пределах заданных ограничений."
+AMF.H264.VBVBuffer.Strictness="Строгость буфера VBV"
+AMF.H264.VBVBuffer.Strictness.Description="Насколько строго должен быть ограничен буфер VBV: 100% — почти полное соответствие целевому битрейту, 0% — без ограничений."
+AMF.H264.VBVBuffer.Size="Размер буфера VBV"
+AMF.H264.VBVBuffer.Fullness="Заполнение буфера VBV"
+AMF.H264.VBVBuffer.Fullness.Description="Изначальная степень заполнения VBV буфера, будет влиять только на первоначальную последовательность кодирования."
+AMF.H264.FillerData="Данные наполнителя"
+AMF.H264.FrameSkipping="Пропуск кадров"
+AMF.H264.EnforceHRDCompatibility="Принудительная HRD совместимость"
+AMF.H264.MaximumAccessUnitSize="Максимальный Размер Блока Доступа"
+AMF.H264.MaximumAccessUnitSize.Description="Большой размер блока доступа для NAL. Значение 0 позволяет регулировать, чтобы выбрать лучший."
+AMF.H264.KeyframeInterval="Интервал ключевых кадров"
+AMF.H264.KeyframeInterval.Description="Сколько секунд должен быть просадок кадров.\nТакже контролирует GOP Size."
+AMF.H264.IDRPeriod="Период IDR"
+AMF.H264.IDRPeriod.Description="Определяет расстояние между Мгновенными обновлениями декодирования (IDR) в кадрах. Так же контролирует размер последовательности GOP."
+AMF.H264.HeaderInsertionSpacing="Расстояние вставки заголовка"
+AMF.H264.HeaderInsertionSpacing.Description="Сколько кадров должно быть между заголовками NAL. Не рекомендуется менять значение с 0 (автоматически)."
+AMF.H264.BPicture.Pattern="Патерн B-кадра"
+AMF.H264.BPicture.Pattern.Description="Сколько кадров B-Pictures должно быть разрешено для кодирования. Имеет положительный эффект на качестве и негативный на производительности.\nПоддерживает только второе поколение VCE. Значение функции LTR Frames должно быть равно нулю."
+AMF.H264.BPicture.Reference="Референс B-кадра"
+AMF.H264.BPicture.Reference.Description="Разрешает B-Кадрам ссылаться на другие B-Кадры как и на P- и I-Кадры.\nОгромный урон производительности, исправление низкого качества."
+AMF.H264.DeblockingFilter="Фильтр деблокинга"
+AMF.H264.DeblockingFilter.Description="Устанавливает флаг, что декодер может использовать фильтр удаления блочности для прямой трансляции."
+AMF.H264.SlicesPerFrame="Количество частей на кадр"
+AMF.H264.SlicesPerFrame.Description="Сколько кусков I-Кадров должно быть сохранено в каждом кадре?\nЗначение 0 позволяет кодировщику выбирать \"на лету\".\nКодирование Intra-Refresh используется для быстрого воспроизведения и поиска при перемотке."
+AMF.H264.IntraRefreshNumMBsPerSlot="Интра-обновить Количество Макроблоков в слот"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="Сколько Макроблоков должно быть сохранено в каждом слоте?\nЗначение 0 позволяет кодировщику выбирать \"на лету\".\nКодирование Intra-Refresh используется для быстрого воспроизведения и поиска при перемотке."
+AMF.H264.MotionEstimation="Оценка движения"
+AMF.H264.MotionEstimation.Description="Оценки движения позволяет кодировщику необходимость уменьшить Битрейт, оценивая, где пиксель прошел."
+AMF.H264.MotionEstimation.None="Нет"
+AMF.H264.MotionEstimation.Half="Пол-пиксельная"
+AMF.H264.MotionEstimation.Quarter="Четверть-пиксельная"
+AMF.H264.MotionEstimation.Both="Пол- & Четверть-пиксельная"
+AMF.H264.Device="Устройство"
+AMF.H264.Device.Description="Которое из устройств использовать для кодирования.\nТип памяти должен быть не 'Host'."
+AMF.H264.UseOpenCL="Использовать OpenCL"
+AMF.H264.UseOpenCL.Description="Должен ли кодировщик использовать OpenCL для подтверждения индивидуальных кадров?"
+AMF.H264.View="Режим просмотра"
+AMF.H264.View.Description="Какие параметры должны быть видны. Вы не будете получать поддержку при использовании режимов 'Эксперт' и 'Мастер'."
+AMF.H264.View.Basic="Обычный"
+AMF.H264.View.Advanced="Расширенный"
+AMF.H264.View.Expert="Эксперт"
+AMF.H264.View.Master="Мастер"
+AMF.H264.UnlockProperties="Разблокировать параметры"
+AMF.H264.UnlockProperties.Description="Разблокировать определённые параметры до их полного, неограниченного диапазона."
+AMF.H264.Debug="Отладка"
+AMF.H264.Debug.Description="Включить дополнительные логи для отладки; следует включить, если вам нужна поддержка с этим кодировщиком."
+AMF.Util.Default="По умолчанию"
+AMF.Util.Automatic="Автоматически"
+AMF.Util.Manual="Руководство"
+AMF.Util.Toggle.Disabled="Выключено"
+AMF.Util.Toggle.Enabled="Включено"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/sk-SK.ini Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/sr-CS.ini Added

@@ -0,0 +1,44 @@
+AMF.H264.Preset="Šablon"
+AMF.H264.Preset.Recording="Snimanje"
+AMF.H264.Preset.HighQuality="Visoki kvalitet"
+AMF.H264.Preset.Indistinguishable="Istovetno"
+AMF.H264.Preset.Lossless="Bez gubitaka"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage.Transcoding="Transkodiranje"
+AMF.H264.Usage.UltraLowLatency="Ultra nisko kašnjenje"
+AMF.H264.Usage.LowLatency="Nisko kašnjenje"
+AMF.H264.QualityPreset="Šablon kvaliteta"
+AMF.H264.QualityPreset.Speed="Brzina"
+AMF.H264.QualityPreset.Balanced="Izbalansirano"
+AMF.H264.QualityPreset.Quality="Kvalitet"
+AMF.H264.Profile="Profil"
+AMF.H264.ProfileLevel="Nivo profila"
+AMF.H264.MaximumLTRFrames="Maksimalan broj LTR frejmova"
+AMF.H264.ScanType="Vrsta skeniranja"
+AMF.H264.ScanType.Progressive="Progresivno"
+AMF.H264.ScanType.Interlaced="Isprekidano"
+AMF.H264.RateControlMethod="Metoda kontrole protoka"
+AMF.H264.RateControlMethod.CQP="Konstantan kvalitet (CQP)"
+AMF.H264.RateControlMethod.CBR="Konstantan protok (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Promenjivi protok (sa gornjom granicom) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Promenjivi protok (sa granicom kašnjenja) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Ciljani protok"
+AMF.H264.Bitrate.Peak="Granica protoka"
+AMF.H264.QP.Minimum="Minimalni QP"
+AMF.H264.QP.Maximum="Maksimalni QP"
+AMF.H264.QP.IFrame="I-Frejm QP"
+AMF.H264.QP.PFrame="P-Frejm QP"
+AMF.H264.QP.BFrame="B-Frejm QP"
+AMF.H264.QP.BPictureDelta="B-Promena slike QP"
+AMF.H264.QP.ReferenceBPictureDelta="Referenca B-Promena slike QP"
+AMF.H264.FillerData="Podaci za popunjavanje"
+AMF.H264.FrameSkipping="Preskakanje frejmova"
+AMF.H264.EnforceHRDCompatibility="Prisilna HRD kompatibilnost"
+AMF.H264.BPicture.Pattern="B-Šablonska slika"
+AMF.H264.BPicture.Reference="B-Referentna slika"
+AMF.H264.DeblockingFilter="Odblokirajući filter"
+AMF.Util.Default="Podrazumevano"
+AMF.Util.Automatic="Automatski"
+AMF.Util.Toggle.Disabled="Onemogućeno"
+AMF.Util.Toggle.Enabled="Omogućeno"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/sr-SP.ini Added

@@ -0,0 +1,36 @@
+AMF.H264.Usage.Transcoding="Транскодирање"
+AMF.H264.Usage.UltraLowLatency="Ултра ниско кашњење"
+AMF.H264.Usage.LowLatency="Ниско кашњење"
+AMF.H264.QualityPreset="Шаблон квалитета"
+AMF.H264.QualityPreset.Speed="Брзина"
+AMF.H264.QualityPreset.Balanced="Избалансирано"
+AMF.H264.QualityPreset.Quality="Квалитет"
+AMF.H264.Profile="Профил"
+AMF.H264.ProfileLevel="Ниво профила"
+AMF.H264.ScanType="Врста скенирања"
+AMF.H264.ScanType.Progressive="Прогресивно"
+AMF.H264.ScanType.Interlaced="Испрекидано"
+AMF.H264.RateControlMethod="Метода контроле протока"
+AMF.H264.RateControlMethod.CQP="Константан квалитет (CQP)"
+AMF.H264.RateControlMethod.CBR="Константан проток (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Промењиви проток (са горњом границом) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Промењиви проток (са границом кашњења) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Циљани проток"
+AMF.H264.Bitrate.Peak="Граница протока"
+AMF.H264.QP.Minimum="Минимални QP"
+AMF.H264.QP.Maximum="Максимални QP"
+AMF.H264.QP.IFrame="I-Фрејм QP"
+AMF.H264.QP.PFrame="P-Фрејм QP"
+AMF.H264.QP.BFrame="B-Фрејм QP"
+AMF.H264.QP.BPictureDelta="B-Промена слике QP"
+AMF.H264.QP.ReferenceBPictureDelta="Референца B-Промена слике QP"
+AMF.H264.FillerData="Подаци за попуњавање"
+AMF.H264.FrameSkipping="Прескакање фрејмова"
+AMF.H264.EnforceHRDCompatibility="Присилна HRD компатибилност"
+AMF.H264.BPicture.Pattern="B-Шаблонска слика"
+AMF.H264.BPicture.Reference="B-Референтна слика"
+AMF.H264.DeblockingFilter="Одблокирајући филтер"
+AMF.Util.Default="Подразумевано"
+AMF.Util.Automatic="Аутоматски"
+AMF.Util.Toggle.Disabled="Онемогућено"
+AMF.Util.Toggle.Enabled="Омогућено"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/sv-SE.ini Added

@@ -0,0 +1,40 @@
+AMF.H264.Preset="Förinställning"
+AMF.H264.Preset.HighQuality="Hög kvalitet"
+AMF.H264.Preset.Indistinguishable="Oskiljbar"
+AMF.H264.Preset.Lossless="Förlustfri"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Användning"
+AMF.H264.Usage.Transcoding="Omkodning"
+AMF.H264.Usage.UltraLowLatency="Ultralåg latens"
+AMF.H264.Usage.LowLatency="Låg latens"
+AMF.H264.QualityPreset="Kvalitetsförinställning"
+AMF.H264.QualityPreset.Speed="Hastighet"
+AMF.H264.QualityPreset.Balanced="Balanserad"
+AMF.H264.QualityPreset.Quality="Kvalitet"
+AMF.H264.Profile="Profil"
+AMF.H264.ProfileLevel="Profilnivå"
+AMF.H264.ScanType="Typ av skanning"
+AMF.H264.ScanType.Progressive="Progressiv"
+AMF.H264.ScanType.Interlaced="Sammanflätad"
+AMF.H264.RateControlMethod.CQP="Konstant QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Konstant bithastighet (CBR)"
+AMF.H264.Bitrate.Target="Målets bithastighet"
+AMF.H264.Bitrate.Peak="Maximal bithastighet"
+AMF.H264.QP.Minimum="Minimal QP"
+AMF.H264.QP.Maximum="Maximal QP"
+AMF.H264.FrameSkipping="Hoppa över bildrutor"
+AMF.H264.EnforceHRDCompatibility="Tvinga HRD-kompatibilitet"
+AMF.H264.DeblockingFilter="Avblockningsfilter"
+AMF.H264.MotionEstimation.None="Ingen"
+AMF.H264.View="Visningsläge"
+AMF.H264.View.Basic="Grundläggande"
+AMF.H264.View.Advanced="Avancerad"
+AMF.H264.View.Expert="Expert"
+AMF.H264.View.Master="Master"
+AMF.H264.Debug="Felsök"
+AMF.Util.Default="Standard"
+AMF.Util.Automatic="Automatisk"
+AMF.Util.Manual="Manuell"
+AMF.Util.Toggle.Disabled="Inaktiverad"
+AMF.Util.Toggle.Enabled="Aktiverad"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/uk-UA.ini Added

@@ -0,0 +1,109 @@
+AMF.H264.Preset="Шаблон"
+AMF.H264.Preset.ResetToDefaults="Відновити параметри за замовчанням"
+AMF.H264.Preset.Recording="Звичайний запис"
+AMF.H264.Preset.HighQuality="Висока якість"
+AMF.H264.Preset.Indistinguishable="Якість майже без втрат"
+AMF.H264.Preset.Lossless="Без втрат якості"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="Використання"
+AMF.H264.Usage.Description="Тип використання AMF або напрямок його використання, тобто:\n  'Для перекодування' - загальний тип налаштувань (рекомендований).\n  'З ультра-низькою затримкою' - тип лише для дійсно низької затримки під час кодування.\n  'З низькою затримкою' - схожий на зазначений вище, але з трохи більшою затримкою.\n\nТрансляції підтримують лише напрямок використання 'Для перекодування'."
+AMF.H264.Usage.Transcoding="Для перекодування"
+AMF.H264.Usage.UltraLowLatency="З ультра-низькою затримкою"
+AMF.H264.Usage.LowLatency="З низькою затримкою"
+AMF.H264.QualityPreset="Шаблон якості"
+AMF.H264.QualityPreset.Description="Визначає який Шаблон якості AMF намагатиметься встановити:\n  'Швидкість' - є найшвидшим, але має гіршу якість відео.\n  'Збалансований' - це баланс між шаблонами Швидкість та Якість.\n  'Якість' - дає найкращу якість відео для заданого бітрейту."
+AMF.H264.QualityPreset.Speed="Швидкість"
+AMF.H264.QualityPreset.Balanced="Збалансований"
+AMF.H264.QualityPreset.Quality="Якість"
+AMF.H264.Profile="Профіль"
+AMF.H264.Profile.Description="Зазначений профіль H.264 буде використано енкодером:\n  'Baseline' - найпоширеніший серед пристроїв відтворення\n  'Main' - майже всі пристрої відтворення мають підтримку цього профілю\n  'High' - профіль підтримується найсучаснішими пристроями (рекомендується)."
+AMF.H264.ProfileLevel="Рівень профілю"
+AMF.H264.ProfileLevel.Description="Визначає рівень профілю H.264 який буде використано під час кодування:\n  'Автоматично' - програма сама встановить найкращій рівень профілю згідно розміру та частоти кадрів,\n  '4.1' - підтримує 1920x1080 30 кадрів/с, 1280x720 60 кадрів/с, 960x540 90 кадрів/с\n  '4.2' - підтримує 1920x1080 60 кадрів/с, 1280x720 120 кадрів/с, 960x540 172 кадрів/с\n  '5.0' - підтримує 1920x1080 60 кадрів/с, 1280x720 144 кадрів/с, 960x540 172 кадрів/с\n  '5.1' - підтримує 3840x2160 30 кадрів/с, 1920x1080 120 кадрів/с, 1280x720 172 кадрів/с, 960x540 172 кадрів/с\n  '5.2' - підтримує 3840x2160 60 кадрів/с, 1920x1080 172 кадрів/с, 1280x720 172 кадрів/с, 960x540 172 кадрів/с"
+AMF.H264.MaximumLTRFrames="Кількість LTR-кадрів контрольованих користувачем"
+AMF.H264.MaximumLTRFrames.Description="Long-Term Reference (LTR) кадри дозволяють при кодуванні маркувати декілька кадрів як опорні для інших.\nЦе може поліпшити якість у разі відсутності підтримки B-кадрів або небажаності їх використання.\nЯкщо 'Кількість LTR-кадрів контрольованих користувачем' вказано, то енкодер не підтримуватиме B-кадри у відео."
+AMF.H264.ScanType="Вид розгортки"
+AMF.H264.ScanType.Description="Визначає вид розгортки який треба використовувати у кодуванні,\nзавжди користуйтеся значенням 'Прогресивна'."
+AMF.H264.ScanType.Progressive="Прогресивна"
+AMF.H264.ScanType.Interlaced="Черезрядкова"
+AMF.H264.RateControlMethod="Метод керування потоком"
+AMF.H264.RateControlMethod.Description="Визначає метод керування потоком:\n  'Фіксований QP (CQP)' - встановлює фіксовані QP для I-/P-/B-кадрів,\n  'Постійний бітрейт (CBR)' - дотримується значення Бажаний бітрейт потоку (використовуючи\nопцію Заповнювати пустоти у бітрейту) (рекомендується для трансляцій),\n  'Змінний бітрейт (максимальний бітрейт обмежено) (VBR)' - потік завжди залишається нижче значення Максимальний бітрейт,\n  'Змінний бітрейт (затримку обмежено) (VBR_LAT)' - потік буде збережено близько до значення Бажаний бітрейт,\nдопоки затримка графічного адаптеру та навантаження на нього дозволятимуть це,\nв іншому випадку бітрейт буде збільшено (рекомендується для запису).\n\nQP - Quantization Parameter (параметр квантування)."
+AMF.H264.RateControlMethod.CQP="Фіксований QP (CQP)"
+AMF.H264.RateControlMethod.CBR="Постійний бітрейт (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Змінний бітрейт (максимальний бітрейт обмежено) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Змінний бітрейт (затримку обмежено) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Бажаний бітрейт"
+AMF.H264.Bitrate.Target.Description="Енкодер буде намагатися дотримуватись цього бітрейту."
+AMF.H264.Bitrate.Peak="Максимальний бітрейт"
+AMF.H264.Bitrate.Peak.Description="Енкодер буде намагатися не перевищувати цього бітрейту."
+AMF.H264.QP.Minimum="Мінімальний QP"
+AMF.H264.QP.Minimum.Description="Найнижчий QP (параметр квантування) в кадрі."
+AMF.H264.QP.Maximum="Максимальний QP"
+AMF.H264.QP.Maximum.Description="Найвищий QP (параметр квантування) в кадрі."
+AMF.H264.QP.IFrame="QP для I-кадрів"
+AMF.H264.QP.IFrame.Description="Фіксоване значення QP (параметр квантування) для I-кадрів.\nQP для I-кадрів повинно бути на рівні або вище за QP для P- та B-кадрів."
+AMF.H264.QP.PFrame="QP для P-кадрів"
+AMF.H264.QP.PFrame.Description="Фіксоване значення QP (параметр квантування) для P-кадрів.\nQP для P-кадрів повинно бути на рівні або вище за QP для B-кадрів."
+AMF.H264.QP.BFrame="QP для B-кадрів"
+AMF.H264.QP.BFrame.Description="Фіксоване значення QP (параметр квантування) для B-кадрів."
+AMF.H264.QP.BPictureDelta="B-кадри, відхил QP"
+AMF.H264.QP.BPictureDelta.Description="Відхил QP (параметра квантування) для не опорних B-кадрів, по відношенню до I-кадрів."
+AMF.H264.QP.ReferenceBPictureDelta="Опорні B-кадри, відхил QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="Відхил QP (параметра квантування) для порних B-кадрів, по відношенню до I-кадрів."
+AMF.H264.VBVBuffer="Буфер VBV"
+AMF.H264.VBVBuffer.Description="Метод, що використовується для визначення параметру Розмір VBV буфера:\n  'Автоматично' - енкодер вираховує розмір враховуючи параметр Буфер VBV, кореляція.\n  'Вручну' - дозволяє користувачеві контролювати цей розмір.\nVBV (Video Buffering Verifier) Буфер використовується різними Методами керування потоком для збереження бітрейту у зазначених межах."
+AMF.H264.VBVBuffer.Strictness="Буфер VBV, кореляція"
+AMF.H264.VBVBuffer.Strictness.Description="Визначає як близько значення Буфер VBV дорівнюють значенню Бажаний бітрейт, у відсотках."
+AMF.H264.VBVBuffer.Size="Розмір VBV буфера"
+AMF.H264.VBVBuffer.Size.Description="Розмір VBV буфера (Video Buffering Verifier) використовується під час контролю бітрейта відео.\nМалі значення дозволяють цілком збігатися зі встановленим бітрейтом але здійснюють додаткове навантаження."
+AMF.H264.VBVBuffer.Fullness="Початкова повнота буферу VBV"
+AMF.H264.VBVBuffer.Fullness.Description="Визначає початкову заповнюваність Буферу VBV, діє лише на початку кодування."
+AMF.H264.FillerData="Заповнювати пустоти у бітрейту"
+AMF.H264.FillerData.Description="Заповнювати пустоти у бітрейту - це наповнювання інформацією, яку декодер просто ігнорує. Якщо увімкнено то зайве місце у бітрейті буде заповнено нічого не значущою інформацією за для досягнення точного значення Бажаний бітрейт. Аналог Filler Data."
+AMF.H264.FrameSkipping="Пропускати кадри"
+AMF.H264.FrameSkipping.Description="Пропускати кадри - дозволяє енкодеру відкидати кадри, якщо керування потоком не може досягти встановленого значення Бажаний бітрейт.\nКоли енкодер пропускає кадр, він додає дублювати-останній-кадр NAL до потоку.\nМоже допомогти при встановленні дуже низьких значень Бажаний бітрейт."
+AMF.H264.EnforceHRDCompatibility="Застосувати примусову сумісність з HRD"
+AMF.H264.EnforceHRDCompatibility.Description="Застосувати примусову сумісність з HRD (Hypothetical Reference Decoder) - накладає обмеження на максимальне значення QP (параметра квантування) у кадрі задля досягнення сумісності з HRD.\nНе рекомендується для записів або трансляцій. Використовувати лише для сумісності з найстарішими пристроями які мають лише базовий декодер."
+AMF.H264.MaximumAccessUnitSize="Максимальний розмір Access Unit"
+AMF.H264.MaximumAccessUnitSize.Description="Визначає максимальний розмір Access Unit для NAL. Значення 0 дозволяє енкодеру обирати найкращий розмір самостійно."
+AMF.H264.KeyframeInterval="Інтервал ключових кадрів"
+AMF.H264.KeyframeInterval.Description="Визначає кількість секунд між двома повними кадрами (ключовими кадрами).\nТакож контролює довжину послідовності кадрів у групі зображень (GOP)."
+AMF.H264.IDRPeriod="IDR, період (кадрів)"
+AMF.H264.IDRPeriod.Description="Визначає відстань між Instantaneous Decoding Refreshes (IDR) (ключовими кадрами), в кадрах.\nТакож контролює довжину послідовності кадрів у групі зображень (GOP)."
+AMF.H264.HeaderInsertionSpacing="Заголовки потоку, період (кадрів)"
+AMF.H264.HeaderInsertionSpacing.Description="Визначає скільки кадрів повинно бути між NAL заголовками. Не рекомендується змінювати цей параметр від значення 0 (автоматично)."
+AMF.H264.BPicture.Pattern="Послідовні B-кадри"
+AMF.H264.BPicture.Pattern.Description="Визначає кількість дозволених B-кадрів у кодуванні. Має позитивний вплив на якість зображення та негативний на продуктивність.\nПідтримується принаймні 2-м та 3-м поколінням VCE карт."
+AMF.H264.BPicture.Reference="B-кадри як опорні"
+AMF.H264.BPicture.Reference.Description="Дозволяє робити B-кадри опорними для інших B-кадрів в додаток до вже існуючих P- та I-кадрів.\nЗдійснює величезне навантаження, при незначному поліпшенні якості."
+AMF.H264.DeblockingFilter="Деблокінг-фільтр"
+AMF.H264.DeblockingFilter.Description="Встановлює позначку, що дозволяє декодеру використовувати Деблокінг-фільтр для цього відео."
+AMF.H264.SlicesPerFrame="Фрагментів на кадр"
+AMF.H264.SlicesPerFrame.Description="Скільки фрагментів I-кадрів буде у кожному кадру?\nНульове значення дозволяє енкодеру визначати цю кількість під час кодування самостійно.\nIntra-Refresh кодування використовується для більш швидкого відтворення та навігації."
+AMF.H264.IntraRefreshNumMBsPerSlot="Кількість Intra-Refresh макроблоків на слот"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="Скільки Intra-Refresh макроблоків буде у кожному слоті?\nНульове значення дозволяє енкодеру визначати цю кількість під час кодування самостійно.\nIntra-Refresh кодування використовується для більш швидкого відтворення та навігації."
+AMF.H264.MotionEstimation="Оцінка руху"
+AMF.H264.MotionEstimation.Description="Оцінка руху дозволяє енкодеру зменшити вимоги до бітрейту завдяки розрахункам з переміщення пікселів."
+AMF.H264.MotionEstimation.None="Немає"
+AMF.H264.MotionEstimation.Half="Пів-пікселя"
+AMF.H264.MotionEstimation.Quarter="Чверть-пікселя"
+AMF.H264.MotionEstimation.Both="Пів-пікселя та Чверть-пікселя"
+AMF.H264.Device="Пристрій"
+AMF.H264.Device.Description="Визначає Пристрій що буде використано у кодуванні.\nПотребує встановити параметр Пам'ять адресується у значення відмінне від 'Host'."
+AMF.H264.UseOpenCL="Використовувати OpenCL"
+AMF.H264.UseOpenCL.Description="Чи буде енкодер використовувати OpenCL щоб надсилати кожен окремий кадр?"
+AMF.H264.View="Вид для налаштувань"
+AMF.H264.View.Description="Визначає кількість наявних опцій для налаштування. Навряд чи розробник вам допомагатиме, якщо ви оберете рівень 'Експерт' або 'Бог енкодерів'."
+AMF.H264.View.Basic="Базовий"
+AMF.H264.View.Advanced="Розширений"
+AMF.H264.View.Expert="Експерт"
+AMF.H264.View.Master="Бог енкодерів"
+AMF.H264.UnlockProperties="Розширити ввод параметрів"
+AMF.H264.UnlockProperties.Description="Дозволяє вводити деякі параметри у їх необробленому виді, тобто без\nперерахунків на Кбайтність/Кбітність та без деяких обмежень."
+AMF.H264.Debug="Відладка"
+AMF.H264.Debug.Description="Вмикає занесення до лог-файлу додаткової інформації про процес кодування. Корисно у випадку коли ви бажаєте звернутися за допомогою до розробника енкодера."
+AMF.Util.Default="За замовчанням"
+AMF.Util.Automatic="Автоматично"
+AMF.Util.Manual="Вручну"
+AMF.Util.Toggle.Disabled="Вимкнено"
+AMF.Util.Toggle.Enabled="Увімкнено"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/vi-VN.ini Added

@@ -0,0 +1,60 @@
+AMF.H264.Preset="Mẫu thiết lập"
+AMF.H264.Preset.Recording="Quay video"
+AMF.H264.Preset.HighQuality="Chất lượng cao"
+AMF.H264.Preset.Indistinguishable="Không thể phân biệt"
+AMF.H264.Preset.Lossless="Lossless"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage.Transcoding="Chuyển mã"
+AMF.H264.Usage.UltraLowLatency="Độ trễ cực thấp"
+AMF.H264.Usage.LowLatency="Độ trễ thấp"
+AMF.H264.QualityPreset="Quality Preset"
+AMF.H264.QualityPreset.Speed="Tốc độ"
+AMF.H264.QualityPreset.Balanced="Cân bằng"
+AMF.H264.QualityPreset.Quality="Chất lượng"
+AMF.H264.Profile="Profile"
+AMF.H264.ProfileLevel="Profile Level"
+AMF.H264.MaximumLTRFrames="LTR Frames tối đa"
+AMF.H264.ScanType="Quét hình loại"
+AMF.H264.ScanType.Progressive="Quét nguyên ảnh (Progressive)"
+AMF.H264.ScanType.Interlaced="Quét 1/2 ảnh (Interlaced)"
+AMF.H264.RateControlMethod="Cách kiểm soát Bitrate"
+AMF.H264.RateControlMethod.CQP="QP Không thay đổi (CQP)"
+AMF.H264.RateControlMethod.CBR="Bitrate Không thay đổi (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="Bitrate Thay đổi được (Phụ thuộc vào Bitrate Cao nhất) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="Bitrate Thay đổi được (Phụ thuộc vào độ trễ) (VBR_LAT)"
+AMF.H264.Bitrate.Target="Bitrate Mục tiêu"
+AMF.H264.Bitrate.Peak="Bitrate Cao nhất"
+AMF.H264.QP.Minimum="QP Thấp nhất"
+AMF.H264.QP.Maximum="QP Cao nhất"
+AMF.H264.QP.IFrame="I-Frame QP"
+AMF.H264.QP.PFrame="P-Frame QP"
+AMF.H264.QP.BFrame="B-Frame QP"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
+AMF.H264.FillerData="Filler Data (Thêm data cho đủ bitrate)"
+AMF.H264.FrameSkipping="Frame Skipping"
+AMF.H264.EnforceHRDCompatibility="Enforce HRD Compatibility"
+AMF.H264.KeyframeInterval="Thời gian đặt keyframe"
+AMF.H264.BPicture.Pattern="B-Picture Pattern"
+AMF.H264.BPicture.Reference="B-Picture Reference"
+AMF.H264.DeblockingFilter="De-blocking Filter (Lọc chống nhiễu ảnh)"
+AMF.H264.SlicesPerFrame="Lát cho mỗi khung hình"
+AMF.H264.MotionEstimation="Dự đoán bù trừ chuyển động"
+AMF.H264.MotionEstimation.Description="Dự toán chuyển động cho phép bộ mã hóa giảm bitrate cần thiết bằng cách ước tính một pixel sẽ đi đâu."
+AMF.H264.MotionEstimation.None="Không"
+AMF.H264.MotionEstimation.Half="1/2 Pixel"
+AMF.H264.MotionEstimation.Quarter="1/4 Pixel"
+AMF.H264.MotionEstimation.Both="1/2 và 1/4 Pixel"
+AMF.H264.View="Chế độ xem"
+AMF.H264.View.Basic="Cơ bản"
+AMF.H264.View.Advanced="Nâng cao"
+AMF.H264.View.Expert="Chuyên gia"
+AMF.H264.View.Master="Bật cả tính năng ẩn"
+AMF.H264.UnlockProperties="Mở khóa Properties"
+AMF.H264.Debug="Gỡ lỗi"
+AMF.Util.Default="Mặc định"
+AMF.Util.Automatic="Tự động"
+AMF.Util.Manual="Thủ công"
+AMF.Util.Toggle.Disabled="Tắt"
+AMF.Util.Toggle.Enabled="Bật"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/zh-CN.ini Added

@@ -0,0 +1,109 @@
+AMF.H264.Preset="预设"
+AMF.H264.Preset.ResetToDefaults="重置为默认值"
+AMF.H264.Preset.Recording="录像"
+AMF.H264.Preset.HighQuality="高质量"
+AMF.H264.Preset.Indistinguishable="无法区分"
+AMF.H264.Preset.Lossless="无损"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="使用"
+AMF.H264.Usage.Description="AMF 应调整为什么用法:\n-'转码' 是通用转码(推荐), \n '超低延迟' 对于真的低延迟编码,\n-'低延迟' 类似于上面稍高的延迟.\n 推流仅支持 '转码', 所有其他值可以用于录制."
+AMF.H264.Usage.Transcoding="转码"
+AMF.H264.Usage.UltraLowLatency="超低延迟"
+AMF.H264.Usage.LowLatency="低延迟"
+AMF.H264.QualityPreset="质量预设"
+AMF.H264.QualityPreset.Description="哪种质量预设 AMF 应该尝试对于目标:\n-'速度' 是最快但有最差的质量,\n-'平衡' 是 '速度' 和 '质量' 之间, 提供一个两者之间的较好的平衡,\n-'质量' 给出了最好的质量对于给定的比特率."
+AMF.H264.QualityPreset.Speed="速度"
+AMF.H264.QualityPreset.Balanced="平衡"
+AMF.H264.QualityPreset.Quality="质量"
+AMF.H264.Profile="配置文件"
+AMF.H264.Profile.Description="H.264的编码选项有：\n-'Baseline' 支持的平台最广，\n-'Main' 支持较老的设备（如果使用的平台是手机，推荐使用），\n-'High' 被当下的设备支持（推荐使用）。"
+AMF.H264.ProfileLevel="配置等级"
+AMF.H264.ProfileLevel.Description="对于编码使用哪种 H.264 Profile Level:\n-'Automatic' 根据给定的帧率和帧大小计算最优的 profile level,\n-'4.1' 支持 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n-'4.2' 支持 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n-'5.0' 支持 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n-'5.1' 支持 3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n-'5.2' 支持 3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="最大的 LTR 帧"
+AMF.H264.MaximumLTRFrames.Description="长期参考帧(LTR) 是一个特性允许编码器来标记在一个序列的一些帧作为参考帧.\n这会使当 B 帧不支持或者不需要时提高质量.\nLTR真不能和 B 帧一起使用, 并且当使用LTR时, 编码器会禁用 B 帧."
+AMF.H264.ScanType="扫描类型"
+AMF.H264.ScanType.Description="使用哪种扫描方法, 通常设置为'Progressive'."
+AMF.H264.ScanType.Progressive="渐进"
+AMF.H264.ScanType.Interlaced="交错"
+AMF.H264.RateControlMethod="速率控制方法"
+AMF.H264.RateControlMethod.Description="该使用什么调节码率的方法：\n- '\@AMF.H264.RateControlMethod.CQP\@' assigns fixed I-/P-/B-Frame QP (Quantization Parameter) values,\n- '\@AMF.H264.RateControlMethod.CBR\@' stays at the given Target Bitrate (using Filler Data) (推荐推流使用),\n- '\@AMF.H264.RateControlMethod.VBR\@' stays below the given Peak Bitrate,\n- '\@AMF.H264.RateControlMethod.VBR_LAT\@' stays close to the Target Bitrate if GPU latency and load allow for it, otherwise will use higher bitrate (推荐录像使用)."
+AMF.H264.RateControlMethod.CQP="恒定 QP (CQP)"
+AMF.H264.RateControlMethod.CBR="固定比特率 (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="变比特率 (峰值约束) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="变比特率 (延迟约束) (VBR_LAT)"
+AMF.H264.Bitrate.Target="目标比特率"
+AMF.H264.Bitrate.Target.Description="尝试在这个序列中获取的比特率."
+AMF.H264.Bitrate.Peak="峰值比特率"
+AMF.H264.Bitrate.Peak.Description="尝试在这个序列中获取的峰值比特率."
+AMF.H264.QP.Minimum="最低 QP"
+AMF.H264.QP.Minimum.Description="一帧中最低 QP (量化参数) 值"
+AMF.H264.QP.Maximum="最高 QP"
+AMF.H264.QP.Maximum.Description="一帧中最高 QP (量化参数) 值"
+AMF.H264.QP.IFrame="I 帧 QP"
+AMF.H264.QP.IFrame.Description="用于 I 帧的固定 QP (量化参数) 值.\nI帧 QP值应该大于等于 P B 帧的 QP 值."
+AMF.H264.QP.PFrame="P 帧 QP"
+AMF.H264.QP.PFrame.Description="用于 P 帧的固定 QP (量化参数) 值.\nP帧 QP值应该大于等于 B 帧的 QP 值."
+AMF.H264.QP.BFrame="B 帧 QP"
+AMF.H264.QP.BFrame.Description="用于 B 帧的固定 QP (量化参数) 值."
+AMF.H264.QP.BPictureDelta="B 图片 差值 QP"
+AMF.H264.QP.BPictureDelta.Description="相对于上一个非参考 B 帧的差值 QP 值."
+AMF.H264.QP.ReferenceBPictureDelta="参考 B 图片 差值 QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="相对于上一个参考 B 帧的差值 QP 值."
+AMF.H264.VBVBuffer="VBV 缓存"
+AMF.H264.VBVBuffer.Description="应使用什么方法来确定 VBV 缓冲区大小:\n-'自动' 计算使用严格约束的大小,\n- '手册' 允许用户控制大小.\nVBV缓存 (视频缓冲程序验证程序) 用于某些率控制方法来保持整体的比特率在给定的约束内."
+AMF.H264.VBVBuffer.Strictness="VBV 缓存规范性"
+AMF.H264.VBVBuffer.Strictness.Description="VBV 缓存应该怎样严格, 100% 几乎完全和目标比特率一致和 0% 不受限制的."
+AMF.H264.VBVBuffer.Size="VBV 缓存大小"
+AMF.H264.VBVBuffer.Size.Description="VBV 缓存大小用于在一个序列中的比特率控制.\n小缓存会导致几乎完美的比特率控制但有较大的性能影响."
+AMF.H264.VBVBuffer.Fullness="VBV 缓冲满"
+AMF.H264.VBVBuffer.Fullness.Description="VBV 缓存最初应该多满, 将只会影响最初的序列的编码."
+AMF.H264.FillerData="填充数据"
+AMF.H264.FillerData.Description="启用填充数据允许编码器至少保持目标比特率, 通过填满空信息序列中的剩余空间."
+AMF.H264.FrameSkipping="跳过的帧"
+AMF.H264.FrameSkipping.Description="跳过的帧允许编码器下丢帧, 以满足目标比特率要求.\n当编码器丢帧时, 它反而插入一个重复最后一帧的 NAL 到流中.\n可以帮助非常低的目标比特率."
+AMF.H264.EnforceHRDCompatibility="强制 HRD 兼容"
+AMF.H264.EnforceHRDCompatibility.Description="强制假设的参考解码器限制在一个帧内的最大的 QP 值更改.\n不推荐用于录制或推流, 并且应仅用于面向只有参考软件解码器的很老的设备."
+AMF.H264.MaximumAccessUnitSize="最大访问单元大小"
+AMF.H264.MaximumAccessUnitSize.Description="一个 NAL 的访问单元的最大大小. 值 0 允许编码器挑选最好的一个."
+AMF.H264.KeyframeInterval="关键帧间隔"
+AMF.H264.KeyframeInterval.Description="非丢弃帧之间应该多少秒.\n也控制序列(GOP) 的大小."
+AMF.H264.IDRPeriod="IDR 周期"
+AMF.H264.IDRPeriod.Description="定义的帧内瞬时解码刷新 (IDR) 的距离. 也控制 GOP 序列长度."
+AMF.H264.HeaderInsertionSpacing="头部插入空白"
+AMF.H264.HeaderInsertionSpacing.Description="NAL 头之间应该多少帧. 不推荐改为非零(自动) 值."
+AMF.H264.BPicture.Pattern="B 图片模式"
+AMF.H264.BPicture.Pattern.Description="应该允许编码多少 B 帧, 对质量有好处和对性能有坏处.\n第二代和第三代 VCE 卡支持."
+AMF.H264.BPicture.Reference="B 图片参考"
+AMF.H264.BPicture.Reference.Description="允许 B 帧参考 P 帧和 I 帧之外的其他 B 帧.\n 巨大的性能影响, 较小的质量提高."
+AMF.H264.DeblockingFilter="去块滤波"
+AMF.H264.DeblockingFilter.Description="设置解码器允许使用的标记, 用于编码流去块滤波器."
+AMF.H264.SlicesPerFrame="每帧的切片数"
+AMF.H264.SlicesPerFrame.Description="每个帧应该和多少 I 帧切片一起存储?\n0 值让编码器运行时决定.\n内部刷新编码用于更快的回放和定位."
+AMF.H264.IntraRefreshNumMBsPerSlot="每个槽的内部宏块刷新数量"
+AMF.H264.IntraRefreshNumMBsPerSlot.Description="每个槽应该和多少宏块一起存储?\n0 值让编码器在运行时决定.\n帧内刷新编码用于更快的回放和定位."
+AMF.H264.MotionEstimation="移动侦测"
+AMF.H264.MotionEstimation.Description="运动侦测允许编码器通过估计一个像素去了哪里来降低比特率."
+AMF.H264.MotionEstimation.None="无"
+AMF.H264.MotionEstimation.Half="半像素"
+AMF.H264.MotionEstimation.Quarter="四分之一像素"
+AMF.H264.MotionEstimation.Both="半&四分之一像素"
+AMF.H264.Device="设备"
+AMF.H264.Device.Description="哪个设备用来编码.\n需要内存类型不能设置为'主机'."
+AMF.H264.UseOpenCL="使用 OpenCL"
+AMF.H264.UseOpenCL.Description="编码器应该使用 OpenCL 提交单独的帧吗?"
+AMF.H264.View="查看模式"
+AMF.H264.View.Description="哪些属性应该是可见的. 当使用 '专家' 或者 '大师' 模式时, 您将不会得到支持."
+AMF.H264.View.Basic="基本"
+AMF.H264.View.Advanced="高级"
+AMF.H264.View.Expert="专家"
+AMF.H264.View.Master="主"
+AMF.H264.UnlockProperties="解锁属性"
+AMF.H264.UnlockProperties.Description="解锁给他们完整范围的某些属性, 而不是将他们局限到一定范围内."
+AMF.H264.Debug="调试"
+AMF.H264.Debug.Description="启用附加调试日志记录, 应该是启用的, 无论何时您需要此编码器的支持."
+AMF.Util.Default="默认"
+AMF.Util.Automatic="自动"
+AMF.Util.Manual="手动"
+AMF.Util.Toggle.Disabled="禁用"
+AMF.Util.Toggle.Enabled="启用"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Resources/locale/zh-TW.ini Added

@@ -0,0 +1,86 @@
+AMF.H264.Preset="預設"
+AMF.H264.Preset.ResetToDefaults="重設為預設值"
+AMF.H264.Preset.Recording="錄影"
+AMF.H264.Preset.HighQuality="高品質"
+AMF.H264.Preset.Indistinguishable="無法區分"
+AMF.H264.Preset.Lossless="無損"
+AMF.H264.Preset.Twitch="Twitch"
+AMF.H264.Preset.YouTube="YouTube"
+AMF.H264.Usage="用法"
+AMF.H264.Usage.Description="根據用途 AMF 應調整為︰ \n- '\@AMF.H264.Usage.Transcoding\@' 是通用轉碼 （推薦），\n- '\@AMF.H264.Usage.UltraLowLatency\@' 是為了真的非常低延遲的編碼，\n- '\@AMF.H264.Usage.LowLatency\@'是類似於上面但延遲稍高。 \n串流僅支援'\@AMF.H264.Usage.Transcoding\@'，其他值可以用於錄影。"
+AMF.H264.Usage.Transcoding="轉碼"
+AMF.H264.Usage.UltraLowLatency="超低延遲"
+AMF.H264.Usage.LowLatency="低延遲"
+AMF.H264.QualityPreset="預設品質"
+AMF.H264.QualityPreset.Speed="速度"
+AMF.H264.QualityPreset.Balanced="平衡"
+AMF.H264.QualityPreset.Quality="品質"
+AMF.H264.Profile="設定檔"
+AMF.H264.Profile.Description="用於編碼的 H.264 設定：\n- 'Baseline' 有最廣泛的平台支援度，\n- 'Main' 較舊的裝置也支援 (如果目標是行動裝置，建議選此)，\n- 'High' 當前主流裝置支援 (建議選此)。"
+AMF.H264.ProfileLevel="設定檔級別"
+AMF.H264.ProfileLevel.Description="用於編碼的 H.264 設定等級：\n- '\@AMF.Util.Automatic\@'根據給定的畫面播放速率以及尺寸計算最佳的設定等級,\n- '4.1'支援 1920x1080 30FPS, 1280x720 60FPS, 960x540 90FPS\n- '4.2'支援 1920x1080 60FPS, 1280x720 120FPS, 960x540 172FPS\n- '5.0'支援 1920x1080 60FPS, 1280x720 144FPS, 960x540 172FPS\n- '5.1'支援3840x2160 30FPS, 1920x1080 120FPS, 1280x720 172FPS, 960x540 172FPS\n- '5.2'支援3840x2160 60FPS, 1920x1080 172FPS, 1280x720 172FPS, 960x540 172FPS"
+AMF.H264.MaximumLTRFrames="長期參照訊框(LTR)最大數量"
+AMF.H264.MaximumLTRFrames.Description="當指定了長期參照訊框(LTR)最大數量時，編碼器將會停用 B-Picture。"
+AMF.H264.ScanType="掃描類型"
+AMF.H264.ScanType.Progressive="漸進式"
+AMF.H264.ScanType.Interlaced="交错式"
+AMF.H264.RateControlMethod="速率控制方法"
+AMF.H264.RateControlMethod.Description="該使用什麼位元速率控制方法：\n- '\@AMF.H264.RateControlMethod.CQP\@' 指定固定的 I-/P-/B-訊框 QP (量化參數)值，\n- '\@AMF.H264.RateControlMethod.CBR\@' 固定在給定的目標位元速率 (藉由填塞空白資料)(建議用於串流)，\n- '\@AMF.H264.RateControlMethod.VBR\@' 保持低於給定的位元速率最大值，\n- '\@AMF.H264.RateControlMethod.VBR_LAT\@' 在 GPU 延遲跟負載允許的情況下盡量接近目標位元速率，不足時使用較高的位元速率(建議用於錄影)。"
+AMF.H264.RateControlMethod.CQP="固定 QP (CQP)"
+AMF.H264.RateControlMethod.CBR="固定位元率 (CBR)"
+AMF.H264.RateControlMethod.VBR.Peak="可變位元率 (限制最大位元率) (VBR)"
+AMF.H264.RateControlMethod.VBR.Latency="可變位元率 (限制延遲) (VBR)"
+AMF.H264.Bitrate.Target="目標位元率"
+AMF.H264.Bitrate.Target.Description="在整體過程中嘗試達成的位元速率。"
+AMF.H264.Bitrate.Peak="最大位元率"
+AMF.H264.Bitrate.Peak.Description="在整體過程中嘗試不超過的位元速率。"
+AMF.H264.QP.Minimum="最低 QP 值"
+AMF.H264.QP.Minimum.Description="一個訊框中使用的最低 QP （量化參數） 值。"
+AMF.H264.QP.Maximum="最大 QP 值"
+AMF.H264.QP.Maximum.Description="一個訊框中使用的最高 QP （量化參數） 值。"
+AMF.H264.QP.IFrame="I-訊框 QP"
+AMF.H264.QP.IFrame.Description="I-訊框使用的固定 QP (量化參數) 值。\nI-訊框 QP 應該要跟 P/B-訊框 QP 一樣或更高。"
+AMF.H264.QP.PFrame="P-訊框 QP"
+AMF.H264.QP.PFrame.Description="P-訊框使用的固定 QP (量化參數) 值。\nP-訊框 QP 應該要跟 B-訊框 QP 一樣或更高。"
+AMF.H264.QP.BFrame="B-訊框 QP"
+AMF.H264.QP.BFrame.Description="B-訊框使用的固定 QP (量化參數) 值。"
+AMF.H264.QP.BPictureDelta="B-Picture Delta QP"
+AMF.H264.QP.BPictureDelta.Description="最後一個非參考 B-Picture 所使用的 Delta QP。"
+AMF.H264.QP.ReferenceBPictureDelta="Reference B-Picture Delta QP"
+AMF.H264.QP.ReferenceBPictureDelta.Description="最後一個參考 B-Picture 所使用的 Delta QP。"
+AMF.H264.VBVBuffer="VBV(Video Buffering Verifier) 緩衝區"
+AMF.H264.VBVBuffer.Description="決定 VBV 緩衝區大小的方法：\n- '\@AMF.Util.Automatic\@' 根據嚴格性計算大小，\n- '\@AMF.Util.Manual\@' 允許使用者調整大小。\n 某些速率控制方法會使用 VBV (Video Buffering Verifier) 緩衝區讓整體的位元速率保持在給定的條件之內。"
+AMF.H264.VBVBuffer.Strictness="VBV 緩衝區嚴格性"
+AMF.H264.VBVBuffer.Strictness.Description="VBV 緩衝區嚴格程度，100% 表示幾乎跟目標位元速率一樣，0% 則不受限制。"
+AMF.H264.VBVBuffer.Size="VBV 緩衝區大小"
+AMF.H264.VBVBuffer.Size.Description="用於位元流量控制的 VBV 緩衝區大小。\n一個極小值將會得到近乎完美的位元速率結果，但是會有較大的效能消耗。"
+AMF.H264.VBVBuffer.Fullness="初始 VBV 緩衝區填充度"
+AMF.H264.VBVBuffer.Fullness.Description="VBV 緩衝區起始該多滿，將只影響編碼的起始。"
+AMF.H264.FillerData="填塞空白資料"
+AMF.H264.FillerData.Description="啟用填塞空白資料允許編碼器保持位元速率至少有目標位元速率，編碼器將會將不足的位元用空白訊息填滿"
+AMF.H264.FrameSkipping="省略訊框"
+AMF.H264.EnforceHRDCompatibility="與 HRD 相容"
+AMF.H264.BPicture.Pattern="B-Picture 模式"
+AMF.H264.BPicture.Reference="B-Picture 參照"
+AMF.H264.DeblockingFilter="去塊狀色斑濾鏡"
+AMF.H264.MotionEstimation="動態估算"
+AMF.H264.MotionEstimation.Description="動態估算讓編碼器藉由估算像素移動來減少位元速率。"
+AMF.H264.MotionEstimation.None="無"
+AMF.H264.MotionEstimation.Half="半像素"
+AMF.H264.MotionEstimation.Quarter="四分之一像素"
+AMF.H264.MotionEstimation.Both="半 & 四分之一像素"
+AMF.H264.View="檢視模式"
+AMF.H264.View.Description="該顯示哪些屬性？\n使用'\@AMF.H264.View.Master\@'時將不提供任何的支援。"
+AMF.H264.View.Basic="基本"
+AMF.H264.View.Advanced="進階"
+AMF.H264.View.Expert="專家"
+AMF.H264.View.Master="上帝模式"
+AMF.H264.UnlockProperties="解除屬性值限制"
+AMF.H264.UnlockProperties.Description="允許一些屬性的數值範圍為全部可行的範圍，而非限定在一定的範圍內。"
+AMF.H264.Debug="除錯模式"
+AMF.H264.Debug.Description="啟用額外的除錯紀錄，當需要任何關於此編碼器的支援時皆應啟用。"
+AMF.Util.Default="預設"
+AMF.Util.Automatic="自動"
+AMF.Util.Manual="手動"
+AMF.Util.Toggle.Disabled="停用"
+AMF.Util.Toggle.Enabled="啟用"

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source Added

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/amd-amf-vce-capabilities.cpp Added

@@ -0,0 +1,364 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <string>
+#include <sstream>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <VersionHelpers.h>
+#endif
+
+#include "amd-amf-vce-capabilities.h"
+#include "api-d3d11.h"
+#include "api-d3d9.h"
+#include "misc-util.cpp"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+
+std::shared_ptr<Plugin::AMD::VCECapabilities> Plugin::AMD::VCECapabilities::GetInstance() {
+	static std::shared_ptr<VCECapabilities> __instance = std::make_shared<VCECapabilities>();
+	static std::mutex __mutex;
+
+	const std::lock_guard<std::mutex> lock(__mutex);
+	return __instance;
+}
+
+void Plugin::AMD::VCECapabilities::ReportCapabilities() {
+	auto inst = GetInstance();
+
+	auto devs = inst->GetDevices();
+	for (auto dev : devs) {
+		ReportDeviceCapabilities(dev);
+	}
+}
+
+void Plugin::AMD::VCECapabilities::ReportDeviceCapabilities(Plugin::API::Device device) {
+	auto inst = GetInstance();
+
+	AMF_LOG_INFO("Capabilities for Device '%s':", device.Name.c_str());
+
+	VCEEncoderType types[] = { VCEEncoderType_AVC, VCEEncoderType_SVC };
+	for (VCEEncoderType type : types) {
+		auto caps = inst->GetDeviceCaps(device, type);
+
+		AMF_LOG_INFO(" %s (Acceleration: %s)",
+			(type == VCEEncoderType_AVC ? "AVC" : (type == VCEEncoderType_SVC ? "SVC" : (type == VCEEncoderType_HEVC ? "HEVC" : "Unknown"))),
+			(caps.acceleration_type == amf::AMF_ACCEL_SOFTWARE ? "Software" : (caps.acceleration_type == amf::AMF_ACCEL_GPU ? "GPU" : (caps.acceleration_type == amf::AMF_ACCEL_HARDWARE ? "Hardware" : "None")))
+		);
+
+		if (caps.acceleration_type == amf::AMF_ACCEL_NOT_SUPPORTED)
+			continue;
+
+		AMF_LOG_INFO(" Limits");
+		AMF_LOG_INFO(" # of Streams: %ld", caps.maxNumOfStreams);
+		AMF_LOG_INFO(" # of Instances: %ld", caps.maxNumOfHwInstances);
+		AMF_LOG_INFO(" Profile: %s", Plugin::Utility::ProfileAsString((VCEProfile)caps.maxProfile));
+		AMF_LOG_INFO(" Level: %ld.%ld", caps.maxProfileLevel / 10, caps.maxProfileLevel % 10);
+		AMF_LOG_INFO(" Bitrate: %ld", caps.maxBitrate);
+		AMF_LOG_INFO(" Temporal Layers: %ld", caps.maxTemporalLayers);
+		AMF_LOG_INFO(" Reference Frames: %ld (min) - %ld (max)", caps.minReferenceFrames, caps.maxReferenceFrames);
+		AMF_LOG_INFO(" Features")
+			AMF_LOG_INFO(" B-Frames: %s", caps.supportsBFrames ? "Supported" : "Not Supported");
+		AMF_LOG_INFO(" Fixed Slice Mode: %s", caps.supportsFixedSliceMode ? "Supported" : "Not Supported");
+		AMF_LOG_INFO(" Input");
+		ReportDeviceIOCapabilities(device, type, false);
+		AMF_LOG_INFO(" Output");
+		ReportDeviceIOCapabilities(device, type, true);
+	}
+}
+
+void Plugin::AMD::VCECapabilities::ReportDeviceIOCapabilities(Plugin::API::Device device, VCEEncoderType type, bool output) {
+	auto amf = Plugin::AMD::AMF::GetInstance();
+	auto inst = GetInstance();
+	auto ioCaps = inst->GetDeviceIOCaps(device, type, output);
+	AMF_LOG_INFO(" Resolution: %ldx%ld - %ldx%ld",
+		ioCaps.minWidth, ioCaps.minHeight,
+		ioCaps.maxWidth, ioCaps.maxHeight);
+	AMF_LOG_INFO(" Vertical Alignment: %ld", ioCaps.verticalAlignment);
+	AMF_LOG_INFO(" Interlaced: %s", ioCaps.isInterlacedSupported ? "Supported" : "Not Supported");
+	std::stringstream formatstr;
+	for (auto format : ioCaps.formats) {
+		std::vector<char> buf(1024);
+		wcstombs(buf.data(), amf->GetTrace()->SurfaceGetFormatName(format.first), 1024);
+		formatstr
+			<< buf.data()
+			<< (format.second ? " (Native)" : "")
+			<< ", ";
+	}
+	AMF_LOG_INFO(" Formats: %s", formatstr.str().c_str());
+	std::stringstream memorystr;
+	for (auto memory : ioCaps.memoryTypes) {
+		std::vector<char> buf(1024);
+		wcstombs(buf.data(), amf->GetTrace()->GetMemoryTypeName(memory.first), 1024);
+		memorystr
+			<< buf.data()
+			<< (memory.second ? " (Native)" : "")
+			<< ", ";
+	}
+	AMF_LOG_INFO(" Memory Types: %s", memorystr.str().c_str());
+}
+
+Plugin::AMD::VCECapabilities::VCECapabilities() {
+	this->Refresh();
+}
+
+Plugin::AMD::VCECapabilities::~VCECapabilities() {}
+
+static AMF_RESULT GetIOCapability(bool output, amf::AMFCapsPtr amfCaps, Plugin::AMD::VCEDeviceCapabilities::IOCaps* caps) {
+	AMF_RESULT res = AMF_OK;
+	amf::AMFIOCapsPtr amfIOCaps;
+	if (output)
+		res = amfCaps->GetOutputCaps(&amfIOCaps);
+	else
+		res = amfCaps->GetInputCaps(&amfIOCaps);
+	if (res != AMF_OK)
+		return res;
+
+	amfIOCaps->GetWidthRange(&(caps->minWidth), &(caps->maxWidth));
+	amfIOCaps->GetHeightRange(&(caps->minHeight), &(caps->maxHeight));
+	caps->isInterlacedSupported = amfIOCaps->IsInterlacedSupported();
+	caps->verticalAlignment = amfIOCaps->GetVertAlign();
+
+	int32_t numFormats = amfIOCaps->GetNumOfFormats();
+	caps->formats.resize(numFormats);
+	for (int32_t formatIndex = 0; formatIndex < numFormats; formatIndex++) {
+		amf::AMF_SURFACE_FORMAT format = amf::AMF_SURFACE_UNKNOWN;
+		bool isNative = false;
+
+		amfIOCaps->GetFormatAt(formatIndex, &format, &isNative);
+		caps->formats[formatIndex].first = format;
+		caps->formats[formatIndex].second = isNative;
+	}
+
+	int32_t numMemoryTypes = amfIOCaps->GetNumOfMemoryTypes();
+	caps->memoryTypes.resize(numMemoryTypes);
+	for (int32_t memoryTypeIndex = 0; memoryTypeIndex < numMemoryTypes; memoryTypeIndex++) {
+		amf::AMF_MEMORY_TYPE type = amf::AMF_MEMORY_UNKNOWN;
+		bool isNative = false;
+
+		amfIOCaps->GetMemoryTypeAt(memoryTypeIndex, &type, &isNative);
+		caps->memoryTypes[memoryTypeIndex].first = type;
+		caps->memoryTypes[memoryTypeIndex].second = isNative;
+	}
+
+	return AMF_OK;
+}
+
+bool Plugin::AMD::VCECapabilities::Refresh() {
+	AMF_RESULT res;
+
+	// Build a list of Devices
+	#ifdef _WIN32
+	if (IsWindows8OrGreater()) {
+		devices = Plugin::API::Direct3D11::EnumerateDevices();
+	} else if (IsWindowsXPOrGreater()) {
+		devices = Plugin::API::Direct3D9::EnumerateDevices();
+	} else
+		#endif 
+	{ // OpenGL
+		//devices = Plugin::API::OpenGL::EnumerateDevices();
+	}
+	//devices.insert(devices.begin(), Plugin::API::Device());
+
+	// Query Information for each Device
+	std::shared_ptr<AMD::AMF> amfInstance = AMD::AMF::GetInstance();
+	amf::AMFFactory* amfFactory = amfInstance->GetFactory();
+	for (Plugin::API::Device device : devices) {
+		amf::AMFContextPtr amfContext;
+		res = amfFactory->CreateContext(&amfContext);
+		if (res != AMF_OK) {
+			AMF_LOG_ERROR("Unable to gather capabilities for device '%s', error %ls (code %d).",
+				device.Name.c_str(), amfInstance->GetTrace()->GetResultText(res), res);
+			continue;
+		}
+
+		auto apiDev = Plugin::API::APIBase::CreateBestAvailableAPI(device);
+		switch (apiDev->GetType()) {
+			case Plugin::API::APIType_Direct3D11:
+				res = amfContext->InitDX11(apiDev->GetContext());
+				break;
+			case Plugin::API::APIType_Direct3D9:
+				res = amfContext->InitDX9(apiDev->GetContext());
+				break;
+			case Plugin::API::APIType_OpenGL:
+				res = amfContext->InitOpenGL(apiDev->GetContext(), nullptr, nullptr);
+				break;
+		}
+		if (res != AMF_OK) {
+			AMF_LOG_ERROR("Unable to gather capabilities for device '%s' after initialization, error %ls (code %d).",
+				device.Name.c_str(), amfInstance->GetTrace()->GetResultText(res), res);
+			continue;
+		}
+
+		VCEDeviceCapabilities devAVCCaps, devSVCCaps;
+		const wchar_t* capsString[] = {
+			AMFVideoEncoderVCE_AVC,
+			AMFVideoEncoderVCE_SVC,
+		};
+		VCEDeviceCapabilities* caps[] = {
+			&devAVCCaps,
+			&devSVCCaps,
+		};
+		VCEEncoderType capsType[] = {
+			VCEEncoderType_AVC,
+			VCEEncoderType_SVC,
+		};
+
+		for (uint8_t capsIndex = 0; capsIndex < _countof(caps); capsIndex++) {
+			#pragma region Null Structure
+			caps[capsIndex]->acceleration_type = amf::AMF_ACCEL_NOT_SUPPORTED;
+			caps[capsIndex]->maxBitrate =
+				caps[capsIndex]->maxNumOfStreams =
+				caps[capsIndex]->maxProfile =
+				caps[capsIndex]->maxProfileLevel =
+				caps[capsIndex]->minReferenceFrames =
+				caps[capsIndex]->maxReferenceFrames =
+				caps[capsIndex]->maxTemporalLayers =
+				caps[capsIndex]->maxNumOfHwInstances =
+				caps[capsIndex]->input.minWidth =
+				caps[capsIndex]->input.maxWidth =
+				caps[capsIndex]->input.minHeight =
+				caps[capsIndex]->input.maxHeight =
+				caps[capsIndex]->input.verticalAlignment =
+				caps[capsIndex]->output.minWidth =
+				caps[capsIndex]->output.maxWidth =
+				caps[capsIndex]->output.minHeight =
+				caps[capsIndex]->output.maxHeight =
+				caps[capsIndex]->output.verticalAlignment = 0;
+			caps[capsIndex]->supportsBFrames =
+				caps[capsIndex]->supportsFixedSliceMode =
+				caps[capsIndex]->input.isInterlacedSupported =
+				caps[capsIndex]->output.isInterlacedSupported = false;
+			caps[capsIndex]->input.formats.clear();
+			caps[capsIndex]->output.formats.clear();
+			caps[capsIndex]->input.memoryTypes.clear();
+			caps[capsIndex]->output.memoryTypes.clear();
+			#pragma endregion Null Structure
+
+			#pragma region Initialization
+			amf::AMFComponentPtr amfComponent;
+			res = amfFactory->CreateComponent(amfContext, capsString[capsIndex], &amfComponent);
+			if (res != AMF_OK) {
+				AMF_LOG_ERROR("<" __FUNCTION_NAME__ "> Failed to create component for device '%s' with codec '%ls', error %ls (code %d).",
+					device.Name.c_str(), capsString[capsIndex],
+					amfInstance->GetTrace()->GetResultText(res), res);
+				continue;
+			}
+
+			amf::AMFCapsPtr amfCaps;
+			res = amfComponent->GetCaps(&amfCaps);
+			if (res != AMF_OK) {
+				AMF_LOG_ERROR("<" __FUNCTION_NAME__ "> Failed to gather capabilities for device '%s' with codec '%ls', error %ls (code %d).",
+					device.Name.c_str(), capsString[capsIndex],
+					amfInstance->GetTrace()->GetResultText(res), res);
+				amfComponent->Terminate();
+				continue;
+			}
+			#pragma endregion Initialization
+
+			#pragma region Basic Capabilities
+			caps[capsIndex]->acceleration_type = amfCaps->GetAccelerationType();
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_BITRATE, &(caps[capsIndex]->maxBitrate));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_NUM_OF_STREAMS, &(caps[capsIndex]->maxNumOfStreams));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_PROFILE, &(caps[capsIndex]->maxProfile));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_LEVEL, &(caps[capsIndex]->maxProfileLevel));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_BFRAMES, &(caps[capsIndex]->supportsBFrames));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MIN_REFERENCE_FRAMES, &(caps[capsIndex]->minReferenceFrames));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_REFERENCE_FRAMES, &(caps[capsIndex]->maxReferenceFrames));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_MAX_TEMPORAL_LAYERS, &(caps[capsIndex]->maxTemporalLayers));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_FIXED_SLICE_MODE, &(caps[capsIndex]->supportsFixedSliceMode));
+			amfCaps->GetProperty(AMF_VIDEO_ENCODER_CAP_NUM_OF_HW_INSTANCES, &(caps[capsIndex]->maxNumOfHwInstances));
+			#pragma endregion Basic Capabilities
+
+			if (GetIOCapability(false, amfCaps, &(caps[capsIndex]->input))) {
+				AMF_LOG_ERROR("<" __FUNCTION_NAME__ "> Failed to gather input capabilities for device '%s' with codec '%ls', error %ls (code %d).",
+					device.Name.c_str(), capsString[capsIndex],
+					amfInstance->GetTrace()->GetResultText(res), res);
+			}
+			if (GetIOCapability(true, amfCaps, &(caps[capsIndex]->output))) {
+				AMF_LOG_ERROR("<" __FUNCTION_NAME__ "> Failed to gather output capabilities for device '%s' with codec '%ls', error %ls (code %d).",
+					device.Name.c_str(), capsString[capsIndex],
+					amfInstance->GetTrace()->GetResultText(res), res);
+			}
+
+			amfComponent->Terminate();
+
+			// Register
+			std::pair<Plugin::API::Device, Plugin::AMD::VCEEncoderType> devkv(device, capsType[capsIndex]);
+			deviceToCapabilities.insert(std::make_pair(devkv, *caps[capsIndex]));
+		}
+
+		amfContext->Terminate();
+	}
+
+	return true;
+}
+
+std::vector<Plugin::API::Device> Plugin::AMD::VCECapabilities::GetDevices() {
+	return std::vector<Plugin::API::Device>(devices);
+}
+
+Plugin::AMD::VCEDeviceCapabilities Plugin::AMD::VCECapabilities::GetDeviceCaps(Plugin::API::Device device, VCEEncoderType type) {
+	if (deviceToCapabilities.empty())
+		return Plugin::AMD::VCEDeviceCapabilities();
+
+	if (device.UniqueId == "")
+		return deviceToCapabilities.begin()->second;
+
+	auto dt = std::pair<Plugin::API::Device, Plugin::AMD::VCEEncoderType>(device, type);
+	if (deviceToCapabilities.count(dt) == 0)
+		return Plugin::AMD::VCEDeviceCapabilities();
+
+	return deviceToCapabilities.find(dt)->second;
+}
+
+Plugin::AMD::VCEDeviceCapabilities::IOCaps Plugin::AMD::VCECapabilities::GetDeviceIOCaps(Plugin::API::Device device, VCEEncoderType type, bool output) {
+	if (deviceToCapabilities.empty())
+		return Plugin::AMD::VCEDeviceCapabilities::IOCaps();
+
+	if (device.UniqueId == "") {
+		if (output)
+			return deviceToCapabilities.begin()->second.output;
+		else
+			return deviceToCapabilities.begin()->second.input;
+	}
+
+	auto dt = std::pair<Plugin::API::Device, Plugin::AMD::VCEEncoderType>(device, type);
+	if (deviceToCapabilities.count(dt) == 0)
+		return Plugin::AMD::VCEDeviceCapabilities::IOCaps();
+
+	if (output)
+		return deviceToCapabilities.find(dt)->second.output;
+	else
+		return deviceToCapabilities.find(dt)->second.input;
+}
+

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/amd-amf-vce.cpp Added

@@ -0,0 +1,1868 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <chrono>
+
+#include "amd-amf-vce.h"
+#include "amd-amf-vce-capabilities.h"
+#include "misc-util.cpp"
+
+// AMF
+#include "components/VideoEncoderVCE.h"
+#include "components/VideoConverter.h"
+
+// Windows
+#ifdef _WIN32
+#include <windows.h>
+#include <VersionHelpers.h>
+
+#include "api-d3d9.h"
+#include "api-d3d11.h"
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+
+// Logging and Exception Helpers
+static void FormatTextWithAMFError(std::vector<char>* buffer, const char* format, AMF_RESULT res) {
+	sprintf(buffer->data(), format, Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);
+}
+
+template<typename _T>
+static void FormatTextWithAMFError(std::vector<char>* buffer, const char* format, _T other, AMF_RESULT res) {
+	sprintf(buffer->data(), format, other, Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);
+}
+
+// Class
+void Plugin::AMD::VCEEncoder::InputThreadMain(Plugin::AMD::VCEEncoder* p_this) {
+	p_this->InputThreadLogic();
+}
+
+void Plugin::AMD::VCEEncoder::OutputThreadMain(Plugin::AMD::VCEEncoder* p_this) {
+	p_this->OutputThreadLogic();
+}
+
+static void fastPrintVariant(const char* text, amf::AMFVariantStruct variant) {
+	std::vector<char> buf(1024);
+	switch (variant.type) {
+		case amf::AMF_VARIANT_EMPTY:
+			sprintf(buf.data(), "%s%s", text, "Empty");
+			break;
+		case amf::AMF_VARIANT_BOOL:
+			sprintf(buf.data(), "%s%s", text, variant.boolValue ? "true" : "false");
+			break;
+		case amf::AMF_VARIANT_INT64:
+			sprintf(buf.data(), "%s%lld", text, variant.int64Value);
+			break;
+		case amf::AMF_VARIANT_DOUBLE:
+			sprintf(buf.data(), "%s%f", text, variant.doubleValue);
+			break;
+		case amf::AMF_VARIANT_RECT:
+			sprintf(buf.data(), "%s[%ld,%ld,%ld,%ld]", text,
+				variant.rectValue.top, variant.rectValue.left,
+				variant.rectValue.bottom, variant.rectValue.right);
+			break;
+		case amf::AMF_VARIANT_SIZE:
+			sprintf(buf.data(), "%s%ldx%ld", text,
+				variant.sizeValue.width, variant.sizeValue.height);
+			break;
+		case amf::AMF_VARIANT_POINT:
+			sprintf(buf.data(), "%s[%ld,%ld]", text,
+				variant.pointValue.x, variant.pointValue.y);
+			break;
+		case amf::AMF_VARIANT_RATE:
+			sprintf(buf.data(), "%s%ld/%ld", text,
+				variant.rateValue.num, variant.rateValue.den);
+			break;
+		case amf::AMF_VARIANT_RATIO:
+			sprintf(buf.data(), "%s%ld:%ld", text,
+				variant.ratioValue.num, variant.ratioValue.den);
+			break;
+		case amf::AMF_VARIANT_COLOR:
+			sprintf(buf.data(), "%s(%d,%d,%d,%d)", text,
+				variant.colorValue.r,
+				variant.colorValue.g,
+				variant.colorValue.b,
+				variant.colorValue.a);
+			break;
+		case amf::AMF_VARIANT_STRING:
+			sprintf(buf.data(), "%s'%s'", text,
+				variant.stringValue);
+			break;
+		case amf::AMF_VARIANT_WSTRING:
+			sprintf(buf.data(), "%s'%ls'", text,
+				variant.wstringValue);
+			break;
+	}
+	AMF_LOG_INFO("%s", buf.data());
+};
+
+static void printDebugInfo(amf::AMFComponentPtr m_AMFEncoder) {
+	#ifdef _DEBUG
+	amf::AMFPropertyInfo* pInfo;
+	size_t propCount = m_AMFEncoder->GetPropertyCount();
+	AMF_LOG_INFO("-- Internal AMF Encoder Properties --");
+	for (size_t propIndex = 0; propIndex < propCount; propIndex++) {
+		static const char* typeToString[] = {
+			"Empty",
+			"Boolean",
+			"Int64",
+			"Double",
+			"Rect",
+			"Size",
+			"Point",
+			"Rate",
+			"Ratio",
+			"Color",
+			"String",
+			"WString",
+			"Interface"
+		};
+
+		AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(propIndex, (const amf::AMFPropertyInfo**) &pInfo);
+		if (res != AMF_OK)
+			continue;
+		AMF_LOG_INFO(" [%ls] %ls (Type: %s, Index %d)",
+			pInfo->name, pInfo->desc, typeToString[pInfo->type], propIndex);
+		AMF_LOG_INFO(" Content Type: %d",
+			pInfo->contentType);
+		AMF_LOG_INFO(" Access: %s%s%s",
+			(pInfo->accessType & amf::AMF_PROPERTY_ACCESS_READ) ? "R" : "",
+			(pInfo->accessType & amf::AMF_PROPERTY_ACCESS_WRITE) ? "W" : "",
+			(pInfo->accessType & amf::AMF_PROPERTY_ACCESS_WRITE_RUNTIME) ? "X" : "");
+
+		AMF_LOG_INFO(" Values:");
+		amf::AMFVariantStruct curStruct = amf::AMFVariantStruct();
+		m_AMFEncoder->GetProperty(pInfo->name, &curStruct);
+		fastPrintVariant(" Current: ", curStruct);
+		fastPrintVariant(" Default: ", pInfo->defaultValue);
+		fastPrintVariant(" Minimum: ", pInfo->minValue);
+		fastPrintVariant(" Maximum: ", pInfo->maxValue);
+		if (pInfo->pEnumDescription) {
+			AMF_LOG_INFO(" Enumeration: ");
+			const amf::AMFEnumDescriptionEntry* pEnumEntry = pInfo->pEnumDescription;
+			while (pEnumEntry->name != nullptr) {
+				AMF_LOG_INFO(" %ls (%ld)",
+					pEnumEntry->name,
+					pEnumEntry->value);
+				pEnumEntry++;
+			}
+		}
+	}
+	#endif
+}
+
+Plugin::AMD::VCEEncoder::VCEEncoder(VCEEncoderType p_Type,
+	std::string p_DeviceId/* = ""*/,
+	bool p_OpenCL/* = false*/,
+	VCEColorFormat p_SurfaceFormat/* = VCESurfaceFormat_NV12*/
+) {
+	AMF_RESULT res;
+
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Initializing...");
+
+	// Solve the optimized away issue.
+	m_EncoderType = p_Type;
+	m_SurfaceFormat = p_SurfaceFormat;
+	m_UseOpenCL = p_OpenCL;
+	m_Flag_IsStarted = false;
+	m_Flag_FirstFrameReceived = false;
+	m_Flag_FirstFrameSubmitted = false;
+	m_FrameSize.first = 64;	m_FrameSize.second = 64;
+	m_FrameRate.first = 30; m_FrameRate.second = 1;
+	m_FrameRateDivisor = ((double_t)m_FrameRate.first / (double_t)m_FrameRate.second);
+	m_FrameRateReverseDivisor = ((double_t)m_FrameRate.second / (double_t)m_FrameRate.first);
+	m_InputQueueLimit = (uint32_t)(m_FrameRateDivisor * 3);
+	m_InputQueueLastSize = 0;
+	m_TimerPeriod = 1;
+
+	// AMF
+	m_AMF = AMF::GetInstance();
+	m_AMFFactory = m_AMF->GetFactory();
+	/// AMF Context
+	res = m_AMFFactory->CreateContext(&m_AMFContext);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Creating a context object failed with error %ls (code %ld).", res);
+	}
+
+	// API Init
+	if (p_DeviceId == "") { // Use primary/available AMD devices only.
+		p_DeviceId = Plugin::AMD::VCECapabilities::GetInstance()->GetDevices().begin()->UniqueId;
+	}
+	m_APIDevice = Plugin::API::APIBase::CreateBestAvailableAPI(Plugin::API::APIBase::GetDeviceForUniqueId(p_DeviceId));
+	switch (m_APIDevice->GetType()) {
+		case Plugin::API::APIType_Direct3D11:
+			res = m_AMFContext->InitDX11(m_APIDevice->GetContext());
+			m_MemoryType = VCEMemoryType_DirectX11;
+			break;
+		case Plugin::API::APIType_Direct3D9:
+			res = m_AMFContext->InitDX9(m_APIDevice->GetContext());
+			m_MemoryType = VCEMemoryType_DirectX9;
+			break;
+		case Plugin::API::APIType_OpenGL:
+			res = m_AMFContext->InitOpenGL(m_APIDevice->GetContext(), nullptr, nullptr);
+			m_MemoryType = VCEMemoryType_OpenGL;
+			break;
+		case Plugin::API::APIType_Base: // Not the best case, but whatever.
+			m_UseOpenCL = false;
+			m_MemoryType = VCEMemoryType_Host;
+			break;
+	}
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Initializing 3D queue failed with error %ls (code %ld).", res);
+
+	if (m_UseOpenCL) {
+		res = m_AMFContext->InitOpenCL(nullptr);
+		if (res != AMF_OK)
+			ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> InitOpenCL failed with error %ls (code %ld).", res);
+		m_AMFContext->GetCompute(amf::AMF_MEMORY_OPENCL, &m_AMFCompute);
+	}
+
+	/// AMF Component (Encoder)
+	switch (p_Type) {
+		case VCEEncoderType_AVC:
+			res = m_AMFFactory->CreateComponent(m_AMFContext, AMFVideoEncoderVCE_AVC, &m_AMFEncoder);
+			break;
+		case VCEEncoderType_SVC:
+			res = m_AMFFactory->CreateComponent(m_AMFContext, AMFVideoEncoderVCE_SVC, &m_AMFEncoder);
+			break;
+		case VCEEncoderType_HEVC:
+			res = m_AMFFactory->CreateComponent(m_AMFContext, L"AMFVideoEncoderHW_HEVC", &m_AMFEncoder);
+			break;
+	}
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Creating a component object failed with error %ls (code %ld).", res);
+
+	/// AMF Component (Converter)
+	res = m_AMFFactory->CreateComponent(m_AMFContext, AMFVideoConverter, &m_AMFConverter);
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Unable to create VideoConverter component, error %ls (code %ld).", res);
+	m_AMFConverter->SetProperty(AMF_VIDEO_CONVERTER_MEMORY_TYPE, Utility::MemoryTypeAsAMF(m_MemoryType));
+	m_AMFConverter->SetProperty(AMF_VIDEO_CONVERTER_OUTPUT_FORMAT, Utility::SurfaceFormatAsAMF(m_SurfaceFormat));
+
+	printDebugInfo(m_AMFEncoder);
+
+	AMF_LOG_DEBUG("Initialization complete!");
+}
+
+Plugin::AMD::VCEEncoder::~VCEEncoder() {
+	if (m_Flag_IsStarted)
+		Stop();
+
+	// AMF
+	if (m_AMFConverter) {
+		m_AMFConverter->Terminate();
+		m_AMFConverter = nullptr;
+	}
+	if (m_AMFEncoder) {
+		m_AMFEncoder->Terminate();
+		m_AMFEncoder = nullptr;
+	}
+	if (m_AMFContext) {
+		m_AMFContext->Terminate();
+		m_AMFContext = nullptr;
+	}
+	m_AMFFactory = nullptr;
+}
+
+void Plugin::AMD::VCEEncoder::Start() {
+	// Set proper Timer resolution.
+	m_TimerPeriod = 1;
+	while (timeBeginPeriod(m_TimerPeriod) == TIMERR_NOCANDO) {
+		++m_TimerPeriod;
+	}
+
+	// Create Encoder
+	AMF_RESULT res = m_AMFEncoder->Init(Utility::SurfaceFormatAsAMF(m_SurfaceFormat),
+		m_FrameSize.first, m_FrameSize.second);
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Encoder initialization failed with error %ls (code %ld).", res);
+
+	// Create Converter
+	m_AMFConverter->SetProperty(AMF_VIDEO_CONVERTER_COLOR_PROFILE, AMF_VIDEO_CONVERTER_COLOR_PROFILE_709);
+	//m_AMFConverter->SetProperty(L"NominalRange", this->IsFullColorRangeEnabled());
+	res = m_AMFConverter->Init(Utility::SurfaceFormatAsAMF(m_SurfaceFormat), m_FrameSize.first, m_FrameSize.second);
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Converter initialization failed with error %ls (code %ld).", res);
+
+	m_Flag_IsStarted = true;
+
+	// Threading
+	m_Input.thread = std::thread(&(Plugin::AMD::VCEEncoder::InputThreadMain), this);
+	m_Output.thread = std::thread(&(Plugin::AMD::VCEEncoder::OutputThreadMain), this);
+}
+
+void Plugin::AMD::VCEEncoder::Restart() {
+	if (!m_Flag_IsStarted)
+		return;
+
+	std::unique_lock<std::mutex> ilock(m_Input.mutex);
+	std::unique_lock<std::mutex> olock(m_Output.mutex);
+
+	// Create Encoder
+	AMF_RESULT res = m_AMFEncoder->ReInit(m_FrameSize.first, m_FrameSize.second);
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Initialization failed with error %ls (code %ld).", res);
+}
+
+void Plugin::AMD::VCEEncoder::Stop() {
+	// Restore Timer precision.
+	if (m_TimerPeriod != 0) {
+		timeEndPeriod(m_TimerPeriod);
+	}
+
+	m_Flag_IsStarted = false;
+
+	// Threading
+	m_Output.condvar.notify_all();
+	#if defined _WIN32 || defined _WIN64
+	{ // Windows: Force terminate Thread after 1 second of waiting.
+		std::thread::native_handle_type hnd = m_Output.thread.native_handle();
+
+		uint32_t res = WaitForSingleObject((HANDLE)hnd, 1000);
+		switch (res) {
+			case WAIT_OBJECT_0:
+				m_Output.thread.join();
+				break;
+			default:
+				m_Output.thread.detach();
+				TerminateThread((HANDLE)hnd, 0);
+				break;
+		}
+	}
+	#else
+	m_Output.thread.join();
+	#endif
+
+	m_Input.condvar.notify_all();
+	#if defined _WIN32 || defined _WIN64
+	{ // Windows: Force terminate Thread after 1 second of waiting.
+		std::thread::native_handle_type hnd = m_Input.thread.native_handle();
+
+		uint32_t res = WaitForSingleObject((HANDLE)hnd, 1000);
+		switch (res) {
+			case WAIT_OBJECT_0:
+				m_Input.thread.join();
+				break;
+			default:
+				m_Input.thread.detach();
+				TerminateThread((HANDLE)hnd, 0);
+				break;
+		}
+	}
+	#else
+	m_Input.thread.join();
+	#endif
+
+	// Stop AMF Encoder
+	if (m_AMFEncoder) {
+		m_AMFEncoder->Drain();
+		m_AMFEncoder->Flush();
+	}
+
+	// Clear Queues, Data
+	std::queue<amf::AMFSurfacePtr>().swap(m_Input.queue);
+	std::queue<amf::AMFDataPtr>().swap(m_Output.queue);
+	m_PacketDataBuffer.clear();
+	m_ExtraDataBuffer.clear();
+}
+
+bool Plugin::AMD::VCEEncoder::IsStarted() {
+	return m_Flag_IsStarted;
+}
+
+bool Plugin::AMD::VCEEncoder::SendInput(struct encoder_frame* frame) {
+	// Early-Exception if not encoding.
+	if (!m_Flag_IsStarted) {
+		const char* error = "<" __FUNCTION_NAME__ "> Attempted to send input while not running.";
+		AMF_LOG_ERROR("%s", error);
+		throw std::exception(error);
+	}
+
+	// Convert Frame into a Surface and queue it.
+	if (frame != nullptr) {
+		amf::AMFSurfacePtr pAMFSurface = CreateSurfaceFromFrame(frame);
+		if (pAMFSurface) {
+			// Set Surface Properties
+			pAMFSurface->SetPts(frame->pts / m_FrameRate.second);
+			pAMFSurface->SetProperty(L"Frame", frame->pts);
+			pAMFSurface->SetDuration((uint64_t)ceil(m_FrameRateReverseDivisor * AMF_SECOND));
+
+			// Add to Queue
+			std::unique_lock<std::mutex> qlock(m_Input.queuemutex);
+			size_t uiQueueSize = m_Input.queue.size();
+
+			if (uiQueueSize >= m_InputQueueLimit) {
+				AMF_LOG_WARNING("Submission queue is full, dropping frame instead...");
+			} else {
+				m_Input.queue.push(pAMFSurface);
+				if (m_InputQueueLastSize != uiQueueSize) {
+					int32_t delta = ((int32_t)uiQueueSize - (int32_t)m_InputQueueLastSize);
+					if (uiQueueSize == 0) {
+						AMF_LOG_DEBUG("Submission queue is empty. (%d/%d/%d)", uiQueueSize, delta, m_InputQueueLimit);
+						m_InputQueueLastSize = uiQueueSize;
+					} else if (delta >= 5) {
+						AMF_LOG_WARNING("Submission queue size is growing. (%d/%d/%d)", uiQueueSize, delta, m_InputQueueLimit);
+						m_InputQueueLastSize = uiQueueSize;
+					} else if (delta <= -5) {
+						AMF_LOG_INFO("Submission queue size is shrinking. (%d/%d/%d)", uiQueueSize, delta, m_InputQueueLimit);
+						m_InputQueueLastSize = uiQueueSize;
+					}
+				}
+			}
+		} else {
+			AMF_LOG_ERROR("Unable copy frame for submission, terminating...");
+			return false;
+		}
+	}
+
+	/// Signal Thread Wakeup
+	m_Input.condvar.notify_all();
+
+	// WORKAROUND: Block for at most 5 seconds until the first frame has been submitted.
+	if (!m_Flag_FirstFrameSubmitted) {
+		auto startsubmit = std::chrono::high_resolution_clock::now();
+		auto diff = std::chrono::high_resolution_clock::now() - startsubmit;
+		do {
+			diff = std::chrono::high_resolution_clock::now() - startsubmit;
+			std::this_thread::sleep_for(std::chrono::milliseconds(m_TimerPeriod));
+		} while ((diff <= std::chrono::seconds(5)) && !m_Flag_FirstFrameSubmitted);
+		if (!m_Flag_FirstFrameSubmitted)
+			throw std::exception("Unable to submit first frame, terminating...");
+		else
+			AMF_LOG_INFO("First submission took %d nanoseconds.", diff.count());
+	}
+
+	return true;
+}
+
+bool Plugin::AMD::VCEEncoder::GetOutput(struct encoder_packet* packet, bool* received_packet) {
+	// Early-Exception if not encoding.
+	if (!m_Flag_IsStarted) {
+		const char* error = "<" __FUNCTION_NAME__ "> Attempted to send input while not running.";
+		AMF_LOG_ERROR("%s", error);
+		throw std::exception(error);
+	}
+
+	/// Signal Thread Wakeup
+	m_Output.condvar.notify_all();
+
+	if (received_packet != nullptr) {
+		amf::AMFDataPtr pAMFData;
+		{ // Attempt to dequeue an Item.
+			std::unique_lock<std::mutex> qlock(m_Output.queuemutex);
+			if (m_Output.queue.size() == 0)
+				return true;
+
+			pAMFData = m_Output.queue.front();
+			m_Output.queue.pop();
+		}
+
+		// We've got a DataPtr, let's use it.
+		amf::AMFBufferPtr pAMFBuffer = amf::AMFBufferPtr(pAMFData);
+
+		// Assemble Packet
+		packet->type = OBS_ENCODER_VIDEO;
+		/// Data
+		size_t oldBufferSize = pAMFBuffer->GetSize();
+		if (m_PacketDataBuffer.size() < oldBufferSize) {
+			size_t newBufferSize = (size_t)exp2(ceil(log2(oldBufferSize)));
+			AMF_LOG_DEBUG("Packet Buffer was resized to %d byte from %d byte.", newBufferSize, m_PacketDataBuffer.size());
+			m_PacketDataBuffer.resize(newBufferSize);
+		}
+		packet->data = m_PacketDataBuffer.data();
+		packet->size = oldBufferSize;
+		std::memcpy(packet->data, pAMFBuffer->GetNative(), packet->size);
+		/// Timestamps
+		packet->dts = (pAMFData->GetPts() - 2) * m_FrameRate.second; // Offset by 2 to support B-Pictures
+		pAMFBuffer->GetProperty(L"Frame", &packet->pts);
+		{ /// Packet Priority & Keyframe
+			uint64_t pktType;
+			pAMFData->GetProperty(AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE, &pktType);
+
+			switch ((AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_ENUM)pktType) {
+				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_IDR://
+					packet->keyframe = true;				// IDR-Frames are Key-Frames that contain a lot of information.
+					packet->priority = 3;					// Highest priority, always continue streaming with these.
+					//packet->drop_priority = 3;				// Dropped IDR-Frames can only be replaced by the next IDR-Frame.
+					break;
+				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_I:	// I-Frames need only a previous I- or IDR-Frame.
+					packet->priority = 2;					// I- and IDR-Frames will most likely be present.
+				//	packet->drop_priority = 2;				// So we can continue with a I-Frame when streaming.
+				//	break;
+				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_P:	// P-Frames need either a previous P-, I- or IDR-Frame.
+					packet->priority = 1;					// We can safely assume that at least one of these is present.
+				//	packet->drop_priority = 1;				// So we can continue with a P-Frame when streaming.
+				//	break;
+				case AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_B:	// B-Frames need either a parent B-, P-, I- or IDR-Frame.
+					packet->priority = 0;					// We don't know if the last non-dropped frame was a B-Frame.
+				//	packet->drop_priority = 1;				// So require a P-Frame or better to continue streaming.
+				//	break;
+			}
+		}
+		*received_packet = true;
+
+		// Debug: Packet Information
+		std::vector<wchar_t> fileName(128);
+		mbstowcs(fileName.data(), __FILE__, fileName.size());
+		std::vector<wchar_t> functionName(128);
+		mbstowcs(functionName.data(), __FUNCTION__, functionName.size());
+		m_AMF->GetTrace()->TraceW(fileName.data(), __LINE__, AMF_TRACE_TRACE, L"Plugin::GetOutput", 4, L"Packet: Type(%lld), PTS(%4lld), DTS(%4lld), Size(%8lld)", (int64_t)packet->priority, (int64_t)packet->pts, (int64_t)packet->dts, (int64_t)packet->size);
+	}
+
+	return true;
+}
+
+bool Plugin::AMD::VCEEncoder::GetExtraData(uint8_t**& extra_data, size_t*& extra_data_size) {
+	if (!m_AMFContext || !m_AMFEncoder)
+		throw std::exception("<" __FUNCTION_NAME__ "> Called while not initialized.");
+
+	if (!m_Flag_IsStarted)
+		throw std::exception("<" __FUNCTION_NAME__ "> Called while not encoding.");
+
+	amf::AMFVariant var;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_EXTRADATA, &var);
+	if (res == AMF_OK && var.type == amf::AMF_VARIANT_INTERFACE) {
+		amf::AMFBufferPtr buf(var.pInterface);
+
+		*extra_data_size = buf->GetSize();
+		m_ExtraDataBuffer.resize(*extra_data_size);
+		std::memcpy(m_ExtraDataBuffer.data(), buf->GetNative(), *extra_data_size);
+		*extra_data = m_ExtraDataBuffer.data();
+
+		return true;
+	}
+	return false;
+}
+
+void Plugin::AMD::VCEEncoder::GetVideoInfo(struct video_scale_info*& vsi) {
+	if (!m_AMFContext || !m_AMFEncoder)
+		throw std::exception("<" __FUNCTION_NAME__ "> Called while not initialized.");
+
+	if (!m_Flag_IsStarted)
+		throw std::exception("<" __FUNCTION_NAME__ "> Called while not encoding.");
+
+	switch (m_SurfaceFormat) {
+		// 4:2:0 Formats
+		case VCEColorFormat_NV12:
+			vsi->format = VIDEO_FORMAT_NV12;
+			break;
+		case VCEColorFormat_I420:
+			vsi->format = VIDEO_FORMAT_I420;
+			break;
+		// 4:2:2 Formats
+		case VCEColorFormat_YUY2:
+			vsi->format = VIDEO_FORMAT_YUY2;
+			break;
+		// Uncompressed
+		case VCEColorFormat_RGBA:
+			vsi->format = VIDEO_FORMAT_RGBA;
+			break;
+		case VCEColorFormat_BGRA:
+			vsi->format = VIDEO_FORMAT_BGRA;
+			break;
+		// Other
+		case VCEColorFormat_GRAY:
+			vsi->format = VIDEO_FORMAT_Y800;
+			break;
+	}
+
+	// AMF requires Partial Range for some reason.
+	if (this->IsFullColorRangeEnabled()) { // Only use Full range if actually enabled.
+		vsi->range = VIDEO_RANGE_FULL;
+	} else {
+		vsi->range = VIDEO_RANGE_PARTIAL;
+	}
+	// Also Colorspace is automatic, see: https://github.com/GPUOpen-LibrariesAndSDKs/AMF/issues/6#issuecomment-243473568
+	//if (this->GetFrameSize().second <= 780) { // SD content is .601, HD content is .709
+	//	vsi->colorspace = VIDEO_CS_601;
+	//} else {
+	//	vsi->colorspace = VIDEO_CS_709;
+	//}
+}
+
+void Plugin::AMD::VCEEncoder::InputThreadLogic() {	// Thread Loop that handles Surface Submission
+	// Assign Thread Name
+	static const char* __threadName = "enc-amf Input Thread";
+	SetThreadName(__threadName);
+
+	// Core Loop
+	std::unique_lock<std::mutex> lock(m_Input.mutex);
+	uint32_t repeatSurfaceSubmission = 0;
+	do {
+		m_Input.condvar.wait(lock);
+
+		// Assign Thread Name
+		static const char* __threadName = "enc-amf Input Thread";
+		SetThreadName(__threadName);
+
+		// Skip to check if isStarted is false.
+		if (!m_Flag_IsStarted)
+			continue;
+
+		// Dequeue Surface
+		amf::AMFSurfacePtr surface;
+		{
+			std::unique_lock<std::mutex> qlock(m_Input.queuemutex);
+			if (m_Input.queue.size() == 0)
+				continue; // Queue is empty, 
+			surface = m_Input.queue.front();
+		}
+
+		/// Convert Frame
+		AMF_RESULT res;
+		amf::AMFDataPtr outbuf;
+
+		res = m_AMFConverter->SubmitInput(surface);
+		if (res != AMF_OK)
+			ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Unable to submit Frame to Converter, error %ls (code %ld).", res);
+		res = m_AMFConverter->QueryOutput(&outbuf);
+		if (res != AMF_OK)
+			ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Unable to retrieve Frame from Converter, error %ls (code %ld).", res);
+
+		/// Submit to AMF
+		res = m_AMFEncoder->SubmitInput(outbuf);
+		if (res == AMF_OK) {
+			m_Flag_FirstFrameSubmitted = true;
+
+			{ // Remove Surface from Queue
+				std::unique_lock<std::mutex> qlock(m_Input.queuemutex);
+				m_Input.queue.pop();
+			}
+
+			// Reset AMF_INPUT_FULL retries.
+			repeatSurfaceSubmission = 0;
+
+			// Continue with next Surface.
+			m_Input.condvar.notify_all();
+		} else if (res == AMF_INPUT_FULL) {
+			m_Output.condvar.notify_all();
+			if (repeatSurfaceSubmission < 5) {
+				repeatSurfaceSubmission++;
+
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
+				m_Input.condvar.notify_all();
+			}
+		} else if (res == AMF_EOF) {
+			// This should never happen, but on the off-chance that it does, just straight up leave the loop.
+			break;
+		} else {
+			// Unknown, unexpected return code.
+			std::vector<char> msgBuf(128);
+			FormatTextWithAMFError(&msgBuf, "%ls (code %d)", Plugin::AMD::AMF::GetInstance()->GetTrace()->GetResultText(res), res);
+			AMF_LOG_WARNING("<" __FUNCTION_NAME__ "> SubmitInput failed with error %s.", msgBuf.data());
+		}
+	} while (m_Flag_IsStarted);
+}
+
+void Plugin::AMD::VCEEncoder::OutputThreadLogic() {	// Thread Loop that handles Querying
+	// Assign Thread Name
+	static const char* __threadName = "enc-amf Output Thread";
+	SetThreadName(__threadName);
+
+	// Core Loop
+	std::unique_lock<std::mutex> lock(m_Output.mutex);
+	do {
+		m_Output.condvar.wait(lock);
+
+		// Assign Thread Name
+		static const char* __threadName = "enc-amf Output Thread";
+		SetThreadName(__threadName);
+
+		// Skip to check if isStarted is false.
+		if (!m_Flag_IsStarted)
+			continue;
+
+		amf::AMFDataPtr pData = amf::AMFDataPtr();
+		AMF_RESULT res = m_AMFEncoder->QueryOutput(&pData);
+		if (res == AMF_OK) {
+			m_Flag_FirstFrameReceived = true;
+
+			{ // Queue
+				std::unique_lock<std::mutex> qlock(m_Output.queuemutex);
+				m_Output.queue.push(pData);
+			}
+
+			// Continue querying until nothing is left.
+			m_Output.condvar.notify_all();
+		} else if (res == AMF_REPEAT) {
+			m_Input.condvar.notify_all();
+		} else if (res == AMF_EOF) {
+			// This should never happen, but on the off-chance that it does, just straight up leave the loop.
+			break;
+		} else {
+			// Unknown, unexpected return code.
+			std::vector<char> msgBuf(128);
+			FormatTextWithAMFError(&msgBuf, "%s (code %d)", res);
+			AMF_LOG_WARNING("<" __FUNCTION_NAME__ "> QueryOutput failed with error %s.", msgBuf.data());
+		}
+	} while (m_Flag_IsStarted);
+}
+
+amf::AMFSurfacePtr Plugin::AMD::VCEEncoder::CreateSurfaceFromFrame(struct encoder_frame*& frame) {
+	AMF_RESULT res = AMF_UNEXPECTED;
+	amf::AMFSurfacePtr pSurface = nullptr;
+	if (m_UseOpenCL) {
+		amf_size l_origin[] = { 0, 0, 0 };
+		amf_size l_size0[] = { m_FrameSize.first, m_FrameSize.second, 1 };
+		amf_size l_size1[] = { m_FrameSize.first >> 1, m_FrameSize.second >> 1, 1 };
+
+		res = m_AMFContext->AllocSurface(Utility::MemoryTypeAsAMF(m_MemoryType),
+			Utility::SurfaceFormatAsAMF(m_SurfaceFormat),
+			m_FrameSize.first, m_FrameSize.second, &pSurface);
+		if (res != AMF_OK) // Unable to create Surface
+			ThrowExceptionWithAMFError("AllocSurface failed with error %ls (code %d).", res);
+
+		amf::AMFComputeSyncPointPtr pSyncPoint;
+		m_AMFCompute->PutSyncPoint(&pSyncPoint);
+		pSurface->Convert(amf::AMF_MEMORY_OPENCL);
+		m_AMFCompute->CopyPlaneFromHost(frame->data[0], l_origin, l_size0, frame->linesize[0], pSurface->GetPlaneAt(0), false);
+		m_AMFCompute->CopyPlaneFromHost(frame->data[1], l_origin, l_size1, frame->linesize[1], pSurface->GetPlaneAt(1), false);
+		m_AMFCompute->FinishQueue();
+		pSurface->Convert(Utility::MemoryTypeAsAMF(m_MemoryType));
+		pSyncPoint->Wait();
+	} else {
+		res = m_AMFContext->AllocSurface(amf::AMF_MEMORY_HOST, Utility::SurfaceFormatAsAMF(m_SurfaceFormat),
+			m_FrameSize.first, m_FrameSize.second, &pSurface);
+		if (res != AMF_OK) // Unable to create Surface
+			ThrowExceptionWithAMFError("AllocSurface failed with error %ls (code %d).", res);
+
+		size_t planeCount = pSurface->GetPlanesCount();
+		for (uint8_t i = 0; i < planeCount; i++) {
+			amf::AMFPlanePtr plane = pSurface->GetPlaneAt(i);
+			void* plane_nat = plane->GetNative();
+			int32_t height = plane->GetHeight();
+			int32_t hpitch = plane->GetHPitch();
+
+			for (int32_t py = 0; py < height; py++) {
+				int32_t plane_off = py * hpitch;
+				int32_t frame_off = py * frame->linesize[i];
+				std::memcpy(static_cast<void*>(static_cast<uint8_t*>(plane_nat) + plane_off), static_cast<void*>(frame->data[i] + frame_off), frame->linesize[i]);
+			}
+		}
+
+		// Convert to AMF native type.
+		pSurface->Convert(Utility::MemoryTypeAsAMF(m_MemoryType));
+	}
+
+	return pSurface;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// AMF Properties
+//////////////////////////////////////////////////////////////////////////
+
+void Plugin::AMD::VCEEncoder::LogProperties() {
+	AMF_LOG_INFO("-- AMD Advanced Media Framework VCE Encoder --");
+	AMF_LOG_INFO("Initialization Parameters: ");
+	AMF_LOG_INFO(" Memory Type: %s", Utility::MemoryTypeAsString(m_MemoryType));
+	if (m_MemoryType != VCEMemoryType_Host) {
+		AMF_LOG_INFO(" Device: %s", m_APIDevice->GetDevice().Name.c_str());
+		AMF_LOG_INFO(" OpenCL: %s", m_UseOpenCL ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_INFO(" Surface Format: %s", Utility::SurfaceFormatAsString(m_SurfaceFormat));
+	try { AMF_LOG_INFO(" Color Profile: %s", this->GetColorProfile() == VCEColorProfile_709 ? "709" : "601"); } catch (...) {}
+	try { AMF_LOG_INFO(" Color Range: %s", this->IsFullColorRangeEnabled() ? "Full" : "Partial"); } catch (...) {}
+	AMF_LOG_INFO("Static Parameters: ");
+	AMF_LOG_INFO(" Usage: %s", Utility::UsageAsString(this->GetUsage()));
+	AMF_LOG_INFO(" Profile: %s %d.%d", Utility::ProfileAsString(this->GetProfile()), this->GetProfileLevel() / 10, this->GetProfileLevel() % 10);
+	AMF_LOG_INFO(" Maximum Long-Term Reference Frames: %d", this->GetMaximumLongTermReferenceFrames());
+	AMF_LOG_INFO(" Frame Size: %dx%d", this->GetFrameSize().first, this->GetFrameSize().second);
+	AMF_LOG_INFO(" Frame Rate: %d/%d", this->GetFrameRate().first, this->GetFrameRate().second);
+	AMF_LOG_INFO(" Quality Preset: %s", Utility::QualityPresetAsString(this->GetQualityPreset()));
+	AMF_LOG_INFO(" Scan Type: %s", this->GetScanType() == VCEScanType_Progressive ? "Progressive" : "Interlaced");
+	try { AMF_LOG_INFO(" Coding Type: %s", Utility::CodingTypeAsString(this->GetCodingType())); } catch (...) {}
+	AMF_LOG_INFO("Rate Control Parameters: ");
+	AMF_LOG_INFO(" Method: %s", Utility::RateControlMethodAsString(this->GetRateControlMethod()));
+	AMF_LOG_INFO(" Bitrate: ");
+	AMF_LOG_INFO(" Target: %d bits", this->GetTargetBitrate());
+	AMF_LOG_INFO(" Peak: %d bits", this->GetPeakBitrate());
+	AMF_LOG_INFO(" Quantization Parameter: ");
+	AMF_LOG_INFO(" Minimum: %d", this->GetMinimumQP());
+	AMF_LOG_INFO(" Maximum: %d", this->GetMaximumQP());
+	AMF_LOG_INFO(" I-Frame: %d", this->GetIFrameQP());
+	AMF_LOG_INFO(" P-Frame: %d", this->GetPFrameQP());
+	if (VCECapabilities::GetInstance()->GetDeviceCaps(m_APIDevice->GetDevice(), VCEEncoderType_AVC).supportsBFrames) {
+		try { AMF_LOG_INFO(" B-Frame: %d", this->GetBFrameQP()); } catch (...) {}
+		try { AMF_LOG_INFO(" B-Picture Delta QP: %d", this->GetBPictureDeltaQP()); } catch (...) {}
+		try { AMF_LOG_INFO(" Reference B-Picture Delta QP: %d", this->GetReferenceBPictureDeltaQP()); } catch (...) {}
+	} else {
+		AMF_LOG_INFO(" B-Frame: N/A");
+		AMF_LOG_INFO(" B-Picture Delta QP: N/A");
+		AMF_LOG_INFO(" Reference B-Picture Delta QP: N/A");
+	}
+	AMF_LOG_INFO(" VBV Buffer: ");
+	AMF_LOG_INFO(" Size: %d bits", this->GetVBVBufferSize());
+	AMF_LOG_INFO(" Initial Fullness: %f%%", this->GetInitialVBVBufferFullness() * 100.0);
+	AMF_LOG_INFO(" Flags: ");
+	AMF_LOG_INFO(" Filler Data: %s", this->IsFillerDataEnabled() ? "Enabled" : "Disabled");
+	AMF_LOG_INFO(" Frame Skipping: %s", this->IsFrameSkippingEnabled() ? "Enabled" : "Disabled");
+	AMF_LOG_INFO(" Enforce HRD Restrictions: %s", this->IsEnforceHRDRestrictionsEnabled() ? "Enabled" : "Disabled");
+	AMF_LOG_INFO(" Maximum Access Unit Size: %d bits", this->GetMaximumAccessUnitSize());
+	AMF_LOG_INFO("Picture Control Parameters: ");
+	AMF_LOG_INFO(" IDR Period: %d frames", this->GetIDRPeriod());
+	AMF_LOG_INFO(" Header Insertion Spacing: %d frames", this->GetHeaderInsertionSpacing());
+	AMF_LOG_INFO(" Deblocking Filter: %s", this->IsDeblockingFilterEnabled() ? "Enabled" : "Disabled");
+	if (VCECapabilities::GetInstance()->GetDeviceCaps(m_APIDevice->GetDevice(), VCEEncoderType_AVC).supportsBFrames) {
+		AMF_LOG_INFO(" B-Picture Pattern: %d", this->GetBPicturePattern());
+		AMF_LOG_INFO(" B-Picture Reference: %s", this->IsBPictureReferenceEnabled() ? "Enabled" : "Disabled");
+	} else {
+		AMF_LOG_INFO(" B-Picture Pattern: N/A");
+		AMF_LOG_INFO(" B-Picture Reference: N/A");
+	}
+	AMF_LOG_INFO(" Intra-Refresh MBs Number per Slot: %d", this->GetIntraRefreshMBsNumberPerSlot());
+	AMF_LOG_INFO(" Slices Per Frame: %d", this->GetSlicesPerFrame());
+	AMF_LOG_INFO("Motion Estimation Parameters: ");
+	AMF_LOG_INFO(" Half Pixel: %s", this->IsHalfPixelMotionEstimationEnabled() ? "Enabled" : "Disabled");
+	AMF_LOG_INFO(" Quarter Pixel: %s", this->IsQuarterPixelMotionEstimationEnabled() ? "Enabled" : "Disabled");
+	AMF_LOG_INFO("Experimental Parameters: ");
+	try { AMF_LOG_INFO(" Wait For Task: %s", this->IsWaitForTaskEnabled() ? "Enabled" : "Disabled"); } catch (...) {}
+	try { AMF_LOG_INFO(" Aspect Ratio: %d:%d", this->GetAspectRatio().first, this->GetAspectRatio().second); } catch (...) {}
+	try { AMF_LOG_INFO(" MaxNumRefFrames: %d", this->GetMaximumNumberOfReferenceFrames()); } catch (...) {}
+	try { AMF_LOG_INFO(" MaxMBPerSec: %d", this->GetMaxMBPerSec()); } catch (...) {}
+	try { AMF_LOG_INFO(" Pre-Analysis Pass: %s", this->IsRateControlPreanalysisEnabled() ? "Enabled" : "Disabled"); } catch (...) {}
+	//try { AMF_LOG_INFO(" Quality Enhancement Mode: %s", Utility::QualityEnhancementModeAsString(this->GetQualityEnhancementMode())); } catch (...) {}
+	try { AMF_LOG_INFO(" VBAQ: %s", this->IsVBAQEnabled() ? "Enabled" : "Disabled"); } catch (...) {}
+
+	Plugin::AMD::VCECapabilities::ReportDeviceCapabilities(m_APIDevice->GetDevice());
+
+	printDebugInfo(m_AMFEncoder);
+	AMF_LOG_INFO("-- AMD Advanced Media Framework VCE Encoder --");
+}
+
+/************************************************************************/
+/* Static Properties */
+/************************************************************************/
+
+void Plugin::AMD::VCEEncoder::SetUsage(VCEUsage usage) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_USAGE,
+		(uint32_t)Utility::UsageAsAMF(usage));
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).",
+			res, Utility::UsageAsString(usage));
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", Utility::UsageAsString(usage));
+}
+
+Plugin::AMD::VCEUsage Plugin::AMD::VCEEncoder::GetUsage() {
+	uint32_t usage;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_USAGE, &usage);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.",
+		Utility::UsageAsString(Utility::UsageFromAMF(usage)));
+	return Utility::UsageFromAMF(usage);
+}
+
+void Plugin::AMD::VCEEncoder::SetQualityPreset(VCEQualityPreset preset) {
+	static AMF_VIDEO_ENCODER_QUALITY_PRESET_ENUM CustomToAMF[] = {
+		AMF_VIDEO_ENCODER_QUALITY_PRESET_SPEED,
+		AMF_VIDEO_ENCODER_QUALITY_PRESET_BALANCED,
+		AMF_VIDEO_ENCODER_QUALITY_PRESET_QUALITY,
+	};
+	static char* CustomToName[] = {
+		"Speed",
+		"Balanced",
+		"Quality",
+	};
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QUALITY_PRESET, (uint32_t)CustomToAMF[preset]);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, CustomToName[preset]);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", CustomToName[preset]);
+}
+
+Plugin::AMD::VCEQualityPreset Plugin::AMD::VCEEncoder::GetQualityPreset() {
+	static VCEQualityPreset AMFToCustom[] = {
+		VCEQualityPreset_Balanced,
+		VCEQualityPreset_Speed,
+		VCEQualityPreset_Quality,
+	};
+	static char* CustomToName[] = {
+		"Speed",
+		"Balanced",
+		"Quality",
+	};
+
+	uint32_t preset;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QUALITY_PRESET, &preset);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", CustomToName[AMFToCustom[preset]]);
+	return AMFToCustom[preset];
+}
+
+void Plugin::AMD::VCEEncoder::SetProfile(VCEProfile profile) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_PROFILE, (uint32_t)profile);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, Utility::ProfileAsString(profile));
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", Utility::ProfileAsString(profile));
+}
+
+Plugin::AMD::VCEProfile Plugin::AMD::VCEEncoder::GetProfile() {
+	uint32_t profile;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_PROFILE, &profile);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", Utility::ProfileAsString((VCEProfile)profile));
+	return (VCEProfile)profile;
+}
+
+void Plugin::AMD::VCEEncoder::SetProfileLevel(VCEProfileLevel level) {
+	// Automatic Detection
+	if (level == VCEProfileLevel_Automatic) {
+		auto frameSize = this->GetFrameSize();
+		auto frameRate = this->GetFrameRate();
+		level = Plugin::Utility::GetMinimumProfileLevel(frameSize, frameRate);
+	}
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_PROFILE_LEVEL, (uint32_t)level);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, level);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", level);
+}
+
+Plugin::AMD::VCEProfileLevel Plugin::AMD::VCEEncoder::GetProfileLevel() {
+	uint32_t profileLevel;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_PROFILE_LEVEL, &profileLevel);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", profileLevel);
+	return (VCEProfileLevel)(profileLevel);
+}
+
+void Plugin::AMD::VCEEncoder::SetMaximumLongTermReferenceFrames(uint32_t maximumLTRFrames) {
+	// Clamp Parameter Value
+	maximumLTRFrames = max(min(maximumLTRFrames, 2), 0);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MAX_LTR_FRAMES, (uint32_t)maximumLTRFrames);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, maximumLTRFrames);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", maximumLTRFrames);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetMaximumLongTermReferenceFrames() {
+	uint32_t maximumLTRFrames;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MAX_LTR_FRAMES, &maximumLTRFrames);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", maximumLTRFrames);
+	return maximumLTRFrames;
+}
+
+void Plugin::AMD::VCEEncoder::SetCodingType(VCECodingType type) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(L"CABACEnable", type);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, Utility::CodingTypeAsString(type));
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", Utility::CodingTypeAsString(type));
+}
+
+VCECodingType Plugin::AMD::VCEEncoder::GetCodingType() {
+	uint64_t type;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"CABACEnable", &type);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", Utility::CodingTypeAsString((VCECodingType)type));
+	return (VCECodingType)type;
+}
+
+/************************************************************************/
+/* Frame Properties */
+/************************************************************************/
+
+void Plugin::AMD::VCEEncoder::SetColorProfile(VCEColorProfile profile) {
+	AMF_VIDEO_CONVERTER_COLOR_PROFILE_ENUM pluginToAMF[] = {
+		AMF_VIDEO_CONVERTER_COLOR_PROFILE_601,
+		AMF_VIDEO_CONVERTER_COLOR_PROFILE_709,
+		AMF_VIDEO_CONVERTER_COLOR_PROFILE_2020,
+	};
+	const char* pluginToString[] = {
+		"601",
+		"709",
+		"2020",
+	};
+
+	AMF_RESULT res = m_AMFConverter->SetProperty(AMF_VIDEO_CONVERTER_COLOR_PROFILE,
+		pluginToAMF[profile]);
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Unable to set Color Profile, error %ls (code %ld).", res);
+	m_ColorProfile = profile;
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", pluginToString[profile]);
+}
+
+Plugin::AMD::VCEColorProfile Plugin::AMD::VCEEncoder::GetColorProfile() {
+	return m_ColorProfile;
+}
+
+void Plugin::AMD::VCEEncoder::SetFullColorRangeEnabled(bool enabled) {
+	// Info from Mikhail:
+	// - Name may change in the future
+	// - Use GetProperty or GetPropertyDescription to test for older or newer drivers.
+	const wchar_t* names[] = {
+		L"NominalRange", // 16.11.2 and below.
+		L"FullRange"
+	};
+
+	bool enabledTest;
+	AMF_RESULT res = AMF_INVALID_ARG;
+	for (size_t i = 0; i < 2; i++) {
+		if (m_AMFEncoder->GetProperty(names[i], &enabledTest) == AMF_OK) {
+			m_AMFConverter->SetProperty(names[i], enabled);
+			res = m_AMFEncoder->SetProperty(names[i], enabled);
+			break;
+		}
+	}
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsFullColorRangeEnabled() {
+	// Info from Mikhail:
+	// - Name may change in the future
+	// - Use GetProperty or GetPropertyDescription to test for older or newer drivers.
+	const wchar_t* names[] = {
+		L"NominalRange", // 16.11.2 and below.
+		L"FullRange"
+	};
+
+	bool enabled;
+	AMF_RESULT res = AMF_INVALID_ARG;
+	for (size_t i = 0; i < 2; i++) {
+		res = m_AMFEncoder->GetProperty(names[i], &enabled);
+		if (res == AMF_OK) {
+			break;
+		}
+	}
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetScanType(VCEScanType scanType) {
+	static AMF_VIDEO_ENCODER_SCANTYPE_ENUM CustomToAMF[] = {
+		AMF_VIDEO_ENCODER_SCANTYPE_PROGRESSIVE,
+		AMF_VIDEO_ENCODER_SCANTYPE_INTERLACED,
+	};
+	static char* CustomToName[] = {
+		"Progressive",
+		"Interlaced",
+	};
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_SCANTYPE, (uint32_t)CustomToAMF[scanType]);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, CustomToName[scanType]);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", CustomToName[scanType]);
+}
+
+Plugin::AMD::VCEScanType Plugin::AMD::VCEEncoder::GetScanType() {
+	static char* CustomToName[] = {
+		"Progressive",
+		"Interlaced",
+	};
+
+	uint32_t scanType;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_SCANTYPE, &scanType);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", CustomToName[scanType]);
+	return (Plugin::AMD::VCEScanType)scanType;
+}
+
+void Plugin::AMD::VCEEncoder::SetFrameSize(uint32_t width, uint32_t height) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_FRAMESIZE, ::AMFConstructSize(width, height));
+	if (res != AMF_OK) {
+		std::vector<char> msgBuf(128);
+		sprintf(msgBuf.data(), "%dx%d", width, height);
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, msgBuf.data());
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %dx%d.", width, height);
+	m_FrameSize.first = width;
+	m_FrameSize.second = height;
+
+	if (this->GetProfileLevel() == VCEProfileLevel_Automatic)
+		this->SetProfileLevel(VCEProfileLevel_Automatic);
+}
+
+std::pair<uint32_t, uint32_t> Plugin::AMD::VCEEncoder::GetFrameSize() {
+	AMFSize frameSize;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_FRAMESIZE, &frameSize);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %dx%d.", frameSize.width, frameSize.height);
+	m_FrameSize.first = frameSize.width;
+	m_FrameSize.second = frameSize.height;
+
+	if (this->GetProfileLevel() == VCEProfileLevel_Automatic)
+		this->SetProfileLevel(VCEProfileLevel_Automatic);
+
+	return std::pair<uint32_t, uint32_t>(m_FrameSize);
+}
+
+void Plugin::AMD::VCEEncoder::SetFrameRate(uint32_t num, uint32_t den) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_FRAMERATE, ::AMFConstructRate(num, den));
+	if (res != AMF_OK) {
+		std::vector<char> msgBuf;
+		sprintf(msgBuf.data(), "%d/%d", num, den);
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, msgBuf.data());
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d/%d.", num, den);
+	m_FrameRate.first = num;
+	m_FrameRate.second = den;
+	m_FrameRateDivisor = (double_t)m_FrameRate.first / (double_t)m_FrameRate.second;
+	m_FrameRateReverseDivisor = ((double_t)m_FrameRate.second / (double_t)m_FrameRate.first);
+	m_InputQueueLimit = (uint32_t)ceil(m_FrameRateDivisor * 3);
+
+	if (this->GetProfileLevel() == VCEProfileLevel_Automatic)
+		this->SetProfileLevel(VCEProfileLevel_Automatic);
+}
+
+std::pair<uint32_t, uint32_t> Plugin::AMD::VCEEncoder::GetFrameRate() {
+	AMFRate frameRate;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_FRAMERATE, &frameRate);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d/%d.", frameRate.num, frameRate.den);
+	m_FrameRate.first = frameRate.num;
+	m_FrameRate.second = frameRate.den;
+	m_FrameRateDivisor = (double_t)frameRate.num / (double_t)frameRate.den;
+	m_InputQueueLimit = (uint32_t)ceil(m_FrameRateDivisor * 3);
+
+	if (this->GetProfileLevel() == VCEProfileLevel_Automatic)
+		this->SetProfileLevel(VCEProfileLevel_Automatic);
+
+	return std::pair<uint32_t, uint32_t>(m_FrameRate);
+}
+
+/************************************************************************/
+/* Rate Control Properties */
+/************************************************************************/
+
+void Plugin::AMD::VCEEncoder::SetRateControlMethod(VCERateControlMethod method) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD,
+		(uint64_t)Utility::RateControlMethodAsAMF(method));
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).",
+			res, Utility::RateControlMethodAsString(method));
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.",
+		Utility::RateControlMethodAsString(method));
+}
+
+Plugin::AMD::VCERateControlMethod Plugin::AMD::VCEEncoder::GetRateControlMethod() {
+	uint32_t method;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD, &method);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.",
+		Utility::RateControlMethodAsString(Utility::RateControlMethodFromAMF(method)));
+	return Utility::RateControlMethodFromAMF(method);
+}
+
+void Plugin::AMD::VCEEncoder::SetTargetBitrate(uint32_t bitrate) {
+	// Clamp Value
+	bitrate = clamp(bitrate, 10000,
+		Plugin::AMD::VCECapabilities::GetInstance()->GetDeviceCaps(m_APIDevice->GetDevice(), VCEEncoderType_AVC).maxBitrate);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_TARGET_BITRATE, bitrate);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d bits failed with error %ls (code %d).", res, bitrate);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d bits.", bitrate);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetTargetBitrate() {
+	uint32_t bitrate;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_TARGET_BITRATE, &bitrate);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d bits.", bitrate);
+	return bitrate;
+}
+
+void Plugin::AMD::VCEEncoder::SetPeakBitrate(uint32_t bitrate) {
+	// Clamp Value
+	bitrate = clamp(bitrate, 10000,
+		Plugin::AMD::VCECapabilities::GetInstance()->GetDeviceCaps(m_APIDevice->GetDevice(), VCEEncoderType_AVC).maxBitrate);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_PEAK_BITRATE, (uint32_t)bitrate);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d bits failed with error %ls (code %d).", res, bitrate);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d bits.", bitrate);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetPeakBitrate() {
+	uint32_t bitrate;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_PEAK_BITRATE, &bitrate);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d bits.", bitrate);
+	return bitrate;
+}
+
+void Plugin::AMD::VCEEncoder::SetMinimumQP(uint8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, 0, 51);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MIN_QP, (uint32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+uint8_t Plugin::AMD::VCEEncoder::GetMinimumQP() {
+	uint32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MIN_QP, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (uint8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetMaximumQP(uint8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, 0, 51);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MAX_QP, (uint32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+uint8_t Plugin::AMD::VCEEncoder::GetMaximumQP() {
+	uint32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MAX_QP, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (uint8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetIFrameQP(uint8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, 0, 51);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QP_I, (uint32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+uint8_t Plugin::AMD::VCEEncoder::GetIFrameQP() {
+	uint32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QP_I, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (uint8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetPFrameQP(uint8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, 0, 51);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QP_P, (uint32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+uint8_t Plugin::AMD::VCEEncoder::GetPFrameQP() {
+	uint32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QP_P, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (uint8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetBFrameQP(uint8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, 0, 51);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_QP_B, (uint32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+uint8_t Plugin::AMD::VCEEncoder::GetBFrameQP() {
+	uint32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_QP_B, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (uint8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetBPictureDeltaQP(int8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, -10, 10);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_B_PIC_DELTA_QP, (int32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+int8_t Plugin::AMD::VCEEncoder::GetBPictureDeltaQP() {
+	int32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_B_PIC_DELTA_QP, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (int8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetReferenceBPictureDeltaQP(int8_t qp) {
+	// Clamp Value
+	qp = clamp(qp, -10, 10);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_REF_B_PIC_DELTA_QP, (int32_t)qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, qp);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", qp);
+}
+
+int8_t Plugin::AMD::VCEEncoder::GetReferenceBPictureDeltaQP() {
+	int32_t qp;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_REF_B_PIC_DELTA_QP, &qp);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", qp);
+	return (int8_t)qp;
+}
+
+void Plugin::AMD::VCEEncoder::SetVBVBufferSize(uint32_t size) {
+	// Clamp Value
+	size = clamp(size, 1000, 100000000); // 1kbit to 100mbit.
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_VBV_BUFFER_SIZE, (uint32_t)size);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d bits failed with error %ls (code %d).", res, size);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d bits.", size);
+}
+
+void Plugin::AMD::VCEEncoder::SetVBVBufferAutomatic(double_t strictness) {
+	uint32_t strictBitrate = 1000, looseBitrate = 100000000;
+
+	// Strict VBV Buffer Size = Bitrate / FPS
+	// Loose VBV Buffer Size = Bitrate
+
+	switch (this->GetRateControlMethod()) {
+		case VCERateControlMethod_ConstantBitrate:
+		case VCERateControlMethod_VariableBitrate_LatencyConstrained:
+			looseBitrate = this->GetTargetBitrate();
+			break;
+		case VCERateControlMethod_VariableBitrate_PeakConstrained:
+			looseBitrate = max(this->GetTargetBitrate(), this->GetPeakBitrate());
+			break;
+		case VCERateControlMethod_ConstantQP:
+			// When using Constant QP, one will have to pick a QP that is decent
+			// in both quality and bitrate. We can easily calculate both the QP
+			// required for an average bitrate and the average bitrate itself 
+			// with these formulas:
+			// BITRATE = ((1 - (QP / 51)) ^ 2) * ((Width * Height) * 1.5 * (FPSNumerator / FPSDenumerator))
+			// QP = (1 - sqrt(BITRATE / ((Width * Height) * 1.5 * (FPSNumerator / FPSDenumerator)))) * 51
+
+			auto frameSize = this->GetFrameSize();
+			auto frameRate = this->GetFrameRate();
+
+			double_t bitrate = frameSize.first * frameSize.second;
+			switch (this->m_SurfaceFormat) {
+				case VCEColorFormat_NV12:
+				case VCEColorFormat_I420:
+					bitrate *= 1.5;
+					break;
+				case VCEColorFormat_YUY2:
+					bitrate *= 4;
+					break;
+				case VCEColorFormat_BGRA:
+				case VCEColorFormat_RGBA:
+					bitrate *= 3;
+					break;
+				case VCEColorFormat_GRAY:
+					bitrate *= 1;
+					break;
+			}
+			bitrate *= frameRate.first / frameRate.second;
+
+			uint8_t qp_i, qp_p, qp_b;
+			qp_i = this->GetIFrameQP();
+			qp_p = this->GetPFrameQP();
+			try { qp_b = this->GetBFrameQP(); } catch (...) { qp_b = 51; }
+			double_t qp = 1 - ((double_t)(min(min(qp_i, qp_p), qp_b)) / 51.0);
+			qp = max(qp * qp, 0.001); // Needs to be at least 0.001.
+
+			looseBitrate = static_cast<uint32_t>(bitrate * qp);
+			break;
+	}
+	strictBitrate = static_cast<uint32_t>(looseBitrate * m_FrameRateReverseDivisor);
+
+	#define PI 3.14159265
+	double_t interpVal = (sin(max(min(strictness, 1.0), 0.0) * 90 * (PI / 180))); // sin curve?
+	uint32_t realBitrate = static_cast<uint32_t>(ceil((strictBitrate * interpVal) + (looseBitrate * (1.0 - interpVal))));
+	this->SetVBVBufferSize(realBitrate);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetVBVBufferSize() {
+	uint32_t size;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_VBV_BUFFER_SIZE, &size);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", size);
+	return size;
+}
+
+void Plugin::AMD::VCEEncoder::SetInitialVBVBufferFullness(double_t fullness) {
+	// Clamp Value
+	fullness = max(min(fullness, 1), 0); // 0 to 100 %
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_INITIAL_VBV_BUFFER_FULLNESS, (uint32_t)(fullness * 64));
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %f%% failed with error %ls (code %d).", res, fullness * 100);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %f%%.", fullness * 100);
+}
+
+double_t Plugin::AMD::VCEEncoder::GetInitialVBVBufferFullness() {
+	uint32_t vbvBufferFullness;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_INITIAL_VBV_BUFFER_FULLNESS, &vbvBufferFullness);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %f%%.", vbvBufferFullness / 64.0 * 100.0);
+	return ((double_t)vbvBufferFullness / 64.0);
+}
+
+void Plugin::AMD::VCEEncoder::SetMaximumAccessUnitSize(uint32_t size) {
+	// Clamp Value
+	size = max(min(size, 100000000), 0); // 1kbit to 100mbit.
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MAX_AU_SIZE, (uint32_t)size);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d bits failed with error %ls (code %d).", res, size);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d bits.", size);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetMaximumAccessUnitSize() {
+	uint32_t size;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MAX_AU_SIZE, &size);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", size);
+	return size;
+}
+
+void Plugin::AMD::VCEEncoder::SetFillerDataEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_FILLER_DATA_ENABLE, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsFillerDataEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_FILLER_DATA_ENABLE, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetFrameSkippingEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_SKIP_FRAME_ENABLE, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsFrameSkippingEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_RATE_CONTROL_SKIP_FRAME_ENABLE, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetEnforceHRDRestrictionsEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_ENFORCE_HRD, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsEnforceHRDRestrictionsEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_ENFORCE_HRD, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+/************************************************************************/
+/* Picture Control Properties */
+/************************************************************************/
+
+void Plugin::AMD::VCEEncoder::SetIDRPeriod(uint32_t period) {
+	// Clamp Value
+	period = max(min(period, m_FrameRate.second * 1000), 1); // 1-1000 so that OBS can actually quit.
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_IDR_PERIOD, (uint32_t)period);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, period);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", period);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetIDRPeriod() {
+	int32_t period;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_IDR_PERIOD, &period);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", period);
+	return period;
+}
+
+void Plugin::AMD::VCEEncoder::SetHeaderInsertionSpacing(uint32_t spacing) {
+	// Clamp Value
+	spacing = max(min(spacing, m_FrameRate.second * 1000), 0);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_HEADER_INSERTION_SPACING, (uint32_t)spacing);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, spacing);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", spacing);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetHeaderInsertionSpacing() {
+	int32_t headerInsertionSpacing;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_HEADER_INSERTION_SPACING, &headerInsertionSpacing);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", headerInsertionSpacing);
+	return headerInsertionSpacing;
+}
+
+void Plugin::AMD::VCEEncoder::SetBPicturePattern(VCEBPicturePattern pattern) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_B_PIC_PATTERN, (uint32_t)pattern);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, pattern);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", pattern);
+}
+
+Plugin::AMD::VCEBPicturePattern Plugin::AMD::VCEEncoder::GetBPicturePattern() {
+	uint32_t pattern;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_B_PIC_PATTERN, &pattern);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", pattern);
+	return (Plugin::AMD::VCEBPicturePattern)pattern;
+}
+
+void Plugin::AMD::VCEEncoder::SetBPictureReferenceEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_B_REFERENCE_ENABLE, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsBPictureReferenceEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_B_REFERENCE_ENABLE, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetDeblockingFilterEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_DE_BLOCKING_FILTER, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsDeblockingFilterEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_DE_BLOCKING_FILTER, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetSlicesPerFrame(uint32_t slices) {
+	slices = max(slices, 1);
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_SLICES_PER_FRAME, (uint32_t)slices);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, slices);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", slices);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetSlicesPerFrame() {
+	uint32_t slices;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_SLICES_PER_FRAME, &slices);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", slices);
+	return slices;
+}
+
+void Plugin::AMD::VCEEncoder::SetIntraRefreshMBsNumberPerSlot(uint32_t mbs) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_INTRA_REFRESH_NUM_MBS_PER_SLOT, (uint32_t)mbs);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, mbs);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", mbs);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetIntraRefreshMBsNumberPerSlot() {
+	int32_t mbs;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_INTRA_REFRESH_NUM_MBS_PER_SLOT, &mbs);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", mbs);
+	return mbs;
+}
+
+/************************************************************************/
+/* Miscellaneous Control Properties */
+/************************************************************************/
+
+void Plugin::AMD::VCEEncoder::SetHalfPixelMotionEstimationEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MOTION_HALF_PIXEL, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsHalfPixelMotionEstimationEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MOTION_HALF_PIXEL, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetQuarterPixelMotionEstimationEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(AMF_VIDEO_ENCODER_MOTION_QUARTERPIXEL, enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsQuarterPixelMotionEstimationEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(AMF_VIDEO_ENCODER_MOTION_QUARTERPIXEL, &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+/************************************************************************/
+/* Hidden Properties */
+/************************************************************************/
+
+void Plugin::AMD::VCEEncoder::SetGOPSize(uint32_t size) {
+	AMF_LOG_WARNING("Using unsupported SetGOPSize function. Unexpected behaviour may happen.");
+
+	AMF_RESULT res = m_AMFEncoder->SetProperty(L"GOPSize", (uint32_t)size);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, size);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", size);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetGOPSize() {
+	AMF_LOG_WARNING("Using unsupported GetGOPSize function. Unexpected behaviour may happen.");
+
+	uint32_t size;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"GOPSize", &size);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", size);
+	return size;
+}
+
+void Plugin::AMD::VCEEncoder::SetWaitForTaskEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(L"WaitForTask", enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsWaitForTaskEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"WaitForTask", &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}
+
+void Plugin::AMD::VCEEncoder::SetAspectRatio(uint32_t num, uint32_t den) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(L"AspectRatio", ::AMFConstructRate(num, den));
+	if (res != AMF_OK) {
+		std::vector<char> msgBuf;
+		sprintf(msgBuf.data(), "%d:%d", num, den);
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, msgBuf.data());
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d:%d.", num, den);
+}
+
+std::pair<uint32_t, uint32_t> Plugin::AMD::VCEEncoder::GetAspectRatio() {
+	AMFRate aspectRatio;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"AspectRatio", &aspectRatio);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d:%d.", aspectRatio.num, aspectRatio.den);
+	return std::pair<uint32_t, uint32_t>(aspectRatio.num, aspectRatio.den);
+}
+
+void Plugin::AMD::VCEEncoder::SetMaximumNumberOfReferenceFrames(uint32_t numFrames) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(L"MaxNumRefFrames", (uint32_t)numFrames);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %d failed with error %ls (code %d).", res, numFrames);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %d.", numFrames);
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetMaximumNumberOfReferenceFrames() {
+	uint32_t numFrames;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"MaxNumRefFrames", &numFrames);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", numFrames);
+	return numFrames;
+}
+
+uint32_t Plugin::AMD::VCEEncoder::GetMaxMBPerSec() {
+	uint32_t maxMBPerSec;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"MaxMBPerSec", &maxMBPerSec);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %d.", maxMBPerSec);
+	return maxMBPerSec;
+}
+
+void Plugin::AMD::VCEEncoder::SetVBAQEnabled(bool enabled) {
+
+}
+
+bool Plugin::AMD::VCEEncoder::IsVBAQEnabled() {
+	return false;
+}
+
+void Plugin::AMD::VCEEncoder::SetRateControlPreanalysisEnabled(bool enabled) {
+	AMF_RESULT res = m_AMFEncoder->SetProperty(L"RateControlPreanalysisEnable", enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Setting to %s failed with error %ls (code %d).", res, enabled ? "Enabled" : "Disabled");
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Set to %s.", enabled ? "Enabled" : "Disabled");
+}
+
+bool Plugin::AMD::VCEEncoder::IsRateControlPreanalysisEnabled() {
+	bool enabled;
+	AMF_RESULT res = m_AMFEncoder->GetProperty(L"RateControlPreanalysisEnable", &enabled);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<" __FUNCTION_NAME__ "> Failed with error %ls (code %d).", res);
+	}
+	AMF_LOG_DEBUG("<" __FUNCTION_NAME__ "> Value is %s.", enabled ? "Enabled" : "Disabled");
+	return enabled;
+}

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/amd-amf.cpp Added

@@ -0,0 +1,264 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <vector>
+#include <mutex>
+
+#include "amd-amf.h"
+#include "windows.h"
+
+// AMD AMF SDK
+#include "components\Component.h"
+#include "components\ComponentCaps.h"
+#include "components\VideoEncoderVCE.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+using namespace Plugin::AMD;
+
+class CustomWriter : public amf::AMFTraceWriter {
+	public:
+	virtual void Write(const wchar_t* scope, const wchar_t* message) override {
+		const wchar_t* realmsg = &(message[(33 + wcslen(scope) + 2)]); // Skip Time & Scope
+		size_t msgLen = wcslen(realmsg) - (sizeof(wchar_t));
+
+		blog(LOG_INFO, "[%ls] %.*ls", scope, msgLen, realmsg);
+	}
+
+	virtual void Flush() override {}
+
+	static std::shared_ptr<CustomWriter> GetInstance() {
+		static std::shared_ptr<CustomWriter> __instance = std::make_shared<CustomWriter>();
+		static std::mutex __mutex;
+
+		const std::lock_guard<std::mutex> lock(__mutex);
+		return __instance;
+	}
+};
+
+std::shared_ptr<Plugin::AMD::AMF> Plugin::AMD::AMF::GetInstance() {
+	static std::shared_ptr<AMF> __instance = std::make_shared<AMF>();
+	static std::mutex __mutex;
+
+	const std::lock_guard<std::mutex> lock(__mutex);
+	return __instance;
+}
+
+Plugin::AMD::AMF::AMF() {
+	AMF_RESULT res = AMF_OK;
+
+	// Initialize AMF Library
+	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Initializing...");
+
+	#pragma region Null Class Members
+	m_TimerPeriod = 0;
+	m_AMFVersion_Compiler = 0;
+	m_AMFVersion_Runtime = 0;
+	m_AMFModule = 0;
+
+	m_AMFFactory = nullptr;
+	m_AMFTrace = nullptr;
+	m_AMFDebug = nullptr;
+	AMFQueryVersion = nullptr;
+	AMFInit = nullptr;
+	#pragma endregion Null Class Members
+
+	/// Load AMF Runtime into Memory.
+	m_AMFModule = LoadLibraryW(AMF_DLL_NAME);
+	if (!m_AMFModule) {
+		DWORD error = GetLastError();
+		std::vector<char> buf(1024);
+		sprintf(buf.data(), "Unable to load '%ls', error code %ld.", AMF_DLL_NAME, error);
+		AMF_LOG_ERROR("%s", buf.data());
+		throw std::exception(buf.data(), error);
+	}
+	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Loaded '%ls'.", AMF_DLL_NAME);
+	#ifdef _WIN32 // Windows: Get Product Version
+	std::vector<char> verbuf(GetFileVersionInfoSizeW(AMF_DLL_NAME, nullptr));
+	GetFileVersionInfoW(AMF_DLL_NAME, 0, (DWORD)verbuf.size(), verbuf.data());
+
+	void* pBlock = verbuf.data();
+
+	// Read the list of languages and code pages.
+	struct LANGANDCODEPAGE {
+		WORD wLanguage;
+		WORD wCodePage;
+	} *lpTranslate;
+	UINT cbTranslate = sizeof(LANGANDCODEPAGE);
+
+	VerQueryValueA(pBlock, "\\VarFileInfo\\Translation", (LPVOID*)&lpTranslate, &cbTranslate);
+
+	std::vector<char> buf(1024);
+	sprintf(buf.data(), "%s%04x%04x%s",
+		"\\StringFileInfo\\",
+		lpTranslate[0].wLanguage,
+		lpTranslate[0].wCodePage,
+		"\\ProductVersion");
+
+	// Retrieve file description for language and code page "i". 
+	void* lpBuffer;
+	uint32_t dwBytes;
+	VerQueryValueA(pBlock, buf.data(), &lpBuffer, &dwBytes);
+
+	AMF_LOG_INFO("Runtime Library is on Version %.*s.", dwBytes, lpBuffer);
+	#endif _WIN32 // Windows: Get Product Version
+
+	/// Find Function for Querying AMF Version.
+	#pragma region Query AMF Runtime Version
+	AMFQueryVersion = (AMFQueryVersion_Fn)GetProcAddress(m_AMFModule, AMF_QUERY_VERSION_FUNCTION_NAME);
+	if (!AMFQueryVersion) {
+		DWORD error = GetLastError();
+		std::vector<char> buf(1024);
+		sprintf(buf.data(), "<Plugin::AMD::AMF::AMF> Finding Address of Function '%s' failed with error code %ld.", AMF_QUERY_VERSION_FUNCTION_NAME, error);
+		AMF_LOG_ERROR("%s", buf.data());
+		throw std::exception(buf.data(), error);
+	}
+	/// Query Runtime Version
+	m_AMFVersion_Compiler = AMF_FULL_VERSION;
+	res = AMFQueryVersion(&m_AMFVersion_Runtime);
+	if (res != AMF_OK)
+		ThrowExceptionWithAMFError("<Plugin::AMD::AMF::AMF> Querying Version failed with error %ls (code %ld).", res);
+	/// Log some Information for Supporters.
+	AMF_LOG_INFO("Runtime is on Version %d.%d.%d.%d, compiled against Version %d.%d.%d.%d.",
+		(uint16_t)((m_AMFVersion_Runtime >> 48ull) & 0xFFFF),
+		(uint16_t)((m_AMFVersion_Runtime >> 32ull) & 0xFFFF),
+		(uint16_t)((m_AMFVersion_Runtime >> 16ull) & 0xFFFF),
+		(uint16_t)((m_AMFVersion_Runtime & 0xFFFF)),
+		(uint16_t)((m_AMFVersion_Compiler >> 48ull) & 0xFFFF),
+		(uint16_t)((m_AMFVersion_Compiler >> 32ull) & 0xFFFF),
+		(uint16_t)((m_AMFVersion_Compiler >> 16ull) & 0xFFFF),
+		(uint16_t)((m_AMFVersion_Compiler & 0xFFFF)));
+	#pragma endregion Query AMF Runtime Version
+
+		/// Find Function for Initializing AMF.
+	AMFInit = (AMFInit_Fn)GetProcAddress(m_AMFModule, AMF_INIT_FUNCTION_NAME);
+	if (!AMFInit) {
+		DWORD error = GetLastError();
+		std::vector<char> buf(1024);
+		sprintf(buf.data(), "<Plugin::AMD::AMF::AMF> Finding Address of Function '%s' failed with error code %ld.", AMF_INIT_FUNCTION_NAME, error);
+		AMF_LOG_ERROR("%s", buf.data());
+		throw std::exception(buf.data(), error);
+	} else {
+		res = AMFInit(m_AMFVersion_Runtime, &m_AMFFactory);
+		if (res != AMF_OK)
+			ThrowExceptionWithAMFError("<Plugin::AMD::AMF::AMF> Initializing AMF Library failed with error %ls (code %ld).", res);
+	}
+	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> AMF Library initialized.");
+
+	/// Retrieve Trace Object.
+	res = m_AMFFactory->GetTrace(&m_AMFTrace);
+	if (res != AMF_OK) {
+		ThrowExceptionWithAMFError("<Plugin::AMD::AMF::AMF> Retrieving Trace object failed with error %ls (code %ld).", res);
+	}
+
+	/// Retrieve Debug Object.
+	res = m_AMFFactory->GetDebug(&m_AMFDebug);
+	if (res != AMF_OK) {
+		AMF_LOG_ERROR("<Plugin::AMD::AMF::AMF> Retrieving Debug object failed with error code %ls (code %ld).", res);
+		throw std::exception("", res);
+	}
+
+	/// Register Custom Trace Writer and disable Debug Tracing.
+	m_AMFTrace->RegisterWriter(L"OBSWriter", CustomWriter::GetInstance().get(), true);
+	this->EnableDebugTrace(false);
+
+	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Initialized.");
+}
+
+Plugin::AMD::AMF::~AMF() {
+	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Finalizing.");
+
+	/// Unregister Writer
+	if (m_AMFTrace)
+		m_AMFTrace->UnregisterWriter(L"OBSWriter");
+
+	// Free Library again
+	if (m_AMFModule)
+		FreeLibrary(m_AMFModule);
+
+	#pragma region Null Class Members
+	m_TimerPeriod = 0;
+	m_AMFVersion_Compiler = 0;
+	m_AMFVersion_Runtime = 0;
+	m_AMFModule = 0;
+
+	m_AMFFactory = nullptr;
+	m_AMFTrace = nullptr;
+	m_AMFDebug = nullptr;
+	AMFQueryVersion = nullptr;
+	AMFInit = nullptr;
+	#pragma endregion Null Class Members
+
+	AMF_LOG_DEBUG("<Plugin::AMD::AMF::AMF> Finalized.");
+}
+
+amf::AMFFactory* Plugin::AMD::AMF::GetFactory() {
+	return m_AMFFactory;
+}
+
+amf::AMFTrace* Plugin::AMD::AMF::GetTrace() {
+	return m_AMFTrace;
+}
+
+amf::AMFDebug* Plugin::AMD::AMF::GetDebug() {
+	return m_AMFDebug;
+}
+
+void Plugin::AMD::AMF::EnableDebugTrace(bool enable) {
+	if (!m_AMFTrace)
+		throw std::exception(__FUNCTION_NAME__ " called without a AMFTrace object!");
+	if (!m_AMFDebug)
+		throw std::exception(__FUNCTION_NAME__ " called without a AMFDebug object!");
+
+	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_CONSOLE, false);
+	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_CONSOLE, AMF_TRACE_ERROR);
+	#ifdef DEBUG
+	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_DEBUG_OUTPUT, true);
+	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_DEBUG_OUTPUT, AMF_TRACE_TEST);
+	m_AMFTrace->SetPath(L"C:/AMFTrace.log");
+	#else
+	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_DEBUG_OUTPUT, false);
+	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_DEBUG_OUTPUT, AMF_TRACE_ERROR);
+	#endif
+	m_AMFTrace->EnableWriter(AMF_TRACE_WRITER_FILE, false);
+	m_AMFTrace->SetWriterLevel(AMF_TRACE_WRITER_FILE, AMF_TRACE_ERROR);
+
+	if (enable) {
+		m_AMFDebug->AssertsEnable(true);
+		m_AMFDebug->EnablePerformanceMonitor(true);
+		m_AMFTrace->TraceEnableAsync(true);
+		m_AMFTrace->SetGlobalLevel(AMF_TRACE_TEST);
+		m_AMFTrace->SetWriterLevel(L"OBSWriter", AMF_TRACE_TEST);
+	} else {
+		m_AMFDebug->AssertsEnable(false);
+		m_AMFDebug->EnablePerformanceMonitor(false);
+		m_AMFTrace->TraceEnableAsync(true);
+		m_AMFTrace->SetGlobalLevel(AMF_TRACE_WARNING);
+		m_AMFTrace->SetWriterLevel(L"OBSWriter", AMF_TRACE_WARNING);
+	}
+}

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/api-base.cpp Added

@@ -0,0 +1,154 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "api-base.h"
+
+#include "api-d3d9.h"
+#include "api-d3d11.h"
+
+#if defined(_WIN32) || defined(_WIN64)
+#include <windows.h>
+#include <VersionHelpers.h>
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+
+Plugin::API::Device::Device() {
+	this->Name = "Default";
+	this->UniqueId = "";
+}
+
+Plugin::API::Device::Device(std::string Name, std::string UniqueId) {
+	this->Name = Name;
+	this->UniqueId = UniqueId;
+}
+
+Plugin::API::Device::~Device() {
+}
+
+bool Plugin::API::operator<(const Plugin::API::Device & left, const Plugin::API::Device& right) {
+	return left.UniqueId < right.UniqueId;
+}
+
+bool Plugin::API::operator>(const Plugin::API::Device & left, const Plugin::API::Device& right) {
+	return right < left;
+}
+
+bool Plugin::API::operator<=(const Plugin::API::Device & left, const Plugin::API::Device& right) {
+	return !(right < left);
+}
+
+bool Plugin::API::operator>=(const Plugin::API::Device & left, const Plugin::API::Device& right) {
+	return !(left < right);
+}
+
+bool Plugin::API::operator==(const Plugin::API::Device & left, const Plugin::API::Device& right) {
+	return left.UniqueId == right.UniqueId;
+}
+
+bool Plugin::API::operator!=(const Plugin::API::Device & left, const Plugin::API::Device& right) {
+	return !(left == right);
+}
+
+std::vector<Plugin::API::Device> Plugin::API::APIBase::EnumerateDevices() {
+	// Build a list of Devices
+	#if defined(_WIN32) || defined(_WIN64)
+	if (IsWindows8OrGreater()) {
+		return Plugin::API::Direct3D11::EnumerateDevices();
+	} else if (IsWindowsXPOrGreater()) {
+		//return Plugin::API::Direct3D9::EnumerateDevices();
+	} else
+		#endif 
+	{ // OpenGL
+		//return Plugin::API::OpenGL::EnumerateDevices();
+	}
+	return std::vector<Plugin::API::Device>();
+}
+
+Plugin::API::Device Plugin::API::APIBase::GetDeviceForUniqueId(std::string uniqueId) {
+	auto devices = EnumerateDevices();
+	for (auto device : devices) {
+		if (device.UniqueId == uniqueId)
+			return device;
+	}
+	return Plugin::API::Device();
+}
+
+std::unique_ptr<Plugin::API::APIBase> Plugin::API::APIBase::CreateBestAvailableAPI(Plugin::API::Device device) {
+	std::unique_ptr<Plugin::API::APIBase> retVal = std::make_unique<Plugin::API::APIBase>();
+	#if defined(_WIN32) || defined(_WIN64)
+	if (IsWindows8OrGreater()) {
+		retVal = std::make_unique<Plugin::API::Direct3D11>(device);
+	} else if (IsWindowsXPOrGreater()) {
+		//retVal = std::make_unique<Plugin::API::Direct3D9>(device);
+	} else
+		#endif 
+	{ // OpenGL
+	 //return Plugin::API::OpenGL::OpenGL(device);
+	}
+	return retVal;
+}
+
+Plugin::API::APIType Plugin::API::APIBase::GetBestAvailableAPI() {
+	#if defined(_WIN32) || defined(_WIN64)
+	if (IsWindows8OrGreater()) {
+		return APIType_Direct3D11;
+	} else if (IsWindowsXPOrGreater()) {
+		return APIType_Direct3D9;
+	} else
+		#endif 
+	{ // OpenGL
+		return APIType_OpenGL;
+	}
+	return APIType_Base;
+}
+
+Plugin::API::APIBase::APIBase() {
+	myDevice = Plugin::API::Device();
+}
+
+Plugin::API::APIBase::APIBase(Device device) {
+	myDevice = device;
+}
+
+Plugin::API::APIBase::~APIBase() {
+}
+
+Plugin::API::APIType Plugin::API::APIBase::GetType() {
+	return myType;
+}
+
+void* Plugin::API::APIBase::GetContext() {
+	return nullptr;
+}
+
+Plugin::API::Device Plugin::API::APIBase::GetDevice() {
+	return myDevice;
+}

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/api-d3d11.cpp Added

@@ -0,0 +1,311 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#ifdef _WIN32
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "api-d3d11.h"
+
+#include <vector>
+#include <string>
+#include <sstream>
+#include <stdlib.h>
+
+#include <dxgi.h>
+#include <d3d11.h>
+
+#include <mutex>
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+using namespace Plugin::API;
+
+class SingletonDXGI {
+	public:
+
+	#pragma region Singleton
+	static std::shared_ptr<SingletonDXGI> GetInstance() {
+		static std::shared_ptr<SingletonDXGI> __instance = std::make_shared<SingletonDXGI>();
+		static std::mutex __mutex;
+
+		const std::lock_guard<std::mutex> lock(__mutex);
+		return __instance;
+	}
+	#pragma endregion Singleton
+
+	SingletonDXGI() {
+		hModule = LoadLibrary(TEXT("dxgi.dll"));
+		if (hModule == 0)
+			throw std::exception("Unable to load 'dxgi.dll'.");
+
+	}
+	~SingletonDXGI() {
+		if (hModule)
+			FreeLibrary(hModule);
+	}
+
+	HRESULT CreateDXGIFactory1(REFIID riid, _Out_ void **ppFactory) {
+		if (hModule == 0)
+			return S_FALSE;
+
+		typedef HRESULT(__stdcall *t_CreateDXGIFactory1)(REFIID, void**);
+		t_CreateDXGIFactory1 pCreateDXGIFactory1 = (t_CreateDXGIFactory1)GetProcAddress(hModule, "CreateDXGIFactory1");
+
+		if (pCreateDXGIFactory1) {
+			return pCreateDXGIFactory1(riid, ppFactory);
+		}
+		return S_FALSE;
+	}
+
+	private:
+	HMODULE hModule;
+};
+class SingletonD3D11 {
+	public:
+
+	#pragma region Singleton
+	static std::shared_ptr<SingletonD3D11> GetInstance() {
+		static std::shared_ptr<SingletonD3D11> __instance = std::make_shared<SingletonD3D11>();
+		static std::mutex __mutex;
+
+		const std::lock_guard<std::mutex> lock(__mutex);
+		return __instance;
+	}
+	#pragma endregion Singleton
+
+	SingletonD3D11() {
+		hModule = LoadLibrary(TEXT("d3d11.dll"));
+		if (hModule == 0)
+			throw std::exception("Unable to load 'd3d11.dll'.");
+
+	}
+	~SingletonD3D11() {
+		if (hModule)
+			FreeLibrary(hModule);
+	}
+
+	HRESULT WINAPI D3D11CreateDevice(
+		_In_opt_ IDXGIAdapter* pAdapter,
+		D3D_DRIVER_TYPE DriverType,
+		HMODULE Software,
+		UINT Flags,
+		_In_reads_opt_(FeatureLevels) CONST D3D_FEATURE_LEVEL* pFeatureLevels,
+		UINT FeatureLevels,
+		UINT SDKVersion,
+		_Out_opt_ ID3D11Device** ppDevice,
+		_Out_opt_ D3D_FEATURE_LEVEL* pFeatureLevel,
+		_Out_opt_ ID3D11DeviceContext** ppImmediateContext) {
+
+		if (hModule == 0)
+			return S_FALSE;
+
+		typedef HRESULT(__stdcall *t_D3D11CreateDevice)(_In_opt_ IDXGIAdapter*, D3D_DRIVER_TYPE, HMODULE, UINT,
+			CONST D3D_FEATURE_LEVEL*, UINT, UINT, _Out_opt_ ID3D11Device**,
+			_Out_opt_ D3D_FEATURE_LEVEL*, _Out_opt_ ID3D11DeviceContext**);
+		t_D3D11CreateDevice pD3D11CreateDevice = (t_D3D11CreateDevice)GetProcAddress(hModule, "D3D11CreateDevice");
+
+		if (pD3D11CreateDevice) {
+			return pD3D11CreateDevice(pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels,
+				SDKVersion, ppDevice, pFeatureLevel, ppImmediateContext);
+		}
+		return S_FALSE;
+	}
+
+	private:
+	HMODULE hModule;
+};
+
+Plugin::API::Device BuildDeviceFromAdapter(DXGI_ADAPTER_DESC1* pAdapter) {
+	if (pAdapter == nullptr)
+		return Device("INVALID DEVICE", "");
+
+	std::vector<char> uidBuf(1024);
+	sprintf(uidBuf.data(), "%ld:%ld",
+		pAdapter->AdapterLuid.LowPart,
+		pAdapter->AdapterLuid.HighPart);
+
+	std::vector<char> nameBuf(1024);
+	wcstombs(nameBuf.data(), pAdapter->Description, 1024);
+
+	return Device(std::string(nameBuf.data()), std::string(uidBuf.data()));
+}
+
+std::vector<Plugin::API::Device> Plugin::API::Direct3D11::EnumerateDevices() {
+	std::vector<Plugin::API::Device> devices = std::vector<Plugin::API::Device>();
+
+	IDXGIFactory1* pFactory = NULL;
+	auto singletonDXGI = SingletonDXGI::GetInstance();
+	HRESULT hr = singletonDXGI->CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory));
+	if (FAILED(hr)) {
+		return devices;
+	}
+
+	IDXGIAdapter1* pAdapter = NULL;
+	for (uint32_t iAdapterIndex = 0; pFactory->EnumAdapters1(iAdapterIndex, &pAdapter) != DXGI_ERROR_NOT_FOUND; iAdapterIndex++) {
+		DXGI_ADAPTER_DESC1 adapterDesc = DXGI_ADAPTER_DESC1();
+		std::memset(&adapterDesc, 0, sizeof(DXGI_ADAPTER_DESC1));
+
+		if (pAdapter->GetDesc1(&adapterDesc) == S_OK) {
+			// Only allow AMD devices to be listed here.
+			if (adapterDesc.VendorId != 0x1002)
+				continue;
+
+			devices.push_back(BuildDeviceFromAdapter(&adapterDesc));
+		}
+	}
+
+	pFactory->Release();
+
+	return devices;
+}
+
+Plugin::API::Device Plugin::API::Direct3D11::GetDeviceForUniqueId(std::string uniqueId) {
+	Plugin::API::Device device = Device("", "");
+
+	IDXGIFactory1* pFactory = NULL;
+	auto singletonDXGI = SingletonDXGI::GetInstance();
+	HRESULT hr = singletonDXGI->CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory));
+	if (FAILED(hr)) {
+		return device;
+	}
+
+	IDXGIAdapter1* pAdapter = NULL;
+	for (uint32_t iAdapterIndex = 0; pFactory->EnumAdapters1(iAdapterIndex, &pAdapter) != DXGI_ERROR_NOT_FOUND; iAdapterIndex++) {
+		DXGI_ADAPTER_DESC1 adapterDesc = DXGI_ADAPTER_DESC1();
+		std::memset(&adapterDesc, 0, sizeof(DXGI_ADAPTER_DESC1));
+
+		if (pAdapter->GetDesc1(&adapterDesc) == S_OK) {
+			// Only allow AMD devices to be listed here.
+			if (adapterDesc.VendorId != 0x1002)
+				continue;
+
+			Plugin::API::Device device2 = BuildDeviceFromAdapter(&adapterDesc);
+
+			if (uniqueId == device2.UniqueId) {
+				device = device2;
+				break;
+			}
+		}
+	}
+
+	pFactory->Release();
+	return device;
+}
+
+Plugin::API::Direct3D11::Direct3D11(Device device) : APIBase(device) {
+	IDXGIFactory1 *pFactory;
+
+	this->myType = APIType_Direct3D11;
+
+	auto singletonDXGI = SingletonDXGI::GetInstance();
+	if (FAILED(singletonDXGI->CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)(&pFactory))))
+		throw new std::exception("Unable to create D3D11 driver.");
+
+	try {
+		IDXGIAdapter1 *pAdapter = NULL;
+		if (device.UniqueId != "") {
+			IDXGIAdapter1 *pAdapter2 = NULL;
+			for (uint32_t iAdapterIndex = 0; pFactory->EnumAdapters1(iAdapterIndex, &pAdapter2) != DXGI_ERROR_NOT_FOUND; iAdapterIndex++) {
+				DXGI_ADAPTER_DESC1 adapterDesc = DXGI_ADAPTER_DESC1();
+				std::memset(&adapterDesc, 0, sizeof(DXGI_ADAPTER_DESC1));
+
+				if (pAdapter2->GetDesc1(&adapterDesc) == S_OK) {
+					// Only allow AMD devices to be listed here.
+					if (adapterDesc.VendorId != 0x1002)
+						continue;
+
+					Plugin::API::Device device2 = BuildDeviceFromAdapter(&adapterDesc);
+
+					if (device.UniqueId == device2.UniqueId) {
+						pAdapter = pAdapter2;
+						break;
+					}
+				}
+			}
+		}
+
+		try {
+			D3D_FEATURE_LEVEL featureLevels[] = {
+				D3D_FEATURE_LEVEL_11_1,
+				D3D_FEATURE_LEVEL_11_0
+			};
+			D3D_FEATURE_LEVEL featureLevel;
+			uint32_t flags =
+				D3D11_CREATE_DEVICE_BGRA_SUPPORT |
+				D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT |
+				D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
+
+			DXGI_ADAPTER_DESC desc;
+			if (pAdapter != NULL) {
+				pAdapter->GetDesc(&desc);
+			}
+
+			auto singletonD3D11 = SingletonD3D11::GetInstance();
+			HRESULT hr = singletonD3D11->D3D11CreateDevice(
+				pAdapter, pAdapter == NULL ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_UNKNOWN,
+				NULL, flags,
+				featureLevels, _countof(featureLevels),
+				D3D11_SDK_VERSION,
+				&pDevice, &featureLevel, &pDeviceContext);
+			if (FAILED(hr)) {
+				AMF_LOG_ERROR("Unable to create D3D11.1 device.");
+				hr = singletonD3D11->D3D11CreateDevice(
+					pAdapter, pAdapter == NULL ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_UNKNOWN,
+					NULL, flags,
+					featureLevels + 1, _countof(featureLevels) - 1,
+					D3D11_SDK_VERSION,
+					&pDevice, &featureLevel, &pDeviceContext);
+				if (FAILED(hr)) {
+					throw std::exception("Unable to create D3D11 device.");
+				}
+			}
+		} catch (...) {
+			if (pAdapter)
+				pAdapter->Release();
+
+			throw;
+		}
+	} catch (...) {
+		if (pFactory)
+			pFactory->Release();
+
+		throw;
+	}
+}
+
+Plugin::API::Direct3D11::~Direct3D11() {
+	if (pDeviceContext)
+		pDeviceContext->Release();
+	if (pDevice)
+		pDevice->Release();
+}
+
+void* Plugin::API::Direct3D11::GetContext() {
+	return pDevice;
+}
+
+
+#endif

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/api-d3d9.cpp Added

@@ -0,0 +1,200 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#ifdef _WIN32
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "api-d3d9.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+using namespace Plugin::API;
+
+Plugin::API::Device BuildDeviceFromAdapter(D3DADAPTER_IDENTIFIER9* pAdapter) {
+	if (pAdapter == nullptr)
+		return Device("INVALID DEVICE", "");
+
+	std::vector<char> uidBuf(1024);
+	sprintf(uidBuf.data(), "%ld:%ld:%ld:%ld",
+		pAdapter->VendorId,
+		pAdapter->DeviceId,
+		pAdapter->SubSysId,
+		pAdapter->Revision);
+
+	std::vector<char> nameBuf(1024);
+	sprintf(nameBuf.data(), "%s (%s)",
+		pAdapter->DeviceName,
+		pAdapter->Description);
+
+	return Device(std::string(nameBuf.data()), std::string(uidBuf.data()));
+}
+
+
+std::vector<Plugin::API::Device> Plugin::API::Direct3D9::EnumerateDevices() {
+	std::vector<Plugin::API::Device> devices = std::vector<Plugin::API::Device>();
+
+	IDirect3D9* pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
+
+	uint32_t adapterCount = pDirect3D->GetAdapterCount();
+	for (uint32_t adapterIndex = 0; adapterIndex < adapterCount; adapterIndex++) {
+		D3DADAPTER_IDENTIFIER9 adapterDesc = D3DADAPTER_IDENTIFIER9();
+		pDirect3D->GetAdapterIdentifier(adapterIndex, 0, &adapterDesc);
+
+		if (adapterDesc.VendorId != 0x1002)
+			continue;
+
+		Device device = BuildDeviceFromAdapter(&adapterDesc);
+		devices.push_back(device);
+	}
+
+	pDirect3D->Release();
+
+	return devices;
+}
+
+Plugin::API::Device Plugin::API::Direct3D9::GetDeviceForUniqueId(std::string uniqueId) {
+	Plugin::API::Device device = Device("", "");
+
+	IDirect3D9* pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
+
+	uint32_t adapterCount = pDirect3D->GetAdapterCount();
+	for (uint32_t adapterIndex = 0; adapterIndex <= adapterCount; adapterIndex++) {
+		D3DADAPTER_IDENTIFIER9 adapterDesc = D3DADAPTER_IDENTIFIER9();
+		pDirect3D->GetAdapterIdentifier(adapterIndex, 0, &adapterDesc);
+
+		if (adapterDesc.VendorId != 0x1002)
+			continue;
+
+		Device device2 = BuildDeviceFromAdapter(&adapterDesc);
+		if (device2.UniqueId == uniqueId)
+			device = device2;
+	}
+
+	pDirect3D->Release();
+
+	return device;
+}
+
+struct EnumWindowsData {
+	DWORD processId;
+	HWND bestWindowId;
+};
+
+BOOL CALLBACK EnumWindowsCallback(HWND handle, LPARAM lParam) {
+	EnumWindowsData* data = (EnumWindowsData*)lParam;
+
+	DWORD processId;
+	GetWindowThreadProcessId(handle, &processId);
+	if ((processId == data->processId)
+		&& (GetWindow(handle, GW_OWNER) == (HWND)0)
+		&& (IsWindowVisible(handle))) {
+		return TRUE;
+	}
+	data->bestWindowId = handle;
+	return FALSE;
+}
+
+Plugin::API::Direct3D9::Direct3D9(Device device) : APIBase(device) {
+	this->myType = APIType_Direct3D9;
+
+	pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
+	if (!pDirect3D)
+		throw std::exception("Unable to create D3D9 driver.");
+
+	// Find Adapter Index
+	uint32_t usedAdapter = 0;
+	uint32_t adapterCount = pDirect3D->GetAdapterCount();
+	for (uint32_t adapterIndex = 0; adapterIndex <= adapterCount; adapterIndex++) {
+		D3DADAPTER_IDENTIFIER9 adapterDesc = D3DADAPTER_IDENTIFIER9();
+		pDirect3D->GetAdapterIdentifier(adapterIndex, 0, &adapterDesc);
+
+		if (adapterDesc.VendorId != 0x1002)
+			continue;
+
+		Device device2 = BuildDeviceFromAdapter(&adapterDesc);
+		if (device2.UniqueId == device.UniqueId) {
+			usedAdapter = adapterIndex++;
+			break;
+		}
+	}
+
+	EnumWindowsData data = EnumWindowsData();
+	data.processId = GetCurrentProcessId();
+	EnumWindows(EnumWindowsCallback, (LPARAM)&data);
+
+	D3DPRESENT_PARAMETERS pPresentParameter = D3DPRESENT_PARAMETERS();
+	pPresentParameter.BackBufferWidth = 1280;
+	pPresentParameter.BackBufferHeight = 720;
+	pPresentParameter.BackBufferFormat = D3DFORMAT::D3DFMT_X8R8G8B8;
+	pPresentParameter.BackBufferCount = 2;
+	pPresentParameter.MultiSampleType = D3DMULTISAMPLE_TYPE::D3DMULTISAMPLE_NONE;
+	pPresentParameter.MultiSampleQuality = 0;
+	pPresentParameter.SwapEffect = D3DSWAPEFFECT::D3DSWAPEFFECT_DISCARD;
+	pPresentParameter.hDeviceWindow = data.bestWindowId;
+	pPresentParameter.Windowed = TRUE;
+	pPresentParameter.EnableAutoDepthStencil = FALSE;
+	pPresentParameter.AutoDepthStencilFormat = D3DFORMAT::D3DFMT_A1;
+	pPresentParameter.Flags = D3DPRESENTFLAG_VIDEO;
+	pPresentParameter.FullScreen_RefreshRateInHz = 0;
+	pPresentParameter.PresentationInterval = 60;
+		
+	HRESULT hr = pDirect3D->CreateDevice(usedAdapter,
+		D3DDEVTYPE_HAL,
+		data.bestWindowId,
+		0, //D3DCREATE_DISABLE_DRIVER_MANAGEMENT_EX | D3DCREATE_MULTITHREADED | D3DCREATE_PUREDEVICE | D3DCREATE_MIXED_VERTEXPROCESSING | D3DCREATE_NOWINDOWCHANGES,
+		&pPresentParameter,
+		&pDirect3DDevice);
+	switch (hr) {
+		case D3DERR_DEVICELOST:
+			throw std::exception("D3DERR_DEVICELOST");
+			break;
+		case D3DERR_INVALIDCALL:
+			throw std::exception("D3DERR_INVALIDCALL");
+			break;
+		case D3DERR_NOTAVAILABLE:
+			throw std::exception("D3DERR_NOTAVAILABLE");
+			break;
+		case D3DERR_OUTOFVIDEOMEMORY:
+			throw std::exception("D3DERR_OUTOFVIDEOMEMORY");
+			break;
+	}
+	if (FAILED(hr))
+		throw std::exception("Unable to create D3D9 device.");
+}
+
+Plugin::API::Direct3D9::~Direct3D9() {
+	if (pDirect3DDevice)
+		pDirect3DDevice->Release();
+
+	if (pDirect3D)
+		pDirect3D->Release();
+}
+
+void* Plugin::API::Direct3D9::GetContext() {
+	return pDirect3DDevice;
+}
+
+#endif

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/enc-h264.cpp Added

@@ -0,0 +1,1592 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include "enc-h264.h"
+#include "misc-util.cpp"
+
+#if (defined _WIN32) || (defined _WIN64)
+#include <VersionHelpers.h>
+
+#include "api-d3d9.h"
+#include "api-d3d11.h"
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+using namespace Plugin;
+using namespace Plugin::AMD;
+using namespace Plugin::Interface;
+
+enum Presets {
+	None = -1,
+	ResetToDefaults = 0,
+	Recording,
+	HighQuality,
+	Indistinguishable,
+	Lossless,
+	Twitch,
+	YouTube,
+};
+enum ViewMode {
+	Basic,
+	Advanced,
+	Expert,
+	Master
+};
+
+void Plugin::Interface::H264Interface::encoder_register() {
+	static obs_encoder_info* encoder_info = new obs_encoder_info();
+	static const char* encoder_name = "amd_amf_h264";
+	static const char* encoder_codec = "h264";
+
+	std::memset(encoder_info, 0, sizeof(obs_encoder_info));
+
+	// Initialize Structure
+	encoder_info->id = encoder_name;
+	encoder_info->type = obs_encoder_type::OBS_ENCODER_VIDEO;
+	encoder_info->codec = encoder_codec;
+
+	// Functions
+	encoder_info->get_name = &get_name;
+	encoder_info->get_defaults = &get_defaults;
+	encoder_info->get_properties = &get_properties;
+	encoder_info->create = &create;
+	encoder_info->destroy = &destroy;
+	encoder_info->encode = &encode;
+	encoder_info->update = &update;
+	encoder_info->get_video_info = &get_video_info;
+	encoder_info->get_extra_data = &get_extra_data;
+
+	obs_register_encoder(encoder_info);
+}
+
+const char* Plugin::Interface::H264Interface::get_name(void*) {
+	static const char* name = "H264 Encoder (AMD Advanced Media Framework)";
+	return name;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Deprecated old Encoder
+const char* Plugin::Interface::H264Interface::get_name_simple(void*) {
+	static const char* name = "[DEPRECATED] H264 Encoder (AMD Advanced Media Framework)";
+	return name;
+}
+//////////////////////////////////////////////////////////////////////////
+void* Plugin::Interface::H264Interface::create(obs_data_t* settings, obs_encoder_t* encoder) {
+	Plugin::Interface::H264Interface* enc = nullptr;
+	try {
+		AMF_LOG_INFO("Starting up...");
+		enc = new Plugin::Interface::H264Interface(settings, encoder);
+		return enc;
+	} catch (std::exception e) {
+		AMF_LOG_ERROR("Exception: %s", e.what());
+		AMF_LOG_ERROR("Unable to create Encoder, see log for more information.");
+		if (enc)
+			delete enc;
+		return NULL;
+	} catch (...) {
+		AMF_LOG_ERROR("Unhandled Exception during start up.");
+		if (enc)
+			delete enc;
+		return NULL;
+	}
+}
+
+#pragma warning( push )
+#pragma warning( disable: 4702 )
+void Plugin::Interface::H264Interface::destroy(void* data) {
+	try {
+		AMF_LOG_INFO("Shutting down...");
+		Plugin::Interface::H264Interface* enc = static_cast<Plugin::Interface::H264Interface*>(data);
+		delete enc;
+	} catch (std::exception e) {
+		AMF_LOG_ERROR("Exception: %s", e.what());
+		AMF_LOG_ERROR("Unable to destroy Encoder, see log for more information.");
+	} catch (...) {
+		AMF_LOG_ERROR("Unhandled Exception during shut down.");
+	}
+	data = nullptr;
+}
+#pragma warning( pop )
+
+bool Plugin::Interface::H264Interface::encode(void *data, struct encoder_frame *frame, struct encoder_packet *packet, bool *received_packet) {
+	try {
+		return static_cast<Plugin::Interface::H264Interface*>(data)->encode(frame, packet, received_packet);
+	} catch (std::exception e) {
+		AMF_LOG_ERROR("Exception: %s", e.what());
+		AMF_LOG_ERROR("Unable to encode, see log for more information.");
+		return false;
+	} catch (...) {
+		throw;
+	}
+}
+
+void Plugin::Interface::H264Interface::get_defaults(obs_data_t *data) {
+	#pragma region OBS - Enforce Streaming Service Restrictions
+	// OBS - Enforce Streaming Service Restrictions
+	obs_data_set_default_int(data, "bitrate", -1);
+	obs_data_set_default_int(data, "keyint_sec", -1);
+	obs_data_set_default_string(data, "rate_control", "");
+	obs_data_set_default_string(data, "profile", "");
+	obs_data_set_default_string(data, "preset", "");
+	obs_data_set_int(data, "bitrate", -1);
+	obs_data_set_int(data, "keyint_sec", -1);
+	obs_data_set_string(data, "rate_control", "");
+	obs_data_set_string(data, "profile", "");
+	obs_data_set_string(data, "preset", "");
+	#pragma endregion OBS - Enforce Streaming Service Restrictions
+
+	// Cached Data
+	obs_data_set_string(data, "last" vstr(AMF_H264_DEVICE), "InvalidUniqueDeviceId");
+	obs_data_set_int(data, "last" vstr(AMF_H264_VIEW), -1);
+	obs_data_set_int(data, "last" vstr(AMF_H264_RATECONTROLMETHOD), -1);
+	obs_data_set_int(data, "last" vstr(AMF_H264_VBVBUFFER), -1);
+	obs_data_set_int(data, "last" vstr(AMF_H264_BPICTURE_PATTERN), -1);
+	obs_data_set_int(data, "last" vstr(AMF_H264_BPICTURE_REFERENCE), -1);
+
+	// Preset
+	obs_data_set_default_int(data, AMF_H264_PRESET, -1);
+
+	// Static Properties
+	obs_data_set_default_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+	obs_data_set_default_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Balanced);
+	obs_data_set_default_int(data, AMF_H264_PROFILE, VCEProfile_Main);
+	obs_data_set_default_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+	obs_data_set_default_int(data, AMF_H264_MAXIMUMLTRFRAMES, 0);
+	obs_data_set_default_int(data, AMF_H264_CODINGTYPE, 0);
+
+	// Rate Control Properties
+	obs_data_set_default_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantBitrate);
+	obs_data_set_default_int(data, AMF_H264_BITRATE_TARGET, 3500);
+	obs_data_set_default_int(data, AMF_H264_BITRATE_PEAK, 9000);
+	obs_data_set_default_int(data, AMF_H264_QP_MINIMUM, 0);
+	obs_data_set_default_int(data, AMF_H264_QP_MAXIMUM, 51);
+	obs_data_set_default_int(data, AMF_H264_QP_IFRAME, 22);
+	obs_data_set_default_int(data, AMF_H264_QP_PFRAME, 22);
+	obs_data_set_default_int(data, AMF_H264_QP_BFRAME, 22);
+	obs_data_set_default_int(data, AMF_H264_QP_BPICTURE_DELTA, 4);
+	obs_data_set_default_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 2);
+	obs_data_set_default_int(data, AMF_H264_VBVBUFFER, 0);
+	obs_data_set_default_int(data, AMF_H264_VBVBUFFER_SIZE, 3500);
+	obs_data_set_default_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
+	obs_data_set_default_double(data, AMF_H264_VBVBUFFER_FULLNESS, 100);
+	obs_data_set_default_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+	obs_data_set_default_int(data, AMF_H264_FILLERDATA, 1);
+	obs_data_set_default_int(data, AMF_H264_FRAMESKIPPING, 0);
+	obs_data_set_default_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+	// Picture Control Properties
+	obs_data_set_default_double(data, AMF_H264_KEYFRAME_INTERVAL, 2);
+	obs_data_set_default_int(data, AMF_H264_IDR_PERIOD, 60);
+	obs_data_set_default_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+	obs_data_set_default_int(data, AMF_H264_BPICTURE_PATTERN, VCEBPicturePattern_None);
+	obs_data_set_default_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
+	obs_data_set_default_int(data, AMF_H264_DEBLOCKINGFILTER, 1);
+	obs_data_set_default_int(data, AMF_H264_SLICESPERFRAME, 0);
+	obs_data_set_default_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+	// Miscellaneous Control Properties
+	obs_data_set_default_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+	obs_data_set_default_int(data, AMF_H264_MOTIONESTIMATION, 3);
+
+	// System Properties
+	obs_data_set_default_string(data, AMF_H264_DEVICE, "");
+	obs_data_set_default_int(data, AMF_H264_USE_OPENCL, 0);
+
+	obs_data_set_default_int(data, AMF_H264_VIEW, ViewMode::Basic);
+	obs_data_set_default_bool(data, AMF_H264_UNLOCK_PROPERTIES, false);
+	obs_data_set_default_bool(data, AMF_H264_DEBUG, false);
+}
+
+static void fill_device_list(obs_property_t* p) {
+	std::vector<Plugin::API::Device> devices = Plugin::API::APIBase::EnumerateDevices();
+
+	obs_property_list_clear(p);
+	obs_property_list_add_string(p, TEXT_T(AMF_UTIL_DEFAULT), "");
+	for (Plugin::API::Device device : devices) {
+		obs_property_list_add_string(p, device.Name.c_str(), device.UniqueId.c_str());
+	}
+}
+
+obs_properties_t* Plugin::Interface::H264Interface::get_properties(void*) {
+	obs_properties* props = obs_properties_create();
+	obs_property_t* p;
+
+	#pragma region Preset
+	p = obs_properties_add_list(props, AMF_H264_PRESET, TEXT_T(AMF_H264_PRESET), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_modified_callback(p, properties_modified);
+	obs_property_list_add_int(p, "", -1);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_RESETTODEFAULTS), Presets::ResetToDefaults);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_RECORDING), Presets::Recording);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_HIGHQUALITY), Presets::HighQuality);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_INDISTINGUISHABLE), Presets::Indistinguishable);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_LOSSLESS), Presets::Lossless);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_TWITCH), Presets::Twitch);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_PRESET_YOUTUBE), Presets::YouTube);
+	#pragma endregion Preset
+
+	#pragma region Static Properties
+	#pragma region Usage
+	p = obs_properties_add_list(props, AMF_H264_USAGE, TEXT_T(AMF_H264_USAGE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_USAGE_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_USAGE_TRANSCODING), VCEUsage_Transcoding);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_USAGE_ULTRALOWLATENCY), VCEUsage_UltraLowLatency);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_USAGE_LOWLATENCY), VCEUsage_LowLatency);
+	//obs_property_list_add_int(list, TEXT_T(AMF_H264_USAGE_WEBCAM), VCEUsage_Webcam); // Requires SVC? SVC is not implemented by default.
+	#pragma endregion Usage
+	#pragma region Quality Preset
+	p = obs_properties_add_list(props, AMF_H264_QUALITY_PRESET, TEXT_T(AMF_H264_QUALITY_PRESET), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QUALITY_PRESET_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_QUALITY_PRESET_SPEED), VCEQualityPreset_Speed);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_QUALITY_PRESET_BALANCED), VCEQualityPreset_Balanced);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_QUALITY_PRESET_QUALITY), VCEQualityPreset_Quality);
+	#pragma endregion Quality Preset
+	#pragma region Profile
+	p = obs_properties_add_list(props, AMF_H264_PROFILE, TEXT_T(AMF_H264_PROFILE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_PROFILE_DESCRIPTION));
+	obs_property_list_add_int(p, "NOT INITIALIZED", 0xFFFFFFFFFFFFFFFFull);
+	#pragma endregion Profile
+	#pragma region Profile Level
+	p = obs_properties_add_list(props, AMF_H264_PROFILELEVEL, TEXT_T(AMF_H264_PROFILELEVEL), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_PROFILELEVEL_DESCRIPTION));
+	obs_property_list_add_int(p, "NOT INITIALIZED", 0xFFFFFFFFFFFFFFFFull);
+	#pragma endregion Profile Levels
+	#pragma region Long Term Reference Frames
+	p = obs_properties_add_int_slider(props, AMF_H264_MAXIMUMLTRFRAMES, TEXT_T(AMF_H264_MAXIMUMLTRFRAMES), 0, 2, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_MAXIMUMLTRFRAMES_DESCRIPTION));
+	obs_property_set_modified_callback(p, properties_modified);
+	#pragma endregion Long Term Reference Frames
+	#pragma region Coding Type
+	p = obs_properties_add_list(props, AMF_H264_CODINGTYPE, TEXT_T(AMF_H264_CODINGTYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_CODINGTYPE_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_DEFAULT), VCECodingType_Default);
+	obs_property_list_add_int(p, "CALVC", VCECodingType_CALV);
+	obs_property_list_add_int(p, "CABAC", VCECodingType_CABAC);
+	#pragma endregion Coding Type
+	#pragma endregion Static Properties
+
+	#pragma region Rate Control Properties
+	//p = obs_properties_add_bool(props, "rcp_delimiter", "------ Rate Control Properties ------");
+	#pragma region Method
+	p = obs_properties_add_list(props, AMF_H264_RATECONTROLMETHOD, TEXT_T(AMF_H264_RATECONTROLMETHOD), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_RATECONTROLMETHOD_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_RATECONTROLMETHOD_CQP), VCERateControlMethod_ConstantQP);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_RATECONTROLMETHOD_CBR), VCERateControlMethod_ConstantBitrate);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_RATECONTROLMETHOD_VBR), VCERateControlMethod_VariableBitrate_PeakConstrained);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_RATECONTROLMETHOD_VBR_LAT), VCERateControlMethod_VariableBitrate_LatencyConstrained);
+	obs_property_set_modified_callback(p, properties_modified);
+	#pragma endregion Method
+	#pragma region Method Parameters
+	/// Bitrate Constraints
+	p = obs_properties_add_int(props, AMF_H264_BITRATE_TARGET, TEXT_T(AMF_H264_BITRATE_TARGET), 0,
+		1, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_BITRATE_TARGET_DESCRIPTION));
+	p = obs_properties_add_int(props, AMF_H264_BITRATE_PEAK, TEXT_T(AMF_H264_BITRATE_PEAK), 0,
+		1, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_BITRATE_PEAK_DESCRIPTION));
+	/// Minimum QP, Maximum QP
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_MINIMUM, TEXT_T(AMF_H264_QP_MINIMUM), 0, 51, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_MINIMUM_DESCRIPTION));
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_MAXIMUM, TEXT_T(AMF_H264_QP_MAXIMUM), 0, 51, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_MAXIMUM_DESCRIPTION));
+	/// Method: Constant QP
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_IFRAME, TEXT_T(AMF_H264_QP_IFRAME), 0, 51, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_IFRAME_DESCRIPTION));
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_PFRAME, TEXT_T(AMF_H264_QP_PFRAME), 0, 51, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_PFRAME_DESCRIPTION));
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_BFRAME, TEXT_T(AMF_H264_QP_BFRAME), 0, 51, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_BFRAME_DESCRIPTION));
+	#pragma endregion Method Parameters
+	#pragma region VBV Buffer
+	p = obs_properties_add_list(props, AMF_H264_VBVBUFFER, TEXT_T(AMF_H264_VBVBUFFER), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_VBVBUFFER_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_AUTOMATIC), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_MANUAL), 1);
+	obs_property_set_modified_callback(p, properties_modified);
+	p = obs_properties_add_float_slider(props, AMF_H264_VBVBUFFER_STRICTNESS, TEXT_T(AMF_H264_VBVBUFFER_STRICTNESS), 0.0, 100.0, 0.1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_VBVBUFFER_STRICTNESS_DESCRIPTION));
+	p = obs_properties_add_int_slider(props, AMF_H264_VBVBUFFER_SIZE, TEXT_T(AMF_H264_VBVBUFFER_SIZE), 1, 1000000, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_VBVBUFFER_SIZE_DESCRIPTION));
+	p = obs_properties_add_float_slider(props, AMF_H264_VBVBUFFER_FULLNESS, TEXT_T(AMF_H264_VBVBUFFER_FULLNESS), 0.0, 100.0, 100.0 / 64.0);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_VBVBUFFER_FULLNESS_DESCRIPTION));
+	#pragma endregion VBV Buffer
+	/// Max Access Unit Size
+	p = obs_properties_add_int_slider(props, AMF_H264_MAXIMUMACCESSUNITSIZE, TEXT_T(AMF_H264_MAXIMUMACCESSUNITSIZE), 0, 100000000, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_MAXIMUMACCESSUNITSIZE_DESCRIPTION));
+	#pragma region Flags
+	/// Filler Data (Only supported by CBR so far)
+	p = obs_properties_add_list(props, AMF_H264_FILLERDATA, TEXT_T(AMF_H264_FILLERDATA), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_FILLERDATA_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_DISABLED), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_ENABLED), 1);
+	/// Frame Skipping
+	p = obs_properties_add_list(props, AMF_H264_FRAMESKIPPING, TEXT_T(AMF_H264_FRAMESKIPPING), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_FRAMESKIPPING_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_DISABLED), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_ENABLED), 1);
+	/// Enforce Hypothetical Reference Decoder Compatibility
+	p = obs_properties_add_list(props, AMF_H264_ENFORCEHRDCOMPATIBILITY, TEXT_T(AMF_H264_ENFORCEHRDCOMPATIBILITY), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_ENFORCEHRDCOMPATIBILITY_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_DISABLED), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_ENABLED), 1);
+	#pragma endregion Flags
+	#pragma endregion Rate Control Properties
+
+	#pragma region Picture Control Properties
+	//p = obs_properties_add_bool(props, "pcp_delimiter", "------ Picture Control Properties ------");
+	#pragma region IDR Period / Keyframe Interval / Header Insertion Spacing
+	p = obs_properties_add_float(props, AMF_H264_KEYFRAME_INTERVAL, TEXT_T(AMF_H264_KEYFRAME_INTERVAL), 0, 100, 0.001);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_KEYFRAME_INTERVAL_DESCRIPTION));
+	p = obs_properties_add_int(props, AMF_H264_IDR_PERIOD, TEXT_T(AMF_H264_IDR_PERIOD), 1, 1000, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_IDR_PERIOD_DESCRIPTION));
+	p = obs_properties_add_int(props, AMF_H264_HEADER_INSERTION_SPACING, TEXT_T(AMF_H264_HEADER_INSERTION_SPACING), 0, 1000, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_HEADER_INSERTION_SPACING_DESCRIPTION));
+	#pragma endregion IDR Period / Keyframe Interval / Header Insertion Spacing
+	#pragma region B-Pictures
+	/// B-Pictures Pattern
+	p = obs_properties_add_int_slider(props, AMF_H264_BPICTURE_PATTERN, TEXT_T(AMF_H264_BPICTURE_PATTERN),
+		VCEBPicturePattern_None, VCEBPicturePattern_Three, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_BPICTURE_PATTERN_DESCRIPTION));
+	obs_property_set_modified_callback(p, properties_modified);
+	/// Enable Reference to B-Frames (2nd Generation GCN and newer)
+	p = obs_properties_add_list(props, AMF_H264_BPICTURE_REFERENCE, TEXT_T(AMF_H264_BPICTURE_REFERENCE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_BPICTURE_REFERENCE_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_DISABLED), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_ENABLED), 1);
+	obs_property_set_modified_callback(p, properties_modified);
+	/// B-Picture Delta QP
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_BPICTURE_DELTA, TEXT_T(AMF_H264_QP_BPICTURE_DELTA), -10, 10, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_BPICTURE_DELTA_DESCRIPTION));
+	p = obs_properties_add_int_slider(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, TEXT_T(AMF_H264_QP_REFERENCE_BPICTURE_DELTA), -10, 10, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_QP_REFERENCE_BPICTURE_DELTA_DESCRIPTION));
+	#pragma endregion B-Pictures
+	/// De-Blocking Filter
+	p = obs_properties_add_list(props, AMF_H264_DEBLOCKINGFILTER, TEXT_T(AMF_H264_DEBLOCKINGFILTER), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_DEBLOCKINGFILTER_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_DISABLED), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_ENABLED), 1);
+	/// Number of Slices Per Frame 
+	p = obs_properties_add_int_slider(props, AMF_H264_SLICESPERFRAME, TEXT_T(AMF_H264_SLICESPERFRAME), 0, 8160, 1);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_SLICESPERFRAME_DESCRIPTION));
+	/// Intra Refresh Number of Macro Blocks per Slot
+	obs_properties_add_int_slider(props, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, TEXT_T(AMF_H264_INTRAREFRESHNUMMBSPERSLOT), 0, 8160, 1);
+	#pragma endregion Picture Control Properties
+
+	#pragma region Miscellaneous Control Properties
+	//p = obs_properties_add_bool(props, "msc_delimiter", "------ Miscellaneous Properties ------");
+	/// Scan Type
+	p = obs_properties_add_list(props, AMF_H264_SCANTYPE, TEXT_T(AMF_H264_SCANTYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_SCANTYPE_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_SCANTYPE_PROGRESSIVE), VCEScanType_Progressive);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_SCANTYPE_INTERLACED), VCEScanType_Interlaced);
+	/// Motion Estimation
+	p = obs_properties_add_list(props, AMF_H264_MOTIONESTIMATION, TEXT_T(AMF_H264_MOTIONESTIMATION), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_MOTIONESTIMATION_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_MOTIONESTIMATION_NONE), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_MOTIONESTIMATION_HALF), 1);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_MOTIONESTIMATION_QUARTER), 2);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_MOTIONESTIMATION_BOTH), 3);
+	#pragma endregion Miscellaneous Control Properties
+
+	#pragma region System Properties
+	//p = obs_properties_add_bool(props, "sys_delimiter", "------ System Properties ------");
+	#pragma region Device Selection
+	p = obs_properties_add_list(props, AMF_H264_DEVICE, TEXT_T(AMF_H264_DEVICE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
+	fill_device_list(p);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_DEVICE_DESCRIPTION));
+	obs_property_set_modified_callback(p, properties_modified);
+	#pragma endregion Device Selection
+
+	/// Compute Type
+	p = obs_properties_add_list(props, AMF_H264_USE_OPENCL, TEXT_T(AMF_H264_USE_OPENCL), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_USE_OPENCL_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_DISABLED), 0);
+	obs_property_list_add_int(p, TEXT_T(AMF_UTIL_TOGGLE_ENABLED), 1);
+
+	/// View Mode
+	p = obs_properties_add_list(props, AMF_H264_VIEW, TEXT_T(AMF_H264_VIEW), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_VIEW_DESCRIPTION));
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_VIEW_BASIC), ViewMode::Basic);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_VIEW_ADVANCED), ViewMode::Advanced);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_VIEW_EXPERT), ViewMode::Expert);
+	obs_property_list_add_int(p, TEXT_T(AMF_H264_VIEW_MASTER), ViewMode::Master);
+	obs_property_set_modified_callback(p, properties_modified);
+	/// Unlock Properties to full range.
+	p = obs_properties_add_bool(props, AMF_H264_UNLOCK_PROPERTIES, TEXT_T(AMF_H264_UNLOCK_PROPERTIES));
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_UNLOCK_PROPERTIES_DESCRIPTION));
+	obs_property_set_modified_callback(p, properties_modified);
+
+	/// Debug
+	p = obs_properties_add_bool(props, AMF_H264_DEBUG, TEXT_T(AMF_H264_DEBUG));
+	obs_property_set_long_description(p, TEXT_T(AMF_H264_DEBUG_DESCRIPTION));
+	#pragma endregion System Properties
+
+	return props;
+}
+
+static void obs_data_default_single(obs_properties_t *props, obs_data_t *data, const char* name) {
+	obs_property_t *p = obs_properties_get(props, name);
+	switch (obs_property_get_type(p)) {
+		case OBS_PROPERTY_INVALID:
+			break;
+		case OBS_PROPERTY_BOOL:
+			obs_data_set_bool(data, name, obs_data_get_default_bool(data, name));
+			break;
+		case OBS_PROPERTY_INT:
+			obs_data_set_int(data, name, obs_data_get_default_int(data, name));
+			break;
+		case OBS_PROPERTY_FLOAT:
+			obs_data_set_double(data, name, obs_data_get_default_double(data, name));
+			break;
+		case OBS_PROPERTY_TEXT:
+		case OBS_PROPERTY_PATH:
+			obs_data_set_string(data, name, obs_data_get_default_string(data, name));
+			break;
+		case OBS_PROPERTY_LIST:
+		case OBS_PROPERTY_EDITABLE_LIST:
+			switch (obs_property_list_format(p)) {
+				case OBS_COMBO_FORMAT_INT:
+					obs_data_set_int(data, name, obs_data_get_default_int(data, name));
+					break;
+				case OBS_COMBO_FORMAT_FLOAT:
+					obs_data_set_double(data, name, obs_data_get_default_double(data, name));
+					break;
+				case OBS_COMBO_FORMAT_STRING:
+					obs_data_set_string(data, name, obs_data_get_default_string(data, name));
+					break;
+			}
+			break;
+		case OBS_PROPERTY_COLOR:
+			break;
+		case OBS_PROPERTY_BUTTON:
+			break;
+		case OBS_PROPERTY_FONT:
+			break;
+		case OBS_PROPERTY_FRAME_RATE:
+			break;
+	}
+}
+
+bool Plugin::Interface::H264Interface::properties_modified(obs_properties_t *props, obs_property_t *, obs_data_t *data) {
+	bool result = false;
+	obs_property_t* p;
+
+	#pragma region Presets
+	Presets preset = (Presets)obs_data_get_int(data, AMF_H264_PRESET);
+	{ // Reset State
+		obs_property_t* pn = obs_properties_first(props);
+		do {
+			obs_property_set_enabled(pn, true);
+		} while (obs_property_next(&pn));
+
+		if (preset != Presets::None) {
+			// System Properties
+			obs_data_set_bool(data, AMF_H264_UNLOCK_PROPERTIES, false);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_UNLOCK_PROPERTIES), false);
+			result = true;
+		}
+	}
+
+	switch (preset) {
+		case ResetToDefaults:
+			#pragma region Default
+		{
+			obs_property_t* pn = obs_properties_first(props);
+			do {
+				const char* name = obs_property_name(pn);
+				switch (obs_property_get_type(pn)) {
+					case obs_property_type::OBS_PROPERTY_BOOL:
+						obs_data_set_bool(data, name, obs_data_get_default_bool(data, name));
+						break;
+					case obs_property_type::OBS_PROPERTY_FLOAT:
+						obs_data_set_double(data, name, obs_data_get_default_double(data, name));
+						break;
+					case obs_property_type::OBS_PROPERTY_INT:
+						obs_data_set_int(data, name, obs_data_get_default_int(data, name));
+						break;
+					case obs_property_type::OBS_PROPERTY_TEXT:
+						obs_data_set_string(data, name, obs_data_get_default_string(data, name));
+						break;
+					case obs_property_type::OBS_PROPERTY_LIST:
+						switch (obs_property_list_format(pn)) {
+							case obs_combo_format::OBS_COMBO_FORMAT_INT:
+								obs_data_set_int(data, name, obs_data_get_default_int(data, name));
+								break;
+							case obs_combo_format::OBS_COMBO_FORMAT_FLOAT:
+								obs_data_set_double(data, name, obs_data_get_default_double(data, name));
+								break;
+							case obs_combo_format::OBS_COMBO_FORMAT_STRING:
+								obs_data_set_string(data, name, obs_data_get_default_string(data, name));
+								break;
+						}
+						break;
+				}
+				obs_property_set_enabled(pn, true);
+			} while (obs_property_next(&pn));
+		}
+		break;
+		#pragma endregion Default
+		case Recording:
+			#pragma region Recording
+			// Static Properties
+			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILE), false);
+			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILELEVEL), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
+
+			// Rate Control Properties
+			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_VariableBitrate_LatencyConstrained);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), false);
+			if (obs_data_get_int(data, AMF_H264_BITRATE_TARGET) < 10000)
+				obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 10000);
+			obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_TARGET), 10000, 100000, 1);
+			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
+			obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_MINIMUM), false);
+			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_MAXIMUM), false);
+			/*obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
+			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
+			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);*/
+			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), false);
+			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), false);
+			//obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+			obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_FILLERDATA), false);
+			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
+			//obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+			// Picture Control Properties
+			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), false);
+			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 60);
+			//obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
+			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
+			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
+			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+			// Miscellaneous Properties
+			//obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
+			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_SCANTYPE), false);
+			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), false);
+			//obs_data_set_int(data, AMF_H264_CABAC, 0);
+			break;
+			#pragma endregion Recording
+		case HighQuality:
+			#pragma region High Quality
+			// Static Properties
+			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILE), false);
+			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILELEVEL), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
+
+			// Rate Control Properties
+			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantQP);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), false);
+			//obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
+			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
+			/*obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
+			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);*/
+			obs_data_set_int(data, AMF_H264_QP_IFRAME, 26);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_IFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_PFRAME, 24);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_PFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_BFRAME, 22);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, -2);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), false);
+			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, -2);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), false);
+			//obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+			//obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
+			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
+			//obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+			// Picture Control Properties
+			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), false);
+			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 60);
+			//obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
+			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
+			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
+			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+			// Miscellaneous Properties
+			//obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
+			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_SCANTYPE), false);
+			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), false);
+			//obs_data_set_int(data, AMF_H264_CABAC, 0);
+			break;
+			#pragma endregion High Quality
+		case Indistinguishable:
+			#pragma region Indistinguishable
+			// Static Properties
+			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILE), false);
+			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILELEVEL), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get_default_int(data, AMF_H264_MAXIMUMLTRFRAMES));
+
+			// Rate Control Properties
+			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantQP);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), false);
+			//obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
+			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
+			/*obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
+			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);*/
+			obs_data_set_int(data, AMF_H264_QP_IFRAME, 21);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_IFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_PFRAME, 19);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_PFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_BFRAME, 17);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, -2);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), false);
+			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, -2);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), false);
+			//obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+			//obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
+			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
+			//obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+			// Picture Control Properties
+			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), false);
+			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 60);
+			//obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, obs_data_get_default_int(data, AMF_H264_BPICTURE_PATTERN));
+			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, obs_data_get_default_int(data, AMF_H264_BPICTURE_REFERENCE));
+			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
+			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+			// Miscellaneous Properties
+			//obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
+			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_SCANTYPE), false);
+			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), false);
+			//obs_data_set_int(data, AMF_H264_CABAC, 0);
+			break;
+			#pragma endregion Indistinguishable
+		case Lossless:
+			#pragma region Lossless
+			// Static Properties
+			//obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_High);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILE), false);
+			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILELEVEL), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, 0);
+
+			// Rate Control Properties
+			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantQP);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), false);
+			//obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 35000 * (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1000 : 1));
+			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
+			/*obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
+			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);*/
+			obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_IFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_PFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BFRAME), false);
+			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), false);
+			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), false);
+			//obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+			//obs_data_set_int(data, AMF_H264_FILLERDATA, 0);
+			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
+			//obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+			// Picture Control Properties
+			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 1);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), false);
+			obs_data_set_int(data, AMF_H264_IDR_PERIOD, 30);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_IDR_PERIOD), false);
+			//obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+			obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_BPICTURE_PATTERN), false);
+			obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_BPICTURE_REFERENCE), false);
+			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
+			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+			// Miscellaneous Properties
+			//obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
+			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_SCANTYPE), false);
+			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), false);
+			//obs_data_set_int(data, AMF_H264_CABAC, 0);
+			break;
+			#pragma endregion Lossless
+		case Twitch:
+			#pragma region Twitch
+			// Static Properties
+			obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_USAGE), false);
+			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_Main);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILE), false);
+			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILELEVEL), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get);
+
+			// Rate Control Properties
+			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantBitrate);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), false);
+			if (obs_data_get_int(data, AMF_H264_BITRATE_TARGET) < 1000)
+				obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 1000);
+			if (obs_data_get_int(data, AMF_H264_BITRATE_TARGET) > 4000)
+				obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 4000);
+			obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_TARGET), 1000, 4000, 1);
+			//obs_data_set_int(data, AMF_H264_BITRATE_PEAK, VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxBitrate / (obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000));
+			obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_MINIMUM), false);
+			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_MAXIMUM), false);
+			/*obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
+			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
+			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);*/
+			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), false);
+			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), false);
+			//obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 80);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 100);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+			obs_data_set_int(data, AMF_H264_FILLERDATA, 1);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_FILLERDATA), false);
+			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
+			//obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+			// Picture Control Properties
+			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 2);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), false);
+			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 120);
+			//obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
+			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
+			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+			// Miscellaneous Properties
+			//obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
+			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_SCANTYPE), false);
+			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), false);
+			//obs_data_set_int(data, AMF_H264_CABAC, 0);
+			break;
+			#pragma endregion Twitch
+		case YouTube:
+			#pragma region YouTube
+			// Static Properties
+			obs_data_set_int(data, AMF_H264_USAGE, VCEUsage_Transcoding);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_USAGE), false);
+			obs_data_set_int(data, AMF_H264_PROFILE, VCEProfile_Main);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILE), false);
+			obs_data_set_int(data, AMF_H264_PROFILELEVEL, VCEProfileLevel_Automatic);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_PROFILELEVEL), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMLTRFRAMES, obs_data_get);
+
+			// Rate Control Properties
+			obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, VCERateControlMethod_ConstantBitrate);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_RATECONTROLMETHOD), false);
+			if (obs_data_get_int(data, AMF_H264_BITRATE_TARGET) < 1000)
+				obs_data_set_int(data, AMF_H264_BITRATE_TARGET, 1000);
+			if (obs_data_get_int(data, AMF_H264_BITRATE_PEAK) > 25000)
+				obs_data_set_int(data, AMF_H264_BITRATE_PEAK, 25000);
+			obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_TARGET), 1000, 25000, 1);
+			obs_data_set_int(data, AMF_H264_QP_MINIMUM, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_MINIMUM), false);
+			obs_data_set_int(data, AMF_H264_QP_MAXIMUM, 51);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_MAXIMUM), false);
+			/*obs_data_set_int(data, AMF_H264_QP_IFRAME, 0);
+			obs_data_set_int(data, AMF_H264_QP_PFRAME, 0);
+			obs_data_set_int(data, AMF_H264_QP_BFRAME, 0);*/
+			obs_data_set_int(data, AMF_H264_QP_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), false);
+			obs_data_set_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA, 0);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), false);
+			//obs_data_set_int(data, AMF_H264_VBVBUFFER, 0);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_STRICTNESS, 80);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), false);
+			//obs_data_set_double(data, AMF_H264_VBVBUFFER_FULLNESS, 100);
+			//obs_property_set_enabled(obs_properties_get(props, AMF_H264_VBVBUFFER_FULLNESS), false);
+			//obs_data_set_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE, 0);
+			obs_data_set_int(data, AMF_H264_FILLERDATA, 1);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_FILLERDATA), false);
+			//obs_data_set_int(data, AMF_H264_FRAMESKIPPING, 0);
+			//obs_data_set_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY, 0);
+
+			// Picture Control Properties
+			obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, 2);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), false);
+			//obs_data_set_int(data, AMF_H264_IDR_PERIOD, 120);
+			//obs_data_set_int(data, AMF_H264_HEADER_INSERTION_SPACING, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_PATTERN, 0);
+			//obs_data_set_int(data, AMF_H264_BPICTURE_REFERENCE, 0);
+			//obs_data_set_int(data, AMF_H264_SLICESPERFRAME, 0);
+			//obs_data_set_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT, 0);
+
+			// Miscellaneous Properties
+			//obs_data_set_int(data, AMF_H264_QUALITY_PRESET, VCEQualityPreset_Quality);
+			obs_data_set_int(data, AMF_H264_SCANTYPE, VCEScanType_Progressive);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_SCANTYPE), false);
+			obs_data_set_int(data, AMF_H264_MOTIONESTIMATION, 3);
+			obs_property_set_enabled(obs_properties_get(props, AMF_H264_MOTIONESTIMATION), false);
+			//obs_data_set_int(data, AMF_H264_CABAC, 0);
+			break;
+			#pragma endregion YouTube
+	}
+	#pragma endregion Presets
+
+	#pragma region Device Capabilities
+	const char* deviceId = obs_data_get_string(data, AMF_H264_DEVICE);
+	auto device = Plugin::API::APIBase::GetDeviceForUniqueId(deviceId);
+	auto caps = Plugin::AMD::VCECapabilities::GetInstance();
+	auto devCaps = caps->GetDeviceCaps(device, VCEEncoderType_AVC);
+	#pragma endregion Device Capabilities
+
+	#pragma region Rebuild UI
+	bool unlocked = obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES);
+	bool lastUnlocked = obs_data_get_bool(data, "last" vstr(AMF_H264_UNLOCK_PROPERTIES));
+	const char* lastDeviceId = obs_data_get_string(data, "last" vstr(AMF_H264_DEVICE));
+	if (strcmp(lastDeviceId, deviceId) != 0 || (unlocked != lastUnlocked)) {
+		#pragma region Static Properties
+		#pragma region Profile
+		p = obs_properties_get(props, AMF_H264_PROFILE);
+		obs_property_list_clear(p);
+		switch (devCaps.maxProfile) {
+			case 100:
+				obs_property_list_add_int(p, "High", VCEProfile_High);
+				obs_property_list_add_int(p, "Constrained High", VCEProfile_ConstrainedHigh);
+			case 77:
+				obs_property_list_add_int(p, "Main", VCEProfile_Main);
+			case 66:
+				obs_property_list_add_int(p, "Baseline", VCEProfile_Baseline);
+				obs_property_list_add_int(p, "Constrained Baseline", VCEProfile_ConstrainedBaseline);
+				break;
+		}
+		#pragma endregion Profile
+		#pragma region Profile Level
+		p = obs_properties_get(props, AMF_H264_PROFILELEVEL);
+		obs_property_list_clear(p);
+		obs_property_list_add_int(p, TEXT_T(AMF_UTIL_AUTOMATIC), VCEProfileLevel_Automatic);
+		switch (devCaps.maxProfileLevel) {
+			case 62:
+				obs_property_list_add_int(p, "6.2", VCEProfileLevel_62);
+			case 61:
+				obs_property_list_add_int(p, "6.1", VCEProfileLevel_61);
+			case 60:
+				obs_property_list_add_int(p, "6.0", VCEProfileLevel_60);
+			case 52:
+				obs_property_list_add_int(p, "5.2", VCEProfileLevel_52);
+			case 51:
+				obs_property_list_add_int(p, "5.1", VCEProfileLevel_51);
+			case 50:
+				obs_property_list_add_int(p, "5.0", VCEProfileLevel_50);
+			case 42: // Some VCE 2.0 Cards.
+				obs_property_list_add_int(p, "4.2", VCEProfileLevel_42);
+			case 41: // Some APUs and VCE 1.0 Cards.
+				obs_property_list_add_int(p, "4.1", VCEProfileLevel_41);
+			case 40: // These should in theory be supported by all VCE 1.0 devices and APUs.
+				obs_property_list_add_int(p, "4.0", VCEProfileLevel_40);
+			case 32:
+				obs_property_list_add_int(p, "3.2", VCEProfileLevel_32);
+			case 31:
+				obs_property_list_add_int(p, "3.1", VCEProfileLevel_31);
+			case 30:
+				obs_property_list_add_int(p, "3.0", VCEProfileLevel_30);
+			case 22:
+				obs_property_list_add_int(p, "2.2", VCEProfileLevel_22);
+			case 21:
+				obs_property_list_add_int(p, "2.1", VCEProfileLevel_21);
+			case 20:
+				obs_property_list_add_int(p, "2.0", VCEProfileLevel_20);
+			case 13:
+				obs_property_list_add_int(p, "1.3", VCEProfileLevel_13);
+			case 12:
+				obs_property_list_add_int(p, "1.2", VCEProfileLevel_12);
+			case 11:
+				obs_property_list_add_int(p, "1.1", VCEProfileLevel_11);
+			case 10:
+			default:
+				obs_property_list_add_int(p, "1.0", VCEProfileLevel_10);
+		}
+		#pragma endregion Profile Level
+		#pragma endregion Static Properties
+
+		#pragma region Unlockable Stuff
+		// Store values.
+		uint64_t bitrateTarget = obs_data_get_int(data, AMF_H264_BITRATE_TARGET),
+			bitratePeak = obs_data_get_int(data, AMF_H264_BITRATE_PEAK),
+			vbvBufferSize = obs_data_get_int(data, AMF_H264_VBVBUFFER_SIZE);
+
+		// Set proper limits
+		uint32_t limitDivisor = unlocked ? 1 : 1000;
+		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_TARGET),
+			10000 / limitDivisor,
+			devCaps.maxBitrate / limitDivisor,
+			1);
+		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_BITRATE_PEAK),
+			10000 / limitDivisor,
+			devCaps.maxBitrate / limitDivisor,
+			1);
+		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_VBVBUFFER_SIZE),
+			1000 / limitDivisor,
+			100000000 / limitDivisor,
+			1);
+		obs_property_float_set_limits(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL),
+			unlocked ? 0 : 1,
+			100,
+			1);
+		obs_property_int_set_limits(obs_properties_get(props, AMF_H264_IDR_PERIOD),
+			unlocked ? 0 : 1,
+			1000,
+			1);
+
+		// Restore values.
+		uint64_t valDivisor = (lastUnlocked && !unlocked ? 1000 : 1);
+		uint64_t valMultiplier = (unlocked && !lastUnlocked ? 1000 : 1);
+
+		obs_data_set_int(data, AMF_H264_BITRATE_TARGET, (bitrateTarget * valMultiplier) / valDivisor);
+		obs_data_set_int(data, AMF_H264_BITRATE_PEAK, (bitratePeak * valMultiplier) / valDivisor);
+		obs_data_set_int(data, AMF_H264_VBVBUFFER_SIZE, (vbvBufferSize * valMultiplier) / valDivisor);
+		#pragma endregion Unlockable Stuff
+
+		obs_data_set_bool(data, "last" vstr(AMF_H264_UNLOCK_PROPERTIES), unlocked);
+		obs_data_set_string(data, "last" vstr(AMF_H264_DEVICE), deviceId);
+		result = true;
+	}
+	#pragma endregion Rebuild UI
+
+	#pragma region View Mode
+	uint32_t view = (uint32_t)obs_data_get_int(data, AMF_H264_VIEW);
+	bool vis_basic = view >= ViewMode::Basic,
+		vis_advanced = view >= ViewMode::Advanced,
+		vis_expert = view >= ViewMode::Expert,
+		vis_master = view >= ViewMode::Master;
+
+	uint32_t lastView = (uint32_t)obs_data_get_int(data, "last" vstr(AMF_H264_VIEW));
+	if (lastView != view) {
+		obs_data_set_int(data, "last" vstr(AMF_H264_VIEW), view);
+		result = true;
+	}
+
+	#pragma region Basic
+	const char* basicProps[] = {
+		AMF_H264_QUALITY_PRESET,
+		AMF_H264_PROFILE,
+		AMF_H264_RATECONTROLMETHOD,
+		AMF_H264_DEBUG,
+	};
+	for (auto prop : basicProps) {
+		obs_property_set_visible(obs_properties_get(props, prop), vis_basic);
+		if (!vis_basic)
+			obs_data_default_single(props, data, prop);
+	}
+	#pragma endregion Basic
+
+	#pragma region Advanced
+	const char* advancedProps[] = {
+		AMF_H264_VBVBUFFER,
+		AMF_H264_FRAMESKIPPING,
+		AMF_H264_DEBLOCKINGFILTER,
+		AMF_H264_DEVICE,
+	};
+	for (auto prop : advancedProps) {
+		obs_property_set_visible(obs_properties_get(props, prop), vis_advanced);
+		if (!vis_advanced)
+			obs_data_default_single(props, data, prop);
+	}
+	#pragma endregion Advanced
+
+	#pragma region Expert
+	const char* expertProps[] = {
+		AMF_H264_PROFILELEVEL,
+		AMF_H264_CODINGTYPE,
+		AMF_H264_VBVBUFFER_FULLNESS,
+		AMF_H264_ENFORCEHRDCOMPATIBILITY,
+		AMF_H264_MOTIONESTIMATION,
+		AMF_H264_USE_OPENCL,
+	};
+	for (auto prop : expertProps) {
+		obs_property_set_visible(obs_properties_get(props, prop), vis_expert);
+		if (!vis_expert)
+			obs_data_default_single(props, data, prop);
+	}
+	#pragma endregion Expert
+
+	#pragma region Master
+	const char* masterProps[] = {
+		AMF_H264_USAGE,
+		AMF_H264_MAXIMUMLTRFRAMES,
+		AMF_H264_MAXIMUMACCESSUNITSIZE,
+		AMF_H264_IDR_PERIOD,
+		AMF_H264_HEADER_INSERTION_SPACING,
+		AMF_H264_SLICESPERFRAME,
+		AMF_H264_INTRAREFRESHNUMMBSPERSLOT,
+		AMF_H264_SCANTYPE,
+		AMF_H264_UNLOCK_PROPERTIES,
+	};
+	for (auto prop : masterProps) {
+		obs_property_set_visible(obs_properties_get(props, prop), vis_master);
+		if (!vis_master)
+			obs_data_default_single(props, data, prop);
+	}
+	#pragma endregion Master
+
+	#pragma region Special Logic
+	uint32_t ltrFrames = (uint32_t)obs_data_get_int(data, AMF_H264_MAXIMUMLTRFRAMES);
+	bool usingLTRFrames = ltrFrames > 0;
+
+	// Keyframe Interval
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_KEYFRAME_INTERVAL), !vis_master);
+	if (vis_master)
+		obs_data_default_single(props, data, AMF_H264_KEYFRAME_INTERVAL);
+
+	#pragma region Rate Control
+	bool vis_rcm_bitrate_target = false,
+		vis_rcm_bitrate_peak = false,
+		vis_rcm_qp = false,
+		vis_rcm_qp_b = false,
+		vis_rcm_fillerdata = false;
+
+	VCERateControlMethod rcm = (VCERateControlMethod)obs_data_get_int(data, AMF_H264_RATECONTROLMETHOD);
+	switch (rcm) {
+		case VCERateControlMethod_ConstantBitrate:
+			vis_rcm_bitrate_target = true;
+			vis_rcm_fillerdata = true;
+			break;
+		case VCERateControlMethod_VariableBitrate_PeakConstrained:
+			vis_rcm_bitrate_target = true;
+			vis_rcm_bitrate_peak = true;
+			break;
+		case VCERateControlMethod_VariableBitrate_LatencyConstrained:
+			vis_rcm_bitrate_target = true;
+			vis_rcm_bitrate_peak = true;
+			break;
+		case VCERateControlMethod_ConstantQP:
+			vis_rcm_qp = true;
+			vis_rcm_qp_b = (!usingLTRFrames) && devCaps.supportsBFrames;
+			break;
+	}
+
+	VCERateControlMethod lastRCM = (VCERateControlMethod)obs_data_get_int(data, "last" vstr(AMF_H264_RATECONTROLMETHOD));
+	if (lastRCM != rcm) {
+		obs_data_set_int(data, "last" vstr(AMF_H264_RATECONTROLMETHOD), rcm);
+		result = true;
+	}
+
+	/// Bitrate
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_BITRATE_TARGET), vis_rcm_bitrate_target);
+	if (!vis_rcm_bitrate_target)
+		obs_data_default_single(props, data, AMF_H264_BITRATE_TARGET);
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_BITRATE_PEAK), vis_rcm_bitrate_peak);
+	if (!vis_rcm_bitrate_peak)
+		obs_data_default_single(props, data, AMF_H264_BITRATE_PEAK);
+
+	/// QP
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_IFRAME), vis_rcm_qp);
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_PFRAME), vis_rcm_qp);
+	if (!vis_rcm_qp) {
+		obs_data_default_single(props, data, AMF_H264_QP_IFRAME);
+		obs_data_default_single(props, data, AMF_H264_QP_PFRAME);
+	}
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_BFRAME), vis_rcm_qp_b);
+	if (!vis_rcm_qp_b)
+		obs_data_default_single(props, data, AMF_H264_QP_BFRAME);
+
+	/// QP Min/Max
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_MINIMUM), vis_advanced && !vis_rcm_qp);
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_MAXIMUM), vis_advanced && !vis_rcm_qp);
+	if (!vis_advanced || vis_rcm_qp) {
+		obs_data_default_single(props, data, AMF_H264_QP_MINIMUM);
+		obs_data_default_single(props, data, AMF_H264_QP_MAXIMUM);
+	}
+
+	/// Filler Data (CBR only at the moment)
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_FILLERDATA), vis_rcm_fillerdata);
+	if (!vis_rcm_fillerdata)
+		obs_data_default_single(props, data, AMF_H264_FILLERDATA);
+	#pragma endregion Rate Control
+	#pragma region VBV Buffer
+	uint32_t vbvBufferMode = (uint32_t)obs_data_get_int(data, AMF_H264_VBVBUFFER);
+	bool vbvBufferVisible = vis_advanced;
+
+	uint32_t lastVBVBufferMode = (uint32_t)obs_data_get_int(data, "last" vstr(AMF_H264_VBVBUFFER));
+	if (lastVBVBufferMode != vbvBufferMode) {
+		obs_data_set_int(data, "last" vstr(AMF_H264_VBVBUFFER), vbvBufferMode);
+		result = true;
+	}
+
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_VBVBUFFER_STRICTNESS), vbvBufferVisible && (vbvBufferMode == 0));
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_VBVBUFFER_SIZE), vbvBufferVisible && (vbvBufferMode == 1));
+	if (!vbvBufferVisible) {
+		if (vbvBufferMode == 0) {
+			obs_data_default_single(props, data, AMF_H264_VBVBUFFER_SIZE);
+		} else if (vbvBufferMode == 1) {
+			obs_data_default_single(props, data, AMF_H264_VBVBUFFER_STRICTNESS);
+		}
+	}
+	#pragma endregion VBV Buffer
+	#pragma region B-Frames
+	/// Pattern
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_BPICTURE_PATTERN), vis_advanced && !usingLTRFrames && devCaps.supportsBFrames);
+	if (!vis_advanced || usingLTRFrames || !devCaps.supportsBFrames)
+		obs_data_default_single(props, data, AMF_H264_BPICTURE_PATTERN);
+	bool usingBPictures = obs_data_get_int(data, AMF_H264_BPICTURE_PATTERN) != 0;
+
+	bool lastUsingBPictures = obs_data_get_int(data, "last" vstr(AMF_H264_BPICTURE_PATTERN)) != 0;
+	if (usingBPictures != lastUsingBPictures) {
+		obs_data_set_int(data, "last" vstr(AMF_H264_BPICTURE_PATTERN), obs_data_get_int(data, AMF_H264_BPICTURE_PATTERN));
+		result = true;
+	}
+
+	/// Reference
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_BPICTURE_REFERENCE), vis_advanced && !usingLTRFrames && usingBPictures && devCaps.supportsBFrames);
+	if (!vis_advanced || usingLTRFrames || !usingBPictures || !devCaps.supportsBFrames)
+		obs_data_default_single(props, data, AMF_H264_BPICTURE_REFERENCE);
+	bool usingBPictureReference = obs_data_get_int(data, AMF_H264_BPICTURE_REFERENCE) == 1;
+
+	bool lastUsingBPictureReference = obs_data_get_int(data, "last" vstr(AMF_H264_BPICTURE_REFERENCE)) != 0;
+	if (usingBPictureReference != lastUsingBPictureReference) {
+		obs_data_set_int(data, "last" vstr(AMF_H264_BPICTURE_REFERENCE), obs_data_get_int(data, AMF_H264_BPICTURE_REFERENCE));
+		result = true;
+	}
+
+	/// QP Delta
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_BPICTURE_DELTA), vis_advanced && usingBPictures && devCaps.supportsBFrames);
+	if (!vis_advanced || !usingBPictures || !devCaps.supportsBFrames)
+		obs_data_default_single(props, data, AMF_H264_QP_BPICTURE_DELTA);
+	obs_property_set_visible(obs_properties_get(props, AMF_H264_QP_REFERENCE_BPICTURE_DELTA), vis_advanced && usingBPictures && usingBPictureReference && devCaps.supportsBFrames);
+	if (!vis_advanced || !usingBPictures || !usingBPictureReference || !devCaps.supportsBFrames)
+		obs_data_default_single(props, data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA);
+	#pragma endregion B-Frames
+	#pragma endregion Special Logic
+	#pragma endregion View Mode
+
+	return result;
+}
+
+bool Plugin::Interface::H264Interface::update(void *data, obs_data_t *settings) {
+	try {
+		return static_cast<Plugin::Interface::H264Interface*>(data)->update(settings);
+	} catch (...) {
+		AMF_LOG_ERROR("Unable to update Encoder, see log for more information.");
+		return false;
+	}
+}
+
+void Plugin::Interface::H264Interface::get_video_info(void *data, struct video_scale_info *info) {
+	try {
+		return static_cast<Plugin::Interface::H264Interface*>(data)->get_video_info(info);
+	} catch (...) {
+		AMF_LOG_ERROR("Unable to get video info, see log for more information.");
+	}
+}
+
+bool Plugin::Interface::H264Interface::get_extra_data(void *data, uint8_t** extra_data, size_t* size) {
+	try {
+		return static_cast<Plugin::Interface::H264Interface*>(data)->get_extra_data(extra_data, size);
+	} catch (...) {
+		AMF_LOG_ERROR("Unable to get extra data, see log for more information.");
+		return false;
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Module Code
+//////////////////////////////////////////////////////////////////////////
+Plugin::Interface::H264Interface::H264Interface(obs_data_t* data, obs_encoder_t* encoder) {
+	AMF_LOG_DEBUG("<H264Interface::H264Interface> Initializing...");
+
+	// OBS Settings
+	uint32_t m_cfgWidth = obs_encoder_get_width(encoder);
+	uint32_t m_cfgHeight = obs_encoder_get_height(encoder);
+	video_t *video = obs_encoder_video(encoder);
+	const struct video_output_info *voi = video_output_get_info(video);
+	uint32_t m_cfgFPSnum = voi->fps_num;
+	uint32_t m_cfgFPSden = voi->fps_den;
+
+	//////////////////////////////////////////////////////////////////////////
+	/// Initialize Encoder
+	bool debug = obs_data_get_bool(data, AMF_H264_DEBUG);
+	Plugin::AMD::AMF::GetInstance()->EnableDebugTrace(debug);
+
+	VCEColorFormat surfFormat = VCEColorFormat_NV12;
+	switch (voi->format) {
+		case VIDEO_FORMAT_NV12:
+			surfFormat = VCEColorFormat_NV12;
+			break;
+		case VIDEO_FORMAT_I420:
+			surfFormat = VCEColorFormat_I420;
+			break;
+		case VIDEO_FORMAT_YUY2:
+			surfFormat = VCEColorFormat_YUY2;
+			break;
+		case VIDEO_FORMAT_RGBA:
+			surfFormat = VCEColorFormat_RGBA;
+			break;
+		case VIDEO_FORMAT_BGRA:
+			surfFormat = VCEColorFormat_BGRA;
+			break;
+		case VIDEO_FORMAT_Y800:
+			surfFormat = VCEColorFormat_GRAY;
+			break;
+	}
+	m_VideoEncoder = new VCEEncoder(VCEEncoderType_AVC,
+		std::string(obs_data_get_string(data, AMF_H264_DEVICE)),
+		!!obs_data_get_int(data, AMF_H264_USE_OPENCL),
+		surfFormat);
+	m_VideoEncoder->SetColorProfile(voi->colorspace == VIDEO_CS_709 ? VCEColorProfile_709 : VCEColorProfile_601);
+	m_VideoEncoder->SetFullColorRangeEnabled(voi->range == VIDEO_RANGE_FULL);
+
+	/// Static Properties
+	m_VideoEncoder->SetUsage((VCEUsage)obs_data_get_int(data, AMF_H264_USAGE));
+	m_VideoEncoder->SetQualityPreset((VCEQualityPreset)obs_data_get_int(data, AMF_H264_QUALITY_PRESET));
+
+	/// Framesize & Framerate
+	m_VideoEncoder->SetFrameSize(m_cfgWidth, m_cfgHeight);
+	m_VideoEncoder->SetFrameRate(m_cfgFPSnum, m_cfgFPSden);
+
+	/// Profile & Level
+	m_VideoEncoder->SetProfile((VCEProfile)obs_data_get_int(data, AMF_H264_PROFILE));
+	m_VideoEncoder->SetProfileLevel((VCEProfileLevel)obs_data_get_int(data, AMF_H264_PROFILELEVEL));
+
+	/// LTR Stuff
+	if ((uint32_t)obs_data_get_int(data, AMF_H264_MAXIMUMLTRFRAMES) > 0)
+		m_VideoEncoder->SetBPicturePattern(VCEBPicturePattern_None);
+	m_VideoEncoder->SetMaximumLongTermReferenceFrames((uint32_t)obs_data_get_int(data, AMF_H264_MAXIMUMLTRFRAMES));
+
+	/// Miscellaneous Properties
+	m_VideoEncoder->SetScanType((VCEScanType)obs_data_get_int(data, AMF_H264_SCANTYPE));
+	m_VideoEncoder->SetCodingType((VCECodingType)obs_data_get_int(data, AMF_H264_CODINGTYPE));
+	//m_VideoEncoder->SetRateControlPreanalysisEnabled(true);
+	//m_VideoEncoder->SetWaitForTaskEnabled(true);
+	//m_VideoEncoder->SetMaximumNumberOfReferenceFrames(VCECapabilities::GetInstance()->GetEncoderCaps(VCEEncoderType_AVC)->maxReferenceFrames);
+
+	// OBS - Enforce Streaming Service Restrictions
+	#pragma region OBS - Enforce Streaming Service Restrictions
+	{
+		// Profile
+		const char* p_str = obs_data_get_string(data, "profile");
+		if (strcmp(p_str, "") != 0) {
+			if (strcmp(p_str, "baseline")) {
+				m_VideoEncoder->SetProfile(VCEProfile_Baseline);
+			} else if (strcmp(p_str, "main")) {
+				m_VideoEncoder->SetProfile(VCEProfile_Main);
+			} else if (strcmp(p_str, "high")) {
+				m_VideoEncoder->SetProfile(VCEProfile_High);
+			}
+		} else {
+			switch (m_VideoEncoder->GetProfile()) {
+				case VCEProfile_Baseline:
+					obs_data_set_string(data, "profile", "baseline");
+					break;
+				case VCEProfile_Main:
+					obs_data_set_string(data, "profile", "main");
+					break;
+				case VCEProfile_High:
+					obs_data_set_string(data, "profile", "high");
+					break;
+			}
+		}
+
+		// Preset
+		const char* preset = obs_data_get_string(data, "preset");
+		if (strcmp(preset, "") != 0) {
+			if (strcmp(preset, "speed") == 0) {
+				m_VideoEncoder->SetQualityPreset(VCEQualityPreset_Speed);
+			} else if (strcmp(preset, "balanced") == 0) {
+				m_VideoEncoder->SetQualityPreset(VCEQualityPreset_Balanced);
+			} else if (strcmp(preset, "quality") == 0) {
+				m_VideoEncoder->SetQualityPreset(VCEQualityPreset_Quality);
+			}
+			obs_data_set_int(data, AMF_H264_QUALITY_PRESET, m_VideoEncoder->GetQualityPreset());
+		} else {
+			switch (m_VideoEncoder->GetQualityPreset()) {
+				case VCEQualityPreset_Speed:
+					obs_data_set_string(data, "preset", "speed");
+					break;
+				case VCEQualityPreset_Balanced:
+					obs_data_set_string(data, "preset", "balanced");
+					break;
+				case VCEQualityPreset_Quality:
+					obs_data_set_string(data, "preset", "quality");
+					break;
+			}
+		}
+	}
+	#pragma endregion OBS - Enforce Streaming Service Restrictions
+
+	// Dynamic Properties (Can be changed during Encoding)
+	this->update(data);
+
+	// Initialize (locks static properties)
+	try {
+		m_VideoEncoder->Start();
+	} catch (...) {
+		throw;
+	}
+
+	// Dynamic Properties (Can be changed during Encoding)
+	this->update(data);
+
+	AMF_LOG_DEBUG("<H264Interface::H264Interface> Complete.");
+}
+
+Plugin::Interface::H264Interface::~H264Interface() {
+	AMF_LOG_DEBUG("<H264Interface::~H264Interface> Finalizing...");
+	if (m_VideoEncoder) {
+		m_VideoEncoder->Stop();
+		delete m_VideoEncoder;
+	}
+	AMF_LOG_DEBUG("<H264Interface::~H264Interface> Complete.");
+}
+
+bool Plugin::Interface::H264Interface::update(obs_data_t* data) {
+	#pragma region Device Capabilities
+	const char* deviceId = obs_data_get_string(data, AMF_H264_DEVICE);
+	auto device = Plugin::API::APIBase::GetDeviceForUniqueId(deviceId);
+	auto caps = Plugin::AMD::VCECapabilities::GetInstance();
+	auto devCaps = caps->GetDeviceCaps(device, VCEEncoderType_AVC);
+	#pragma endregion Device Capabilities
+
+	double_t framerate = (double_t)m_VideoEncoder->GetFrameRate().first / (double_t)m_VideoEncoder->GetFrameRate().second;
+	int32_t bitrateMultiplier = obs_data_get_bool(data, AMF_H264_UNLOCK_PROPERTIES) ? 1 : 1000;
+
+	// Rate Control Properties
+	m_VideoEncoder->SetRateControlMethod((VCERateControlMethod)obs_data_get_int(data, AMF_H264_RATECONTROLMETHOD));
+	m_VideoEncoder->SetMinimumQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_MINIMUM));
+	m_VideoEncoder->SetMaximumQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_MAXIMUM));
+	switch ((VCERateControlMethod)obs_data_get_int(data, AMF_H264_RATECONTROLMETHOD)) {
+		case VCERateControlMethod_ConstantBitrate:
+			m_VideoEncoder->SetTargetBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * bitrateMultiplier);
+			m_VideoEncoder->SetPeakBitrate(m_VideoEncoder->GetTargetBitrate());
+			break;
+		case VCERateControlMethod_VariableBitrate_PeakConstrained:
+			m_VideoEncoder->SetTargetBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * bitrateMultiplier);
+			m_VideoEncoder->SetPeakBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_PEAK) * bitrateMultiplier);
+			break;
+		case VCERateControlMethod_VariableBitrate_LatencyConstrained:
+			m_VideoEncoder->SetTargetBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_TARGET) * bitrateMultiplier);
+			m_VideoEncoder->SetPeakBitrate((uint32_t)obs_data_get_int(data, AMF_H264_BITRATE_PEAK) * bitrateMultiplier);
+			break;
+		case VCERateControlMethod_ConstantQP:
+			m_VideoEncoder->SetIFrameQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_IFRAME));
+			m_VideoEncoder->SetPFrameQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_PFRAME));
+			try {
+				m_VideoEncoder->SetBFrameQP((uint8_t)obs_data_get_int(data, AMF_H264_QP_BFRAME));
+			} catch (...) {}
+			break;
+	}
+	if (obs_data_get_int(data, AMF_H264_VBVBUFFER) == 0) {
+		m_VideoEncoder->SetVBVBufferAutomatic(obs_data_get_double(data, AMF_H264_VBVBUFFER_STRICTNESS) / 100.0);
+	} else {
+		m_VideoEncoder->SetVBVBufferSize((uint32_t)obs_data_get_int(data, AMF_H264_VBVBUFFER_SIZE) * bitrateMultiplier);
+	}
+	m_VideoEncoder->SetInitialVBVBufferFullness(obs_data_get_double(data, AMF_H264_VBVBUFFER_FULLNESS) / 100.0);
+	m_VideoEncoder->SetEnforceHRDRestrictionsEnabled(obs_data_get_int(data, AMF_H264_ENFORCEHRDCOMPATIBILITY) == 1);
+	m_VideoEncoder->SetFillerDataEnabled(obs_data_get_int(data, AMF_H264_FILLERDATA) == 1);
+	m_VideoEncoder->SetFrameSkippingEnabled(obs_data_get_int(data, AMF_H264_FRAMESKIPPING) == 1);
+	if (obs_data_get_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE) != 0)
+		m_VideoEncoder->SetMaximumAccessUnitSize((uint32_t)obs_data_get_int(data, AMF_H264_MAXIMUMACCESSUNITSIZE));
+
+	// Picture Control Properties
+	if (obs_data_get_int(data, AMF_H264_VIEW) == ViewMode::Master)
+		m_VideoEncoder->SetIDRPeriod((uint32_t)obs_data_get_int(data, AMF_H264_IDR_PERIOD));
+	else
+		m_VideoEncoder->SetIDRPeriod(max((uint32_t)(obs_data_get_double(data, AMF_H264_KEYFRAME_INTERVAL) * framerate), 1));
+	if (obs_data_get_int(data, AMF_H264_HEADER_INSERTION_SPACING) != 0)
+		m_VideoEncoder->SetHeaderInsertionSpacing((uint32_t)obs_data_get_int(data, AMF_H264_HEADER_INSERTION_SPACING));
+	m_VideoEncoder->SetDeblockingFilterEnabled(!!obs_data_get_int(data, AMF_H264_DEBLOCKINGFILTER));
+	if (devCaps.supportsBFrames) {
+		try {
+			m_VideoEncoder->SetBPicturePattern((VCEBPicturePattern)obs_data_get_int(data, AMF_H264_BPICTURE_PATTERN));
+			m_VideoEncoder->SetBPictureReferenceEnabled(!!obs_data_get_int(data, AMF_H264_BPICTURE_REFERENCE));
+		} catch (...) {}
+		try {
+			if (m_VideoEncoder->GetBPicturePattern() != VCEBPicturePattern_None) {
+				m_VideoEncoder->SetBPictureDeltaQP((int8_t)obs_data_get_int(data, AMF_H264_QP_BPICTURE_DELTA));
+				if (m_VideoEncoder->IsBPictureReferenceEnabled())
+					m_VideoEncoder->SetReferenceBPictureDeltaQP((int8_t)obs_data_get_int(data, AMF_H264_QP_REFERENCE_BPICTURE_DELTA));
+			}
+		} catch (...) {}
+	}
+	if (obs_data_get_int(data, AMF_H264_SLICESPERFRAME) != 0)
+		m_VideoEncoder->SetSlicesPerFrame((uint32_t)obs_data_get_int(data, AMF_H264_SLICESPERFRAME));
+	if (obs_data_get_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT) != 0)
+		m_VideoEncoder->SetIntraRefreshMBsNumberPerSlot((uint32_t)obs_data_get_int(data, AMF_H264_INTRAREFRESHNUMMBSPERSLOT));
+
+	// Miscellaneous Properties
+	m_VideoEncoder->SetHalfPixelMotionEstimationEnabled(!!(obs_data_get_int(data, AMF_H264_MOTIONESTIMATION) & 1));
+	m_VideoEncoder->SetQuarterPixelMotionEstimationEnabled(!!(obs_data_get_int(data, AMF_H264_MOTIONESTIMATION) & 2));
+
+	if (m_VideoEncoder->IsStarted()) {
+		// OBS - Enforce Streaming Service Stuff
+		#pragma region OBS Enforce Streaming Service Settings
+		{
+			// Rate Control Method
+			const char* t_str = obs_data_get_string(data, "rate_control");
+			if (strcmp(t_str, "") != 0) {
+				if (strcmp(t_str, "CBR") == 0) {
+					m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_ConstantBitrate);
+					m_VideoEncoder->SetFillerDataEnabled(true);
+				} else if (strcmp(t_str, "VBR") == 0) {
+					m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_VariableBitrate_PeakConstrained);
+				} else if (strcmp(t_str, "VBR_LAT") == 0) {
+					m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_VariableBitrate_LatencyConstrained);
+				} else if (strcmp(t_str, "CQP") == 0) {
+					m_VideoEncoder->SetRateControlMethod(VCERateControlMethod_ConstantQP);
+				}
+
+				obs_data_set_int(data, AMF_H264_RATECONTROLMETHOD, m_VideoEncoder->GetRateControlMethod());
+			} else {
+				switch (m_VideoEncoder->GetRateControlMethod()) {
+					case VCERateControlMethod_ConstantBitrate:
+						obs_data_set_string(data, "rate_control", "CBR");
+						break;
+					case VCERateControlMethod_VariableBitrate_PeakConstrained:
+						obs_data_set_string(data, "rate_control", "VBR");
+						break;
+					case VCERateControlMethod_VariableBitrate_LatencyConstrained:
+						obs_data_set_string(data, "rate_control", "VBR_LAT");
+						break;
+					case VCERateControlMethod_ConstantQP:
+						obs_data_set_string(data, "rate_control", "CQP");
+						break;
+				}
+			}
+
+			// Bitrate
+			uint64_t bitrateOvr = obs_data_get_int(data, "bitrate") * 1000;
+			if (bitrateOvr != -1) {
+				if (m_VideoEncoder->GetTargetBitrate() > bitrateOvr)
+					m_VideoEncoder->SetTargetBitrate((uint32_t)bitrateOvr);
+
+				if (m_VideoEncoder->GetPeakBitrate() > bitrateOvr)
+					m_VideoEncoder->SetPeakBitrate((uint32_t)bitrateOvr);
+
+				obs_data_set_int(data, "bitrate", m_VideoEncoder->GetTargetBitrate() / 1000);
+
+				obs_data_set_int(data, AMF_H264_BITRATE_TARGET, m_VideoEncoder->GetTargetBitrate() / bitrateMultiplier);
+				obs_data_set_int(data, AMF_H264_BITRATE_PEAK, m_VideoEncoder->GetPeakBitrate() / bitrateMultiplier);
+			} else {
+				obs_data_set_int(data, "bitrate", m_VideoEncoder->GetTargetBitrate() / 1000);
+			}
+
+			// IDR-Period (Keyframes)
+			uint32_t fpsNum = m_VideoEncoder->GetFrameRate().first;
+			uint32_t fpsDen = m_VideoEncoder->GetFrameRate().second;
+			if (obs_data_get_int(data, "keyint_sec") != -1) {
+				m_VideoEncoder->SetIDRPeriod((uint32_t)(obs_data_get_int(data, "keyint_sec") * ((double_t)fpsNum / (double_t)fpsDen)));
+
+				obs_data_set_double(data, AMF_H264_KEYFRAME_INTERVAL, (double_t)obs_data_get_int(data, "keyint_sec"));
+				obs_data_set_int(data, AMF_H264_IDR_PERIOD, (uint32_t)(obs_data_get_int(data, "keyint_sec") * ((double_t)fpsNum / (double_t)fpsDen)));
+			} else {
+				obs_data_set_int(data, "keyint_sec", (uint64_t)(m_VideoEncoder->GetIDRPeriod() / ((double_t)fpsNum / (double_t)fpsDen)));
+			}
+		}
+		#pragma endregion OBS Enforce Streaming Service Settings
+
+		// Verify
+		m_VideoEncoder->LogProperties();
+		if (obs_data_get_int(data, AMF_H264_VIEW) >= ViewMode::Master)
+			AMF_LOG_ERROR("View Mode 'Master' is active, avoid giving anything but basic support. Error is most likely caused by user settings themselves.");
+	}
+
+	return true;
+}
+
+bool Plugin::Interface::H264Interface::encode(struct encoder_frame * frame, struct encoder_packet * packet, bool * received_packet) {
+	if (!frame || !packet || !received_packet)
+		return false;
+
+	bool retVal = true;
+
+	retVal = m_VideoEncoder->SendInput(frame);
+	retVal = retVal && m_VideoEncoder->GetOutput(packet, received_packet);
+
+	return retVal;
+}
+
+void Plugin::Interface::H264Interface::get_video_info(struct video_scale_info* info) {
+	m_VideoEncoder->GetVideoInfo(info);
+}
+
+bool Plugin::Interface::H264Interface::get_extra_data(uint8_t** extra_data, size_t* size) {
+	return m_VideoEncoder->GetExtraData(extra_data, size);
+}

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/misc-util.cpp Added

@@ -0,0 +1,229 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+
+// Plugin
+#include "plugin.h"
+#include "amd-amf.h"
+#include "amd-amf-vce.h"
+#include "amd-amf-vce-capabilities.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+using namespace Plugin::AMD;
+
+namespace Plugin {
+	namespace Utility {
+		VCEProfileLevel inline GetMinimumProfileLevel(std::pair<uint32_t, uint32_t> frameSize, std::pair<uint32_t, uint32_t> frameRate) {
+			typedef std::pair<uint32_t, uint32_t> levelRestriction;
+			typedef std::pair<VCEProfileLevel, levelRestriction> level;
+
+			static const level profileLevelLimit[] = { // [Level, [Samples, Samples_Per_Sec]]
+				level(VCEProfileLevel_10, levelRestriction(25344, 380160)),
+				level(VCEProfileLevel_11, levelRestriction(101376, 768000)),
+				level(VCEProfileLevel_12, levelRestriction(101376, 1536000)),
+				level(VCEProfileLevel_13, levelRestriction(101376, 3041280)),
+				level(VCEProfileLevel_20, levelRestriction(101376, 3041280)),
+				level(VCEProfileLevel_21, levelRestriction(202752, 5068800)),
+				level(VCEProfileLevel_22, levelRestriction(414720, 5184000)),
+				level(VCEProfileLevel_30, levelRestriction(414720, 10368000)),
+				level(VCEProfileLevel_31, levelRestriction(921600, 27648000)),
+				level(VCEProfileLevel_32, levelRestriction(1310720, 55296000)),
+				//level(VCEProfileLevel_40, levelRestriction(2097152, 62914560)), // Technically identical to 4.1, but backwards compatible.
+				level(VCEProfileLevel_41, levelRestriction(2097152, 62914560)),
+				level(VCEProfileLevel_42, levelRestriction(2228224, 133693440)),
+				level(VCEProfileLevel_50, levelRestriction(5652480, 150994944)),
+				level(VCEProfileLevel_51, levelRestriction(9437184, 251658240)),
+				level(VCEProfileLevel_52, levelRestriction(9437184, 530841600)),
+				level((VCEProfileLevel)-1, levelRestriction(0, 0))
+			};
+
+			uint32_t samples = frameSize.first * frameSize.second;
+			uint32_t samples_sec = (uint32_t)ceil((double_t)samples * ((double_t)frameRate.first / (double_t)frameRate.second));
+
+			level curLevel = profileLevelLimit[0];
+			for (uint32_t index = 0; curLevel.first != -1; index++) {
+				curLevel = profileLevelLimit[index];
+
+				if (samples > curLevel.second.first)
+					continue;
+
+				if (samples_sec > curLevel.second.second)
+					continue;
+
+				return curLevel.first;
+			}
+			return VCEProfileLevel_52;
+		}
+
+		#pragma region VCEMemoryType
+		inline const char* MemoryTypeAsString(VCEMemoryType memoryType) {
+			static const char* memoryTypeToString[] = {
+				"Host",
+				"DirectX9",
+				"DirectX11",
+				"OpenGL"
+			};
+			return memoryTypeToString[memoryType];
+		}
+		inline amf::AMF_MEMORY_TYPE MemoryTypeAsAMF(VCEMemoryType memoryType) {
+			static amf::AMF_MEMORY_TYPE memoryTypeToAMF[] = {
+				amf::AMF_MEMORY_HOST,
+				amf::AMF_MEMORY_DX9,
+				amf::AMF_MEMORY_DX11,
+				amf::AMF_MEMORY_OPENGL,
+			};
+			return memoryTypeToAMF[memoryType];
+		}
+		#pragma endregion VCEMemoryType
+		#pragma region VCESurfaceFormat
+		inline const char* SurfaceFormatAsString(VCEColorFormat surfaceFormat) {
+			static const char* surfaceFormatToString[] = {
+				"NV12",
+				"I420",
+				"YUY2",
+				"BGRA",
+				"RGBA",
+				"GRAY",
+			};
+			return surfaceFormatToString[surfaceFormat];
+		}
+		inline amf::AMF_SURFACE_FORMAT SurfaceFormatAsAMF(VCEColorFormat surfaceFormat) {
+			static amf::AMF_SURFACE_FORMAT surfaceFormatToAMF[] = {
+				// 4:2:0 Formats
+				amf::AMF_SURFACE_NV12,
+				amf::AMF_SURFACE_YUV420P,
+				// 4:2:2 Formats
+				amf::AMF_SURFACE_YUY2,
+				// Uncompressed
+				amf::AMF_SURFACE_BGRA,
+				amf::AMF_SURFACE_RGBA,
+				// Other
+				amf::AMF_SURFACE_GRAY8,
+			};
+			return surfaceFormatToAMF[surfaceFormat];
+		}
+		#pragma endregion VCESurfaceFormat
+		#pragma region VCEUsage
+		inline const char* UsageAsString(VCEUsage usage) {
+			static const char* usageToString[] = {
+				"Transcoding",
+				"Ultra Low Latency",
+				"Low Latency",
+				"Webcam"
+			};
+			return usageToString[usage];
+		}
+		inline AMF_VIDEO_ENCODER_USAGE_ENUM UsageAsAMF(VCEUsage usage) {
+			static AMF_VIDEO_ENCODER_USAGE_ENUM usageToAMF[] = {
+				AMF_VIDEO_ENCODER_USAGE_TRANSCONDING,
+				AMF_VIDEO_ENCODER_USAGE_ULTRA_LOW_LATENCY,
+				AMF_VIDEO_ENCODER_USAGE_LOW_LATENCY,
+				AMF_VIDEO_ENCODER_USAGE_WEBCAM,
+			};
+			return usageToAMF[usage];
+		}
+		inline VCEUsage UsageFromAMF(uint32_t usage) {
+			static VCEUsage usageFromAMF[] = {
+				VCEUsage_Transcoding,
+				VCEUsage_UltraLowLatency,
+				VCEUsage_LowLatency,
+				VCEUsage_Webcam,
+			};
+			return usageFromAMF[usage];
+		}
+		#pragma endregion VCEUsage
+		#pragma region VCEQualityPreset
+		inline const char* QualityPresetAsString(VCEQualityPreset preset) {
+			static const char* qualityPresetToString[] = {
+				"Speed",
+				"Balanced",
+				"Quality"
+			};
+			return qualityPresetToString[preset];
+		}
+		#pragma endregion VCEQualityPreset
+		#pragma region VCEProfile
+		inline const char* ProfileAsString(VCEProfile profile) {
+			switch (profile) {
+				case VCEProfile_Baseline:
+					return "Baseline";
+				case VCEProfile_Main:
+					return "Main";
+				case VCEProfile_High:
+					return "High";
+				case VCEProfile_ConstrainedBaseline:
+					return "Constrained Baseline";
+				case VCEProfile_ConstrainedHigh:
+					return "Constrained High";
+			}
+
+			return "Invalid";
+		}
+		#pragma endregion VCEProfile
+		#pragma region VCERateControlMethod
+		inline const char* RateControlMethodAsString(VCERateControlMethod method) {
+			static const char* rateControlMethodToString[] = {
+				"Constant Quantization Parameter (CQP)",
+				"Constant Bitrate (CBR)",
+				"Peak Constrained Variable Bitrate (VBR)",
+				"Latency Constrained Variable Bitrate (VBR_LAT)"
+			};
+			return rateControlMethodToString[method];
+		}
+		inline AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_ENUM RateControlMethodAsAMF(VCERateControlMethod method) {
+			static AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_ENUM CustomToAMF[] = {
+				AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_CONSTANT_QP,
+				AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_CBR,
+				AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR,
+				AMF_VIDEO_ENCODER_RATE_CONTROL_METHOD_LATENCY_CONSTRAINED_VBR,
+			};
+			return CustomToAMF[method];
+		}
+		inline VCERateControlMethod RateControlMethodFromAMF(uint32_t method) {
+			static VCERateControlMethod AMFToCustom[] = {
+				VCERateControlMethod_ConstantQP,
+				VCERateControlMethod_ConstantBitrate,
+				VCERateControlMethod_VariableBitrate_PeakConstrained,
+				VCERateControlMethod_VariableBitrate_LatencyConstrained,
+			};
+			return AMFToCustom[method];
+		}
+		#pragma endregion VCERateControlMethod
+
+		inline const char* CodingTypeAsString(VCECodingType type) {
+			const char* TypeToString[] = {
+				"Default",
+				"CABAC",
+				"CALV",
+			};
+			return TypeToString[type];
+		}
+	}
+}
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/enc-amf/Source/plugin.cpp Added

@@ -0,0 +1,195 @@
+/*
+MIT License
+
+Copyright (c) 2016 Michael Fabian Dirks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+*/
+
+#pragma once
+//////////////////////////////////////////////////////////////////////////
+// Includes
+//////////////////////////////////////////////////////////////////////////
+#include <windows.h>
+#include <sstream>
+#include <map>
+
+// Plugin
+#include "plugin.h"
+#include "amd-amf.h"
+#include "amd-amf-vce-capabilities.h"
+#include "enc-h264.h"
+
+//////////////////////////////////////////////////////////////////////////
+// Code
+//////////////////////////////////////////////////////////////////////////
+BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) {
+	return TRUE;
+}
+
+OBS_DECLARE_MODULE();
+OBS_MODULE_AUTHOR("Michael Fabian Dirks");
+OBS_MODULE_USE_DEFAULT_LOCALE("enc-amf", "en-US");
+
+/**
+* Required: Called when the module is loaded. Use this function to load all
+* the sources/encoders/outputs/services for your module, or anything else that
+* may need loading.
+*
+* @return Return true to continue loading the module, otherwise
+* false to indicate failure and unload the module
+*/
+MODULE_EXPORT bool obs_module_load(void) {
+	try {
+		AMF_LOG_INFO("Version " PLUGIN_VERSION_TEXT);
+
+		// Load AMF Runtime
+		auto instance = Plugin::AMD::AMF::GetInstance();
+
+		// Report AMF Capabilities
+		//Plugin::AMD::VCECapabilities::ReportCapabilities();
+
+		// Register Encoders
+		Plugin::Interface::H264Interface::encoder_register();
+	} catch (std::exception& e) {
+		AMF_LOG_ERROR("Uncaught Exception: %s", e.what());
+	} catch (std::exception* e) {
+		AMF_LOG_ERROR("Uncaught Exception: %s", e->what());
+		delete e;
+	} catch (...) {
+		AMF_LOG_ERROR("Uncaught Unknown Exception.");
+	}
+	return true;
+}
+
+/** Optional: Called when the module is unloaded. */
+MODULE_EXPORT void obs_module_unload(void) {}
+
+/** Optional: Returns the full name of the module */
+MODULE_EXPORT const char* obs_module_name() {
+	return "AMD Media Framework Plugin";
+}
+
+/** Optional: Returns a description of the module */
+MODULE_EXPORT const char* obs_module_description() {
+	return "AMD Media Framework Plugin";
+}
+
+// Allow translation strings to reference other translation strings up to a certain depth.
+static std::map<std::string, std::string> translatedMap;
+const char *obs_module_text_multi(const char *key, uint8_t depth) {
+	// Check if it already was translated.
+	if (!translatedMap.count(std::string(key))) { // If not, translate it now.
+		const char* out = obs_module_text(key);
+
+		// Allow for nested translations using \@...\@ sequences.
+		if (depth > 0) {
+			// I'm pretty sure this can be optimized a ton if necessary.
+
+			size_t seqStart = 0,
+				seqEnd = 0;
+			bool haveSequence = false;
+
+			std::stringstream fout;
+
+			// Walk the given string.
+			std::string walkable = std::string(out);
+
+			for (size_t pos = 0; pos <= walkable.length(); pos++) {
+				std::string walked = walkable.substr(pos, 2);
+
+				if (walked == "\\@") { // Sequence Start/End
+					if (haveSequence) {
+						seqEnd = pos;
+
+						std::string sequence = walkable.substr(seqStart, seqEnd - seqStart);
+						fout << obs_module_text_multi(sequence.c_str(), depth--);
+					} else {
+						seqStart = pos + 2;
+					}
+					haveSequence = !haveSequence;
+					pos = pos + 2;
+				} else if (!haveSequence) {
+					fout << walked.substr(0, 1); // Append the left character.
+				}
+			}
+
+			std::pair<std::string, std::string> kv = std::pair<std::string, std::string>(std::string(key), fout.str());
+			translatedMap.insert(kv);
+		} else {
+			return out;
+		}
+	}
+
+	auto value = translatedMap.find(std::string(key));
+	return value->second.c_str();
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Threading Specific
+//////////////////////////////////////////////////////////////////////////
+
+#if (defined _WIN32) || (defined _WIN64) // Windows
+#include <windows.h>
+
+const DWORD MS_VC_EXCEPTION = 0x406D1388;
+
+#pragma pack(push,8)
+typedef struct tagTHREADNAME_INFO {
+	DWORD dwType; // Must be 0x1000.
+	LPCSTR szName; // Pointer to name (in user addr space).
+	DWORD dwThreadID; // Thread ID (-1=caller thread).
+	DWORD dwFlags; // Reserved for future use, must be zero.
+} THREADNAME_INFO;
+#pragma pack(pop)
+
+void SetThreadName(uint32_t dwThreadID, const char* threadName) {
+
+	// DWORD dwThreadID = ::GetThreadId( static_cast<HANDLE>( t.native_handle() ) );
+
+	THREADNAME_INFO info;
+	info.dwType = 0x1000;
+	info.szName = threadName;
+	info.dwThreadID = dwThreadID;
+	info.dwFlags = 0;
+
+	__try {
+		RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
+	} __except (EXCEPTION_EXECUTE_HANDLER) {}
+}
+void SetThreadName(const char* threadName) {
+	SetThreadName(GetCurrentThreadId(), threadName);
+}
+void SetThreadName(std::thread* thread, const char* threadName) {
+	DWORD threadId = ::GetThreadId(static_cast<HANDLE>(thread->native_handle()));
+	SetThreadName(threadId, threadName);
+}
+
+#else // Linux, Mac
+#include <sys/prctl.h>
+
+void SetThreadName(std::thread* thread, const char* threadName) {
+	auto handle = thread->native_handle();
+	pthread_setname_np(handle, threadName);
+}
+void SetThreadName(const char* threadName) {
+	prctl(PR_SET_NAME, threadName, 0, 0, 0);
+}
+
+#endif
\ No newline at end of file

obs-studio-0.16.5.tar.xz/plugins/image-source/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/image-source/data/locale/sk-SK.ini Changed

obs-studio-0.16.6.tar.xz/plugins/linux-alsa/data/locale/sk-SK.ini Added

obs-studio-0.16.5.tar.xz/plugins/linux-capture/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/linux-capture/data/locale/sk-SK.ini Changed

obs-studio-0.16.5.tar.xz/plugins/linux-capture/data/locale/sv-SE.ini -> obs-studio-0.16.6.tar.xz/plugins/linux-capture/data/locale/sv-SE.ini Changed

obs-studio-0.16.5.tar.xz/plugins/mac-avcapture/data/locale/da-DK.ini -> obs-studio-0.16.6.tar.xz/plugins/mac-avcapture/data/locale/da-DK.ini Changed

obs-studio-0.16.5.tar.xz/plugins/mac-avcapture/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/mac-avcapture/data/locale/sk-SK.ini Changed

obs-studio-0.16.5.tar.xz/plugins/mac-syphon/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/mac-syphon/data/locale/sk-SK.ini Changed

obs-studio-0.16.6.tar.xz/plugins/mac-vth264/data/locale/da-DK.ini Added

obs-studio-0.16.5.tar.xz/plugins/mac-vth264/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/plugins/mac-vth264/data/locale/de-DE.ini Changed

obs-studio-0.16.5.tar.xz/plugins/obs-ffmpeg/data/locale/da-DK.ini -> obs-studio-0.16.6.tar.xz/plugins/obs-ffmpeg/data/locale/da-DK.ini Changed

@@ -1,23 +1,49 @@
 FFmpegOutput="FFmpeg Output"
 FFmpegAAC="FFmpeg Standard AAC Encoder"
 Bitrate="Bitrate"
+Preset="Forudindstillet"
+RateControl="Tempokontrol"
+KeyframeIntervalSec="Keyframe-interval (sekunder, 0= auto)"
+Lossless="Tabsfri"
 
+NVENC.Use2Pass="Benyt to-trins kodning"
+NVENC.Preset.default="Standard"
+NVENC.Preset.hq="Høj kvalitet"
+NVENC.Preset.hp="Høj ydeevne"
+NVENC.Preset.bd="BluRay"
+NVENC.Preset.ll="Lav latens"
+NVENC.Preset.llhq="Lav-latens høj kvalitet"
+NVENC.Preset.llhp="Lav latens høj ydeevne"
+NVENC.Level="Niveau"
 
 FFmpegSource="Mediekilde"
 LocalFile="Lokal fil"
 Looping="Gentagelse"
 Input="Input"
 InputFormat="Input format"
+ForceFormat="Gennemtving-formatkonvertering"
 HardwareDecode="Brug hardwareafkodning når tilgængelige"
 ClearOnMediaEnd="Skjul kilde når afspilning slutter"
 Advanced="Avanceret"
 AudioBufferSize="Audio bufferstørrelse (frames)"
 VideoBufferSize="Video bufferstørrelse (frames)"
+FrameDropping="Billedtabsniveau"
 DiscardNone="Ingen"
+DiscardDefault="Standard (ugyldige pakker)"
+DiscardNonRef="Ikke-reference billeder"
 DiscardBiDir="Tovejs frames"
 DiscardNonIntra="Non-Intra frames"
 DiscardNonKey="Non-Key Frames"
 DiscardAll="Alle frames (pas på!)"
+RestartWhenActivated="Genstart afspilning når kilde bliver aktiv"
+ColorRange="YUV-farveområde"
+ColorRange.Auto="Auto"
+ColorRange.Partial="Delvis"
+ColorRange.Full="Fuld"
 
 
+MediaFileFilter.AllMediaFiles="Alle mediefiler"
+MediaFileFilter.VideoFiles="Videofiler"
+MediaFileFilter.AudioFiles="Lydfiler"
+MediaFileFilter.AllFiles="Alle filer"

obs-studio-0.16.5.tar.xz/plugins/obs-ffmpeg/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/plugins/obs-ffmpeg/data/locale/de-DE.ini Changed

obs-studio-0.16.5.tar.xz/plugins/obs-ffmpeg/obs-ffmpeg-nvenc.c -> obs-studio-0.16.6.tar.xz/plugins/obs-ffmpeg/obs-ffmpeg-nvenc.c Changed

@@ -23,6 +23,7 @@
 #include <obs-avc.h>
 
 #include <libavutil/opt.h>
+#include <libavutil/pixdesc.h>
 #include <libavformat/avformat.h>
 
 #include "obs-ffmpeg-formats.h"
@@ -298,8 +299,10 @@
 }
 
 static inline void copy_data(AVPicture *pic, const struct encoder_frame *frame,
-		int height)
+		int height, enum AVPixelFormat format)
 {
+	int h_chroma_shift, v_chroma_shift;
+	av_pix_fmt_get_chroma_sub_sample(format, &h_chroma_shift, &v_chroma_shift);
 	for (int plane = 0; plane < MAX_AV_PLANES; plane++) {
 		if (!frame->data[plane])
 			continue;
@@ -308,7 +311,7 @@
 		int pic_rowsize = pic->linesize[plane];
 		int bytes = frame_rowsize < pic_rowsize ?
 			frame_rowsize : pic_rowsize;
-		int plane_height = plane == 0 ? height : height/2;
+		int plane_height = height >> (plane ? v_chroma_shift : 0);
 
 		for (int y = 0; y < plane_height; y++) {
 			int pos_frame = y * frame_rowsize;
@@ -331,7 +334,7 @@
 
 	av_init_packet(&av_pkt);
 
-	copy_data(&enc->dst_picture, frame, enc->height);
+	copy_data(&enc->dst_picture, frame, enc->height, enc->context->pix_fmt);
 
 	enc->vframe->pts = frame->pts;
 	ret = avcodec_encode_video2(enc->context, &av_pkt, enc->vframe,

obs-studio-0.16.5.tar.xz/plugins/obs-ffmpeg/obs-ffmpeg-output.c -> obs-studio-0.16.6.tar.xz/plugins/obs-ffmpeg/obs-ffmpeg-output.c Changed

@@ -23,6 +23,7 @@
 #include <util/platform.h>
 
 #include <libavutil/opt.h>
+#include <libavutil/pixdesc.h>
 #include <libavformat/avformat.h>
 #include <libswscale/swscale.h>
 
@@ -620,8 +621,10 @@
 }
 
 static inline void copy_data(AVPicture *pic, const struct video_data *frame,
-		int height)
+		int height, enum AVPixelFormat format)
 {
+	int h_chroma_shift, v_chroma_shift;
+	av_pix_fmt_get_chroma_sub_sample(format, &h_chroma_shift, &v_chroma_shift);
 	for (int plane = 0; plane < MAX_AV_PLANES; plane++) {
 		if (!frame->data[plane])
 			continue;
@@ -630,7 +633,7 @@
 		int pic_rowsize = pic->linesize[plane];
 		int bytes = frame_rowsize < pic_rowsize ?
 			frame_rowsize : pic_rowsize;
-		int plane_height = plane == 0 ? height : height/2;
+		int plane_height = height >> (plane ? v_chroma_shift : 0);
 
 		for (int y = 0; y < plane_height; y++) {
 			int pos_frame = y * frame_rowsize;
@@ -669,7 +672,7 @@
 				0, data->config.height, data->dst_picture.data,
 				data->dst_picture.linesize);
 	else
-		copy_data(&data->dst_picture, frame, context->height);
+		copy_data(&data->dst_picture, frame, context->height, context->pix_fmt);
 
 	if (data->output->flags & AVFMT_RAWPICTURE) {
 		packet.flags |= AV_PKT_FLAG_KEY;

obs-studio-0.16.5.tar.xz/plugins/obs-libfdk/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/plugins/obs-libfdk/data/locale/de-DE.ini Changed

obs-studio-0.16.5.tar.xz/plugins/obs-outputs/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/obs-outputs/data/locale/sk-SK.ini Changed

obs-studio-0.16.6.tar.xz/plugins/obs-outputs/data/locale/vi-VN.ini Added

obs-studio-0.16.5.tar.xz/plugins/obs-outputs/rtmp-stream.c -> obs-studio-0.16.6.tar.xz/plugins/obs-outputs/rtmp-stream.c Changed

obs-studio-0.16.6.tar.xz/plugins/obs-qsv11/data/locale/sk-SK.ini Added

obs-studio-0.16.5.tar.xz/plugins/obs-qsv11/data/locale/sv-SE.ini -> obs-studio-0.16.6.tar.xz/plugins/obs-qsv11/data/locale/sv-SE.ini Changed

obs-studio-0.16.5.tar.xz/plugins/obs-qsv11/obs-qsv11.c -> obs-studio-0.16.6.tar.xz/plugins/obs-qsv11/obs-qsv11.c Changed

@@ -59,6 +59,7 @@
 #include <util/darray.h>
 #include <util/platform.h>
 #include <obs-module.h>
+#include <obs-avc.h>
 
 #ifndef _STDINT_H_INCLUDED
 #define _STDINT_H_INCLUDED
@@ -579,6 +580,9 @@
 
 static void parse_packet(struct obs_qsv *obsqsv, struct encoder_packet *packet, mfxBitstream *pBS, uint32_t fps_num, bool *received_packet)
 {
+	uint8_t *start, *end;
+	int type;
+
 	if (pBS == NULL || pBS->DataLength == 0) {
 		*received_packet = false;
 		return;
@@ -595,6 +599,36 @@
 	packet->keyframe = (pBS->FrameType &
 			(MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF));
 
+	/* ------------------------------------ */
+
+	start = obsqsv->packet_data.array;
+	end = start + obsqsv->packet_data.num;
+
+	start = (uint8_t*)obs_avc_find_startcode(start, end);
+	while (true) {
+		while (start < end && !*(start++));
+
+		if (start == end)
+			break;
+
+		type = start[0] & 0x1F;
+		if (type == OBS_NAL_SLICE_IDR || type == OBS_NAL_SLICE) {
+			uint8_t prev_type = (start[0] >> 5) & 0x3;
+			start[0] &= ~(3 << 5);
+
+			if (pBS->FrameType & MFX_FRAMETYPE_I)
+				start[0] |= OBS_NAL_PRIORITY_HIGHEST << 5;
+			else if (pBS->FrameType & MFX_FRAMETYPE_P)
+				start[0] |= OBS_NAL_PRIORITY_HIGH << 5;
+			else
+				start[0] |= prev_type << 5;
+		}
+
+		start = (uint8_t*)obs_avc_find_startcode(start, end);
+	}
+
+	/* ------------------------------------ */
+
 	//bool iFrame = pBS->FrameType & MFX_FRAMETYPE_I;
 	//bool bFrame = pBS->FrameType & MFX_FRAMETYPE_B;
 	bool pFrame = pBS->FrameType & MFX_FRAMETYPE_P;

obs-studio-0.16.5.tar.xz/plugins/obs-text/data/locale/nl-NL.ini -> obs-studio-0.16.6.tar.xz/plugins/obs-text/data/locale/nl-NL.ini Changed

obs-studio-0.16.6.tar.xz/plugins/obs-text/data/locale/sk-SK.ini Added

obs-studio-0.16.5.tar.xz/plugins/rtmp-services/data/package.json -> obs-studio-0.16.6.tar.xz/plugins/rtmp-services/data/package.json Changed

obs-studio-0.16.5.tar.xz/plugins/rtmp-services/data/services.json -> obs-studio-0.16.6.tar.xz/plugins/rtmp-services/data/services.json Changed

obs-studio-0.16.5.tar.xz/plugins/text-freetype2/text-freetype2.c -> obs-studio-0.16.6.tar.xz/plugins/text-freetype2/text-freetype2.c Changed

@@ -50,24 +50,34 @@
 	.get_properties = ft2_source_properties,
 };
 
-bool obs_module_load()
+static bool plugin_initialized = false;
+
+static void init_plugin(void)
 {
-	char *config_dir = obs_module_config_path(NULL);
-	if (config_dir) {
-		os_mkdirs(config_dir);
-		bfree(config_dir);
-	}
+	if (plugin_initialized)
+		return;
 
 	FT_Init_FreeType(&ft2_lib);
 
 	if (ft2_lib == NULL) {
 		blog(LOG_WARNING, "FT2-text: Failed to initialize FT2.");
-		return false;
+		return;
 	}
 
 	if (!load_cached_os_font_list())
 		load_os_font_list();
 
+	plugin_initialized = true;
+}
+
+bool obs_module_load()
+{
+	char *config_dir = obs_module_config_path(NULL);
+	if (config_dir) {
+		os_mkdirs(config_dir);
+		bfree(config_dir);
+	}
+
 	obs_register_source(&freetype2_source_info);
 
 	return true;
@@ -75,8 +85,10 @@
 
 void obs_module_unload(void)
 {
-	free_os_font_list();
-	FT_Done_FreeType(ft2_lib);
+	if (plugin_initialized) {
+		free_os_font_list();
+		FT_Done_FreeType(ft2_lib);
+	}
 }
 
 static const char *ft2_source_get_name(void *unused)
@@ -442,6 +454,8 @@
 	obs_data_t *font_obj = obs_data_create();
 	srcdata->src = source;
 
+	init_plugin();
+
 	srcdata->font_size = 32;
 
 	obs_data_set_default_string(font_obj, "face", DEFAULT_FACE);

obs-studio-0.16.6.tar.xz/plugins/vlc-video/data/locale/sk-SK.ini Added

obs-studio-0.16.5.tar.xz/plugins/win-capture/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/win-capture/data/locale/sk-SK.ini Changed

obs-studio-0.16.5.tar.xz/plugins/win-capture/game-capture.c -> obs-studio-0.16.6.tar.xz/plugins/win-capture/game-capture.c Changed

obs-studio-0.16.5.tar.xz/plugins/win-capture/load-graphics-offsets.c -> obs-studio-0.16.6.tar.xz/plugins/win-capture/load-graphics-offsets.c Changed

obs-studio-0.16.5.tar.xz/plugins/win-capture/plugin-main.c -> obs-studio-0.16.6.tar.xz/plugins/win-capture/plugin-main.c Changed

@@ -11,6 +11,8 @@
 extern struct obs_source_info window_capture_info;
 extern struct obs_source_info game_capture_info;
 
+static HANDLE init_hooks_thread = NULL;
+
 extern bool cached_versions_match(void);
 extern bool load_cached_graphics_offsets(bool is32bit);
 extern bool load_graphics_offsets(bool is32bit);
@@ -25,6 +27,37 @@
 
 #define USE_HOOK_ADDRESS_CACHE false
 
+static DWORD WINAPI init_hooks(LPVOID unused)
+{
+	if (USE_HOOK_ADDRESS_CACHE &&
+	    cached_versions_match() &&
+	    load_cached_graphics_offsets(IS32BIT)) {
+
+		load_cached_graphics_offsets(!IS32BIT);
+		obs_register_source(&game_capture_info);
+
+	} else if (load_graphics_offsets(IS32BIT)) {
+		load_graphics_offsets(!IS32BIT);
+	}
+
+	UNUSED_PARAMETER(unused);
+	return 0;
+}
+
+void wait_for_hook_initialization(void)
+{
+	static bool initialized = false;
+
+	if (!initialized) {
+		if (init_hooks_thread) {
+			WaitForSingleObject(init_hooks_thread, INFINITE);
+			CloseHandle(init_hooks_thread);
+			init_hooks_thread = NULL;
+		}
+		initialized = true;
+	}
+}
+
 bool obs_module_load(void)
 {
 	struct win_version_info ver;
@@ -52,17 +85,13 @@
 
 	obs_register_source(&window_capture_info);
 
-	if (USE_HOOK_ADDRESS_CACHE &&
-	    cached_versions_match() &&
-	    load_cached_graphics_offsets(IS32BIT)) {
-
-		load_cached_graphics_offsets(!IS32BIT);
-		obs_register_source(&game_capture_info);
-
-	} else if (load_graphics_offsets(IS32BIT)) {
-		load_graphics_offsets(!IS32BIT);
-		obs_register_source(&game_capture_info);
-	}
+	init_hooks_thread = CreateThread(NULL, 0, init_hooks, NULL, 0, NULL);
+	obs_register_source(&game_capture_info);
 
 	return true;
 }
+
+void obs_module_unload(void)
+{
+	wait_for_hook_initialization();
+}

obs-studio-0.16.5.tar.xz/plugins/win-dshow/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/plugins/win-dshow/data/locale/de-DE.ini Changed

obs-studio-0.16.5.tar.xz/plugins/win-dshow/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/win-dshow/data/locale/sk-SK.ini Changed

obs-studio-0.16.6.tar.xz/plugins/win-ivcam Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/CMakeLists.txt Added

@@ -0,0 +1,62 @@
+project(win-ivcam)
+
+if(DISABLE_IVCAM)
+	message(STATUS "Realsense camera plugin disabled")
+	return()
+endif()
+
+find_package(RSSDK QUIET)
+if(NOT RSSDK_FOUND AND ENABLE_IVCAM)
+	message(FATAL_ERROR "RSSDK not found, but the realsense camera plugin is set as enabled")
+elseif(NOT RSSDK_FOUND)
+	message(STATUS "RSSDK not found, Realsense camera plugin disabled")
+	return()
+endif()
+
+include(IDLFileHelper)
+
+set(win-ivcam_seg_library_IDLS
+	seg_service/seg_service.idl
+	)
+
+add_idl_files(win-ivcam_seg_library_GENERATED_FILES
+	${win-ivcam_seg_library_IDLS})
+
+include_directories(
+	${CMAKE_CURRENT_BINARY_DIR}
+	)
+
+set(win-ivcam_seg_library_HEADERS
+	seg_library/Dependencies.h
+	seg_library/SegImage.h
+	seg_library/SegServer.h
+	seg_library/SegServerImpl.h
+	seg_library/SegService.h
+	)
+set(win-ivcam_seg_library_SOURCES
+	seg_library/SerServer.cpp
+	seg_library/SegServerImpl.cpp
+	seg_library/SegImage.cpp
+	${win-ivcam_seg_library_GENERATED_FILES}
+	)
+
+set(win-ivcam_SOURCES
+	realsense.cpp
+	)
+
+source_group("seg_library\\Source Files" FILES ${win-ivcam_seg_library_SOURCES})
+source_group("seg_library\\Header Files" FILES ${win-ivcam_seg_library_HEADERS})
+
+add_library(win-ivcam MODULE
+	${win-ivcam_seg_library_HEADERS}
+	${win-ivcam_seg_library_SOURCES}
+	${win-ivcam_SOURCES}
+	)
+target_link_libraries(win-ivcam
+	libobs)
+
+install_obs_plugin_with_data(win-ivcam data)
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+	add_subdirectory(seg_service)
+endif()

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/realsense.cpp Added

@@ -0,0 +1,184 @@
+/*
+Copyright(c) 2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met :
+
+- Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and /
+or other materials provided with the distribution.
+- Neither the name of Intel Corporation nor the names of its contributors may
+be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <obs-module.h>
+#include <stdlib.h>
+#include <util/threading.h>
+#include <util/platform.h>
+#include <obs.h>
+#include <thread>
+#include <atomic>
+
+#include "seg_library/SegService.h"
+
+using namespace std;
+
+#include <Tlhelp32.h>
+#include <shlobj.h>
+#include <sstream>
+
+#define do_log(level, format, ...) \
+	blog(level, "[win-ivcam (%s): '%s'] " format, \
+			__FUNCTION__, obs_source_get_name(source), \
+			##__VA_ARGS__)
+
+#define warn(format, ...) do_log(LOG_WARNING, format, ##__VA_ARGS__)
+#define info(format, ...) do_log(LOG_INFO, format, ##__VA_ARGS__)
+#define debug(format, ...) do_log(LOG_DEBUG, format, ##__VA_ARGS__)
+
+void TerminateProcessByName(wchar_t *procName)
+{
+	PROCESSENTRY32 entry;
+	entry.dwSize = sizeof(entry);
+
+	HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, NULL);
+	BOOL hRes = Process32First(snapshot, &entry);
+
+	while (hRes) {
+		if (wcscmp(entry.szExeFile, procName) == 0) {
+			HANDLE process = OpenProcess(PROCESS_TERMINATE, 0,
+					(DWORD)entry.th32ProcessID);
+
+			if (process != NULL) {
+				TerminateProcess(process, 0);
+				CloseHandle(process);
+			}
+		}
+		hRes = Process32Next(snapshot, &entry);
+	}
+	CloseHandle(snapshot);
+}
+
+struct IVCamSource {
+	SegServer* pSegServer;
+	obs_source_t *source;
+	thread camThread;
+	atomic<bool> stopThread = false;
+
+	void IVCamSource::PushSegmentedFrameData(SegImage *segmented_image)
+	{
+		/*uint8_t* pix = (uint8_t*)segmented_image->GetData();
+		if (pix != NULL) {
+			int pixels = segmented_image->Width() *
+				segmented_image->Height();
+
+			for (int i = 0; i < pixels; i++) {
+				if (pix[3]<100) {
+					pix[0] /= 3; pix[1] /= 2; pix[2] /= 3;
+				}
+				pix += 4;
+			}
+		}*/
+
+		obs_source_frame frame = {};
+		frame.data[0] = (uint8_t*)segmented_image->GetData();
+		frame.linesize[0] = segmented_image->Pitch();
+		frame.format = VIDEO_FORMAT_BGRA;
+		frame.width = segmented_image->Width();
+		frame.height = segmented_image->Height();
+		frame.timestamp = os_gettime_ns();
+		obs_source_output_video(source, &frame);
+	}
+
+	void IVCamSource::CamThread()
+	{
+		pSegServer = SegServer::CreateServer();
+		SegServer::ServiceStatus status = pSegServer->Init();
+
+		if (status != SegServer::ServiceStatus::SERVICE_NO_ERROR) {
+			warn("SegServer initialization error (%d)\n", status);
+			return;
+		}
+
+		while (!stopThread) {
+			SegImage* image = nullptr;
+			SegServer::ServiceStatus error =
+				pSegServer->GetFrame(&image);
+			if (error != SegServer::ServiceStatus::SERVICE_NO_ERROR
+					|| image->Width() == 0
+					|| image->Height() == 0) {
+				//warn("AcquireFrame failed (%d)\n", error);
+				continue;
+			}
+
+			PushSegmentedFrameData(image);
+
+			delete image;
+		}
+
+		pSegServer->Stop();
+		delete pSegServer;
+	}
+
+	inline IVCamSource::IVCamSource(obs_source_t* source_) :
+		source(source_)
+	{
+		stopThread = false;
+		camThread = std::thread(&IVCamSource::CamThread, this);
+	}
+
+	static void* IVCamSource::CreateIVCamSource(obs_data_t*,
+			obs_source_t *source)
+	{
+		//kill whatever is running just in case
+		TerminateProcessByName(L"seg_service.exe");
+		return new IVCamSource(source);
+	}
+
+	inline IVCamSource::~IVCamSource()
+	{
+		//done using it, kill the seg_service
+		stopThread = true;
+		if (camThread.joinable()) camThread.join();
+		TerminateProcessByName(L"seg_service.exe");
+	}
+};
+
+static const char *GetIVCamName(void*)
+{
+	return "Intel(R) RealSense(TM) 3D Camera GreenScreen";
+}
+
+static void DestroyIVCamSource(void *data)
+{
+	delete reinterpret_cast<IVCamSource*>(data);
+}
+
+OBS_DECLARE_MODULE()
+
+bool obs_module_load(void)
+{
+	obs_source_info info = {};
+	info.id = "win-ivcam";
+	info.type = OBS_SOURCE_TYPE_INPUT;
+	info.output_flags = OBS_SOURCE_ASYNC_VIDEO;
+	info.get_name = GetIVCamName;
+	info.create = IVCamSource::CreateIVCamSource;
+	info.destroy = DestroyIVCamSource;
+	obs_register_source(&info);
+	return true;
+}

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/Dependencies.h Added

@@ -0,0 +1,40 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef DEPENDENCIES_H_
+#define DEPENDENCIES_H_
+
+// WinAPI section
+#include <windows.h>
+
+// CRT section
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <exception>
+
+#endif // DEPENDENCIES_H_
\ No newline at end of file

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SegImage.cpp Added

@@ -0,0 +1,102 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "SegImage.h"
+
+SegImage::SegImage()
+	: m_width(0), m_height(0), m_pitch(0), m_data(nullptr), m_number(0), m_timestamp(0L) {}
+
+SegImage::SegImage(int width, int height, int pitch, void* data, long long timestamp, int number)
+	: m_width(width), m_height(height), m_pitch(pitch), m_data(new char[height*pitch]), m_timestamp(timestamp), m_number(number)
+{
+    memcpy_s(m_data, height*pitch, data, height*pitch);
+}
+
+SegImage::SegImage(SegImage const& src)
+    : m_width(src.m_width), m_height(src.m_height), m_pitch(src.m_pitch), m_data(new char[src.m_height*src.m_pitch]),
+	m_timestamp(src.m_timestamp), m_number(src.m_number)
+{
+	memcpy_s(m_data, m_pitch*m_height, src.m_data, src.m_height*src.m_pitch);
+}
+
+SegImage::~SegImage()
+{
+    delete[] m_data;
+}
+
+SegImage& SegImage::operator=(const SegImage & src)
+{
+    if (this != &src)
+    {
+        m_width = src.m_width;
+        m_height = src.m_height;
+        m_pitch = src.m_pitch;
+        if (m_data)
+        {
+            delete[] m_data;
+        }
+        m_data = new char[m_height*m_pitch];
+		m_timestamp = src.m_timestamp;
+		m_number = src.m_number;
+        memcpy_s(m_data, m_pitch*m_height, src.m_data, m_height*m_pitch);
+    }
+    return *this;
+}
+
+int SegImage::Width()
+{
+    return m_width;
+}
+
+int SegImage::Height()
+{
+    return m_height;
+}
+
+int SegImage::Pitch()
+{
+    return m_pitch;
+}
+
+long long SegImage::TimeStamp()
+{
+	return m_timestamp;
+}
+
+int SegImage::Number()
+{
+	return m_number;
+}
+
+SegPixel SegImage::Get(int i, int j)
+{
+    SegPixel result;
+    result.blue = (((char*)m_data) + j*m_pitch + i * 4)[0];
+    result.green = (((char*)m_data) + j*m_pitch + i * 4)[1];
+    result.red = (((char*)m_data) + j*m_pitch + i * 4)[2];
+    return result;
+}

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SegImage.h Added

@@ -0,0 +1,66 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef SEG_IMAGE_H_
+#define SEG_IMAGE_H_
+
+#include "Dependencies.h"
+
+struct SegPixel
+{
+    unsigned char red;
+    unsigned char green;
+    unsigned char blue;
+};
+
+class SegImage
+{
+private:
+    int m_width;
+    int m_height;
+    int m_pitch;
+	long long m_timestamp;
+	int m_number;
+    void* m_data;
+public:
+    SegImage();
+    SegImage(SegImage const& src);
+    SegImage(int width, int height, int pitch, void* data, long long timestamp, int number);
+    ~SegImage();
+
+    SegImage& operator=(const SegImage & src);
+
+    int Width();
+    int Height();
+    int Pitch();
+	long long TimeStamp();
+	int Number();
+    SegPixel Get(int i, int j);
+    void* GetData() { return m_data; };
+};
+
+#endif // SEG_IMAGE_H_

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SegServer.h Added

@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef SEG_SERVER_H_
+#define SEG_SERVER_H_
+
+#include "Dependencies.h"
+#include "SegImage.h"
+
+#define USE_DEFAULT_PROPERTY_VALUE -1
+
+class SegServer
+{
+public:
+    enum ServiceStatus
+    {
+        COM_LIB_INIT_ERROR = -1,
+        SERVICE_INIT_ERROR = -2,
+        SERVICE_REINIT_ERROR = -3,
+        SERVICE_FUNC_ERROR = -4,
+        SHARED_MEMORY_ERROR = -5,
+        ALLOCATION_FAILURE = -6,
+        SERVICE_NO_ERROR = 0,
+		SERVICE_NOT_READY = 1
+    };
+
+    static SegServer* CreateServer();
+    static SegServer* GetServerInstance();
+
+    virtual ServiceStatus Init() = 0;
+    virtual ServiceStatus Stop() = 0;
+
+    virtual ServiceStatus GetFrame(SegImage** image) = 0;
+
+    virtual void SetFps(int fps) = 0;
+    virtual int GetFps() = 0;
+    /**
+    @brief Set the IVCAM motion range trade off option, ranged from 0 (short range, better motion) to 100 (far range, long exposure). Custom property value used only with 60 fps profile
+    @param[in] value		The motion range trade option. USE_DEFAULT_PROPERTY_VALUE to return default value
+    */
+    virtual void SetIVCAMMotionRangeTradeOff(int value) = 0;
+    virtual int GetIVCAMMotionRangeTradeOff() = 0;
+
+    virtual ~SegServer() {};
+};
+
+#endif // SEG_SERVER_H_

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SegServerImpl.cpp Added

@@ -0,0 +1,202 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "SegServerImpl.h"
+
+SegServerImpl* SegServerImpl::instance = nullptr;
+
+SegServerImpl::SegServerImpl()
+{
+    m_comInit = false;
+    m_serviceConnected = false;
+    m_sharedBuffer = NULL;
+}
+
+SegServerImpl::SegServerImpl(SegServerImpl const& src) {};
+SegServerImpl::~SegServerImpl() 
+{
+    if (m_server)
+    {
+        m_server->Release();
+        m_server = nullptr;
+    }
+    instance = nullptr;
+};
+SegServerImpl& SegServerImpl::operator=(const SegServerImpl & src) { return *this; };
+
+SegServer* SegServerImpl::CreateServer()
+{
+    if (instance == nullptr)
+    {
+        instance = new SegServerImpl();
+        return instance;
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+SegServer* SegServerImpl::GetServerInstance()
+{
+    return instance;
+}
+
+SegServerImpl::ServiceStatus SegServerImpl::Init()
+{
+    if (m_comInit && m_serviceConnected)
+        return SERVICE_REINIT_ERROR;
+    GUID guid = { 0 };
+    m_bufferName = new wchar_t[40]();
+    CoCreateGuid(&guid);
+    StringFromGUID2(guid, m_bufferName, 40);
+    if (!m_comInit)
+    {
+        HRESULT comInit = CoInitializeEx(0, COINIT_MULTITHREADED);
+        if (FAILED(comInit))
+        {
+            comInit = CoInitialize(0);
+            if (FAILED(comInit))
+            {
+                return COM_LIB_INIT_ERROR;
+            }
+        }
+        m_comInit = true;
+    }
+
+    if (!m_serviceConnected)
+    {
+        HRESULT instanceCreate = CoCreateInstance(CLSID_SegProc, NULL, CLSCTX_LOCAL_SERVER, IID_ISegProc, (void**)&m_server);
+        if (FAILED(instanceCreate)) {
+            return SERVICE_INIT_ERROR;
+        }
+
+        HRESULT serverInit = m_server->Init(m_bufferName);
+        if (FAILED(serverInit)) {
+            return SERVICE_INIT_ERROR;
+        }
+        m_serviceConnected = true;
+    }
+    return SERVICE_NO_ERROR;
+}
+
+SegServerImpl::ServiceStatus SegServerImpl::Stop()
+{
+    HRESULT errCode = m_server->Stop();
+    if (FAILED(errCode)) {
+        return SERVICE_FUNC_ERROR;
+    }
+    return SERVICE_NO_ERROR;
+}
+
+void SegServerImpl::SetFps(int fps)
+{
+    m_server->SetFps(fps);
+}
+
+int SegServerImpl::GetFps()
+{
+    int outFps = -1;
+    m_server->GetFps(&outFps);
+    return outFps;
+}
+
+void SegServerImpl::SetIVCAMMotionRangeTradeOff(int value)
+{
+    m_server->SetIVCAMMotionRangeTradeOff(value);
+}
+
+int SegServerImpl::GetIVCAMMotionRangeTradeOff()
+{
+    int outPropertyValue = -1;
+    m_server->GetIVCAMMotionRangeTradeOff(&outPropertyValue);
+    return outPropertyValue;
+}
+
+SegServerImpl::ServiceStatus SegServerImpl::GetFrame(SegImage** image)
+{
+    ServiceStatus res = SERVICE_NO_ERROR;
+    int frameId = -1;
+    int bufferRealloc = -1;
+    int frameSize = -1;
+    if (FAILED(m_server->LockBuffer(&frameId, &frameSize, &bufferRealloc)))
+    {
+        return SHARED_MEMORY_ERROR;
+    }
+    if (bufferRealloc)
+    {
+        HANDLE hMapFile = OpenFileMapping(FILE_MAP_READ, FALSE, m_bufferName);
+
+        if (hMapFile == NULL)
+        {
+            m_server->UnlockBuffer();
+            return SHARED_MEMORY_ERROR;
+        }
+
+        m_sharedBuffer = (LPTSTR)MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, frameSize * 2);
+
+        if (m_sharedBuffer == NULL)
+        {
+            CloseHandle(hMapFile);
+            m_server->UnlockBuffer();
+            return SHARED_MEMORY_ERROR;
+        }
+        CloseHandle(hMapFile);
+    }
+
+	if(m_sharedBuffer && frameId != -1 && frameSize != -1)
+	{
+		size_t offset = (size_t)frameId * frameSize;
+		//int width = ((int*)(m_sharedBuffer + offset))[0];
+		//int height = ((int*)(m_sharedBuffer + offset))[1];
+		//int pitch = ((int*)(m_sharedBuffer + offset))[2];
+		FrameHeader* fhPtr = (FrameHeader*)(m_sharedBuffer + offset);
+		int width = fhPtr->width;
+		int height = fhPtr->height;
+		int pitch = fhPtr->pitch;
+		long long timestamp = fhPtr->timestamp;
+		int frameNumber = fhPtr->frameNumber;
+		void* data = (void*)(m_sharedBuffer + offset + sizeof(FrameHeader));
+		SegImage* result = nullptr;
+		try
+		{
+			result = new SegImage(width, height, pitch, data, timestamp, frameNumber);
+		}
+		catch (std::bad_alloc &/*e*/)
+		{
+			res = ALLOCATION_FAILURE;
+			result = NULL;
+		}
+		*image = result;
+	}
+	else
+	{
+		res = SERVICE_NOT_READY;
+	}
+    m_server->UnlockBuffer();
+    return res;
+}

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SegServerImpl.h Added

@@ -0,0 +1,77 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef SEG_SERVER_IMPL_H_
+#define SEG_SERVER_IMPL_H_
+
+#include "Dependencies.h"
+#include "SegImage.h"
+#include "SegServer.h"
+
+#include "seg_service.h"
+
+typedef struct
+{
+	int width;
+	int height;
+	int pitch;
+	long long timestamp;
+	int frameNumber;
+} FrameHeader;
+
+class SegServerImpl : public SegServer
+{
+private:
+    static SegServerImpl* instance;
+    ISegProc* m_server;
+
+    bool m_comInit;
+    bool m_serviceConnected;
+
+    LPWSTR m_bufferName;
+    LPCTSTR m_sharedBuffer;
+
+    SegServerImpl();
+    SegServerImpl(SegServerImpl const& src);
+    SegServerImpl& operator=(const SegServerImpl & src);
+
+public:
+    virtual ~SegServerImpl();
+    static SegServer* CreateServer();
+    static SegServer* GetServerInstance();
+
+    ServiceStatus Init();
+    ServiceStatus Stop();
+    void SetFps(int fps) override;
+    int GetFps() override;
+    void SetIVCAMMotionRangeTradeOff(int value) override;
+    int GetIVCAMMotionRangeTradeOff() override;
+
+    ServiceStatus GetFrame(SegImage** image);
+};
+
+#endif // SEG_SERVER_IMPL_H_

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SegService.h Added

@@ -0,0 +1,34 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef SEG_SERVICE_H_
+#define SEG_SERVICE_H_
+
+#include "SegImage.h"
+#include "SegServer.h"
+
+#endif // SEG_SERVICE_H_

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_library/SerServer.cpp Added

@@ -0,0 +1,39 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "SegServer.h"
+#include "SegServerImpl.h"
+
+SegServer* SegServer::CreateServer()
+{
+    return SegServerImpl::CreateServer();
+}
+
+SegServer* SegServer::GetServerInstance()
+{
+    return SegServerImpl::GetServerInstance();
+}

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/CMakeLists.txt Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/SegProc.cpp Added

@@ -0,0 +1,35 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// SegProc.cpp : Implementation of CSegProc
+
+#include "stdafx.h"
+#include "SegProc.h"
+
+
+// CSegProc
+

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/SegProc.h Added

@@ -0,0 +1,508 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// SegProc.h : Declaration of the CSegProc
+
+#pragma once
+#include "resource.h" // main symbols
+#include "seg_service.h"
+
+#include "pxcsession.h"
+#include "pxcsensemanager.h"
+#include "pxc3dseg.h"
+
+#include <string>
+
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+
+#if defined(_WIN32_WCE) && !defined(_CE_DCOM) && !defined(_CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA)
+#error "Single-threaded COM objects are not properly supported on Windows CE platform, such as the Windows Mobile platforms that do not include full DCOM support. Define _CE_ALLOW_SINGLE_THREADED_OBJECTS_IN_MTA to force ATL to support creating single-thread COM object's and allow use of it's single-threaded COM object implementations. The threading model in your rgs file was set to 'Free' as that is the only threading model supported in non DCOM Windows CE platforms."
+#endif
+
+using namespace ATL;
+
+
+/* Number of milliseconds service waits for worker thread to start */
+#define START_TIMEOUT 2000
+#define USE_DEFAULT_PROPERTY_VALUE -1
+
+// CSegProc
+
+typedef struct _frameHeader
+{
+ int width;
+ int height;
+ int pitch;
+ long long timestamp;
+ int frameNumber;
+} FrameHeader;
+
+class ATL_NO_VTABLE CSegProc :
+ public CComObjectRootEx<CComSingleThreadModel>,
+ public CComCoClass<CSegProc, &CLSID_SegProc>,
+ public IDispatchImpl<ISegProc, &IID_ISegProc, &LIBID_seg_serviceLib, /*wMajor =*/ 1, /*wMinor =*/ 0>,
+ public PXCSenseManager::Handler
+{
+private:
+ enum {
+ DEPTH_PROPERTY_NORMAL_MODE = 0x03,
+ DEPTH_PROPERTY_HDR_MODE = 0x200
+ };
+ // Service state section
+ HANDLE m_loopThreadHandle;
+ bool m_procRun;
+ HANDLE m_hStartedEvt;
+
+ // Shared memory section
+ std::wstring m_bufferName;
+ HANDLE m_sharedBufferHandle;
+ LPCTSTR m_sharedBuffer;
+ bool m_bufferRealloc;
+
+ // Frames section
+ int m_currentFrame;
+ int m_frameToRead;
+ size_t m_frameSize;
+ const static size_t headerSize = sizeof(FrameHeader);
+ CRITICAL_SECTION m_frameAccess[2];
+
+ // RSSDK section
+ PXCSenseManager* m_senseManager;
+ PXC3DSeg* m_segModule;
+ int m_fps;
+ int m_motionRangeTradeOff;
+
+ bool m_processing;
+ bool m_isPause;
+ std::condition_variable m_cvPause;
+ std::mutex m_pauseMtx;
+
+ pxcStatus PXCAPI OnModuleSetProfile(pxcUID /*mid*/, PXCBase* /*module*/) override
+ {
+ PXCCaptureManager* captureMgr = m_senseManager->QueryCaptureManager();
+ if (!captureMgr || m_fps != 60)
+ return PXC_STATUS_NO_ERROR;
+ PXCCapture::Device* device = captureMgr->QueryDevice();
+ PXCCapture::Device::PropertyInfo propInfo = device->QueryIVCAMMotionRangeTradeOffInfo();
+
+ int value = m_motionRangeTradeOff;
+ if (m_motionRangeTradeOff == USE_DEFAULT_PROPERTY_VALUE)
+ value = (int)propInfo.defaultValue;
+
+ device->SetIVCAMMotionRangeTradeOff(value);
+ return PXC_STATUS_NO_ERROR;
+ }
+
+ pxcStatus senseMgrInit()
+ {
+ pxcStatus status = PXC_STATUS_NO_ERROR;
+ status = m_senseManager->Enable3DSeg(nullptr);
+ if (status != PXC_STATUS_NO_ERROR)
+ return status;
+ m_segModule = m_senseManager->Query3DSeg();
+ if (!m_segModule)
+ return PXC_STATUS_DATA_UNAVAILABLE;
+
+ 
+ 
+ for (int i = 0; ; i++) {
+ pxcStatus status = PXC_STATUS_NO_ERROR;
+ PXCVideoModule::DataDesc currentProfile = {};
+ status = m_segModule->QueryInstance<PXCVideoModule>()->QueryCaptureProfile(i, &currentProfile);
+ if (status != PXC_STATUS_NO_ERROR)
+ return status;
+ if ((currentProfile.streams.depth.propertySet != DEPTH_PROPERTY_NORMAL_MODE)
+ || (currentProfile.streams.depth.options & PXCCapture::Device::STREAM_OPTION_DEPTH_CONFIDENCE)) {
+ continue;
+ }
+
+ m_senseManager->QueryCaptureManager()->FilterByStreamProfiles(nullptr);
+ m_senseManager->QueryCaptureManager()->FilterByStreamProfiles(nullptr);
+
+ m_senseManager->QueryCaptureManager()->FilterByStreamProfiles(PXCCapture::StreamType::STREAM_TYPE_COLOR, 0, 0, m_fps);
+ m_senseManager->QueryCaptureManager()->FilterByStreamProfiles(PXCCapture::StreamType::STREAM_TYPE_DEPTH, 0, 0, m_fps);
+ 
+ status = m_senseManager->EnableStreams(&currentProfile);
+ if (status != PXC_STATUS_NO_ERROR)
+ return status;
+ status = m_senseManager->Init(this);
+ if (status == PXC_STATUS_NO_ERROR) {
+ m_isPause = false;
+ break;
+ }
+ else {
+ continue;
+ }
+ }
+
+ return status;
+ }
+
+ HRESULT reinit()
+ {
+ m_isPause = true;
+ //wait_for_end_processing
+ while (m_processing)
+ std::this_thread::yield();
+
+ std::unique_lock<std::mutex> lck(m_pauseMtx);
+ m_senseManager->Close();
+
+ pxcStatus status = senseMgrInit();
+ m_isPause = false;
+ m_cvPause.notify_one();
+ return S_OK;
+ }
+
+ /* -----------------------------------------------------------------
+ * Modification by Jim
+ *
+ * To avoid linker issues with the RSSDK .lib files, load via
+ * LoadLibrary
+ * ----------------------------------------------------------------- */
+ typedef int (WINAPI *PXCSessionCreateProc)(PXCSession **output);
+
+ static HMODULE GetLib()
+ {
+ HMODULE lib = nullptr;
+ HKEY key = nullptr;
+ wchar_t path[1024];
+
+ LONG res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Intel\\RSSDK\\Dispatch", 0, KEY_QUERY_VALUE, &key);
+ if (res != ERROR_SUCCESS) {
+ res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Intel\\RSSDK\\v10\\Dispatch", 0, KEY_QUERY_VALUE, &key);
+ }
+
+ if (res != ERROR_SUCCESS)
+ return nullptr;
+
+ DWORD size = 1024;
+ res = RegQueryValueExW(key, L"Core", nullptr, nullptr, (LPBYTE)path, &size);
+ if (res == ERROR_SUCCESS) {
+ lib = LoadLibrary(path);
+ }
+
+ RegCloseKey(key);
+ return lib;
+ }
+
+ static PXCSenseManager* CreateSessionInstance()
+ {
+ static bool initialized = false;
+ static HMODULE lib = nullptr;
+ static PXCSessionCreateProc create = nullptr;
+
+ if (!initialized) {
+ lib = GetLib();
+ create = (PXCSessionCreateProc)GetProcAddress(lib, "PXCSession_Create");
+ initialized = true;
+ }
+
+ if (!lib || !create)
+ return nullptr;
+
+ PXCSession *session = nullptr;
+	int test = create(&session);
+ if (test != 0 || !session)
+ return nullptr;
+
+ PXCSenseManager *sm = session->CreateSenseManager();
+ session->Release();
+ return sm;
+ }
+
+ /* -----------------------------------------------------------------
+ * End Modification
+ * ----------------------------------------------------------------- */
+
+public:
+ CSegProc()
+ : m_isPause(true)
+ , m_fps(0)
+ , m_processing(false)
+ , m_motionRangeTradeOff(USE_DEFAULT_PROPERTY_VALUE)
+ {
+ }
+
+ DECLARE_REGISTRY_RESOURCEID(IDR_SEGPROC)
+
+ DECLARE_NOT_AGGREGATABLE(CSegProc)
+
+ BEGIN_COM_MAP(CSegProc)
+ COM_INTERFACE_ENTRY(ISegProc)
+ COM_INTERFACE_ENTRY(IDispatch)
+ END_COM_MAP()
+
+ DECLARE_PROTECT_FINAL_CONSTRUCT()
+
+ HRESULT FinalConstruct()
+ {
+ return S_OK;
+ }
+
+ void FinalRelease()
+ {
+ }
+
+ HRESULT STDMETHODCALLTYPE Init(LPCWSTR bufferName)
+ {
+ m_frameSize = 16;
+ m_frameToRead = -1;
+
+ m_bufferName = bufferName;
+
+ m_sharedBufferHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 2 * m_frameSize, m_bufferName.c_str());
+ if (m_sharedBufferHandle == NULL)
+ return E_FAIL;
+ m_sharedBuffer = (LPTSTR)MapViewOfFile(m_sharedBufferHandle, FILE_MAP_ALL_ACCESS, 0, 0, 32);
+ if (m_sharedBuffer == NULL)
+ {
+ CloseHandle(m_sharedBufferHandle);
+ return E_FAIL;
+ }
+ m_procRun = false;
+
+ /* -----------------------------------------------------------------
+ * Modification by Jim
+ *
+ * To avoid linker issues with the RSSDK .lib files, load via
+ * LoadLibrary.
+ * ----------------------------------------------------------------- */
+ m_senseManager = CreateSessionInstance();
+ /* -----------------------------------------------------------------
+ * End Modification
+ * ----------------------------------------------------------------- */
+ if (!m_senseManager)
+ return E_FAIL;
+
+ pxcStatus status = senseMgrInit();
+ if (status < PXC_STATUS_NO_ERROR)
+ return E_FAIL;
+
+ m_hStartedEvt = CreateEvent(NULL, FALSE, FALSE, TEXT("StartEvent"));
+ if (m_hStartedEvt == NULL)
+ {
+ return E_FAIL;
+ }
+
+ if (m_procRun)
+ return E_FAIL;
+ m_loopThreadHandle = CreateThread(NULL, 0, &CSegProc::LoopStub, this, 0, NULL);
+ if (m_loopThreadHandle == NULL)
+ {
+ return E_OUTOFMEMORY;
+ }
+ /* Waiting thread for start */
+ DWORD dwWaitResult = WaitForSingleObject(m_hStartedEvt, INFINITE);
+ switch (dwWaitResult)
+ {
+ case WAIT_OBJECT_0:
+ return S_OK;
+ }
+ return E_FAIL;
+ }
+
+ static DWORD WINAPI LoopStub(LPVOID lpParam)
+ {
+ if (!lpParam) return -1;
+ return ((CSegProc*)lpParam)->Loop(NULL);
+ }
+
+ DWORD WINAPI Loop(LPVOID /*lpParam*/)
+ {
+ static const int headerSize = sizeof(FrameHeader);
+ InitializeCriticalSection(&m_frameAccess[0]);
+ InitializeCriticalSection(&m_frameAccess[1]);
+ // Loop through frames
+ m_procRun = true;
+ SetEvent(m_hStartedEvt);
+ m_currentFrame = 0;
+ int frameCounter = 0;
+ while (m_procRun)
+ {
+ m_processing = false;
+
+ if (m_isPause)
+ {
+ std::unique_lock<std::mutex> lck(m_pauseMtx);
+ while (m_isPause)
+ m_cvPause.wait(lck);
+ }
+
+ m_processing = true;
+ if (m_senseManager->AcquireFrame(true) != PXC_STATUS_NO_ERROR)
+ {
+ continue;
+ }
+
+ EnterCriticalSection(&m_frameAccess[m_currentFrame]);
+ {
+ PXCImage* segImage = m_segModule->AcquireSegmentedImage();
+ if (segImage)
+ {
+ PXCImage::ImageData segData;
+ ZeroMemory(&segData, sizeof(segData));
+ pxcStatus sts = segImage->AcquireAccess(PXCImage::ACCESS_READ, PXCImage::PixelFormat::PIXEL_FORMAT_RGB32, &segData);
+ if (sts >= PXC_STATUS_NO_ERROR)
+ {
+ int newFrameSize = segData.pitches[0] * segImage->QueryInfo().height + headerSize;
+ if (newFrameSize != (int)m_frameSize)
+ {
+ EnterCriticalSection(&m_frameAccess[1 - m_currentFrame]);
+ ResizeBuffer(newFrameSize * 2);
+ m_frameSize = newFrameSize;
+ m_bufferRealloc = true;
+ LeaveCriticalSection(&m_frameAccess[1 - m_currentFrame]);
+ }
+ int offset = m_frameSize*m_currentFrame;
+ //((int*)m_sharedBuffer)[offset+0] = segImage->QueryInfo().width;
+ //((int*)m_sharedBuffer)[offset+1] = segImage->QueryInfo().height;
+ //((int*)m_sharedBuffer)[offset+2] = segData.pitches[0];
+ char *ptr = ((char*)m_sharedBuffer) + offset;
+ PXCImage::ImageInfo info = segImage->QueryInfo();
+ FrameHeader *fhPtr = (FrameHeader*)ptr;
+ fhPtr->width = info.width;
+ fhPtr->height = info.height;
+ fhPtr->pitch = segData.pitches[0];
+ fhPtr->timestamp = segImage->QueryTimeStamp();
+ fhPtr->frameNumber = frameCounter;
+ memcpy_s((void*)((char*)m_sharedBuffer + offset + headerSize), m_frameSize - headerSize, segData.planes[0], m_frameSize - headerSize);
+ segImage->ReleaseAccess(&segData);
+ }
+ segImage->Release();
+ }
+ }
+ m_currentFrame = 1 - m_currentFrame;
+ LeaveCriticalSection(&m_frameAccess[m_currentFrame]);
+
+ m_senseManager->ReleaseFrame();
+ frameCounter++;
+ }
+
+ DeleteCriticalSection(&m_frameAccess[0]);
+ DeleteCriticalSection(&m_frameAccess[1]);
+
+ return 0;
+ }
+
+ // Bad function for the reason of outside syncronization
+ HRESULT ResizeBuffer(size_t newSize)
+ {
+ UnmapViewOfFile(m_sharedBuffer);
+ CloseHandle(m_sharedBufferHandle);
+ m_sharedBufferHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, newSize, m_bufferName.c_str());
+
+ if (!m_sharedBufferHandle)
+ return E_ACCESSDENIED;
+ m_sharedBuffer = (LPTSTR)MapViewOfFile(m_sharedBufferHandle, FILE_MAP_ALL_ACCESS, 0, 0, newSize);
+
+ if (!m_sharedBuffer)
+ {
+ CloseHandle(m_sharedBufferHandle);
+ return E_OUTOFMEMORY;
+ }
+ ZeroMemory((void*)m_sharedBuffer, newSize);
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE LockBuffer(int* frameId, int* frameSize, int* bufferRealloc)
+ {
+ if (!m_procRun || m_frameToRead != -1)
+ return E_FAIL;
+ m_frameToRead = 1 - m_currentFrame;
+ EnterCriticalSection(&m_frameAccess[m_frameToRead]);
+ *frameId = m_frameToRead;
+ if (m_bufferRealloc)
+ {
+ *bufferRealloc = (int)m_bufferRealloc;
+ m_bufferRealloc = false;
+ }
+ else
+ *bufferRealloc = false;
+ *frameSize = m_frameSize;
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE UnlockBuffer()
+ {
+ if (!m_procRun || m_frameToRead == -1)
+ {
+ return E_FAIL;
+ }
+ LeaveCriticalSection(&m_frameAccess[m_frameToRead]);
+ m_frameToRead = -1;
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE Stop()
+ {
+ if (!m_procRun)
+ {
+ return E_FAIL;
+ }
+ m_procRun = false;
+ WaitForSingleObject(m_loopThreadHandle, INFINITE);
+ m_senseManager->Close();
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE SetFps(int fps)
+ {
+ if (m_fps == fps)
+ return S_OK;
+ m_fps = fps;
+ if (m_procRun)
+ return reinit();
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE GetFps(int* fps)
+ {
+ *fps = m_fps;
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE SetIVCAMMotionRangeTradeOff(int value)
+ {
+ if (m_motionRangeTradeOff == value)
+ return S_OK;
+ m_motionRangeTradeOff = value;
+ if (m_procRun)
+ return reinit();
+ return S_OK;
+ }
+
+ HRESULT STDMETHODCALLTYPE GetIVCAMMotionRangeTradeOff(int* value)
+ {
+ *value = m_motionRangeTradeOff;
+ return S_OK;
+ }
+};
+
+OBJECT_ENTRY_AUTO(__uuidof(SegProc), CSegProc)

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/SegProc.rgs Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/resource.h Added

@@ -0,0 +1,45 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by seg_service.rc
+//
+#define IDS_PROJNAME                    100
+#define IDR_SEG_SERVICE                 101
+#define IDR_SEGPROC                     106
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        201
+#define _APS_NEXT_COMMAND_VALUE         32768
+#define _APS_NEXT_CONTROL_VALUE         201
+#define _APS_NEXT_SYMED_VALUE           107
+#endif
+#endif

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/seg_service.cpp Added

@@ -0,0 +1,56 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// seg_service.cpp : Implementation of WinMain
+
+
+#include "stdafx.h"
+#include "resource.h"
+#include "seg_service.h"
+#include "xdlldata.h"
+
+using namespace ATL;
+
+
+class Cseg_serviceModule : public ATL::CAtlExeModuleT< Cseg_serviceModule >
+{
+public :
+	DECLARE_LIBID(LIBID_seg_serviceLib)
+	DECLARE_REGISTRY_APPID_RESOURCEID(IDR_SEG_SERVICE, "{B5EB3281-4ED1-4777-8ACD-99162EB15E81}")
+	};
+
+Cseg_serviceModule _AtlModule;
+
+
+
+//
+extern "C" int WINAPI _tWinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, 
+								LPTSTR /*lpCmdLine*/, int nShowCmd)
+{
+	return _AtlModule.WinMain(nShowCmd);
+}
+

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/seg_service.idl Added

@@ -0,0 +1,69 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// seg_service.idl : IDL source for seg_service
+//
+
+// This file will be processed by the MIDL tool to
+// produce the type library (seg_service.tlb) and marshalling code.
+
+import "oaidl.idl";
+import "ocidl.idl";
+
+[
+	object,
+	uuid(ADD60B51-95C7-4232-84B0-3CCBBEA7147C),
+	dual,
+	nonextensible,
+	pointer_default(unique)
+]
+interface ISegProc : IDispatch{
+    HRESULT Init(LPCWSTR bufferName);
+    HRESULT Stop();
+    HRESULT LockBuffer(int* frame, int* bufferRealloc, int* frameSize);
+    HRESULT SetFps(int fps);
+    HRESULT GetFps(int* fps);
+    HRESULT SetIVCAMMotionRangeTradeOff(int value);
+    HRESULT GetIVCAMMotionRangeTradeOff(int* value);
+    HRESULT UnlockBuffer();
+};
+[
+	uuid(64BC16FD-9E3C-4904-B9BA-A360310BCFEC),
+	version(1.0),
+]
+library seg_serviceLib
+{
+	importlib("stdole2.tlb");
+	[
+		uuid(66917998-CA70-42A6-B8AE-A3A5126123C7)		
+	]
+	coclass SegProc
+	{
+		[default] interface ISegProc;
+	};
+};
+

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/seg_service.rc Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/seg_service.rgs Added

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/stdafx.cpp Added

@@ -0,0 +1,32 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// stdafx.cpp : source file that includes just the standard includes
+// seg_service.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/stdafx.h Added

@@ -0,0 +1,52 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently,
+// but are changed infrequently
+
+#pragma once
+
+#ifndef STRICT
+#define STRICT
+#endif
+
+#include "targetver.h"
+
+#define _ATL_APARTMENT_THREADED
+
+#define _ATL_NO_AUTOMATIC_NAMESPACE
+
+#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS	// some CString constructors will be explicit
+
+
+#define ATL_NO_ASSERT_ON_DESTROY_NONEXISTENT_WINDOW
+
+#include "resource.h"
+#include <atlbase.h>
+#include <atlcom.h>
+#include <atlctl.h>

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/targetver.h Added

@@ -0,0 +1,35 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of Intel Corporation nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/xdlldata.c Added

@@ -0,0 +1,44 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+// wrapper for dlldata.c
+
+#ifdef _MERGE_PROXYSTUB // merge proxy stub DLL
+
+#define REGISTER_PROXY_DLL //DllRegisterServer, etc.
+
+#define _WIN32_WINNT 0x0500	//for WinNT 4.0 or Win95 with DCOM
+#define USE_STUBLESS_PROXY	//defined only with MIDL switch /Oicf
+
+#pragma comment(lib, "rpcns4.lib")
+#pragma comment(lib, "rpcrt4.lib")
+
+#define ENTRY_PREFIX	Prx
+
+#include "dlldata.c"
+#include "seg_service_p.c"
+
+#endif //_MERGE_PROXYSTUB

obs-studio-0.16.6.tar.xz/plugins/win-ivcam/seg_service/xdlldata.h Added

@@ -0,0 +1,42 @@
+/*
+Copyright (c) 2015-2016, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#pragma once
+
+#ifdef _MERGE_PROXYSTUB
+
+extern "C" 
+{
+BOOL WINAPI PrxDllMain(HINSTANCE hInstance, DWORD dwReason, 
+	LPVOID lpReserved);
+STDAPI PrxDllCanUnloadNow(void);
+STDAPI PrxDllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv);
+STDAPI PrxDllRegisterServer(void);
+STDAPI PrxDllUnregisterServer(void);
+}
+
+#endif

obs-studio-0.16.5.tar.xz/plugins/win-mf/data/locale/de-DE.ini -> obs-studio-0.16.6.tar.xz/plugins/win-mf/data/locale/de-DE.ini Changed

@@ -1,8 +1,8 @@
-MFAACEnc="Media Foundation AAC Encoder"
+MFAACEnc="Media Foundation AAC Codierer"
 Bitrate="Bitrate"
 
-MF.H264.EncoderName="Media Foundation H264 Encoder"
-MF.H264.Encoder="Encoder-Name"
+MF.H264.EncoderName="Media Foundation H264 Codierer"
+MF.H264.Encoder="Codierer-Name"
 MF.H264.LowLatency="Niedrige Latenz (Deaktiviert Frame Neuanordnung)"
 MF.H264.BFrames="Consecutive B-Frame count"
 MF.H264.CustomBufsize="Verwende benutzerdefinierte Puffergröße"
@@ -23,8 +23,8 @@
 MF.H264.Profile="Profil"
 MF.H264.Advanced="Erweitert"
 
-MF.H264.EncoderSWMicrosoft="Microsoft Software H.264 Encoder"
-MF.H264.EncoderHWAMD="AMD Video Coding Engine (VCE) H.264 Encoder (Media Foundation)"
-MF.H264.EncoderHWIntel="Intel Quick Sync H.264 Encoder (Media Foundation)"
-MF.H264.EncoderHWNVIDIA="NVIDIA NVENC H.264 Encoder (Media Foundation)"
+MF.H264.EncoderSWMicrosoft="Microsoft Software H.264 Codierer"
+MF.H264.EncoderHWAMD="AMD Video Coding Engine (VCE) H.264 Codierer (Media Foundation)"
+MF.H264.EncoderHWIntel="Intel Quick Sync H.264 Codierer (Media Foundation)"
+MF.H264.EncoderHWNVIDIA="NVIDIA NVENC H.264 Codierer (Media Foundation)"

obs-studio-0.16.5.tar.xz/plugins/win-mf/data/locale/sk-SK.ini -> obs-studio-0.16.6.tar.xz/plugins/win-mf/data/locale/sk-SK.ini Changed

Build Results
RPM Lint

Refresh

Comments for request 3146 0

Request History

boombatower created request about 8 years ago

boombatower accepted request about 8 years ago