decklink.cpp File Reference

#include <algorithm>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <condition_variable>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
#include "blackmagic_common.hpp"
#include "audio/types.h"
#include "audio/utils.h"
#include "compat/htonl.h"
#include "compat/strings.h"
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "types.h"
#include "utils/color_out.h"
#include "utils/macros.h"
#include "utils/math.h"
#include "utils/windows.h"
#include "video.h"
#include "video_capture.h"

Include dependency graph for decklink.cpp:

Go to the source code of this file.

Classes
struct	device_state
struct	vidcap_decklink_state
struct	vidcap_decklink_state::audio
class	VideoDelegate

Macros
#define	CALL_AND_CHECK(cmd, ...)
#define	CALL_AND_CHECK_2(cmd, name)
#define	CALL_AND_CHECK_3(cmd, name, msg)
#define	CALL_AND_CHECK_CHOOSER(...)
#define	EXIT_IF_FAILED(cmd, name)
#define	GET_3TH_ARG(arg1, arg2, arg3, ...)
#define	INIT_ERR()
#define	MOD_NAME   "[DeckLink capture] "
#define	RELEASE_IF_NOT_NULL(x)
#define	STDMETHODCALLTYPE

Functions
static void	cleanup_common (struct vidcap_decklink_state *s)
static bool	decklink_cap_configure_audio (struct vidcap_decklink_state *s, unsigned int audio_src_flag, BMDAudioConnection *audioConnection)
static int	decklink_help (bool full, const char *query_prop_fcc=nullptr)
static bool	detect_format (struct vidcap_decklink_state *s, BMDDisplayMode *outDisplayMode, struct device_state *device)
static list< tuple< int, string, string, string > >	get_input_modes (IDeckLink *deckLink)
static int	nr_frames (struct vidcap_decklink_state *s)
static void	parse_devices (struct vidcap_decklink_state *s, const char *devs)
static bool	parse_option (struct vidcap_decklink_state *s, const char *opt)
static void	postprocess_frame (struct vidcap_decklink_state *s)
static void	print_input_modes (IDeckLink *deckLink)
static audio_frame *	process_new_audio_packets (struct vidcap_decklink_state *s)
	REGISTER_MODULE (decklink, &vidcap_decklink_info, LIBRARY_CLASS_VIDEO_CAPTURE, VIDEO_CAPTURE_ABI_VERSION)
static HRESULT	set_display_mode_properties (struct vidcap_decklink_state *s, struct tile *tile, IDeckLinkDisplayMode *displayMode, BMDPixelFormat *pf)
static bool	settings_init (struct vidcap_decklink_state *s, char *fmt)
static bool	settings_init_key_val (struct vidcap_decklink_state *s, char **save_ptr)
static void	vidcap_decklink_done (void *state)
static struct video_frame *	vidcap_decklink_grab (void *state, struct audio_frame **audio)
static int	vidcap_decklink_init (struct vidcap_params *params, void **state)
static void	vidcap_decklink_print_card_info (IDeckLink *deckLink, const char *query_prop_fcc)
static void	vidcap_decklink_probe (device_info **available_cards, int *card_count, void(**deleter)(void *))

Variables
constexpr const int	DEFAULT_AUDIO_BPS = 4
constexpr const size_t	MAX_AUDIO_PACKETS = 10
static const struct video_capture_info	vidcap_decklink_info

Macro Definition Documentation

CALL_AND_CHECK

#define CALL_AND_CHECK	(		cmd,
			... )

Value:

CALL_AND_CHECK_CHOOSER(__VA_ARGS__)(cmd, __VA_ARGS__)

Definition at line 165 of file decklink.cpp.

Referenced by display_decklink_done(), device_state::init(), and VideoDelegate::VideoInputFormatChanged().

CALL_AND_CHECK_2

#define CALL_AND_CHECK_2	(		cmd,
			name )

Value:

        do {\
                HRESULT result = cmd;\
                if (FAILED(result)) {;\
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << name << ": " << bmd_hresult_to_string(result) << "\n";\
                }\
        } while (0)

Definition at line 143 of file decklink.cpp.

#define CALL_AND_CHECK_2(cmd, name) \
        do {\
                HRESULT result = cmd;\
                if (FAILED(result)) {;\
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << name << ": " << bmd_hresult_to_string(result) << "\n";\
                }\
        } while (0)

CALL_AND_CHECK_3

#define CALL_AND_CHECK_3	(		cmd,
			name,
			msg )

Value:

        do {\
                HRESULT result = cmd;\
                if (FAILED(result)) {;\
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << name << ": " << bmd_hresult_to_string(result) << "\n";\
                } else {\
                        LOG(LOG_LEVEL_INFO) << MOD_NAME << name << ": " << msg << "\n";\
                }\
        } while (0)

Definition at line 151 of file decklink.cpp.

#define CALL_AND_CHECK_3(cmd, name, msg) \
        do {\
                HRESULT result = cmd;\
                if (FAILED(result)) {;\
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME << name << ": " << bmd_hresult_to_string(result) << "\n";\
                } else {\
                        LOG(LOG_LEVEL_INFO) << MOD_NAME << name << ": " << msg << "\n";\
                }\
        } while (0)

CALL_AND_CHECK_CHOOSER

#define CALL_AND_CHECK_CHOOSER

(

...

)

Value:

    GET_3TH_ARG(__VA_ARGS__, CALL_AND_CHECK_3, CALL_AND_CHECK_2, )

Definition at line 162 of file decklink.cpp.

#define CALL_AND_CHECK_CHOOSER(...) \
    GET_3TH_ARG(__VA_ARGS__, CALL_AND_CHECK_3, CALL_AND_CHECK_2, )

EXIT_IF_FAILED

#define EXIT_IF_FAILED	(		cmd,
			name )

Value:

        do {\
                HRESULT result = cmd;\
                if (FAILED(result)) {;\
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME << name << ": " << bmd_hresult_to_string(result) << "\n";\
                        goto error;\
                }\
        } while (0)

Definition at line 133 of file decklink.cpp.

#define EXIT_IF_FAILED(cmd, name) \
        do {\
                HRESULT result = cmd;\
                if (FAILED(result)) {;\
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME << name << ": " << bmd_hresult_to_string(result) << "\n";\
                        goto error;\
                }\
        } while (0)

GET_3TH_ARG

#define GET_3TH_ARG	(		arg1,
			arg2,
			arg3,
			... )

Value:

arg3

Definition at line 161 of file decklink.cpp.

INIT_ERR

#define INIT_ERR

(

)

Value:

do { RELEASE_IF_NOT_NULL(displayMode); RELEASE_IF_NOT_NULL(displayModeIterator); return false; } while (0)

Definition at line 1134 of file decklink.cpp.

Referenced by device_state::init().

MOD_NAME

#define MOD_NAME   "[DeckLink capture] "

Definition at line 91 of file decklink.cpp.

Referenced by vidcap_decklink_state::vidcap_decklink_state(), decklink_cap_configure_audio(), get_input_modes(), device_state::init(), parse_option(), vidcap_decklink_state::set_codec(), set_display_mode_properties(), settings_init(), vidcap_decklink_done(), vidcap_decklink_init(), vidcap_decklink_print_card_info(), vidcap_decklink_probe(), VideoDelegate::VideoInputFormatChanged(), and VideoDelegate::VideoInputFrameArrived().

RELEASE_IF_NOT_NULL

#define RELEASE_IF_NOT_NULL

(

x

)

Value:

if (x != nullptr) { x->Release(); x = nullptr; }

Definition at line 97 of file decklink.cpp.

Referenced by VideoDelegate::~VideoDelegate(), cleanup_common(), get_input_modes(), vidcap_decklink_print_card_info(), vidcap_decklink_probe(), and VideoDelegate::VideoInputFrameArrived().

STDMETHODCALLTYPE

#define STDMETHODCALLTYPE

Definition at line 94 of file decklink.cpp.

Function Documentation

cleanup_common()

