#include "DeckLinkAPI.h"
#include <cctype>
#include <cstdbool>
#include <cstdint>
#include <map>
#include <memory>
#include <tuple>
#include <vector>
#include <string>
#include <type_traits>
#include <utility>
#include "utils/macros.h"
#include "video.h"

Include dependency graph for blackmagic_common.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	bmd_option

Macros
#define	BMD_BOOL bool

#define	BMD_CHECK(cmd, name, action)

#define	BMD_FALSE false

#define	BMD_NAT_SORT "bmd-sort-natural"

#define	BMD_STR const char *

#define	BMD_TRUE true

#define	R10K_FULL_OPT "bmd-r10k-full-range"

Typedefs
using	bmd_dev

Enumerations
enum	{ BMD_MAX_AUD_CH = 64 }

Functions
bool	blackmagic_api_version_check ()

bool	bmd_check_stereo_profile (IDeckLink *deckLink)

std::string	bmd_get_audio_connection_name (BMDAudioOutputAnalogAESSwitch audioConnection)

std::string	bmd_get_device_name (IDeckLink *decklink)

std::string	bmd_get_flags_str (BMDDisplayModeFlags flags)

std::vector< bmd_dev >	bmd_get_sorted_devices (bool *com_initialized, bool verbose=true, bool natural_sort=false)

std::string	bmd_hresult_to_string (HRESULT res)

bool	bmd_parse_audio_levels (const char *opt) noexcept(false)
	TOREMOVE (implicit "aacl" option is preferred)

uint32_t	bmd_read_fourcc (const char *)

IDeckLinkIterator *	create_decklink_iterator (bool *com_initialized, bool verbose=true)

bool	decklink_set_profile (IDeckLink *deckLink, bmd_option const &req_profile, bool stereo)

template<typename T >
bool	decklink_supports_codec (T *deckLink, BMDPixelFormat pf)

template bool	decklink_supports_codec< IDeckLinkInput > (IDeckLinkInput *deckLink, BMDPixelFormat pf)

template bool	decklink_supports_codec< IDeckLinkOutput > (IDeckLinkOutput *deckLink, BMDPixelFormat pf)

void	decklink_uninitialize (bool *com_initialized)

BMD_STR	get_bmd_api_str_from_cstr (const char *cstr)

const std::map< BMDVideoConnection, std::string > &	get_connection_string_map ()

char *	get_cstr_from_bmd_api_str (BMD_STR string)

std::string	get_str_from_bmd_api_str (BMD_STR string)

std::ostream &	operator<< (std::ostream &output, const bmd_option &b)

std::ostream &	operator<< (std::ostream &output, REFIID iid)

void	print_bmd_attribute (IDeckLinkProfileAttributes deckLinkAttributes, const char query_prop_fcc)

void	print_bmd_device_profiles (const char *line_prefix)

void	print_decklink_version (void)

void	r10k_full_to_limited (const char in, char out, size_t len)

void	r10k_limited_to_full (const char in, char out, size_t len)

void	release_bmd_api_str (BMD_STR string)

Variables
static std::vector< std::pair< codec_t, BMDPixelFormat > >	uv_to_bmd_codec_map

Detailed Description

Author: Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file blackmagic_common.hpp.

Macro Definition Documentation

◆ BMD_BOOL

#define BMD_BOOL bool

Definition at line 81 of file blackmagic_common.hpp.

Referenced by decklink_get_active_profile_id(), decklink_supports_codec(), display_decklink_init(), display_decklink_reconfigure(), device_state::init(), print_bmd_attribute(), and ProfileCallback::WaitForProfileActivation().

◆ BMD_CHECK

#define BMD_CHECK	(	cmd,
		name,
		action )

Value:

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

Definition at line 157 of file blackmagic_common.hpp.

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

Referenced by decklink_set_profile(), and device_state::init().

◆ BMD_FALSE

#define BMD_FALSE false

Definition at line 83 of file blackmagic_common.hpp.

Referenced by decklink_get_active_profile_id(), display_decklink_init(), display_decklink_reconfigure(), device_state::init(), and ProfileCallback::WaitForProfileActivation().

◆ BMD_NAT_SORT

#define BMD_NAT_SORT "bmd-sort-natural"

Definition at line 168 of file blackmagic_common.hpp.

Referenced by decklink_help(), and show_help().

◆ BMD_STR

#define BMD_STR const char *

Definition at line 128 of file blackmagic_common.hpp.

Referenced by bmd_get_device_name(), bmd_option::device_write(), get_bmd_api_str_from_cstr(), get_input_modes(), get_mode(), device_state::init(), print_bmd_attribute(), print_decklink_version(), print_output_modes(), and set_display_mode_properties().

◆ BMD_TRUE

#define BMD_TRUE true

Definition at line 82 of file blackmagic_common.hpp.

Referenced by display_decklink_init(), and display_decklink_reconfigure().

◆ R10K_FULL_OPT

#define R10K_FULL_OPT "bmd-r10k-full-range"

Definition at line 167 of file blackmagic_common.hpp.

Referenced by display_decklink_putf(), display_decklink_reconfigure(), postprocess_frame(), and vidcap_decklink_state::set_codec().

