/* -LICENSE-START-
 ** Copyright (c) 2012 Blackmagic Design
 **  
 ** Permission is hereby granted, free of charge, to any person or organization 
 ** obtaining a copy of the software and accompanying documentation (the 
 ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
 ** and transmit the Software, and to prepare derivative works of the Software, 
 ** and to permit third-parties to whom the Software is furnished to do so, in 
 ** accordance with:
 ** 
 ** (1) if the Software is obtained from Blackmagic Design, the End User License 
 ** Agreement for the Software Development Kit ("EULA") available at 
 ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
 ** 
 ** (2) if the Software is obtained from any third party, such licensing terms 
 ** as notified by that third party,
 ** 
 ** and all subject to the following:
 ** 
 ** (3) the copyright notices in the Software and this entire statement, 
 ** including the above license grant, this restriction and the following 
 ** disclaimer, must be included in all copies of the Software, in whole or in 
 ** part, and all derivative works of the Software, unless such copies or 
 ** derivative works are solely in the form of machine-executable object code 
 ** generated by a source language processor.
 ** 
 ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
 ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
 ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
 ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
 ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
 ** DEALINGS IN THE SOFTWARE.
 ** 
 ** A copy of the Software is available free of charge at 
 ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
 ** 
 ** -LICENSE-END-
 */

#include "ControlServer.h"
#include "DeckLinkDisplayMode.h"
#include "DeckLinkFrameTransfer.h"
#include "OpenGLComposite.h"
#include "GLExtensions.h"
#include "GlRenderConstants.h"
#include "OpenGLRenderPass.h"
#include "OpenGLShaderPrograms.h"
#include "OscServer.h"
#include "RuntimeControlBridge.h"

#include <memory>
#include <string>
#include <vector>

OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
	hGLWnd(hWnd), hGLDC(hDC), hGLRC(hRC),
	mCaptureDelegate(NULL), mPlayoutDelegate(NULL),
	mDLInput(NULL), mDLOutput(NULL), mDLKeyer(NULL),
	mPlayoutAllocator(NULL),
	mInputFrameWidth(0), mInputFrameHeight(0),
	mOutputFrameWidth(0), mOutputFrameHeight(0),
	mInputDisplayModeName("1080p59.94"),
	mOutputDisplayModeName("1080p59.94"),
	mHasNoInputSource(true),
	mDeckLinkSupportsInternalKeying(false),
	mDeckLinkSupportsExternalKeying(false),
	mDeckLinkKeyerInterfaceAvailable(false),
	mDeckLinkExternalKeyingActive(false),
	mRenderer(std::make_unique<OpenGLRenderer>())
{
	InitializeCriticalSection(&pMutex);
	mRuntimeHost = std::make_unique<RuntimeHost>();
	mRenderPass = std::make_unique<OpenGLRenderPass>(*mRenderer);
	mShaderPrograms = std::make_unique<OpenGLShaderPrograms>(*mRenderer, *mRuntimeHost);
	mControlServer = std::make_unique<ControlServer>();
	mOscServer = std::make_unique<OscServer>();
}

OpenGLComposite::~OpenGLComposite()
{
	// Cleanup for Capture
	if (mDLInput != NULL)
	{
		mDLInput->SetCallback(NULL);

		mDLInput->Release();
		mDLInput = NULL;
	}

	if (mCaptureDelegate != NULL)
	{
		mCaptureDelegate->Release();
		mCaptureDelegate = NULL;
	}

	// Cleanup for Playout
	while (!mDLOutputVideoFrameQueue.empty())
	{
		IDeckLinkMutableVideoFrame* frameToRelease = mDLOutputVideoFrameQueue.front();
		if (frameToRelease != NULL)
		{
			frameToRelease->Release();
			frameToRelease = NULL;
		}
		mDLOutputVideoFrameQueue.pop_front();
	}

	if (mDLOutput != NULL)
	{
		if (mDLKeyer != NULL)
		{
			mDLKeyer->Disable();
			mDLKeyer->Release();
			mDLKeyer = NULL;
		}

		mDLOutput->SetScheduledFrameCompletionCallback(NULL);

		mDLOutput->Release();
		mDLOutput = NULL;
	}

	if (mPlayoutDelegate != NULL)
	{
		mPlayoutDelegate->Release();
		mPlayoutDelegate = NULL;
	}

	if (mPlayoutAllocator != NULL)
	{
		mPlayoutAllocator->Release();
		mPlayoutAllocator = NULL;
	}

	mRenderer->DestroyResources();
	if (mOscServer)
		mOscServer->Stop();
	if (mControlServer)
		mControlServer->Stop();

	DeleteCriticalSection(&pMutex);
}