static void cleanup_common ( struct vidcap_decklink_state * s )

static

Definition at line 1498 of file decklink.cpp.

                                                            {
        while (!s->audioPackets.empty()) {
                auto *audioPacket = s->audioPackets.front();
                s->audioPackets.pop();
                audioPacket->Release();
        }
 
        for (int i = 0; i < s->devices_cnt; ++i) {
                RELEASE_IF_NOT_NULL(s->state[i].deckLinkConfiguration);
                RELEASE_IF_NOT_NULL(s->state[i].deckLinkAttributes);
                RELEASE_IF_NOT_NULL(s->state[i].deckLinkInput);
                RELEASE_IF_NOT_NULL(s->state[i].deckLink);
        }
 
        free(s->audio.data);
 
        vf_free(s->frame);
        delete s;
}

References vidcap_decklink_state::audioPackets, vidcap_decklink_state::devices_cnt, vidcap_decklink_state::frame, RELEASE_IF_NOT_NULL, vidcap_decklink_state::state, and vf_free().

Referenced by vidcap_decklink_done(), and vidcap_decklink_init().

Here is the call graph for this function:

decklink_cap_configure_audio()

static bool decklink_cap_configure_audio ( struct vidcap_decklink_state * s, unsigned int audio_src_flag, BMDAudioConnection * audioConnection )

static

Definition at line 1086 of file decklink.cpp.

                                                                                                                                            {
        if (audio_src_flag == 0U) {
                return true;
        }
 
        s->state[0].audio = true;
        switch (audio_src_flag) {
                case VIDCAP_FLAG_AUDIO_EMBEDDED:
                        *audioConnection = bmdAudioConnectionEmbedded;
                        break;
                case VIDCAP_FLAG_AUDIO_AESEBU:
                        *audioConnection = bmdAudioConnectionAESEBU;
                        break;
                case VIDCAP_FLAG_AUDIO_ANALOG:
                        *audioConnection = bmdAudioConnectionAnalog;
                        break;
                default:
                        LOG(LOG_LEVEL_FATAL) << MOD_NAME << "Unexpected audio flag " << audio_src_flag << " encountered.\n";
                        abort();
        }
        s->audio.bps = audio_capture_bps == 0 ? DEFAULT_AUDIO_BPS : audio_capture_bps;
        if (s->audio.bps != 2 && s->audio.bps != 4) {
                        LOG(LOG_LEVEL_ERROR)
                            << MOD_NAME << "Unsupported audio Bps "
                            << audio_capture_bps
                            << "! Supported is 2 or 4 bytes only!\n";
                        return false;
        }
        if (audio_capture_sample_rate != 0 && audio_capture_sample_rate != bmdAudioSampleRate48kHz) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Unsupported sample rate " << audio_capture_sample_rate << "! Only " << bmdAudioSampleRate48kHz << " is supported.\n";
                return false;
        }
        s->audio.sample_rate = bmdAudioSampleRate48kHz;
        s->audio.ch_count = audio_capture_channels > 0 ? audio_capture_channels : DEFAULT_AUDIO_CAPTURE_CHANNELS;
        s->audio.max_size = (s->audio.sample_rate / 10) * s->audio.ch_count * s->audio.bps;
        s->audio.data = (char *) malloc(s->audio.max_size);
        s->audio.flags |= TIMESTAMP_VALID;
 
        return true;
}

References audio_capture_bps, audio_capture_channels, audio_capture_sample_rate, DEFAULT_AUDIO_BPS, DEFAULT_AUDIO_CAPTURE_CHANNELS, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, MOD_NAME, vidcap_decklink_state::state, TIMESTAMP_VALID, VIDCAP_FLAG_AUDIO_AESEBU, VIDCAP_FLAG_AUDIO_ANALOG, and VIDCAP_FLAG_AUDIO_EMBEDDED.

Referenced by vidcap_decklink_init().

decklink_help()

static int decklink_help ( bool full, const char * query_prop_fcc = nullptr )

static

Definition at line 523 of file decklink.cpp.

{
        col() << "\nDeckLink options:\n";
        col() << SBOLD(SRED("\t-t decklink") << ":[full]help") << " | "
              << SBOLD(SRED("-t decklink") << ":query=<FourCC>") << "\n";
        col() << SBOLD(SRED("\t-t decklink")
                       << "{:m[ode]=<mode>|:d[evice]=<idx|ID|name>|:c[odec]=<colorspace>...<key>=<"
                          "val>}*")
              << "\n";
        col() << SBOLD(SRED("\t-t decklink")
                       << "[:<device_index(indices)>[:<mode>:<colorspace>[:3D]["
                          ":sync_timecode][:connection=<input>][:detect-"
                          "format][:conversion=<conv_mode>]]")
              << "\n";
        col() << "\t(mode specification is mandatory if your card does not support format autodetection; syntax on the first line is recommended, the second is obsolescent)\n";
        col() << "\n";
 
        col() << SBOLD("3D") << "\n";
        printf("\tUse this to capture 3D from supported card (eg. DeckLink HD 3D Extreme).\n");
        printf("\tDo not use it for eg. Quad or Duo. Availability of the mode is indicated\n");
        printf("\tin video format listing above by flag \"3D\".\n");
        printf("\n");
 
        col() << SBOLD("fullhelp") << "\n";
        col() << "\tPrint description of all available options.\n";
        col() << "\n";
 
        col() << SBOLD("half-duplex | full-duplex | simplex") << "\n";
        col() << "\tSet a profile that allows maximal number of simultaneous "
                 "IOs / set device to better compatibility (3D, dual-link) / "
                 "use all connectors as single input.\n";
        col() << "\n";
 
        col() << SBOLD("[no]passthrough[=keep]") << "\n";
        col() << "\tDisables/enables/keeps capture passthrough (default is "
                 "disable).\n";
        col() << "\n";
 
        if (full) {
                col() << SBOLD("conversion") << "\n";
                col() << SBOLD("\tnone") << " - No video input conversion\n";
                col() << SBOLD("\t10lb") << " - HD1080 to SD video input down conversion\n";
                col() << SBOLD("\t10am") << " - Anamorphic from HD1080 to SD video input down conversion\n";
                col() << SBOLD("\t72lb") << " - Letter box from HD720 to SD video input down conversion\n";
                col() << SBOLD("\t72ab") << " - Letterbox video input up conversion\n";
                col() << SBOLD("\tamup") << " - Anamorphic video input up conversion\n";
                col() << "\tThen use the set the resulting mode (!) for capture, eg. for 1080p to PAL conversion:\n"
                                "\t\t-t decklink:mode=pal:conversion=10lb\n";
                col() << "\n";
 
                col() << SBOLD("query=<FourCC>") << "\n";
                col() << "\tQueries device attribute, eg. `decklink:q=mach` to "
                         "see max embed. channels).\n";
                col() << "\n";
 
                col() << SBOLD("p_not_i") << "\n";
                col() << "\tIncoming signal should be treated as progressive even if detected as interlaced (PsF).\n";
                col() << "\n";
 
                col() << SBOLD("Use1080PsF[=true|false]") << "\n";
                col() << "\tIncoming signal should be treated as PsF instead of progressive.\n";
                col() << "\n";
 
                col() << SBOLD("nosig-send") << "\n";
                col() << "\tSend video even if no signal was detected (useful when video interrupts\n"
                        "\tbut the video stream needs to be preserved, eg. to keep sync with audio).\n";
                col() << "\n";
 
                col() << SBOLD("detect-format") << "\n";
                col() << "\tTry to detect input video format even if the "
                         "device doesn't support\n"
                         "\tautodetect, eg. \"-t "
                         "decklink:connection=HDMI:detect-format\".\n";
                col() << "\n";
 
                col() << SBOLD("profile=<FourCC>") << " - use desired device profile:\n";
                print_bmd_device_profiles("\t");
                col() << "\n";
                col() << SBOLD("sync_timecode") << "\n";
                col() << "\tTry to synchronize inputs based on timecode (for multiple inputs, eg. tiled 4K)\n";
                col() << "\n";
                col() << SBOLD("keep-settings") << "\n\tdo not apply any DeckLink settings by UG than required (keep user-selected defaults)\n";
                col() << "\n";
                col() << SBOLD("<option_FourCC>=<value>") << " - arbitrary BMD option (given a FourCC) and corresponding value, i.a.:\n";
                col() << SBOLD("\taacl[=no]")
                      << "\t\tset analog audio levels to maximum gain "
                         "(consumer audio level)\n";
                col() << "\n";
        } else {
                col() << "(other options available, use \"" << SBOLD("fullhelp") << "\" to see complete list of options)\n\n";
        }
 
        col() << "Available color spaces:";
        for (auto & i : uv_to_bmd_codec_map) {
                if (i != *uv_to_bmd_codec_map.begin()) {
                        col() << ",";
                }
 
                col() << " " << SBOLD(get_codec_name(i.first));
        }
        cout << "\n";
        if (!full) {
                col() << "Possible connections: " << TBOLD("SDI") << ", " << TBOLD("HDMI") << ", " << TBOLD("OpticalSDI") << ", " << TBOLD("Component") << ", " << TBOLD("Composite") << ", " << TBOLD("SVideo") << "\n";
        }
        cout << "\n";
 
        // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
        bool com_initialized = false;
        
        cout << "Devices (idx, topological ID, name):\n";
        // Enumerate all cards in this system
        int numDevices = 0;
        const bool natural_sort =
            get_commandline_param(BMD_NAT_SORT) != nullptr;
        for (auto &d :
             bmd_get_sorted_devices(&com_initialized, true, natural_sort)) {
                IDeckLink *deckLink   = get<0>(d).get();
                string deviceName = bmd_get_device_name(deckLink);
                if (deviceName.empty()) {
                        deviceName = "(unable to get name)";
                }
                
                char index[STR_LEN] = "";
                if (!natural_sort) {
                        snprintf(index, sizeof index,
                                 TBOLD("%c") ") ", get<char>(d));
                }
                if (full || natural_sort) {
                        snprintf(index + strlen(index),
                                 sizeof index - strlen(index), TBOLD("%d") ") ",
                                 get<int>(d));
                }
                // *** Print the model name of the DeckLink card
                color_printf("\t%s" TBOLD("%6x") ") " TBOLD(
                                 TGREEN("%s")) "\n",
                             index, get<unsigned>(d),
                             deviceName.c_str());
 
                // Increment the total number of DeckLink cards found
                numDevices++;
        
                if (full) {
                        vidcap_decklink_print_card_info(deckLink, query_prop_fcc);
                }
        }
        if (!full) {
                col() << "\n(use \"-t decklink:"
                      << SBOLD(
                             "fullhelp") "\" to see full list of device modes "
                                         "and available connections)\n\n";
        }
 
        decklink_uninitialize(&com_initialized);
 
        // If no DeckLink cards were found in the system, inform the user
        if (numDevices == 0)
        {
                log_msg(LOG_LEVEL_ERROR, "No Blackmagic Design devices were found.\n");
        }
 
        printf("Examples:\n");
        col() << "\t" << SBOLD(uv_argv[0] << " -t decklink")
              << " # captures autodetected video from first DeckLink (index 0) "
                 "in system\n";
        col() << "\t" << SBOLD(uv_argv[0] << " -t decklink:d=b:m=Hp30:c=v210")
              << " # specify mode for 2nd device which doesn't have "
                 "autodetection\n";
        col() << "\t"
              << SBOLD(uv_argv[0]
                       << " -t decklink:d=\"DeckLink 8K Pro (1)\":profile=1dfd")
              << " # capture from 8K Pro and set profile to 1-subdevice "
                 "full-duplex (useful for 3D capture)\n";
 
        printf("\n");
 
        print_decklink_version();
 
        printf("\n");
 
        return 1;
}

