device_state Struct Reference

Collaboration diagram for device_state:

Public Member Functions
void	check_attributes (struct vidcap_decklink_state *s)
bool	init (struct vidcap_decklink_state *s, struct tile *tile, BMDAudioConnection audioConnection)

Public Attributes
bool	audio = false
IDeckLink *	deckLink = nullptr
IDeckLinkProfileAttributes *	deckLinkAttributes = nullptr
IDeckLinkConfiguration *	deckLinkConfiguration = nullptr
IDeckLinkInput *	deckLinkInput = nullptr
unique_ptr< VideoDelegate >	delegate
string	device_id = "0"
struct tile *	tile = nullptr

Detailed Description

Definition at line 169 of file decklink.cpp.

Member Function Documentation

check_attributes()

void device_state::check_attributes

(

struct vidcap_decklink_state *

s

)

Definition at line 1127 of file decklink.cpp.

{
        if (s->stereo) {
                bmd_check_stereo_profile(deckLink);
        }
}

References bmd_check_stereo_profile(), deckLink, and vidcap_decklink_state::stereo.

Referenced by init().

Here is the call graph for this function:

init()

bool device_state::init	(	struct vidcap_decklink_state *	s,
		struct tile *	tile,
		BMDAudioConnection	audioConnection )

Definition at line 1135 of file decklink.cpp.