Typedef Documentation

◆ bmd_dev

using bmd_dev

Initial value:

std::tuple<std::unique_ptr<IDeckLink, void (*)(IDeckLink *)>,

unsigned, int, char>

parameters:

first - IDeckLinkInstance
unsigned - topological ID
int - natural idx (the old, order as given by IDeckLinkIterator)
char - new index ('a', 'b', 'c'...); sorted by topological ID

Definition at line 189 of file blackmagic_common.hpp.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
BMD_MAX_AUD_CH

Definition at line 86 of file blackmagic_common.hpp.

     {
        BMD_MAX_AUD_CH = 64,
};

Function Documentation

◆ blackmagic_api_version_check()

bool blackmagic_api_version_check ( )

Definition at line 202 of file blackmagic_common.cpp.

{
        bool ret = false;
        IDeckLinkAPIInformation *APIInformation = NULL;
        HRESULT result;
        bool com_initialized = false;
 
        if (!com_initialize(&com_initialized, "[BMD] ")) {
                goto cleanup;
        }
#ifdef _WIN32
        result = CoCreateInstance(CLSID_CDeckLinkAPIInformation, NULL, CLSCTX_ALL,
                IID_IDeckLinkAPIInformation, (void **) &APIInformation);
        if(FAILED(result)) {
#else
        APIInformation = CreateDeckLinkAPIInformationInstance();
        if(APIInformation == NULL) {
#endif
                log_msg(LOG_LEVEL_ERROR, "Cannot get API information! Perhaps drivers not installed.\n");
                goto cleanup;
        }
        int64_t value;
        result = APIInformation->GetInt(BMDDeckLinkAPIVersion, &value);
        if(result != S_OK) {
                log_msg(LOG_LEVEL_ERROR, "Cannot get API version!\n");
                goto cleanup;
        }
 
        if (BLACKMAGIC_DECKLINK_API_VERSION > value) { // this is safe comparision, for internal structure please see SDK documentation
                log_msg(LOG_LEVEL_ERROR, "The DeckLink drivers may not be installed or are outdated.\n");
                log_msg(LOG_LEVEL_ERROR, "You should have at least the version UltraGrid has been linked with.\n");
                log_msg(LOG_LEVEL_ERROR, "Vendor download page is http://www.blackmagic-design.com/support\n");
                print_decklink_version();
                ret = false;
        } else {
                ret = true;
        }
 
cleanup:
        if (APIInformation) {
                APIInformation->Release();
        }
        decklink_uninitialize(&com_initialized);
 
        return ret;
}

References cleanup(), com_initialize(), decklink_uninitialize(), FAILED, LOG_LEVEL_ERROR, log_msg(), and print_decklink_version().

Referenced by display_decklink_init(), and vidcap_decklink_init().

Here is the call graph for this function:

◆ bmd_check_stereo_profile()

bool bmd_check_stereo_profile ( IDeckLink * deckLink )

Definition at line 509 of file blackmagic_common.cpp.

                                                   {
        if (BMDProfileID profile_active = decklink_get_active_profile_id(deckLink)) {
                if (profile_active != bmdProfileOneSubDeviceHalfDuplex &&
                                profile_active != bmdProfileOneSubDeviceFullDuplex) {
                        uint32_t profile_fcc_host = ntohl(profile_active);
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Active profile '%.4s' may not be compatible with stereo mode.\n", (char *) &profile_fcc_host);
                        log_msg(LOG_LEVEL_INFO, MOD_NAME "Use 'profile=' parameter to set 1-subdevice mode in either '1dhd' (half) or '1dfd' (full) duplex.\n");
                }
                return false;
        }
        return true;
}

References decklink_get_active_profile_id(), LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), and MOD_NAME.

Referenced by device_state::check_attributes(), and display_decklink_reconfigure().

Here is the call graph for this function:

◆ bmd_get_audio_connection_name()

std::string bmd_get_audio_connection_name ( BMDAudioOutputAnalogAESSwitch audioConnection )

Definition at line 903 of file blackmagic_common.cpp.

                                                                                    {
        switch(audioConnection) {
                case bmdAudioOutputSwitchAESEBU:
                        return "AES/EBU";
                case bmdAudioOutputSwitchAnalog:
                        return "analog";
                default:
                        return "default";
        }
}

◆ bmd_get_device_name()

std::string bmd_get_device_name ( IDeckLink * decklink )

Definition at line 522 of file blackmagic_common.cpp.

                                                {
        BMD_STR         deviceNameString = NULL;
        char *          deviceNameCString = NULL;
        string          ret;
 
        if (decklink->GetDisplayName((BMD_STR *) &deviceNameString) == S_OK) {
                deviceNameCString = get_cstr_from_bmd_api_str(deviceNameString);
                ret = deviceNameCString;
                release_bmd_api_str(deviceNameString);
                free(deviceNameCString);
        }
 
        return ret;
}

References BMD_STR, get_cstr_from_bmd_api_str(), and release_bmd_api_str().

Referenced by decklink_help(), display_decklink_init(), display_decklink_probe(), device_state::init(), show_help(), and vidcap_decklink_probe().

