Audio experiments

2026-05-05 12:18:42 +10:00
parent f836c53d10
commit 9a8748687a
6 changed files with 719 additions and 80 deletions
--- a/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.cpp
@@ -44,6 +44,7 @@
 #include "OscServer.h"

 #include <algorithm>
+#include <chrono>
 #include <cstdint>
 #include <cstring>
 #include <cctype>
@@ -51,6 +52,7 @@
 #include <set>
 #include <sstream>
 #include <string>
+#include <thread>
 #include <vector>

 #include <initguid.h>
@@ -66,6 +68,8 @@ constexpr GLuint kPackedVideoTextureUnit = 2;
 constexpr GLuint kGlobalParamsBindingPoint = 0;
 constexpr unsigned kVideoPrerollFrameCount = 5;
 constexpr unsigned kAudioOutputWaterLevelSampleFrames = kAudioSampleRate / 2;
+constexpr unsigned kAudioScheduleChunkSampleFrames = kAudioSampleRate / 100;
+constexpr unsigned kDeckLinkOutputAudioChannelCount = 16;

 #ifndef GL_RGBA32F
 #define GL_RGBA32F 0x8814
@@ -325,7 +329,7 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	mDLInput(NULL), mDLOutput(NULL), mDLInputConfiguration(NULL), mDLKeyer(NULL),
 	mPlayoutAllocator(NULL),
 	mTotalPlayoutFrames(0),
-	mNextAudioSampleFrame(0),
+	mAudioOutputSampleTime(0),
 	mInputFrameWidth(0), mInputFrameHeight(0),
 	mOutputFrameWidth(0), mOutputFrameHeight(0),
 	mInputDisplayModeName("1080p59.94"),
@@ -358,7 +362,14 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	mViewWidth(0),
 	mViewHeight(0),
 	mAudioEnabled(false),
+	mAudioOutputEnabled(false),
+	mAudioScheduleEnabled(false),
+	mAudioPrerollEnabled(false),
+	mAudioScheduleSilence(false),
+	mAudioScheduleTone(false),
 	mAudioPrerolling(false),