{
        IDeckLinkDisplayModeIterator*   displayModeIterator = NULL;
        IDeckLinkDisplayMode*           displayMode = NULL;
 
        tile = t;
 
        bool com_initialized = false;
        for (auto &d : bmd_get_sorted_devices(&com_initialized, true)) {
                deckLink = get<0>(d).release(); // we must release manually!
                string deviceName = bmd_get_device_name(deckLink);
                if (!deviceName.empty() && deviceName == device_id.c_str()) {
                        break;
                }
 
                // topological ID
                const unsigned long tid =
                    strtoul(device_id.c_str(), nullptr, 16);
                if (get<unsigned>(d) == tid) {
                        break;
                }
                // natural (old) index
                if (isdigit(device_id.c_str()[0])) {
                        if (atoi(device_id.c_str()) == get<int>(d)) {
                                break;
                        }
                }
                // new (character) index
                if (device_id.length() == 1 && device_id[0] >= 'a') {
                        if (device_id[0] == get<char>(d)) {
                                break;
                        }
                }
 
                // Release the IDeckLink instance when we've finished with it to prevent leaks
                deckLink->Release();
                deckLink = NULL;
        }
 
        if (deckLink == nullptr) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Device " << device_id << " was not found.\n";
                INIT_ERR();
        }
 
        // Print the model name of the DeckLink card
        string deviceName = bmd_get_device_name(deckLink);
        if (!deviceName.empty()) {
                LOG(LOG_LEVEL_INFO) << MOD_NAME "Using device " << deviceName << "\n";
        }
 
        if (!s->keep_device_defaults && !s->profile.keep()) {
                if (!decklink_set_profile(deckLink, s->profile, s->stereo)) {
                        INIT_ERR();
                }
        }
 
        // Query the DeckLink for its configuration interface
        BMD_CHECK(deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&deckLinkInput), "Could not obtain the IDeckLinkInput interface", INIT_ERR());
 
        // Query the DeckLink for its configuration interface
        BMD_CHECK(deckLinkInput->QueryInterface(IID_IDeckLinkConfiguration, (void**)&deckLinkConfiguration), "Could not obtain the IDeckLinkConfiguration interface", INIT_ERR());
 
        IDeckLinkProfileAttributes *deckLinkAttributes;
        BMD_CHECK(deckLinkInput->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes), "Could not query device attributes", INIT_ERR());
 
        for (const auto &o : s->device_options) {
                if (s->keep_device_defaults && !o.second.is_user_set()) {
                        continue;
                }
                if (!o.second.device_write(deckLinkConfiguration, o.first, MOD_NAME)) {
                        INIT_ERR();
                }
        }
        const BMDVideoInputConversionMode supported_conversion_mode = s->device_options.find(bmdDeckLinkConfigVideoInputConversionMode) != s->device_options.end() ? (BMDVideoInputConversionMode) s->device_options.at(bmdDeckLinkConfigVideoInputConversionMode).get_int() : (BMDVideoInputConversionMode) bmdNoVideoInputConversion;
        if (s->stereo) {
                CALL_AND_CHECK(deckLinkConfiguration->SetFlag(bmdDeckLinkConfigSDIInput3DPayloadOverride, true), "Unable to set 3D payload override");
        }
 
        // set Callback which returns frames
        delegate = make_unique<VideoDelegate>(s, *this);
        deckLinkInput->SetCallback(delegate.get());
 
        BMDDisplayMode detectedDisplayMode = bmdModeUnknown;
        if (s->detect_format) {
                if (!detect_format(s, &detectedDisplayMode, this)) {
                        LOG(LOG_LEVEL_WARNING) << "Signal could have not been detected!\n";
                        INIT_ERR();
                }
        }
 
        // Obtain an IDeckLinkDisplayModeIterator to enumerate the display modes supported on input
        BMD_CHECK(deckLinkInput->GetDisplayModeIterator(&displayModeIterator),
                        "Could not obtain the video input display mode iterator:", INIT_ERR());
 
        check_attributes(s);
 
        int mnum = 0;
        enum { MODE_SPEC_AUTODETECT = -1, MODE_SPEC_FOURCC = -2, MODE_SPEC_DETECTED = -3 };
        int mode_idx = MODE_SPEC_AUTODETECT;
 
        // mode selected manually - either by index or FourCC
        if (s->mode.length() > 0) {
                if (s->mode.length() <= 2) {
                        mode_idx = atoi(s->mode.c_str());
                } else {
                        mode_idx = MODE_SPEC_FOURCC;
                }
        }
        if (s->detect_format) { // format already detected manually
                mode_idx = MODE_SPEC_DETECTED;
        }
 
        while (displayModeIterator->Next(&displayMode) == S_OK) {
                if (mode_idx == MODE_SPEC_DETECTED) { // format already detected manually
                        if (detectedDisplayMode == displayMode->GetDisplayMode()) {
                                break;
                        } else {
                                displayMode->Release();
                        }
                } else if (mode_idx == MODE_SPEC_AUTODETECT) { // autodetect, pick first eligible mode and let device autodetect
                        if ((s->stereo && (displayMode->GetFlags() & bmdDisplayModeSupports3D) == 0u) || displayMode->GetFieldDominance() == bmdLowerFieldFirst) {
                                displayMode->Release();
                                continue;
                        }
                        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";
                                INIT_ERR();
                        }
                        BMDPixelFormat pf = it->second;
                        BMD_BOOL supported = 0;
                        const BMDVideoConnection connection = s->device_options.find(bmdDeckLinkConfigVideoInputConnection) != s->device_options.end()
                                ? (BMDVideoConnection) s->device_options.at(bmdDeckLinkConfigVideoInputConnection).get_int() : (BMDVideoConnection) bmdVideoConnectionUnspecified;
                        BMD_CHECK(deckLinkInput->DoesSupportVideoMode(connection, displayMode->GetDisplayMode(), pf, supported_conversion_mode, s->supported_flags, nullptr, &supported), "DoesSupportVideoMode", INIT_ERR());
                        if (supported) {
                                break;
                        }
                } else if (mode_idx != MODE_SPEC_FOURCC) { // manually given idx
                        if (mode_idx != mnum) {
                                mnum++;
                                // Release the IDeckLinkDisplayMode object to prevent a leak
                                displayMode->Release();
                                continue;
                        }
 
                        mnum++;
                        break;
                } else { // manually given FourCC
                        if (displayMode->GetDisplayMode() == bmd_read_fourcc(s->mode.c_str())) {
                                break;
                        }
                        displayMode->Release();
                }
        }
 
        if (displayMode) {
                BMD_STR displayModeString = NULL;
                if (HRESULT result = displayMode->GetName(&displayModeString); result == S_OK) {
                        LOG(LOG_LEVEL_INFO)
                            << "The desired display mode is supported: "
                            << get_str_from_bmd_api_str(displayModeString)
                            << "\n";
                        release_bmd_api_str(displayModeString);
                }
        } else {
                if (mode_idx == MODE_SPEC_FOURCC) {
                        MSG(ERROR,
                            "Desired mode \"%s\" is invalid or not "
                            "supported.\n",
                            s->mode.c_str());
                } else if (mode_idx >= 0) {
                        MSG(ERROR, "Desired mode index %s is out of bounds.\n", s->mode.c_str());
                } else if (mode_idx == MODE_SPEC_AUTODETECT) {
                        MSG(ERROR, "Cannot set initial format for "
                                   "autodetection - perhaps imposible "
                                   "combinations of parameters were set.\n");
                } else {
                        assert("Invalid mode spec." && 0);
                }
                INIT_ERR();
        }
 
        BMDPixelFormat pf;
        BMD_CHECK(set_display_mode_properties(s, tile, displayMode, &pf),
                        "Could not set display mode properties", INIT_ERR());
 
        deckLinkInput->StopStreams();
 
        if (mode_idx == MODE_SPEC_AUTODETECT) {
                MSG(INFO, "Trying to autodetect format.\n");
                BMD_BOOL autodetection;
                BMD_CHECK(deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInputFormatDetection, &autodetection), "Could not verify if device supports autodetection", INIT_ERR());
                if (autodetection == BMD_FALSE) {
                        MSG(ERROR,
                            "Device doesn't support format autodetection, you "
                            "must set it manually or try \"-t "
                            "decklink:detect-format[:connection=<in>]\"\n");
                        INIT_ERR();
                }
                s->enable_flags |=  bmdVideoInputEnableFormatDetection;
        }
 
        BMD_BOOL supported = 0;
        const BMDVideoConnection connection = s->device_options.find(bmdDeckLinkConfigVideoInputConnection) != s->device_options.end()
                ? (BMDVideoConnection) s->device_options.at(bmdDeckLinkConfigVideoInputConnection).get_int() : (BMDVideoConnection) bmdVideoConnectionUnspecified;
        BMD_CHECK(deckLinkInput->DoesSupportVideoMode(connection, displayMode->GetDisplayMode(), pf, supported_conversion_mode, s->supported_flags, nullptr, &supported), "DoesSupportVideoMode", INIT_ERR());
 
        if (!supported) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Requested display mode not supported with the selected pixel format\n";
                INIT_ERR();
        }
 
        if (HRESULT result = deckLinkInput->EnableVideoInput(displayMode->GetDisplayMode(), pf, s->enable_flags); result != S_OK) {
                switch (result) {
                        case E_INVALIDARG:
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "You have required invalid video mode and pixel format combination.\n");
                                break;
                        case E_ACCESSDENIED:
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to access the hardware or input "
                                                "stream currently active (another application using it?).\n");
                                break;
                        default:
                                LOG(LOG_LEVEL_ERROR) << MOD_NAME "Could not enable video input: " << bmd_hresult_to_string(result) << "\n";
                }
                INIT_ERR();
        }
 
        if (!audio) { //TODO: figure out output from multiple streams
                deckLinkInput->DisableAudioInput();
        } else {
                if (deckLinkConfiguration->SetInt(bmdDeckLinkConfigAudioInputConnection,
                                        audioConnection) == S_OK) {
                        const map<BMDAudioConnection, string> mapping = {
                                { bmdAudioConnectionEmbedded, "embedded" },
                                { bmdAudioConnectionAESEBU, "AES/EBU" },
                                { bmdAudioConnectionAnalog, "analog" },
                                { bmdAudioConnectionAnalogXLR, "analogXLR" },
                                { bmdAudioConnectionAnalogRCA, "analogRCA" },
                                { bmdAudioConnectionMicrophone, "microphone" },
                                { bmdAudioConnectionHeadphones, "headphones" },
                        };
                        log_msg(LOG_LEVEL_INFO, MOD_NAME "Audio input set to: %s\n", mapping.find(audioConnection) != mapping.end() ? mapping.at(audioConnection).c_str() : "unknown");
                } else {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to set audio input!!! Please check if it is OK. Continuing anyway.\n");
 
                }
                if (s->audio.ch_count == 4 ||
                    s->audio.ch_count > BMD_MAX_AUD_CH ||
                    !is_power_of_two(s->audio.ch_count)) {
                        log_msg(LOG_LEVEL_WARNING,
                                MOD_NAME
                                "DeckLink may not be able to grab %d audio "
                                "channels. "
                                "1, 2, 8, 16, 32 or 64 may work.\n",
                                s->audio.ch_count);
                }
                BMD_CHECK(deckLinkInput->EnableAudioInput(
                              bmdAudioSampleRate48kHz,
                              s->audio.bps == 2
                                  ? bmdAudioSampleType16bitInteger
                                  : bmdAudioSampleType32bitInteger,
                              max(s->audio.ch_count, 2)), // capture at least 2
                          "EnableAudioInput", INIT_ERR());
        }
 
        // Start streaming
        BMD_CHECK(deckLinkInput->StartStreams(), "Could not start stream", INIT_ERR());
 
        displayMode->Release();
        displayMode = NULL;
 
        displayModeIterator->Release();
        displayModeIterator = NULL;
        return true;
}