bool OpenGLComposite::InitDeckLink()
{
	bool							bSuccess = false;
	IDeckLinkIterator*				pDLIterator = NULL;
	IDeckLink*						pDL = NULL;
	IDeckLinkProfileAttributes*			deckLinkAttributes = NULL;
	IDeckLinkDisplayModeIterator*	pDLInputDisplayModeIterator = NULL;
	IDeckLinkDisplayModeIterator*	pDLOutputDisplayModeIterator = NULL;
	IDeckLinkDisplayMode*			pDLInputDisplayMode = NULL;
	IDeckLinkDisplayMode*			pDLOutputDisplayMode = NULL;
	BMDDisplayMode					inputDisplayMode = bmdModeHD1080p5994;
	BMDDisplayMode					outputDisplayMode = bmdModeHD1080p5994;
	std::string						inputDisplayModeName = "1080p59.94";
	std::string						outputDisplayModeName = "1080p59.94";
	std::string						initFailureReason;
	int								outputFrameRowBytes;
	HRESULT							result;

	if (mRuntimeHost && mRuntimeHost->GetRepoRoot().empty())
	{
		std::string runtimeError;
		if (!mRuntimeHost->Initialize(runtimeError))
		{
			MessageBoxA(NULL, runtimeError.c_str(), "Runtime host failed to initialize", MB_OK);
			return false;
		}
	}

	if (mRuntimeHost)
	{
		if (!ResolveConfiguredDisplayMode(mRuntimeHost->GetInputVideoFormat(), mRuntimeHost->GetInputFrameRate(), inputDisplayMode, inputDisplayModeName))
		{
			const std::string error = "Unsupported DeckLink inputVideoFormat/inputFrameRate in config/runtime-host.json: " +
				mRuntimeHost->GetInputVideoFormat() + " / " + mRuntimeHost->GetInputFrameRate();
			MessageBoxA(NULL, error.c_str(), "DeckLink input mode configuration error", MB_OK);
			return false;
		}
		if (!ResolveConfiguredDisplayMode(mRuntimeHost->GetOutputVideoFormat(), mRuntimeHost->GetOutputFrameRate(), outputDisplayMode, outputDisplayModeName))
		{
			const std::string error = "Unsupported DeckLink outputVideoFormat/outputFrameRate in config/runtime-host.json: " +
				mRuntimeHost->GetOutputVideoFormat() + " / " + mRuntimeHost->GetOutputFrameRate();
			MessageBoxA(NULL, error.c_str(), "DeckLink output mode configuration error", MB_OK);
			return false;
		}
	}
	mInputDisplayModeName = inputDisplayModeName;
	mOutputDisplayModeName = outputDisplayModeName;

	result = CoCreateInstance(CLSID_CDeckLinkIterator, NULL, CLSCTX_ALL, IID_IDeckLinkIterator, (void**)&pDLIterator);
	if (FAILED(result))
	{
		MessageBox(NULL, _T("Please install the Blackmagic DeckLink drivers to use the features of this application."), _T("This application requires the DeckLink drivers installed."), MB_OK);
		return false;
	}

	while (pDLIterator->Next(&pDL) == S_OK)
	{
		int64_t duplexMode;
		bool supportsInternalKeying = false;
		bool supportsExternalKeying = false;
		std::string modelName;

		if (result = pDL->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes) != S_OK)
		{
			printf("Could not obtain the IDeckLinkProfileAttributes interface - result %08x\n", result);
			pDL->Release();
			pDL = NULL;
			continue;
		}

		result = deckLinkAttributes->GetInt(BMDDeckLinkDuplex, &duplexMode);
		BOOL attributeFlag = FALSE;
		if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &attributeFlag) == S_OK)
			supportsInternalKeying = (attributeFlag != FALSE);
		attributeFlag = FALSE;
		if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsExternalKeying, &attributeFlag) == S_OK)
			supportsExternalKeying = (attributeFlag != FALSE);
		BSTR modelNameBstr = NULL;
		if (deckLinkAttributes->GetString(BMDDeckLinkModelName, &modelNameBstr) == S_OK && modelNameBstr != NULL)
		{
			const int requiredBytes = WideCharToMultiByte(CP_UTF8, 0, modelNameBstr, -1, NULL, 0, NULL, NULL);
			if (requiredBytes > 1)
			{
				std::vector<char> utf8Name(static_cast<std::size_t>(requiredBytes), '\0');
				if (WideCharToMultiByte(CP_UTF8, 0, modelNameBstr, -1, utf8Name.data(), requiredBytes, NULL, NULL) > 0)
					modelName.assign(utf8Name.data());
			}
			SysFreeString(modelNameBstr);
		}
		deckLinkAttributes->Release();
		deckLinkAttributes = NULL;

		if (result != S_OK  || duplexMode == bmdDuplexInactive)
		{
			pDL->Release();
			pDL = NULL;
			continue;
		}

		// Preserve the original input-then-output selection for half-duplex cards.
		// Input is optional later, but choosing output first can pick the wrong card.
		bool inputUsed = false;
		if (!mDLInput && pDL->QueryInterface(IID_IDeckLinkInput, (void**)&mDLInput) == S_OK)
			inputUsed = true;

		if (!mDLOutput && (!inputUsed || (duplexMode == bmdDuplexFull)))
		{
			if (pDL->QueryInterface(IID_IDeckLinkOutput, (void**)&mDLOutput) != S_OK)
				mDLOutput = NULL;
			else
			{
				mDeckLinkOutputModelName = modelName;
				mDeckLinkSupportsInternalKeying = supportsInternalKeying;
				mDeckLinkSupportsExternalKeying = supportsExternalKeying;
			}
		}

		pDL->Release();
		pDL = NULL;

		if (mDLOutput && mDLInput)
			break;
	}

	if (!mDLOutput)
	{
		MessageBox(NULL, _T("Expected an Output DeckLink device"), _T("This application requires a DeckLink output device."), MB_OK);
		goto error;
	}

	if (mDLInput && mDLInput->GetDisplayModeIterator(&pDLInputDisplayModeIterator) != S_OK)
	{
		MessageBox(NULL, _T("Cannot get input Display Mode Iterator."), _T("DeckLink error."), MB_OK);
		goto error;
	}

	if (mDLInput && !FindDeckLinkDisplayMode(pDLInputDisplayModeIterator, inputDisplayMode, &pDLInputDisplayMode))
	{
		const std::string error = "Cannot get specified input BMDDisplayMode for configured mode: " + inputDisplayModeName;
		MessageBoxA(NULL, error.c_str(), "DeckLink input error.", MB_OK);
		goto error;
	}
	if (pDLInputDisplayModeIterator)
	{
		pDLInputDisplayModeIterator->Release();
		pDLInputDisplayModeIterator = NULL;
	}

	if (mDLOutput->GetDisplayModeIterator(&pDLOutputDisplayModeIterator) != S_OK)
	{
		MessageBox(NULL, _T("Cannot get output Display Mode Iterator."), _T("DeckLink error."), MB_OK);
		goto error;
	}

	if (!FindDeckLinkDisplayMode(pDLOutputDisplayModeIterator, outputDisplayMode, &pDLOutputDisplayMode))
	{
		const std::string error = "Cannot get specified output BMDDisplayMode for configured mode: " + outputDisplayModeName;
		MessageBoxA(NULL, error.c_str(), "DeckLink output error.", MB_OK);
		goto error;
	}
	pDLOutputDisplayModeIterator->Release();
	pDLOutputDisplayModeIterator = NULL;

	mOutputFrameWidth = pDLOutputDisplayMode->GetWidth();
	mOutputFrameHeight = pDLOutputDisplayMode->GetHeight();
	mInputFrameWidth = pDLInputDisplayMode ? pDLInputDisplayMode->GetWidth() : mOutputFrameWidth;
	mInputFrameHeight = pDLInputDisplayMode ? pDLInputDisplayMode->GetHeight() : mOutputFrameHeight;
	if (!mDLInput)
		mInputDisplayModeName = "No input - black frame";

	if (! CheckOpenGLExtensions())
	{
		initFailureReason = "OpenGL extension checks failed.";
		goto error;
	}
	if (mInputFrameWidth != mOutputFrameWidth || mInputFrameHeight != mOutputFrameHeight)
	{
		mRenderer->mFastTransferExtensionAvailable = false;
		OutputDebugStringA("Input/output dimensions differ; using regular OpenGL transfer fallback instead of fast transfer.\n");
	}

	if (! InitOpenGLState())
	{
		initFailureReason = "OpenGL state initialization failed.";
		goto error;
	}

	if (mRuntimeHost)
	{
		mDeckLinkStatusMessage = mDeckLinkOutputModelName.empty()
			? "DeckLink output device selected."
			: ("Selected output device: " + mDeckLinkOutputModelName);
		mRuntimeHost->SetDeckLinkOutputStatus(
			mDeckLinkOutputModelName,
			mDeckLinkSupportsInternalKeying,
			mDeckLinkSupportsExternalKeying,
			mDeckLinkKeyerInterfaceAvailable,
			mRuntimeHost->ExternalKeyingEnabled(),
			mDeckLinkExternalKeyingActive,
			mDeckLinkStatusMessage);
	}

	pDLOutputDisplayMode->GetFrameRate(&mFrameDuration, &mFrameTimescale);

	// Resize window to match output video frame, but scale large formats down by half for viewing.
	if (mOutputFrameWidth < 1920)
		resizeWindow(mOutputFrameWidth, mOutputFrameHeight);
	else
		resizeWindow(mOutputFrameWidth / 2, mOutputFrameHeight / 2);

	if (mRenderer->mFastTransferExtensionAvailable)
	{
		// Initialize fast video frame transfers
		if (! VideoFrameTransfer::initialize(mInputFrameWidth, mInputFrameHeight, mRenderer->mCaptureTexture, mRenderer->mOutputTexture))
		{
			MessageBox(NULL, _T("Cannot initialize video transfers."), _T("VideoFrameTransfer error."), MB_OK);
			goto error;
		}
	}

	if (mDLInput)
	{
		// Use custom allocators so we pin only once then recycle them
		CComPtr<IDeckLinkVideoBufferAllocatorProvider> captureAllocator(new (std::nothrow) InputAllocatorPool(hGLDC, hGLRC));

		if (mDLInput->EnableVideoInputWithAllocatorProvider(inputDisplayMode, bmdFormat8BitYUV, bmdVideoInputFlagDefault, captureAllocator) != S_OK)
		{
			OutputDebugStringA("DeckLink input could not be enabled; continuing in output-only black-frame mode.\n");
			mDLInput->Release();
			mDLInput = NULL;
			mHasNoInputSource = true;
			mInputDisplayModeName = "No input - black frame";
			if (mRuntimeHost)
				mRuntimeHost->SetSignalStatus(false, mInputFrameWidth, mInputFrameHeight, mInputDisplayModeName);
		}
	}

	if (mDLInput)
	{
		mCaptureDelegate = new CaptureDelegate(this);
		if (mDLInput->SetCallback(mCaptureDelegate) != S_OK)
		{
			initFailureReason = "DeckLink input setup failed while installing the capture callback.";
			goto error;
		}
	}
	else if (mRuntimeHost)
	{
		mRuntimeHost->SetSignalStatus(false, mInputFrameWidth, mInputFrameHeight, mInputDisplayModeName);
	}

	if (mDLOutput->RowBytesForPixelFormat(bmdFormat8BitBGRA, mOutputFrameWidth, &outputFrameRowBytes) != S_OK)
	{
		initFailureReason = "DeckLink output setup failed while calculating BGRA row bytes.";
		goto error;
	}

	// Use a custom allocator so we pin only once then recycle them
	mPlayoutAllocator = new PinnedMemoryAllocator(hGLDC, hGLRC, VideoFrameTransfer::GPUtoCPU, 1, outputFrameRowBytes * mOutputFrameHeight);

	if (mDLOutput->EnableVideoOutput(outputDisplayMode, bmdVideoOutputFlagDefault) != S_OK)
	{
		initFailureReason = "DeckLink output setup failed while enabling video output.";
		goto error;
	}

	if (mDLOutput->QueryInterface(IID_IDeckLinkKeyer, (void**)&mDLKeyer) == S_OK && mDLKeyer != NULL)
		mDeckLinkKeyerInterfaceAvailable = true;

	if (mRuntimeHost && mRuntimeHost->ExternalKeyingEnabled())
	{
		if (!mDeckLinkSupportsExternalKeying)
		{
			mDeckLinkStatusMessage = "External keying was requested, but the selected DeckLink output does not report external keying support.";
		}
		else if (!mDeckLinkKeyerInterfaceAvailable)
		{
			mDeckLinkStatusMessage = "External keying was requested, but the selected DeckLink output does not expose the IDeckLinkKeyer interface.";
		}
		else if (mDLKeyer->Enable(TRUE) != S_OK || mDLKeyer->SetLevel(255) != S_OK)
		{
			mDeckLinkStatusMessage = "External keying was requested, but enabling the DeckLink keyer failed.";
		}
		else
		{
			mDeckLinkExternalKeyingActive = true;
			mDeckLinkStatusMessage = "External keying is active on the selected DeckLink output.";
		}
	}
	else if (mDeckLinkSupportsExternalKeying)
	{
		mDeckLinkStatusMessage = "Selected DeckLink output supports external keying. Set enableExternalKeying to true in runtime-host.json to request it.";
	}

	if (mRuntimeHost)
	{
		mRuntimeHost->SetDeckLinkOutputStatus(
			mDeckLinkOutputModelName,
			mDeckLinkSupportsInternalKeying,
			mDeckLinkSupportsExternalKeying,
			mDeckLinkKeyerInterfaceAvailable,
			mRuntimeHost->ExternalKeyingEnabled(),
			mDeckLinkExternalKeyingActive,
			mDeckLinkStatusMessage);
	}

	// Create a queue of 10 IDeckLinkMutableVideoFrame objects to use for scheduling output video frames.
	// The ScheduledFrameCompleted() callback will immediately schedule a new frame using the next video frame from this queue.
	for (int i = 0; i < 10; i++)
	{
		// The frame read back from the GPU frame buffer and used for the playout video frame is in BGRA format.
		// The BGRA frame will be converted on playout to YCbCr either in hardware on most DeckLink cards or in software
		// within the DeckLink API for DeckLink devices without this hardware conversion.
		// 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 (mPlayoutAllocator->AllocateVideoBuffer(&outputFrameBuffer) != S_OK)
		{
			initFailureReason = "DeckLink output setup failed while allocating an output frame buffer.";
			goto error;
		}

		if (mDLOutput->CreateVideoFrameWithBuffer(mOutputFrameWidth, mOutputFrameHeight, outputFrameRowBytes, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, outputFrameBuffer, &outputFrame) != S_OK)
		{
			initFailureReason = "DeckLink output setup failed while creating an output video frame.";
			goto error;
		}

		mDLOutputVideoFrameQueue.push_back(outputFrame);
	}

	mPlayoutDelegate = new PlayoutDelegate(this);
	if (mPlayoutDelegate == NULL)
	{
		initFailureReason = "DeckLink output setup failed while creating the playout callback.";
		goto error;
	}

	if (mDLOutput->SetScheduledFrameCompletionCallback(mPlayoutDelegate) != S_OK)
	{
		initFailureReason = "DeckLink output setup failed while installing the scheduled-frame callback.";
		goto error;
	}

	bSuccess = true;