References bmd_get_device_name(), bmd_get_sorted_devices(), BMD_NAT_SORT, color_printf(), device_state::deckLink, decklink_uninitialize(), get_codec_name(), get_commandline_param(), LOG_LEVEL_ERROR, log_msg(), print_bmd_device_profiles(), print_decklink_version(), SBOLD, SRED, STR_LEN, TBOLD, TGREEN, uv_argv, uv_to_bmd_codec_map, and vidcap_decklink_print_card_info().

Referenced by vidcap_decklink_init().

Here is the call graph for this function:

detect_format()

static bool detect_format ( struct vidcap_decklink_state * s, BMDDisplayMode * outDisplayMode, struct device_state * device )

static

This function is used when device does not support autodetection and user request explicitly to detect the format (:detect-format)

Definition at line 1039 of file decklink.cpp.

{
        IDeckLinkDisplayMode *displayMode;
        HRESULT result;
        IDeckLinkDisplayModeIterator*   displayModeIterator = NULL;
        result = device->deckLinkInput->GetDisplayModeIterator(&displayModeIterator);
        if (result != S_OK) {
                return false;
        }
 
        vector<BMDPixelFormat> pfs = {bmdFormat8BitYUV, bmdFormat8BitBGRA};
 
        while (displayModeIterator->Next(&displayMode) == S_OK) {
                for (BMDPixelFormat pf : pfs) {
                        uint32_t mode = ntohl(displayMode->GetDisplayMode());
                        log_msg(LOG_LEVEL_NOTICE, "DeckLink: trying mode %.4s, pixel format %.4s\n", (const char *) &mode, (const char *) &pf);
                        result = device->deckLinkInput->EnableVideoInput(displayMode->GetDisplayMode(), pf, 0);
                        if (result == S_OK) {
                                device->deckLinkInput->StartStreams();
                                unique_lock<mutex> lk(s->lock);
                                s->boss_cv.wait_for(
                                    lk, milliseconds(1200), [device] {
                                            return device->delegate
                                                       ->newFrameReady == 1;
                                    });
                                lk.unlock();
                                device->deckLinkInput->StopStreams();
                                device->deckLinkInput->DisableVideoInput();
 
                                if (device->delegate->newFrameReady == 1) {
                                        *outDisplayMode = displayMode->GetDisplayMode();
                                        // set also detected codec (!)
                                        s->set_codec(pf == bmdFormat8BitYUV ? UYVY : RGBA);
                                        displayMode->Release();
                                        displayModeIterator->Release();
                                        return true;
                                }
                        }
                }
 
                displayMode->Release();
        }
 
        displayModeIterator->Release();
        return false;
}

References vidcap_decklink_state::boss_cv, device_state::deckLinkInput, device_state::delegate, vidcap_decklink_state::lock, LOG_LEVEL_NOTICE, log_msg(), mode, RGBA, vidcap_decklink_state::set_codec(), and UYVY.

Referenced by device_state::init().

Here is the call graph for this function:

get_input_modes()

static list< tuple< int, string, string, string > > get_input_modes ( IDeckLink * deckLink )

static

Definition at line 1771 of file decklink.cpp.