+	mAudioSchedulerRunning(false),
+	mPlayoutCallbackActive(false),
 	mTemporalHistoryNeedsReset(true)
 {
 	InitializeCriticalSection(&pMutex);
@@ -369,6 +380,11 @@ OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :

 OpenGLComposite::~OpenGLComposite()
 {
+	mAudioSchedulerRunning.store(false);
+	mAudioPacketQueued.notify_all();
+	if (mAudioSchedulerThread.joinable())
+		mAudioSchedulerThread.join();
+
 	// Cleanup for Capture
 	if (mDLInput != NULL)
 	{
@@ -638,6 +654,11 @@ bool OpenGLComposite::InitDeckLink()

 	if (! CheckOpenGLExtensions())
 		goto error;
+	if (mAudioOutputEnabled)
+	{
+		mFastTransferExtensionAvailable = false;
+		OutputDebugStringA("Audio output enabled; using DeckLink-owned output video frames for SDI stability.\n");
+	}
 	if (mInputFrameWidth != mOutputFrameWidth || mInputFrameHeight != mOutputFrameHeight)
 	{
 		mFastTransferExtensionAvailable = false;
@@ -689,6 +710,11 @@ bool OpenGLComposite::InitDeckLink()
 	}

 	mAudioEnabled = mRuntimeHost ? mRuntimeHost->AudioEnabled() : true;
+	mAudioOutputEnabled = mAudioEnabled && (mRuntimeHost ? mRuntimeHost->AudioOutputEnabled() : true);
+	mAudioScheduleEnabled = mAudioOutputEnabled && (mRuntimeHost ? mRuntimeHost->AudioScheduleEnabled() : true);
+	mAudioPrerollEnabled = mAudioScheduleEnabled && (mRuntimeHost ? mRuntimeHost->AudioPrerollEnabled() : true);
+	mAudioScheduleSilence = mAudioScheduleEnabled && (mRuntimeHost ? mRuntimeHost->AudioScheduleSilence() : false);
+	mAudioScheduleTone = mAudioScheduleEnabled && (mRuntimeHost ? mRuntimeHost->AudioScheduleTone() : false);
 	if (mAudioEnabled)
 	{
 		if (mDLInput->QueryInterface(IID_IDeckLinkConfiguration, (void**)&mDLInputConfiguration) == S_OK && mDLInputConfiguration != NULL)
@@ -721,11 +747,10 @@ bool OpenGLComposite::InitDeckLink()
 	if (mDLOutput->EnableVideoOutput(outputDisplayMode, bmdVideoOutputFlagDefault) != S_OK)
 		goto error;

-	if (mAudioEnabled && mDLOutput->EnableAudioOutput(bmdAudioSampleRate48kHz, bmdAudioSampleType32bitInteger, kAudioChannelCount, bmdAudioOutputStreamTimestamped) != S_OK)
+	if (mAudioOutputEnabled && mDLOutput->EnableAudioOutput(bmdAudioSampleRate48kHz, bmdAudioSampleType32bitInteger, kDeckLinkOutputAudioChannelCount, bmdAudioOutputStreamContinuous) != S_OK)
 	{
 		OutputDebugStringA("Could not enable DeckLink audio output; continuing without audio.\n");
-		mDLInput->DisableAudioInput();
-		mAudioEnabled = false;
+		mAudioOutputEnabled = false;
 	}

 	if (mDLOutput->QueryInterface(IID_IDeckLinkKeyer, (void**)&mDLKeyer) == S_OK && mDLKeyer != NULL)
@@ -778,12 +803,23 @@ bool OpenGLComposite::InitDeckLink()
 		// If you want RGB 4:4:4 format to be played out "over the wire" in SDI, turn on the "Use 4:4:4 SDI" in the control
 		// panel or turn on the bmdDeckLinkConfig444SDIVideoOutput flag using the IDeckLinkConfiguration interface.
 		IDeckLinkMutableVideoFrame* outputFrame;
-		IDeckLinkVideoBuffer* outputFrameBuffer = NULL;
+		if (mAudioOutputEnabled)
+		{
+			if (mDLOutput->CreateVideoFrame(mOutputFrameWidth, mOutputFrameHeight, outputFrameRowBytes, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, &outputFrame) != S_OK)
+				goto error;
+		}
+		else
+		{
+			IDeckLinkVideoBuffer* outputFrameBuffer = NULL;

-		if (mPlayoutAllocator->AllocateVideoBuffer(&outputFrameBuffer) != S_OK)
-			goto error;
+			if (mPlayoutAllocator->AllocateVideoBuffer(&outputFrameBuffer) != S_OK)
+				goto error;

-		if (mDLOutput->CreateVideoFrameWithBuffer(mOutputFrameWidth, mOutputFrameHeight, outputFrameRowBytes, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, outputFrameBuffer, &outputFrame) != S_OK)
+			if (mDLOutput->CreateVideoFrameWithBuffer(mOutputFrameWidth, mOutputFrameHeight, outputFrameRowBytes, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, outputFrameBuffer, &outputFrame) != S_OK)
+				goto error;
+		}
+
+		if (outputFrame == NULL)
 			goto error;

 		mDLOutputVideoFrameQueue.push_back(outputFrame);
@@ -796,12 +832,11 @@ bool OpenGLComposite::InitDeckLink()
 	if (mDLOutput->SetScheduledFrameCompletionCallback(mPlayoutDelegate) != S_OK)
 		goto error;

-	if (mAudioEnabled && mDLOutput->SetAudioCallback(mPlayoutDelegate) != S_OK)
+	if (mAudioOutputEnabled && mDLOutput->SetAudioCallback(mPlayoutDelegate) != S_OK)
 	{
 		OutputDebugStringA("Could not set DeckLink audio output callback; continuing without audio.\n");
-		mDLInput->DisableAudioInput();
 		mDLOutput->DisableAudioOutput();
-		mAudioEnabled = false;
+		mAudioOutputEnabled = false;
 	}

 	bSuccess = true;
@@ -1217,16 +1252,48 @@ void OpenGLComposite::AudioPacketArrived(IDeckLinkAudioInputPacket* audioPacket)
 	if (sampleFrameCount <= 0)
 		return;

-	mAudioDelayBuffer.PushInterleaved(static_cast<const int32_t*>(audioBytes), static_cast<std::size_t>(sampleFrameCount));
-	updateAudioStatus();
+	TimestampedAudioPacket packet;
+	packet.block.interleavedSamples.assign(
+		static_cast<const int32_t*>(audioBytes),
+		static_cast<const int32_t*>(audioBytes) + (static_cast<std::size_t>(sampleFrameCount) * kAudioChannelCount));
+
+	if (!mAudioScheduleEnabled)
+	{
+		AudioAnalysisSnapshot audioAnalysis;
+		{
+			std::lock_guard<std::mutex> analyzerLock(mAudioAnalyzerMutex);
+			audioAnalysis = mAudioAnalyzer.Analyze(packet.block);
+		}
+		{
+			std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
+			mAudioAnalysis = audioAnalysis;
+		}
+		updateAudioStatus();
+		return;
+	}
+
+	{
+		std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
+		for (int32_t sample : packet.block.interleavedSamples)
+			mAudioSampleQueue.push_back(sample);
+		mQueuedAudioSampleFrames += static_cast<unsigned>(sampleFrameCount);
+	}
+	mAudioPacketQueued.notify_one();
+	ScheduleAudioToWaterLevel();
 }

 HRESULT OpenGLComposite::RenderAudioSamples(BOOL preroll)
 {
-	if (!mAudioEnabled || !mDLOutput)
+	return ScheduleAudioToWaterLevel();
+}
+
+HRESULT OpenGLComposite::ScheduleAudioToWaterLevel()
+{
+	if (!mAudioScheduleEnabled || !mDLOutput)
 		return S_OK;

-	std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
+	if (mPlayoutCallbackActive.load(std::memory_order_acquire))
+		return S_FALSE;

 	unsigned bufferedSampleFrames = 0;
 	if (mDLOutput->GetBufferedAudioSampleFrameCount(&bufferedSampleFrames) != S_OK)
@@ -1235,24 +1302,88 @@ HRESULT OpenGLComposite::RenderAudioSamples(BOOL preroll)
 		return E_FAIL;
 	}

-	const unsigned delayedSampleFrames = delayedAudioSampleFrames();
-	const unsigned waterLevel = kAudioOutputWaterLevelSampleFrames > delayedSampleFrames
-		? kAudioOutputWaterLevelSampleFrames
-		: delayedSampleFrames;
-	if (bufferedSampleFrames >= waterLevel)
+	const unsigned audioWaterLevel = static_cast<unsigned>(AudioSampleTimeForVideoFrame(kVideoPrerollFrameCount, mFrameDuration, mFrameTimescale));
+	if (bufferedSampleFrames >= audioWaterLevel)
 		return S_OK;

-	const unsigned requestedSampleFrames = waterLevel - bufferedSampleFrames;
-	bool underrun = false;
-	AudioFrameBlock audioBlock = mAudioDelayBuffer.Pop(requestedSampleFrames, underrun);
-	mAudioAnalysis = mAudioAnalyzer.Analyze(audioBlock);
+	TimestampedAudioPacket packet;
+	bool poppedCapturedAudio = false;
+	{
+		std::unique_lock<std::mutex> audioLock(mAudioStateMutex, std::try_to_lock);
+		if (!audioLock.owns_lock())
+			return S_FALSE;
+
+		const unsigned audioDeficitFrames = audioWaterLevel - bufferedSampleFrames;
+		const unsigned requestedFrames = audioDeficitFrames < kAudioScheduleChunkSampleFrames ? audioDeficitFrames : kAudioScheduleChunkSampleFrames;
+		if (requestedFrames == 0)
+			return S_OK;
+
+		if (mAudioScheduleTone)
+		{
+			const std::size_t requestedSamples = static_cast<std::size_t>(requestedFrames) * kAudioChannelCount;
+			packet.block.interleavedSamples.reserve(requestedSamples);
+			for (unsigned frame = 0; frame < requestedFrames; ++frame)
+			{
+				const double phase = (static_cast<double>(mAudioToneSampleIndex++) * 440.0 * 6.28318530717958647692) / static_cast<double>(kAudioSampleRate);
+				const int32_t sample = static_cast<int32_t>(std::sin(phase) * 0.125 * 2147483647.0);
+				for (unsigned channel = 0; channel < kAudioChannelCount; ++channel)
+					packet.block.interleavedSamples.push_back(sample);
+			}
+		}
+		else if (mAudioScheduleSilence)
+		{
+			packet.block.interleavedSamples.assign(static_cast<std::size_t>(requestedFrames) * kAudioChannelCount, 0);
+		}
+		else
+		{
+			const std::size_t requestedSamples = static_cast<std::size_t>(requestedFrames) * kAudioChannelCount;
+			packet.block.interleavedSamples.reserve(requestedSamples);
+			while (!mAudioSampleQueue.empty() && packet.block.interleavedSamples.size() < requestedSamples)
+			{
+				packet.block.interleavedSamples.push_back(mAudioSampleQueue.front());
+				mAudioSampleQueue.pop_front();
+			}
+			if (packet.block.interleavedSamples.size() < requestedSamples)
+			{
+				mAudioUnderrunCount++;
+				packet.block.interleavedSamples.resize(requestedSamples, 0);
+			}
+			const auto frameCount = static_cast<unsigned>(packet.block.frameCount());
+			mQueuedAudioSampleFrames = frameCount <= mQueuedAudioSampleFrames ? mQueuedAudioSampleFrames - frameCount : 0;
+			poppedCapturedAudio = true;
+		}
+	}
+
+	const unsigned sampleFrames = static_cast<unsigned>(packet.block.frameCount());
+	if (sampleFrames == 0)
+		return S_FALSE;
+
+	std::vector<int32_t> deckLinkAudioSamples(static_cast<std::size_t>(sampleFrames) * kDeckLinkOutputAudioChannelCount, 0);
+	for (unsigned frame = 0; frame < sampleFrames; ++frame)
+	{
+		const std::size_t source = static_cast<std::size_t>(frame) * kAudioChannelCount;
+		const std::size_t destination = static_cast<std::size_t>(frame) * kDeckLinkOutputAudioChannelCount;
+		deckLinkAudioSamples[destination] = packet.block.interleavedSamples[source];
+		deckLinkAudioSamples[destination + 1] = packet.block.interleavedSamples[source + 1];
+	}
+
+	if (mPlayoutCallbackActive.load(std::memory_order_acquire))
+	{
+		std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
+		if (poppedCapturedAudio)
+		{
+			for (auto it = packet.block.interleavedSamples.rbegin(); it != packet.block.interleavedSamples.rend(); ++it)
+				mAudioSampleQueue.push_front(*it);
+			mQueuedAudioSampleFrames += sampleFrames;
+		}
+		return S_FALSE;
+	}

 	unsigned sampleFramesWritten = 0;
-	const unsigned sampleFrames = static_cast<unsigned>(audioBlock.frameCount());
-	const HRESULT scheduleResult = mDLOutput->ScheduleAudioSamples(
-		audioBlock.interleavedSamples.data(),
+	HRESULT scheduleResult = mDLOutput->ScheduleAudioSamples(
+		deckLinkAudioSamples.data(),
 		sampleFrames,
-		static_cast<BMDTimeValue>(mNextAudioSampleFrame),
+		static_cast<BMDTimeValue>(mAudioOutputSampleTime),
 		kAudioSampleRate,
 		&sampleFramesWritten);

@@ -1260,41 +1391,69 @@ HRESULT OpenGLComposite::RenderAudioSamples(BOOL preroll)
 	{
 		if (sampleFramesWritten == 0 && sampleFrames > 0)
 			OutputDebugStringA("DeckLink accepted audio schedule call but wrote 0 sample frames.\n");
-		mNextAudioSampleFrame += sampleFramesWritten;
+		mAudioOutputSampleTime += sampleFramesWritten;
+
+		AudioFrameBlock analysisBlock = packet.block;
+		AudioAnalysisSnapshot audioAnalysis;
+		{
+			std::lock_guard<std::mutex> analyzerLock(mAudioAnalyzerMutex);
+			audioAnalysis = mAudioAnalyzer.Analyze(analysisBlock);
+		}
+		{
+			std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
+			mAudioAnalysis = audioAnalysis;
+			packet.scheduledOutputSamples = std::move(deckLinkAudioSamples);
+			mScheduledAudioPacketRetainQueue.push_back(std::move(packet));
+			while (mScheduledAudioPacketRetainQueue.size() > 64)
+				mScheduledAudioPacketRetainQueue.pop_front();
+		}
+		updateAudioStatus();
 	}
 	else
 	{
 		OutputDebugStringA("DeckLink ScheduleAudioSamples failed while topping up audio output.\n");
 	}

-	updateAudioStatus();
 	return scheduleResult;
 }

+void OpenGLComposite::AudioSchedulingLoop()
+{
+	while (mAudioSchedulerRunning.load())
+	{
+		ScheduleAudioToWaterLevel();
+
+		std::unique_lock<std::mutex> audioLock(mAudioStateMutex);
+		mAudioPacketQueued.wait_for(audioLock, std::chrono::milliseconds(20), [this]()
+		{
+			return !mAudioSchedulerRunning.load() || !mAudioPacketQueue.empty();
+		});
+	}
+}
+
 // Render the live video texture through the runtime shader into the off-screen framebuffer.
 // Read the result back from the frame buffer and schedule it for playout.
 void OpenGLComposite::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult)
 {
+	mPlayoutCallbackActive.store(true, std::memory_order_release);
 	EnterCriticalSection(&pMutex);
+	auto leavePlayoutCallback = [this]()
+	{
+		mPlayoutCallbackActive.store(false, std::memory_order_release);
+		LeaveCriticalSection(&pMutex);
+	};

-	// Get the first frame from the queue
-	IDeckLinkMutableVideoFrame* outputVideoFrame = mDLOutputVideoFrameQueue.front();
-	mDLOutputVideoFrameQueue.push_back(outputVideoFrame);
-	mDLOutputVideoFrameQueue.pop_front();
+	if (!completedFrame)
+	{
+		leavePlayoutCallback();
+		return;
+	}
+
+	IDeckLinkVideoFrame* outputVideoFrame = completedFrame;

 	// make GL context current in this thread
 	wglMakeCurrent( hGLDC, hGLRC );

-	if (mAudioEnabled)
-	{
-		AudioAnalysisSnapshot audioAnalysis;
-		{
-			std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
-			audioAnalysis = mAudioAnalysis;
-		}
-		updateAudioDataTexture(audioAnalysis);
-	}
-
 	// Draw the effect output to the off-screen framebuffer.
 	const auto renderStartTime = std::chrono::steady_clock::now();
 	if (mFastTransferExtensionAvailable)
@@ -1323,14 +1482,14 @@ void OpenGLComposite::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame,
 	IDeckLinkVideoBuffer* outputVideoFrameBuffer;
 	if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK)
 	{
-		LeaveCriticalSection(&pMutex);
+		leavePlayoutCallback();
 		return;
 	}

 	if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK)
 	{
 		outputVideoFrameBuffer->Release();
-		LeaveCriticalSection(&pMutex);
+		leavePlayoutCallback();
 		return;
 	}

@@ -1371,22 +1530,21 @@ void OpenGLComposite::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame,

 	wglMakeCurrent( NULL, NULL );

-	LeaveCriticalSection(&pMutex);
+	leavePlayoutCallback();
 }

 bool OpenGLComposite::Start()
 {
 	mTotalPlayoutFrames = 0;
 	initializeAudioDelay();
-	if (mAudioEnabled)
+	if (mAudioPrerollEnabled)
 	{
 		mDLOutput->FlushBufferedAudioSamples();
 		if (mDLOutput->BeginAudioPreroll() != S_OK)
 		{
 			OutputDebugStringA("Could not begin DeckLink audio preroll; continuing without audio.\n");
-			mDLInput->DisableAudioInput();
 			mDLOutput->DisableAudioOutput();
-			mAudioEnabled = false;
+			mAudioOutputEnabled = false;
 		}
 		else
 		{
@@ -1426,26 +1584,37 @@ bool OpenGLComposite::Start()
 		mTotalPlayoutFrames++;
 	}

-	if (mAudioEnabled)
-		RenderAudioSamples(TRUE);
+	if (mDLInput->StartStreams() != S_OK)
+	{
+		return false;
+	}

 	if (mAudioPrerolling)
 	{
+		const unsigned audioWaterLevel = static_cast<unsigned>(AudioSampleTimeForVideoFrame(kVideoPrerollFrameCount, mFrameDuration, mFrameTimescale));
+		const auto prerollDeadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(750);
+		while (mAudioScheduleEnabled && std::chrono::steady_clock::now() < prerollDeadline)
+		{
+			unsigned bufferedSampleFrames = 0;
+			if (mDLOutput->GetBufferedAudioSampleFrameCount(&bufferedSampleFrames) == S_OK && bufferedSampleFrames >= audioWaterLevel)
+				break;
+			std::this_thread::sleep_for(std::chrono::milliseconds(5));
+		}
+
 		if (mDLOutput->EndAudioPreroll() != S_OK)
 		{
 			OutputDebugStringA("Could not end DeckLink audio preroll; continuing without audio.\n");
-			mDLInput->DisableAudioInput();
 			mDLOutput->DisableAudioOutput();
-			mAudioEnabled = false;
+			mAudioOutputEnabled = false;
+			mAudioScheduleEnabled = false;
 		}
 		mAudioPrerolling = false;
 	}

-	if (mDLInput->StartStreams() != S_OK)
-		return false;
-
 	if (mDLOutput->StartScheduledPlayback(0, mFrameTimescale, 1.0) != S_OK)
+	{
 		return false;
+	}

 	return true;
 }
@@ -1475,6 +1644,11 @@ bool OpenGLComposite::Stop()
 		}
 	}