Here is the call graph for this function:

◆ bmd_get_flags_str()

std::string bmd_get_flags_str ( BMDDisplayModeFlags flags )

Definition at line 914 of file blackmagic_common.cpp.

                                                    {
        bool first = true;
        ostringstream oss;
        vector<pair<uint32_t, const char *>> map {
                { bmdDisplayModeColorspaceRec601, "Rec601" },
                { bmdDisplayModeColorspaceRec709, "Rec709" },
                { bmdDisplayModeColorspaceRec2020, "Rec2020" },
                { bmdDisplayModeSupports3D, "3D" },
        };
 
        for (auto &f : map ) {
                if (flags & f.first) {
                        oss << (!first ? ", " : "") << f.second;
                        first = false;
                }
        }
        if (flags == 0) {
                oss << "(none)";
        }
        if (flags >= bmdDisplayModeColorspaceRec2020 << 1) {
                oss << ", (unknown flags)";
        }
        return oss.str();
}

References first, and flags.

Referenced by get_input_modes(), and print_output_modes().

◆ bmd_get_sorted_devices()

std::vector< bmd_dev > bmd_get_sorted_devices	(	bool *	com_initialized,
		bool	verbose,
		bool	natural_sort )

Returns: list of DeckLink devices sorted (indexed) by topological ID If no topological ID is reported, use UINT_MAX (and lower vals)

Parameters

verbose	- print errors
natural_sort	- use the (old) natural sort as given by the iterator

Note: Each call of this function should be followed by com_uninitialize() when done with DeckLink. No BMD stuff originating from this function call (IDeckLinks) can be used after that and new call must be made.; The returned IDeckLink instances are managed with the unique_ptr, so take care about the returned object lifetime (particularly not to be destroyed after decklink_uninitialize()).

Definition at line 1106 of file blackmagic_common.cpp.

{
        IDeckLinkIterator *deckLinkIterator =
            create_decklink_iterator(com_initialized, verbose);
        if (deckLinkIterator == nullptr) {
                return {};
        }
 
        IDeckLink *deckLink = nullptr;
        std::vector<bmd_dev> out;
        int                  idx = 0;
        while (deckLinkIterator->Next(&deckLink) == S_OK) {
                IDeckLinkProfileAttributes *deckLinkAttributes = nullptr;
                HRESULT                     result             = E_FAIL;
                result =
                    deckLink->QueryInterface(IID_IDeckLinkProfileAttributes,
                                             (void **) &deckLinkAttributes);
                assert(result == S_OK);
                int64_t id = 0;
                result =
                    deckLinkAttributes->GetInt(BMDDeckLinkTopologicalID, &id);
                if (result != S_OK) {
                        id = UINT_MAX - idx;
                }
                assert(id >= 0 && id <= UINT_MAX);
                deckLinkAttributes->Release();
 
                auto release = [](IDeckLink *d) { d->Release(); };
                auto &it      = out.emplace_back(
                    std::unique_ptr<IDeckLink, void (*)(IDeckLink *)>{
                        deckLink, release },
                    0, 0, 0);
                std::get<unsigned>(it) = id;
                std::get<int>(it) = idx++;
        }
        deckLinkIterator->Release();
        if (!natural_sort) {
                std::sort(out.begin(), out.end(), [](bmd_dev &a, bmd_dev &b) {
                        return std::get<unsigned>(a) < std::get<unsigned>(b);
                });
        }
        // assign new indices
        char new_idx = 'a';
        for (auto &d : out) {
                std::get<char>(d) = new_idx++;
        }
        return out;
}

References create_decklink_iterator().

Referenced by decklink_help(), display_decklink_init(), display_decklink_probe(), device_state::init(), show_help(), and vidcap_decklink_probe().

Here is the call graph for this function:

◆ bmd_hresult_to_string()

std::string bmd_hresult_to_string ( HRESULT res )

Definition at line 85 of file blackmagic_common.cpp.

{
        const char *errptr = nullptr;
#ifdef _WIN32
        errptr = hresult_to_str(res);
#else
        HRESULT_GET_ERROR_COMMON(res, errptr)
#endif
        ostringstream oss;
        if (errptr) {
                oss << errptr;
        }
        oss << " " << "(0x" << hex << setfill('0') << setw(8) << res << ")";
        return oss.str();
}

References HRESULT_GET_ERROR_COMMON.

Referenced by decklink_get_active_profile_id(), decklink_set_profile(), decklink_supports_codec(), bmd_option::device_write(), display_decklink_init(), display_decklink_reconfigure(), get_input_modes(), GetDeckLinkProfileID(), device_state::init(), print_bmd_attribute(), set_audio_props(), set_display_mode_properties(), vidcap_decklink_done(), and VideoDelegate::VideoInputFormatChanged().

◆ bmd_parse_audio_levels()

bool bmd_parse_audio_levels ( const char * opt )

TOREMOVE (implicit "aacl" option is preferred)

Definition at line 1020 of file blackmagic_common.cpp.