{
        list<tuple<int, string, string, string>> ret;
        IDeckLinkInput*                 deckLinkInput = NULL;
        IDeckLinkDisplayModeIterator*           displayModeIterator = NULL;
        IDeckLinkDisplayMode*                   displayMode = NULL;
        HRESULT                                 result;
        int                                     displayModeNumber = 0;
 
        // Query the DeckLink for its configuration interface
        if ((result = deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput)) != S_OK) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Could not obtain the IDeckLinkInput interface: " << bmd_hresult_to_string(result) << "\n";
                if (result == E_NOINTERFACE) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Device doesn't support video capture.\n");
                }
                goto bail;
        }
 
        // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on input
        if ((result = deckLinkInput->GetDisplayModeIterator(&displayModeIterator)) != S_OK) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Could not obtain the video input display mode iterator: " << bmd_hresult_to_string(result) << "\n";
                goto bail;
        }
 
        // List all supported output display modes
        while (displayModeIterator->Next(&displayMode) == S_OK)
        {
                BMD_STR displayModeString = NULL;
 
                result = displayMode->GetName((BMD_STR *) &displayModeString);
 
                if (result == S_OK)
                {
                        BMDTimeValue    frameRateDuration;
                        BMDTimeScale    frameRateScale;
 
                        // Obtain the display mode's properties
                        string flags_str = bmd_get_flags_str(displayMode->GetFlags());
                        int modeWidth = displayMode->GetWidth();
                        int modeHeight = displayMode->GetHeight();
                        displayMode->GetFrameRate(&frameRateDuration, &frameRateScale);
                        uint32_t mode = ntohl(displayMode->GetDisplayMode());
                        uint32_t field_dominance_n = ntohl(displayMode->GetFieldDominance());
                        string fcc{(char *) &mode, 4};
                        string name{get_str_from_bmd_api_str(displayModeString)};
                        char buf[1024];
                        snprintf(buf, sizeof buf, "%d x %d \t %6.2f FPS \t flags: %.4s, %s", modeWidth, modeHeight,
                                        (float) ((double)frameRateScale / (double)frameRateDuration),
                                        (char *) &field_dominance_n, flags_str.c_str());
                        string details{buf};
                        ret.push_back(tuple<int, string, string, string> {displayModeNumber, fcc, name, details});
 
                        release_bmd_api_str(displayModeString);
                }
 
                // Release the IDeckLinkDisplayMode object to prevent a leak
                displayMode->Release();
 
                displayModeNumber++;
        }
 
bail:
        // Ensure that the interfaces we obtained are released to prevent a memory leak
        RELEASE_IF_NOT_NULL(displayModeIterator);
        RELEASE_IF_NOT_NULL(deckLinkInput);
 
        return ret;
}

References bmd_get_flags_str(), bmd_hresult_to_string(), BMD_STR, vidcap_decklink_state::frameRateScale, get_str_from_bmd_api_str(), LOG, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, mode, name, release_bmd_api_str(), and RELEASE_IF_NOT_NULL.

Referenced by print_input_modes(), and vidcap_decklink_probe().

Here is the call graph for this function:

nr_frames()

static int nr_frames ( struct vidcap_decklink_state * s )

static

This function basically counts frames from all devices, optionally with respect to timecode (if synchronized).

Lock needs to be hold during the whole function call.

Parameters

s	Blackmagic state

Returns

number of captured tiles

Definition at line 1566 of file decklink.cpp.

                                                      {
        BMDTimecodeBCD max_timecode = 0u;
        int tiles_total = 0;
        int i;
 
        /* If we use timecode, take maximal timecode value... */
        if (s->sync_timecode) {
                for (i = 0; i < s->devices_cnt; ++i) {
                        if(s->state[i].delegate->newFrameReady == 1) {
                                if (s->state[i].delegate->timecode > max_timecode) {
                                        max_timecode = s->state[i].delegate->timecode;
                                }
                        }
                }
        }
 
        /* count all tiles */
        for (i = 0; i < s->devices_cnt; ++i) {
                if(s->state[i].delegate->newFrameReady == 1) {
                        /* if inputs are synchronized, use only up-to-date frames (with same TC)
                         * as the most recent */
                        if(s->sync_timecode) {
                                if(s->state[i].delegate->timecode && s->state[i].delegate->timecode != max_timecode) {
                                        s->state[i].delegate->newFrameReady = 0;
                                } else {
                                        tiles_total++;
                                }
                        }
                        /* otherwise, simply add up the count */
                        else {
                                tiles_total++;
                        }
                }
                if (s->state[i].delegate->newFrameReady == -1) {
                        return -1;
                }
        }
        return tiles_total;
}

References vidcap_decklink_state::devices_cnt, vidcap_decklink_state::state, and vidcap_decklink_state::sync_timecode.

Referenced by vidcap_decklink_grab().

parse_devices()

static void parse_devices ( struct vidcap_decklink_state * s, const char * devs )

static

Definition at line 706 of file decklink.cpp.

{
        assert(devs != NULL && strlen(devs) > 0);
        char *devices = strdup(devs);
        char *ptr;
        char *save_ptr_dev;
        char *tmp = devices;
 
        s->devices_cnt = 0;
        while ((ptr = strtok_r(tmp, ",", &save_ptr_dev))) {
                s->devices_cnt += 1;
                s->state.resize(s->devices_cnt);
                s->state[s->devices_cnt - 1].device_id = ptr;
                tmp = NULL;
        }
        free (devices);
}

References vidcap_decklink_state::devices_cnt, and vidcap_decklink_state::state.

Referenced by parse_option(), and settings_init().

parse_option()

static bool parse_option ( struct vidcap_decklink_state * s, const char * opt )

static

Definition at line 725 of file decklink.cpp.

{
        const char *val = strchr(opt, '=') + 1;
        if(strcasecmp(opt, "3D") == 0) {
                s->stereo = true;
        } else if(strcasecmp(opt, "timecode") == 0) {
                s->sync_timecode = true;
        } else if (IS_KEY_PREFIX(opt, "codec")) {
                const char *codec = strchr(opt, '=') + 1;
                s->set_codec(get_codec_from_name(codec));
                if(s->codec == VIDEO_CODEC_NONE) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong config. Unknown color space %s\n", codec);
                        return false;
                }
        } else if (IS_KEY_PREFIX(opt, "connection")) {
                const char *connection = strchr(opt, '=') + 1;
                for (auto const & it : get_connection_string_map()) {
                        if (strcasecmp(connection, it.second.c_str()) == 0) {
                                s->device_options[bmdDeckLinkConfigVideoInputConnection] = bmd_option((int64_t) it.first);
                        }
                }
                if (s->device_options.find(bmdDeckLinkConfigVideoInputConnection) == s->device_options.end()) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unrecognized connection %s.\n", connection);
                        return false;
                }
        } else if(strncasecmp(opt, "audio_level=",
                                strlen("audio_level=")) == 0) {
                s->device_options[bmdDeckLinkConfigAnalogAudioConsumerLevels] =
                    bmd_option(bmd_parse_audio_levels(val));
        } else if (IS_KEY_PREFIX(opt, "conversion")) {
                s->device_options[bmdDeckLinkConfigVideoInputConversionMode].parse(strchr(opt, '='));
        } else if (IS_KEY_PREFIX(opt, "device")) {
                parse_devices(s, strchr(opt, '=') + 1);
        } else if (IS_KEY_PREFIX(opt, "mode")) {
                s->mode = strchr(opt, '=') + 1;
        } else if (IS_KEY_PREFIX(opt, "profile")) {
                s->profile.parse(strchr(opt, '=') + 1);
        } else if (strcasecmp(opt, "detect-format") == 0) {
                s->detect_format = true;
        } else if (strcasecmp(opt, "p_not_i") == 0) {
                s->p_not_i = true;
        } else if (strstr(opt, "Use1080PsF") != nullptr) {
                s->device_options[bmdDeckLinkConfigCapture1080pAsPsF].set_flag(strchr(opt, '=') == nullptr || strcasecmp(strchr(opt, '='), "false") != 0);
        } else if (strncasecmp(opt, "passthrough", 4) == 0 ||
                   strncasecmp(opt, "nopassthrough", 6) == 0) {
                if (strstr(opt, "keep")) {
                        s->device_options.erase(bmdDeckLinkConfigCapturePassThroughMode);
                } else {
                        s->device_options[bmdDeckLinkConfigCapturePassThroughMode] = bmd_option((int64_t) (opt[0] == 'n' ? bmdDeckLinkCapturePassthroughModeDisabled
                                : bmdDeckLinkCapturePassthroughModeCleanSwitch));
                }
        } else if (strstr(opt, "full-duplex") == opt) {
                s->profile.set_int(bmdProfileOneSubDeviceFullDuplex);
        } else if (strstr(opt, "half-duplex") == opt) {
                s->profile.set_int(bmdDuplexHalf);
        } else if (strstr(opt, "simplex") == opt) {
                s->profile.set_int(bmdProfileOneSubDeviceHalfDuplex);
        } else if (strcasecmp(opt, "nosig-send") == 0) {
                s->nosig_send = true;
        } else if (strstr(opt, "keep-settings") == opt) {
                s->keep_device_defaults = true;
        } else if ((strchr(opt, '=') != nullptr && strchr(opt, '=') - opt == 4) || strlen(opt) == 4) {
                s->device_options[(BMDDeckLinkConfigurationID) bmd_read_fourcc(opt)].parse(strchr(opt, '=') + 1);
        } else {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unknown option in init string: %s\n", opt);
                return false;
        }
 
        return true;
}

