Extract frame transfer callbacks

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLDeckLinkBridge.cpp

@@ -0,0 +1,177 @@
+#include "OpenGLDeckLinkBridge.h"
+
+#include "DeckLinkFrameTransfer.h"
+#include "DeckLinkSession.h"
+#include "OpenGLRenderer.h"
+#include "RuntimeHost.h"
+#include "VideoFrameTransfer.h"
+
+#include <atlbase.h>
+#include <chrono>
+#include <gl/gl.h>
+
+OpenGLDeckLinkBridge::OpenGLDeckLinkBridge(
+	DeckLinkSession& deckLink,
+	OpenGLRenderer& renderer,
+	RuntimeHost& runtimeHost,
+	CRITICAL_SECTION& mutex,
+	HDC hdc,
+	HGLRC hglrc,
+	RenderEffectCallback renderEffect,
+	PaintCallback paint) :
+	mDeckLink(deckLink),
+	mRenderer(renderer),
+	mRuntimeHost(runtimeHost),
+	mMutex(mutex),
+	mHdc(hdc),
+	mHglrc(hglrc),
+	mRenderEffect(renderEffect),
+	mPaint(paint)
+{
+}
+
+void OpenGLDeckLinkBridge::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource)
+{
+	mDeckLink.hasNoInputSource = hasNoInputSource;
+	mRuntimeHost.SetSignalStatus(!hasNoInputSource, mDeckLink.inputFrameWidth, mDeckLink.inputFrameHeight, mDeckLink.inputDisplayModeName);
+
+	if (mDeckLink.hasNoInputSource)
+		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);
+
+	EnterCriticalSection(&mMutex);
+
+	wglMakeCurrent(mHdc, mHglrc);		// make OpenGL context current in this thread
+
+	if (mRenderer.FastTransferAvailable())
+	{
+		CComQIPtr<PinnedMemoryAllocator, &IID_PinnedMemoryAllocator> allocator(inputFrameBuffer);
+		if (!allocator || !allocator->transferFrame(videoPixels, mRenderer.CaptureTexture()))
+			OutputDebugStringA("Capture: transferFrame() failed\n");
+
+		allocator->waitForTransferComplete(videoPixels);
+	}
+	else
+	{
+		// Use a straightforward texture buffer
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mRenderer.UnpinnedTextureBuffer());
+		glBufferData(GL_PIXEL_UNPACK_BUFFER, textureSize, videoPixels, GL_DYNAMIC_DRAW);
+		glBindTexture(GL_TEXTURE_2D, mRenderer.CaptureTexture());
+
+		// NULL for last arg indicates use current GL_PIXEL_UNPACK_BUFFER target as texture data
+		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mDeckLink.inputFrameWidth / 2, mDeckLink.inputFrameHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
+
+		glBindTexture(GL_TEXTURE_2D, 0);
+		glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+	}
+
+	wglMakeCurrent(NULL, NULL);
+
+	LeaveCriticalSection(&mMutex);
+
+	inputFrameBuffer->EndAccess(bmdBufferAccessRead);
+	inputFrameBuffer->Release();
+}
+
+void OpenGLDeckLinkBridge::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult)
+{
+	(void)completedFrame;
+
+	EnterCriticalSection(&mMutex);
+
+	// Get the first frame from the queue
+	IDeckLinkMutableVideoFrame* outputVideoFrame = mDeckLink.outputVideoFrameQueue.front();
+	mDeckLink.outputVideoFrameQueue.push_back(outputVideoFrame);
+	mDeckLink.outputVideoFrameQueue.pop_front();
+
+	// make GL context current in this thread
+	wglMakeCurrent(mHdc, mHglrc);
+
+	// Draw the effect output to the off-screen framebuffer.
+	const auto renderStartTime = std::chrono::steady_clock::now();
+	if (mRenderer.FastTransferAvailable())
+		VideoFrameTransfer::beginTextureInUse(VideoFrameTransfer::GPUtoCPU);
+	glBindFramebuffer(GL_FRAMEBUFFER, mRenderer.CompositeFramebuffer());
+	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);
+	glBindFramebuffer(GL_FRAMEBUFFER, mRenderer.OutputFramebuffer());
+	glFlush();
+	if (mRenderer.FastTransferAvailable())
+		VideoFrameTransfer::endTextureInUse(VideoFrameTransfer::GPUtoCPU);
+	const auto renderEndTime = std::chrono::steady_clock::now();
+	const double frameBudgetMilliseconds = mDeckLink.frameTimescale != 0
+		? (static_cast<double>(mDeckLink.frameDuration) * 1000.0) / static_cast<double>(mDeckLink.frameTimescale)
+		: 0.0;
+	const double renderMilliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(renderEndTime - renderStartTime).count();
+	mRuntimeHost.SetPerformanceStats(frameBudgetMilliseconds, renderMilliseconds);
+	mRuntimeHost.AdvanceFrame();
+
+	IDeckLinkVideoBuffer* outputVideoFrameBuffer;
+	if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK)
+	{
+		LeaveCriticalSection(&mMutex);
+		return;
+	}
+
+	if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK)
+	{
+		outputVideoFrameBuffer->Release();
+		LeaveCriticalSection(&mMutex);
+		return;
+	}
+
+	void*	pFrame;
+	outputVideoFrameBuffer->GetBytes(&pFrame);
+
+	if (mRenderer.FastTransferAvailable())
+	{
+		// Finished sampling the capture texture for this frame.
+		if (!mDeckLink.hasNoInputSource)
+			VideoFrameTransfer::endTextureInUse(VideoFrameTransfer::CPUtoGPU);
+
+		if (!mDeckLink.playoutAllocator->transferFrame(pFrame, mRenderer.OutputTexture()))
+			OutputDebugStringA("Playback: transferFrame() failed\n");
+
+		mPaint();
+
+		// Wait for transfer to system memory to complete
+		mDeckLink.playoutAllocator->waitForTransferComplete(pFrame);
+	}
+	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);
+		mPaint();
+	}
+
+	outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite);
+	outputVideoFrameBuffer->Release();
+
+	// If the last completed frame was late or dropped, bump the scheduled time further into the future
+	if (completionResult == bmdOutputFrameDisplayedLate || completionResult == bmdOutputFrameDropped)
+		mDeckLink.totalPlayoutFrames += 2;
+
+	// Schedule the next frame for playout
+	HRESULT hr = mDeckLink.output->ScheduleVideoFrame(outputVideoFrame, (mDeckLink.totalPlayoutFrames * mDeckLink.frameDuration), mDeckLink.frameDuration, mDeckLink.frameTimescale);
+	if (SUCCEEDED(hr))
+		mDeckLink.totalPlayoutFrames++;
+
+	wglMakeCurrent(NULL, NULL);
+
+	LeaveCriticalSection(&mMutex);
+}