video-shader-toys/apps/LoopThroughWithOpenGLCompositing/gl/OpenGLDeckLinkBridge.cpp

#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);
}