@@ -1,4 +1,16 @@

 -------------------------------------------------------------------

+Thu Oct 26 05:22:23 UTC 2017 - jimmy@boombatower.com

+

+- Update to version 20.1.1:

+  * libobs: Add wrapper function to query Windows registry

+  * libobs: Log Windows 10 Gaming Features

+  * CI: Update Travis script to target OSX 10.10+

+  * enc-amf: Version 2.2.4

+  * libobs: Update to version 20.1.1

+  * rtmp-services: Add Picarto eu-west1 ingress server

+  * rtmp-services: Add stream.me streaming platform

+

+-------------------------------------------------------------------

 Wed Oct 18 13:59:23 UTC 2017 - jimmy@boombatower.com

 - Update to version 20.1.0:

​

@@ -1,5 +1,5 @@

 Name:           obs-studio

-Version:        20.1.0

+Version:        20.1.1

 Release:        0

 Summary:        A recording/broadcasting program

 Group:          Productivity/Multimedia/Video/Editors and Convertors

​

@@ -1,7 +1,7 @@

 <services>

   <service name="tar_scm" mode="disabled">

     <param name="versionformat">@PARENT_TAG@</param>

-    <param name="revision">refs/tags/20.1.0</param>

+    <param name="revision">refs/tags/20.1.1</param>

     <param name="url">git://github.com/jp9000/obs-studio.git</param>

     <param name="scm">git</param>

     <param name="changesgenerate">enable</param>

​

@@ -1,6 +1,6 @@

 <servicedata>

   <service name="tar_scm">

     <param name="url">git://github.com/jp9000/obs-studio.git</param>

-    <param name="changesrevision">7bd06e7f26d6735e86cff4980f7777078d480f7d</param>

+    <param name="changesrevision">bf7561934ed098a4cf3c885f5e55febb23cac563</param>

   </service>

 </servicedata>

​

@@ -3,4 +3,4 @@

 mkdir build

 cd build

-cmake -DENABLE_SPARKLE_UPDATER=ON -DCMAKE_OSX_DEPLOYMENT_TARGET=10.9 -DDepsPath=/tmp/obsdeps -DVLCPath=$PWD/../../vlc-master -DBUILD_BROWSER=ON -DCEF_ROOT_DIR=$PWD/../../cef_binary_${CEF_BUILD_VERSION}_macosx64 ..

+cmake -DENABLE_SPARKLE_UPDATER=ON -DCMAKE_OSX_DEPLOYMENT_TARGET=10.10 -DDepsPath=/tmp/obsdeps -DVLCPath=$PWD/../../vlc-master -DBUILD_BROWSER=ON -DCEF_ROOT_DIR=$PWD/../../cef_binary_${CEF_BUILD_VERSION}_macosx64 ..

​

@@ -83,6 +83,7 @@

        util/platform-windows.c)

    set(libobs_PLATFORM_HEADERS

        util/threading-windows.h

+       util/windows/win-registry.h

        util/windows/win-version.h

        util/windows/ComPtr.hpp

        util/windows/CoTaskMemPtr.hpp

​

@@ -41,7 +41,7 @@

  *

  * Reset to zero each major or minor version

  */

-#define LIBOBS_API_PATCH_VER  0

+#define LIBOBS_API_PATCH_VER  1

 #define MAKE_SEMANTIC_VERSION(major, minor, patch) \

                              ((major << 24) | \

​

@@ -15,6 +15,7 @@

     along with this program.  If not, see <http://www.gnu.org/licenses/>.

 ******************************************************************************/

+#include "util/windows/win-registry.h"

 #include "util/windows/win-version.h"

 #include "util/platform.h"

 #include "util/dstr.h"

@@ -189,6 +190,49 @@

            aeroMessage);

 }

+#define WIN10_GAME_BAR_REG_KEY \

+       L"Software\\Microsoft\\Windows\\CurrentVersion\\GameDVR"

+#define WIN10_GAME_DVR_POLICY_REG_KEY \

+       L"SOFTWARE\\Policies\\Microsoft\\Windows\\GameDVR"

+#define WIN10_GAME_DVR_REG_KEY L"System\\GameConfigStore"

+#define WIN10_GAME_MODE_REG_KEY L"Software\\Microsoft\\GameBar"

+

+static void log_gaming_features(void)

