int krad_decklink_cpp_detect_devices () { IDeckLinkIterator *deckLinkIterator; IDeckLink *deckLink; int device_count; //HRESULT result; device_count = 0; deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { printke ("krad_decklink_detect_devices: The DeckLink drivers may not be installed."); return 0; } while (deckLinkIterator->Next(&deckLink) == S_OK) { device_count++; deckLink->Release(); } deckLinkIterator->Release(); return device_count; }
bool DeckLinkController::init() { IDeckLinkIterator* deckLinkIterator = NULL; IDeckLink* deckLink = NULL; bool result = false; // Create an iterator deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { ofLogError("DeckLinkController") << "Please install the Blackmagic Desktop Video drivers to use the features of this application."; goto bail; } // List all DeckLink devices while (deckLinkIterator->Next(&deckLink) == S_OK) { // Add device to the device list deviceList.push_back(deckLink); } if (deviceList.size() == 0) { ofLogError("DeckLinkController") << "You will not be able to use the features of this application until a Blackmagic device is installed."; goto bail; } result = true; bail: if (deckLinkIterator != NULL) { deckLinkIterator->Release(); deckLinkIterator = NULL; } return result; }
// // Get a list of the names of the cards // int dl_list_devices( CaptureCardList *cards ){ IDeckLinkIterator* deckLinkIterator; IDeckLink* deckLink; int numDevices = 0; HRESULT result; // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { //fprintf(stderr, "A DeckLink iterator could not be created. The DeckLink drivers may not be installed.\n"); return 0; } while (deckLinkIterator->Next(&deckLink) == S_OK) { char * deviceNameString = NULL; // *** Print the model name of the DeckLink card result = deckLink->GetModelName((const char **) &deviceNameString); if (result == S_OK){ if(numDevices < MAX_CAPTURE_LIST_ITEMS){ strcpy(cards->item[numDevices],deviceNameString); } numDevices++; free(deviceNameString); } // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); cards->items = numDevices; return numDevices; }
int old_main (int argc, char** argv) { IDeckLinkIterator* deckLinkIterator; IDeckLink* deckLink; int numDevices = 0; HRESULT result; // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { fprintf(stderr, "A DeckLink iterator could not be created. The DeckLink drivers may not be installed.\n"); return 1; } // Enumerate all cards in this system while (deckLinkIterator->Next(&deckLink) == S_OK) { char * deviceNameString = NULL; // Increment the total number of DeckLink cards found numDevices++; if (numDevices > 1) printf("\n\n"); // *** Print the model name of the DeckLink card result = deckLink->GetModelName((const char **) &deviceNameString); if (result == S_OK) { printf("=============== %s ===============\n\n", deviceNameString); free(deviceNameString); } print_attributes(deckLink); // ** List the video output display modes supported by the card print_output_modes(deckLink); // ** List the video input display modes supported by the card print_input_modes(deckLink); // ** List the input and output capabilities of the card print_capabilities(deckLink); // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); // If no DeckLink cards were found in the system, inform the user if (numDevices == 0) printf("No Blackmagic Design devices were found.\n"); printf("\n"); return 0; }
bool open( unsigned card = 0 ) { IDeckLinkIterator* deckLinkIterator = CreateDeckLinkIteratorInstance(); unsigned i = 0; if ( !deckLinkIterator ) { mlt_log_verbose( NULL, "The DeckLink drivers not installed.\n" ); return false; } // Connect to the Nth DeckLink instance do { if ( deckLinkIterator->Next( &m_deckLink ) != S_OK ) { mlt_log_verbose( NULL, "DeckLink card not found\n" ); deckLinkIterator->Release(); return false; } } while ( ++i <= card ); // Obtain the audio/video output interface (IDeckLinkOutput) if ( m_deckLink->QueryInterface( IID_IDeckLinkOutput, (void**)&m_deckLinkOutput ) != S_OK ) { mlt_log_verbose( NULL, "No DeckLink cards support output\n" ); m_deckLink->Release(); m_deckLink = 0; deckLinkIterator->Release(); return false; } // Provide this class as a delegate to the audio and video output interfaces m_deckLinkOutput->SetScheduledFrameCompletionCallback( this ); m_deckLinkOutput->SetAudioCallback( this ); pthread_mutex_init( &m_mutex, NULL ); pthread_cond_init( &m_condition, NULL ); m_maxAudioBuffer = bmdAudioSampleRate48kHz; m_videoFrameQ = mlt_deque_init(); return true; }
bool BMDOpenGLOutput::InitDeckLink() { bool bSuccess = FALSE; IDeckLinkIterator* pDLIterator = NULL; pDLIterator = CreateDeckLinkIteratorInstance(); if (pDLIterator == NULL) { QMessageBox::critical(NULL,"This application requires the DeckLink drivers installed.", "Please install the Blackmagic DeckLink drivers to use the features of this application."); goto error; } if (pDLIterator->Next(&pDL) != S_OK) { QMessageBox::critical(NULL,"This application requires a DeckLink device.", "You will not be able to use the features of this application until a DeckLink device is installed."); goto error; } if (pDL->QueryInterface(IID_IDeckLinkOutput, (void**)&pDLOutput) != S_OK) goto error; pRenderDelegate = new RenderDelegate(this); if (pRenderDelegate == NULL) goto error; if (pDLOutput->SetScheduledFrameCompletionCallback(pRenderDelegate) != S_OK) goto error; bSuccess = TRUE; error: if (!bSuccess) { if (pDLOutput != NULL) { pDLOutput->Release(); pDLOutput = NULL; } if (pDL != NULL) { pDL->Release(); pDL = NULL; } } if (pDLIterator != NULL) { pDLIterator->Release(); pDLIterator = NULL; } return bSuccess; }
static void init_devices (void) { IDeckLinkIterator *iterator; IDeckLink *decklink = NULL; HRESULT ret; int i; static gboolean inited = FALSE; if (inited) return; inited = TRUE; iterator = CreateDeckLinkIteratorInstance (); if (iterator == NULL) { GST_ERROR ("no driver"); return; } i = 0; ret = iterator->Next (&decklink); while (ret == S_OK) { devices[i].decklink = decklink; ret = decklink->QueryInterface (IID_IDeckLinkInput, (void **) &devices[i].input); if (ret != S_OK) { GST_WARNING ("selected device does not have input interface"); } ret = decklink->QueryInterface (IID_IDeckLinkOutput, (void **) &devices[i].output); if (ret != S_OK) { GST_WARNING ("selected device does not have output interface"); } ret = decklink->QueryInterface (IID_IDeckLinkConfiguration, (void **) &devices[i].config); if (ret != S_OK) { GST_WARNING ("selected device does not have config interface"); } ret = iterator->Next (&decklink); i++; if (i == 10) { GST_WARNING ("this hardware has more then 10 devices"); break; } } n_devices = i; iterator->Release(); }
vector<ofVideoDevice> ofxBlackmagicGrabber::listDevices() { IDeckLinkIterator* deckLinkIterator; IDeckLink* deckLink; int numDevices = 0; HRESULT result; vector<ofVideoDevice> devices; // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL){ ofLogError(LOG_NAME) << "A DeckLink iterator could not be created. The DeckLink drivers may not be installed."; } // Enumerate all cards in this system while (deckLinkIterator->Next(&deckLink) == S_OK){ CFStringRef deviceNameString; // Increment the total number of DeckLink cards found numDevices++; if (numDevices > 1) printf("\n\n"); // *** Print the model name of the DeckLink card result = deckLink->GetModelName(&deviceNameString); if (result == S_OK) { printf("=============== %s ===============\n\n", deviceNameString); // free(deviceNameString); } print_attributes(deckLink); // ** List the video output display modes supported by the card print_output_modes(deckLink); // ** List the input and output capabilities of the card print_capabilities(deckLink); // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); // If no DeckLink cards were found in the system, inform the user if (numDevices == 0) ofLogError(LOG_NAME) << "No Blackmagic Design devices were found."; return devices; }
static void gst_decklinksrc_class_probe_devices (GstElementClass * klass) { IDeckLinkIterator *iterator; IDeckLink *decklink; n_devices = 0; iterator = CreateDeckLinkIteratorInstance (); if (iterator) { while (iterator->Next (&decklink) == S_OK) { n_devices++; } } iterator->Release(); probed = TRUE; }
/* former device probe code, redux */ static void gst_decklinksrc_list_devices (void) { IDeckLinkIterator *iterator; IDeckLink *decklink; int n_devices; n_devices = 0; iterator = CreateDeckLinkIteratorInstance (); if (iterator) { while (iterator->Next (&decklink) == S_OK) { n_devices++; } } iterator->Release(); g_print ("%d devices\n", n_devices); }
QStringList BMDOutputDelegate::enumDeviceNames(bool forceReload) { if(!s_knownDevices.isEmpty()) { if(!forceReload) return s_knownDevices; else s_knownDevices.clear(); } IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { fprintf(stderr, "BMDCaptureDelegate::enumDeviceNames: A DeckLink iterator could not be created. The DeckLink drivers may not be installed.\n"); return QStringList(); } IDeckLink *deckLink; IDeckLinkInput *deckLinkOutput; int index = 0; // Enumerate all cards in this system while (deckLinkIterator->Next(&deckLink) == S_OK) { if (deckLink->QueryInterface(IID_IDeckLinkOutput, (void**)&deckLinkOutput) == S_OK) { s_knownDevices << QString("bmd:%1").arg(index); deckLinkOutput->Release(); deckLinkOutput = NULL; } index ++; // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); return s_knownDevices; }
int ff_decklink_list_devices(AVFormatContext *avctx) { IDeckLink *dl = NULL; IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance(); if (!iter) { av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n"); return AVERROR(EIO); } av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink devices:\n"); while (iter->Next(&dl) == S_OK) { const char *displayName; ff_decklink_get_display_name(dl, &displayName); av_log(avctx, AV_LOG_INFO, "\t'%s'\n", displayName); av_free((void *) displayName); dl->Release(); } iter->Release(); return 0; }
int ff_decklink_init_device(AVFormatContext *avctx, const char* name) { struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data; struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx; IDeckLink *dl = NULL; IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance(); if (!iter) { av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n"); return AVERROR_EXTERNAL; } while (iter->Next(&dl) == S_OK) { const char *displayName; ff_decklink_get_display_name(dl, &displayName); if (!strcmp(name, displayName)) { av_free((void *)displayName); ctx->dl = dl; break; } av_free((void *)displayName); dl->Release(); } iter->Release(); if (!ctx->dl) return AVERROR(ENXIO); if (ctx->dl->QueryInterface(IID_IDeckLinkConfiguration, (void **)&ctx->cfg) != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not get configuration interface for '%s'\n", name); ff_decklink_cleanup(avctx); return AVERROR_EXTERNAL; } if (ctx->dl->QueryInterface(IID_IDeckLinkAttributes, (void **)&ctx->attr) != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not get attributes interface for '%s'\n", name); ff_decklink_cleanup(avctx); return AVERROR_EXTERNAL; } return 0; }
IDeckLink* BMDConfig::GetDeckLink(int idx) { HRESULT result; IDeckLink* deckLink; IDeckLinkIterator* deckLinkIterator = CreateDeckLinkIteratorInstance(); int i = idx; while((result = deckLinkIterator->Next(&deckLink)) == S_OK) { if (i == 0) break; --i; deckLink->Release(); } deckLinkIterator->Release(); if (result != S_OK) return NULL; return deckLink; }
IDeckLink *getFirstDeckLinkCard() { IDeckLink *deckLink = NULL; IDeckLinkIterator *deckLinkIter = CreateDeckLinkIteratorInstance(); if (deckLinkIter) { // get the first decklink card if (deckLinkIter->Next(&deckLink) != S_OK) { printf("Could not detect a DeckLink card\n"); } deckLinkIter->Release(); } else { printf("Could not enumerate DeckLink cards\n"); } return deckLink; }
BMDOutputDelegate *BMDOutputDelegate::openDevice(QString deviceName) { if(enumDeviceNames().indexOf(deviceName) < 0) return 0; QString name = deviceName.replace("bmd:",""); int cardNum = name.toInt(); IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { qDebug() << "BMDOutputDelegate::openDevice: A DeckLink iterator could not be created. The DeckLink drivers may not be installed."; return 0; } int index = 0; IDeckLink* deckLink; // Find the card requested while (deckLinkIterator->Next(&deckLink) == S_OK) { if(index == cardNum) return new BMDOutputDelegate(deckLink); index ++; // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); return 0; }
void krad_decklink_capture_info () { IDeckLink *deckLink; IDeckLinkInput *deckLinkInput; IDeckLinkIterator *deckLinkIterator; IDeckLinkDisplayModeIterator *displayModeIterator; IDeckLinkDisplayMode *displayMode; HRESULT result; int displayModeCount; char *displayModeString; displayModeString = NULL; displayModeCount = 0; deckLinkIterator = CreateDeckLinkIteratorInstance(); if (!deckLinkIterator) { printke ("Krad Decklink: This application requires the DeckLink drivers installed.\n"); } /* Connect to the first DeckLink instance */ result = deckLinkIterator->Next(&deckLink); if (result != S_OK) { printke ("Krad Decklink: No DeckLink PCI cards found.\n"); } result = deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput); if (result != S_OK) { printke ("Krad Decklink: Fail QueryInterface\n"); } result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator); if (result != S_OK) { printke ("Krad Decklink: Could not obtain the video output display mode iterator - result = %08x\n", result); } while (displayModeIterator->Next(&displayMode) == S_OK) { result = displayMode->GetName((const char **) &displayModeString); if (result == S_OK) { BMDTimeValue frameRateDuration, frameRateScale; displayMode->GetFrameRate(&frameRateDuration, &frameRateScale); printkd ("%2d: %-20s \t %li x %li \t %g FPS\n", displayModeCount, displayModeString, displayMode->GetWidth(), displayMode->GetHeight(), (double)frameRateScale / (double)frameRateDuration); free (displayModeString); displayModeCount++; } displayMode->Release(); } if (displayModeIterator != NULL) { displayModeIterator->Release(); displayModeIterator = NULL; } if (deckLinkInput != NULL) { deckLinkInput->Release(); deckLinkInput = NULL; } if (deckLink != NULL) { deckLink->Release(); deckLink = NULL; } if (deckLinkIterator != NULL) { deckLinkIterator->Release(); } }
int main(int argc, char *argv[]) { IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance(); DeckLinkCaptureDelegate *delegate; BMDDisplayMode selectedDisplayMode = bmdModeNTSC; int displayModeCount = 0; int exitStatus = 1; int aconnection = 0, vconnection = 0, camera = 0, i = 0; int ch; AVDictionary *opts = NULL; BMDPixelFormat pix = bmdFormat8BitYUV; HRESULT result; pthread_t th; pthread_mutex_init(&sleepMutex, NULL); pthread_cond_init(&sleepCond, NULL); av_register_all(); if (!deckLinkIterator) { fprintf(stderr, "This application requires the DeckLink drivers installed.\n"); goto bail; } // Parse command line options while ((ch = getopt(argc, argv, "?hvc:s:f:a:m:n:p:M:F:C:A:V:o:")) != -1) { switch (ch) { case 'v': g_verbose = true; break; case 'm': g_videoModeIndex = atoi(optarg); break; case 'c': g_audioChannels = atoi(optarg); if (g_audioChannels != 2 && g_audioChannels != 8 && g_audioChannels != 16) { fprintf( stderr, "Invalid argument: Audio Channels must be either 2, 8 or 16\n"); goto bail; } break; case 's': g_audioSampleDepth = atoi(optarg); switch (g_audioSampleDepth) { case 16: sample_fmt = AV_SAMPLE_FMT_S16; break; case 32: sample_fmt = AV_SAMPLE_FMT_S32; break; default: fprintf(stderr, "Invalid argument:" " Audio Sample Depth must be either 16 bits" " or 32 bits\n"); goto bail; } break; case 'p': switch (atoi(optarg)) { case 8: pix = bmdFormat8BitYUV; pix_fmt = PIX_FMT_UYVY422; break; case 10: pix = bmdFormat10BitYUV; pix_fmt = PIX_FMT_YUV422P10; break; default: fprintf( stderr, "Invalid argument: Pixel Format Depth must be either 8 bits or 10 bits\n"); goto bail; } break; case 'f': g_videoOutputFile = optarg; break; case 'n': g_maxFrames = atoi(optarg); break; case 'M': g_memoryLimit = atoi(optarg) * 1024 * 1024 * 1024L; break; case 'F': fmt = av_guess_format(optarg, NULL, NULL); break; case 'A': aconnection = atoi(optarg); break; case 'V': vconnection = atoi(optarg); break; case 'C': camera = atoi(optarg); break; case 'S': serial_fd = open(optarg, O_RDWR | O_NONBLOCK); break; case 'o': if (av_dict_parse_string(&opts, optarg, "=", ":", 0) < 0) { fprintf(stderr, "Cannot parse option string %s\n", optarg); goto bail; } case '?': case 'h': usage(0); } } /* Connect to the first DeckLink instance */ do result = deckLinkIterator->Next(&deckLink); while (i++ < camera); if (result != S_OK) { fprintf(stderr, "No DeckLink PCI cards found.\n"); goto bail; } if (deckLink->QueryInterface(IID_IDeckLinkInput, (void **)&deckLinkInput) != S_OK) { goto bail; } result = deckLink->QueryInterface(IID_IDeckLinkConfiguration, (void **)&deckLinkConfiguration); if (result != S_OK) { fprintf( stderr, "Could not obtain the IDeckLinkConfiguration interface - result = %08x\n", result); goto bail; } result = S_OK; switch (aconnection) { case 1: result = DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionAnalog); break; case 2: result = DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionEmbedded); break; case 3: result = DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionAESEBU); break; default: // do not change it break; } if (result != S_OK) { fprintf(stderr, "Failed to set audio input - result = %08x\n", result); goto bail; } result = S_OK; switch (vconnection) { case 1: result = DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionComposite); break; case 2: result = DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionComponent); break; case 3: result = DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionHDMI); break; case 4: result = DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionSDI); break; case 5: result = DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionOpticalSDI); break; case 6: result = DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionSVideo); break; default: // do not change it break; } if (result != S_OK) { fprintf(stderr, "Failed to set video input - result %08x\n", result); goto bail; } delegate = new DeckLinkCaptureDelegate(); 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); goto bail; } if (!g_videoOutputFile) { fprintf(stderr, "Missing argument: Please specify output path using -f\n"); goto bail; } if (!fmt) { fmt = av_guess_format(NULL, g_videoOutputFile, NULL); if (!fmt) { fprintf( stderr, "Unable to guess output format, please specify explicitly using -F\n"); goto bail; } } if (g_videoModeIndex < 0) { fprintf(stderr, "No video mode specified\n"); usage(0); } selectedDisplayMode = -1; while (displayModeIterator->Next(&displayMode) == S_OK) { if (g_videoModeIndex == displayModeCount) { selectedDisplayMode = displayMode->GetDisplayMode(); break; } displayModeCount++; displayMode->Release(); } if (selectedDisplayMode < 0) { fprintf(stderr, "Invalid mode %d specified\n", g_videoModeIndex); goto bail; } result = deckLinkInput->EnableVideoInput(selectedDisplayMode, pix, 0); if (result != S_OK) { fprintf(stderr, "Failed to enable video input. Is another application using " "the card?\n"); goto bail; } result = deckLinkInput->EnableAudioInput(bmdAudioSampleRate48kHz, g_audioSampleDepth, g_audioChannels); if (result != S_OK) { fprintf(stderr, "Failed to enable audio input. Is another application using " "the card?\n"); goto bail; } oc = avformat_alloc_context(); oc->oformat = fmt; snprintf(oc->filename, sizeof(oc->filename), "%s", g_videoOutputFile); fmt->video_codec = (pix == bmdFormat8BitYUV ? AV_CODEC_ID_RAWVIDEO : AV_CODEC_ID_V210); fmt->audio_codec = (sample_fmt == AV_SAMPLE_FMT_S16 ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_S32LE); video_st = add_video_stream(oc, fmt->video_codec); audio_st = add_audio_stream(oc, fmt->audio_codec); if (serial_fd > 0) data_st = add_data_stream(oc, AV_CODEC_ID_TEXT); if (!(fmt->flags & AVFMT_NOFILE)) { if (avio_open(&oc->pb, oc->filename, AVIO_FLAG_WRITE) < 0) { fprintf(stderr, "Could not open '%s'\n", oc->filename); exit(1); } } avformat_write_header(oc, NULL); avpacket_queue_init(&queue); result = deckLinkInput->StartStreams(); if (result != S_OK) { goto bail; } // All Okay. exitStatus = 0; if (pthread_create(&th, NULL, push_packet, oc)) goto bail; // Block main thread until signal occurs pthread_mutex_lock(&sleepMutex); pthread_cond_wait(&sleepCond, &sleepMutex); pthread_mutex_unlock(&sleepMutex); deckLinkInput->StopStreams(); fprintf(stderr, "Stopping Capture\n"); avpacket_queue_end(&queue); bail: if (displayModeIterator != NULL) { displayModeIterator->Release(); displayModeIterator = NULL; } if (deckLinkInput != NULL) { deckLinkInput->Release(); deckLinkInput = NULL; } if (deckLink != NULL) { deckLink->Release(); deckLink = NULL; } if (deckLinkIterator != NULL) { deckLinkIterator->Release(); } if (oc != NULL) { av_write_trailer(oc); if (!(fmt->flags & AVFMT_NOFILE)) { /* close the output file */ avio_close(oc->pb); } } return exitStatus; }
int usage(int status) { HRESULT result; IDeckLinkIterator *deckLinkIterator; IDeckLink *deckLink; int numDevices = 0; // int displayModeCount = 0; fprintf(stderr, "Usage: bmdcapture -m <mode id> [OPTIONS]\n" "\n" " -m <mode id>:\n" ); // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { fprintf( stderr, "A DeckLink iterator could not be created. The DeckLink drivers may not be installed.\n"); return 1; } // Enumerate all cards in this system while (deckLinkIterator->Next(&deckLink) == S_OK) { BMDProbeString str; // Increment the total number of DeckLink cards found numDevices++; if (numDevices > 1) { printf("\n\n"); } // *** Print the model name of the DeckLink card result = deckLink->GetModelName(&str); if (result == S_OK) { printf("-> %s (-C %d )\n\n", ToStr(str), numDevices - 1); FreeStr(str); } print_output_modes(deckLink); // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); // If no DeckLink cards were found in the system, inform the user if (numDevices == 0) { printf("No Blackmagic Design devices were found.\n"); } printf("\n"); /* * if (displayModeIterator) * { * // we try to print out some useful information about the chosen * // card, but this only works if a card has been selected successfully * * while (displayModeIterator->Next(&displayMode) == S_OK) * { * char * displayModeString = NULL; * * result = displayMode->GetName((const char **) &displayModeString); * if (result == S_OK) * { * BMDTimeValue frameRateDuration, frameRateScale; * displayMode->GetFrameRate(&frameRateDuration, &frameRateScale); * fprintf(stderr, " %2d: %-20s \t %li x %li \t %g FPS\n", * displayModeCount, displayModeString, displayMode->GetWidth(), displayMode->GetHeight(), (double)frameRateScale / (double)frameRateDuration); * free(displayModeString); * displayModeCount++; * } * * // Release the IDeckLinkDisplayMode object to prevent a leak * displayMode->Release(); * } * } */ fprintf( stderr, " -v Be verbose (report each 25 frames)\n" " -f <filename> Filename raw video will be written to\n" " -F <format> Define the file format to be used\n" " -c <channels> Audio Channels (2, 8 or 16 - default is 2)\n" " -s <depth> Audio Sample Depth (16 or 32 - default is 16)\n" " -p <pixel> PixelFormat Depth (8 or 10 - default is 8)\n" " -n <frames> Number of frames to capture (default is unlimited)\n" " -M <memlimit> Maximum queue size in GB (default is 1 GB)\n" " -C <num> number of card to be used\n" " -S <serial_device> data input serial\n" " -A <audio-in> Audio input:\n" " 1: Analog (RCA or XLR)\n" " 2: Embedded Audio (HDMI/SDI)\n" " 3: Digital Audio (AES/EBU)\n" " -V <video-in> Video input:\n" " 1: Composite\n" " 2: Component\n" " 3: HDMI\n" " 4: SDI\n" " 5: Optical SDI\n" " 6: S-Video\n" " -o <optionstring> AVFormat options\n" "Capture video and audio to a file. Raw video and audio can be sent to a pipe to avconv or vlc e.g.:\n" "\n" " bmdcapture -m 2 -A 1 -V 1 -F nut -f pipe:1\n\n\n" ); exit(status); }
bool OpenGLComposite::InitDeckLink() { bool bSuccess = false; IDeckLinkIterator* pDLIterator = NULL; IDeckLink* pDL = NULL; IDeckLinkDisplayModeIterator* pDLDisplayModeIterator = NULL; IDeckLinkDisplayMode* pDLDisplayMode = NULL; BMDDisplayMode displayMode = bmdModeHD1080i5994; // mode to use for capture and playout float fps; HRESULT result; 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) { // Use first board found as capture device, second board will be playout device if (! mDLInput) { if (pDL->QueryInterface(IID_IDeckLinkInput, (void**)&mDLInput) != S_OK) goto error; } else if (! mDLOutput) { if (pDL->QueryInterface(IID_IDeckLinkOutput, (void**)&mDLOutput) != S_OK) goto error; } } if (! mDLOutput || ! mDLInput) { MessageBox(NULL, _T("Expected both Input and Output DeckLink devices"), _T("This application requires two DeckLink devices."), MB_OK); goto error; } if (mDLOutput->GetDisplayModeIterator(&pDLDisplayModeIterator) != S_OK) { MessageBox(NULL, _T("Cannot get Display Mode Iterator."), _T("DeckLink error."), MB_OK); goto error; } while (pDLDisplayModeIterator->Next(&pDLDisplayMode) == S_OK) { if (pDLDisplayMode->GetDisplayMode() == displayMode) break; pDLDisplayMode->Release(); pDLDisplayMode = NULL; } pDLDisplayModeIterator->Release(); if (pDLDisplayMode == NULL) { MessageBox(NULL, _T("Cannot get specified BMDDisplayMode."), _T("DeckLink error."), MB_OK); goto error; } mFrameWidth = pDLDisplayMode->GetWidth(); mFrameHeight = pDLDisplayMode->GetHeight(); if (! CheckOpenGLExtensions()) goto error; if (! InitOpenGLState()) goto error; // Compute a rotate angle rate so box will spin at a rate independent of video mode frame rate pDLDisplayMode->GetFrameRate(&mFrameDuration, &mFrameTimescale); fps = (float)mFrameTimescale / (float)mFrameDuration; mRotateAngleRate = 35.0f / fps; // rotate box through 35 degrees every second // Resize window to match video frame, but scale large formats down by half for viewing if (mFrameWidth < 1920) resizeWindow(mFrameWidth, mFrameHeight); else resizeWindow(mFrameWidth / 2, mFrameHeight / 2); if (mFastTransferExtensionAvailable) { // Initialize fast video frame transfers if (! VideoFrameTransfer::initialize(mFrameWidth, mFrameHeight, mCaptureTexture, mFBOTexture)) { MessageBox(NULL, _T("Cannot initialize video transfers."), _T("VideoFrameTransfer error."), MB_OK); goto error; } } // Capture will use a user-supplied frame memory allocator mCaptureAllocator = new PinnedMemoryAllocator(hGLDC, hGLRC, VideoFrameTransfer::CPUtoGPU, 3); if (mDLInput->SetVideoInputFrameMemoryAllocator(mCaptureAllocator) != S_OK) goto error; if (mDLInput->EnableVideoInput(displayMode, bmdFormat8BitYUV, bmdVideoInputFlagDefault) != S_OK) goto error; mCaptureDelegate = new CaptureDelegate(this); if (mDLInput->SetCallback(mCaptureDelegate) != S_OK) goto error; // Playout will use a user-supplied frame memory allocator mPlayoutAllocator = new PinnedMemoryAllocator(hGLDC, hGLRC, VideoFrameTransfer::GPUtoCPU, 1); if (mDLOutput->SetVideoOutputFrameMemoryAllocator(mPlayoutAllocator) != S_OK) goto error; if (mDLOutput->EnableVideoOutput(displayMode, bmdVideoOutputFlagDefault) != S_OK) goto error; // 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; if (mDLOutput->CreateVideoFrame(mFrameWidth, mFrameHeight, mFrameWidth*4, bmdFormat8BitBGRA, bmdFrameFlagFlipVertical, &outputFrame) != S_OK) goto error; mDLOutputVideoFrameQueue.push_back(outputFrame); } mPlayoutDelegate = new PlayoutDelegate(this); if (mPlayoutDelegate == NULL) goto error; if (mDLOutput->SetScheduledFrameCompletionCallback(mPlayoutDelegate) != S_OK) goto error; bSuccess = true; error: if (!bSuccess) { if (mDLInput != NULL) { mDLInput->Release(); mDLInput = NULL; } if (mDLOutput != NULL) { mDLOutput->Release(); mDLOutput = NULL; } } if (pDL != NULL) { pDL->Release(); pDL = NULL; } if (pDLIterator != NULL) { pDLIterator->Release(); pDLIterator = NULL; } return bSuccess; }
int main(int argc, char *argv[]) { IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance(); DeckLinkCaptureDelegate *delegate; BMDDisplayMode selectedDisplayMode = bmdModeNTSC; int displayModeCount = 0; int exitStatus = 1; int connection = 0, camera = 0, i=0; int ch; HRESULT result; pthread_mutex_init(&sleepMutex, NULL); pthread_cond_init(&sleepCond, NULL); av_register_all(); if (!deckLinkIterator) { fprintf(stderr, "This application requires the DeckLink drivers installed.\n"); goto bail; } // Parse command line options while ((ch = getopt(argc, argv, "?hc:s:f:a:m:n:F:C:I:")) != -1) { switch (ch) { case 'm': g_videoModeIndex = atoi(optarg); break; case 'c': g_audioChannels = atoi(optarg); if (g_audioChannels != 2 && g_audioChannels != 8 && g_audioChannels != 16) { fprintf(stderr, "Invalid argument: Audio Channels must be either 2, 8 or 16\n"); goto bail; } break; case 's': g_audioSampleDepth = atoi(optarg); if (g_audioSampleDepth != 16 && g_audioSampleDepth != 32) { fprintf(stderr, "Invalid argument: Audio Sample Depth must be either 16 bits or 32 bits\n"); goto bail; } break; case 'f': g_videoOutputFile = optarg; break; case 'n': g_maxFrames = atoi(optarg); break; case 'F': fmt = av_guess_format(optarg, NULL, NULL); break; case 'I': connection = atoi(optarg); break; case 'C': camera = atoi(optarg); break; case '?': case 'h': usage(0); } } /* Connect to the first DeckLink instance */ do { result = deckLinkIterator->Next(&deckLink); } while(i++<camera); if (result != S_OK) { fprintf(stderr, "No DeckLink PCI cards found.\n"); goto bail; } if (deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput) != S_OK) goto bail; result = deckLink->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration); if (result != S_OK) { fprintf(stderr, "Could not obtain the IDeckLinkConfiguration interface - result = %08x\n", result); goto bail; } //XXX make it generic if (connection == 1) { // video compuesto + audio analogico deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection, bmdVideoConnectionComposite); deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection, bmdAudioConnectionAnalog); }else if (connection == 2) { // video componentes + audio analogico deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection, bmdVideoConnectionComponent); deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection, bmdAudioConnectionAnalog); }else if (connection == 3) { // HDMI video + audio deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection, bmdVideoConnectionHDMI); deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection, bmdAudioConnectionEmbedded); }else if (connection == 4) { // SDI video + audio deckLinkConfiguration->SetInt(bmdDeckLinkConfigVideoInputConnection, bmdVideoConnectionSDI); deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection, bmdAudioConnectionEmbedded); } delegate = new DeckLinkCaptureDelegate(); 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); goto bail; } if (!fmt) fmt = av_guess_format(NULL, g_videoOutputFile, NULL); if (g_videoModeIndex < 0) { fprintf(stderr, "No video mode specified\n"); usage(0); } selectedDisplayMode = -1; while (displayModeIterator->Next(&displayMode) == S_OK) { if (g_videoModeIndex == displayModeCount) { selectedDisplayMode = displayMode->GetDisplayMode(); break; } displayModeCount++; displayMode->Release(); } oc = avformat_alloc_context(); oc->oformat = fmt; snprintf(oc->filename, sizeof(oc->filename), "%s", g_videoOutputFile); fmt->video_codec = CODEC_ID_RAWVIDEO; fmt->audio_codec = CODEC_ID_PCM_S16LE; video_st = add_video_stream(oc, fmt->video_codec); audio_st = add_audio_stream(oc, fmt->audio_codec); av_set_parameters(oc, NULL); if (!(fmt->flags & AVFMT_NOFILE)) { if (url_fopen(&oc->pb, oc->filename, URL_WRONLY) < 0) { fprintf(stderr, "Could not open '%s'\n", oc->filename); exit(1); } } if (selectedDisplayMode < 0) { fprintf(stderr, "Invalid mode %d specified\n", g_videoModeIndex); goto bail; } result = deckLinkInput->EnableVideoInput(selectedDisplayMode, bmdFormat8BitYUV, 0); if(result != S_OK) { fprintf(stderr, "Failed to enable video input. Is another application using the card?\n"); goto bail; } result = deckLinkInput->EnableAudioInput(bmdAudioSampleRate48kHz, g_audioSampleDepth, g_audioChannels); if(result != S_OK) { goto bail; } av_write_header(oc); result = deckLinkInput->StartStreams(); if(result != S_OK) { goto bail; } // All Okay. exitStatus = 0; // Block main thread until signal occurs pthread_mutex_lock(&sleepMutex); pthread_cond_wait(&sleepCond, &sleepMutex); pthread_mutex_unlock(&sleepMutex); fprintf(stderr, "Stopping Capture\n"); bail: if (displayModeIterator != NULL) { displayModeIterator->Release(); displayModeIterator = NULL; } if (deckLinkInput != NULL) { deckLinkInput->Release(); deckLinkInput = NULL; } if (deckLink != NULL) { deckLink->Release(); deckLink = NULL; } if (deckLinkIterator != NULL) deckLinkIterator->Release(); if (oc != NULL) { av_write_trailer(oc); if (!(fmt->flags & AVFMT_NOFILE)) { /* close the output file */ url_fclose(oc->pb); } } return exitStatus; }
static gpointer init_devices (gpointer data) { IDeckLinkIterator *iterator; IDeckLink *decklink = NULL; HRESULT ret; int i; #ifdef _MSC_VER // Start COM thread for Windows g_mutex_lock (&com_init_lock); /* create the COM initialization thread */ g_thread_create ((GThreadFunc) gst_decklink_com_thread, NULL, FALSE, NULL); /* wait until the COM thread signals that COM has been initialized */ g_cond_wait (&com_init_cond, &com_init_lock); g_mutex_unlock (&com_init_lock); #endif /* _MSC_VER */ iterator = CreateDeckLinkIteratorInstance (); if (iterator == NULL) { GST_ERROR ("no driver"); return NULL; } i = 0; ret = iterator->Next (&decklink); while (ret == S_OK) { ret = decklink->QueryInterface (IID_IDeckLinkInput, (void **) &devices[i].input.input); if (ret != S_OK) { GST_WARNING ("selected device does not have input interface"); } else { devices[i].input.device = decklink; devices[i].input.clock = gst_decklink_clock_new ("GstDecklinkInputClock"); GST_DECKLINK_CLOCK_CAST (devices[i].input.clock)->input = &devices[i].input; devices[i].input. input->SetCallback (new GStreamerDecklinkInputCallback (&devices[i]. input)); } ret = decklink->QueryInterface (IID_IDeckLinkOutput, (void **) &devices[i].output.output); if (ret != S_OK) { GST_WARNING ("selected device does not have output interface"); } else { devices[i].output.device = decklink; devices[i].output.clock = gst_decklink_clock_new ("GstDecklinkOutputClock"); GST_DECKLINK_CLOCK_CAST (devices[i].output.clock)->output = &devices[i].output; } ret = decklink->QueryInterface (IID_IDeckLinkConfiguration, (void **) &devices[i].input.config); if (ret != S_OK) { GST_WARNING ("selected device does not have config interface"); } ret = decklink->QueryInterface (IID_IDeckLinkAttributes, (void **) &devices[i].input.attributes); if (ret != S_OK) { GST_WARNING ("selected device does not have attributes interface"); } ret = iterator->Next (&decklink); i++; if (i == 10) { GST_WARNING ("this hardware has more then 10 devices"); break; } } n_devices = i; iterator->Release (); return NULL; }
void SignalGenerator::setup() { IDeckLinkIterator* deckLinkIterator = NULL; bool success = false; // **** Find a DeckLink instance and obtain video output interface deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { QMessageBox::critical(this, "This application requires the DeckLink drivers installed.", "Please install the Blackmagic DeckLink drivers to use the features of this application."); goto bail; } // Connect to the first DeckLink instance if (deckLinkIterator->Next(&deckLink) != S_OK) { QMessageBox::critical(this, "This application requires a DeckLink PCI card.", "You will not be able to use the features of this application until a DeckLink PCI card is installed."); goto bail; } // Obtain the audio/video output interface (IDeckLinkOutput) if (deckLink->QueryInterface(IID_IDeckLinkOutput, (void**)&deckLinkOutput) != S_OK) goto bail; // Create a delegate class to allow the DeckLink API to call into our code playerDelegate = new PlaybackDelegate(this, deckLinkOutput); if (playerDelegate == NULL) goto bail; // Provide the delegate to the audio and video output interfaces deckLinkOutput->SetScheduledFrameCompletionCallback(playerDelegate); deckLinkOutput->SetAudioCallback(playerDelegate); // Populate the display mode menu with a list of display modes supported by the installed DeckLink card IDeckLinkDisplayModeIterator* displayModeIterator; IDeckLinkDisplayMode* deckLinkDisplayMode; ui->videoFormatPopup->clear(); if (deckLinkOutput->GetDisplayModeIterator(&displayModeIterator) != S_OK) goto bail; while (displayModeIterator->Next(&deckLinkDisplayMode) == S_OK) { const char * modeName; if (deckLinkDisplayMode->GetName(&modeName) == S_OK) { ui->videoFormatPopup->addItem(modeName, QVariant::fromValue((void *)deckLinkDisplayMode)); } } displayModeIterator->Release(); enableInterface(true); deckLinkOutput->SetScreenPreviewCallback(previewView); success = true; bail: if (success == false) { // Release any resources that were partially allocated if (deckLinkOutput != NULL) { deckLinkOutput->Release(); deckLinkOutput = NULL; } // if (deckLink != NULL) { deckLink->Release(); deckLink = NULL; } // Disable the user interface if we could not succsssfully connect to a DeckLink device ui->startButton->setEnabled(false); enableInterface(false); } if (deckLinkIterator != NULL) deckLinkIterator->Release(); }
av_cold int ff_decklink_read_header(AVFormatContext *avctx) { struct decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data; struct decklink_ctx *ctx; IDeckLinkDisplayModeIterator *itermode; IDeckLinkIterator *iter; IDeckLink *dl = NULL; AVStream *st; HRESULT result; char fname[1024]; char *tmp; int mode_num = 0; ctx = (struct decklink_ctx *) av_mallocz(sizeof(struct decklink_ctx)); if (!ctx) return AVERROR(ENOMEM); ctx->list_devices = cctx->list_devices; ctx->list_formats = cctx->list_formats; ctx->preroll = cctx->preroll; cctx->ctx = ctx; iter = CreateDeckLinkIteratorInstance(); if (!iter) { av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n"); return AVERROR(EIO); } /* List available devices. */ if (ctx->list_devices) { ff_decklink_list_devices(avctx); return AVERROR_EXIT; } strcpy (fname, avctx->filename); tmp=strchr (fname, '@'); if (tmp != NULL) { mode_num = atoi (tmp+1); *tmp = 0; } /* Open device. */ while (iter->Next(&dl) == S_OK) { const char *displayName; ff_decklink_get_display_name(dl, &displayName); if (!strcmp(fname, displayName)) { av_free((void *) displayName); ctx->dl = dl; break; } av_free((void *) displayName); dl->Release(); } iter->Release(); if (!ctx->dl) { av_log(avctx, AV_LOG_ERROR, "Could not open '%s'\n", fname); return AVERROR(EIO); } /* Get input device. */ if (ctx->dl->QueryInterface(IID_IDeckLinkInput, (void **) &ctx->dli) != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not open output device from '%s'\n", avctx->filename); ctx->dl->Release(); return AVERROR(EIO); } /* List supported formats. */ if (ctx->list_formats) { ff_decklink_list_formats(avctx, DIRECTION_IN); ctx->dli->Release(); ctx->dl->Release(); return AVERROR_EXIT; } if (ctx->dli->GetDisplayModeIterator(&itermode) != S_OK) { av_log(avctx, AV_LOG_ERROR, "Could not get Display Mode Iterator\n"); ctx->dl->Release(); return AVERROR(EIO); } if (mode_num > 0) { if (ff_decklink_set_format(avctx, DIRECTION_IN, mode_num) < 0) { av_log(avctx, AV_LOG_ERROR, "Could not set mode %d for %s\n", mode_num, fname); goto error; } } itermode->Release(); /* Setup streams. */ st = avformat_new_stream(avctx, NULL); if (!st) { av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n"); goto error; } st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_id = AV_CODEC_ID_PCM_S16LE; st->codec->sample_rate = bmdAudioSampleRate48kHz; st->codec->channels = 2; avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ ctx->audio_st=st; st = avformat_new_stream(avctx, NULL); if (!st) { av_log(avctx, AV_LOG_ERROR, "Cannot add stream\n"); goto error; } st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = AV_CODEC_ID_RAWVIDEO; st->codec->width = ctx->bmd_width; st->codec->height = ctx->bmd_height; st->codec->pix_fmt = AV_PIX_FMT_UYVY422; st->codec->time_base.den = ctx->bmd_tb_den; st->codec->time_base.num = ctx->bmd_tb_num; st->codec->bit_rate = avpicture_get_size(st->codec->pix_fmt, ctx->bmd_width, ctx->bmd_height) * 1/av_q2d(st->codec->time_base) * 8; st->codec->codec_tag = MKTAG('U', 'Y', 'V', 'Y'); avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */ ctx->video_st=st; result = ctx->dli->EnableAudioInput(bmdAudioSampleRate48kHz, bmdAudioSampleType16bitInteger, 2); if (result != S_OK) { av_log(avctx, AV_LOG_ERROR, "Cannot enable audio input\n"); goto error; } result = ctx->dli->EnableVideoInput(ctx->bmd_mode, bmdFormat8BitYUV, bmdVideoInputFlagDefault); if (result != S_OK) { av_log(avctx, AV_LOG_ERROR, "Cannot enable video input\n"); goto error; } avpacket_queue_init (avctx, &ctx->queue); if (decklink_start_input (avctx) != S_OK) { av_log(avctx, AV_LOG_ERROR, "Cannot start input stream\n"); goto error; } return 0; error: ctx->dli->Release(); ctx->dl->Release(); return AVERROR(EIO); }
bool Player::Init(int videomode, int connection, int camera) { // Initialize the DeckLink API IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance(); HRESULT result; int i = 0; if (!deckLinkIterator) { fprintf(stderr, "This application requires the DeckLink drivers installed.\n"); goto bail; } m_audioSampleDepth = av_get_exact_bits_per_sample(audio_st->codec->codec_id); switch (audio_st->codec->channels) { case 2: case 8: case 16: break; default: fprintf(stderr, "%d channels not supported, please use 2, 8 or 16\n", audio_st->codec->channels); goto bail; } switch (m_audioSampleDepth) { case 16: case 32: break; default: fprintf(stderr, "%dbit audio not supported use 16bit or 32bit\n", m_audioSampleDepth); } do result = deckLinkIterator->Next(&m_deckLink); while (i++ < camera); if (result != S_OK) { fprintf(stderr, "No DeckLink PCI cards found\n"); goto bail; } // Obtain the audio/video output interface (IDeckLinkOutput) if (m_deckLink->QueryInterface(IID_IDeckLinkOutput, (void **)&m_deckLinkOutput) != S_OK) goto bail; result = m_deckLink->QueryInterface(IID_IDeckLinkConfiguration, (void **)&deckLinkConfiguration); if (result != S_OK) { fprintf( stderr, "Could not obtain the IDeckLinkConfiguration interface - result = %08x\n", result); goto bail; } //XXX make it generic switch (connection) { case 1: DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionComposite); DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionAnalog); break; case 2: DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionComponent); DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionAnalog); break; case 3: DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionHDMI); DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionEmbedded); break; case 4: DECKLINK_SET_VIDEO_CONNECTION(bmdVideoConnectionSDI); DECKLINK_SET_AUDIO_CONNECTION(bmdAudioConnectionEmbedded); break; default: // do not change it break; } // Provide this class as a delegate to the audio and video output interfaces m_deckLinkOutput->SetScheduledFrameCompletionCallback(this); m_deckLinkOutput->SetAudioCallback(this); avframe = avcodec_alloc_frame(); packet_queue_init(&audioqueue); packet_queue_init(&videoqueue); packet_queue_init(&dataqueue); pthread_t th; pthread_create(&th, NULL, fill_queues, NULL); usleep(buffer); // You can add the microseconds you need for pre-buffering before start playing // Start playing StartRunning(videomode); pthread_mutex_lock(&sleepMutex); pthread_cond_wait(&sleepCond, &sleepMutex); pthread_mutex_unlock(&sleepMutex); fill_me = 0; fprintf(stderr, "Exiting, cleaning up\n"); packet_queue_end(&audioqueue); packet_queue_end(&videoqueue); bail: if (m_running == true) { StopRunning(); } else { // Release any resources that were partially allocated if (m_deckLinkOutput != NULL) { m_deckLinkOutput->Release(); m_deckLinkOutput = NULL; } // if (m_deckLink != NULL) { m_deckLink->Release(); m_deckLink = NULL; } } if (deckLinkIterator != NULL) deckLinkIterator->Release(); return true; }
void krad_decklink_cpp_get_device_name (int device_num, char *device_name) { IDeckLinkIterator *deckLinkIterator; IDeckLink *deckLink; int device_count; HRESULT result; #ifdef IS_LINUX char *device_name_temp; #endif #ifdef IS_MACOSX CFStringRef device_name_temp; #endif device_name_temp = NULL; device_count = 0; deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { printke ("krad_decklink_detect_devices: The DeckLink drivers may not be installed."); return; } while (deckLinkIterator->Next(&deckLink) == S_OK) { if (device_count == device_num) { #ifdef IS_LINUX result = deckLink->GetModelName((const char **) &device_name_temp); if (result == S_OK) { strcpy(device_name, device_name_temp); free(device_name_temp); #endif #ifdef IS_MACOSX result = deckLink->GetModelName(&device_name_temp); if (result == S_OK) { CFStringGetCString(device_name_temp, device_name, 64, kCFStringEncodingMacRoman); CFRelease(device_name_temp); #endif } else { strcpy(device_name, "Unknown Error in GetModelName"); } deckLink->Release(); deckLinkIterator->Release(); return; } device_count++; deckLink->Release(); } deckLinkIterator->Release(); sprintf(device_name, "Could not get a device name for device %d", device_num); return; } }
int usage(int status) { HRESULT result; IDeckLinkIterator *deckLinkIterator; IDeckLink *deckLink; int numDevices = 0; fprintf(stderr, "Usage: bmdplay -m <mode id> [OPTIONS]\n" "\n" " -m <mode id>:\n" ); // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system deckLinkIterator = CreateDeckLinkIteratorInstance(); if (deckLinkIterator == NULL) { fprintf( stderr, "A DeckLink iterator could not be created. The DeckLink drivers may not be installed.\n"); return 1; } // Enumerate all cards in this system while (deckLinkIterator->Next(&deckLink) == S_OK) { BMDProbeString str; // Increment the total number of DeckLink cards found numDevices++; if (numDevices > 1) printf("\n\n"); // *** Print the model name of the DeckLink card result = deckLink->GetModelName(&str); if (result == S_OK) { printf("-> %s (-C %d )\n\n", ToStr(str), numDevices - 1); FreeStr(str); } print_output_modes(deckLink); // Release the IDeckLink instance when we've finished with it to prevent leaks deckLink->Release(); } deckLinkIterator->Release(); // If no DeckLink cards were found in the system, inform the user if (numDevices == 0) printf("No Blackmagic Design devices were found.\n"); printf("\n"); fprintf( stderr, " -f <filename> Filename raw video will be written to\n" " -C <num> Card number to be used\n" " -b <num> Milliseconds of pre-buffering before playback (default = 2000 ms)\n" " -p <pixel> PixelFormat Depth (8 or 10 - default is 8)\n" " -O <output> Output connection:\n" " 1: Composite video + analog audio\n" " 2: Components video + analog audio\n" " 3: HDMI video + audio\n" " 4: SDI video + audio\n\n"); return status; }
int main(int argc, char *argv[]) { HRESULT result; int exitStatus = 1; int idx; IDeckLinkIterator* deckLinkIterator = NULL; IDeckLink* deckLink = NULL; IDeckLinkAttributes* deckLinkAttributes = NULL; bool formatDetectionSupported; IDeckLinkDisplayModeIterator* displayModeIterator = NULL; IDeckLinkDisplayMode* displayMode = NULL; char* displayModeName = NULL; BMDDisplayModeSupport displayModeSupported; DeckLinkCaptureDelegate* delegate = NULL; pthread_mutex_init(&g_sleepMutex, NULL); pthread_cond_init(&g_sleepCond, NULL); signal(SIGINT, sigfunc); signal(SIGTERM, sigfunc); signal(SIGHUP, sigfunc); // Network g_video_sock = socket(AF_INET, SOCK_STREAM, 0); g_video_addr.sin_family = AF_INET; g_video_addr.sin_port = htons(62310); g_video_addr.sin_addr.s_addr = inet_addr("192.168.100.31"); connect(g_video_sock, (struct sockaddr *)&g_video_addr, sizeof(g_video_addr)); g_audio_sock = socket(AF_INET, SOCK_STREAM, 0); g_audio_addr.sin_family = AF_INET; g_audio_addr.sin_port = htons(62311); g_audio_addr.sin_addr.s_addr = inet_addr("192.168.100.31"); connect(g_audio_sock, (struct sockaddr *)&g_audio_addr, sizeof(g_audio_addr)); // Process the command line arguments if (!g_config.ParseArguments(argc, argv)) { g_config.DisplayUsage(exitStatus); goto bail; } // Get the DeckLink device deckLinkIterator = CreateDeckLinkIteratorInstance(); if (!deckLinkIterator) { fprintf(stderr, "This application requires the DeckLink drivers installed.\n"); goto bail; } idx = g_config.m_deckLinkIndex; while ((result = deckLinkIterator->Next(&deckLink)) == S_OK) { if (idx == 0) break; --idx; deckLink->Release(); } if (result != S_OK || deckLink == NULL) { fprintf(stderr, "Unable to get DeckLink device %u\n", g_config.m_deckLinkIndex); goto bail; } // Get the input (capture) interface of the DeckLink device result = deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&g_deckLinkInput); if (result != S_OK) goto bail; // Get the display mode if (g_config.m_displayModeIndex == -1) { // Check the card supports format detection result = deckLink->QueryInterface(IID_IDeckLinkAttributes, (void**)&deckLinkAttributes); if (result == S_OK) { result = deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInputFormatDetection, &formatDetectionSupported); if (result != S_OK || !formatDetectionSupported) { fprintf(stderr, "Format detection is not supported on this device\n"); goto bail; } } g_config.m_inputFlags |= bmdVideoInputEnableFormatDetection; // Format detection still needs a valid mode to start with idx = 0; } else { idx = g_config.m_displayModeIndex; } result = g_deckLinkInput->GetDisplayModeIterator(&displayModeIterator); if (result != S_OK) { goto bail; } while ((result = displayModeIterator->Next(&displayMode)) == S_OK) { if (idx == 0) { break; } --idx; displayMode->Release(); } if (result != S_OK || displayMode == NULL) { fprintf(stderr, "Unable to get display mode %d\n", g_config.m_displayModeIndex); goto bail; } // Get display mode name result = displayMode->GetName((const char**)&displayModeName); if (result != S_OK) { displayModeName = (char *)malloc(32); snprintf(displayModeName, 32, "[index %d]", g_config.m_displayModeIndex); } // Check display mode is supported with given options result = g_deckLinkInput->DoesSupportVideoMode(displayMode->GetDisplayMode(), g_config.m_pixelFormat, bmdVideoInputFlagDefault, &displayModeSupported, NULL); if (result != S_OK) goto bail; if (displayModeSupported == bmdDisplayModeNotSupported) { fprintf(stderr, "The display mode %s is not supported with the selected pixel format\n", displayModeName); goto bail; } if (g_config.m_inputFlags & bmdVideoInputDualStream3D) { if (!(displayMode->GetFlags() & bmdDisplayModeSupports3D)) { fprintf(stderr, "The display mode %s is not supported with 3D\n", displayModeName); goto bail; } } // Print the selected configuration g_config.DisplayConfiguration(); // Configure the capture callback delegate = new DeckLinkCaptureDelegate(); g_deckLinkInput->SetCallback(delegate); // Open output files // if (g_config.m_videoOutputFile != NULL) // { // g_videoOutputFile = open(g_config.m_videoOutputFile, O_WRONLY|O_CREAT|O_TRUNC, 0664); // if (g_videoOutputFile < 0) // { // fprintf(stderr, "Could not open video output file \"%s\"\n", g_config.m_videoOutputFile); // goto bail; // } // } // // if (g_config.m_audioOutputFile != NULL) // { // g_audioOutputFile = open(g_config.m_audioOutputFile, O_WRONLY|O_CREAT|O_TRUNC, 0664); // if (g_audioOutputFile < 0) // { // fprintf(stderr, "Could not open audio output file \"%s\"\n", g_config.m_audioOutputFile); // goto bail; // } // } // Block main thread until signal occurs while (!g_do_exit) { // Start capturing result = g_deckLinkInput->EnableVideoInput(displayMode->GetDisplayMode(), g_config.m_pixelFormat, g_config.m_inputFlags); if (result != S_OK) { fprintf(stderr, "Failed to enable video input. Is another application using the card?\n"); goto bail; } result = g_deckLinkInput->EnableAudioInput(bmdAudioSampleRate48kHz, g_config.m_audioSampleDepth, g_config.m_audioChannels); if (result != S_OK) goto bail; result = g_deckLinkInput->StartStreams(); if (result != S_OK) goto bail; // All Okay. exitStatus = 0; pthread_mutex_lock(&g_sleepMutex); pthread_cond_wait(&g_sleepCond, &g_sleepMutex); pthread_mutex_unlock(&g_sleepMutex); fprintf(stderr, "Stopping Capture\n"); g_deckLinkInput->StopStreams(); g_deckLinkInput->DisableAudioInput(); g_deckLinkInput->DisableVideoInput(); } bail: if (g_videoOutputFile != 0) close(g_videoOutputFile); if (g_audioOutputFile != 0) close(g_audioOutputFile); if (displayModeName != NULL) free(displayModeName); if (displayMode != NULL) displayMode->Release(); if (displayModeIterator != NULL) displayModeIterator->Release(); if (g_deckLinkInput != NULL) { g_deckLinkInput->Release(); g_deckLinkInput = NULL; } if (deckLinkAttributes != NULL) deckLinkAttributes->Release(); if (deckLink != NULL) deckLink->Release(); if (deckLinkIterator != NULL) deckLinkIterator->Release(); close(g_video_sock); close(g_audio_sock); return exitStatus; }
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; }
bool ofxBlackmagicGrabber::initGrabber(int w, int h) { IDeckLinkIterator *deckLinkIterator = CreateDeckLinkIteratorInstance(); int displayModeCount = 0; int exitStatus = 1; bool foundDisplayMode = false; HRESULT result; IDeckLinkDisplayModeIterator *displayModeIterator; if (!deckLinkIterator){ ofLogError(LOG_NAME) << "This application requires the DeckLink drivers installed."; goto bail; } for(int i=0;i<deviceID+1;i++){ result = deckLinkIterator->Next(&deckLink); if (result != S_OK){ ofLogError(LOG_NAME) << "Couldn't open device" << deviceID; goto bail; } } if (deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput) != S_OK) goto bail; deckLinkInput->SetCallback(this); // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on output result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator); if (result != S_OK){ ofLogError(LOG_NAME) << "Could not obtain the video output display mode iterator - result =" << result; goto bail; } if (g_videoModeIndex < 0){ ofLogError(LOG_NAME) << "No video mode specified, specify it before initGrabber using setVideoMode"; goto bail; } while (displayModeIterator->Next(&displayMode) == S_OK){ if (g_videoModeIndex == displayMode->GetDisplayMode()){ BMDDisplayModeSupport result; CFStringRef displayModeName; foundDisplayMode = true; displayMode->GetName(&displayModeName); selectedDisplayMode = displayMode->GetDisplayMode(); pixels[0].allocate(displayMode->GetWidth(),displayMode->GetHeight(),OF_IMAGE_COLOR); pixels[1].allocate(displayMode->GetWidth(),displayMode->GetHeight(),OF_IMAGE_COLOR); ofLogVerbose(LOG_NAME) << "device initialized:" << displayMode->GetWidth() << displayMode->GetHeight(); deckLinkInput->DoesSupportVideoMode(selectedDisplayMode, pixelFormat, bmdVideoInputFlagDefault, &result, NULL); if (result == bmdDisplayModeNotSupported){ ofLogError(LOG_NAME) << "The display mode" << displayModeName << "is not supported with the selected pixel format"; goto bail; } if (inputFlags & bmdVideoInputDualStream3D){ if (!(displayMode->GetFlags() & bmdDisplayModeSupports3D)){ ofLogError(LOG_NAME) << "The display mode" << displayModeName << "is not supported with 3D"; goto bail; } } break; } displayModeCount++; displayMode->Release(); } if (!foundDisplayMode){ ofLogError(LOG_NAME) << "Invalid mode" << g_videoModeIndex << "specified"; goto bail; } result = deckLinkInput->EnableVideoInput(selectedDisplayMode, pixelFormat, inputFlags); if(result != S_OK){ ofLogError(LOG_NAME) << "Failed to enable video input. Is another application using the card?"; goto bail; } #if 0 // no audio by now result = deckLinkInput->EnableAudioInput(bmdAudioSampleRate48kHz, g_audioSampleDepth, g_audioChannels); if(result != S_OK){ goto bail; } #endif result = deckLinkInput->StartStreams(); if(result != S_OK){ goto bail; } // All Okay. exitStatus = 0; return true; bail: if (displayModeIterator != NULL){ displayModeIterator->Release(); displayModeIterator = NULL; } if (deckLinkIterator != NULL) deckLinkIterator->Release(); close(); return false; }