+	mAudioSchedulerRunning.store(false);
+	mAudioPacketQueued.notify_all();
+	if (mAudioSchedulerThread.joinable())
+		mAudioSchedulerThread.join();
+
 	mDLInput->StopStreams();
 	mDLInput->DisableVideoInput();
 	if (mAudioEnabled)
@@ -1485,7 +1659,7 @@ bool OpenGLComposite::Stop()
 	mDLOutput->SetScheduledFrameCompletionCallback(NULL);
 	mDLOutput->DisableVideoOutput();
 	mAudioPrerolling = false;
-	if (mAudioEnabled)
+	if (mAudioOutputEnabled)
 		mDLOutput->DisableAudioOutput();

 	return true;
@@ -2260,30 +2434,33 @@ void OpenGLComposite::broadcastRuntimeState()
 		mControlServer->BroadcastState();
 }

-unsigned OpenGLComposite::delayedAudioSampleFrames() const
+BMDTimeValue OpenGLComposite::delayedAudioStreamTime() const
 {
-	return static_cast<unsigned>(AudioSampleTimeForVideoFrame(kVideoPrerollFrameCount, mFrameDuration, mFrameTimescale));
+	return static_cast<BMDTimeValue>(kVideoPrerollFrameCount) * mFrameDuration;
 }

 void OpenGLComposite::initializeAudioDelay()
 {
-	std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
-	mAudioAnalyzer.Reset();
-	mAudioAnalysis = AudioAnalysisSnapshot();
-	mAudioDelayBuffer.Reset(delayedAudioSampleFrames());
-	mNextAudioSampleFrame = 0;
+	{
+		std::lock_guard<std::mutex> analyzerLock(mAudioAnalyzerMutex);
+		mAudioAnalyzer.Reset();
+	}
+	{
+		std::lock_guard<std::mutex> audioLock(mAudioStateMutex);
+		mAudioAnalysis = AudioAnalysisSnapshot();
+		mAudioPacketQueue.clear();
+		mScheduledAudioPacketRetainQueue.clear();
+		mAudioSampleQueue.clear();
+		mQueuedAudioSampleFrames = 0;
+		mAudioUnderrunCount = 0;
+		mAudioOutputSampleTime = 0;
+		mAudioToneSampleIndex = 0;
+		mHasFirstAudioPacketTime = false;
+		mFirstAudioPacketTime = 0;
+	}
 	updateAudioStatus();
 }