References bmd_parse_audio_levels(), bmd_read_fourcc(), vidcap_decklink_state::codec, vidcap_decklink_state::detect_format, vidcap_decklink_state::device_options, get_codec_from_name(), get_connection_string_map(), IS_KEY_PREFIX, vidcap_decklink_state::keep_device_defaults, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, vidcap_decklink_state::mode, vidcap_decklink_state::nosig_send, vidcap_decklink_state::p_not_i, bmd_option::parse(), parse_devices(), vidcap_decklink_state::profile, vidcap_decklink_state::set_codec(), bmd_option::set_int(), vidcap_decklink_state::stereo, vidcap_decklink_state::sync_timecode, val, and VIDEO_CODEC_NONE.

Referenced by settings_init(), and settings_init_key_val().

Here is the call graph for this function:

postprocess_frame()

static void postprocess_frame ( struct vidcap_decklink_state * s )

static

Definition at line 1644 of file decklink.cpp.

                                                               {
        if (s->codec == RGBA) {
                for (unsigned i = 0; i < s->frame->tile_count; ++i) {
                        vc_copylineToRGBA_inplace((unsigned char*) s->frame->tiles[i].data,
                                        (unsigned char*)s->frame->tiles[i].data,
                                        s->frame->tiles[i].data_len, 16, 8, 0);
                }
        }
        if (s->codec == R10k && get_commandline_param(R10K_FULL_OPT) == nullptr) {
                for (unsigned i = 0; i < s->frame->tile_count; ++i) {
                        r10k_limited_to_full(s->frame->tiles[i].data, s->frame->tiles[i].data,
                                        s->frame->tiles[i].data_len);
                }
        }
}

References vidcap_decklink_state::codec, tile::data, tile::data_len, vidcap_decklink_state::frame, get_commandline_param(), R10k, R10K_FULL_OPT, r10k_limited_to_full(), RGBA, video_frame::tile_count, video_frame::tiles, and vc_copylineToRGBA_inplace.

Referenced by vidcap_decklink_grab().

Here is the call graph for this function:

print_input_modes()

static void print_input_modes ( IDeckLink * deckLink )

static

Definition at line 1840 of file decklink.cpp.

{
        list<tuple<int, string, string, string>> ret = get_input_modes (deckLink);
        printf("\tcapture modes:\n");
        for (auto &i : ret) {
                col() << "\t\t" << right << SBOLD(setw(2) << get<0>(i) << " (" << get<1>(i) << ")") << ") " <<
                        left << setw(20) << get<2>(i) << internal << "  " <<
                        get<3>(i) << "\n";
        }
}

References get_input_modes().

Referenced by vidcap_decklink_print_card_info().

Here is the call graph for this function:

process_new_audio_packets()

static audio_frame * process_new_audio_packets ( struct vidcap_decklink_state * s )

static

Definition at line 1606 of file decklink.cpp.

                                                                               {
        if (s->audioPackets.empty()) {
                return nullptr;
        }
        s->audio.data_len = 0;
 
        BMDTimeValue audio_time = 0;
        s->audioPackets.front()->GetPacketTime(&audio_time, bmdAudioSampleRate48kHz);
        s->audio.timestamp =
            ((int64_t)audio_time * 90000 + bmdAudioSampleRate48kHz - 1) / bmdAudioSampleRate48kHz;
 
        while (!s->audioPackets.empty()) {
                auto *audioPacket = s->audioPackets.front();
                s->audioPackets.pop();
 
                void *audioFrame = nullptr;
                audioPacket->GetBytes(&audioFrame);
 
                if (s->audio.ch_count == 1) { // there are actually 2 channels grabbed
                        if (s->audio.data_len + audioPacket->GetSampleFrameCount() * 1U * s->audio.bps <= static_cast<unsigned>(s->audio.max_size)) {
                                demux_channel(s->audio.data + s->audio.data_len, static_cast<char *>(audioFrame), s->audio.bps, min<int64_t>(audioPacket->GetSampleFrameCount() * 2 /* channels */ * s->audio.bps, INT_MAX), 2 /* channels (originally) */, 0 /* we want first channel */);
                                s->audio.data_len = min<int64_t>(s->audio.data_len + audioPacket->GetSampleFrameCount() * 1 * s->audio.bps, INT_MAX);
                        } else {
                                MSG(WARNING, "Audio frame too small!\n");
                        }
                } else {
                        if (s->audio.data_len + audioPacket->GetSampleFrameCount() * s->audio.ch_count * s->audio.bps <= s->audio.max_size) {
                                memcpy(s->audio.data + s->audio.data_len, audioFrame, audioPacket->GetSampleFrameCount() * s->audio.ch_count * s->audio.bps);
                                s->audio.data_len = min<int64_t>(s->audio.data_len + audioPacket->GetSampleFrameCount() * s->audio.ch_count * s->audio.bps, INT_MAX);
                        } else {
                                MSG(WARNING, "Audio frame too small!\n");
                        }
                }
                audioPacket->Release();
        }
        return &s->audio;
}

References vidcap_decklink_state::audioPackets, demux_channel(), min, and MSG.

Referenced by vidcap_decklink_grab().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	decklink	,
		&	vidcap_decklink_info,
		LIBRARY_CLASS_VIDEO_CAPTURE	,
		VIDEO_CAPTURE_ABI_VERSION	)

set_display_mode_properties()

static HRESULT set_display_mode_properties ( struct vidcap_decklink_state * s, struct tile * tile, IDeckLinkDisplayMode * displayMode, BMDPixelFormat * pf )

static

Definition at line 964 of file decklink.cpp.

{
        BMD_STR displayModeBMDString = nullptr;
 
        if (HRESULT result = displayMode->GetName(&displayModeBMDString); FAILED(result)) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "IDeckLinkDisplayMode::GetName failed: " << bmd_hresult_to_string(result) << "\n";
        }
        string displayModeString = get_str_from_bmd_api_str(displayModeBMDString);
        release_bmd_api_str(displayModeBMDString);
 
        auto it = std::find_if(uv_to_bmd_codec_map.begin(),
                        uv_to_bmd_codec_map.end(),
                        [&s](const std::pair<codec_t, BMDPixelFormat>& el){ return el.first == s->codec; });
        if (it == uv_to_bmd_codec_map.end()) {
                LOG(LOG_LEVEL_ERROR) << "Unsupported codec: " <<  get_codec_name(s->codec) << "!\n";
                return E_FAIL;
        }
        *pf = it->second;
 
        // get avarage time between frames
        BMDTimeValue frameRateDuration = 0;
 
        tile->width = displayMode->GetWidth();
        tile->height = displayMode->GetHeight();
        s->frame->color_spec = s->codec;
 
        displayMode->GetFrameRate(&frameRateDuration, &s->frameRateScale);
        s->frame->fps = static_cast<double>(s->frameRateScale) / frameRateDuration;
        s->next_frame_time = static_cast<int>(std::chrono::microseconds::period::den / s->frame->fps); // in microseconds
        switch(displayMode->GetFieldDominance()) {
                case bmdLowerFieldFirst:
                        bug_msg(LOG_LEVEL_WARNING,
                                MOD_NAME "Lower field first format detected, "
                                         "fields can be switched! ");
                        // fall through
                case bmdUpperFieldFirst:
                        s->frame->interlacing = INTERLACED_MERGED;
                        break;
                case bmdProgressiveFrame:
                case bmdProgressiveSegmentedFrame:
                        s->frame->interlacing = PROGRESSIVE;
                        break;
                case bmdUnknownFieldDominance:
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME "Unknown field dominance!\n";
                        s->frame->interlacing = PROGRESSIVE;
                        break;
        }
 
        if (s->p_not_i) {
                s->frame->interlacing = PROGRESSIVE;
        }
 
        LOG(LOG_LEVEL_DEBUG) << MOD_NAME << displayModeString << " \t " << tile->width << " x " << tile->height << " \t " <<
                s->frame->fps << " FPS \t " << s->next_frame_time << " AVAREGE TIME BETWEEN FRAMES\n";
        LOG(LOG_LEVEL_NOTICE) << MOD_NAME "Enable video input: " << displayModeString << ((s->enable_flags & bmdVideoInputDualStream3D) != 0U ? " (stereoscopic 3D)" : "") << "\n";
 
        tile->data_len =
                vc_get_linesize(tile->width, s->frame->color_spec) * tile->height;
 
        if(s->stereo) {
                s->frame->tile_count = 2;
                s->frame->tiles[1].width = s->frame->tiles[0].width;
                s->frame->tiles[1].height = s->frame->tiles[0].height;
                s->frame->tiles[1].data_len = s->frame->tiles[0].data_len;
        } else {
                s->frame->tile_count = s->devices_cnt;
        }
 
        return S_OK;
}

