OFX_DECKLINK_API_BEGIN_NAMESPACE
vector<Device> listDevice()
{
vector<Device> devinfo;
IDeckLinkIterator* deckLinkIterator = CreateDeckLinkIteratorInstance();
if (deckLinkIterator == NULL)
{
ofLogError("ofxDeckLinkAPI::Monitor") << "This application requires the DeckLink drivers installed." << "\n" << "Please install the Blackmagic DeckLink drivers to use the features of this application.";
}
cout << "==== ofxDeckLinkAPI::listDevice() ====" << endl;
IDeckLink* deckLink = NULL;
HRESULT result;
int num_device = 0;
while (deckLinkIterator->Next(&deckLink) == S_OK)
{
Device dev;
CFStringRef deviceNameCFString = NULL;
result = deckLink->GetModelName(&deviceNameCFString);
if (result == S_OK)
{
char deviceName[64];
CFStringGetCString(deviceNameCFString, deviceName, sizeof(deviceName), kCFStringEncodingUTF8);
cout << num_device << ": " << deviceName;
CFRelease(deviceNameCFString);
dev.model_name = (string)deviceName;
}
IDeckLinkAttributes* attr = NULL;
deckLink->QueryInterface(IID_IDeckLinkAttributes, (void**)&attr);
if (attr != NULL) {
{
int64_t v = 0;
if (attr->GetInt(BMDDeckLinkPersistentID, &v) == S_OK) {
dev.persistent_id = v;
cout << ", pid:" << v;
}
}
{
int64_t v = 0;
if (attr->GetInt(BMDDeckLinkTopologicalID, &v) == S_OK) {
dev.topological_id = v;
cout << ", tid:" << v;
}
}
}
cout << endl;
devinfo.push_back(dev);
deckLink->Release();
num_device++;
}
if (num_device == 0)
cout << "device not found" << endl;
cout << "======================================" << endl << endl;
if (deckLinkIterator != NULL)
{
deckLinkIterator->Release();
deckLinkIterator = NULL;
}
return devinfo;
}
static void print_capabilities (IDeckLink* deckLink)
{
IDeckLinkAttributes* deckLinkAttributes = NULL;
int64_t ports;
int itemCount;
HRESULT result;
// Query the DeckLink for its configuration interface
result = deckLink->QueryInterface(IID_IDeckLinkAttributes, (void**)&deckLinkAttributes);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the IDeckLinkAttributes interface - result = %08x\n", result);
goto bail;
}
printf("Supported video output connections:\n ");
itemCount = 0;
result = deckLinkAttributes->GetInt(BMDDeckLinkVideoOutputConnections, &ports);
if (result == S_OK)
{
if (ports & bmdVideoConnectionSDI)
{
itemCount++;
printf("SDI");
}
if (ports & bmdVideoConnectionHDMI)
{
if (itemCount++ > 0)
printf(", ");
printf("HDMI");
}
if (ports & bmdVideoConnectionOpticalSDI)
{
if (itemCount++ > 0)
printf(", ");
printf("Optical SDI");
}
if (ports & bmdVideoConnectionComponent)
{
if (itemCount++ > 0)
printf(", ");
printf("Component");
}
if (ports & bmdVideoConnectionComposite)
{
if (itemCount++ > 0)
printf(", ");
printf("Composite");
}
if (ports & bmdVideoConnectionSVideo)
{
if (itemCount++ > 0)
printf(", ");
printf("S-Video");
}
}
else
{
fprintf(stderr, "Could not obtain the list of output ports - result = %08x\n", result);
goto bail;
}
printf("\n\n");
printf("Supported video input connections:\n ");
itemCount = 0;
result = deckLinkAttributes->GetInt(BMDDeckLinkVideoInputConnections, &ports);
if (result == S_OK)
{
if (ports & bmdVideoConnectionSDI)
{
itemCount++;
printf("SDI");
}
if (ports & bmdVideoConnectionHDMI)
{
if (itemCount++ > 0)
printf(", ");
printf("HDMI");
}
if (ports & bmdVideoConnectionOpticalSDI)
{
if (itemCount++ > 0)
printf(", ");
printf("Optical SDI");
}
if (ports & bmdVideoConnectionComponent)
{
if (itemCount++ > 0)
printf(", ");
printf("Component");
}
if (ports & bmdVideoConnectionComposite)
{
if (itemCount++ > 0)
printf(", ");
printf("Composite");
}
if (ports & bmdVideoConnectionSVideo)
{
if (itemCount++ > 0)
printf(", ");
printf("S-Video");
}
}
else
{
fprintf(stderr, "Could not obtain the list of input ports - result = %08x\n", result);
goto bail;
}
printf("\n");
bail:
if (deckLinkAttributes != NULL)
deckLinkAttributes->Release();
}
static void print_attributes (IDeckLink* deckLink)
{
IDeckLinkAttributes* deckLinkAttributes = NULL;
bool supported;
int64_t count;
char * serialPortName = NULL;
HRESULT result;
// Query the DeckLink for its attributes interface
result = deckLink->QueryInterface(IID_IDeckLinkAttributes, (void**)&deckLinkAttributes);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the IDeckLinkAttributes interface - result = %08x\n", result);
goto bail;
}
// List attributes and their value
printf("Attribute list:\n");
result = deckLinkAttributes->GetFlag(BMDDeckLinkHasSerialPort, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Serial port present ?", (supported == true) ? "Yes" : "No");
if (supported)
{
CFStringRef serialPortNameString = CFStringCreateWithCString(kCFAllocatorDefault, serialPortName, kCFStringEncodingMacRoman);
result = deckLinkAttributes->GetString(BMDDeckLinkSerialPortDeviceName, &serialPortNameString);
if (result == S_OK)
{
printf(" %-40s %s\n", "Serial port name: ", serialPortName);
free(serialPortName);
}
else
{
fprintf(stderr, "Could not query the serial port presence attribute- result = %08x\n", result);
}
}
}
else
{
fprintf(stderr, "Could not query the serial port presence attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetInt(BMDDeckLinkNumberOfSubDevices, &count);
if (result == S_OK)
{
printf(" %-40s %lld\n", "Number of sub-devices:", count);
if (count != 0)
{
result = deckLinkAttributes->GetInt(BMDDeckLinkSubDeviceIndex, &count);
if (result == S_OK)
{
printf(" %-40s %lld\n", "Sub-device index:", count);
}
else
{
fprintf(stderr, "Could not query the sub-device index attribute- result = %08x\n", result);
}
}
}
else
{
fprintf(stderr, "Could not query the number of sub-device attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetInt(BMDDeckLinkMaximumAudioChannels, &count);
if (result == S_OK)
{
printf(" %-40s %lld\n", "Number of audio channels:", count);
}
else
{
fprintf(stderr, "Could not query the number of supported audio channels attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInputFormatDetection, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Input mode detection supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the input mode detection attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Internal keying supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the internal keying attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsExternalKeying, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "External keying supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the external keying attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsHDKeying, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "HD-mode keying supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the HD-mode keying attribute- result = %08x\n", result);
}
bail:
printf("\n");
if(deckLinkAttributes != NULL)
deckLinkAttributes->Release();
}
/**
* process the arugments
* return negative value of failed
*/
int Window::processArguments(int argc, char* argv[]){
IDeckLinkAttributes *deckLinkAttributes = NULL;
DeckLinkCaptureDelegate *delegate;
IDeckLinkDisplayMode *displayMode;
BMDVideoInputFlags inputFlags = 0;
BMDDisplayMode selectedDisplayMode = bmdModeNTSC;
BMDPixelFormat pixelFormat = bmdFormat8BitYUV;
int displayModeCount = 0;
int exitStatus = 1;
int ch;
bool foundDisplayMode = false;
HRESULT result;
int dnum = 0;
IDeckLink *tempLink = NULL;
int found = 0;
bool supported = 0;
int64_t ports;
int itemCount;
int vinput = 0;
int64_t vport = 0;
IDeckLinkConfiguration *deckLinkConfiguration = NULL;
bool flickerremoval = true;
bool pnotpsf = true;
// Parse command line options
while ((ch = getopt(argc, argv, "?h3c:d:s:f:a:m:n:p:t:u::vi:jy")) != -1)
{
switch (ch)
{
case 'i':
vinput = atoi(optarg);
break;
case 'd':
card = atoi(optarg);
break;
case 'm':
g_videoModeIndex = atoi(optarg);
break;
case 'n':
g_maxFrames = atoi(optarg);
break;
case '3':
inputFlags |= bmdVideoInputDualStream3D;
break;
case 'p':
switch(atoi(optarg))
{
case 0: pixelFormat = bmdFormat8BitYUV; break;
case 1: pixelFormat = bmdFormat10BitYUV; break;
case 2: pixelFormat = bmdFormat10BitRGB; break;
default:
fprintf(stderr, "Invalid argument: Pixel format %d is not valid", atoi(optarg));
exit(1);
}
break;
case 't':
if (!strcmp(optarg, "rp188"))
g_timecodeFormat = bmdTimecodeRP188Any;
else if (!strcmp(optarg, "vitc"))
g_timecodeFormat = bmdTimecodeVITC;
else if (!strcmp(optarg, "serial"))
g_timecodeFormat = bmdTimecodeSerial;
else
{
fprintf(stderr, "Invalid argument: Timecode format \"%s\" is invalid\n", optarg);
exit(1);
}
break;
case '?':
case 'h':
usage();
}
}
if (!deckLinkIterator)
{
fprintf(stderr, "This application requires the DeckLink drivers installed.\n");
return -1;
}
/* Connect to the first DeckLink instance */
while (deckLinkIterator->Next(&tempLink) == S_OK)
{
if (card != dnum) {
dnum++;
// Release the IDeckLink instance when we've finished with it to prevent leaks
tempLink->Release();
continue;
}
else {
deckLink = tempLink;
found = 1;
}
dnum++;
}
if (! found ) {
fprintf(stderr, "No DeckLink PCI cards found.\n");
return -1;
}
if (deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput) != S_OK)
return -1;
// Query the DeckLink for its attributes interface
result = deckLink->QueryInterface(IID_IDeckLinkAttributes, (void**)&deckLinkAttributes);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the IDeckLinkAttributes interface - result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInputFormatDetection, &supported);
if (result == S_OK)
{
fprintf(stderr, " %-40s %s\n", "Input mode detection supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the input mode detection attribute- result = %08x\n", result);
}
fprintf(stderr, "Supported video input connections (-i [input #]:\n ");
itemCount = 0;
result = deckLinkAttributes->GetInt(BMDDeckLinkVideoInputConnections, &ports);
if (result == S_OK)
{
if (ports & bmdVideoConnectionSDI)
{
fprintf(stderr, "%d: SDI, ", bmdVideoConnectionSDI);
itemCount++;
}
if (ports & bmdVideoConnectionHDMI)
{
fprintf(stderr, "%d: HDMI, ", bmdVideoConnectionHDMI);
itemCount++;
}
if (ports & bmdVideoConnectionOpticalSDI)
{
fprintf(stderr, "%d: Optical SDI, ", bmdVideoConnectionOpticalSDI);
itemCount++;
}
if (ports & bmdVideoConnectionComponent)
{
fprintf(stderr, "%d: Component, ", bmdVideoConnectionComponent);
itemCount++;
}
if (ports & bmdVideoConnectionComposite)
{
fprintf(stderr, "%d: Composite, ", bmdVideoConnectionComposite);
itemCount++;
}
if (ports & bmdVideoConnectionSVideo)
{
fprintf(stderr, "%d: S-Video, ", bmdVideoConnectionSVideo);
itemCount++;
}
}
fprintf(stderr, "\n");
//glWidget->initShaderProgram();
delegate = new DeckLinkCaptureDelegate(glWidget);
connect(delegate, SIGNAL(updateGLSignal()), glWidget, SLOT(updateGLSlot()));
deckLinkInput->SetCallback(delegate);
// Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on output
result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the video output display mode iterator - result = %08x\n", result);
return -1;
}
if (g_videoModeIndex < 0)
{
fprintf(stderr, "No video mode specified\n");
usage();
return -1;
}
while (displayModeIterator->Next(&displayMode) == S_OK)
{
if (g_videoModeIndex == displayModeCount)
{
BMDDisplayModeSupport result;
const char *displayModeName;
foundDisplayMode = true;
displayMode->GetName(&displayModeName);
selectedDisplayMode = displayMode->GetDisplayMode();
deckLinkInput->DoesSupportVideoMode(selectedDisplayMode, pixelFormat, bmdVideoInputFlagDefault, &result, NULL);
if (result == bmdDisplayModeNotSupported)
{
fprintf(stderr, "The display mode %s is not supported with the selected pixel format\n", displayModeName);
return -1;
}
if (inputFlags & bmdVideoInputDualStream3D)
{
if (!(displayMode->GetFlags() & bmdDisplayModeSupports3D))
{
fprintf(stderr, "The display mode %s is not supported with 3D\n", displayModeName);
return -1;
}
}
fprintf(stderr, "Selecting mode: %s\n", displayModeName);
break;
}
displayModeCount++;
displayMode->Release();
}
if (!foundDisplayMode)
{
fprintf(stderr, "Invalid mode %d specified\n", g_videoModeIndex);
return -1;
}
// Query the DeckLink for its configuration interface
result = deckLinkInput->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the IDeckLinkConfiguration interface: %08x\n", result);
}
BMDVideoConnection conn;
switch (vinput) {
case 0:
conn = bmdVideoConnectionSDI;
break;
case 1:
conn = bmdVideoConnectionHDMI;
break;
case 2:
conn = bmdVideoConnectionComponent;
break;
case 3:
conn = bmdVideoConnectionComposite;
break;
case 4:
conn = bmdVideoConnectionSVideo;
break;
case 5:
conn = bmdVideoConnectionOpticalSDI;
break;
default:
break;
}
conn = vinput;
// Set the input desired
result = deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection, conn);
if(result != S_OK) {
fprintf(stderr, "Cannot set the input to [%d]\n", conn);
return -1;
}
// check input
result = deckLinkConfiguration->GetInt(bmdDeckLinkConfigVideoInputConnection, &vport);
if (vport == bmdVideoConnectionSDI)
fprintf(stderr, "Before Input configured for SDI\n");
if (vport == bmdVideoConnectionHDMI)
fprintf(stderr, "Before Input configured for HDMI\n");
if (deckLinkConfiguration->SetFlag(bmdDeckLinkConfigFieldFlickerRemoval, flickerremoval) == S_OK) {
fprintf(stderr, "Flicker removal set : %d\n", flickerremoval);
}
else {
fprintf(stderr, "Flicker removal NOT set\n");
}
if (deckLinkConfiguration->SetFlag(bmdDeckLinkConfigUse1080pNotPsF, pnotpsf) == S_OK) {
fprintf(stderr, "bmdDeckLinkConfigUse1080pNotPsF: %d\n", pnotpsf);
}
else {
fprintf(stderr, "bmdDeckLinkConfigUse1080pNotPsF NOT set\n");
}
//if (deckLinkConfiguration->SetFlag(bmdDeckLinkConfigVideoInputConnection, conn) == S_OK) {
//fprintf(stderr, "Input set to: %d\n", vinput);
//}
result = deckLinkConfiguration->GetInt(bmdDeckLinkConfigVideoInputConnection, &vport);
if (vport == bmdVideoConnectionSDI)
fprintf(stderr, "After Input configured for SDI\n");
if (vport == bmdVideoConnectionHDMI)
fprintf(stderr, "After Input configured for HDMI\n");
result = deckLinkInput->EnableVideoInput(selectedDisplayMode, pixelFormat, inputFlags);
if(result != S_OK)
{
fprintf(stderr, "Failed to enable video input. Is another application using the card?\n");
return -1;
}
displayWidth = displayMode->GetWidth();
displayHeight = displayMode->GetHeight();
displayMode->GetFrameRate(&frameRateDuration, &frameRateScale);
displayFPS = (double)frameRateScale / (double)frameRateDuration;
//set to delegate
delegate->setWidth(displayWidth);
delegate->setHeight(displayHeight);
delegate->setFPS(displayFPS);
delegate->setFrameRateDuration(frameRateDuration);
delegate->setFrameRateScale(frameRateScale);
//set texture width and height
glWidget->setTextureWidth(displayWidth);
glWidget->setTextureHeight(displayHeight);
glWidget->initBuffer();
fprintf(stderr, "GetFrameRate: %10ld %10ld --> fps %g\n", (long)frameRateScale, (long)frameRateDuration, displayFPS);
result = deckLinkInput->StartStreams();
if(result != S_OK){
fprintf(stderr, "Cannot start streams...\n");
return -1;
}
fprintf(stderr, "Finish procesing arguments \n");
}
DeckLinkCapture::DeckLinkCapture(IDeckLink *card, int card_index)
: card_index(card_index)
{
{
const char *model_name;
char buf[256];
if (card->GetModelName(&model_name) == S_OK) {
snprintf(buf, sizeof(buf), "PCI card %d: %s", card_index, model_name);
} else {
snprintf(buf, sizeof(buf), "PCI card %d: Unknown DeckLink card", card_index);
}
description = buf;
}
if (card->QueryInterface(IID_IDeckLinkInput, (void**)&input) != S_OK) {
fprintf(stderr, "Card %d has no inputs\n", card_index);
exit(1);
}
IDeckLinkAttributes *attr;
if (card->QueryInterface(IID_IDeckLinkAttributes, (void**)&attr) != S_OK) {
fprintf(stderr, "Card %d has no attributes\n", card_index);
exit(1);
}
// Get the list of available video inputs.
int64_t video_input_mask;
if (attr->GetInt(BMDDeckLinkVideoInputConnections, &video_input_mask) != S_OK) {
fprintf(stderr, "Failed to enumerate video inputs for card %d\n", card_index);
exit(1);
}
const vector<pair<BMDVideoConnection, string>> video_input_types = {
{ bmdVideoConnectionSDI, "SDI" },
{ bmdVideoConnectionHDMI, "HDMI" },
{ bmdVideoConnectionOpticalSDI, "Optical SDI" },
{ bmdVideoConnectionComponent, "Component" },
{ bmdVideoConnectionComposite, "Composite" },
{ bmdVideoConnectionSVideo, "S-Video" }
};
for (const auto &video_input : video_input_types) {
if (video_input_mask & video_input.first) {
video_inputs.emplace(video_input.first, video_input.second);
}
}
// And then the available audio inputs.
int64_t audio_input_mask;
if (attr->GetInt(BMDDeckLinkAudioInputConnections, &audio_input_mask) != S_OK) {
fprintf(stderr, "Failed to enumerate audio inputs for card %d\n", card_index);
exit(1);
}
const vector<pair<BMDAudioConnection, string>> audio_input_types = {
{ bmdAudioConnectionEmbedded, "Embedded" },
{ bmdAudioConnectionAESEBU, "AES/EBU" },
{ bmdAudioConnectionAnalog, "Analog" },
{ bmdAudioConnectionAnalogXLR, "Analog XLR" },
{ bmdAudioConnectionAnalogRCA, "Analog RCA" },
{ bmdAudioConnectionMicrophone, "Microphone" },
{ bmdAudioConnectionHeadphones, "Headphones" }
};
for (const auto &audio_input : audio_input_types) {
if (audio_input_mask & audio_input.first) {
audio_inputs.emplace(audio_input.first, audio_input.second);
}
}
attr->Release();
/* Set up the video and audio sources. */
if (card->QueryInterface(IID_IDeckLinkConfiguration, (void**)&config) != S_OK) {
fprintf(stderr, "Failed to get configuration interface for card %d\n", card_index);
exit(1);
}
set_video_input(bmdVideoConnectionHDMI);
set_audio_input(bmdAudioConnectionEmbedded);
IDeckLinkDisplayModeIterator *mode_it;
if (input->GetDisplayModeIterator(&mode_it) != S_OK) {
fprintf(stderr, "Failed to enumerate display modes for card %d\n", card_index);
exit(1);
}
for (IDeckLinkDisplayMode *mode_ptr; mode_it->Next(&mode_ptr) == S_OK; mode_ptr->Release()) {
VideoMode mode;
const char *mode_name;
if (mode_ptr->GetName(&mode_name) != S_OK) {
mode.name = "Unknown mode";
} else {
mode.name = mode_name;
}
mode.autodetect = false;
mode.width = mode_ptr->GetWidth();
mode.height = mode_ptr->GetHeight();
BMDTimeScale frame_rate_num;
BMDTimeValue frame_rate_den;
if (mode_ptr->GetFrameRate(&frame_rate_den, &frame_rate_num) != S_OK) {
fprintf(stderr, "Could not get frame rate for mode '%s' on card %d\n", mode.name.c_str(), card_index);
exit(1);
}
mode.frame_rate_num = frame_rate_num;
mode.frame_rate_den = frame_rate_den;
// TODO: Respect the TFF/BFF flag.
mode.interlaced = (mode_ptr->GetFieldDominance() == bmdLowerFieldFirst || mode_ptr->GetFieldDominance() == bmdUpperFieldFirst);
uint32_t id = mode_ptr->GetDisplayMode();
video_modes.insert(make_pair(id, mode));
}
set_video_mode_no_restart(bmdModeHD720p5994);
if (input->EnableAudioInput(48000, bmdAudioSampleType32bitInteger, 2) != S_OK) {
fprintf(stderr, "Failed to enable audio input for card %d\n", card_index);
exit(1);
}
input->SetCallback(this);
}
void print_attributes (IDeckLink* deckLink)
{
IDeckLinkAttributes* deckLinkAttributes = NULL;
bool supported;
int64_t value;
char * serialPortName = NULL;
HRESULT result;
// Query the DeckLink for its attributes interface
result = deckLink->QueryInterface(IID_IDeckLinkAttributes, (void**)&deckLinkAttributes);
if (result != S_OK)
{
fprintf(stderr, "Could not obtain the IDeckLinkAttributes interface - result = %08x\n", result);
goto bail;
}
// List attributes and their value
printf("Attribute list:\n");
result = deckLinkAttributes->GetFlag(BMDDeckLinkHasSerialPort, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Serial port present ?", (supported == true) ? "Yes" : "No");
if (supported)
{
result = deckLinkAttributes->GetString(BMDDeckLinkSerialPortDeviceName, (const char **) &serialPortName);
if (result == S_OK)
{
printf(" %-40s %s\n", "Serial port name: ", serialPortName);
free(serialPortName);
}
else
{
fprintf(stderr, "Could not query the serial port presence attribute- result = %08x\n", result);
}
}
}
else
{
fprintf(stderr, "Could not query the serial port presence attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetInt(BMDDeckLinkPersistentID, &value);
if (result == S_OK)
{
printf(" %-40s %llx\n", "Device Persistent ID:", value);
}
else
{
printf(" %-40s %s\n", "Device Persistent ID:", "Not Supported on this device");
}
result = deckLinkAttributes->GetInt(BMDDeckLinkTopologicalID, &value);
if (result == S_OK)
{
printf(" %-40s %llx\n", "Device Topological ID:", value);
}
else
{
printf(" %-40s %s\n", "Device Topological ID:", "Not Supported on this device");
}
result = deckLinkAttributes->GetInt(BMDDeckLinkNumberOfSubDevices, &value);
if (result == S_OK)
{
printf(" %-40s %" PRId64 "\n", "Number of sub-devices:", value);
if (value != 0)
{
result = deckLinkAttributes->GetInt(BMDDeckLinkSubDeviceIndex, &value);
if (result == S_OK)
{
printf(" %-40s %" PRId64 "\n", "Sub-device index:", value);
}
else
{
fprintf(stderr, "Could not query the sub-device index attribute- result = %08x\n", result);
}
}
}
else
{
fprintf(stderr, "Could not query the number of sub-device attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetInt(BMDDeckLinkMaximumAudioChannels, &value);
if (result == S_OK)
{
printf(" %-40s %" PRId64 "\n", "Number of audio channels:", value);
}
else
{
fprintf(stderr, "Could not query the number of supported audio channels attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInputFormatDetection, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Input mode detection supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the input mode detection attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsFullDuplex, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Full duplex operation supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the full duplex operation supported attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "Internal keying supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the internal keying attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsExternalKeying, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "External keying supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the external keying attribute- result = %08x\n", result);
}
result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsHDKeying, &supported);
if (result == S_OK)
{
printf(" %-40s %s\n", "HD-mode keying supported ?", (supported == true) ? "Yes" : "No");
}
else
{
fprintf(stderr, "Could not query the HD-mode keying attribute- result = %08x\n", result);
}
bail:
printf("\n");
if(deckLinkAttributes != NULL)
deckLinkAttributes->Release();
}