399 lines
12 KiB
C++
399 lines
12 KiB
C++
#include "DeckLinkDisplayMode.h"
|
|
#include "DeckLinkFrameTransfer.h"
|
|
#include "DeckLinkSession.h"
|
|
#include "OpenGLComposite.h"
|
|
#include "GLExtensions.h"
|
|
#include "GlRenderConstants.h"
|
|
#include "OpenGLDeckLinkBridge.h"
|
|
#include "OpenGLRenderPass.h"
|
|
#include "OpenGLShaderPrograms.h"
|
|
#include "RuntimeServices.h"
|
|
#include "ShaderBuildQueue.h"
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
|
|
hGLWnd(hWnd), hGLDC(hDC), hGLRC(hRC),
|
|
mDeckLink(std::make_unique<DeckLinkSession>()),
|
|
mRenderer(std::make_unique<OpenGLRenderer>()),
|
|
mUseCommittedLayerStates(false)
|
|
{
|
|
InitializeCriticalSection(&pMutex);
|
|
mRuntimeHost = std::make_unique<RuntimeHost>();
|
|
mDeckLinkBridge = std::make_unique<OpenGLDeckLinkBridge>(
|
|
*mDeckLink,
|
|
*mRenderer,
|
|
*mRuntimeHost,
|
|
pMutex,
|
|
hGLDC,
|
|
hGLRC,
|
|
[this]() { renderEffect(); },
|
|
[this]() { paintGL(); });
|
|
mRenderPass = std::make_unique<OpenGLRenderPass>(*mRenderer);
|
|
mShaderPrograms = std::make_unique<OpenGLShaderPrograms>(*mRenderer, *mRuntimeHost);
|
|
mShaderBuildQueue = std::make_unique<ShaderBuildQueue>(*mRuntimeHost);
|
|
mRuntimeServices = std::make_unique<RuntimeServices>();
|
|
}
|
|
|
|
OpenGLComposite::~OpenGLComposite()
|
|
{
|
|
if (mRuntimeServices)
|
|
mRuntimeServices->Stop();
|
|
if (mShaderBuildQueue)
|
|
mShaderBuildQueue->Stop();
|
|
mDeckLink->ReleaseResources();
|
|
mRenderer->DestroyResources();
|
|
|
|
DeleteCriticalSection(&pMutex);
|
|
}
|
|
|
|
bool OpenGLComposite::InitDeckLink()
|
|
{
|
|
VideoFormatSelection videoModes;
|
|
std::string initFailureReason;
|
|
|
|
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 (!ResolveConfiguredVideoFormats(
|
|
mRuntimeHost->GetInputVideoFormat(),
|
|
mRuntimeHost->GetInputFrameRate(),
|
|
mRuntimeHost->GetOutputVideoFormat(),
|
|
mRuntimeHost->GetOutputFrameRate(),
|
|
videoModes,
|
|
initFailureReason))
|
|
{
|
|
MessageBoxA(NULL, initFailureReason.c_str(), "DeckLink mode configuration error", MB_OK);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!mDeckLink->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."
|
|
: "DeckLink initialization failed";
|
|
MessageBoxA(NULL, initFailureReason.c_str(), title, MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
|
|
if (! CheckOpenGLExtensions())
|
|
{
|
|
initFailureReason = "OpenGL extension checks failed.";
|
|
goto error;
|
|
}
|
|
if (mDeckLink->InputOutputDimensionsDiffer())
|
|
{
|
|
mRenderer->SetFastTransferAvailable(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;
|
|
}
|
|
|
|
PublishDeckLinkOutputStatus(mDeckLink->OutputModelName().empty()
|
|
? "DeckLink output device selected."
|
|
: ("Selected output device: " + mDeckLink->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());
|
|
else
|
|
resizeWindow(mDeckLink->OutputFrameWidth() / 2, mDeckLink->OutputFrameHeight() / 2);
|
|
|
|
if (mRenderer->FastTransferAvailable())
|
|
{
|
|
// Initialize fast video frame transfers
|
|
if (! VideoFrameTransfer::initialize(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mRenderer->CaptureTexture(), mRenderer->OutputTexture()))
|
|
{
|
|
MessageBox(NULL, _T("Cannot initialize video transfers."), _T("VideoFrameTransfer error."), MB_OK);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
if (!mDeckLink->ConfigureInput(this, hGLDC, hGLRC, videoModes.input, initFailureReason))
|
|
{
|
|
goto error;
|
|
}
|
|
if (!mDeckLink->HasInputDevice() && mRuntimeHost)
|
|
{
|
|
mRuntimeHost->SetSignalStatus(false, mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mDeckLink->InputDisplayModeName());
|
|
}
|
|
|
|
if (!mDeckLink->ConfigureOutput(this, hGLDC, hGLRC, videoModes.output, mRuntimeHost && mRuntimeHost->ExternalKeyingEnabled(), initFailureReason))
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
PublishDeckLinkOutputStatus(mDeckLink->StatusMessage());
|
|
|
|
return true;
|
|
|
|
error:
|
|
if (!initFailureReason.empty())
|
|
MessageBoxA(NULL, initFailureReason.c_str(), "DeckLink initialization failed", MB_OK | MB_ICONERROR);
|
|
mDeckLink->ReleaseResources();
|
|
return false;
|
|
}
|
|
|
|
void OpenGLComposite::paintGL()
|
|
{
|
|
if (!TryEnterCriticalSection(&pMutex))
|
|
{
|
|
ValidateRect(hGLWnd, NULL);
|
|
return;
|
|
}
|
|
|
|
mRenderer->PresentToWindow(hGLDC, mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight());
|
|
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);
|
|
}
|
|
}
|
|
|
|
void OpenGLComposite::PublishDeckLinkOutputStatus(const std::string& statusMessage)
|
|
{
|
|
if (!mRuntimeHost)
|
|
return;
|
|
|
|
if (!statusMessage.empty())
|
|
mDeckLink->SetStatusMessage(statusMessage);
|
|
|
|
mRuntimeHost->SetDeckLinkOutputStatus(
|
|
mDeckLink->OutputModelName(),
|
|
mDeckLink->SupportsInternalKeying(),
|
|
mDeckLink->SupportsExternalKeying(),
|
|
mDeckLink->KeyerInterfaceAvailable(),
|
|
mRuntimeHost->ExternalKeyingEnabled(),
|
|
mDeckLink->ExternalKeyingActive(),
|
|
mDeckLink->StatusMessage());
|
|
}
|
|
|
|
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 (!mRuntimeServices->Start(*this, *mRuntimeHost, 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(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
|
|
{
|
|
MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
|
|
return false;
|
|
}
|
|
mCachedLayerRenderStates = mShaderPrograms->CommittedLayerStates();
|
|
mUseCommittedLayerStates = false;
|
|
mShaderPrograms->ResetTemporalHistoryState();
|
|
|
|
std::string rendererError;
|
|
if (!mRenderer->InitializeResources(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight(), rendererError))
|
|
{
|
|
MessageBoxA(NULL, rendererError.c_str(), "OpenGL initialization error.", MB_OK);
|
|
return false;
|
|
}
|
|
|
|
broadcastRuntimeState();
|
|
mRuntimeServices->BeginPolling(*mRuntimeHost);
|
|
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();
|
|
}
|
|
|
|
bool OpenGLComposite::Stop()
|
|
{
|
|
if (mRuntimeServices)
|
|
mRuntimeServices->Stop();
|
|
|
|
const bool wasExternalKeyingActive = mDeckLink->ExternalKeyingActive();
|
|
mDeckLink->Stop();
|
|
if (wasExternalKeyingActive)
|
|
PublishDeckLinkOutputStatus("External keying has been disabled.");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OpenGLComposite::ReloadShader()
|
|
{
|
|
if (mRuntimeHost)
|
|
{
|
|
mRuntimeHost->SetCompileStatus(true, "Shader rebuild queued.");
|
|
mRuntimeHost->ClearReloadRequest();
|
|
}
|
|
RequestShaderBuild();
|
|
broadcastRuntimeState();
|
|
return true;
|
|
}
|
|
|
|
void OpenGLComposite::renderEffect()
|
|
{
|
|
ProcessRuntimePollResults();
|
|
|
|
const bool hasInputSource = mDeckLink->HasInputSource();
|
|
std::vector<RuntimeRenderState> layerStates;
|
|
if (mUseCommittedLayerStates)
|
|
{
|
|
layerStates = mShaderPrograms->CommittedLayerStates();
|
|
}
|
|
else if (mRuntimeHost)
|
|
{
|
|
if (mRuntimeHost->TryGetLayerRenderStates(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), layerStates))
|
|
mCachedLayerRenderStates = layerStates;
|
|
else
|
|
layerStates = mCachedLayerRenderStates;
|
|
}
|
|
const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
|
|
mRenderPass->Render(
|
|
hasInputSource,
|
|
layerStates,
|
|
mDeckLink->InputFrameWidth(),
|
|
mDeckLink->InputFrameHeight(),
|
|
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::ProcessRuntimePollResults()
|
|
{
|
|
if (!mRuntimeHost || !mRuntimeServices)
|
|
return true;
|
|
|
|
const RuntimePollEvents events = mRuntimeServices->ConsumePollEvents();
|
|
if (events.failed)
|
|
{
|
|
mRuntimeHost->SetCompileStatus(false, events.error);
|
|
broadcastRuntimeState();
|
|
return false;
|
|
}
|
|
|
|
if (events.registryChanged)
|
|
broadcastRuntimeState();
|
|
|
|
if (!events.reloadRequested)
|
|
{
|
|
PreparedShaderBuild readyBuild;
|
|
if (!mShaderBuildQueue || !mShaderBuildQueue->TryConsumeReadyBuild(readyBuild))
|
|
return true;
|
|
|
|
char compilerErrorMessage[1024] = {};
|
|
if (!mShaderPrograms->CommitPreparedLayerPrograms(readyBuild, mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
|
|
{
|
|
mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
|
|
mUseCommittedLayerStates = true;
|
|
broadcastRuntimeState();
|
|
return false;
|
|
}
|
|
|
|
mUseCommittedLayerStates = false;
|
|
mCachedLayerRenderStates = mShaderPrograms->CommittedLayerStates();
|
|
mShaderPrograms->ResetTemporalHistoryState();
|
|
broadcastRuntimeState();
|
|
return true;
|
|
}
|
|
|
|
mRuntimeHost->SetCompileStatus(true, "Shader rebuild queued.");
|
|
RequestShaderBuild();
|
|
broadcastRuntimeState();
|
|
return true;
|
|
}
|
|
|
|
void OpenGLComposite::RequestShaderBuild()
|
|
{
|
|
if (!mShaderBuildQueue || !mDeckLink)
|
|
return;
|
|
|
|
mUseCommittedLayerStates = true;
|
|
if (mRuntimeHost)
|
|
mRuntimeHost->ClearReloadRequest();
|
|
mShaderBuildQueue->RequestBuild(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight());
|
|
}
|
|
|
|
void OpenGLComposite::broadcastRuntimeState()
|
|
{
|
|
if (mRuntimeServices)
|
|
mRuntimeServices->BroadcastState();
|
|
}
|
|
|
|
void OpenGLComposite::resetTemporalHistoryState()
|
|
{
|
|
mShaderPrograms->ResetTemporalHistoryState();
|
|
}
|
|
|
|
bool OpenGLComposite::CheckOpenGLExtensions()
|
|
{
|
|
mRenderer->SetFastTransferAvailable(VideoFrameTransfer::checkFastMemoryTransferAvailable());
|
|
|
|
if (!mRenderer->FastTransferAvailable())
|
|
OutputDebugStringA("Fast memory transfer extension not available, using regular OpenGL transfer fallback instead\n");
|
|
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////////////////////
|
|
|
|
|