-AudioFrameBlock OpenGLComposite::popAudioForVideoFrame(uint64_t videoFrameIndex)
-{
-	const unsigned sampleFrames = AudioSamplesForVideoFrame(videoFrameIndex, mFrameDuration, mFrameTimescale);
-	bool underrun = false;
-	AudioFrameBlock block = mAudioDelayBuffer.Pop(sampleFrames, underrun);
-	mAudioAnalysis = mAudioAnalyzer.Analyze(block);
-	return block;
-}
-
 void OpenGLComposite::updateAudioDataTexture(const AudioAnalysisSnapshot& analysis)
 {
 	if (mAudioDataTexture == 0)
@@ -2303,8 +2480,8 @@ void OpenGLComposite::updateAudioStatus()

 	AudioStatusSnapshot status;
 	status.enabled = mAudioEnabled;
-	status.bufferedSampleFrames = mAudioDelayBuffer.BufferedSampleFrames();
-	status.underrunCount = mAudioDelayBuffer.UnderrunCount();
+	status.bufferedSampleFrames = mQueuedAudioSampleFrames;
+	status.underrunCount = mAudioUnderrunCount;
 	status.analysis = mAudioAnalysis;
 	mRuntimeHost->SetAudioStatus(status);
 }
--- a/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.h
+++ b/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.h
@@ -57,11 +57,13 @@
 #include "RuntimeHost.h"

 #include <atomic>