{
        MSG(WARNING, "audio_level option is deprecated, use "
                     "\"aacl[=true|false]\" instead\n");
        if (strcasecmp(opt, "false") == 0 || strcasecmp(opt, "off") == 0 ||
            strcasecmp(opt, "line") == 0) {
                return false;
        }
        if (strcasecmp(opt, "true") == 0 || strcasecmp(opt, "on") == 0 ||
            strcasecmp(opt, "mic") == 0) {
                return true;
        }
        throw invalid_argument(string("invalid BMD audio level ") + opt);
}

References MSG.

Referenced by parse_option(), and settings_init().

◆ bmd_read_fourcc()

uint32_t bmd_read_fourcc ( const char * str )

Definition at line 537 of file blackmagic_common.cpp.

                                          {
        union {
                uint32_t fourcc;
                char c4[4];
        } u;
        memset(u.c4, ' ', 4);
        memcpy(u.c4, str, min(strlen(str), sizeof u.c4));
        return htonl(u.fourcc);
}

Referenced by device_state::init(), bmd_option::parse(), parse_option(), and settings_init().

◆ create_decklink_iterator()

IDeckLinkIterator * create_decklink_iterator	(	bool *	com_initialized,
		bool	verbose )

Parameters

[out] com_initialized pointer to be passed to decklnk_uninitialize (keeps information if COM needs to be unintialized)

Note: Each successful call (returning non-null pointer) of this function should be followed by com_uninitialize() when done with DeckLink (not when releasing IDeckLinkIterator!), typically on application shutdown.

Definition at line 171 of file blackmagic_common.cpp.

{
        IDeckLinkIterator *deckLinkIterator = nullptr;
#ifdef _WIN32
        com_initialize(com_initialized, "[BMD] ");
        HRESULT result = CoCreateInstance(CLSID_CDeckLinkIterator, NULL, CLSCTX_ALL,
                        IID_IDeckLinkIterator, (void **) &deckLinkIterator);
        if (FAILED(result)) {
                decklink_uninitialize(com_initialized);
                deckLinkIterator = nullptr;
        }
#else
        *com_initialized = false;
        deckLinkIterator = CreateDeckLinkIteratorInstance();
#endif
 
        if (!deckLinkIterator && verbose) {
                log_msg(LOG_LEVEL_ERROR, "A DeckLink iterator could not be created. The DeckLink drivers may not be installed or are outdated.\n");
                log_msg(LOG_LEVEL_INFO, "This UltraGrid version was compiled with DeckLink drivers %s. You should have at least this version.\n\n",
                                BLACKMAGIC_DECKLINK_API_VERSION_STRING);
 
        }
 
        return deckLinkIterator;
}

References com_initialize(), decklink_uninitialize(), FAILED, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, and log_msg().

Referenced by bmd_get_sorted_devices().

Here is the call graph for this function:

◆ decklink_set_profile()

bool decklink_set_profile	(	IDeckLink *	deckLink,
		bmd_option const &	req_profile,
		bool	stereo )

Parameters

a	value from BMDProfileID or bmdDuplexHalf (maximize number of IOs)

Definition at line 399 of file blackmagic_common.cpp.

                                                                                           {
        if (req_profile.is_default() && !stereo) {
                return true;
        }
 
        if (req_profile.is_help()) {
                printf("Available profiles:\n");
                print_bmd_device_profiles("\t");
                return false;
        }
 
        bool ret = true;
        IDeckLinkProfileManager *manager = nullptr;
        IDeckLinkProfileIterator *it = nullptr;
        IDeckLinkProfile *profile = nullptr;
        bool found = false;
        ProfileCallback *p = nullptr;
 
        if (HRESULT res = deckLink->QueryInterface(IID_IDeckLinkProfileManager, (void**)&manager)) {
                const bool error = !(req_profile.is_default() && res == E_NOINTERFACE);
                LOG(error ? LOG_LEVEL_ERROR : LOG_LEVEL_VERBOSE) << MOD_NAME << "Cannot set duplex - query profile manager: " << bmd_hresult_to_string(res) << "\n";
                return error;
        }
 
        // set '1dfd' for stereo if profile is not set explicitly
        assert(!req_profile.is_default() || stereo);
        const uint32_t profileID = req_profile.is_default() ? (int64_t) bmdProfileOneSubDeviceFullDuplex : req_profile.get_int();
 
        EXIT_IF_FAILED(manager->GetProfiles(&it), "Cannot set duplex - get profiles");
 
        while (it->Next(&profile) == S_OK) {
                IDeckLinkProfileAttributes *attributes;
                int64_t id;
                if (profile->QueryInterface(IID_IDeckLinkProfileAttributes,
                                        (void**)&attributes) != S_OK) {
                        LOG(LOG_LEVEL_WARNING) << "[DeckLink] Cannot get profile attributes!\n";
                        continue;
                }
                if (attributes->GetInt(BMDDeckLinkProfileID, &id) == S_OK) {
                        if (profileID == bmdDuplexHalf) {
                                if (id == bmdProfileTwoSubDevicesHalfDuplex || id == bmdProfileFourSubDevicesHalfDuplex) {
                                        found = true;
                                }
                        } else if (profileID == id) {
                                found = true;
                        }
                        if (found) {
                                p = new ProfileCallback(profile);
                                BMD_CHECK(manager->SetCallback(p), "IDeckLinkProfileManager::SetCallback", goto cleanup);
                                if (profile->SetActive() != S_OK) {
                                        LOG(LOG_LEVEL_ERROR) << "[DeckLink] Cannot set profile!\n";
                                        ret = false;
                                }
                                if (!p->WaitForProfileActivation()) {
                                        ret = false;
                                }
                        }
                } else {
                        LOG(LOG_LEVEL_WARNING) << "[DeckLink] Cannot get profile ID!\n";
                }
                attributes->Release();
                profile->Release();
                if (found) {
                        break;
                }
        }
 
        if (!found && ret) { // no err but not found
                LOG(LOG_LEVEL_WARNING) << "[DeckLink] did not find suitable duplex profile!\n";
                ret = false;
        }
 
cleanup:
        RELEASE_IF_NOT_NULL(p);
        RELEASE_IF_NOT_NULL(it);
        RELEASE_IF_NOT_NULL(manager);
        return ret;
}