+{

+   if (win_ver < 0xA00)

+       return;

+

+   struct reg_dword game_bar_enabled;

+   struct reg_dword game_dvr_allowed;

+   struct reg_dword game_dvr_enabled;

+   struct reg_dword game_dvr_bg_recording;

+   struct reg_dword game_mode_enabled;

+

+   get_reg_dword(HKEY_CURRENT_USER, WIN10_GAME_BAR_REG_KEY,

+           L"AppCaptureEnabled", &game_bar_enabled);

+   get_reg_dword(HKEY_CURRENT_USER, WIN10_GAME_DVR_POLICY_REG_KEY,

+           L"AllowGameDVR", &game_dvr_allowed);

+   get_reg_dword(HKEY_CURRENT_USER, WIN10_GAME_DVR_REG_KEY,

+           L"GameDVR_Enabled", &game_dvr_enabled);

+   get_reg_dword(HKEY_CURRENT_USER, WIN10_GAME_BAR_REG_KEY,

+           L"HistoricalCaptureEnabled", &game_dvr_bg_recording);

+   get_reg_dword(HKEY_CURRENT_USER, WIN10_GAME_MODE_REG_KEY,

+           L"AllowAutoGameMode", &game_mode_enabled);

+

+   blog(LOG_INFO, "Windows 10 Gaming Features:");

+   blog(LOG_INFO, "\tGame Bar: %s",

+           (bool)game_bar_enabled.return_value ? "On" : "Off");

+   blog(LOG_INFO, "\tGame DVR Allowed: %s",

+           (bool)game_dvr_allowed.return_value ? "Yes" : "No");

+   blog(LOG_INFO, "\tGame DVR: %s",

+           (bool)game_dvr_enabled.return_value ? "On" : "Off");

+   blog(LOG_INFO, "\tGame DVR Background Recording: %s",

+           (bool)game_dvr_bg_recording.return_value ? "On" :

+           "Off");

+   blog(LOG_INFO, "\tGame Mode: %s",

+           (bool)game_mode_enabled.return_value ? "On" : "Off");

+}

+

 void log_system_info(void)

 {

    struct win_version_info ver;

@@ -202,6 +246,7 @@

    log_windows_version();

    log_admin_status();

    log_aero();

+   log_gaming_features();

 }

​

@@ -26,6 +26,7 @@

 #include "platform.h"

 #include "darray.h"

 #include "dstr.h"

+#include "windows/win-registry.h"

 #include "windows/win-version.h"

 #include "../../deps/w32-pthreads/pthread.h"

@@ -800,6 +801,28 @@

 #endif

 }

+void get_reg_dword(HKEY hkey, LPCWSTR sub_key, LPCWSTR value_name,

+       struct reg_dword *info)

+{

+   struct reg_dword reg = {0};

+   HKEY key;

+   LSTATUS status;

+

+   status = RegOpenKeyEx(hkey, sub_key, 0, KEY_READ, &key);

+

+   if (status != ERROR_SUCCESS)

+       return;

+

+   reg.size = sizeof(reg.return_value);

+

+   reg.status = RegQueryValueExW(key, value_name, NULL, NULL,

+           (LPBYTE)&reg.return_value, &reg.size);

+

+   RegCloseKey(key);

+

+   *info = reg;

+}

+

 #define WINVER_REG_KEY L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"

 void get_win_ver(struct win_version_info *info)

​

@@ -0,0 +1,38 @@

+/*

+ * Copyright (c) 2015 Hugh Bailey <obs.jim@gmail.com>

+ * Copyright (c) 2017 Ryan Foster <RytoEX@gmail.com>

+ *

+ * Permission to use, copy, modify, and distribute this software for any

+ * purpose with or without fee is hereby granted, provided that the above

+ * copyright notice and this permission notice appear in all copies.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ */

+

+#pragma once

+

+#include <windows.h>

+#include "../c99defs.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+struct reg_dword {

+   LSTATUS status;

+   DWORD   size;

+   DWORD   return_value;

+};

+

+EXPORT void get_reg_dword(HKEY hkey, LPCWSTR sub_key, LPCWSTR value_name,

+       struct reg_dword *info);

+

+#ifdef __cplusplus

+}

+#endif

​

@@ -1,4 +1,4 @@

-# 2.2.2 - Pre-Pass, VBAQ and more fixes! (Hotfix 2)

