Merge branch 'staging' into update-libobs-v29.1.3sl38

obs-studio-client/source/audio-track.cpp

@@ -62,7 +62,9 @@ Napi::Value osn::AudioTrack::Create(const Napi::CallbackInfo &info)
 	if (!conn)
 		return info.Env().Undefined();
 
-	std::vector<ipc::value> response = conn->call_synchronous_helper("AudioTrack", "Create", {});
+	uint32_t bitrate = info[0].ToNumber().Uint32Value();
+	std::string name = info[1].ToString().Utf8Value();
+	std::vector<ipc::value> response = conn->call_synchronous_helper("AudioTrack", "Create", {ipc::value(bitrate), ipc::value(name)});
 
 	if (!ValidateResponse(info, response))
 		return info.Env().Undefined();

obs-studio-server/source/nodeobs_common.cpp

@@ -394,14 +394,14 @@ void OBS_content::OBS_content_resizeDisplay(void *data, const int64_t id, const
 	display->m_gsInitData.cx = args[1].value_union.ui32;
 	display->m_gsInitData.cy = args[2].value_union.ui32;
 
+#ifdef WIN32
+	display->SetSize(display->m_gsInitData.cx, display->m_gsInitData.cy);
+#else
 	// Resize Display
 	obs_display_resize(display->m_display, display->m_gsInitData.cx, display->m_gsInitData.cy);
 
 	// Store new size.
 	display->UpdatePreviewArea();
-
-#ifdef WIN32
-	display->SetSize(display->m_gsInitData.cx, display->m_gsInitData.cy);
 #endif
 	rval.push_back(ipc::value((uint64_t)ErrorCode::Ok));
 	AUTO_DEBUG;

obs-studio-server/source/nodeobs_service.cpp

@@ -1237,6 +1237,7 @@ bool OBS_service::startStreaming(StreamServiceId serviceId)
 
 	obs_output_set_video_encoder(streamingOutput[serviceId], videoStreamingEncoder[serviceId]);
 	obs_output_set_audio_encoder(streamingOutput[serviceId], audioStreamingEncoder[serviceId], 0);
+	obs_encoder_set_video_mix(audioStreamingEncoder[serviceId], obs_video_mix_get(videoInfo[serviceId], OBS_MAIN_VIDEO_RENDERING));
 
 	twitchSoundtrackEnabled = startTwitchSoundtrackAudio();
 	if (!twitchSoundtrackEnabled)
@@ -1320,7 +1321,7 @@ void OBS_service::updateAudioStreamingEncoder(bool isSimpleMode, StreamServiceId
 		obs_data_release(settings);
 	}
 	obs_encoder_set_audio(enc, obs_get_audio());
-
+	obs_encoder_set_video_mix(enc, obs_video_mix_get(videoInfo[serviceId], OBS_STREAMING_VIDEO_RENDERING));
 	return;
 }
 
@@ -1341,6 +1342,7 @@ void OBS_service::updateAudioRecordingEncoder(bool isSimpleMode)
 			throw std::runtime_error("Failed to create audio simple recording encoder");
 
 		obs_encoder_set_audio(audioSimpleRecordingEncoder, obs_get_audio());
+		obs_encoder_set_video_mix(audioSimpleRecordingEncoder, obs_video_mix_get(0, OBS_RECORDING_VIDEO_RENDERING));
 	} else {
 		updateRecordingAudioTracks();
 	}
@@ -2626,7 +2628,6 @@ void OBS_service::JSCallbackOutputSignal(void *data, calldata_t *params)
 
 void OBS_service::connectOutputSignals(StreamServiceId serviceId)
 {
-	blog(LOG_DEBUG, "connectOutputSignals ");
 	if (streamingOutput[serviceId]) {
 		signal_handler *streamingOutputSignalHandler = obs_output_get_signal_handler(streamingOutput[serviceId]);
 
@@ -2658,7 +2659,6 @@ void OBS_service::connectOutputSignals(StreamServiceId serviceId)
 					       &(replayBufferSignals.at(i)));
 		}
 	}
-	blog(LOG_DEBUG, "connectOutputSignals finished ");
 }
 
 struct HotkeyInfo {
@@ -2931,6 +2931,7 @@ bool OBS_service::startTwitchSoundtrackAudio(void)
 	}
 
 	obs_output_set_audio_encoder(streamingOutput[0], streamArchiveEncST, kSoundtrackArchiveEncoderIdx);
+	obs_encoder_set_video_mix(streamArchiveEncST, obs_video_mix_get(videoInfo[0], OBS_STREAMING_VIDEO_RENDERING));
 
 	std::string currentOutputMode = config_get_string(ConfigManager::getInstance().getBasic(), "Output", "Mode");
 	bool isSimpleMode = currentOutputMode.compare("Simple") == 0;
@@ -3027,6 +3028,7 @@ void OBS_service::setupVodTrack(bool isSimpleMode)
 				       ARCHIVE_NAME, vodTrackIndex)) {
 			obs_encoder_set_audio(streamArchiveEncVod, obs_get_audio());
 			obs_output_set_audio_encoder(streamingOutput[0], streamArchiveEncVod, 1);
+			obs_encoder_set_video_mix(streamArchiveEncVod, obs_video_mix_get(videoInfo[0], OBS_STREAMING_VIDEO_RENDERING));
 		}
 	}
 }

obs-studio-server/source/osn-advanced-recording.cpp