References BMD_CHECK, bmd_hresult_to_string(), cleanup(), EXIT_IF_FAILED, bmd_option::get_int(), bmd_option::is_default(), bmd_option::is_help(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, MOD_NAME, print_bmd_device_profiles(), RELEASE_IF_NOT_NULL, and ProfileCallback::WaitForProfileActivation().

Referenced by display_decklink_init(), display_decklink_reconfigure(), and device_state::init().

Here is the call graph for this function:

◆ decklink_supports_codec()

template<typename T >

bool decklink_supports_codec	(	T *	deckLink,
		BMDPixelFormat	pf )

This function returns true if any display mode and any output supports the codec. The codec, however, may not be supported with actual video mode.

Todo: For UltraStudio Pro DoesSupportVideoMode returns E_FAIL on not supported pixel formats instead of setting supported to false.

Definition at line 979 of file blackmagic_common.cpp.

{
        IDeckLinkDisplayModeIterator *displayModeIterator = nullptr;
        IDeckLinkDisplayMode         *deckLinkDisplayMode = nullptr;
 
        if (FAILED(
                deckLink->GetDisplayModeIterator(&displayModeIterator))) {
                MSG(ERROR, "Fatal: cannot create display mode iterator.\n");
                return false;
        }
 
        while (displayModeIterator->Next(&deckLinkDisplayMode) == S_OK) {
                BMD_BOOL supported = false;
                const HRESULT res       = deckLink->DoesSupportVideoMode(
                    bmdVideoConnectionUnspecified,
                    deckLinkDisplayMode->GetDisplayMode(), pf,
                    bmd_no_conv<T>::value, bmdSupportedVideoModeDefault,
                    nullptr, &supported);
                deckLinkDisplayMode->Release();
                if (res != S_OK) {
                        MSG(WARNING, "DoesSupportVideoMode: %s\n",
                            bmd_hresult_to_string(res).c_str());
                        continue;
                }
                if (supported) {
                        displayModeIterator->Release();
                        return true;
                }
        }
        displayModeIterator->Release();
 
        return false;
}

References BMD_BOOL, bmd_hresult_to_string(), FAILED, and MSG.

Referenced by display_decklink_get_property(), print_output_modes(), and vidcap_decklink_print_card_info().

Here is the call graph for this function:

◆ decklink_supports_codec< IDeckLinkInput >()

template bool decklink_supports_codec< IDeckLinkInput >	(	IDeckLinkInput *	deckLink,
		BMDPixelFormat	pf )

extern

◆ decklink_supports_codec< IDeckLinkOutput >()

template bool decklink_supports_codec< IDeckLinkOutput >	(	IDeckLinkOutput *	deckLink,
		BMDPixelFormat	pf )

extern

◆ decklink_uninitialize()

void decklink_uninitialize ( bool * com_initialized )

Parameters

com_initialized - pointer passed to create_decklink_iterator

Definition at line 197 of file blackmagic_common.cpp.

{
        com_uninitialize(com_initialized);
}

References com_uninitialize().

Referenced by blackmagic_api_version_check(), create_decklink_iterator(), decklink_help(), display_decklink_done(), display_decklink_probe(), show_help(), and vidcap_decklink_probe().

Here is the call graph for this function:

◆ get_bmd_api_str_from_cstr()

BMD_STR get_bmd_api_str_from_cstr ( const char * cstr )

Definition at line 125 of file blackmagic_common.cpp.

{
#ifdef __APPLE__
        return CFStringCreateWithCString(kCFAllocatorMalloc, cstr, kCFStringEncodingUTF8);
#elif defined _WIN32
        mbstate_t mbstate{};
        const char *tmp = cstr;
        size_t required_size = mbsrtowcs(NULL, &tmp, 0, &mbstate) + 1;
        BMD_STR out = (wchar_t *) malloc(required_size * sizeof(wchar_t));
        mbsrtowcs(out, &tmp, required_size, &mbstate);
        return out;
#else
        return strdup(cstr);
#endif
}

References BMD_STR.

Referenced by bmd_option::device_write().

◆ get_connection_string_map()

const std::map< BMDVideoConnection, std::string > & get_connection_string_map ( )

Definition at line 948 of file blackmagic_common.cpp.

                                                                   {
        static const map<BMDVideoConnection, string> m = {
                { bmdVideoConnectionSDI, "SDI" },
                { bmdVideoConnectionHDMI, "HDMI"},
                { bmdVideoConnectionOpticalSDI, "OpticalSDI"},
                { bmdVideoConnectionComponent, "Component"},
                { bmdVideoConnectionComposite, "Composite"},
                { bmdVideoConnectionSVideo, "SVideo"}
        };
        return m;
}

Referenced by bmd_option::device_write(), parse_option(), vidcap_decklink_print_card_info(), and vidcap_decklink_probe().

◆ get_cstr_from_bmd_api_str()

char * get_cstr_from_bmd_api_str ( BMD_STR bmd_string )

returned c-sring needs to be freed when not used

Definition at line 104 of file blackmagic_common.cpp.

{
        if (!bmd_string) {
                return strdup("(NULL!)");
        }
       char *cstr;
#ifdef __APPLE__
       size_t len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(bmd_string), kCFStringEncodingUTF8) + 1;
       cstr = (char *) malloc(len);
       CFStringGetCString(bmd_string, (char *) cstr, len, kCFStringEncodingUTF8);
#elif defined _WIN32
       size_t len = SysStringLen(bmd_string) * 4 + 1;
       cstr = (char *) malloc(len);
       wcstombs((char *) cstr, bmd_string, len);
#else // Linux
       cstr = strdup(bmd_string);
#endif
 
       return cstr;
}