+# 2.2.4 - Pre-Pass, VBAQ and more fixes! (Hotfix 4)

 With the newly released Driver 17.7.2, AMD fixed many reported issues and added some much wanted features:

 - Pre-Pass and VBAQ are finally working,

@@ -10,8 +10,16 @@

 Hotfix 1: Fixed VBAQ and Pre-Pass being used with Constant QP, causing significant corruption issues and changed some default values for H265.

 Hotfix 2: Fixed an at-exit crash caused by an AMF trace function.

+Hotfix 3: Fixed an issue with Constant QP that caused it to incorrectly use Minimum/Maximum QP.

+Hotfix 4: Updated internal property list to match Fall Creators Update AMD Driver.

 ## Changelog

+### 2.2.4

+* Removed LowLatency, CommonLowLatency and QPC*Offset properties.

+

+### 2.2.3

+* Fixed Minimum/Maximum QP incorrectly being applied to Constant QP.

+

 ### 2.2.2

 * Fixed an at-exit crash caused by calling amf::AMFTrace::TraceEnableAsync(true).

​

@@ -23,7 +23,7 @@

 ################################################################################

 SET(enc-amf_VERSION_MAJOR 2)

 SET(enc-amf_VERSION_MINOR 2)

-SET(enc-amf_VERSION_PATCH 2)