error:
	if (!bSuccess)
	{
		if (!initFailureReason.empty())
			MessageBoxA(NULL, initFailureReason.c_str(), "DeckLink initialization failed", MB_OK | MB_ICONERROR);

		if (mDLKeyer != NULL)
		{
			mDLKeyer->Disable();
			mDLKeyer->Release();
			mDLKeyer = NULL;
			mDeckLinkExternalKeyingActive = false;
		}
		if (mDLInput != NULL)
		{
			mDLInput->Release();
			mDLInput = NULL;
		}
		if (mDLOutput != NULL)
		{
			mDLOutput->Release();
			mDLOutput = NULL;
		}
	}

	if (pDL != NULL)
	{
		pDL->Release();
		pDL = NULL;
	}

	if (pDLInputDisplayMode != NULL)
	{
		pDLInputDisplayMode->Release();
		pDLInputDisplayMode = NULL;
	}

	if (pDLOutputDisplayMode != NULL)
	{
		pDLOutputDisplayMode->Release();
		pDLOutputDisplayMode = NULL;
	}

	if (pDLInputDisplayModeIterator != NULL)
	{
		pDLInputDisplayModeIterator->Release();
		pDLInputDisplayModeIterator = NULL;
	}

	if (pDLOutputDisplayModeIterator != NULL)
	{
		pDLOutputDisplayModeIterator->Release();
		pDLOutputDisplayModeIterator = NULL;
	}

	if (pDLIterator != NULL)
	{
		pDLIterator->Release();
		pDLIterator = NULL;
	}

	return bSuccess;
}

