Decklink abstraction

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.cpp

@@ -3,9 +3,9 @@
 #include "OpenGLComposite.h"
 #include "GLExtensions.h"
 #include "GlRenderConstants.h"
-#include "OpenGLDeckLinkBridge.h"
 #include "OpenGLRenderPass.h"
 #include "OpenGLShaderPrograms.h"
+#include "OpenGLVideoIOBridge.h"
 #include "PngScreenshotWriter.h"
 #include "RuntimeServices.h"
 #include "ShaderBuildQueue.h"
@@ -22,15 +22,15 @@
 
 OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
 	hGLWnd(hWnd), hGLDC(hDC), hGLRC(hRC),
-	mDeckLink(std::make_unique<DeckLinkSession>()),
+	mVideoIO(std::make_unique<DeckLinkSession>()),
 	mRenderer(std::make_unique<OpenGLRenderer>()),
 	mUseCommittedLayerStates(false),
 	mScreenshotRequested(false)
 {
 	InitializeCriticalSection(&pMutex);
 	mRuntimeHost = std::make_unique<RuntimeHost>();
-	mDeckLinkBridge = std::make_unique<OpenGLDeckLinkBridge>(
-		*mDeckLink,
+	mVideoIOBridge = std::make_unique<OpenGLVideoIOBridge>(
+		*mVideoIO,
 		*mRenderer,
 		*mRuntimeHost,
 		pMutex,
@@ -51,13 +51,18 @@ OpenGLComposite::~OpenGLComposite()
 		mRuntimeServices->Stop();
 	if (mShaderBuildQueue)
 		mShaderBuildQueue->Stop();
-	mDeckLink->ReleaseResources();
+	mVideoIO->ReleaseResources();
 	mRenderer->DestroyResources();
 
 	DeleteCriticalSection(&pMutex);
 }
 
 bool OpenGLComposite::InitDeckLink()
+{
+	return InitVideoIO();
+}
+
+bool OpenGLComposite::InitVideoIO()
 {
 	VideoFormatSelection		videoModes;
 	std::string						initFailureReason;
@@ -87,7 +92,7 @@ bool OpenGLComposite::InitDeckLink()
 		}
 	}
 
-	if (!mDeckLink->DiscoverDevicesAndModes(videoModes, initFailureReason))
+	if (!mVideoIO->DiscoverDevicesAndModes(videoModes, initFailureReason))
 	{
 		const char* title = initFailureReason == "Please install the Blackmagic DeckLink drivers to use the features of this application."
 			? "This application requires the DeckLink drivers installed."
@@ -95,7 +100,7 @@ bool OpenGLComposite::InitDeckLink()
 		MessageBoxA(NULL, initFailureReason.c_str(), title, MB_OK | MB_ICONERROR);
 		return false;
 	}
-	if (!mDeckLink->SelectPreferredFormats(videoModes, initFailureReason))
+	if (!mVideoIO->SelectPreferredFormats(videoModes, initFailureReason))
 		goto error;
 
 	if (! CheckOpenGLExtensions())
@@ -110,38 +115,38 @@ bool OpenGLComposite::InitDeckLink()
 		goto error;
 	}
 
-	PublishDeckLinkOutputStatus(mDeckLink->OutputModelName().empty()
+	PublishVideoIOStatus(mVideoIO->OutputModelName().empty()
 		? "DeckLink output device selected."
-		: ("Selected output device: " + mDeckLink->OutputModelName()));
+		: ("Selected output device: " + mVideoIO->OutputModelName()));
 
 	// Resize window to match output video frame, but scale large formats down by half for viewing.
-	if (mDeckLink->OutputFrameWidth() < 1920)
-		resizeWindow(mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight());
+	if (mVideoIO->OutputFrameWidth() < 1920)
+		resizeWindow(mVideoIO->OutputFrameWidth(), mVideoIO->OutputFrameHeight());
 	else
-		resizeWindow(mDeckLink->OutputFrameWidth() / 2, mDeckLink->OutputFrameHeight() / 2);
+		resizeWindow(mVideoIO->OutputFrameWidth() / 2, mVideoIO->OutputFrameHeight() / 2);
 