+SET(enc-amf_VERSION_PATCH 4)

 configure_file(

    "${PROJECT_SOURCE_DIR}/#Resources/package.in.bat"

    "${PROJECT_SOURCE_DIR}/#Resources/package.bat"

​

@@ -101,9 +101,11 @@

            virtual void SetFillerDataEnabled(bool v) override;

            virtual bool IsFillerDataEnabled() override;

+           virtual std::pair<uint8_t, uint8_t> CapsQPMinimum();

            void SetQPMinimum(uint8_t v);

            uint8_t GetQPMinimum();

+           virtual std::pair<uint8_t, uint8_t> CapsQPMaximum();

            void SetQPMaximum(uint8_t v);

            uint8_t GetQPMaximum();

@@ -115,12 +117,15 @@

            virtual void SetPeakBitrate(uint64_t v) override;

            virtual uint64_t GetPeakBitrate() override;

+           virtual std::pair<uint8_t, uint8_t> CapsIFrameQP();

            virtual void SetIFrameQP(uint8_t v) override;

            virtual uint8_t GetIFrameQP() override;

+           virtual std::pair<uint8_t, uint8_t> CapsPFrameQP();

            virtual void SetPFrameQP(uint8_t v) override;

            virtual uint8_t GetPFrameQP() override;

+           virtual std::pair<uint8_t, uint8_t> CapsBFrameQP();

            virtual void SetBFrameQP(uint8_t v);

            virtual uint8_t GetBFrameQP();

@@ -195,11 +200,11 @@

            uint32_t GetMaximumSliceSize();

            // Properties - Experimental

-           virtual void SetLowLatencyInternal(bool v) override;

-           virtual bool GetLowLatencyInternal() override;

+           //virtual void SetLowLatencyInternal(bool v) override;

+           //virtual bool GetLowLatencyInternal() override;

-           virtual void SetCommonLowLatencyInternal(bool v) override;

-           virtual bool GetCommonLowLatencyInternal() override;

+           //virtual void SetCommonLowLatencyInternal(bool v) override;

+           //virtual bool GetCommonLowLatencyInternal() override;

            // Internal

            virtual void LogProperties() override;

​

@@ -156,15 +156,19 @@

            virtual void SetFillerDataEnabled(bool v) override;

            virtual bool IsFillerDataEnabled() override;

+           virtual std::pair<uint8_t, uint8_t> CapsIFrameQPMinimum();

            void SetIFrameQPMinimum(uint8_t v);

            uint8_t GetIFrameQPMinimum();

+           virtual std::pair<uint8_t, uint8_t> CapsIFrameQPMaximum();

            void SetIFrameQPMaximum(uint8_t v);

            uint8_t GetIFrameQPMaximum();

+           virtual std::pair<uint8_t, uint8_t> CapsPFrameQPMinimum();

            void SetPFrameQPMinimum(uint8_t v);

            uint8_t GetPFrameQPMinimum();

+           virtual std::pair<uint8_t, uint8_t> CapsPFrameQPMaximum();

            void SetPFrameQPMaximum(uint8_t v);

            uint8_t GetPFrameQPMaximum();

@@ -176,9 +180,11 @@

            virtual void SetPeakBitrate(uint64_t v) override;

            virtual uint64_t GetPeakBitrate() override;

+           virtual std::pair<uint8_t, uint8_t> CapsIFrameQP() override;

            virtual void SetIFrameQP(uint8_t v) override;

            virtual uint8_t GetIFrameQP() override;

+           virtual std::pair<uint8_t, uint8_t> CapsPFrameQP() override;

            virtual void SetPFrameQP(uint8_t v) override;

            virtual uint8_t GetPFrameQP() override;

@@ -198,21 +204,21 @@

            virtual uint32_t GetSliceControlSize() override;

            // Experimental

-           void SetQPCBOffset(uint8_t v);

-           uint8_t GetQPCBOffset();

+           //void SetQPCBOffset(uint8_t v);

+           //uint8_t GetQPCBOffset();

-           void SetQPCROffset(uint8_t v);

-           uint8_t GetQPCROffset();

+           //void SetQPCROffset(uint8_t v);

+           //uint8_t GetQPCROffset();

            std::pair<uint32_t, uint32_t> CapsInputQueueSize();

            void SetInputQueueSize(uint32_t v);

            uint32_t GetInputQueueSize();

-           virtual void SetLowLatencyInternal(bool v) override;

-           virtual bool GetLowLatencyInternal() override;

+           //virtual void SetLowLatencyInternal(bool v) override;

+           //virtual bool GetLowLatencyInternal() override;

-           virtual void SetCommonLowLatencyInternal(bool v) override;

-           virtual bool GetCommonLowLatencyInternal() override;

+           //virtual void SetCommonLowLatencyInternal(bool v) override;

+           //virtual bool GetCommonLowLatencyInternal() override;

            // Internal

            virtual void LogProperties() override;

​

@@ -303,9 +303,11 @@

            virtual void SetPeakBitrate(uint64_t v) = 0;

            virtual uint64_t GetPeakBitrate() = 0;

+           virtual std::pair<uint8_t, uint8_t> CapsIFrameQP() = 0;

            virtual void SetIFrameQP(uint8_t v) = 0;

            virtual uint8_t GetIFrameQP() = 0;

+           virtual std::pair<uint8_t, uint8_t> CapsPFrameQP() = 0;

            virtual void SetPFrameQP(uint8_t v) = 0;

            virtual uint8_t GetPFrameQP() = 0;

@@ -364,11 +366,11 @@

            #pragma endregion Slicing

            #pragma region Internal

-           virtual void SetLowLatencyInternal(bool v) = 0;

-           virtual bool GetLowLatencyInternal() = 0;

+           //virtual void SetLowLatencyInternal(bool v) = 0;

+           //virtual bool GetLowLatencyInternal() = 0;

-           virtual void SetCommonLowLatencyInternal(bool v) = 0;

-           virtual bool GetCommonLowLatencyInternal() = 0;

+           //virtual void SetCommonLowLatencyInternal(bool v) = 0;

+           //virtual bool GetCommonLowLatencyInternal() = 0;

            #pragma endregion Internal

            #pragma endregion Settings

​

@@ -658,6 +658,20 @@

    return e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH264::CapsQPMinimum() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_MIN_QP, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH264::SetQPMinimum(uint8_t v) {

    AMFTRACECALL;

@@ -683,6 +697,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH264::CapsQPMaximum() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_MAX_QP, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH264::SetQPMaximum(uint8_t v) {

    AMFTRACECALL;

@@ -786,6 +814,20 @@

    return e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH264::CapsIFrameQP() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_QP_I, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH264::SetIFrameQP(uint8_t v) {

    AMFTRACECALL;

@@ -811,6 +853,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH264::CapsPFrameQP() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_QP_P, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH264::SetPFrameQP(uint8_t v) {

    AMFTRACECALL;

@@ -836,6 +892,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH264::CapsBFrameQP() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_QP_B, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH264::SetBFrameQP(uint8_t v) {

    AMFTRACECALL;

@@ -1445,54 +1515,54 @@

 }

 // Properties - Experimental

-void Plugin::AMD::EncoderH264::SetLowLatencyInternal(bool v) {

-   AMFTRACECALL;

-

-   AMF_RESULT res = m_AMFEncoder->SetProperty(L"LowLatencyInternal", v);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

-           m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-}

-

-bool Plugin::AMD::EncoderH264::GetLowLatencyInternal() {

-   AMFTRACECALL;

-

-   bool e;

-

-   AMF_RESULT res = m_AMFEncoder->GetProperty(L"LowLatencyInternal", &e);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

-           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-   return e;

-}

-

-void Plugin::AMD::EncoderH264::SetCommonLowLatencyInternal(bool v) {

-   AMFTRACECALL;

-

-   AMF_RESULT res = m_AMFEncoder->SetProperty(L"CommonLowLatencyInternal", v);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

-           m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-}

-

-bool Plugin::AMD::EncoderH264::GetCommonLowLatencyInternal() {

-   AMFTRACECALL;

-

-   bool e;

-   AMF_RESULT res = m_AMFEncoder->GetProperty(L"CommonLowLatencyInternal", &e);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

-           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-   return e;

-}

+//void Plugin::AMD::EncoderH264::SetLowLatencyInternal(bool v) {

+// AMFTRACECALL;

+//

+// AMF_RESULT res = m_AMFEncoder->SetProperty(L"LowLatencyInternal", v);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

+//         m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+//}

+//

+//bool Plugin::AMD::EncoderH264::GetLowLatencyInternal() {

+// AMFTRACECALL;

+//

+// bool e;

+//

+// AMF_RESULT res = m_AMFEncoder->GetProperty(L"LowLatencyInternal", &e);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

+//         m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+// return e;

+//}

+//

+//void Plugin::AMD::EncoderH264::SetCommonLowLatencyInternal(bool v) {

+// AMFTRACECALL;

+//

+// AMF_RESULT res = m_AMFEncoder->SetProperty(L"CommonLowLatencyInternal", v);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

+//         m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+//}

+//

+//bool Plugin::AMD::EncoderH264::GetCommonLowLatencyInternal() {

+// AMFTRACECALL;

+//

+// bool e;

+// AMF_RESULT res = m_AMFEncoder->GetProperty(L"CommonLowLatencyInternal", &e);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, PREFIX "<" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

+//         m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+// return e;

+//}

 // Internal

 void Plugin::AMD::EncoderH264::PacketPriorityAndKeyframe(amf::AMFDataPtr& pData, struct encoder_packet* packet) {

@@ -1827,14 +1897,14 @@

    #pragma endregion Slicing

    #pragma region Experimental

-   PLOG_INFO(PREFIX "  Experimental:",

-       m_UniqueId);

-   PLOG_INFO(PREFIX "    Low Latency: %s",

-       m_UniqueId,

-       GetLowLatencyInternal() ? "Enabled" : "Disabled");

-   PLOG_INFO(PREFIX "    Ultra Low Latency: %s",

-       m_UniqueId,

-       GetCommonLowLatencyInternal() ? "Enabled" : "Disabled");

+   //PLOG_INFO(PREFIX "  Experimental:",

+   //  m_UniqueId);

+   //PLOG_INFO(PREFIX "    Low Latency: %s",

+   //  m_UniqueId,

+   //  GetLowLatencyInternal() ? "Enabled" : "Disabled");

+   //PLOG_INFO(PREFIX "    Ultra Low Latency: %s",

+   //  m_UniqueId,

+   //  GetCommonLowLatencyInternal() ? "Enabled" : "Disabled");

    #pragma endregion Experimental

    //PLOG_INFO(PREFIX "  ");

​

@@ -1026,6 +1026,20 @@

    return e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH265::CapsIFrameQPMinimum() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_HEVC_MIN_QP_I, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH265::SetIFrameQPMinimum(uint8_t v) {

    AMFTRACECALL;

@@ -1051,6 +1065,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH265::CapsIFrameQPMaximum() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_HEVC_MAX_QP_I, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH265::SetIFrameQPMaximum(uint8_t v) {

    AMFTRACECALL;

@@ -1076,6 +1104,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH265::CapsPFrameQPMinimum() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_HEVC_MIN_QP_P, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH265::SetPFrameQPMinimum(uint8_t v) {

    AMFTRACECALL;

@@ -1101,6 +1143,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH265::CapsPFrameQPMaximum() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_HEVC_MAX_QP_P, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH265::SetPFrameQPMaximum(uint8_t v) {

    AMFTRACECALL;

@@ -1204,6 +1260,20 @@

    return e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH265::CapsIFrameQP() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_HEVC_QP_I, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH265::SetIFrameQP(uint8_t v) {

    AMFTRACECALL;

@@ -1229,6 +1299,20 @@

    return (uint8_t)e;

 }

+std::pair<uint8_t, uint8_t> Plugin::AMD::EncoderH265::CapsPFrameQP() {

+   AMFTRACECALL;

+

+   const amf::AMFPropertyInfo* var;

+   AMF_RESULT res = m_AMFEncoder->GetPropertyInfo(AMF_VIDEO_ENCODER_HEVC_QP_P, &var);

+   if (res != AMF_OK) {

+       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Querying capabilities failed, error %ls (code %d)",

+           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+       throw std::exception(errMsg.c_str());

+   }

+

+   return std::make_pair((uint8_t)var->minValue.int64Value, (uint8_t)var->maxValue.int64Value);

+}

+

 void Plugin::AMD::EncoderH265::SetPFrameQP(uint8_t v) {

    AMFTRACECALL;

@@ -1382,53 +1466,53 @@

 }

 // Experimental

-void Plugin::AMD::EncoderH265::SetQPCBOffset(uint8_t v) {

-   AMFTRACECALL;

-

-   AMF_RESULT res = m_AMFEncoder->SetProperty(L"QPCBOFFSET", v);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %ld, error %ls (code %d)",

-           m_UniqueId, v, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-}

-

-uint8_t Plugin::AMD::EncoderH265::GetQPCBOffset() {

-   AMFTRACECALL;

-

-   int64_t e;

-   AMF_RESULT res = m_AMFEncoder->GetProperty(L"QPCBOFFSET", &e);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

-           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-   return (uint8_t)e;

-}

-

-void Plugin::AMD::EncoderH265::SetQPCROffset(uint8_t v) {

-   AMFTRACECALL;

-

-   AMF_RESULT res = m_AMFEncoder->SetProperty(L"QPCROFFSET", v);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %ld, error %ls (code %d)",

-           m_UniqueId, v, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-}

-

-uint8_t Plugin::AMD::EncoderH265::GetQPCROffset() {

-   AMFTRACECALL;

-

-   int64_t e;

-   AMF_RESULT res = m_AMFEncoder->GetProperty(L"QPCROFFSET", &e);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

-           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-   return (uint8_t)e;

-}

+//void Plugin::AMD::EncoderH265::SetQPCBOffset(uint8_t v) {

+// AMFTRACECALL;

+//

+// AMF_RESULT res = m_AMFEncoder->SetProperty(L"QPCBOFFSET", v);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %ld, error %ls (code %d)",

+//         m_UniqueId, v, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+//}

+//

+//uint8_t Plugin::AMD::EncoderH265::GetQPCBOffset() {

+// AMFTRACECALL;

+//

+// int64_t e;

+// AMF_RESULT res = m_AMFEncoder->GetProperty(L"QPCBOFFSET", &e);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

+//         m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+// return (uint8_t)e;

+//}

+//

+//void Plugin::AMD::EncoderH265::SetQPCROffset(uint8_t v) {

+// AMFTRACECALL;

+//

+// AMF_RESULT res = m_AMFEncoder->SetProperty(L"QPCROFFSET", v);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %ld, error %ls (code %d)",

+//         m_UniqueId, v, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+//}

+//

+//uint8_t Plugin::AMD::EncoderH265::GetQPCROffset() {

+// AMFTRACECALL;

+//

+// int64_t e;

+// AMF_RESULT res = m_AMFEncoder->GetProperty(L"QPCROFFSET", &e);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

+//         m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+// return (uint8_t)e;

+//}

 std::pair<uint32_t, uint32_t> Plugin::AMD::EncoderH265::CapsInputQueueSize() {

    AMFTRACECALL;

@@ -1468,54 +1552,54 @@

    return (uint32_t)e;

 }

-void Plugin::AMD::EncoderH265::SetLowLatencyInternal(bool v) {

-   AMFTRACECALL;

-

-   AMF_RESULT res = m_AMFEncoder->SetProperty(L"LowLatencyInternal", v);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

-           m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-}

-

-bool Plugin::AMD::EncoderH265::GetLowLatencyInternal() {

-   AMFTRACECALL;

-

-   bool e;

-

-   AMF_RESULT res = m_AMFEncoder->GetProperty(L"LowLatencyInternal", &e);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

-           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-   return e;

-}

-

-void Plugin::AMD::EncoderH265::SetCommonLowLatencyInternal(bool v) {

-   AMFTRACECALL;

-

-   AMF_RESULT res = m_AMFEncoder->SetProperty(L"CommonLowLatencyInternal", v);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

-           m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-}

-

-bool Plugin::AMD::EncoderH265::GetCommonLowLatencyInternal() {

-   AMFTRACECALL;

-

-   bool e;

-   AMF_RESULT res = m_AMFEncoder->GetProperty(L"CommonLowLatencyInternal", &e);

-   if (res != AMF_OK) {

-       QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

-           m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

-       throw std::exception(errMsg.c_str());

-   }

-   return e;

-}

+//void Plugin::AMD::EncoderH265::SetLowLatencyInternal(bool v) {

+// AMFTRACECALL;

+//

+// AMF_RESULT res = m_AMFEncoder->SetProperty(L"LowLatencyInternal", v);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

+//         m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+//}

+//

+//bool Plugin::AMD::EncoderH265::GetLowLatencyInternal() {

+// AMFTRACECALL;

+//

+// bool e;

+//

+// AMF_RESULT res = m_AMFEncoder->GetProperty(L"LowLatencyInternal", &e);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

+//         m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+// return e;

+//}

+//

+//void Plugin::AMD::EncoderH265::SetCommonLowLatencyInternal(bool v) {

+// AMFTRACECALL;

+//

+// AMF_RESULT res = m_AMFEncoder->SetProperty(L"CommonLowLatencyInternal", v);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to set mode to %s, error %ls (code %d)",

+//         m_UniqueId, v ? "Enabled" : "Disabled", m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+//}

+//

+//bool Plugin::AMD::EncoderH265::GetCommonLowLatencyInternal() {

+// AMFTRACECALL;

+//

+// bool e;

+// AMF_RESULT res = m_AMFEncoder->GetProperty(L"CommonLowLatencyInternal", &e);

+// if (res != AMF_OK) {

+//     QUICK_FORMAT_MESSAGE(errMsg, "<Id: %lld> <" __FUNCTION_NAME__ "> Failed to retrieve value, error %ls (code %d)",

+//         m_UniqueId, m_AMF->GetTrace()->GetResultText(res), res);

+//     throw std::exception(errMsg.c_str());

+// }

+// return e;

+//}

 // Internal

 void Plugin::AMD::EncoderH265::PacketPriorityAndKeyframe(amf::AMFDataPtr& pData, struct encoder_packet* packet) {

@@ -1809,21 +1893,21 @@

    #pragma region Experimental

    PLOG_INFO(PREFIX "  Experimental:",

        m_UniqueId);

-   PLOG_INFO(PREFIX "    QPCBOffset: %" PRIu32,

-       m_UniqueId,

-       GetQPCBOffset());

-   PLOG_INFO(PREFIX "    QPCROffset: %" PRIu32,

-       m_UniqueId,

-       GetQPCROffset());

+   //PLOG_INFO(PREFIX "    QPCBOffset: %" PRIu32,

+   //  m_UniqueId,

+   //  GetQPCBOffset());

+   //PLOG_INFO(PREFIX "    QPCROffset: %" PRIu32,

+   //  m_UniqueId,

+   //  GetQPCROffset());

    PLOG_INFO(PREFIX "    Input Queue: %" PRIu32,

        m_UniqueId,

        GetInputQueueSize());

-   PLOG_INFO(PREFIX "    Low Latency: %s",

-       m_UniqueId,

-       GetLowLatencyInternal() ? "Enabled" : "Disabled");

-   PLOG_INFO(PREFIX "    Ultra Low Latency: %s",

-       m_UniqueId,

-       GetCommonLowLatencyInternal() ? "Enabled" : "Disabled");

+   //PLOG_INFO(PREFIX "    Low Latency: %s",

+   //  m_UniqueId,

+   //  GetLowLatencyInternal() ? "Enabled" : "Disabled");

+   //PLOG_INFO(PREFIX "    Ultra Low Latency: %s",

+   //  m_UniqueId,

+   //  GetCommonLowLatencyInternal() ? "Enabled" : "Disabled");

    #pragma endregion Experimental

    //PLOG_INFO(PREFIX "  ");

​

@@ -1286,10 +1286,10 @@

    }

    ColorSpace colorSpace = ColorSpace::BT601;

    switch (voi->colorspace) {

+       case VIDEO_CS_DEFAULT:

        case VIDEO_CS_601:

            colorSpace = ColorSpace::BT601;

            break;

-       case VIDEO_CS_DEFAULT:

        case VIDEO_CS_709:

            colorSpace = ColorSpace::BT709;

            break;

@@ -1395,42 +1395,35 @@

    // Rate Control

    RateControlMethod rcm = static_cast<RateControlMethod>(obs_data_get_int(data, P_RATECONTROLMETHOD));

    m_VideoEncoder->SetRateControlMethod(rcm);

-   m_VideoEncoder->SetQPMinimum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_MINIMUM)));

-   m_VideoEncoder->SetQPMaximum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_MAXIMUM)));

-   switch (rcm) {

-       case RateControlMethod::PeakConstrainedVariableBitrate:

-       case RateControlMethod::LatencyConstrainedVariableBitrate:

-           m_VideoEncoder->SetPeakBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_PEAK) * 1000));

-           m_VideoEncoder->SetTargetBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_TARGET) * 1000));