void OpenGLComposite::paintGL()
{
	if (!TryEnterCriticalSection(&pMutex))
	{
		ValidateRect(hGLWnd, NULL);
		return;
	}

	mRenderer->PresentToWindow(hGLDC, mOutputFrameWidth, mOutputFrameHeight);
	ValidateRect(hGLWnd, NULL);
	LeaveCriticalSection(&pMutex);
}

void OpenGLComposite::resizeGL(WORD width, WORD height)
{
	// We don't set the project or model matrices here since the window data is copied directly from
	// an off-screen FBO in paintGL().  Just save the width and height for use in paintGL().
	mRenderer->ResizeView(width, height);
}

void OpenGLComposite::resizeWindow(int width, int height)
{
	RECT r;
	if (GetWindowRect(hGLWnd, &r))
	{
		SetWindowPos(hGLWnd, HWND_TOP, r.left, r.top, r.left + width, r.top + height, 0);
	}
}

bool OpenGLComposite::InitOpenGLState()
{
	if (! ResolveGLExtensions())
		return false;

	std::string runtimeError;
	if (mRuntimeHost->GetRepoRoot().empty() && !mRuntimeHost->Initialize(runtimeError))
	{
		MessageBoxA(NULL, runtimeError.c_str(), "Runtime host failed to initialize", MB_OK);
		return false;
	}

	if (!StartRuntimeControlServices(*this, *mRuntimeHost, *mControlServer, *mOscServer, runtimeError))
	{
		MessageBoxA(NULL, runtimeError.c_str(), "Runtime control services failed to start", MB_OK);
		return false;
	}

	// Prepare the runtime shader program generated from the active shader package.
	char compilerErrorMessage[1024];
	if (!mShaderPrograms->CompileDecodeShader(sizeof(compilerErrorMessage), compilerErrorMessage))
	{
		MessageBoxA(NULL, compilerErrorMessage, "OpenGL decode shader failed to load or compile", MB_OK);
		return false;
	}

	if (!mShaderPrograms->CompileLayerPrograms(mInputFrameWidth, mInputFrameHeight, sizeof(compilerErrorMessage), compilerErrorMessage))
	{
		MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
		return false;
	}
	mShaderPrograms->ResetTemporalHistoryState();

	std::string rendererError;
	if (!mRenderer->InitializeResources(mInputFrameWidth, mInputFrameHeight, mOutputFrameWidth, mOutputFrameHeight, rendererError))
	{
		MessageBoxA(NULL, rendererError.c_str(), "OpenGL initialization error.", MB_OK);
		return false;
	}

	broadcastRuntimeState();
	return true;
}