References len.

Referenced by bmd_get_device_name(), get_str_from_bmd_api_str(), and print_decklink_version().

◆ get_str_from_bmd_api_str()

std::string get_str_from_bmd_api_str ( BMD_STR string )

Definition at line 155 of file blackmagic_common.cpp.

{
        char *displayModeCString = get_cstr_from_bmd_api_str(string);
        std::string out = displayModeCString;
        free(displayModeCString);
        return out;
}

References get_cstr_from_bmd_api_str().

Referenced by get_input_modes(), get_mode(), device_state::init(), print_bmd_attribute(), print_output_modes(), and set_display_mode_properties().

Here is the call graph for this function:

◆ operator<<() [1/2]

std::ostream & operator<<	(	std::ostream &	output,
		const bmd_option &	b )

Definition at line 100 of file blackmagic_common.cpp.

                                                                {
        switch (b.m_type) {
                case bmd_option::type_tag::t_default:
                        output << "(default)";
                        break;
                case bmd_option::type_tag::t_keep:
                        output << "(keep)";
                        break;
                case bmd_option::type_tag::t_flag:
                        output << (b.get_flag() ? "true" : "false");
                        break;
                case bmd_option::type_tag::t_int:
                        if (IS_FCC(b.get_int())) {
                                output << fcc_to_string(b.get_int());
                        } else if (b.get_int() >= 0) {
                                auto flags = output.flags();
                                output << b.get_int() << " (0x" << hex
                                       << b.get_int() << ")";
                                output.flags(flags);
                        } else {
                                output << b.get_int();
                        }
                        break;
                case bmd_option::type_tag::t_float: {
                        auto flags = output.flags();
                        output << fixed << b.m_val.f;
                        output.flags(flags);
                        break;
                }
                case bmd_option::type_tag::t_string:
                        output << b.m_val.s;
                        break;
        }
        return output;
}

◆ operator<<() [2/2]

std::ostream & operator<<	(	std::ostream &	output,
		REFIID	iid )

Definition at line 547 of file blackmagic_common.cpp.

{
#ifdef _WIN32
        OLECHAR* guidString;
        StringFromCLSID(iid, &guidString);
        char buffer[128];
        int ret = wcstombs(buffer, guidString, sizeof buffer);
        if (ret == sizeof buffer) {
                buffer[sizeof buffer - 1] = '\0';
        }
        output << buffer;
        ::CoTaskMemFree(guidString);
#else
        auto flags = output.flags();
        output << hex << uppercase << setfill('0') <<
                setw(2) << static_cast<int>(iid.byte0) << setw(2) << static_cast<int>(iid.byte1) <<
                setw(2) << static_cast<int>(iid.byte2) << setw(2) << static_cast<int>(iid.byte3) << "-" <<
                setw(2) << static_cast<int>(iid.byte4) << setw(2) << static_cast<int>(iid.byte5) << "-" <<
                setw(2) << static_cast<int>(iid.byte6) << setw(2) << static_cast<int>(iid.byte7) << "-" <<
                setw(2) << static_cast<int>(iid.byte8) << setw(2) << static_cast<int>(iid.byte9) << "-" <<
                setw(2) << static_cast<int>(iid.byte10) << setw(2) << static_cast<int>(iid.byte11) <<
                setw(2) << static_cast<int>(iid.byte12) << setw(2) << static_cast<int>(iid.byte13) <<
                setw(2) << static_cast<int>(iid.byte14) << setw(2) << static_cast<int>(iid.byte15);
        output.flags(flags);
#endif
        return output;
}