-           break;

-       case RateControlMethod::ConstantBitrate:

-           m_VideoEncoder->SetPeakBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_TARGET) * 1000));

-           m_VideoEncoder->SetTargetBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_TARGET) * 1000));

-           break;

-       case RateControlMethod::ConstantQP:

-           m_VideoEncoder->SetIFrameQP(static_cast<uint8_t>(obs_data_get_int(data, P_QP_IFRAME)));

-           m_VideoEncoder->SetPFrameQP(static_cast<uint8_t>(obs_data_get_int(data, P_QP_PFRAME)));

+   if (rcm == RateControlMethod::ConstantQP) {

+       m_VideoEncoder->SetQPMinimum(0);

+       m_VideoEncoder->SetQPMaximum(51);

+       m_VideoEncoder->SetIFrameQP(static_cast<uint8_t>(obs_data_get_int(data, P_QP_IFRAME)));

+       m_VideoEncoder->SetPFrameQP(static_cast<uint8_t>(obs_data_get_int(data, P_QP_PFRAME)));

+       if (m_VideoEncoder->CapsBFramePattern() > 0) {

            try {

                m_VideoEncoder->SetBFrameQP(static_cast<uint8_t>(obs_data_get_int(data, P_QP_BFRAME)));

            } catch (...) {

            }

-           break;

+       }

+       m_VideoEncoder->SetPrePassMode(PrePassMode::Disabled);

+       m_VideoEncoder->SetVarianceBasedAdaptiveQuantizationEnabled(false);

+   } else {

+       m_VideoEncoder->SetQPMinimum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_MINIMUM)));