References audio, BMD_BOOL, BMD_CHECK, BMD_FALSE, bmd_get_device_name(), bmd_get_sorted_devices(), bmd_hresult_to_string(), BMD_MAX_AUD_CH, bmd_read_fourcc(), BMD_STR, CALL_AND_CHECK, check_attributes(), vidcap_decklink_state::codec, deckLink, decklink_set_profile(), deckLinkAttributes, deckLinkConfiguration, deckLinkInput, delegate, detect_format(), vidcap_decklink_state::detect_format, device_id, vidcap_decklink_state::device_options, vidcap_decklink_state::enable_flags, get_codec_name(), get_str_from_bmd_api_str(), INIT_ERR, is_power_of_two(), bmd_option::keep(), vidcap_decklink_state::keep_device_defaults, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), mapping, MOD_NAME, vidcap_decklink_state::mode, MSG, vidcap_decklink_state::profile, release_bmd_api_str(), set_display_mode_properties(), vidcap_decklink_state::stereo, vidcap_decklink_state::supported_flags, and uv_to_bmd_codec_map.

Here is the call graph for this function:

Member Data Documentation

audio

bool device_state::audio = false

Definition at line 176 of file decklink.cpp.

Referenced by init().

deckLink

IDeckLink* device_state::deckLink = nullptr

