Fixing Dual Output audio by moving encoder ownership out of AudioTrackFactory and into each advanced output (#1694)

Author: aleksandr-voitenko

obs-studio-server/source/nodeobs_api.cpp

@@ -1695,17 +1695,6 @@ void OBS_API::destroyOBS_API(void)
 		}
 	});
 
-	// Release all audio track encoders
-	std::vector<osn::AudioTrack *> audioTrackEncoders;
-	// osn::IAudioTrack::Manager::GetInstance().
-	// 	for_each([&audioTrackEncoders](osn::AudioTrack* audioTrackEncoder)
-	for (auto const &audioTrack : osn::IAudioTrack::audioTracks) {
-		if (audioTrack && audioTrack->audioEnc) {
-			obs_encoder_release(audioTrack->audioEnc);
-			audioTrack->audioEnc = nullptr;
-		}
-	};
-
 	// Release all services
 	osn::Service::Manager::GetInstance().for_each([](obs_service_t *service) {
 		if (service) {

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

@@ -96,6 +96,33 @@ void osn::IAdvancedRecording::Destroy(void *data, const int64_t id, const std::v
 	AUTO_DEBUG;
 }
 
+void osn::AdvancedRecording::ClearAudioEncoders()
+{
+	if (GetOutput()) {
+		for (int idx = 0; idx < MAX_AUDIO_MIXES; idx++)
+			obs_output_set_audio_encoder(GetOutput(), nullptr, idx);
+	}
+
+	for (auto *encoder : audioEncoders) {
+		if (!encoder)
+			continue;
+
+		if (obs_encoder_active(encoder)) {
+			blog(LOG_WARNING, "AdvancedRecording audio encoder is still active during cleanup; releasing owner reference.");
+		}
+
+		obs_encoder_release(encoder);
+	}
+
+	audioEncoders.clear();
+}
+
+osn::AdvancedRecording::~AdvancedRecording()
+{
+	DeleteOutput();
+	ClearAudioEncoders();
+}
+
 void osn::IAdvancedRecording::GetRescaling(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval)
 {
 	AdvancedRecording *recording = static_cast<AdvancedRecording *>(osn::IFileOutput::Manager::GetInstance().find(args[0].value_union.ui64));
@@ -210,16 +237,25 @@ void osn::IAdvancedRecording::Start(void *data, const int64_t id, const std::vec
 		PRETTY_ERROR_RETURN(ErrorCode::InvalidReference, "Error while creating the recording output.");
 	}
 
-	int idx = 0;
-	for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
-		osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[i];
-		if ((recording->mixer & (1 << i)) != 0 && audioTrack && audioTrack->audioEnc) {
-			obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio());
-			obs_output_set_audio_encoder(recording->GetOutput(), audioTrack->audioEnc, idx);
+	recording->ClearAudioEncoders();
 
-			obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(recording->GetCanvas(), OBS_RECORDING_VIDEO_RENDERING));
-			idx++;
-		}
+	int outputEncoderIndex = 0;
+	for (int mixerIndex = 0; mixerIndex < MAX_AUDIO_MIXES; mixerIndex++) {
+		if ((recording->mixer & (1 << mixerIndex)) == 0)
+			continue;
+
+		const uint32_t trackNumber = mixerIndex + 1;
+		std::string encoderName = "audio-encoder-recording-track";
+		encoderName += std::to_string(trackNumber);
+		obs_encoder_t *audioEncoder = osn::IAudioTrack::CreateEncoderForTrack(trackNumber, encoderName);
+		if (!audioEncoder)
+			continue;
+
+		recording->audioEncoders.push_back(audioEncoder);
+		obs_encoder_set_audio(audioEncoder, obs_get_audio());
+		obs_output_set_audio_encoder(recording->GetOutput(), audioEncoder, outputEncoderIndex);
+		obs_encoder_set_video_mix(audioEncoder, obs_video_mix_get(recording->GetCanvas(), OBS_RECORDING_VIDEO_RENDERING));
+		outputEncoderIndex++;
 	}
 
 	if (!recording->UpdateEncoders() || !recording->videoEncoder) {

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

@@ -22,6 +22,7 @@
 #include "utility.hpp"
 #include "osn-recording.hpp"
 #include "osn-advanced-streaming.hpp"
+#include <vector>
 
 namespace osn {
 class AdvancedRecording : public Recording {
@@ -36,7 +37,7 @@ class AdvancedRecording : public Recording {
 		streaming = nullptr;
 		simple = false;
 	}
-	~AdvancedRecording() {}
+	~AdvancedRecording();
 
 public:
 	uint32_t mixer;
@@ -45,8 +46,10 @@ class AdvancedRecording : public Recording {
 	uint32_t outputHeight;
 	bool useStreamEncoders;
 	AdvancedStreaming *streaming;
+	std::vector<obs_encoder_t *> audioEncoders;
 
 	bool UpdateEncoders();
+	void ClearAudioEncoders();
 };
 
 class IAdvancedRecording : public IRecording {

obs-studio-server/source/osn-advanced-replay-buffer.cpp

@@ -79,6 +79,33 @@ void osn::IAdvancedReplayBuffer::Destroy(void *data, const int64_t id, const std
 	AUTO_DEBUG;
 }
 
+void osn::AdvancedReplayBuffer::ClearAudioEncoders()
+{
+	if (GetOutput()) {
+		for (int idx = 0; idx < MAX_AUDIO_MIXES; idx++)
+			obs_output_set_audio_encoder(GetOutput(), nullptr, idx);
+	}
+
+	for (auto *encoder : audioEncoders) {
+		if (!encoder)
+			continue;
+
+		if (obs_encoder_active(encoder)) {
+			blog(LOG_WARNING, "AdvancedReplayBuffer audio encoder is still active during cleanup; releasing owner reference.");
+		}
+
+		obs_encoder_release(encoder);
+	}
+
+	audioEncoders.clear();
+}
+
+osn::AdvancedReplayBuffer::~AdvancedReplayBuffer()
+{
+	DeleteOutput();
+	ClearAudioEncoders();
+}
+
 void osn::IAdvancedReplayBuffer::GetMixer(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval)
 {
 	AdvancedReplayBuffer *replayBuffer = static_cast<AdvancedReplayBuffer *>(osn::IFileOutput::Manager::GetInstance().find(args[0].value_union.ui64));
@@ -127,14 +154,24 @@ void osn::IAdvancedReplayBuffer::Start(void *data, const int64_t id, const std::
 	if (!replayBuffer->GetOutput())
 		replayBuffer->CreateOutput("replay_buffer", "replay-buffer");
 
-	int idx = 0;
-	for (int i = 0; i < MAX_AUDIO_MIXES; i++) {
-		osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[i];
-		if ((replayBuffer->mixer & (1 << i)) != 0 && audioTrack && audioTrack->audioEnc) {
-			obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio());
-			obs_output_set_audio_encoder(replayBuffer->GetOutput(), audioTrack->audioEnc, idx);
-			idx++;
-		}
+	replayBuffer->ClearAudioEncoders();
+
+	int outputEncoderIndex = 0;
+	for (int mixerIndex = 0; mixerIndex < MAX_AUDIO_MIXES; mixerIndex++) {
+		if ((replayBuffer->mixer & (1 << mixerIndex)) == 0)
+			continue;
+
+		const uint32_t trackNumber = mixerIndex + 1;
+		std::string encoderName = "audio-encoder-replay-buffer-track";
+		encoderName += std::to_string(trackNumber);
+		obs_encoder_t *audioEncoder = osn::IAudioTrack::CreateEncoderForTrack(trackNumber, encoderName);
+		if (!audioEncoder)
+			continue;
+
+		replayBuffer->audioEncoders.push_back(audioEncoder);
+		obs_encoder_set_audio(audioEncoder, obs_get_audio());
+		obs_output_set_audio_encoder(replayBuffer->GetOutput(), audioEncoder, outputEncoderIndex);
+		outputEncoderIndex++;
 	}
 
 	obs_encoder_t *videoEncoder = nullptr;
@@ -337,4 +374,4 @@ void osn::IAdvancedReplayBuffer::SetRecording(void *data, const int64_t id, cons
 
 	rval.push_back(ipc::value((uint64_t)ErrorCode::Ok));
 	AUTO_DEBUG;
-}
+}

obs-studio-server/source/osn-advanced-replay-buffer.hpp

@@ -23,6 +23,7 @@
 #include "osn-replay-buffer.hpp"
 #include "osn-advanced-recording.hpp"
 #include "osn-advanced-streaming.hpp"
+#include <vector>
 
 namespace osn {
 class AdvancedReplayBuffer : public ReplayBuffer {
@@ -33,12 +34,15 @@ class AdvancedReplayBuffer : public ReplayBuffer {
 		streaming = nullptr;
 		recording = nullptr;
 	}
-	~AdvancedReplayBuffer() {}
+	~AdvancedReplayBuffer();
 
 public:
 	uint32_t mixer;
 	AdvancedStreaming *streaming;
 	AdvancedRecording *recording;
+	std::vector<obs_encoder_t *> audioEncoders;
+
+	void ClearAudioEncoders();
 };
 
 class IAdvancedReplayBuffer : public IReplayBuffer {

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

@@ -260,15 +260,38 @@ void osn::IAdvancedStreaming::SetOutputHeight(void *data, const int64_t id, cons
 
 static bool setAudioEncoder(osn::AdvancedStreaming *streaming)
 {
-	osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[streaming->audioTrack - 1];
-	if (!audioTrack)
+	if (!osn::IAudioTrack::GetTrackConfig(streaming->audioTrack))
 		return false;
-	if (!audioTrack->audioEnc)
+
+	const uint32_t mixerIndex = osn::IAudioTrack::GetMixerIndex(streaming->audioTrack);
+	if (streaming->audioEncoder && streaming->audioEncoderTrack != mixerIndex) {
+		if (obs_encoder_active(streaming->audioEncoder))
+			return false;
+
+		obs_encoder_release(streaming->audioEncoder);
+		streaming->audioEncoder = nullptr;
+		streaming->audioEncoderTrack = 0;
+	}
+
+	if (!streaming->audioEncoder) {
+		streaming->audioEncoder = osn::IAudioTrack::CreateEncoderForTrack(streaming->audioTrack, "audio-encoder-streaming");
+		streaming->audioEncoderTrack = mixerIndex;
+	} else if (!obs_encoder_active(streaming->audioEncoder)) {
+		osn::AudioTrack *audioTrack = osn::IAudioTrack::GetTrackConfig(streaming->audioTrack);
+		if (audioTrack) {
+			obs_data_t *settings = obs_data_create();
+			obs_data_set_int(settings, "bitrate", audioTrack->bitrate);
+			obs_encoder_update(streaming->audioEncoder, settings);
+			obs_data_release(settings);
+		}
+	}
+
+	if (!streaming->audioEncoder)
 		return false;
 
-	obs_encoder_set_audio(audioTrack->audioEnc, obs_get_audio());
-	obs_output_set_audio_encoder(streaming->GetOutput(), audioTrack->audioEnc, 0);
-	obs_encoder_set_video_mix(audioTrack->audioEnc, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING));
+	obs_encoder_set_audio(streaming->audioEncoder, obs_get_audio());
+	obs_output_set_audio_encoder(streaming->GetOutput(), streaming->audioEncoder, 0);
+	obs_encoder_set_video_mix(streaming->audioEncoder, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING));
 
 	return true;
 }
@@ -318,7 +341,7 @@ static void SetupTwitchSoundtrackAudio(osn::AdvancedStreaming *streaming)
 	obs_output_set_audio_encoder(streaming->GetOutput(), streaming->streamArchive, kSoundtrackArchiveEncoderIdx);
 	obs_encoder_set_video_mix(streaming->streamArchive, obs_video_mix_get(streaming->GetCanvas(), OBS_STREAMING_VIDEO_RENDERING));
 
-	osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTracks[streaming->twitchTrack];
+	osn::AudioTrack *audioTrack = osn::IAudioTrack::audioTrackConfigs[streaming->twitchTrack];
 	if (!audioTrack)
 		return;
 
@@ -388,6 +411,21 @@ void osn::AdvancedStreaming::UpdateEncoders()
 	}
 }
 
+osn::AdvancedStreaming::~AdvancedStreaming()
+{
+	DeleteOutput();
+
+	if (audioEncoder) {
+		if (obs_encoder_active(audioEncoder)) {
+			blog(LOG_WARNING, "AdvancedStreaming audio encoder is still active after DeleteOutput; releasing owner reference.");
+		}
+
+		obs_encoder_release(audioEncoder);
+		audioEncoder = nullptr;
+		audioEncoderTrack = 0;
+	}
+}
+
 void osn::IAdvancedStreaming::Start(void *data, const int64_t id, const std::vector<ipc::value> &args, std::vector<ipc::value> &rval)
 {
 	AdvancedStreaming *streaming = static_cast<AdvancedStreaming *>(osn::IAdvancedStreaming::Manager::GetInstance().find(args[0].value_union.ui64));

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

@@ -31,17 +31,21 @@ class AdvancedStreaming : public Streaming {
 	AdvancedStreaming() : Streaming()
 	{
 		audioTrack = 1;
+		audioEncoder = nullptr;
+		audioEncoderTrack = 0;
 		twitchTrack = 2;
 		rescaling = false;
 		rescaleFilter = OBS_SCALE_DISABLE;
 		outputWidth = 1280;
 		outputHeight = 720;
 		simple = false;
 	}
-	~AdvancedStreaming() {}
+	~AdvancedStreaming();
 
 public:
 	uint32_t audioTrack;
+	obs_encoder_t *audioEncoder;
+	uint32_t audioEncoderTrack;
 	uint32_t twitchTrack;
 	bool rescaling;
 	uint32_t rescaleFilter;