Packman Build Service PMBS

obs-studio.changes Changed

obs-studio.spec Changed

_service Changed

_servicedata Changed

obs-studio-20.1.0.tar.xz/CI/before-script-osx.sh -> obs-studio-20.1.1.tar.xz/CI/before-script-osx.sh Changed

obs-studio-20.1.0.tar.xz/libobs/CMakeLists.txt -> obs-studio-20.1.1.tar.xz/libobs/CMakeLists.txt Changed

obs-studio-20.1.0.tar.xz/libobs/obs-config.h -> obs-studio-20.1.1.tar.xz/libobs/obs-config.h Changed

obs-studio-20.1.0.tar.xz/libobs/obs-windows.c -> obs-studio-20.1.1.tar.xz/libobs/obs-windows.c Changed

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

obs-studio-20.1.0.tar.xz/libobs/util/platform-windows.c -> obs-studio-20.1.1.tar.xz/libobs/util/platform-windows.c Changed

obs-studio-20.1.1.tar.xz/libobs/util/windows/win-registry.h Added

@@ -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

obs-studio-20.1.0.tar.xz/plugins/enc-amf/#Resources/PATCH_NOTES.md -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/#Resources/PATCH_NOTES.md Changed

obs-studio-20.1.0.tar.xz/plugins/enc-amf/CMakeLists.txt -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/CMakeLists.txt Changed

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Include/amf-encoder-h264.h -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Include/amf-encoder-h264.h Changed

@@ -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;

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Include/amf-encoder-h265.h -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Include/amf-encoder-h265.h Changed

@@ -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;

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Include/amf-encoder.h -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Include/amf-encoder.h Changed

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Source/amf-encoder-h264.cpp -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Source/amf-encoder-h264.cpp Changed

@@ -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 "  ");

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Source/amf-encoder-h265.cpp -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Source/amf-encoder-h265.cpp Changed

@@ -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 "  ");

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Source/enc-h264.cpp -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Source/enc-h264.cpp Changed

@@ -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);
-	}
-
+	m_VideoEncoder->SetFrameSkippingEnabled(!!obs_data_get_int(data, P_FRAMESKIPPING));
+	m_VideoEncoder->SetEnforceHRDEnabled(!!obs_data_get_int(data, P_ENFORCEHRD));
 	m_VideoEncoder->SetVBVBufferInitialFullness((float)obs_data_get_double(data, P_VBVBUFFER_INITIALFULLNESS) / 100.0f);
 	if (obs_data_get_int(data, P_VBVBUFFER) == 0) {
 		m_VideoEncoder->SetVBVBufferStrictness(obs_data_get_double(data, P_VBVBUFFER_STRICTNESS) / 100.0);

obs-studio-20.1.0.tar.xz/plugins/enc-amf/Source/enc-h265.cpp -> obs-studio-20.1.1.tar.xz/plugins/enc-amf/Source/enc-h265.cpp Changed

@@ -860,10 +860,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;
@@ -1082,26 +1082,25 @@
 	uint32_t obsFPSden = voi->fps_den;
 
 	// Rate Control
-	m_VideoEncoder->SetIFrameQPMinimum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_IFRAME_MINIMUM)));
-	m_VideoEncoder->SetIFrameQPMaximum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_IFRAME_MAXIMUM)));
-	m_VideoEncoder->SetPFrameQPMinimum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_PFRAME_MINIMUM)));
-	m_VideoEncoder->SetPFrameQPMaximum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_PFRAME_MAXIMUM)));
-	switch (m_VideoEncoder->GetRateControlMethod()) {
-		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)));
-			break;
+	RateControlMethod rcm = m_VideoEncoder->GetRateControlMethod();
+	if (rcm == RateControlMethod::ConstantQP) {
+		m_VideoEncoder->SetIFrameQPMinimum(m_VideoEncoder->CapsIFrameQPMinimum().first);
+		m_VideoEncoder->SetIFrameQPMaximum(m_VideoEncoder->CapsIFrameQPMaximum().second);
+		m_VideoEncoder->SetPFrameQPMinimum(m_VideoEncoder->CapsPFrameQPMinimum().first);
+		m_VideoEncoder->SetPFrameQPMaximum(m_VideoEncoder->CapsPFrameQPMaximum().second);
+		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)));
+		m_VideoEncoder->SetFillerDataEnabled(false);
+	} else {
+		m_VideoEncoder->SetIFrameQPMinimum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_IFRAME_MINIMUM)));
+		m_VideoEncoder->SetIFrameQPMaximum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_IFRAME_MAXIMUM)));
+		m_VideoEncoder->SetPFrameQPMinimum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_PFRAME_MINIMUM)));
+		m_VideoEncoder->SetPFrameQPMaximum(static_cast<uint8_t>(obs_data_get_int(data, P_QP_PFRAME_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));
 	}
-	if (m_VideoEncoder->GetRateControlMethod() == RateControlMethod::ConstantBitrate) {
+	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);

obs-studio-20.1.0.tar.xz/plugins/rtmp-services/data/package.json -> obs-studio-20.1.1.tar.xz/plugins/rtmp-services/data/package.json Changed

obs-studio-20.1.0.tar.xz/plugins/rtmp-services/data/services.json -> obs-studio-20.1.1.tar.xz/plugins/rtmp-services/data/services.json Changed

@@ -885,8 +885,12 @@
             "name": "Picarto",
             "servers": [
                 {
-                    "name": "USA/Canada",
-                    "url": "rtmp://live.us.picarto.tv/golive"
+                    "name": "US East",
+                    "url": "rtmp://live.us-east1.picarto.tv/golive"
+                },
+                {
+                    "name": "EU West",
+                    "url": "rtmp://live.eu-west1.picarto.tv/golive"
                 }
             ],
             "recommended": {
@@ -1068,6 +1072,38 @@
                 "max video bitrate": 6000,
                 "max audio bitrate": 160
             }
+        },
+        {
+            "name": "Stream.me",
+            "common": false,
+            "servers": [
+                {
+                    "name": "US, Central",
+                    "url": "rtmp://uc-origin.stream.me/origin"
+                },
+                {
+                    "name": "US, East",
+                    "url": "rtmp://ue-origin.stream.me/origin"
+                },
+                {
+                    "name": "US, West",
+                    "url": "rtmp://uw-origin.stream.me/origin"
+                },
+                {
+                    "name": "Europe, West",
+                    "url": "rtmp://ew-origin.stream.me/origin"
+                },
+                {
+                    "name": "Asia, East",
+                    "url": "rtmp://ae-origin.stream.me/origin"
+                }
+            ],
+            "recommended": {
+                "keyint": 2,
+                "profile": "main",
+                "max video bitrate": 20000,
+                "max audio bitrate": 192
+            }
         }
     ]
 }

Changes of Revision 51