-	if (!mDeckLink->ConfigureInput(this, hGLDC, hGLRC, videoModes.input, initFailureReason))
+	if (!mVideoIO->ConfigureInput([this](const VideoIOFrame& frame) { mVideoIOBridge->VideoFrameArrived(frame); }, videoModes.input, initFailureReason))
 	{
 		goto error;
 	}
-	if (!mDeckLink->HasInputDevice() && mRuntimeHost)
+	if (!mVideoIO->HasInputDevice() && mRuntimeHost)
 	{
-		mRuntimeHost->SetSignalStatus(false, mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mDeckLink->InputDisplayModeName());
+		mRuntimeHost->SetSignalStatus(false, mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), mVideoIO->InputDisplayModeName());
 	}
 
-	if (!mDeckLink->ConfigureOutput(this, hGLDC, hGLRC, videoModes.output, mRuntimeHost && mRuntimeHost->ExternalKeyingEnabled(), initFailureReason))
+	if (!mVideoIO->ConfigureOutput([this](const VideoIOCompletion& completion) { mVideoIOBridge->PlayoutFrameCompleted(completion); }, videoModes.output, mRuntimeHost && mRuntimeHost->ExternalKeyingEnabled(), initFailureReason))
 	{
 		goto error;
 	}
 
-	PublishDeckLinkOutputStatus(mDeckLink->StatusMessage());
+	PublishVideoIOStatus(mVideoIO->StatusMessage());
 
 	return true;
 
 error:
 	if (!initFailureReason.empty())
 		MessageBoxA(NULL, initFailureReason.c_str(), "DeckLink initialization failed", MB_OK | MB_ICONERROR);
-	mDeckLink->ReleaseResources();
+	mVideoIO->ReleaseResources();
 	return false;
 }
 
@@ -153,7 +158,7 @@ void OpenGLComposite::paintGL()
 		return;
 	}
 
-	mRenderer->PresentToWindow(hGLDC, mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight());
+	mRenderer->PresentToWindow(hGLDC, mVideoIO->OutputFrameWidth(), mVideoIO->OutputFrameHeight());
 	ValidateRect(hGLWnd, NULL);
 	LeaveCriticalSection(&pMutex);
 }
@@ -174,22 +179,23 @@ void OpenGLComposite::resizeWindow(int width, int height)
 	}
 }
 
-void OpenGLComposite::PublishDeckLinkOutputStatus(const std::string& statusMessage)
+void OpenGLComposite::PublishVideoIOStatus(const std::string& statusMessage)
 {
 	if (!mRuntimeHost)
 		return;
 
 	if (!statusMessage.empty())
-		mDeckLink->SetStatusMessage(statusMessage);
+		mVideoIO->SetStatusMessage(statusMessage);
 
-	mRuntimeHost->SetDeckLinkOutputStatus(
-		mDeckLink->OutputModelName(),
-		mDeckLink->SupportsInternalKeying(),
-		mDeckLink->SupportsExternalKeying(),
-		mDeckLink->KeyerInterfaceAvailable(),
+	mRuntimeHost->SetVideoIOStatus(
+		"decklink",
+		mVideoIO->OutputModelName(),
+		mVideoIO->SupportsInternalKeying(),
+		mVideoIO->SupportsExternalKeying(),
+		mVideoIO->KeyerInterfaceAvailable(),
 		mRuntimeHost->ExternalKeyingEnabled(),
-		mDeckLink->ExternalKeyingActive(),
-		mDeckLink->StatusMessage());
+		mVideoIO->ExternalKeyingActive(),
+		mVideoIO->StatusMessage());
 }
 
 bool OpenGLComposite::InitOpenGLState()
@@ -223,7 +229,7 @@ bool OpenGLComposite::InitOpenGLState()
 		return false;
 	}
 
