Merge branch 'staging' into enhanced-broadcasting-new-api

avoitenko-logitech · avoitenko-logitech · commit ddbd067d87b0 · 2026-02-18T12:22:35.000Z
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -24,7 +24,7 @@ env:
   SLGenerator: Visual Studio 17 2022
   SLDistributeDirectory: distribute
   SLFullDistributePath: "streamlabs-build.app/distribute" # The .app extension is required to run macOS tests correctly.
-  LibOBSVersion: 30.2.4sl51
+  LibOBSVersion: 30.2.4sl59
   PACKAGE_NAME: osn
 
 jobs:
diff --git a/js/module.js b/js/module.js
@@ -123,11 +123,11 @@ function getSourcesSize(sourcesNames) {
     return sourcesSize;
 }
 exports.getSourcesSize = getSourcesSize;
-const __dirnameApple = hasDeveloperApp
+const appleBinaryFolder = hasDeveloperApp
   ? path.join(__dirname, 'OSN.app', 'distribute', 'obs-studio-node', 'bin')
   : path.join(__dirname, 'bin');
-if (fs.existsSync(path.resolve(__dirnameApple).replace('app.asar', 'app.asar.unpacked'))) {
-    obs.IPC.setServerPath(path.resolve(__dirnameApple, `obs64`).replace('app.asar', 'app.asar.unpacked'), path.resolve(__dirnameApple).replace('app.asar', 'app.asar.unpacked'));
+if (fs.existsSync(path.resolve(appleBinaryFolder, 'obs64').replace('app.asar', 'app.asar.unpacked'))) {
+    obs.IPC.setServerPath(path.resolve(appleBinaryFolder, `obs64`).replace('app.asar', 'app.asar.unpacked'), path.resolve(appleBinaryFolder).replace('app.asar', 'app.asar.unpacked'));
 }
 else if (fs.existsSync(path.resolve(__dirname, `obs64.exe`).replace('app.asar', 'app.asar.unpacked'))) {
     obs.IPC.setServerPath(path.resolve(__dirname, `obs64.exe`).replace('app.asar', 'app.asar.unpacked'), path.resolve(__dirname).replace('app.asar', 'app.asar.unpacked'));
diff --git a/js/module.ts b/js/module.ts
@@ -1926,11 +1926,11 @@ export const enum VCamOutputType {
 };
 
 // Initialization and other stuff which needs local data.
-const __dirnameApple = hasDeveloperApp
+const appleBinaryFolder = hasDeveloperApp
   ? path.join(__dirname, 'OSN.app', 'distribute', 'obs-studio-node', 'bin')
   : path.join(__dirname, 'bin');
-if (fs.existsSync(path.resolve(__dirnameApple).replace('app.asar', 'app.asar.unpacked'))) {
-    obs.IPC.setServerPath(path.resolve(__dirnameApple, `obs64`).replace('app.asar', 'app.asar.unpacked'), path.resolve(__dirnameApple).replace('app.asar', 'app.asar.unpacked'));
+if (fs.existsSync(path.resolve(appleBinaryFolder, 'obs64').replace('app.asar', 'app.asar.unpacked'))) {
+    obs.IPC.setServerPath(path.resolve(appleBinaryFolder, `obs64`).replace('app.asar', 'app.asar.unpacked'), path.resolve(appleBinaryFolder).replace('app.asar', 'app.asar.unpacked'));
 }
 else if (fs.existsSync(path.resolve(__dirname, `obs64.exe`).replace('app.asar', 'app.asar.unpacked'))) {
     obs.IPC.setServerPath(path.resolve(__dirname, `obs64.exe`).replace('app.asar', 'app.asar.unpacked'), path.resolve(__dirname).replace('app.asar', 'app.asar.unpacked'));
diff --git a/obs-studio-client/source/controller.cpp b/obs-studio-client/source/controller.cpp
@@ -449,7 +449,9 @@ Napi::Value js_connect(const Napi::CallbackInfo &info)
 	if (exit_code == STATUS_DLL_NOT_FOUND)
 		exit_code = ProcessInfo::MISSING_DEPENDENCY;
 #endif
-
+	if (exit_code == 0 && cl == nullptr) {
+		exit_code = ProcessInfo::OTHER_ERROR; // Null ipc client which can be caused due to missing obs64
+	}
 	return Napi::Number::New(info.Env(), exit_code);
 }
 
@@ -475,6 +477,9 @@ Napi::Value js_host(const Napi::CallbackInfo &info)
 		exit_code = ProcessInfo::MISSING_DEPENDENCY;
 #endif
 
+	if (exit_code == 0 && cl == nullptr) {
+		exit_code = ProcessInfo::OTHER_ERROR; // Null ipc client which can be caused due to missing obs64
+	}
 	return Napi::Number::New(info.Env(), exit_code);
 }
 
diff --git a/obs-studio-client/source/nodeobs_settings.cpp b/obs-studio-client/source/nodeobs_settings.cpp
@@ -406,6 +406,21 @@ void settings::OBS_settings_saveSettings(const Napi::CallbackInfo &info)
 		return;
 }
 
+Napi::Value settings::OBS_settings_isValidEncoder(const Napi::CallbackInfo &info)
+{
+	std::string category = info[0].ToString().Utf8Value();
+	auto conn = GetConnection(info);
+	if (!conn)
+		return info.Env().Undefined();
+
+	std::vector<ipc::value> response = conn->call_synchronous_helper("Settings", "OBS_settings_isValidEncoder", {ipc::value(category)});
+
+	if (!ValidateResponse(info, response))
+		return info.Env().Undefined();
+
+	return Napi::Boolean::New(info.Env(), response[1].value_union.ui32);
+}
+
 std::vector<std::string> settings::getListCategories(void)
 {
 	std::vector<std::string> categories;
@@ -525,6 +540,7 @@ void settings::Init(Napi::Env env, Napi::Object exports)
 {
 	exports.Set(Napi::String::New(env, "OBS_settings_getSettings"), Napi::Function::New(env, settings::OBS_settings_getSettings));
 	exports.Set(Napi::String::New(env, "OBS_settings_saveSettings"), Napi::Function::New(env, settings::OBS_settings_saveSettings));
+	exports.Set(Napi::String::New(env, "OBS_settings_isValidEncoder"), Napi::Function::New(env, settings::OBS_settings_isValidEncoder));
 	exports.Set(Napi::String::New(env, "OBS_settings_getListCategories"), Napi::Function::New(env, settings::OBS_settings_getListCategories));
 	exports.Set(Napi::String::New(env, "OBS_settings_getInputAudioDevices"), Napi::Function::New(env, settings::OBS_settings_getInputAudioDevices));
 	exports.Set(Napi::String::New(env, "OBS_settings_getOutputAudioDevices"), Napi::Function::New(env, settings::OBS_settings_getOutputAudioDevices));
diff --git a/obs-studio-client/source/nodeobs_settings.hpp b/obs-studio-client/source/nodeobs_settings.hpp
@@ -133,6 +133,8 @@ void Init(Napi::Env env, Napi::Object exports);
 
 Napi::Value OBS_settings_getSettings(const Napi::CallbackInfo &info);
 void OBS_settings_saveSettings(const Napi::CallbackInfo &info);
+Napi::Value OBS_settings_isValidEncoder(const Napi::CallbackInfo &info);
+
 Napi::Value OBS_settings_getListCategories(const Napi::CallbackInfo &info);
 
 Napi::Value OBS_settings_getInputAudioDevices(const Napi::CallbackInfo &info);
diff --git a/obs-studio-client/source/utility.hpp b/obs-studio-client/source/utility.hpp
@@ -122,7 +122,7 @@ static FORCE_INLINE std::shared_ptr<ipc::client> GetConnection(const Napi::Callb
 {
 	auto conn = Controller::GetInstance().GetConnection();
 	if (!conn) {
-		Napi::Error::New(info.Env(), "Failed to obtain IPC connection.").ThrowAsJavaScriptException();
+		std::cerr << "Failed to obtain IPC connection." << std::endl;
 		exit(1);
 	}
 	return conn;
diff --git a/obs-studio-server/source/nodeobs_service.cpp b/obs-studio-server/source/nodeobs_service.cpp
@@ -1550,7 +1550,7 @@ const char *get_simple_output_encoder(const char *encoder)
 		return ADVANCED_ENCODER_AMD_HEVC;
 	} else if (strcmp(encoder, SIMPLE_ENCODER_AMD_AV1) == 0) {
 		return "av1_texture_amf";
-	} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) {
+	} else if ((strcmp(encoder, SIMPLE_ENCODER_NVENC) == 0) || (strcmp(encoder, ENCODER_NVENC_H264_TEX) == 0)) {
 		return EncoderAvailable(ENCODER_NVENC_H264_TEX) ? ENCODER_NVENC_H264_TEX : ADVANCED_ENCODER_NVENC;
 	} else if (strcmp(encoder, SIMPLE_ENCODER_NVENC_HEVC) == 0) {
 		return EncoderAvailable(ENCODER_NVENC_HEVC_TEX) ? ENCODER_NVENC_HEVC_TEX : "ffmpeg_hevc_nvenc";
@@ -2767,6 +2767,8 @@ void OBS_service::OBS_service_connectOutputSignals(void *data, const int64_t id,
 	replayBufferSignals.push_back(SignalInfo("replay-buffer", "wrote"));
 	replayBufferSignals.push_back(SignalInfo("replay-buffer", "writing_error"));
 
+	virtualCamSignals.push_back(SignalInfo("virtual-camera", "activate"));
+	virtualCamSignals.push_back(SignalInfo("virtual-camera", "deactivate"));
 	virtualCamSignals.push_back(SignalInfo("virtual-camera", "start"));
 	virtualCamSignals.push_back(SignalInfo("virtual-camera", "stop"));
 
diff --git a/obs-studio-server/source/nodeobs_settings.cpp b/obs-studio-server/source/nodeobs_settings.cpp
@@ -72,6 +72,7 @@ void OBS_settings::Register(ipc::server &srv)
 	cls->register_function(std::make_shared<ipc::function>(
 		"OBS_settings_saveSettings", std::vector<ipc::type>{ipc::type::String, ipc::type::UInt32, ipc::type::UInt32, ipc::type::Binary},
 		OBS_settings_saveSettings));
+	cls->register_function(std::make_shared<ipc::function>("OBS_settings_isValidEncoder", std::vector<ipc::type>{}, OBS_settings_isValidEncoder));
 	cls->register_function(
 		std::make_shared<ipc::function>("OBS_settings_getInputAudioDevices", std::vector<ipc::type>{}, OBS_settings_getInputAudioDevices));
 	cls->register_function(
@@ -1196,6 +1197,60 @@ static void converOldJimNvencEncoder(config_t *config, const std::string &config
 	}
 }
 
+static bool validateEncoderForService(StreamServiceId serviceId, const char *encoderToFind)
+{
+	bool validEncoder = false;
+
+	//have encoder - find in encoders_set, validate 'streaming' flag and check availability based on 'check_availability_streaming' flag
+	for (int i = 0; i < encoders_set.size(); i++) {
+		if (std::string(encoderToFind) == encoders_set[i].simple_name || std::string(encoderToFind) == encoders_set[i].advanced_name) {
+			if (encoders_set[i].streaming) {
+				if (encoders_set[i].check_availability_streaming) {
+					if (isEncoderAvailableForStreaming(encoderToFind, OBS_service::getService(serviceId))) {
+						validEncoder = true;
+						break;
+					}
+				} else {
+					validEncoder = true;
+				}
+			}
+			break;
+		}
+	}
+
+	return validEncoder;
+}
+
+void OBS_settings::OBS_settings_isValidEncoder(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval)
+{
+	const char *mode = NULL;
+	const char *curEncoder = NULL;
+	bool validEncoder = false;
+	std::string serviceToCheck = args[0].value_str;
+
+	//get mode and configured encoder
+	mode = config_get_string(ConfigManager::getInstance().getBasic(), "Output", "Mode");
+	if (mode == NULL) {
+		mode = "Simple";
+	}
+	if (strcmp(mode, "Advanced") == 0) {
+		curEncoder = config_get_string(ConfigManager::getInstance().getBasic(), "AdvOut", "Encoder");
+	} else {
+		curEncoder = config_get_string(ConfigManager::getInstance().getBasic(), "SimpleOutput", "StreamingEncoder");
+	}
+
+	if (serviceToCheck == "Both") {
+		validEncoder = validateEncoderForService(StreamServiceId::Main, curEncoder) && validateEncoderForService(StreamServiceId::Second, curEncoder);
+	} else if (serviceToCheck == "Stream") {
+		validEncoder = validateEncoderForService(StreamServiceId::Main, curEncoder);
+	} else if (serviceToCheck == "StreamSecond") {
+		validEncoder = validateEncoderForService(StreamServiceId::Second, curEncoder);
+	}
+
+	rval.push_back(ipc::value((uint64_t)ErrorCode::Ok));
+	rval.push_back(ipc::value(validEncoder));
+}
+
 void OBS_settings::getSimpleOutputSettings(std::vector<SubCategory> *outputSettings, config_t *config, bool isCategoryEnabled)
 {
 	converOldJimNvencEncoder(config, "SimpleOutput", "StreamEncoder", "RecEncoder");
@@ -1892,8 +1947,7 @@ SubCategory OBS_settings::getAdvancedOutputStreamingSettings(config_t *config, b
 	rescale.currentValue.resize(sizeof(doRescale));
 	memcpy(rescale.currentValue.data(), &doRescale, sizeof(doRescale));
 	rescale.sizeOfCurrentValue = sizeof(doRescale);
-
-	rescale.visible = (encoderCurrentValue == ENCODER_NVENC_H264_TEX);
+	rescale.visible = (encoderCurrentValue != ENCODER_NVENC_H264_TEX);
 	rescale.enabled = isCategoryEnabled;
 	rescale.masked = false;
 
@@ -1942,8 +1996,7 @@ SubCategory OBS_settings::getAdvancedOutputStreamingSettings(config_t *config, b
 
 		rescaleRes.sizeOfValues = rescaleRes.values.size();
 		rescaleRes.countValues = outputResolutions.size();
-
-		rescaleRes.visible = (encoderCurrentValue == ENCODER_NVENC_H264_TEX);
+		rescaleRes.visible = (encoderCurrentValue != ENCODER_NVENC_H264_TEX);
 		rescaleRes.enabled = isCategoryEnabled;
 		rescaleRes.masked = false;
 
diff --git a/obs-studio-server/source/nodeobs_settings.h b/obs-studio-server/source/nodeobs_settings.h
@@ -149,6 +149,8 @@ class OBS_settings {
 	static void OBS_settings_getSettings(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval);
 	static void OBS_settings_saveSettings(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval);
 
+	static void OBS_settings_isValidEncoder(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval);
+
 	static void saveGenericSettings(std::vector<SubCategory> genericSettings, std::string section, config_t *config);
 
 	static void OBS_settings_getInputAudioDevices(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval);
diff --git a/obs-studio-server/source/osn-multitrack-video-output.cpp b/obs-studio-server/source/osn-multitrack-video-output.cpp
@@ -57,16 +57,16 @@ static void adjust_video_encoder_scaling(const obs_video_info &ovi, obs_encoder_
 	auto requested_width = encoder_config.width;
 	auto requested_height = encoder_config.height;
 
-	if (ovi.output_width == requested_width || ovi.output_height == requested_height)
-		return;
-
 	if (ovi.base_width < requested_width || ovi.base_height < requested_height) {
 		blog(LOG_WARNING, "Requested resolution exceeds canvas/available resolution for encoder %zu: %" PRIu32 "x%" PRIu32 " > %" PRIu32 "x%" PRIu32,
 		     encoder_index, requested_width, requested_height, ovi.base_width, ovi.base_height);
 	}
 
 	obs_encoder_set_scaled_size(video_encoder, requested_width, requested_height);
 	obs_encoder_set_gpu_scale_type(video_encoder, encoder_config.gpu_scale_type.value_or(OBS_SCALE_BICUBIC));
+	obs_encoder_set_preferred_video_format(video_encoder, encoder_config.format.value_or(VIDEO_FORMAT_NV12));
+	obs_encoder_set_preferred_color_space(video_encoder, encoder_config.colorspace.value_or(VIDEO_CS_709));
+	obs_encoder_set_preferred_range(video_encoder, encoder_config.range.value_or(VIDEO_RANGE_PARTIAL));
 }
 
 static uint32_t closest_divisor(const obs_video_info &ovi, const media_frames_per_second &target_fps)
@@ -85,14 +85,12 @@ static void adjust_encoder_frame_rate_divisor(const obs_video_info &ovi, obs_enc
 	}
 	media_frames_per_second requested_fps = *encoder_config.framerate;
 
-	if (ovi.fps_num == requested_fps.numerator && ovi.fps_den == requested_fps.denominator) {
+	if (ovi.fps_num == requested_fps.numerator && ovi.fps_den == requested_fps.denominator)
 		return;
-	}
 
 	auto divisor = closest_divisor(ovi, requested_fps);
-	if (divisor <= 1) {
+	if (divisor <= 1)
 		return;
-	}
 
 	blog(LOG_INFO, "Setting frame rate divisor to %u for encoder %zu", divisor, encoder_index);
 	obs_encoder_set_frame_rate_divisor(video_encoder, divisor);
diff --git a/tests/osn-tests/util/obs_handler.ts b/tests/osn-tests/util/obs_handler.ts
@@ -110,7 +110,13 @@ export class OBSHandler {
         logInfo(this.osnTestName, 'Initializing OBS');
 
         try {
-            osn.NodeObs.IPC.host(this.pipeName);
+            const exitCode = osn.NodeObs.IPC.host(this.pipeName);
+            if (exitCode != osn.EVideoCodes.Success) {
+                if (exitCode == osn.EIPCError.OTHER_ERROR) {
+                    throw Error('OBS IPC host failed: missing executable or some other error.');
+                }
+                throw Error(`OBS IPC host failed with code ${exitCode}. See osn.EIPCError for more details.`);
+            }
             osn.NodeObs.SetWorkingDirectory(this.workingDirectory);
             initResult = osn.NodeObs.OBS_API_initAPI(this.language, this.obsPath, this.version, this.crashServer);
         } catch (e) {

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ static FORCE_INLINE std::shared_ptr<ipc::client> GetConnection(const Napi::Callb`
`122`	`122`	`{`
`123`	`123`	`auto conn = Controller::GetInstance().GetConnection();`
`124`	`124`	`if (!conn) {`
`125`		`- Napi::Error::New(info.Env(), "Failed to obtain IPC connection.").ThrowAsJavaScriptException();`
	`125`	`+ std::cerr << "Failed to obtain IPC connection." << std::endl;`
`126`	`126`	`exit(1);`
`127`	`127`	`}`
`128`	`128`	`return conn;`