//
// Update the captured video frame texture
//
void OpenGLComposite::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource)
{
	mHasNoInputSource = hasNoInputSource;
	if (mRuntimeHost)
		mRuntimeHost->SetSignalStatus(!hasNoInputSource, mInputFrameWidth, mInputFrameHeight, mInputDisplayModeName);

	if (mHasNoInputSource)
		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(&pMutex);

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

	if (mRenderer->mFastTransferExtensionAvailable)
	{
		CComQIPtr<PinnedMemoryAllocator, &IID_PinnedMemoryAllocator> allocator(inputFrameBuffer);
		if (!allocator || !allocator->transferFrame(videoPixels, mRenderer->mCaptureTexture))
			OutputDebugStringA("Capture: transferFrame() failed\n");

		allocator->waitForTransferComplete(videoPixels);
	}
	else
	{
		// Use a straightforward texture buffer
		glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mRenderer->mUnpinnedTextureBuffer);
		glBufferData(GL_PIXEL_UNPACK_BUFFER, textureSize, videoPixels, GL_DYNAMIC_DRAW);
		glBindTexture(GL_TEXTURE_2D, mRenderer->mCaptureTexture);

		// NULL for last arg indicates use current GL_PIXEL_UNPACK_BUFFER target as texture data
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mInputFrameWidth / 2, mInputFrameHeight, 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(&pMutex);

	inputFrameBuffer->EndAccess(bmdBufferAccessRead);
	inputFrameBuffer->Release();
}

