519 lines
16 KiB
C++
519 lines
16 KiB
C++
#include "DeckLinkSession.h"
|
|
|
|
#include "GlRenderConstants.h"
|
|
|
|
#include <atlbase.h>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <new>
|
|
#include <sstream>
|
|
#include <vector>
|
|
|
|
namespace
|
|
{
|
|
std::string BstrToUtf8(BSTR value)
|
|
{
|
|
if (value == nullptr)
|
|
return std::string();
|
|
|
|
const int requiredBytes = WideCharToMultiByte(CP_UTF8, 0, value, -1, NULL, 0, NULL, NULL);
|
|
if (requiredBytes <= 1)
|
|
return std::string();
|
|
|
|
std::vector<char> utf8Name(static_cast<std::size_t>(requiredBytes), '\0');
|
|
if (WideCharToMultiByte(CP_UTF8, 0, value, -1, utf8Name.data(), requiredBytes, NULL, NULL) <= 0)
|
|
return std::string();
|
|
|
|
return std::string(utf8Name.data());
|
|
}
|
|
|
|
bool InputSupportsFormat(IDeckLinkInput* input, BMDDisplayMode displayMode, BMDPixelFormat pixelFormat)
|
|
{
|
|
if (input == nullptr)
|
|
return false;
|
|
|
|
BOOL supported = FALSE;
|
|
BMDDisplayMode actualMode = bmdModeUnknown;
|
|
const HRESULT result = input->DoesSupportVideoMode(
|
|
bmdVideoConnectionUnspecified,
|
|
displayMode,
|
|
pixelFormat,
|
|
bmdNoVideoInputConversion,
|
|
bmdSupportedVideoModeDefault,
|
|
&actualMode,
|
|
&supported);
|
|
return result == S_OK && supported != FALSE;
|
|
}
|
|
|
|
bool OutputSupportsFormat(IDeckLinkOutput* output, BMDDisplayMode displayMode, BMDPixelFormat pixelFormat)
|
|
{
|
|
if (output == nullptr)
|
|
return false;
|
|
|
|
BOOL supported = FALSE;
|
|
BMDDisplayMode actualMode = bmdModeUnknown;
|
|
const HRESULT result = output->DoesSupportVideoMode(
|
|
bmdVideoConnectionUnspecified,
|
|
displayMode,
|
|
pixelFormat,
|
|
bmdNoVideoOutputConversion,
|
|
bmdSupportedVideoModeDefault,
|
|
&actualMode,
|
|
&supported);
|
|
return result == S_OK && supported != FALSE;
|
|
}
|
|
}
|
|
|
|
DeckLinkSession::~DeckLinkSession()
|
|
{
|
|
ReleaseResources();
|
|
}
|
|
|
|
void DeckLinkSession::ReleaseResources()
|
|
{
|
|
if (input != nullptr)
|
|
input->SetCallback(nullptr);
|
|
captureDelegate.Release();
|
|
input.Release();
|
|
|
|
if (output != nullptr)
|
|
output->SetScheduledFrameCompletionCallback(nullptr);
|
|
|
|
if (keyer != nullptr)
|
|
{
|
|
keyer->Disable();
|
|
externalKeyingActive = false;
|
|
}
|
|
keyer.Release();
|
|
|
|
playoutDelegate.Release();
|
|
outputVideoFrameQueue.clear();
|
|
output.Release();
|
|
}
|
|
|
|
bool DeckLinkSession::DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error)
|
|
{
|
|
CComPtr<IDeckLinkIterator> deckLinkIterator;
|
|
CComPtr<IDeckLinkDisplayMode> inputMode;
|
|
CComPtr<IDeckLinkDisplayMode> outputMode;
|
|
|
|
inputDisplayModeName = videoModes.input.displayName;
|
|
outputDisplayModeName = videoModes.output.displayName;
|
|
|
|
HRESULT result = CoCreateInstance(CLSID_CDeckLinkIterator, nullptr, CLSCTX_ALL, IID_IDeckLinkIterator, reinterpret_cast<void**>(&deckLinkIterator));
|
|
if (FAILED(result))
|
|
{
|
|
error = "Please install the Blackmagic DeckLink drivers to use the features of this application.";
|
|
return false;
|
|
}
|
|
|
|
CComPtr<IDeckLink> deckLink;
|
|
while (deckLinkIterator->Next(&deckLink) == S_OK)
|
|
{
|
|
int64_t duplexMode;
|
|
bool deviceSupportsInternalKeying = false;
|
|
bool deviceSupportsExternalKeying = false;
|
|
std::string modelName;
|
|
CComPtr<IDeckLinkProfileAttributes> deckLinkAttributes;
|
|
|
|
if (deckLink->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes) != S_OK)
|
|
{
|
|
printf("Could not obtain the IDeckLinkProfileAttributes interface\n");
|
|
deckLink.Release();
|
|
continue;
|
|
}
|
|
|
|
result = deckLinkAttributes->GetInt(BMDDeckLinkDuplex, &duplexMode);
|
|
BOOL attributeFlag = FALSE;
|
|
if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &attributeFlag) == S_OK)
|
|
deviceSupportsInternalKeying = (attributeFlag != FALSE);
|
|
attributeFlag = FALSE;
|
|
if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsExternalKeying, &attributeFlag) == S_OK)
|
|
deviceSupportsExternalKeying = (attributeFlag != FALSE);
|
|
CComBSTR modelNameBstr;
|
|
if (deckLinkAttributes->GetString(BMDDeckLinkModelName, &modelNameBstr) == S_OK)
|
|
modelName = BstrToUtf8(modelNameBstr);
|
|
|
|
if (result != S_OK || duplexMode == bmdDuplexInactive)
|
|
{
|
|
deckLink.Release();
|
|
continue;
|
|
}
|
|
|
|
bool inputUsed = false;
|
|
if (!input && deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&input) == S_OK)
|
|
inputUsed = true;
|
|
|
|
if (!output && (!inputUsed || (duplexMode == bmdDuplexFull)))
|
|
{
|
|
if (deckLink->QueryInterface(IID_IDeckLinkOutput, (void**)&output) != S_OK)
|
|
output.Release();
|
|
else
|
|
{
|
|
outputModelName = modelName;
|
|
supportsInternalKeying = deviceSupportsInternalKeying;
|
|
supportsExternalKeying = deviceSupportsExternalKeying;
|
|
}
|
|
}
|
|
|
|
deckLink.Release();
|
|
|
|
if (output && input)
|
|
break;
|
|
}
|
|
|
|
if (!output)
|
|
{
|
|
error = "Expected an Output DeckLink device";
|
|
ReleaseResources();
|
|
return false;
|
|
}
|
|
|
|
CComPtr<IDeckLinkDisplayModeIterator> inputDisplayModeIterator;
|
|
if (input && input->GetDisplayModeIterator(&inputDisplayModeIterator) != S_OK)
|
|
{
|
|
error = "Cannot get input Display Mode Iterator.";
|
|
ReleaseResources();
|
|
return false;
|
|
}
|
|
|
|
if (input && !FindDeckLinkDisplayMode(inputDisplayModeIterator, videoModes.input.displayMode, &inputMode))
|
|
{
|
|
error = "Cannot get specified input BMDDisplayMode for configured mode: " + videoModes.input.displayName;
|
|
ReleaseResources();
|
|
return false;
|
|
}
|
|
inputDisplayModeIterator.Release();
|
|
|
|
CComPtr<IDeckLinkDisplayModeIterator> outputDisplayModeIterator;
|
|
if (output->GetDisplayModeIterator(&outputDisplayModeIterator) != S_OK)
|
|
{
|
|
error = "Cannot get output Display Mode Iterator.";
|
|
ReleaseResources();
|
|
return false;
|
|
}
|
|
|
|
if (!FindDeckLinkDisplayMode(outputDisplayModeIterator, videoModes.output.displayMode, &outputMode))
|
|
{
|
|
error = "Cannot get specified output BMDDisplayMode for configured mode: " + videoModes.output.displayName;
|
|
ReleaseResources();
|
|
return false;
|
|
}
|
|
|
|
outputFrameSize = { static_cast<unsigned>(outputMode->GetWidth()), static_cast<unsigned>(outputMode->GetHeight()) };
|
|
inputFrameSize = inputMode
|
|
? FrameSize{ static_cast<unsigned>(inputMode->GetWidth()), static_cast<unsigned>(inputMode->GetHeight()) }
|
|
: outputFrameSize;
|
|
if (!input)
|
|
inputDisplayModeName = "No input - black frame";
|
|
outputMode->GetFrameRate(&frameDuration, &frameTimescale);
|
|
|
|
inputFrameRowBytes = inputFrameSize.width * 2u;
|
|
outputFrameRowBytes = outputFrameSize.width * 4u;
|
|
captureTextureWidth = inputFrameSize.width / 2u;
|
|
outputPackTextureWidth = outputFrameSize.width;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DeckLinkSession::SelectPreferredFormats(const VideoFormatSelection& videoModes, std::string& error)
|
|
{
|
|
if (!output)
|
|
{
|
|
error = "Expected an Output DeckLink device";
|
|
return false;
|
|
}
|
|
|
|
formatStatusMessage.clear();
|
|
|
|
const bool inputTenBitSupported = input != nullptr && InputSupportsFormat(input, videoModes.input.displayMode, bmdFormat10BitYUV);
|
|
inputPixelFormat = input != nullptr ? ChoosePreferredVideoIOFormat(inputTenBitSupported) : VideoIOPixelFormat::Uyvy8;
|
|
if (input != nullptr && !inputTenBitSupported)
|
|
formatStatusMessage += "DeckLink input does not report 10-bit YUV support for the configured mode; using 8-bit capture. ";
|
|
|
|
const bool outputTenBitSupported = OutputSupportsFormat(output, videoModes.output.displayMode, bmdFormat10BitYUV);
|
|
outputPixelFormat = ChoosePreferredVideoIOFormat(outputTenBitSupported);
|
|
if (!outputTenBitSupported)
|
|
formatStatusMessage += "DeckLink output does not report 10-bit YUV support for the configured mode; using 8-bit BGRA output. ";
|
|
|
|
int deckLinkOutputRowBytes = 0;
|
|
if (output->RowBytesForPixelFormat(OutputIsTenBit() ? bmdFormat10BitYUV : bmdFormat8BitBGRA, outputFrameSize.width, &deckLinkOutputRowBytes) != S_OK)
|
|
{
|
|
error = "DeckLink output setup failed while calculating output row bytes.";
|
|
return false;
|
|
}
|
|
outputFrameRowBytes = static_cast<unsigned>(deckLinkOutputRowBytes);
|
|
outputPackTextureWidth = OutputIsTenBit()
|
|
? PackedTextureWidthFromRowBytes(outputFrameRowBytes)
|
|
: outputFrameSize.width;
|
|
|
|
if (InputIsTenBit())
|
|
{
|
|
int deckLinkInputRowBytes = 0;
|
|
if (output->RowBytesForPixelFormat(bmdFormat10BitYUV, inputFrameSize.width, &deckLinkInputRowBytes) == S_OK)
|
|
inputFrameRowBytes = static_cast<unsigned>(deckLinkInputRowBytes);
|
|
else
|
|
inputFrameRowBytes = MinimumV210RowBytes(inputFrameSize.width);
|
|
}
|
|
else
|
|
{
|
|
inputFrameRowBytes = inputFrameSize.width * 2u;
|
|
}
|
|
captureTextureWidth = InputIsTenBit()
|
|
? PackedTextureWidthFromRowBytes(inputFrameRowBytes)
|
|
: inputFrameSize.width / 2u;
|
|
|
|
std::ostringstream status;
|
|
status << "DeckLink formats: capture " << (input ? VideoIOPixelFormatName(inputPixelFormat) : "none")
|
|
<< ", output " << (OutputIsTenBit() ? "10-bit YUV v210" : "8-bit BGRA") << ".";
|
|
if (!formatStatusMessage.empty())
|
|
status << " " << formatStatusMessage;
|
|
formatStatusMessage = status.str();
|
|
return true;
|
|
}
|
|
|
|
bool DeckLinkSession::ConfigureInput(OpenGLComposite* owner, HDC hdc, HGLRC hglrc, const VideoFormat& inputVideoMode, std::string& error)
|
|
{
|
|
(void)hdc;
|
|
(void)hglrc;
|
|
|
|
if (!input)
|
|
{
|
|
hasNoInputSource = true;
|
|
inputDisplayModeName = "No input - black frame";
|
|
return true;
|
|
}
|
|
|
|
const BMDPixelFormat deckLinkInputPixelFormat = DeckLinkPixelFormatForVideoIO(inputPixelFormat);
|
|
if (input->EnableVideoInput(inputVideoMode.displayMode, deckLinkInputPixelFormat, bmdVideoInputFlagDefault) != S_OK)
|
|
{
|
|
if (inputPixelFormat == VideoIOPixelFormat::V210)
|
|
{
|
|
OutputDebugStringA("DeckLink 10-bit input could not be enabled; falling back to 8-bit capture.\n");
|
|
inputPixelFormat = VideoIOPixelFormat::Uyvy8;
|
|
inputFrameRowBytes = inputFrameSize.width * 2u;
|
|
captureTextureWidth = inputFrameSize.width / 2u;
|
|
if (input->EnableVideoInput(inputVideoMode.displayMode, bmdFormat8BitYUV, bmdVideoInputFlagDefault) == S_OK)
|
|
{
|
|
std::ostringstream status;
|
|
status << "DeckLink formats: capture " << VideoIOPixelFormatName(inputPixelFormat)
|
|
<< ", output " << (OutputIsTenBit() ? "10-bit YUV v210" : "8-bit BGRA")
|
|
<< ". DeckLink 10-bit input enable failed; using 8-bit capture.";
|
|
formatStatusMessage = status.str();
|
|
goto input_enabled;
|
|
}
|
|
}
|
|
|
|
OutputDebugStringA("DeckLink input could not be enabled; continuing in output-only black-frame mode.\n");
|
|
input.Release();
|
|
hasNoInputSource = true;
|
|
inputDisplayModeName = "No input - black frame";
|
|
return true;
|
|
}
|
|
|
|
input_enabled:
|
|
captureDelegate.Attach(new (std::nothrow) CaptureDelegate(owner));
|
|
if (captureDelegate == nullptr)
|
|
{
|
|
error = "DeckLink input setup failed while creating the capture callback.";
|
|
return false;
|
|
}
|
|
if (input->SetCallback(captureDelegate) != S_OK)
|
|
{
|
|
error = "DeckLink input setup failed while installing the capture callback.";
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DeckLinkSession::ConfigureOutput(OpenGLComposite* owner, HDC hdc, HGLRC hglrc, const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error)
|
|
{
|
|
(void)hdc;
|
|
(void)hglrc;
|
|
|
|
if (output->EnableVideoOutput(outputVideoMode.displayMode, bmdVideoOutputFlagDefault) != S_OK)
|
|
{
|
|
error = "DeckLink output setup failed while enabling video output.";
|
|
return false;
|
|
}
|
|
|
|
if (output->QueryInterface(IID_IDeckLinkKeyer, (void**)&keyer) == S_OK && keyer != NULL)
|
|
keyerInterfaceAvailable = true;
|
|
|
|
if (externalKeyingEnabled)
|
|
{
|
|
if (!supportsExternalKeying)
|
|
{
|
|
statusMessage = "External keying was requested, but the selected DeckLink output does not report external keying support.";
|
|
}
|
|
else if (!keyerInterfaceAvailable)
|
|
{
|
|
statusMessage = "External keying was requested, but the selected DeckLink output does not expose the IDeckLinkKeyer interface.";
|
|
}
|
|
else if (keyer->Enable(TRUE) != S_OK || keyer->SetLevel(255) != S_OK)
|
|
{
|
|
statusMessage = "External keying was requested, but enabling the DeckLink keyer failed.";
|
|
}
|
|
else
|
|
{
|
|
externalKeyingActive = true;
|
|
statusMessage = "External keying is active on the selected DeckLink output.";
|
|
}
|
|
}
|
|
else if (supportsExternalKeying)
|
|
{
|
|
statusMessage = "Selected DeckLink output supports external keying. Set enableExternalKeying to true in runtime-host.json to request it.";
|
|
}
|
|
|
|
for (int i = 0; i < 10; i++)
|
|
{
|
|
CComPtr<IDeckLinkMutableVideoFrame> outputFrame;
|
|
|
|
const BMDPixelFormat deckLinkOutputPixelFormat = OutputIsTenBit() ? bmdFormat10BitYUV : bmdFormat8BitBGRA;
|
|
if (output->CreateVideoFrame(outputFrameSize.width, outputFrameSize.height, outputFrameRowBytes, deckLinkOutputPixelFormat, bmdFrameFlagFlipVertical, &outputFrame) != S_OK)
|
|
{
|
|
error = "DeckLink output setup failed while creating an output video frame.";
|
|
return false;
|
|
}
|
|
|
|
outputVideoFrameQueue.push_back(outputFrame);
|
|
}
|
|
|
|
playoutDelegate.Attach(new (std::nothrow) PlayoutDelegate(owner));
|
|
if (playoutDelegate == nullptr)
|
|
{
|
|
error = "DeckLink output setup failed while creating the playout callback.";
|
|
return false;
|
|
}
|
|
|
|
if (output->SetScheduledFrameCompletionCallback(playoutDelegate) != S_OK)
|
|
{
|
|
error = "DeckLink output setup failed while installing the scheduled-frame callback.";
|
|
return false;
|
|
}
|
|
|
|
if (!formatStatusMessage.empty())
|
|
statusMessage = statusMessage.empty() ? formatStatusMessage : formatStatusMessage + " " + statusMessage;
|
|
|
|
return true;
|
|
}
|
|
|
|
double DeckLinkSession::FrameBudgetMilliseconds() const
|
|
{
|
|
return frameTimescale != 0
|
|
? (static_cast<double>(frameDuration) * 1000.0) / static_cast<double>(frameTimescale)
|
|
: 0.0;
|
|
}
|
|
|
|
IDeckLinkMutableVideoFrame* DeckLinkSession::RotateOutputFrame()
|
|
{
|
|
CComPtr<IDeckLinkMutableVideoFrame> outputVideoFrame = outputVideoFrameQueue.front();
|
|
outputVideoFrameQueue.push_back(outputVideoFrame);
|
|
outputVideoFrameQueue.pop_front();
|
|
return outputVideoFrame.p;
|
|
}
|
|
|
|
void DeckLinkSession::AccountForCompletionResult(BMDOutputFrameCompletionResult completionResult)
|
|
{
|
|
if (completionResult == bmdOutputFrameDisplayedLate || completionResult == bmdOutputFrameDropped)
|
|
totalPlayoutFrames += 2;
|
|
}
|
|
|
|
bool DeckLinkSession::ScheduleOutputFrame(IDeckLinkMutableVideoFrame* outputVideoFrame)
|
|
{
|
|
if (output->ScheduleVideoFrame(outputVideoFrame, (totalPlayoutFrames * frameDuration), frameDuration, frameTimescale) != S_OK)
|
|
return false;
|
|
|
|
totalPlayoutFrames++;
|
|
return true;
|
|
}
|
|
|
|
bool DeckLinkSession::Start()
|
|
{
|
|
totalPlayoutFrames = 0;
|
|
if (!output)
|
|
{
|
|
MessageBoxA(NULL, "Cannot start playout because no DeckLink output device is available.", "DeckLink start failed", MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
if (outputVideoFrameQueue.empty())
|
|
{
|
|
MessageBoxA(NULL, "Cannot start playout because the output frame queue is empty.", "DeckLink start failed", MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
|
|
for (unsigned i = 0; i < kPrerollFrameCount; i++)
|
|
{
|
|
CComPtr<IDeckLinkMutableVideoFrame> outputVideoFrame = outputVideoFrameQueue.front();
|
|
outputVideoFrameQueue.push_back(outputVideoFrame);
|
|
outputVideoFrameQueue.pop_front();
|
|
|
|
CComPtr<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)
|
|
{
|
|
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() * outputFrameSize.height);
|
|
|
|
outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite);
|
|
|
|
if (output->ScheduleVideoFrame(outputVideoFrame, (totalPlayoutFrames * frameDuration), frameDuration, frameTimescale) != S_OK)
|
|
{
|
|
MessageBoxA(NULL, "Could not schedule a preroll output frame.", "DeckLink start failed", MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
|
|
totalPlayoutFrames++;
|
|
}
|
|
|
|
if (input)
|
|
{
|
|
if (input->StartStreams() != S_OK)
|
|
{
|
|
MessageBoxA(NULL, "Could not start the DeckLink input stream.", "DeckLink start failed", MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
}
|
|
if (output->StartScheduledPlayback(0, frameTimescale, 1.0) != S_OK)
|
|
{
|
|
MessageBoxA(NULL, "Could not start DeckLink scheduled playback.", "DeckLink start failed", MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DeckLinkSession::Stop()
|
|
{
|
|
if (keyer != nullptr)
|
|
{
|
|
keyer->Disable();
|
|
externalKeyingActive = false;
|
|
}
|
|
|
|
if (input)
|
|
{
|
|
input->StopStreams();
|
|
input->DisableVideoInput();
|
|
}
|
|
|
|
if (output)
|
|
{
|
|
output->StopScheduledPlayback(0, NULL, 0);
|
|
output->DisableVideoOutput();
|
|
}
|
|
|
|
return true;
|
|
}
|