References flags.

◆ print_bmd_attribute()

void print_bmd_attribute	(	IDeckLinkProfileAttributes *	deckLinkAttributes,
		const char *	query_prop_fcc )

Definition at line 1036 of file blackmagic_common.cpp.

{
        if (strcmp(query_prop_fcc, "help") == 0) {
                col{} << "Query usage:\n"
                      << SBOLD("\tq[uery]=<fcc>")
                      << " - gets DeckLink attribute value\n";
                return;
        }
        union {
                char fcc[sizeof(BMDDeckLinkAttributeID)] = { ' ', ' ', ' ',
                                                             ' ' };
                BMDDeckLinkAttributeID key;
        };
        memcpy(fcc, query_prop_fcc, min(strlen(query_prop_fcc), sizeof fcc));
        key = (BMDDeckLinkAttributeID) htonl(key);
        BMD_BOOL      bool_val{};
        int64_t       int_val{};
        double        float_val{};
        BMD_STR       string_val{};
        ostringstream oss;
        HRESULT result = deckLinkAttributes->GetFlag(key, &bool_val);
        if (result == S_OK) {
                oss << (bool_val ? "true" : "false");
        }
        if (result == E_INVALIDARG) {
                result = deckLinkAttributes->GetInt(key, &int_val);
                if (result == S_OK) {
                        oss << int_val << " (0x" << hex << int_val << ")";
                }
        }
        if (result == E_INVALIDARG) {
                result = deckLinkAttributes->GetFloat(key, &float_val);
                if (result == S_OK) {
                        oss << float_val;
                }
        }
        if (result == E_INVALIDARG) {
                result = deckLinkAttributes->GetString(key, &string_val);
                if (result == S_OK) {
                        string str = get_str_from_bmd_api_str(string_val);
                        release_bmd_api_str(string_val);
                        oss << str;
                }
        }
        if (result != S_OK) {
                LOG(LOG_LEVEL_ERROR)
                    << MOD_NAME << "Cannot get " << query_prop_fcc << ": "
                    << bmd_hresult_to_string(result) << "\n";
                return;
        }
        col() << "\t" << hex << "Value of " << SBOLD(query_prop_fcc)
              << " attribute for this device is " << SBOLD(oss.str()) << "\n";
}

References BMD_BOOL, bmd_hresult_to_string(), BMD_STR, get_str_from_bmd_api_str(), key, LOG, LOG_LEVEL_ERROR, min, MOD_NAME, release_bmd_api_str(), and SBOLD.

Referenced by print_output_modes(), and vidcap_decklink_print_card_info().

Here is the call graph for this function:

◆ print_bmd_device_profiles()

void print_bmd_device_profiles ( const char * line_prefix )

Definition at line 939 of file blackmagic_common.cpp.

{
        for (const auto &p : kDeviceProfiles) {
                const uint32_t fcc = htonl(p.first);
                color_printf("%s" TBOLD("%.4s") " - %s (%s)\n", line_prefix, (const char *) &fcc, p.second.first, p.second.second);
        }
        color_printf("%s" TBOLD("keep") " - keep device setting\n", line_prefix);
}

References color_printf(), kDeviceProfiles, and TBOLD.

Referenced by decklink_help(), decklink_set_profile(), and show_help().

Here is the call graph for this function:

◆ print_decklink_version()

void print_decklink_version ( void )

Definition at line 249 of file blackmagic_common.cpp.