+       m_VideoEncoder->SetQPMaximum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_MAXIMUM)));

+       m_VideoEncoder->SetTargetBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_TARGET) * 1000));

+       m_VideoEncoder->SetPeakBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_PEAK) * 1000));

+       m_VideoEncoder->SetPrePassMode(static_cast<PrePassMode>(obs_data_get_int(data, P_PREPASSMODE)));

+       m_VideoEncoder->SetVarianceBasedAdaptiveQuantizationEnabled(!!obs_data_get_int(data, P_VBAQ));

    }

-   m_VideoEncoder->SetFrameSkippingEnabled(!!obs_data_get_int(data, P_FRAMESKIPPING));

-   m_VideoEncoder->SetEnforceHRDEnabled(!!obs_data_get_int(data, P_ENFORCEHRD));

    if (rcm == RateControlMethod::ConstantBitrate) {

+       m_VideoEncoder->SetPeakBitrate(static_cast<uint32_t>(obs_data_get_int(data, P_BITRATE_TARGET) * 1000));

        m_VideoEncoder->SetFillerDataEnabled(!!obs_data_get_int(data, P_FILLERDATA));

    } else {

        m_VideoEncoder->SetFillerDataEnabled(false);

    }

-   if (rcm != RateControlMethod::ConstantQP) {

-       m_VideoEncoder->SetPrePassMode(static_cast<PrePassMode>(obs_data_get_int(data, P_PREPASSMODE)));

-       m_VideoEncoder->SetVarianceBasedAdaptiveQuantizationEnabled(!!obs_data_get_int(data, P_VBAQ));

-   } else {

-       m_VideoEncoder->SetPrePassMode(PrePassMode::Disabled);

-       m_VideoEncoder->SetVarianceBasedAdaptiveQuantizationEnabled(false);

-   }