// 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)
{
	EnterCriticalSection(&pMutex);

	// Get the first frame from the queue
	IDeckLinkMutableVideoFrame* outputVideoFrame = mDLOutputVideoFrameQueue.front();
	mDLOutputVideoFrameQueue.push_back(outputVideoFrame);
	mDLOutputVideoFrameQueue.pop_front();

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

	// Draw the effect output to the off-screen framebuffer.
	const auto renderStartTime = std::chrono::steady_clock::now();
	if (mRenderer->mFastTransferExtensionAvailable)
		VideoFrameTransfer::beginTextureInUse(VideoFrameTransfer::GPUtoCPU);
	glBindFramebuffer(GL_FRAMEBUFFER, mRenderer->mIdFrameBuf);
	renderEffect();
	glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer->mIdFrameBuf);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mRenderer->mOutputFrameBuf);
	glBlitFramebuffer(0, 0, mInputFrameWidth, mInputFrameHeight, 0, 0, mOutputFrameWidth, mOutputFrameHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR);
	glBindFramebuffer(GL_FRAMEBUFFER, mRenderer->mOutputFrameBuf);
	glFlush();
	if (mRenderer->mFastTransferExtensionAvailable)
		VideoFrameTransfer::endTextureInUse(VideoFrameTransfer::GPUtoCPU);
	const auto renderEndTime = std::chrono::steady_clock::now();
	if (mRuntimeHost)
	{
		const double frameBudgetMilliseconds = mFrameTimescale != 0
			? (static_cast<double>(mFrameDuration) * 1000.0) / static_cast<double>(mFrameTimescale)
			: 0.0;
		const double renderMilliseconds = std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(renderEndTime - renderStartTime).count();
		mRuntimeHost->SetPerformanceStats(frameBudgetMilliseconds, renderMilliseconds);
	}
	if (mRuntimeHost)
		mRuntimeHost->AdvanceFrame();

	IDeckLinkVideoBuffer* outputVideoFrameBuffer;
	if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK)
	{
		LeaveCriticalSection(&pMutex);
		return;
	}

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

	void*	pFrame;
	outputVideoFrameBuffer->GetBytes(&pFrame);

	if (mRenderer->mFastTransferExtensionAvailable)
	{
		// Finished with mRenderer->mCaptureTexture
		if (!mHasNoInputSource)
			VideoFrameTransfer::endTextureInUse(VideoFrameTransfer::CPUtoGPU);

		if (! mPlayoutAllocator->transferFrame(pFrame, mRenderer->mOutputTexture))
			OutputDebugStringA("Playback: transferFrame() failed\n");

		paintGL();

		// Wait for transfer to system memory to complete
		mPlayoutAllocator->waitForTransferComplete(pFrame);
	}
	else
	{
		glBindFramebuffer(GL_READ_FRAMEBUFFER, mRenderer->mOutputFrameBuf);
		glReadPixels(0, 0, mOutputFrameWidth, mOutputFrameHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pFrame);
		paintGL();
	}

	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)
		mTotalPlayoutFrames += 2;

	// Schedule the next frame for playout
	HRESULT hr = mDLOutput->ScheduleVideoFrame(outputVideoFrame, (mTotalPlayoutFrames * mFrameDuration), mFrameDuration, mFrameTimescale);
	if (SUCCEEDED(hr))
		mTotalPlayoutFrames++;

	wglMakeCurrent( NULL, NULL );

	LeaveCriticalSection(&pMutex);
}