{
        BMD_STR current_version = NULL;
        IDeckLinkAPIInformation *APIInformation = NULL;
        HRESULT result;
 
#ifdef _WIN32
        bool com_initialized = false;
        if (!com_initialize(&com_initialized, "[BMD] ")) {
                goto cleanup;
        }
 
        result = CoCreateInstance(CLSID_CDeckLinkAPIInformation, NULL, CLSCTX_ALL,
                IID_IDeckLinkAPIInformation, (void **) &APIInformation);
        if(FAILED(result)) {
#else
        APIInformation = CreateDeckLinkAPIInformationInstance();
        if(APIInformation == NULL) {
#endif
                fprintf(stderr, "Cannot get API information! Perhaps drivers not installed.\n");
                goto cleanup;
        }
 
        result = APIInformation->GetString(BMDDeckLinkAPIVersion, &current_version);
        if (result != S_OK) {
                fprintf(stderr, "Cannot get API version string!\n");
                goto cleanup;
        } else {
                fprintf(stderr, "This UltraGrid version was compiled against DeckLink SDK %s. ", BLACKMAGIC_DECKLINK_API_VERSION_STRING);
                const char *currentVersionCString = get_cstr_from_bmd_api_str(current_version);
                fprintf(stderr, "System version is %s.\n", currentVersionCString);
                release_bmd_api_str(current_version);
                free(const_cast<char *>(currentVersionCString));
        }
 
cleanup:
        if (APIInformation) {
                APIInformation->Release();
        }
#ifdef _WIN32
        com_uninitialize(&com_initialized);
#endif
}

References BMD_STR, cleanup(), com_initialize(), com_uninitialize(), FAILED, get_cstr_from_bmd_api_str(), and release_bmd_api_str().

Referenced by blackmagic_api_version_check(), decklink_help(), and show_help().

Here is the call graph for this function:

◆ r10k_full_to_limited()

void r10k_full_to_limited	(	const char *	in,
		char *	out,
		size_t	len )

converts from full range (4-1019) to 64-960

in and out pointers can point to the same address

Definition at line 892 of file blackmagic_common.cpp.

{
        static unsigned int lut[1024];
        if (lut[1023] == 0) {
                fill_full_to_limited_lut(lut);
        }
        DEBUG_TIMER_START(r10k_limited_to_full);
        respawn_parallel(const_cast<char *>(in), out, len / 4, 4, apply_r10k_lut, lut);
        DEBUG_TIMER_STOP(r10k_limited_to_full);
}

References apply_r10k_lut(), DEBUG_TIMER_START, DEBUG_TIMER_STOP, fill_full_to_limited_lut(), len, r10k_limited_to_full(), and respawn_parallel().

Referenced by display_decklink_putf().

Here is the call graph for this function:

◆ r10k_limited_to_full()

void r10k_limited_to_full	(	const char *	in,
		char *	out,
		size_t	len )

converts from range 64-960 to 4-1019

in and out pointers can point to the same address

Definition at line 869 of file blackmagic_common.cpp.

{
        static unsigned int lut[1024];
        if (lut[1023] == 0) {
                fill_limited_to_full_lut(lut);
        }
        DEBUG_TIMER_START(r10k_limited_to_full);
        respawn_parallel(const_cast<char *>(in), out, len / 4, 4, apply_r10k_lut, lut);
        DEBUG_TIMER_STOP(r10k_limited_to_full);
}

References apply_r10k_lut(), DEBUG_TIMER_START, DEBUG_TIMER_STOP, fill_limited_to_full_lut(), len, r10k_limited_to_full(), and respawn_parallel().

Referenced by postprocess_frame(), r10k_full_to_limited(), and r10k_limited_to_full().

Here is the call graph for this function:

◆ release_bmd_api_str()

void release_bmd_api_str ( BMD_STR string )

Definition at line 141 of file blackmagic_common.cpp.

{
        if (!string) {
                return;
        }
#ifdef __APPLE__
        CFRelease(string);
#elif defined _WIN32
        SysFreeString(string);
#else
        free(const_cast<char *>(string));
#endif
}

Referenced by bmd_get_device_name(), bmd_option::device_write(), get_input_modes(), get_mode(), device_state::init(), print_bmd_attribute(), print_decklink_version(), print_output_modes(), and set_display_mode_properties().

Variable Documentation

◆ uv_to_bmd_codec_map

std::vector<std::pair<codec_t, BMDPixelFormat> > uv_to_bmd_codec_map

static

Initial value:

= {
                  { R12L, bmdFormat12BitRGBLE },
                  { R10k, bmdFormat10BitRGBX },
                  { v210, bmdFormat10BitYUV },
                  { RGBA, bmdFormat8BitBGRA },
                  { UYVY, bmdFormat8BitYUV },
}

Definition at line 68 of file blackmagic_common.hpp.

                                                                         {
                  { R12L, bmdFormat12BitRGBLE },
                  { R10k, bmdFormat10BitRGBX },
                  { v210, bmdFormat10BitYUV },
                  { RGBA, bmdFormat8BitBGRA },
                  { UYVY, bmdFormat8BitYUV },
};

Referenced by decklink_help(), display_decklink_get_property(), display_decklink_reconfigure(), device_state::init(), print_output_modes(), set_display_mode_properties(), show_help(), and vidcap_decklink_print_card_info().

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ BMD_BOOL

◆ BMD_CHECK

◆ BMD_FALSE

◆ BMD_NAT_SORT

◆ BMD_STR

◆ BMD_TRUE

◆ R10K_FULL_OPT

Typedef Documentation

◆ bmd_dev

Enumeration Type Documentation

◆ anonymous enum

Function Documentation

◆ blackmagic_api_version_check()

◆ bmd_check_stereo_profile()

◆ bmd_get_audio_connection_name()

◆ bmd_get_device_name()

◆ bmd_get_flags_str()

◆ bmd_get_sorted_devices()

◆ bmd_hresult_to_string()

◆ bmd_parse_audio_levels()

◆ bmd_read_fourcc()

◆ create_decklink_iterator()

◆ decklink_set_profile()

◆ decklink_supports_codec()

◆ decklink_supports_codec< IDeckLinkInput >()

◆ decklink_supports_codec< IDeckLinkOutput >()

◆ decklink_uninitialize()

◆ get_bmd_api_str_from_cstr()

◆ get_connection_string_map()

◆ get_cstr_from_bmd_api_str()

◆ get_str_from_bmd_api_str()

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ print_bmd_attribute()

◆ print_bmd_device_profiles()

◆ print_decklink_version()

◆ r10k_full_to_limited()

◆ r10k_limited_to_full()

◆ release_bmd_api_str()

Variable Documentation

◆ uv_to_bmd_codec_map