-	if (!mShaderPrograms->CompileLayerPrograms(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
+	if (!mShaderPrograms->CompileLayerPrograms(mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
 	{
 		MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
 		return false;
@@ -234,12 +240,12 @@ bool OpenGLComposite::InitOpenGLState()
 
 	std::string rendererError;
 	if (!mRenderer->InitializeResources(
-		mDeckLink->InputFrameWidth(),
-		mDeckLink->InputFrameHeight(),
-		mDeckLink->CaptureTextureWidth(),
-		mDeckLink->OutputFrameWidth(),
-		mDeckLink->OutputFrameHeight(),
-		mDeckLink->OutputPackTextureWidth(),
+		mVideoIO->InputFrameWidth(),
+		mVideoIO->InputFrameHeight(),
+		mVideoIO->CaptureTextureWidth(),
+		mVideoIO->OutputFrameWidth(),
+		mVideoIO->OutputFrameHeight(),
+		mVideoIO->OutputPackTextureWidth(),
 		rendererError))
 	{
 		MessageBoxA(NULL, rendererError.c_str(), "OpenGL initialization error.", MB_OK);
@@ -251,20 +257,9 @@ bool OpenGLComposite::InitOpenGLState()
 	return true;
 }
 
-// DeckLink delegates still target OpenGLComposite; the bridge owns the per-frame work.
-void OpenGLComposite::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource)
-{
-	mDeckLinkBridge->VideoFrameArrived(inputFrame, hasNoInputSource);
-}
-
-void OpenGLComposite::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult)
-{
-	mDeckLinkBridge->PlayoutFrameCompleted(completedFrame, completionResult);
-}
-
 bool OpenGLComposite::Start()
 {
-	return mDeckLink->Start();
+	return mVideoIO->Start();
 }
 
 bool OpenGLComposite::Stop()
@@ -272,10 +267,10 @@ bool OpenGLComposite::Stop()
 	if (mRuntimeServices)
 		mRuntimeServices->Stop();
 
-	const bool wasExternalKeyingActive = mDeckLink->ExternalKeyingActive();
-	mDeckLink->Stop();
+	const bool wasExternalKeyingActive = mVideoIO->ExternalKeyingActive();
+	mVideoIO->Stop();
 	if (wasExternalKeyingActive)
-		PublishDeckLinkOutputStatus("External keying has been disabled.");
+		PublishVideoIOStatus("External keying has been disabled.");
 
 	return true;
 }
@@ -303,7 +298,7 @@ void OpenGLComposite::renderEffect()
 {
 	ProcessRuntimePollResults();
 
-	const bool hasInputSource = mDeckLink->HasInputSource();
+	const bool hasInputSource = mVideoIO->HasInputSource();
 	std::vector<RuntimeRenderState> layerStates;
 	if (mUseCommittedLayerStates)
 	{
@@ -313,7 +308,7 @@ void OpenGLComposite::renderEffect()
 	}
 	else if (mRuntimeHost)
 	{
-		if (mRuntimeHost->TryGetLayerRenderStates(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), layerStates))
+		if (mRuntimeHost->TryGetLayerRenderStates(mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), layerStates))
 		{
 			mCachedLayerRenderStates = layerStates;
 		}
@@ -327,10 +322,10 @@ void OpenGLComposite::renderEffect()
 	mRenderPass->Render(
 		hasInputSource,
 		layerStates,
-		mDeckLink->InputFrameWidth(),
-		mDeckLink->InputFrameHeight(),
-		mDeckLink->CaptureTextureWidth(),
-		mDeckLink->InputPixelFormat(),
+		mVideoIO->InputFrameWidth(),
+		mVideoIO->InputFrameHeight(),
+		mVideoIO->CaptureTextureWidth(),
+		mVideoIO->InputPixelFormat(),
 		historyCap,
 		[this](const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error) {
 			return mShaderPrograms->UpdateTextBindingTexture(state, textBinding, error);
@@ -345,8 +340,8 @@ void OpenGLComposite::ProcessScreenshotRequest()
 	if (!mScreenshotRequested.exchange(false))
 		return;
 
-	const unsigned width = mDeckLink ? mDeckLink->OutputFrameWidth() : 0;
-	const unsigned height = mDeckLink ? mDeckLink->OutputFrameHeight() : 0;
+	const unsigned width = mVideoIO ? mVideoIO->OutputFrameWidth() : 0;
+	const unsigned height = mVideoIO ? mVideoIO->OutputFrameHeight() : 0;
 	if (width == 0 || height == 0)
 		return;
 
@@ -426,7 +421,7 @@ bool OpenGLComposite::ProcessRuntimePollResults()
 			return true;
 
 		char compilerErrorMessage[1024] = {};
-		if (!mShaderPrograms->CommitPreparedLayerPrograms(readyBuild, mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
+		if (!mShaderPrograms->CommitPreparedLayerPrograms(readyBuild, mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
 		{
 			mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
 			mUseCommittedLayerStates = true;
@@ -449,13 +444,13 @@ bool OpenGLComposite::ProcessRuntimePollResults()
 
 void OpenGLComposite::RequestShaderBuild()
 {
-	if (!mShaderBuildQueue || !mDeckLink)
+	if (!mShaderBuildQueue || !mVideoIO)
 		return;
 
 	mUseCommittedLayerStates = true;
 	if (mRuntimeHost)
 		mRuntimeHost->ClearReloadRequest();
-	mShaderBuildQueue->RequestBuild(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight());
+	mShaderBuildQueue->RequestBuild(mVideoIO->InputFrameWidth(), mVideoIO->InputFrameHeight());
 }
 
 void OpenGLComposite::broadcastRuntimeState()

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -10,7 +10,6 @@
 #include <objbase.h>
 #include <atlbase.h>
 #include <comutil.h>
-#include "DeckLinkAPI_h.h"
 
 #include "GLExtensions.h"
 #include "OpenGLRenderer.h"
@@ -25,8 +24,8 @@
 #include <vector>
 #include <deque>
 
-class DeckLinkSession;
-class OpenGLDeckLinkBridge;
+class VideoIODevice;
+class OpenGLVideoIOBridge;
 class OpenGLRenderPass;
 class OpenGLShaderPrograms;
 class RuntimeServices;
@@ -40,6 +39,7 @@ public:
 	~OpenGLComposite();
 
 	bool InitDeckLink();
+	bool InitVideoIO();
 	bool Start();
 	bool Stop();
 	bool ReloadShader();
@@ -65,13 +65,10 @@ public:
 	void resizeGL(WORD width, WORD height);
 	void paintGL();
 
-	void VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource);
-	void PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result);
-
 private:
 	void resizeWindow(int width, int height);
 	bool CheckOpenGLExtensions();
-	void PublishDeckLinkOutputStatus(const std::string& statusMessage);
+	void PublishVideoIOStatus(const std::string& statusMessage);
 	using LayerProgram = OpenGLRenderer::LayerProgram;
 
 	HWND									hGLWnd;
@@ -79,10 +76,10 @@ private:
 	HGLRC									hGLRC;
 	CRITICAL_SECTION						pMutex;
 
-	std::unique_ptr<DeckLinkSession>			mDeckLink;
+	std::unique_ptr<VideoIODevice>			mVideoIO;
 	std::unique_ptr<OpenGLRenderer>			mRenderer;
 	std::unique_ptr<RuntimeHost>				mRuntimeHost;
-	std::unique_ptr<OpenGLDeckLinkBridge>	mDeckLinkBridge;
+	std::unique_ptr<OpenGLVideoIOBridge>		mVideoIOBridge;
 	std::unique_ptr<OpenGLRenderPass>		mRenderPass;
 	std::unique_ptr<OpenGLShaderPrograms>	mShaderPrograms;
 	std::unique_ptr<ShaderBuildQueue>		mShaderBuildQueue;

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLVideoIOBridge.cpp

@@ -1,14 +1,13 @@
-#include "OpenGLDeckLinkBridge.h"
+#include "OpenGLVideoIOBridge.h"
 
-#include "DeckLinkSession.h"
 #include "OpenGLRenderer.h"
 #include "RuntimeHost.h"
 
 #include <chrono>
 #include <gl/gl.h>
 
-OpenGLDeckLinkBridge::OpenGLDeckLinkBridge(
-	DeckLinkSession& deckLink,
+OpenGLVideoIOBridge::OpenGLVideoIOBridge(
+	VideoIODevice& videoIO,
 	OpenGLRenderer& renderer,
 	RuntimeHost& runtimeHost,
 	CRITICAL_SECTION& mutex,
@@ -17,7 +16,7 @@ OpenGLDeckLinkBridge::OpenGLDeckLinkBridge(
 	RenderEffectCallback renderEffect,
 	OutputReadyCallback outputReady,
 	PaintCallback paint) :
-	mDeckLink(deckLink),
+	mVideoIO(videoIO),
 	mRenderer(renderer),
 	mRuntimeHost(runtimeHost),
 	mMutex(mutex),
@@ -29,7 +28,7 @@ OpenGLDeckLinkBridge::OpenGLDeckLinkBridge(
 {
 }
 
-void OpenGLDeckLinkBridge::RecordFramePacing(BMDOutputFrameCompletionResult completionResult)
+void OpenGLVideoIOBridge::RecordFramePacing(VideoIOCompletionResult completionResult)
 {
 	const auto now = std::chrono::steady_clock::now();
 	if (mLastPlayoutCompletionTime != std::chrono::steady_clock::time_point())
@@ -44,11 +43,11 @@ void OpenGLDeckLinkBridge::RecordFramePacing(BMDOutputFrameCompletionResult comp
 	}
 	mLastPlayoutCompletionTime = now;
 
-	if (completionResult == bmdOutputFrameDisplayedLate)
+	if (completionResult == VideoIOCompletionResult::DisplayedLate)
 		++mLateFrameCount;
-	else if (completionResult == bmdOutputFrameDropped)
+	else if (completionResult == VideoIOCompletionResult::Dropped)
 		++mDroppedFrameCount;
-	else if (completionResult == bmdOutputFrameFlushed)
+	else if (completionResult == VideoIOCompletionResult::Flushed)
 		++mFlushedFrameCount;
 
 	mRuntimeHost.TrySetFramePacingStats(
@@ -60,27 +59,15 @@ void OpenGLDeckLinkBridge::RecordFramePacing(BMDOutputFrameCompletionResult comp
 		mFlushedFrameCount);
 }
 
-void OpenGLDeckLinkBridge::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource)
+void OpenGLVideoIOBridge::VideoFrameArrived(const VideoIOFrame& inputFrame)
 {
-	mDeckLink.SetInputSourceMissing(hasNoInputSource);
-	mRuntimeHost.TrySetSignalStatus(!hasNoInputSource, mDeckLink.InputFrameWidth(), mDeckLink.InputFrameHeight(), mDeckLink.InputDisplayModeName());
+	const VideoIOState& state = mVideoIO.State();
+	mRuntimeHost.TrySetSignalStatus(!inputFrame.hasNoInputSource, state.inputFrameSize.width, state.inputFrameSize.height, state.inputDisplayModeName);
 
-	if (!mDeckLink.HasInputSource())
+	if (inputFrame.hasNoInputSource || inputFrame.bytes == nullptr)
 		return;							// don't transfer texture when there's no input
 
-	long textureSize = inputFrame->GetRowBytes() * inputFrame->GetHeight();
-	IDeckLinkVideoBuffer* inputFrameBuffer = NULL;
-	void* videoPixels;
-
-	if (inputFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&inputFrameBuffer) != S_OK)
-		return;
-
-	if (inputFrameBuffer->StartAccess(bmdBufferAccessRead) != S_OK)
-	{
-		inputFrameBuffer->Release();
-		return;
-	}
-	inputFrameBuffer->GetBytes(&videoPixels);
+	const long textureSize = inputFrame.rowBytes * static_cast<long>(inputFrame.height);
 
 	EnterCriticalSection(&mMutex);
 
@@ -89,14 +76,14 @@ void OpenGLDeckLinkBridge::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFram
 	glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 	glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mRenderer.TextureUploadBuffer());
-	glBufferData(GL_PIXEL_UNPACK_BUFFER, textureSize, videoPixels, GL_DYNAMIC_DRAW);
+	glBufferData(GL_PIXEL_UNPACK_BUFFER, textureSize, inputFrame.bytes, GL_DYNAMIC_DRAW);
 	glBindTexture(GL_TEXTURE_2D, mRenderer.CaptureTexture());
 
 	// NULL for last arg indicates use current GL_PIXEL_UNPACK_BUFFER target as texture data.
-	if (mDeckLink.InputPixelFormat() == VideoIOPixelFormat::V210)
-		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mDeckLink.CaptureTextureWidth(), mDeckLink.InputFrameHeight(), GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	if (inputFrame.pixelFormat == VideoIOPixelFormat::V210)
+		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, state.captureTextureWidth, state.inputFrameSize.height, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 	else
-		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mDeckLink.CaptureTextureWidth(), mDeckLink.InputFrameHeight(), GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
+		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, state.captureTextureWidth, state.inputFrameSize.height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
 
 	glBindTexture(GL_TEXTURE_2D, 0);
 	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
@@ -104,21 +91,24 @@ void OpenGLDeckLinkBridge::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFram
 	wglMakeCurrent(NULL, NULL);
 
 	LeaveCriticalSection(&mMutex);
-
-	inputFrameBuffer->EndAccess(bmdBufferAccessRead);
-	inputFrameBuffer->Release();
 }
 
-void OpenGLDeckLinkBridge::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult)
+void OpenGLVideoIOBridge::PlayoutFrameCompleted(const VideoIOCompletion& completion)
 {
-	(void)completedFrame;
-
-	RecordFramePacing(completionResult);
+	RecordFramePacing(completion.result);
 
 	EnterCriticalSection(&mMutex);
 
-	// Get the first frame from the queue
-	IDeckLinkMutableVideoFrame* outputVideoFrame = mDeckLink.RotateOutputFrame();
+	VideoIOOutputFrame outputFrame;
+	if (!mVideoIO.BeginOutputFrame(outputFrame))
+	{
+		LeaveCriticalSection(&mMutex);
+		return;
+	}
+	const VideoIOState& state = mVideoIO.State();
+	RenderPipelineFrameContext frameContext;
+	frameContext.videoState = state;
+	frameContext.completion = completion;
 
 	// make GL context current in this thread
 	wglMakeCurrent(mHdc, mHglrc);
@@ -129,14 +119,14 @@ void OpenGLDeckLinkBridge::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedF
 	mRenderEffect();
 	glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer.CompositeFramebuffer());
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mRenderer.OutputFramebuffer());
-	glBlitFramebuffer(0, 0, mDeckLink.InputFrameWidth(), mDeckLink.InputFrameHeight(), 0, 0, mDeckLink.OutputFrameWidth(), mDeckLink.OutputFrameHeight(), GL_COLOR_BUFFER_BIT, GL_LINEAR);
+	glBlitFramebuffer(0, 0, state.inputFrameSize.width, state.inputFrameSize.height, 0, 0, state.outputFrameSize.width, state.outputFrameSize.height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
 	glBindFramebuffer(GL_FRAMEBUFFER, mRenderer.OutputFramebuffer());
 	if (mOutputReady)
 		mOutputReady();
-	if (mDeckLink.OutputIsTenBit())
+	if (state.outputPixelFormat == VideoIOPixelFormat::V210)
 	{
 		glBindFramebuffer(GL_FRAMEBUFFER, mRenderer.OutputPackFramebuffer());
-		glViewport(0, 0, mDeckLink.OutputPackTextureWidth(), mDeckLink.OutputFrameHeight());
+		glViewport(0, 0, state.outputPackTextureWidth, state.outputFrameSize.height);
 		glDisable(GL_SCISSOR_TEST);
 		glDisable(GL_BLEND);
 		glDisable(GL_DEPTH_TEST);
@@ -147,9 +137,9 @@ void OpenGLDeckLinkBridge::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedF
 		const GLint outputResolutionLocation = glGetUniformLocation(mRenderer.OutputPackProgram(), "uOutputVideoResolution");
 		const GLint activeWordsLocation = glGetUniformLocation(mRenderer.OutputPackProgram(), "uActiveV210Words");
 		if (outputResolutionLocation >= 0)
-			glUniform2f(outputResolutionLocation, static_cast<float>(mDeckLink.OutputFrameWidth()), static_cast<float>(mDeckLink.OutputFrameHeight()));
+			glUniform2f(outputResolutionLocation, static_cast<float>(state.outputFrameSize.width), static_cast<float>(state.outputFrameSize.height));
 		if (activeWordsLocation >= 0)
-			glUniform1f(activeWordsLocation, static_cast<float>(ActiveV210WordsForWidth(mDeckLink.OutputFrameWidth())));
+			glUniform1f(activeWordsLocation, static_cast<float>(ActiveV210WordsForWidth(state.outputFrameSize.width)));
 		glDrawArrays(GL_TRIANGLES, 0, 3);
 		glUseProgram(0);
 		glBindVertexArray(0);
@@ -157,51 +147,31 @@ void OpenGLDeckLinkBridge::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedF
 	}
 	glFlush();
 	const auto renderEndTime = std::chrono::steady_clock::now();
-	const double frameBudgetMilliseconds = mDeckLink.FrameBudgetMilliseconds();
+	const double frameBudgetMilliseconds = state.frameBudgetMilliseconds;
 	const double renderMilliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(renderEndTime - renderStartTime).count();
 	mRuntimeHost.TrySetPerformanceStats(frameBudgetMilliseconds, renderMilliseconds);
 	mRuntimeHost.TryAdvanceFrame();
 
-	IDeckLinkVideoBuffer* outputVideoFrameBuffer;
-	if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK)
-	{
-		wglMakeCurrent(NULL, NULL);
-		LeaveCriticalSection(&mMutex);
-		return;
-	}
-
-	if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK)
-	{
-		outputVideoFrameBuffer->Release();
-		wglMakeCurrent(NULL, NULL);
-		LeaveCriticalSection(&mMutex);
-		return;
-	}
-
-	void*	pFrame;
-	outputVideoFrameBuffer->GetBytes(&pFrame);
-
 	glPixelStorei(GL_PACK_ALIGNMENT, 4);
 	glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-	if (mDeckLink.OutputIsTenBit())
+	if (state.outputPixelFormat == VideoIOPixelFormat::V210)
 	{
 		glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer.OutputPackFramebuffer());
-		glReadPixels(0, 0, mDeckLink.OutputPackTextureWidth(), mDeckLink.OutputFrameHeight(), GL_RGBA, GL_UNSIGNED_BYTE, pFrame);
+		glReadPixels(0, 0, state.outputPackTextureWidth, state.outputFrameSize.height, GL_RGBA, GL_UNSIGNED_BYTE, outputFrame.bytes);
 	}
 	else
 	{
 		glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer.OutputFramebuffer());
-		glReadPixels(0, 0, mDeckLink.OutputFrameWidth(), mDeckLink.OutputFrameHeight(), GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pFrame);
+		glReadPixels(0, 0, state.outputFrameSize.width, state.outputFrameSize.height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, outputFrame.bytes);
 	}
 	mPaint();
 
-	outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite);
-	outputVideoFrameBuffer->Release();
+	mVideoIO.EndOutputFrame(outputFrame);
 
-	mDeckLink.AccountForCompletionResult(completionResult);
+	mVideoIO.AccountForCompletionResult(completion.result);
 
 	// Schedule the next frame for playout
-	mDeckLink.ScheduleOutputFrame(outputVideoFrame);
+	mVideoIO.ScheduleOutputFrame(outputFrame);
 
 	wglMakeCurrent(NULL, NULL);
 

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLVideoIOBridge.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "DeckLinkAPI_h.h"
+#include "VideoIOTypes.h"
 
 #include <windows.h>
 
@@ -8,19 +8,24 @@
 #include <functional>
 #include <cstdint>
 
-class DeckLinkSession;
 class OpenGLRenderer;
 class RuntimeHost;
 
-class OpenGLDeckLinkBridge
+struct RenderPipelineFrameContext
+{
+	VideoIOState videoState;
+	VideoIOCompletion completion;
+};
+
+class OpenGLVideoIOBridge
 {
 public:
 	using RenderEffectCallback = std::function<void()>;
 	using OutputReadyCallback = std::function<void()>;
 	using PaintCallback = std::function<void()>;
 
-	OpenGLDeckLinkBridge(
-		DeckLinkSession& deckLink,
+	OpenGLVideoIOBridge(
+		VideoIODevice& videoIO,
 		OpenGLRenderer& renderer,
 		RuntimeHost& runtimeHost,
 		CRITICAL_SECTION& mutex,
@@ -30,13 +35,13 @@ public:
 		OutputReadyCallback outputReady,
 		PaintCallback paint);
 
-	void VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource);
-	void PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult);
+	void VideoFrameArrived(const VideoIOFrame& inputFrame);
+	void PlayoutFrameCompleted(const VideoIOCompletion& completion);
 
 private:
-	void RecordFramePacing(BMDOutputFrameCompletionResult completionResult);
+	void RecordFramePacing(VideoIOCompletionResult completionResult);
 
-	DeckLinkSession& mDeckLink;
+	VideoIODevice& mVideoIO;
 	OpenGLRenderer& mRenderer;
 	RuntimeHost& mRuntimeHost;
 	CRITICAL_SECTION& mMutex;