References bmd_hresult_to_string(), BMD_STR, bug_msg(), vidcap_decklink_state::codec, video_frame::color_spec, tile::data_len, vidcap_decklink_state::devices_cnt, vidcap_decklink_state::enable_flags, FAILED, video_frame::fps, vidcap_decklink_state::frame, vidcap_decklink_state::frameRateScale, get_codec_name(), get_str_from_bmd_api_str(), tile::height, INTERLACED_MERGED, video_frame::interlacing, LOG, LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, MOD_NAME, vidcap_decklink_state::next_frame_time, vidcap_decklink_state::p_not_i, PROGRESSIVE, release_bmd_api_str(), vidcap_decklink_state::stereo, video_frame::tile_count, video_frame::tiles, uv_to_bmd_codec_map, vc_get_linesize(), and tile::width.

Referenced by device_state::init(), and VideoDelegate::VideoInputFormatChanged().

Here is the call graph for this function:

settings_init()

static bool settings_init ( struct vidcap_decklink_state * s, char * fmt )

static

Definition at line 810 of file decklink.cpp.

{
        char *tmp;
        char *save_ptr = NULL;
 
        if (!fmt || (tmp = strtok_r(fmt, ":", &save_ptr)) == NULL) {
                MSG(INFO, "Auto-choosen device 0.\n");
                return true;
        }
 
        // options are in format <device>:<mode>:<codec>[:other_opts]
        if (isdigit(tmp[0]) && strcasecmp(tmp, "3D") != 0) {
                LOG(LOG_LEVEL_WARNING)
                    << MOD_NAME "Deprecated syntax used, please use options in "
                                "format \"key=value\"\n";
                // choose device
                parse_devices(s, tmp);
 
                // choose mode
                tmp = strtok_r(NULL, ":", &save_ptr);
                if(tmp) {
                        s->mode = tmp;
 
                        tmp = strtok_r(NULL, ":", &save_ptr);
                        if (tmp) {
                                s->set_codec(get_codec_from_name(tmp));
                                if(s->codec == VIDEO_CODEC_NONE) {
                                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong config. Unknown color space %s\n", tmp);
                                        return false;
                                }
                        }
                        if (!settings_init_key_val(s, &save_ptr)) {
                                return false;
                        }
                }
        } else { // options are in format key=val
                if (!parse_option(s, tmp)) {
                        return false;
                }
                if (!settings_init_key_val(s, &save_ptr)) {
                        return false;
                }
        }
 
        return true;
}

