{

if (init) {

#if defined BUILD_LIBRARIES

for (auto a : init->opened_libs) {

dlclose(a);

}

#endif

com_uninitialize(&init->com_initialized);

}

delete init;

#ifdef __gnu_linux__

muntrace();

#endif

#ifdef _WIN32

WSACleanup();

#endif

#if defined CUDA_DEVICE_RESET

// to allow "cuda-memcheck --leak-check full"

cuda_wrapper_device_reset();

#endif

unexpected_exit_called = false;

const unordered_map<const char *, pair<FILE *, int>> outs = { // pair<output, default mode>

#ifdef _WIN32

{ "stdout-buf", pair{stdout, _IONBF} },

#else

{ "stdout-buf", pair{stdout, _IOLBF} },

#endif

{ "stderr-buf", pair{stderr, _IONBF} }

};

for (const auto& outp : outs) {

int mode = outp.second.second; // default

if(running_in_debugger()){

mode = _IONBF;

log_msg(LOG_LEVEL_WARNING, "Running inside debugger - disabling output buffering.\n");

}

if (get_commandline_param(outp.first)) {

const unordered_map<string, int> buf_map {

{ "no", _IONBF }, { "line", _IOLBF }, { "full", _IOFBF }

};

if (string("help") == get_commandline_param(outp.first)) {

printf("Available values for buffering are \"no\", \"line\" and \"full\"\n");

return false;

}

auto it = buf_map.find(get_commandline_param(outp.first));

if (it == buf_map.end()) {

log_msg(LOG_LEVEL_ERROR, "Wrong buffer type: %s\n", get_commandline_param(outp.first));

return false;

}

mode = it->second;

}

if (setvbuf(outp.second.first, NULL, mode, BUFSIZ) != 0) {

log_msg(LOG_LEVEL_WARNING, "setvbuf: %s\n", ug_strerror(errno));

}

}

return true;

//char msg[1024] = "";

//XGetErrorText(d, e->error_code, msg, sizeof msg - 1);

UNUSED(d);

log_msg(LOG_LEVEL_ERROR, "X11 error - code: %d, serial: %d, error: %d, request: %d, minor: %d\n",

e->error_code, e->serial, e->error_code, e->request_code, e->minor_code);

print_backtrace();

return 0;

{

#if !defined(_WIN32) && defined(__GLIBC__)

array<void *, 1> addresses{};

backtrace(addresses.data(), addresses.size());

#endif

{

struct audio_desc desc = {};

if (int ret = parse_audio_format(optarg, &desc)) {

return ret;

}

audio_capture_bps = IF_NOT_NULL_ELSE(desc.bps, audio_capture_bps);

audio_capture_channels = IF_NOT_NULL_ELSE(desc.ch_count, audio_capture_channels);

audio_capture_sample_rate = IF_NOT_NULL_ELSE(desc.sample_rate, audio_capture_sample_rate);

return 0;

if (strcmp(optarg, "help") == 0) {

char desc[] =

TBOLD("--conv-policy") " specifies the order in which various pixfmt properties are to be evaluated "

"if some pixel format needs conversion to another suitable pixel format.";

color_printf("%s\n\n", wrap_paragraph(desc));

color_printf("\t" TBOLD("c") " - color space\n");

color_printf("\t" TBOLD("d") " - bit depth\n");

color_printf("\t" TBOLD("s") " - subsampling\n");

color_printf("\nDefault: \"" TBOLD("dsc") "\" - first is respected bit-depth, then subsampling and finally color space\n\n"

"Permute the above letters to change the default order, eg. \"" TBOLD("cds") "\" to attempt to keep colorspace.\n");

return 1;

}

if (strlen(optarg) != strlen(pixfmt_conv_pref)) {

log_msg(LOG_LEVEL_ERROR, "Wrong pixfmt conversion policy length (exactly 3 letters need to be used)!\n");

return -1;

}

if (strchr(optarg, 'd') == NULL || strchr(optarg, 's') == NULL || strchr(optarg, 'c') == NULL) {

log_msg(LOG_LEVEL_ERROR, "Wrong pixfmt conversion policy - use exactly the set 'dsc'!\n");

return -1;

}

memcpy(pixfmt_conv_pref, optarg, strlen(pixfmt_conv_pref));

return 0;

{

char *log_opt = nullptr;

static struct option getopt_options[] = {

{"param", required_argument, nullptr, 'O'},

{"verbose", optional_argument, nullptr, 'V'},

{ nullptr, 0, nullptr, 0 }

};

const char *const optstring = "+O:V";

int saved_opterr = opterr;

opterr = 0; // options are further handled in main.cpp. skip unknown

int logging_lvl = 0;

bool logger_skip_repeats = true;

log_timestamp_mode logger_show_timestamps = LOG_TIMESTAMP_AUTO;

while (optind < argc) {

const int ch =

getopt_long(argc, argv, optstring, getopt_options, nullptr);

switch (ch) {

case 'V':

if (optarg != nullptr) {

log_opt = optarg;

} else {

logging_lvl += 1;

}

break;

case 'O':

if (!parse_params(optarg, true)) {

return false;

}

break;

case -1: // skip a non-option (or an argument to an option that

// is not recognized by this getopt)

optind += 1;

break;

case '?': // other option that will be handled in main

break;

default:

abort(); // shouldn't reach here

}

}

optind = 0;

opterr = saved_opterr;

if (logging_lvl == 0) {

logging_lvl = getenv("ULTRAGRID_VERBOSE") != nullptr && strlen(getenv("ULTRAGRID_VERBOSE")) > 0 ? LOG_LEVEL_VERBOSE : log_level;

} else {

logging_lvl += LOG_LEVEL_INFO;

}

if (log_opt != nullptr && !parse_log_cfg(log_opt, &logging_lvl, &logger_skip_repeats, &logger_show_timestamps)) {

return false;

}

log_level = logging_lvl;

get_log_output().set_skip_repeats(logger_skip_repeats);

get_log_output().set_timestamp_mode(logger_show_timestamps);

return true;

{

while (*argv != nullptr) {

if (strstr(*argv, tok) != nullptr) {

return true;

}

argv++;

}

return false;

if (!unexpected_exit_called) {

return;

}

fprintf(stderr, "exit() called unexpectedly! Maybe by some library?\n");

{

int fd = *reinterpret_cast<int*>(data);

char buf[STR_LEN];

char *start = buf;

const char *const end = buf + sizeof buf;

//fprintf(stderr, "libbacktrace error: %s (%d)\n", msg, errnum);

strappend(&start, end, "libbacktrace error: ");

strappend(&start, end, msg);

strappend(&start, end, " (");

append_number(&start, end, errnum);

write_all(fd, start - buf, buf);

const char *function)

{

int fd = *reinterpret_cast<int*>(data);

char buf[STR_LEN];

char *start = buf;

const char *const end = buf + sizeof buf;

// printf(" %s at %s:%d [pc=%p]\n", function ? function : "??",

// filename ? filename : "??", lineno, (void *) pc);

strappend(&start, end, " ");

if (function == nullptr) {

function = "??";

}

strappend(&start, end, function);

strappend(&start, end, " at ");

if (filename == nullptr) {

filename = "??";

}

strappend(&start, end, filename);

strappend(&start, end, ":");

append_number(&start, end, lineno);

strappend(&start, end, " [pc=0x");

append_number(&start, end, (uintmax_t) pc);

strappend(&start, end, "]\n");

write_all(fd, start - buf, buf);

return 0; // continue

state_root() noexcept {

if (platform_pipe_init(should_exit_pipe) != 0) {

LOG(LOG_LEVEL_FATAL) << "FATAL: Cannot create pipe!\n";

abort();

}

should_exit_thread = thread(should_exit_watcher, this);

}

~state_root() {

unique_lock<mutex> lk(lock);

should_exit_callbacks.clear();

lk.unlock();

broadcast_should_exit(true); // here just exit the should exit thr

should_exit_thread.join();

for (int i = 0; i < 2; ++i) {

platform_pipe_close(should_exit_pipe[0]);

}

}

static void should_exit_watcher(state_root *s) {

set_thread_name(__func__);

char q = 0;

bool should_exit_thread_notified = false;

while (q != QUIT_WATCHER_FLAG) {

while (PLATFORM_PIPE_READ(s->should_exit_pipe[0], &q,

1) != 1) {

perror("PLATFORM_PIPE_READ");

}

if (!should_exit_thread_notified) {

unique_lock<mutex> lk(s->lock);

for (auto const &c : s->should_exit_callbacks) {

get<0>(c)(get<1>(c));

}

should_exit_thread_notified = true;

}

}

}

void broadcast_should_exit(bool quit_watcher = false)

{

const char q = quit_watcher ? QUIT_WATCHER_FLAG : 0;

while (PLATFORM_PIPE_WRITE(should_exit_pipe[1], &q, 1) != 1) {

perror("PLATFORM_PIPE_WRITE");

}

}

volatile int exit_status = EXIT_SUCCESS;

static constexpr char QUIT_WATCHER_FLAG = 1;

mutex lock;

fd_t should_exit_pipe[2];

thread should_exit_thread;

list<tuple<void (*)(void *), void *>> should_exit_callbacks;

friend void register_should_exit_callback(struct module *mod,

void (*callback)(void *),

void *udata);

friend void unregister_should_exit_callback(struct module *mod,

void (*callback)(void *),

void *udata);

module_init_default(root_mod);

root_mod->cls = MODULE_CLASS_ROOT;

root_mod->new_message = nullptr; // note that the root mod messages

// processes also the reflector

state_root_static = new state_root();

root_mod->priv_data = state_root_static;

module_register(root_mod, nullptr);

if (!state_root_static) {

MSG(ERROR, "%s called without state registered.\n", __func__);

abort();

}

state_root_static->exit_status = status;

state_root_static->broadcast_should_exit();

cout << "[capability][device] {"

"\"purpose\":" << std::quoted(purpose) << ", "

"\"module\":" << std::quoted(mod) << ", "

"\"device\":" << std::quoted(device.dev) << ", "

"\"name\":" << std::quoted(device.name) << ", "

"\"extra\": {" << device.extra << "}, "

"\"repeatable\":\"" << device.repeatable << "\", "

"\"modes\": [";

for(unsigned int j = 0; j < std::size(device.modes); j++) {

if (device.modes[j].id[0] == '\0') { // last item

break;

}

if (j > 0) {

printf(", ");

}

std::cout << "{\"name\":" << std::quoted(device.modes[j].name) << ", "

"\"opts\":" << device.modes[j].id << "}";

}

std::cout << "]";

std::cout << ", \"options\": [";

for(unsigned int j = 0; j < std::size(device.options); j++) {

if (device.options[j].key[0] == '\0') { // last item

break;

}

if (j > 0) {

printf(", ");

}

cout << "{"

"\"display_name\":" << std::quoted(device.options[j].display_name) << ", "

"\"display_desc\":" << std::quoted(device.options[j].display_desc) << ", "

"\"key\":" << std::quoted(device.options[j].key) << ", "

"\"opt_str\":" << std::quoted(device.options[j].opt_str) << ", "

"\"is_boolean\":\"" << (device.options[j].is_boolean ? "t" : "f") << "\"}";

}

std::cout << "]";

std::cout << "}\n";

auto vdi = static_cast<T>(mod);

int count = 0;

struct device_info *devices = nullptr;

void (*deleter)(void *) = nullptr;

vdi->probe(&devices, &count, &deleter);

for (int i = 0; i < count; ++i) {

print_device(std::string(cap_str), name, devices[i]);

}

deleter ? deleter(devices) : free(devices);

auto vci = static_cast<const struct video_compress_info *>(mod);

if(vci->get_module_info){

auto module_info = vci->get_module_info();

cout << "[capability][video_compress] {"

"\"name\":" << std::quoted(name) << ", "

"\"options\": [";

int i = 0;

for(const auto& opt : module_info.opts){

if(i++ > 0)

cout << ", ";

cout << "{"

"\"display_name\":" << std::quoted(opt.display_name) << ", "

"\"display_desc\":" << std::quoted(opt.display_desc) << ", "

"\"placeholder_text\":" << std::quoted(opt.placeholder_text) << ", "

"\"key\":" << std::quoted(opt.key) << ", "

"\"opt_str\":" << std::quoted(opt.opt_str) << ", "

"\"is_boolean\":\"" << (opt.is_boolean ? "t" : "f") << "\"}";

}

cout << "], "

"\"codecs\": [";

int j = 0;

for(const auto& c : module_info.codecs){

if(j++ > 0)

cout << ", ";

cout << "{\"name\":" << std::quoted(c.name) << ", "

"\"priority\": " << c.priority << ", "

"\"encoders\":[";

int z = 0;

for(const auto& e : c.encoders){

if(z++ > 0)

cout << ", ";

cout << "{\"name\":" << std::quoted(e.name) << ", "

"\"opt_str\":" << std::quoted(e.opt_str) << "}";

}

cout << "]}";

}

cout << "]}" << std::endl;

}

{

for(const auto& mod_class : mod_classes){

for(const auto& mod : class_mod_map[mod_class.cls]){

if(!mod_class.probe_print)

continue;

mod_class.probe_print(mod.first, mod.second);

}

}

{

for(const auto& mod_class : mod_classes){

std::cout << "[cap] " << mod_class.desc << ":\n";

for(const auto& mod : class_mod_map[mod_class.cls]){

cout << "[cap][" << mod_class.cap_str <<"] " << mod.first << "\n";

}

}

{

std::string_view conf(cfg);

std::cout << "[capability][start] version 4" << endl;

std::map<enum library_class, module_info_map> class_mod_map;

for(const auto& mod_class: mod_classes){

class_mod_map.emplace(mod_class.cls,

get_libraries_for_class(mod_class.cls, mod_class.abi_ver));

}

auto codecs = get_audio_codec_list();

for(const auto& codec : codecs){

class_mod_map[LIBRARY_CLASS_AUDIO_COMPRESS].emplace(get<0>(codec).name, nullptr);

}

if(conf == "noprobe"){

print_modules(class_mod_map);

} else if(conf.empty()){

print_modules(class_mod_map);

probe_all(class_mod_map);

} else {

auto class_sv = tokenize(conf, ':');

auto mod_sv = tokenize(conf, ':');

enum library_class cls = LIBRARY_CLASS_UNDEFINED;

void (*probe_print)(std::string name, const void *) = nullptr;

for(const auto& i : mod_classes){

if(i.cap_str == class_sv){

cls = i.cls;

probe_print = i.probe_print;

}

}

if(cls == LIBRARY_CLASS_UNDEFINED){

log_msg(LOG_LEVEL_FATAL, "Unknown library class\n");

return;

}

auto& modmap = class_mod_map[cls];

auto modinfo = modmap.find(std::string(mod_sv));

if(modinfo == modmap.end()){

log_msg(LOG_LEVEL_FATAL, "Module not found\n");

return;

}

if(probe_print)

probe_print(std::string(mod_sv), modinfo->second);

}

cout << "[capability][end]" << endl;

{

bool is_release = true;

#ifdef GIT_BRANCH

if (strstr(GIT_BRANCH, "release") == nullptr &&

strstr(GIT_BRANCH, "tags/v") == nullptr) {

is_release = false;

}

#endif

col() << SBOLD(S256_FG(T_ARCTIC_LIME, PACKAGE_STRING <<

(is_release ? "" : "+"))) <<

" (" << get_version_details() << ")\n";

{

const char *config_flags = CONFIG_FLAGS;

if (strlen(config_flags) == 0) {

config_flags = "(none)";

}

printf("configuration flags: %s", config_flags);

printf("\n\n");

printf(PACKAGE_NAME " was compiled with following features:\n");

printf(AUTOCONF_RESULT);

{

log_msg(LOG_LEVEL_NOTICE, "Setting A/V delay: %d\n", audio_delay);

audio_offset = max(audio_delay, 0);

video_offset = audio_delay < 0 ? abs(audio_delay) : 0;