Definition at line 170 of file decklink.cpp.

Referenced by check_attributes(), decklink_help(), init(), vidcap_decklink_print_card_info(), and vidcap_decklink_probe().

deckLinkAttributes

IDeckLinkProfileAttributes* device_state::deckLinkAttributes = nullptr

Definition at line 173 of file decklink.cpp.

Referenced by init(), vidcap_decklink_print_card_info(), and vidcap_decklink_probe().

deckLinkConfiguration

IDeckLinkConfiguration* device_state::deckLinkConfiguration = nullptr

Definition at line 174 of file decklink.cpp.

Referenced by init().

deckLinkInput

IDeckLinkInput* device_state::deckLinkInput = nullptr

Definition at line 171 of file decklink.cpp.

Referenced by detect_format(), init(), vidcap_decklink_print_card_info(), and VideoDelegate::VideoInputFormatChanged().

delegate

unique_ptr<VideoDelegate> device_state::delegate

Definition at line 172 of file decklink.cpp.

Referenced by detect_format(), and init().

device_id

string device_state::device_id = "0"

Definition at line 175 of file decklink.cpp.

Referenced by init().

tile

struct tile* device_state::tile = nullptr

Definition at line 177 of file decklink.cpp.

Referenced by VideoDelegate::VideoInputFormatChanged().

---

The documentation for this struct was generated from the following file:

• src/video_capture/decklink.cpp