bool OpenGLComposite::Start()
{
	mTotalPlayoutFrames = 0;
	if (!mDLOutput)
	{
		MessageBoxA(NULL, "Cannot start playout because no DeckLink output device is available.", "DeckLink start failed", MB_OK | MB_ICONERROR);
		return false;
	}
	if (mDLOutputVideoFrameQueue.empty())
	{
		MessageBoxA(NULL, "Cannot start playout because the output frame queue is empty.", "DeckLink start failed", MB_OK | MB_ICONERROR);
		return false;
	}

	// Preroll frames
	for (unsigned i = 0; i < kPrerollFrameCount; i++)
	{
		// Take each video frame from the front of the queue and move it to the back
		IDeckLinkMutableVideoFrame* outputVideoFrame = mDLOutputVideoFrameQueue.front();
		mDLOutputVideoFrameQueue.push_back(outputVideoFrame);
		mDLOutputVideoFrameQueue.pop_front();

		// Start with a black frame for playout
		IDeckLinkVideoBuffer* outputVideoFrameBuffer;
		if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK)
		{
			MessageBoxA(NULL, "Could not query the preroll output frame buffer.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}
		
		if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK)
		{
			outputVideoFrameBuffer->Release();
			MessageBoxA(NULL, "Could not write to the preroll output frame buffer.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}

		void*	pFrame;
		outputVideoFrameBuffer->GetBytes((void**)&pFrame);
		memset(pFrame, 0, outputVideoFrame->GetRowBytes() * mOutputFrameHeight);		// 0 is black in BGRA format

		outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite);
		outputVideoFrameBuffer->Release();

		if (mDLOutput->ScheduleVideoFrame(outputVideoFrame, (mTotalPlayoutFrames * mFrameDuration), mFrameDuration, mFrameTimescale) != S_OK)
		{
			MessageBoxA(NULL, "Could not schedule a preroll output frame.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}

		mTotalPlayoutFrames++;
	}

	if (mDLInput)
	{
		if (mDLInput->StartStreams() != S_OK)
		{
			MessageBoxA(NULL, "Could not start the DeckLink input stream.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}
	}
	if (mDLOutput->StartScheduledPlayback(0, mFrameTimescale, 1.0) != S_OK)
	{
		MessageBoxA(NULL, "Could not start DeckLink scheduled playback.", "DeckLink start failed", MB_OK | MB_ICONERROR);
		return false;
	}

	return true;
}

bool OpenGLComposite::Stop()
{
	if (mOscServer)
		mOscServer->Stop();

	if (mControlServer)
		mControlServer->Stop();

	if (mDLKeyer != NULL)
	{
		mDLKeyer->Disable();
		mDeckLinkExternalKeyingActive = false;
		if (mRuntimeHost)
		{
			mRuntimeHost->SetDeckLinkOutputStatus(
				mDeckLinkOutputModelName,
				mDeckLinkSupportsInternalKeying,
				mDeckLinkSupportsExternalKeying,
				mDeckLinkKeyerInterfaceAvailable,
				mRuntimeHost->ExternalKeyingEnabled(),
				mDeckLinkExternalKeyingActive,
				"External keying has been disabled.");
		}
	}

	if (mDLInput)
	{
		mDLInput->StopStreams();
		mDLInput->DisableVideoInput();
	}

	if (mDLOutput)
	{
		mDLOutput->StopScheduledPlayback(0, NULL, 0);
		mDLOutput->DisableVideoOutput();
	}

	return true;
}

bool OpenGLComposite::ReloadShader()
{
	char compilerErrorMessage[1024];

	EnterCriticalSection(&pMutex);
	wglMakeCurrent(hGLDC, hGLRC);

	bool success = mShaderPrograms->CompileLayerPrograms(mInputFrameWidth, mInputFrameHeight, sizeof(compilerErrorMessage), compilerErrorMessage);
	if (mRuntimeHost)
		mRuntimeHost->ClearReloadRequest();

	wglMakeCurrent(NULL, NULL);
	LeaveCriticalSection(&pMutex);

	if (!success)
	{
		if (mRuntimeHost)
			mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
		MessageBoxA(NULL, compilerErrorMessage, "Slang shader reload failed", MB_OK);
	}
	else
	{
		if (mRuntimeHost)
			mRuntimeHost->SetCompileStatus(true, "Shader compiled successfully.");
		broadcastRuntimeState();
	}

	return success;
}

void OpenGLComposite::renderEffect()
{
	PollRuntimeChanges();

	const bool hasInputSource = !mHasNoInputSource;
	const std::vector<RuntimeRenderState> layerStates = mRuntimeHost ? mRuntimeHost->GetLayerRenderStates(mInputFrameWidth, mInputFrameHeight) : std::vector<RuntimeRenderState>();
	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
	mRenderPass->Render(
		hasInputSource,
		layerStates,
		mInputFrameWidth,
		mInputFrameHeight,
		historyCap,
		[this](const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error) {
			return mShaderPrograms->UpdateTextBindingTexture(state, textBinding, error);
		},
		[this](const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength) {
			return mShaderPrograms->UpdateGlobalParamsBuffer(state, availableSourceHistoryLength, availableTemporalHistoryLength);
		});
}

bool OpenGLComposite::PollRuntimeChanges()
{
	if (!mRuntimeHost)
		return true;

	bool registryChanged = false;
	bool reloadRequested = false;
	std::string runtimeError;
	if (!mRuntimeHost->PollFileChanges(registryChanged, reloadRequested, runtimeError))
	{
		mRuntimeHost->SetCompileStatus(false, runtimeError);
		broadcastRuntimeState();
		return false;
	}

	if (registryChanged)
		broadcastRuntimeState();

	if (!reloadRequested)
		return true;

	char compilerErrorMessage[1024] = {};
	if (!mShaderPrograms->CompileLayerPrograms(mInputFrameWidth, mInputFrameHeight, sizeof(compilerErrorMessage), compilerErrorMessage))
	{
		mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
		mRuntimeHost->ClearReloadRequest();
		broadcastRuntimeState();
		return false;
	}

	mShaderPrograms->ResetTemporalHistoryState();
	broadcastRuntimeState();
	return true;
}

void OpenGLComposite::broadcastRuntimeState()
{
	if (mControlServer)
		mControlServer->BroadcastState();
}

void OpenGLComposite::resetTemporalHistoryState()
{
	mShaderPrograms->ResetTemporalHistoryState();
}

bool OpenGLComposite::CheckOpenGLExtensions()
{
	mRenderer->mFastTransferExtensionAvailable = VideoFrameTransfer::checkFastMemoryTransferAvailable();

	if (!mRenderer->mFastTransferExtensionAvailable)
		OutputDebugStringA("Fast memory transfer extension not available, using regular OpenGL transfer fallback instead\n");

	return true;
}

////////////////////////////////////////////