References vidcap_decklink_state::codec, fmt, get_codec_from_name(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, vidcap_decklink_state::mode, MSG, parse_devices(), parse_option(), vidcap_decklink_state::set_codec(), settings_init_key_val(), and VIDEO_CODEC_NONE.

Referenced by vidcap_decklink_init().

Here is the call graph for this function:

settings_init_key_val()

static bool settings_init_key_val ( struct vidcap_decklink_state * s, char ** save_ptr )

static

Definition at line 796 of file decklink.cpp.

{
        char *tmp;
 
        while((tmp = strtok_r(NULL, ":", save_ptr))) {
                if (!parse_option(s, tmp)) {
                        return false;
                }
        }
 
        return true;
}

References parse_option().

Referenced by settings_init().

Here is the call graph for this function:

vidcap_decklink_done()

static void vidcap_decklink_done ( void * state )

static

Definition at line 1519 of file decklink.cpp.

{
        debug_msg("vidcap_decklink_done\n"); /* TOREMOVE */
 
        HRESULT result;
 
        struct vidcap_decklink_state *s = (struct vidcap_decklink_state *) state;
 
        assert (s != NULL);
 
        for (int i = 0; i < s->devices_cnt; ++i)
        {
                result = s->state[i].deckLinkInput->StopStreams();
                if (result != S_OK) {
                        LOG(LOG_LEVEL_ERROR)
                            << MOD_NAME "Could not stop stream: "
                            << bmd_hresult_to_string(result) << "\n";
                }
 
                if (s->state[i].audio) {
                        result = s->state[i].deckLinkInput->DisableAudioInput();
                        if (result != S_OK) {
                                LOG(LOG_LEVEL_ERROR)
                                    << MOD_NAME "Could disable audio input: "
                                    << bmd_hresult_to_string(result) << "\n";
                        }
                }
                result = s->state[i].deckLinkInput->DisableVideoInput();
                if (result != S_OK) {
                        LOG(LOG_LEVEL_ERROR)
                            << MOD_NAME "Could disable video input: "
                            << bmd_hresult_to_string(result) << "\n";
                }
        }
 
        cleanup_common(s);
}

References bmd_hresult_to_string(), cleanup_common(), debug_msg, vidcap_decklink_state::devices_cnt, LOG, LOG_LEVEL_ERROR, MOD_NAME, state, and vidcap_decklink_state::state.

Here is the call graph for this function:

vidcap_decklink_grab()

static struct video_frame * vidcap_decklink_grab ( void * state, struct audio_frame ** audio )

static

Definition at line 1661 of file decklink.cpp.

{
        struct vidcap_decklink_state    *s = (struct vidcap_decklink_state *) state;
        int                             tiles_total = 0;
        int                             i;
        bool                            frame_ready = true;
        
        int timeout = 0;
 
        unique_lock<mutex> lk(s->lock);
// LOCK - LOCK - LOCK - LOCK - LOCK - LOCK - LOCK - LOCK - LOCK - LOCK - LOCK //
 
        tiles_total = nr_frames(s);
 
        while(tiles_total != s->devices_cnt) {
        //while (!s->state[0].delegate->newFrameReady) {
                cv_status rc = cv_status::no_timeout;
                steady_clock::time_point t0(steady_clock::now());
 
                while(rc == cv_status::no_timeout
                                && tiles_total != s->devices_cnt /* not all tiles */
                                && tiles_total != -1
                                && !timeout) {
                        rc = s->boss_cv.wait_for(lk, microseconds(2 * s->next_frame_time));
                        // recompute tiles count
                        tiles_total = nr_frames(s);
 
                        // this is for the case of multiple tiles (eg. when one tile is persistently
                        // missing, eg. 01301301. Therefore, pthread_cond_timewait doesn't timeout but
                        // actual timeout time has reached.
                        steady_clock::time_point t(steady_clock::now());
                        if (duration_cast<microseconds>(t - t0).count() > 2 * s->next_frame_time)
                                timeout = 1;
 
                }
 
                if (rc != cv_status::no_timeout || timeout || tiles_total == -1) { //(rc == ETIMEDOUT) {
                        log_msg(LOG_LEVEL_VERBOSE, "Waiting for new frame timed out!\n");
 
                        // try to restart stream
                        /*
                        HRESULT result;
                        debug_msg("Try to restart DeckLink stream!\n");
                        result = s->deckLinkInput->StopStreams();
                        if (result != S_OK)
                        {
                                debug_msg("Could not stop stream: %08x\n", result);
                        }
                        result = s->deckLinkInput->StartStreams();
                        if (result != S_OK)
                        {
                                debug_msg("Could not start stream: %08x\n", result);
                                return NULL; // really end ???
                        }
                        */
 
                        frame_ready = false;
                        break;
                }
        }
 
        /* cleanup newframe flag */
        for (i = 0; i < s->devices_cnt; ++i) {
                if(s->state[i].delegate->newFrameReady == 0) {
                        frame_ready = false;
                }
                s->state[i].delegate->newFrameReady = 0;
        }
 
        *audio = process_new_audio_packets(s); // return audio even if there is no video to avoid
                                               //  hoarding and then dropping of audio packets
// UNLOCK - UNLOCK - UNLOCK - UNLOCK - UNLOCK - UNLOCK - UNLOCK - UNLOCK - UN //
        lk.unlock();
 
        if(!frame_ready)
                return NULL;
 
        /* count returned tiles */
        int count = 0;
        if(s->stereo) {
                if (s->state[0].delegate->pixelFrame != NULL &&
                                s->state[0].delegate->pixelFrameRight != NULL) {
                        s->frame->tiles[0].data = (char*)s->state[0].delegate->pixelFrame;
                        s->frame->tiles[1].data = (char*)s->state[0].delegate->pixelFrameRight;
                        ++count;
                } // else count == 0 -> return NULL
        } else {
                for (i = 0; i < s->devices_cnt; ++i) {
                        if (s->state[i].delegate->pixelFrame == NULL) {
                                break;
                        }
                        s->frame->tiles[i].data = (char*)s->state[i].delegate->pixelFrame;
                        ++count;
                }
        }
        if (count < s->devices_cnt) {
                return NULL;
        }
        postprocess_frame(s);
 
        s->frames++;
        s->frame->timecode = s->state[0].delegate->timecode;
        s->frame->timestamp =
            ((int64_t)s->state[0].delegate->frameTime * 90000 +
             s->frameRateScale - 1) /
            s->frameRateScale;
        return s->frame;
}

References audio, vidcap_decklink_state::boss_cv, count, tile::data, vidcap_decklink_state::devices_cnt, vidcap_decklink_state::frame, vidcap_decklink_state::frameRateScale, vidcap_decklink_state::frames, vidcap_decklink_state::lock, LOG_LEVEL_VERBOSE, log_msg(), vidcap_decklink_state::next_frame_time, nr_frames(), postprocess_frame(), process_new_audio_packets(), state, vidcap_decklink_state::state, vidcap_decklink_state::stereo, video_frame::tiles, video_frame::timecode, and video_frame::timestamp.

Here is the call graph for this function:

vidcap_decklink_init()

static int vidcap_decklink_init ( struct vidcap_params * params, void ** state )

static

Definition at line 1414 of file decklink.cpp.

{
        const char *fmt = vidcap_params_get_fmt(params);
 
        if (strcmp(fmt, "help") == 0 || strcmp(fmt, "fullhelp") == 0) {
                decklink_help(strcmp(fmt, "fullhelp") == 0);
                return VIDCAP_INIT_NOERR;
        }
        if (IS_KEY_PREFIX(fmt, "query")) {
                decklink_help(true, strchr(fmt, '=') + 1);
                return VIDCAP_INIT_NOERR;
        }
 
        if (!blackmagic_api_version_check()) {
                return VIDCAP_INIT_FAIL;
        }
 
        struct vidcap_decklink_state *s = nullptr;
        try {
                if ((s = new vidcap_decklink_state()) == nullptr) {
                        LOG(LOG_LEVEL_ERROR) << "Unable to allocate DeckLink state\n";
                        return VIDCAP_INIT_FAIL;
                }
        } catch(...) {
                return VIDCAP_INIT_FAIL;
        }
 
        // SET UP device and mode
        char *tmp_fmt = strdup(fmt);
        bool ret =  false;
        try {
                ret = settings_init(s, tmp_fmt);
        } catch (exception &e) {
                MSG(ERROR, "%s\n", e.what());
        }
        free(tmp_fmt);
        if (!ret) {
                delete s;
                return VIDCAP_INIT_FAIL;
        }
 
        switch (get_bits_per_component(s->codec)) {
        case 0: s->requested_bit_depth = 0; break;
        case 8: s->requested_bit_depth = bmdDetectedVideoInput8BitDepth; break;
        case 10: s->requested_bit_depth = bmdDetectedVideoInput10BitDepth; break;
        case 12: s->requested_bit_depth = bmdDetectedVideoInput12BitDepth; break;
        default: abort();
        }
        if (s->codec == VIDEO_CODEC_NONE) {
                s->set_codec(UYVY); // default one
        }
 
        BMDAudioConnection audioConnection = bmdAudioConnectionEmbedded;
        if (!decklink_cap_configure_audio(s, vidcap_params_get_flags(params) & VIDCAP_FLAG_AUDIO_ANY, &audioConnection)) {
                delete s;
                return VIDCAP_INIT_FAIL;
        }
 
        if(s->stereo) {
                s->enable_flags |= bmdVideoInputDualStream3D;
                s->supported_flags = (BMDSupportedVideoModeFlags) (s->supported_flags | bmdSupportedVideoModeDualStream3D);
                if (s->devices_cnt > 1) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Passed more than one device while setting 3D mode. "
                                        "In this mode, only one device needs to be passed.");
                        delete s;
                        return VIDCAP_INIT_FAIL;
                }
        }
        s->frame = vf_alloc(MAX(s->devices_cnt, 2));
        s->frame->tile_count = s->stereo ? 2 : s->devices_cnt;
        s->frame->flags |= TIMESTAMP_VALID;
 
        /* TODO: make sure that all devices are have compatible properties */
        for (int i = 0; i < s->devices_cnt; ++i) {
                if (!s->state[i].init(s, vf_get_tile(s->frame, i), audioConnection)) {
                        cleanup_common(s);
                        return VIDCAP_INIT_FAIL;
                }
        }
 
        *state = s;
        return VIDCAP_INIT_OK;
}

References vidcap_decklink_state::vidcap_decklink_state(), blackmagic_api_version_check(), cleanup_common(), vidcap_decklink_state::codec, decklink_cap_configure_audio(), decklink_help(), vidcap_decklink_state::devices_cnt, vidcap_decklink_state::enable_flags, video_frame::flags, fmt, vidcap_decklink_state::frame, get_bits_per_component(), IS_KEY_PREFIX, LOG, LOG_LEVEL_ERROR, log_msg(), MAX, MOD_NAME, MSG, vidcap_decklink_state::requested_bit_depth, vidcap_decklink_state::set_codec(), settings_init(), state, vidcap_decklink_state::state, vidcap_decklink_state::stereo, vidcap_decklink_state::supported_flags, video_frame::tile_count, TIMESTAMP_VALID, UYVY, vf_alloc(), vf_get_tile(), VIDCAP_FLAG_AUDIO_ANY, VIDCAP_INIT_FAIL, VIDCAP_INIT_NOERR, VIDCAP_INIT_OK, vidcap_params_get_flags(), vidcap_params_get_fmt(), and VIDEO_CODEC_NONE.

Here is the call graph for this function:

vidcap_decklink_print_card_info()

static void vidcap_decklink_print_card_info ( IDeckLink * deckLink, const char * query_prop_fcc )

static

Parameters

query_prop_fcc

if not NULL, print corresponding BMDDeckLinkAttribute

Definition at line 470 of file decklink.cpp.

