{

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();

{

#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

{

if (!string) {

return;

}

#ifdef __APPLE__

CFRelease(string);

#elif defined _WIN32

SysFreeString(string);

#else

free(const_cast<char *>(string));

#endif

{

char *displayModeCString = get_cstr_from_bmd_api_str(string);

std::string out = displayModeCString;

free(displayModeCString);

return out;

{

IDeckLinkProfileAttributes* profileAttributes = nullptr;

if (HRESULT result = profile->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&profileAttributes); FAILED(result)) {

return {};

}

int64_t profileIDInt = 0;

// Get Profile ID attribute

const HRESULT res =

profileAttributes->GetInt(BMDDeckLinkProfileID, &profileIDInt);

if (SUCCEEDED(res)) {

profileAttributes->Release();

} else {

LOG(LOG_LEVEL_ERROR) << MOD_NAME << "BMDDeckLinkProfileID: "

<< bmd_hresult_to_string(res) << "\n";

}

return (BMDProfileID) profileIDInt;

{

public:

ProfileCallback(IDeckLinkProfile *requestedProfile) : m_requestedProfile(requestedProfile) {

m_requestedProfile->AddRef();

}

HRESULT ProfileChanging (/* in */ [[maybe_unused]] IDeckLinkProfile* profileToBeActivated, /* in */ [[maybe_unused]] BMD_BOOL streamsWillBeForcedToStop) override { return S_OK; }

HRESULT ProfileActivated (/* in */ [[maybe_unused]] IDeckLinkProfile* activatedProfile) override {

{

std::lock_guard<std::mutex> lock(m_profileActivatedMutex);

m_requestedProfileActivated = true;

}

m_profileActivatedCondition.notify_one();

return S_OK;

}

HRESULT STDMETHODCALLTYPE QueryInterface([[maybe_unused]] REFIID iid, [[maybe_unused]] LPVOID *ppv) override

{

*ppv = nullptr;

return E_NOINTERFACE;

}

ULONG STDMETHODCALLTYPE AddRef() override { return ++m_refCount; }

ULONG STDMETHODCALLTYPE Release() override {

ULONG refCount = --m_refCount;

if (refCount == 0)

delete this;

return refCount;

}

bool WaitForProfileActivation(void) {

BMD_BOOL isActiveProfile = BMD_FALSE;

const char *profileName = kDeviceProfiles.find(GetDeckLinkProfileID(m_requestedProfile)) != kDeviceProfiles.end() ?

kDeviceProfiles.at(GetDeckLinkProfileID(m_requestedProfile)).first : "(unknown)";

if ((m_requestedProfile->IsActive(&isActiveProfile) == S_OK) && isActiveProfile) {

LOG(LOG_LEVEL_INFO) << "[DeckLink] Profile " << profileName << " already active.\n";

return true;

}

LOG(LOG_LEVEL_INFO) << "[DeckLink] Waiting for profile activation... (this may take few seconds)\n";

std::unique_lock<std::mutex> lock(m_profileActivatedMutex);

bool ret = m_profileActivatedCondition.wait_for(lock, std::chrono::seconds{5}, [&]{ return m_requestedProfileActivated; });

if (ret) {

LOG(LOG_LEVEL_NOTICE) << "[DeckLink] Profile " << profileName << " activated successfully.\n";

} else {

LOG(LOG_LEVEL_ERROR) << "[DeckLink] Profile " << profileName << " activation timeouted!\n";

}

return ret;

}

virtual ~ProfileCallback() {

m_requestedProfile->Release();

}

private:

IDeckLinkProfile *m_requestedProfile;

int m_refCount = 1;

std::condition_variable m_profileActivatedCondition;

std::mutex m_profileActivatedMutex;

bool m_requestedProfileActivated = false;

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 (ret) {

const char *fcc = (const char *) &profileID;

if (!found) {// no err but not found

MSG(WARNING,

"Did not find suitable profile for '%.4s'!\n", fcc);

ret = false;

} else {

MSG(VERBOSE, "Found/set profile for %.4s!\n", fcc);

}

}

cleanup:

RELEASE_IF_NOT_NULL(p);

RELEASE_IF_NOT_NULL(it);

RELEASE_IF_NOT_NULL(manager);

return ret;

{

BMDProfileID ret{};

IDeckLinkProfileManager *manager = nullptr;

if (HRESULT result = decklink->QueryInterface(IID_IDeckLinkProfileManager, (void**)&manager); FAILED(result)) {

if (result != E_NOINTERFACE) {

LOG(LOG_LEVEL_ERROR) << "Cannot get IDeckLinkProfileManager: " << bmd_hresult_to_string(result) << "\n";

}

return {};

}

IDeckLinkProfileIterator *it = nullptr;

IDeckLinkProfile *profile = nullptr;

EXIT_IF_FAILED(manager->GetProfiles(&it), "Cannot get profiles iterator");

while (it->Next(&profile) == S_OK) {

BMD_BOOL isActiveProfile = BMD_FALSE;

if ((profile->IsActive(&isActiveProfile) == S_OK) && isActiveProfile) {

ret = GetDeckLinkProfileID(profile);

profile->Release();

break;

}

profile->Release();

}

cleanup:

RELEASE_IF_NOT_NULL(it);

RELEASE_IF_NOT_NULL(manager);

return ret;

if (BMDProfileID profile_active = decklink_get_active_profile_id(deckLink)) {

if (profile_active != bmdProfileOneSubDeviceHalfDuplex &&

profile_active != bmdProfileOneSubDeviceFullDuplex) {

uint32_t profile_fcc_host = be32toh(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;

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;

union {

uint32_t fourcc;

char c4[4];

} u;

memset(u.c4, ' ', 4);

memcpy(u.c4, str, min(strlen(str), sizeof u.c4));

return htobe32(u.fourcc);

for (unsigned i = 0; i < std::size(opt_name_map); ++i) {

if (opt_name_map[i].fourcc == fourcc) {

return opt_name_map[i].name;

}

}

for (unsigned i = 0; i < std::size(val_name_map); ++i) {

if (val_name_map[i].fourcc == fourcc) {

return val_name_map[i].name;

}

}

union {

char c[5];

uint32_t i;

} fcc{};

fcc.i = htobe32(fourcc);

return string("'") + fcc.c + "'";

m_val.i = val_;

m_type = type_tag::t_int;

m_user_specified = true;

m_val.f = val_;

m_type = type_tag::t_float;

m_user_specified = true;

strncpy(m_val.s, val_, sizeof m_val.s - 1);

m_type = type_tag::t_string;

m_user_specified = true;

if (m_type != type_tag::t_flag) {

log_msg(LOG_LEVEL_WARNING, MOD_NAME "Option is not set to a flag but get_flag() called! Current type tag: %d\n", (int) m_type);

return {};

}

return m_val.b;

if (m_type != type_tag::t_int) {

log_msg(LOG_LEVEL_WARNING, MOD_NAME "Option is not set to an int but get_int() called! Current type tag: %d\n", (int) m_type);

return {};

}

return m_val.i;

{

color_printf(TBOLD("BMD") " option syntax:\n");

color_printf("\t" TBOLD("<FourCC>=<val>") "\n\n");

color_printf(

TBOLD("<FourCC>") " must have exactly " TBOLD("4 characters") "\n");

color_printf("\n");

color_printf("The value must corresponding type is deduced accordingly:\n");

color_printf("- " TBOLD("flag") " - values on/of, true/false, yes/no\n");

color_printf("- literal " TBOLD("keep") " - keep the preset value\n");

color_printf("- literal " TBOLD(

"help") " - show help (applicable to profile only)\n");

color_printf("- " TBOLD(

"int") " - any number without decimal point\n");

color_printf("- " TBOLD(

"float") " - a number with a decimal point\n");

color_printf(

"- " TBOLD("FourCC") " - a value with len <= 4 not listed above\n");

color_printf("\n");

color_printf("If the type deduction is not working, you can use also "

"following syntax:\n");

color_printf("- \"value\" - assume the value is string\n");

color_printf("- 'vlue' - assume the value is FourCC\n");

color_printf("\n");

color_printf("List of keys:\n");

for (unsigned i = 0; i < std::size(opt_name_map); ++i) {

if (opt_name_map[i].fourcc == 0) {

color_printf("\n%s:\n", opt_name_map[0].name);

} else {

uint32_t val = htobe32(opt_name_map[i].fourcc);

color_printf("- " TBOLD("%.4s") " - %s\n",

(char *) &val, opt_name_map[i].name);

}

}

color_printf("\n");

color_printf("See also\n" TUNDERLINE(

"https://github.com/CESNET/UltraGrid/blob/master/ext-deps/"

"DeckLink/Linux/DeckLinkAPIConfiguration.h") "\nfor details.\n");

color_printf("\n");

color_printf("Incomplete " TBOLD("(!)") " list of values:\n");

color_printf("(note that the value belongs to its appropriate key)\n");

for (unsigned i = 0; i < std::size(val_name_map); ++i) {

uint32_t val = htobe32(val_name_map[i].fourcc);

color_printf("- " TBOLD("%.4s") " - %s\n", (char *) &val,

val_name_map[i].name);

}

color_printf("\n");

color_printf("Available values can be found here:\n" TUNDERLINE(

"https://github.com/CESNET/UltraGrid/blob/master/ext-deps/"

"DeckLink/Linux/DeckLinkAPI.h") "\n");

color_printf("\n");

color_printf("The actual key type and possible values must be, however "

"consutlted with:\n" TUNDERLINE(

"https://documents.blackmagicdesign.com/UserManuals/"

"DeckLinkSDKManual.pdf") "\n");

color_printf("\n");

color_printf("Examples:\n");

color_printf(TBOLD("aacl=on") " - set audio consumer levels (flag)\n");

color_printf(TBOLD("voio=blac") " - display black when no output\n");

color_printf(TBOLD("DHCP=yes") " - use DHCP config for DeckLink IP\n");

color_printf(TBOLD("DHCP=no:"

"nsip=10.0.0.3:nssm=255.255.255.0:nsgw=10.0.0.1") " - use static "

"net config for "

"DeckLink IP\n");

color_printf(TBOLD(

"noaa=239.255.194.26\\:16384:noav=239.255.194.26\\:"

"163888") " - set output "

"audio/video address\n(note that the shell will remove "

"backslash if not quoted, so you may use eg.:\nuv -t "

"'decklink:noaa=239.255.194.26\\:16384')\n");

color_printf("\n");