@@ -214,6 +214,8 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec
 		if ((recording->mixer & (1 << i)) != 0 && audioTrack && audioTrack->audioEnc) {
 			obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio());
 			obs_output_set_audio_encoder(recording->output, audioTrack->audioEnc, idx);
+
+			obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(recording->canvas, OBS_RECORDING_VIDEO_RENDERING));
 			idx++;
 		}
 	}

obs-studio-server/source/osn-advanced-streaming.cpp

@@ -238,6 +238,7 @@ static bool setAudioEncoder(osn::AdvancedStreaming *streaming)
 
 	obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio());
 	obs_output_set_audio_encoder(streaming->output, audioTrack->audioEnc, 0);
+	obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING));
 
 	return true;
 }
@@ -285,6 +286,7 @@ static void SetupTwitchSoundtrackAudio(osn::AdvancedStreaming *streaming)
 	}
 
 	obs_output_set_audio_encoder(streaming->output, streaming->streamArchive, kSoundtrackArchiveEncoderIdx);
+	obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING));
 
 	osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[streaming->twitchTrack];
 	if (!audioTrack)

obs-studio-server/source/osn-audio-track.cpp

@@ -45,7 +45,9 @@ void osn::IAudioTrack::Register(ipc::server &srv)
 
 void osn::IAudioTrack::Create(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval)
 {
-	uint64_t uid = osn::IAudioTrack::Manager::GetInstance().allocate(new AudioTrack());
+	uint32_t bitrate = args[0].value_union.ui32;
+	std::string name = args[1].value_str;
+	uint64_t uid = osn::IAudioTrack::Manager::GetInstance().allocate(new AudioTrack(bitrate, name));
 	if (uid == UINT64_MAX) {
 		PRETTY_ERROR_RETURN(ErrorCode::CriticalError, "Index list is full.");
 	}
@@ -189,7 +191,7 @@ void osn::IAudioTrack::ImportLegacySettings(void *data, const int64_t id, const
 		bitrateParam += "Bitrate";
 		std::string nameParam = prefix;
 		nameParam += "Name";
-		auto track = new AudioTrack();
+		auto track = new AudioTrack(160, "");
 		auto uid = osn::IAudioTrack::Manager::GetInstance().allocate(track);
 		if (uid != UINT64_MAX) {
 			track->bitrate = config_get_uint(ConfigManager::getInstance().getBasic(), "AdvOut", bitrateParam.c_str());

obs-studio-server/source/osn-audio-track.hpp

@@ -29,12 +29,8 @@
 namespace osn {
 class AudioTrack {
 public:
-	AudioTrack()
-	{
-		bitrate = 160;
-		name = "";
-		audioEnc = nullptr;
-	}
+	AudioTrack(uint32_t bitrate, std::string name) : bitrate(bitrate), name(name), audioEnc(nullptr) {}
+
 	~AudioTrack()
 	{
 		if (audioEnc && !obs_encoder_active(audioEnc)) {

obs-studio-server/source/osn-simple-recording.cpp

@@ -378,6 +378,7 @@ void osn::ISimpleRecording::Start(void *data, const int64_t id, const std::vecto
 
 		obs_encoder_set_audio(recording->audioEncoder, obs_get_audio());
 		obs_output_set_audio_encoder(recording->output, recording->audioEncoder, 0);
+		obs_encoder_set_video_mix(recording->audioEncoder, obs_video_mix_get(recording->canvas, OBS_RECORDING_VIDEO_RENDERING));
 
 		obs_output_set_video_encoder(recording->output, recording->videoEncoder);
 	}

obs-studio-server/source/osn-simple-streaming.cpp

@@ -215,6 +215,7 @@ static void SetupTwitchSoundtrackAudio(osn::SimpleStreaming *streaming)
 	}
 
 	obs_output_set_audio_encoder(streaming->output, streaming->streamArchive, kSoundtrackArchiveEncoderIdx);
+	obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING));
 
 	obs_data_t *settings = obs_data_create();
 
@@ -358,6 +359,7 @@ void osn::ISimpleStreaming::Start(void *data, const int64_t id, const std::vecto
 	streaming->UpdateEncoders();
 	obs_encoder_set_audio(streaming->audioEncoder, obs_get_audio());
 	obs_output_set_audio_encoder(streaming->output, streaming->audioEncoder, 0);
+	obs_encoder_set_video_mix(streaming->audioEncoder, obs_video_mix_get(streaming->canvas, OBS_STREAMING_VIDEO_RENDERING));
 
 	obs_output_set_video_encoder(streaming->output, streaming->videoEncoder);
 

obs-studio-server/source/utility.hpp

@@ -36,7 +36,10 @@
 #define PRETTY_ERROR_RETURN(_error_code, _message)                                                           \
 	{                                                                                                    \
 		if (utility::osn_current_version() == "0.00.00-preview.0") {                                 \
-			rval.push_back((uint64_t)ErrorCode::Error);                                          \
+			rval.push_back(ipc::value((uint64_t)_error_code));                                   \
+			rval.push_back(ipc::value(_message));                                                \
+			auto error_message = std::string(__PRETTY_FUNCTION__) + " " + std::string(_message); \
+			blog(LOG_ERROR, "%s", error_message.c_str());                                        \
 			return;                                                                              \
 		} else {                                                                                     \
 			rval.push_back(ipc::value((uint64_t)_error_code));                                   \