+#include <condition_variable>
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
+#include <thread>
 #include <vector>
 #include <deque>

@@ -101,6 +103,8 @@ public:
 	void VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource);
 	void AudioPacketArrived(IDeckLinkAudioInputPacket* audioPacket);
 	HRESULT RenderAudioSamples(BOOL preroll);
+	HRESULT ScheduleAudioToWaterLevel();
+	void AudioSchedulingLoop();
 	void PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result);

 private:
@@ -124,7 +128,7 @@ private:
 	BMDTimeValue							mFrameDuration;
 	BMDTimeScale							mFrameTimescale;
 	unsigned								mTotalPlayoutFrames;
-	uint64_t								mNextAudioSampleFrame;
+	uint64_t								mAudioOutputSampleTime;
 	unsigned								mInputFrameWidth;
 	unsigned								mInputFrameHeight;
 	unsigned								mOutputFrameWidth;
@@ -166,11 +170,34 @@ private:
 	std::unique_ptr<ControlServer>			mControlServer;
 	std::unique_ptr<OscServer>				mOscServer;
 	bool									mAudioEnabled;
+	bool									mAudioOutputEnabled;
+	bool									mAudioScheduleEnabled;
+	bool									mAudioPrerollEnabled;
+	bool									mAudioScheduleSilence;
+	bool									mAudioScheduleTone;
 	bool									mAudioPrerolling;