{
 
        // ** List the video input display modes supported by the card
        print_input_modes(deckLink);
 
        IDeckLinkProfileAttributes *deckLinkAttributes = nullptr;
 
        HRESULT result = deckLink->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes);
        if (result != S_OK) {
                cout << "Could not query device attributes.\n\n";
                return;
        }
 
        IDeckLinkInput *deckLinkInput = nullptr;
        color_printf("\n\tsupported pixel formats:" TERM_BOLD);
        if ((deckLink->QueryInterface(IID_IDeckLinkInput,
                                      (void **) &deckLinkInput)) == S_OK) {
                for (auto &c : uv_to_bmd_codec_map) {
                        if (decklink_supports_codec(deckLinkInput, c.second)) {
                                printf(" %s", get_codec_name(c.first));
                        }
                }
                RELEASE_IF_NOT_NULL(deckLinkInput);
        } else {
                color_printf(TRED("(error)"));
        }
        color_printf(TERM_RESET "\n");
 
        int64_t connections = 0;
        if (deckLinkAttributes->GetInt(BMDDeckLinkVideoInputConnections, &connections) != S_OK) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Could not get connections.\n";
        } else {
                cout << "\n\tConnection can be one of following:\n";
                for (auto const &it : get_connection_string_map()) {
                        if (connections & it.first) {
                                col() << "\t\t" << SBOLD(it.second) << "\n";
                        }
                }
        }
        cout << "\n";
 
        if (query_prop_fcc != nullptr) {
                print_bmd_attribute(deckLinkAttributes, query_prop_fcc);
                cout << "\n";
        }
 
        // Release the IDeckLink instance when we've finished with it to prevent leaks
        RELEASE_IF_NOT_NULL(deckLinkAttributes);
}

References color_printf(), device_state::deckLink, decklink_supports_codec(), device_state::deckLinkAttributes, device_state::deckLinkInput, get_codec_name(), get_connection_string_map(), LOG, LOG_LEVEL_ERROR, MOD_NAME, print_bmd_attribute(), print_input_modes(), RELEASE_IF_NOT_NULL, SBOLD, TERM_BOLD, TERM_RESET, TRED, and uv_to_bmd_codec_map.

Referenced by decklink_help().

Here is the call graph for this function:

vidcap_decklink_probe()

static void vidcap_decklink_probe ( device_info ** available_cards, int * card_count, void(** deleter )(void *) )

static

Definition at line 859 of file decklink.cpp.

{
        device_info *cards = nullptr;
        *card_count = 0;
        *deleter = free;
 
        // Create an IDeckLinkIterator object to enumerate all DeckLink cards in the system
        bool com_initialized = false;
 
        // Enumerate all cards in this system
        for (auto &d : bmd_get_sorted_devices(&com_initialized, false)) {
                IDeckLink *deckLink = get<0>(d).get();
                HRESULT result;
                IDeckLinkProfileAttributes *deckLinkAttributes;
 
                result = deckLink->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes);
                if (result != S_OK) {
                        continue;
                }
                int64_t connections_bitmap;
                if(deckLinkAttributes->GetInt(BMDDeckLinkVideoInputConnections, &connections_bitmap) != S_OK) {
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "Could not get connections, skipping device.\n");
                        continue;
                }
 
                string deviceName = bmd_get_device_name(deckLink);
                if (deviceName.empty()) {
                        deviceName = "(unknown)";
                }
 
                *card_count += 1;
                cards = (struct device_info *)
                        realloc(cards, *card_count * sizeof(struct device_info));
                memset(&cards[*card_count - 1], 0, sizeof(struct device_info));
                snprintf(cards[*card_count - 1].dev, sizeof cards[*card_count - 1].dev,
                                ":device=%6x", get<unsigned>(d));
                snprintf(cards[*card_count - 1].name, sizeof cards[*card_count - 1].name,
                                "%s", deviceName.c_str());
                snprintf(cards[*card_count - 1].extra, sizeof cards[*card_count - 1].extra,
                                "\"embeddedAudioAvailable\":\"t\"");
 
 
                list<string> connections;
                for (auto const &it : get_connection_string_map()) {
                        if (connections_bitmap & it.first) {
                                connections.push_back(it.second);
                        }
                }
                list<tuple<int, string, string, string>> modes = get_input_modes (deckLink);
 
                int i = 0;
                const int mode_count = sizeof cards[*card_count - 1].modes /
                                                sizeof cards[*card_count - 1].modes[0];
 
                for (auto &c : connections) {
                        if (i >= mode_count) {
                                break;
                        }
                        snprintf(cards[*card_count - 1].modes[i].id,
                                        sizeof cards[*card_count - 1].modes[i].id,
                                        R"({"modeOpt":"connection=%s:codec=UYVY"})",
                                        c.c_str());
                        snprintf(cards[*card_count - 1].modes[i].name,
                                        sizeof cards[*card_count - 1].modes[i].name,
                                        "DeckLink Auto (%s)", c.c_str());
                        if (++i >= mode_count) {
                                break;
                        }
                        snprintf(cards[*card_count - 1].modes[i].id,
                                        sizeof cards[*card_count - 1].modes[i].id,
                                        R"({"modeOpt":"detect-format:connection=%s:codec=UYVY"})",
                                        c.c_str());
                        snprintf(cards[*card_count - 1].modes[i].name,
                                        sizeof cards[*card_count - 1].modes[i].name,
                                        "UltraGrid auto-detect (%s) (SLOW)", c.c_str());
                        i++;
                }
 
                for (auto &m : modes) {
                        for (auto &c : connections) {
                                if (i >= mode_count) { // no space
                                        break;
                                }
 
                                snprintf(cards[*card_count - 1].modes[i].id,
                                                sizeof cards[*card_count - 1].modes[i].id,
                                                R"({"modeOpt":"connection=%s:mode=%s:codec=UYVY"})",
                                                c.c_str(), get<1>(m).c_str());
                                snprintf(cards[*card_count - 1].modes[i].name,
                                                sizeof cards[*card_count - 1].modes[i].name,
                                                "%s (%s)", get<2>(m).c_str(), c.c_str());
                                i++;
                        }
                }
 
                dev_add_option(&cards[*card_count - 1], "3D", "3D", "3D", ":3D", true);
                dev_add_option(&cards[*card_count - 1], "Profile", "Duplex profile can be one of: 1dhd, 2dhd, 2dfd, 4dhd, keep", "profile", ":profile=", false);
 
                RELEASE_IF_NOT_NULL(deckLinkAttributes);
        }
 
        decklink_uninitialize(&com_initialized);
        *available_cards = cards;
}

References bmd_get_device_name(), bmd_get_sorted_devices(), device_state::deckLink, decklink_uninitialize(), device_state::deckLinkAttributes, deleter, device_info::dev, dev_add_option(), device_info::extra, get_connection_string_map(), get_input_modes(), LOG_LEVEL_WARNING, log_msg(), MOD_NAME, device_info::modes, name, and RELEASE_IF_NOT_NULL.

Here is the call graph for this function:

Variable Documentation

DEFAULT_AUDIO_BPS

const int DEFAULT_AUDIO_BPS = 4

constexpr

Definition at line 89 of file decklink.cpp.

Referenced by decklink_cap_configure_audio().

MAX_AUDIO_PACKETS

const size_t MAX_AUDIO_PACKETS = 10

constexpr

Definition at line 90 of file decklink.cpp.

Referenced by VideoDelegate::VideoInputFrameArrived().

vidcap_decklink_info

const struct video_capture_info vidcap_decklink_info

static

Initial value:

= {
        vidcap_decklink_probe,
        vidcap_decklink_init,
        vidcap_decklink_done,
        vidcap_decklink_grab,
        MOD_NAME,
}

Definition at line 1861 of file decklink.cpp.

                                                              {
        vidcap_decklink_probe,
        vidcap_decklink_init,
        vidcap_decklink_done,
        vidcap_decklink_grab,
        MOD_NAME,
};