+	std::atomic<bool>						mAudioSchedulerRunning;
+	std::atomic<bool>						mPlayoutCallbackActive;
+	std::thread								mAudioSchedulerThread;
 	std::mutex								mAudioStateMutex;
-	AudioDelayBuffer						mAudioDelayBuffer;
+	std::mutex								mAudioAnalyzerMutex;
 	AudioAnalyzer							mAudioAnalyzer;
 	AudioAnalysisSnapshot					mAudioAnalysis;
+	struct TimestampedAudioPacket
+	{
+		AudioFrameBlock block;
+		std::vector<int32_t> scheduledOutputSamples;
+		BMDTimeValue streamTime = 0;
+	};
+	std::deque<TimestampedAudioPacket>		mAudioPacketQueue;
+	std::deque<TimestampedAudioPacket>		mScheduledAudioPacketRetainQueue;
+	std::deque<int32_t>						mAudioSampleQueue;
+	std::condition_variable					mAudioPacketQueued;
+	unsigned								mQueuedAudioSampleFrames = 0;
+	uint64_t								mAudioUnderrunCount = 0;
+	uint64_t								mAudioToneSampleIndex = 0;
+	bool									mHasFirstAudioPacketTime = false;
+	BMDTimeValue							mFirstAudioPacketTime = 0;

 	struct LayerProgram
 	{
@@ -224,8 +251,7 @@ private:
 	bool PollRuntimeChanges();
 	void broadcastRuntimeState();
 	void initializeAudioDelay();
-	unsigned delayedAudioSampleFrames() const;
-	AudioFrameBlock popAudioForVideoFrame(uint64_t videoFrameIndex);
+	BMDTimeValue delayedAudioStreamTime() const;
 	void updateAudioDataTexture(const AudioAnalysisSnapshot& analysis);
 	void updateAudioStatus();
 	bool updateGlobalParamsBuffer(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength);
--- a/apps/LoopThroughWithOpenGLCompositing/RuntimeHost.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/RuntimeHost.cpp
@@ -1191,6 +1191,16 @@ bool RuntimeHost::LoadConfig(std::string& error)
 		mConfig.enableExternalKeying = enableExternalKeyingValue->asBoolean(mConfig.enableExternalKeying);
 	if (const JsonValue* audioEnabledValue = configJson.find("audioEnabled"))
 		mConfig.audioEnabled = audioEnabledValue->asBoolean(mConfig.audioEnabled);
+	if (const JsonValue* audioOutputEnabledValue = configJson.find("audioOutputEnabled"))
+		mConfig.audioOutputEnabled = audioOutputEnabledValue->asBoolean(mConfig.audioOutputEnabled);
+	if (const JsonValue* audioScheduleEnabledValue = configJson.find("audioScheduleEnabled"))
+		mConfig.audioScheduleEnabled = audioScheduleEnabledValue->asBoolean(mConfig.audioScheduleEnabled);
+	if (const JsonValue* audioPrerollEnabledValue = configJson.find("audioPrerollEnabled"))
+		mConfig.audioPrerollEnabled = audioPrerollEnabledValue->asBoolean(mConfig.audioPrerollEnabled);
+	if (const JsonValue* audioScheduleSilenceValue = configJson.find("audioScheduleSilence"))
+		mConfig.audioScheduleSilence = audioScheduleSilenceValue->asBoolean(mConfig.audioScheduleSilence);
+	if (const JsonValue* audioScheduleToneValue = configJson.find("audioScheduleTone"))
+		mConfig.audioScheduleTone = audioScheduleToneValue->asBoolean(mConfig.audioScheduleTone);
 	if (const JsonValue* audioChannelCountValue = configJson.find("audioChannelCount"))
 		mConfig.audioChannelCount = static_cast<unsigned>(audioChannelCountValue->asNumber(static_cast<double>(mConfig.audioChannelCount)));
 	if (const JsonValue* audioSampleRateValue = configJson.find("audioSampleRate"))
@@ -1542,6 +1552,11 @@ JsonValue RuntimeHost::BuildStateValue() const
 	app.set("maxTemporalHistoryFrames", JsonValue(static_cast<double>(mConfig.maxTemporalHistoryFrames)));
 	app.set("enableExternalKeying", JsonValue(mConfig.enableExternalKeying));
 	app.set("audioEnabled", JsonValue(mConfig.audioEnabled));
+	app.set("audioOutputEnabled", JsonValue(mConfig.audioOutputEnabled));
+	app.set("audioScheduleEnabled", JsonValue(mConfig.audioScheduleEnabled));
+	app.set("audioPrerollEnabled", JsonValue(mConfig.audioPrerollEnabled));
+	app.set("audioScheduleSilence", JsonValue(mConfig.audioScheduleSilence));
+	app.set("audioScheduleTone", JsonValue(mConfig.audioScheduleTone));
 	app.set("audioChannelCount", JsonValue(static_cast<double>(mConfig.audioChannelCount)));
 	app.set("audioSampleRate", JsonValue(static_cast<double>(mConfig.audioSampleRate)));
 	app.set("audioDelayMode", JsonValue(mConfig.audioDelayMode));
--- a/apps/LoopThroughWithOpenGLCompositing/RuntimeHost.h
+++ b/apps/LoopThroughWithOpenGLCompositing/RuntimeHost.h
@@ -54,6 +54,11 @@ public:
 	unsigned GetMaxTemporalHistoryFrames() const { return mConfig.maxTemporalHistoryFrames; }
 	bool ExternalKeyingEnabled() const { return mConfig.enableExternalKeying; }
 	bool AudioEnabled() const { return mConfig.audioEnabled; }
+	bool AudioOutputEnabled() const { return mConfig.audioOutputEnabled; }
+	bool AudioScheduleEnabled() const { return mConfig.audioScheduleEnabled; }
+	bool AudioPrerollEnabled() const { return mConfig.audioPrerollEnabled; }
+	bool AudioScheduleSilence() const { return mConfig.audioScheduleSilence; }
+	bool AudioScheduleTone() const { return mConfig.audioScheduleTone; }
 	unsigned AudioChannelCount() const { return mConfig.audioChannelCount; }
 	unsigned AudioSampleRate() const { return mConfig.audioSampleRate; }
 	const std::string& GetInputVideoFormat() const { return mConfig.inputVideoFormat; }
@@ -73,6 +78,11 @@ private:
 		unsigned maxTemporalHistoryFrames = 4;
 		bool enableExternalKeying = false;
 		bool audioEnabled = true;
+		bool audioOutputEnabled = true;
+		bool audioScheduleEnabled = true;
+		bool audioPrerollEnabled = true;
+		bool audioScheduleSilence = false;
+		bool audioScheduleTone = false;
 		unsigned audioChannelCount = kAudioChannelCount;
 		unsigned audioSampleRate = kAudioSampleRate;
 		std::string audioDelayMode = "matchVideoPreroll";