#include "host.h"
#include <execinfo.h>
#include <fcntl.h>
#include <algorithm>
#include <array>
#include <cassert>
#include <cerrno>
#include <cmath>
#include <csignal>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <getopt.h>
#include <iterator>
#include <map>
#include <mutex>
#include <string_view>
#include <sys/types.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#include "audio/audio_capture.h"
#include "audio/audio_filter.h"
#include "audio/audio_playback.h"
#include "audio/codec.h"
#include "audio/types.h"
#include "audio/utils.h"
#include "capture_filter.h"
#include "compat/platform_pipe.h"
#include "compat/strings.h"
#include "config_unix.h"
#include "cuda_wrapper.h"
#include "debug.h"
#include "keyboard_control.h"
#include "lib_common.h"
#include "module.h"
#include "types.h"
#include "utils/color_out.h"
#include "utils/fs.h"
#include "utils/misc.h"
#include "utils/random.h"
#include "utils/string.h"
#include "utils/string_view_utils.hpp"
#include "utils/text.h"
#include "utils/thread.h"
#include "utils/windows.h"
#include "video_capture.h"
#include "video_codec.h"
#include "video_compress.h"
#include "video_display.h"
#include <iomanip>
#include <iostream>
#include <list>
#include <fstream>
#include <string>
#include <thread>
#include <utility>

Classes
struct	init_data

struct	state_root

Macros
#define	MOD_NAME "[host] "

Typedefs
using	module_info_map = std::map<std::string, const void *>

Functions
	ADD_TO_PARAM ("allow-unknown-params", "* allow-unknown-params\n" " Do not exit on unknown parameter.\n")

	ADD_TO_PARAM ("audio-buffer-len", "* audio-buffer-len=<ms>\n" " Sets length of software audio playback buffer (in ms, ALSA/Coreaudio/Portaudio/WASAPI)\n")

	ADD_TO_PARAM ("audio-cap-frames", "* audio-cap-frames=<f>\n" " Sets number of audio frames captured at once (CoreAudio)\n")

	ADD_TO_PARAM ("audio-disable-adaptive-buffer", "* audio-disable-adaptive-buffer\n" " Disables audio adaptive playback buffer (CoreAudio/JACK)\n")

	ADD_TO_PARAM ("color", "* color=CT\n" " [experimental] Color space to use, C - colorimetry: 0 - undefined, 1 - BT.709, 2 - BT.2020/2100, 3 - P3; T - transfer fn: 0 - undefined, 1 - 709, 2 - HLG; 3 - PQ (signalized to GLFW on mac, NDI receiver)\n")

	ADD_TO_PARAM ("errors-fatal", "* errors-fatal\n" " Treats some errors as fatal and exit even though " PACKAGE_NAME " could continue otherwise.\n" " This allows less severe errors to be catched (which should not occur under normal circumstances).\n" " An environment variable ULTRAGRID_ERRORS_FATAL with the same effect can also be used.\n")

	ADD_TO_PARAM ("low-latency-audio", "* low-latency-audio[=ultra]\n" " Try to reduce audio latency at the expense of worse reliability\n" " Add ultra for even more aggressive setting.\n")

	ADD_TO_PARAM ("stderr-buf", "* stderr-buf={no\|line\|full}\n" " Buffering for stderr\n")

	ADD_TO_PARAM ("stdout-buf", "* stdout-buf={no\|line\|full}\n" " Buffering for stdout\n")

	ADD_TO_PARAM ("window-title", "* window-title=<title>\n" " Use alternative window title (SDL/GL only)\n")

void	common_cleanup (struct init_data *init)

struct init_data *	common_preinit (int argc, char *argv[])

void	crash_signal_handler (int sig)

static void	echeck_unexpected_exit (void)

void	exit_uv (int status)

int	get_audio_delay (void)

const char *	get_commandline_param (const char *key)

int	get_exit_status (struct module *root_mod)

const char *	get_version_details ()

void	handle_error (int status)

void	hang_signal_handler (int sig)

void	init_root_module (struct module *root_mod)

static void	load_libgcc ()

bool	parse_bitrate (char optarg, long long int bitrate)

static bool	parse_opts_set_logging (int argc, char *argv[])

bool	parse_params (const char *optarg, bool preinit)

static void	print_backtrace ()

void	print_capabilities (const char *cfg)

void	print_configuration ()

static void	print_device (std::string purpose, std::string const &mod, const device_info &device)

static void	print_modules (std::map< enum library_class, module_info_map > &class_mod_map)

static void	print_param_doc (void)

void	print_pixel_formats (void)

void	print_version ()

void	print_video_codecs (void)

static void	probe_all (std::map< enum library_class, module_info_map > &class_mod_map)

static void	probe_compress (std::string const &name, const void *mod) noexcept

template<typename T >
static void	probe_device (std::string_view cap_str, std::string const &name, const void *mod)

bool	register_mainloop (mainloop_t m, void *u)

void	register_param (const char param, const char doc)

void	register_should_exit_callback (struct module mod, void(callback)(void ), void udata)

bool	running_in_debugger ()

int	set_audio_capture_format (const char *optarg)

void	set_audio_delay (int audio_delay)

void	set_commandline_param (const char key, const char val)

static bool	set_output_buffering ()

int	set_pixfmt_conv_policy (const char *optarg)

bool	tok_in_argv (char *argv, const char tok)

void	unregister_should_exit_callback (struct module mod, void(callback)(void ), void udata)

static bool	validate_param (const char *param)

Variables
unsigned int	audio_capture_bps = 0

unsigned int	audio_capture_channels = 0

unsigned int	audio_capture_sample_rate = 0

volatile int	audio_offset
	added audio delay in ms (non-negative), can be used to tune AV sync

std::unordered_map< std::string, std::string >	commandline_params

unsigned int	cuda_devices [MAX_CUDA_DEVICES] = { 0 }

unsigned int	cuda_devices_count = 1

bool	cuda_devices_explicit = false
	–cuda-device/-D specified expilcitly

char *	export_dir = NULL

int	glfw_init_count
	0->1 - call glfwInit, 1->0 call glfwTerminate; glfw{Init,Terminate} should be called from main thr, thus no need to synchronize

mainloop_t	mainloop
	mainloop to be run if display mainloop isn't run

void *	mainloop_udata

struct {

int abi_ver

std::string_view cap_str

enum library_class cls

std::string_view desc

void(* probe_print )(std::string name, const void *)

}	mod_classes []

struct {

const char * doc

const char * param

}	params [100]

uint32_t	RTT = 0

static state_root *volatile	state_root_static
	used by exit_uv() called from signal handler

static bool	unexpected_exit_called = true

int	uv_argc

char **	uv_argv

volatile int	video_offset
	added video delay in ms (non-negative), can be used to tune AV sync

Detailed Description

Author: Martin Piatka piatk.nosp@m.a@ce.nosp@m.snet..nosp@m.cz; Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz

This file contains common external definitions.

Definition in file host.cpp.

Macro Definition Documentation

◆ MOD_NAME

#define MOD_NAME "[host] "

Definition at line 142 of file host.cpp.

Typedef Documentation

◆ module_info_map

using module_info_map = std::map<std::string, const void *>

Definition at line 638 of file host.cpp.

Function Documentation

◆ ADD_TO_PARAM() [1/10]

ADD_TO_PARAM	(	"allow-unknown-params"	,
		"* allow-unknown-params\n" " Do not exit on unknown parameter.\n"	)

◆ ADD_TO_PARAM() [2/10]

ADD_TO_PARAM ( "audio-buffer-len" )

◆ ADD_TO_PARAM() [3/10]

ADD_TO_PARAM ( "audio-cap-frames" )

◆ ADD_TO_PARAM() [4/10]

ADD_TO_PARAM	(	"audio-disable-adaptive-buffer"	,
		"* audio-disable-adaptive-buffer\n" " Disables audio adaptive playback buffer (CoreAudio/JACK)\n"	)

◆ ADD_TO_PARAM() [5/10]

ADD_TO_PARAM	(	"color"	,
		"*	color = CT\n" " [experimental] Color space to use,
		C - colorimetry:0 -	undefined,
		1 - BT.	709,
		2 - BT.2020/	2100,
		3 - P3;T - transfer fn:0 -	undefined,
		1 -	709,
		2 - HLG;3 - PQ(signalized to GLFW on mac, NDI receiver)\n"	)

◆ ADD_TO_PARAM() [6/10]

ADD_TO_PARAM	(	"errors-fatal"	,
		"* errors-fatal\n" " Treats some errors as fatal and exit even though " PACKAGE_NAME " could continue otherwise.\n" " This allows less severe errors to be catched (which should not occur under normal circumstances).\n" " An environment variable ULTRAGRID_ERRORS_FATAL with the same effect can also be used.\n"	)

◆ ADD_TO_PARAM() [7/10]

ADD_TO_PARAM	(	"low-latency-audio"	,
		"* low-latency-audio\n" " Try to reduce audio latency at the expense of worse reliability\n" " Add ultra for even more aggressive setting.\n"	[=ultra] )

◆ ADD_TO_PARAM() [8/10]

ADD_TO_PARAM ( "stderr-buf" )

◆ ADD_TO_PARAM() [9/10]

ADD_TO_PARAM ( "stdout-buf" )

◆ ADD_TO_PARAM() [10/10]

ADD_TO_PARAM ( "window-title" )

◆ common_cleanup()

void common_cleanup ( struct init_data * init )

Definition at line 203 of file host.cpp.

{
        if (init) {
#if defined BUILD_LIBRARIES
                for (auto a : init->opened_libs) {
                        dlclose(a);
                }
#endif
                com_uninitialize(&init->com_initialized);
        }
        delete init;
 
#ifdef __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;
}

References com_uninitialize(), cuda_wrapper_device_reset(), init(), and unexpected_exit_called.

Referenced by main(), and main().

Here is the call graph for this function:

◆ common_preinit()

struct init_data * common_preinit	(	int	argc,
		char *	argv[] )

Definition at line 435 of file host.cpp.

{
        uv_argc = argc;
        uv_argv = argv;
 
        if (!parse_opts_set_logging(argc, argv)) {
                return nullptr;
        }
 
        if (!set_output_buffering()) {
                LOG(LOG_LEVEL_WARNING) << "Cannot set console output buffering!\n";
                return nullptr;
        }
        std::clog.rdbuf(std::cout.rdbuf()); // use stdout for logs by default
        color_output_init();
 
#ifdef HAVE_X
        void *handle = dlopen(X11_LIB_NAME, RTLD_NOW);
 
        if (handle) {
                Status (*XInitThreadsProc)();
                XInitThreadsProc = (Status (*)()) dlsym(handle, "XInitThreads");
                if (XInitThreadsProc) {
                        Status s = XInitThreadsProc();
                        if (s != True) {
                                log_msg(LOG_LEVEL_WARNING, "XInitThreads failed.\n");
                        }
                } else {
                        log_msg(LOG_LEVEL_WARNING, "Unable to load symbol XInitThreads: %s\n", dlerror());
                }
 
                typedef int (*XSetErrorHandler_t(int (*handler)(Display *, XErrorEvent *)))();
                XSetErrorHandler_t *XSetErrorHandlerProc;
                XSetErrorHandlerProc = (XSetErrorHandler_t *) dlsym(handle, "XSetErrorHandler");
                if (XSetErrorHandlerProc) {
                        XSetErrorHandlerProc(x11_error_handler);
                } else {
                        log_msg(LOG_LEVEL_WARNING, "Unable to load symbol XSetErrorHandler: %s\n", dlerror());
                }
 
                dlclose(handle);
        } else {
                log_msg(LOG_LEVEL_WARNING, "Unable open " X11_LIB_NAME " library: %s\n", dlerror());
        }
#endif
 
        struct init_data init{};
#ifdef _WIN32
        WSADATA wsaData;
        int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if(err != 0) {
                fprintf(stderr, "WSAStartup failed with error %d.", err);
                return nullptr;
        }
        if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
                fprintf(stderr, "Counld not found usable version of Winsock.\n");
                WSACleanup();
                return nullptr;
        }
 
        SetConsoleOutputCP(CP_UTF8); // see also https://stackoverflow.com/questions/1660492/utf-8-output-on-windows-console
 
        // Initialize COM on main thread - otherwise Portaudio would initialize it as COINIT_APARTMENTTHREADED but MULTITHREADED
        // is perhaps better variant (Portaudio would accept that).
        const bool init_com = !tok_in_argv(argv, "screen:unregister_elevated");
        if (init_com) {
                com_initialize(&init.com_initialized, nullptr);
        }
 
        // warn in W10 "legacy" terminal emulators
        if (getenv("TERM") == nullptr &&
            _isatty(fileno(stdout)) &&
            get_windows_build() < BUILD_WINDOWS_11_OR_LATER &&
            (win_has_ancestor_process("powershell.exe") ||
             win_has_ancestor_process("cmd.exe")) &&
            !win_has_ancestor_process("WindowsTerminal.exe")) {
                MSG(WARNING, "Running inside PS/cmd terminal is not recommended "
                             "because scrolling the output freezes the process, "
                             "consider using Windows Terminal instead!\n");
                Sleep(1000);
        }
#endif
 
        if (strstr(argv[0], "run_tests") == nullptr) {
                open_all("ultragrid_*.so", init.opened_libs); // load modules
        }
 
        ug_rand_init();
 
#ifdef __linux__
        mtrace();
#endif
 
        load_libgcc();
 
#ifdef HAVE_FEC_INIT
        fec_init();
#endif
 
        atexit(echeck_unexpected_exit);
 
        return new init_data{ std::move(init) };
}

References BUILD_WINDOWS_11_OR_LATER, color_output_init(), com_initialize(), echeck_unexpected_exit(), init(), load_libgcc(), LOG, LOG_LEVEL_WARNING, log_msg(), MSG, open_all(), parse_opts_set_logging(), set_output_buffering(), tok_in_argv(), ug_rand_init(), uv_argc, and uv_argv.

Referenced by main(), and main().

Here is the call graph for this function:

◆ crash_signal_handler()

void crash_signal_handler ( int sig )

Definition at line 1253 of file host.cpp.

{
        print_backtrace();
 
        char buf[1024];
        char *ptr = buf;
        char *ptr_end = buf + sizeof buf;
        strappend(&ptr, ptr_end, "\n" PACKAGE_NAME " has crashed");
 
        append_sig_desc(&ptr, ptr_end, sig);
 
        strappend(&ptr, ptr_end, ".\n\nPlease send a bug report to address " PACKAGE_BUGREPORT ".\n");
        strappend(&ptr, ptr_end, "You may find some tips how to report bugs in file doc/REPORTING_BUGS.md distributed with " PACKAGE_NAME "\n");
        strappend(&ptr, ptr_end, "(or available online at https://github.com/CESNET/UltraGrid/blob/master/doc/REPORTING-BUGS.md).\n");
 
        write_all(STDERR_FILENO, ptr - buf, buf);
 
        restore_old_tio();
 
        signal(sig, SIG_DFL);
        raise(sig);
}

References append_sig_desc(), print_backtrace(), restore_old_tio(), strappend(), and write_all().

Referenced by main(), and main().

Here is the call graph for this function:

◆ echeck_unexpected_exit()

static void echeck_unexpected_exit ( void )

static

Definition at line 428 of file host.cpp.

                                          {
        if (!unexpected_exit_called) {
                return;
        }
        fprintf(stderr, "exit() called unexpectedly! Maybe by some library?\n");
}

References unexpected_exit_called.

Referenced by common_preinit().

◆ exit_uv()

void exit_uv ( int status )

Exit function that sets return value and brodcasts registered modules should_exit.

Should be called after init_root_module() is called.

Definition at line 625 of file host.cpp.

                         {
        if (!state_root_static) {
                log_msg(LOG_LEVEL_WARNING, "%s called witout state registered.\n", __func__);
        }
        state_root_static->exit_status = status;
        state_root_static->broadcast_should_exit();
}

References state_root::broadcast_should_exit(), state_root::exit_status, LOG_LEVEL_WARNING, log_msg(), and state_root_static.

Referenced by audio_cap_alsa_read(), audio_decoder_reconfigure(), audio_play_alsa_write_frame(), audio_receiver_thread(), audio_sender_process_message(), audio_sender_thread(), audio_start(), configure_with(), display_dummy_putf(), display_gl_process_key(), display_panogl_run(), display_reconfigure_audio(), display_sage_run(), display_sdl2_process_key(), display_sdl2_run(), display_sdl_run(), display_xrgl_run(), export_video(), fec_thread(), get_usable_decoders(), glfw_close_callback(), handle_error(), handle_events(), handle_keyboard_event(), initialize(), keep_alive_thread(), main(), ultragrid_rtp_video_rxtx::new_video_decoder(), process_msg(), rtp_video_rxtx::process_sender_message(), ultragrid_rtp_video_rxtx::receiver_loop(), reconfigure(), reconfigure_slave_rendering(), restartAcquisition(), h264_sdp_video_rxtx::send_frame(), signal_handler(), signal_handler(), slave_worker(), tx_send_jpeg(), validate_hwacc_param(), vidcap_file_process_messages(), vidcap_import_grab(), vidcap_screen_x11_grab(), and worker().

Here is the call graph for this function:

◆ get_audio_delay()

int get_audio_delay ( void )

Definition at line 909 of file host.cpp.

{
        return audio_offset > 0 ? audio_offset : -video_offset;
}

References audio_offset, and video_offset.

Referenced by keyboard_control::impl::info(), and keyboard_control::impl::run().

◆ get_commandline_param()

const char * get_commandline_param ( const char * key )

Definition at line 894 of file host.cpp.

{
        auto it = commandline_params.find(key);
        if (it != commandline_params.end()) {
                return it->second.c_str();
        } else {
                return NULL;
        }
}

References commandline_params, and key.

Referenced by am_participant::am_participant(), audio_frame2_resampler::audio_frame2_resampler(), ultragrid_rtp_video_rxtx::ultragrid_rtp_video_rxtx(), audio_cap_ca_init(), audio_decoder_init(), audio_decoder_reconfigure(), audio_play_alsa_init(), audio_play_alsa_reconfigure(), audio_play_ca_init(), audio_play_ca_reconfigure(), audio_play_jack_reconfigure(), audio_play_portaudio_reconfigure(), audio_play_wasapi_reconfigure(), audio_receiver_thread(), check_packet_size(), configure_with(), control_init(), control_thread(), decklink_help(), display_decklink_putf(), display_decklink_reconfigure(), display_gl_init_opengl(), display_gl_set_window_hints(), display_sdl2_reconfigure_real(), display_sdl_reconfigure_real(), echo_cancellation_init(), get_format_callback(), get_sine_signal(), get_usable_decoders(), gl_substitute_compile_link(), handle_error(), vidcap_state_aja::Init(), ldgm::init(), init_common(), init_decoder(), init_encoder(), is_output_color(), j2k_decompress_init(), libavcodec_decompress_get_property(), libavcodec_decompress_reconfigure(), libavcodec_init(), ndi_disp_format_video_metadata(), parse_params(), postprocess_frame(), reconfigure_echo(), vidcap_decklink_state::set_codec(), set_codec_context_params(), set_device_buffer(), set_mac_color_space(), set_output_buffering(), set_postprocess_convert(), show_help(), keyboard_control::impl::start(), udp_init_if(), ug_set_av_logging(), validate_hwacc_param(), vdp_interop_supported(), and video_decoder_register_display().

◆ get_exit_status()

int get_exit_status ( struct module * root_mod )

Definition at line 633 of file host.cpp.

                                             {
        assert(root_mod->cls == MODULE_CLASS_ROOT);
        return static_cast<state_root *>(root_mod->priv_data)->exit_status;
}

References module::cls, MODULE_CLASS_ROOT, and module::priv_data.

Referenced by main().

◆ get_version_details()

const char * get_version_details ( void )

Definition at line 856 of file host.cpp.

{
        return
#ifdef GIT_BRANCH
                GIT_BRANCH " "
#endif
#ifdef GIT_REV
                "rev " GIT_REV " "
#endif
                "built " __DATE__ " " __TIME__;
}

Referenced by keyboard_control::impl::info(), and print_version().

◆ handle_error()

void handle_error ( int status )

Soft version of exit_uv() checks errors-fatal command-line parameters and if set, exit UltraGrid. Otherwise error is ignored.

Caller code normally continues after this function so the error must not have been fatal and UltraGrid must remain in a consistent state.

Definition at line 1184 of file host.cpp.

                              {
        if (get_commandline_param("errors-fatal") || getenv("ULTRAGRID_ERRORS_FATAL")) {
                exit_uv(status);
        }
}

References exit_uv(), and get_commandline_param().

Referenced by decode_video_frame(), display_gl_init_opengl(), init_decoder(), and set_sock_opts_and_bind().

Here is the call graph for this function:

◆ hang_signal_handler()

void hang_signal_handler ( int sig )

Definition at line 1276 of file host.cpp.

{
        UNUSED(sig);
#ifndef _WIN32
        assert(sig == SIGALRM);
        char msg[] = "Hang detected - you may continue waiting or kill UltraGrid. Please report if UltraGrid doesn't exit after reasonable amount of time.\n";
        write_all(STDERR_FILENO, sizeof msg - 1, msg);
        signal(SIGALRM, SIG_DFL);
#endif // ! defined _WIN32
}

References UNUSED, and write_all().

Referenced by main(), and main().

Here is the call graph for this function:

◆ init_root_module()

void init_root_module ( struct module * root_mod )

Initializes root module

This the root module is also responsible for regiestering and broadcasting should_exit events (see register_should_exit_callback) called by exit_uv().

Definition at line 610 of file host.cpp.

                                               {
        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
        root_mod->deleter = state_root::deleter;
        state_root_static = new state_root();
        root_mod->priv_data = state_root_static;
}

References module::cls, module::deleter, state_root::deleter(), MODULE_CLASS_ROOT, module_init_default(), module::new_message, module::priv_data, and state_root_static.

Referenced by hd_rum_translator_state::hd_rum_translator_state(), and state_uv::state_uv().

Here is the call graph for this function:

◆ load_libgcc()

static void load_libgcc ( )

static

dummy load of libgcc for backtrace() to be signal safe within crash_signal_handler() (see backtrace(3))

Definition at line 300 of file host.cpp.

{
#ifndef _WIN32
        array<void *, 1> addresses{};
        backtrace(addresses.data(), addresses.size());
#endif
}

Referenced by common_preinit().

◆ parse_bitrate()

bool parse_bitrate	(	char *	optarg,
		long long int *	bitrate )

Definition at line 1012 of file host.cpp.

{
        unordered_map<string, long long int> bitrate_spec_map = {
                {"auto",       RATE_AUTO     },
                { "dynamic",   RATE_DYNAMIC  },
                { "unlimited", RATE_UNLIMITED},
        };
 
        if (auto it = bitrate_spec_map.find(optarg);
            it != bitrate_spec_map.end()) {
                *bitrate = it->second;
                return true;
        }
        if (strcmp(optarg, "help") == 0) {
                constexpr char const *NUMERIC_PATTERN = "{1-9}{0-9}*[kMG][!][E]";
                col()
                    << "Usage:\n"
                    << "\tuv " << TERM_BOLD "-l [auto | dynamic | unlimited | "
                    << NUMERIC_PATTERN << "]\n" TERM_RESET
                    << "where\n"
                       "\t"
                    << TBOLD("auto")
                    << " - spread packets across frame time\n"
                       "\t"
                    << TBOLD("dynamic")
                    << " - similar to \"auto\" but more relaxed - occasional "
                       "huge frame can spread 1.5x frame time (default)\n"
                       "\t"
                    << TBOLD("unlimited")
                    << " - send packets at a wire speed (in bursts)\n"
                       "\t"
                    << SBOLD(NUMERIC_PATTERN)
                    << " - send packets at most at specified bitrate\n\n"
                    << TBOLD("Notes: ")
                    << "Use an exclamation mark to indicate intentionally very "
                       "low bitrate. 'E' to use the value as a fixed bitrate, "
                       "not cap /i. e. even the frames that may be sent at "
                       "lower bitrate are sent at the nominal bitrate)\n"
                    << "\n";
                return true;
        }
        bool force = false;
        bool fixed = false;
        for (int i = 0; i < 2; ++i) {
                if (optarg[strlen(optarg) - 1] == '!' ||
                    optarg[strlen(optarg) - 1] == 'E') {
                        if (optarg[strlen(optarg) - 1] == '!') {
                                force                      = true;
                                optarg[strlen(optarg) - 1] = '\0';
                        }
                        if (optarg[strlen(optarg) - 1] == 'E') {
                                fixed                      = true;
                                optarg[strlen(optarg) - 1] = '\0';
                        }
                }
        }
        *bitrate = unit_evaluate(optarg, nullptr);
        if (*bitrate <= 0) {
                log_msg(LOG_LEVEL_ERROR, "Invalid bitrate %s!\n", optarg);
                return false;
        }
        constexpr long long mb5 =
            5ll * 1000 *
            1000; // it'll take 6.4 sec to send 4 MB frame at 5 Mbps
        constexpr long long gb100 =
            100ll * 1000 * 1000 *
            1000; // traffic shaping to eg. 40 Gbps may make sense
        if ((*bitrate < mb5 || *bitrate > gb100) && !force) {
                log_msg(LOG_LEVEL_WARNING,
                        "Bitrate %lld bps seems to be too %s, use \"-l %s!\" "
                        "to force if this is not a mistake.\n",
                        *bitrate, *bitrate < mb5 ? "low" : "high", optarg);
                return false;
        }
        if (fixed) {
                *bitrate |= RATE_FLAG_FIXED_RATE;
        }
        return true;
}

References LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), RATE_AUTO, RATE_DYNAMIC, RATE_FLAG_FIXED_RATE, RATE_UNLIMITED, SBOLD, TBOLD, TERM_BOLD, TERM_RESET, and unit_evaluate().

Referenced by parse_fmt(), and parse_options_internal().

Here is the call graph for this function:

◆ parse_opts_set_logging()

static bool parse_opts_set_logging	(	int	argc,
		char *	argv[] )

static

Sets things that must be set before anything else (logging and params)

(params because "std{out,err}-buf" param used by set_output_buffering())

Definition at line 357 of file host.cpp.

{
        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;
}

References get_log_output(), log_level, LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE, LOG_TIMESTAMP_AUTO, parse_log_cfg(), parse_params(), Log_output::set_skip_repeats(), and Log_output::set_timestamp_mode().

Referenced by common_preinit().

Here is the call graph for this function:

◆ parse_params()

bool parse_params	(	const char *	optarg,
		bool	preinit )

Parses command-line parameters given as "--param <key>=<val>[...".

Parameters

optarg	command-line arguments given to "--param", must not be NULL
preinit	true - only parse/set known parameters (notably output buffer setting), ignore help false - set also remaining parameters including full check and "help" output

Note: This function will be usually called twice - first with preinit=true and then with false. It is because the bufffering parameter need to be set early (prior to any output). On the other hand not all params can be set immediately – modules are not yet registered, so it is called once more the preinit is done.

Definition at line 976 of file host.cpp.

{
        if (!preinit && strcmp(optarg, "help") == 0) {
                puts("Use of params below is experimental and should be used with a caution and a knowledge of consequences and affected functionality!\n");
                puts("Params can be one or more (separated by comma) of following:");
                print_param_doc();
                return false;
        }
        char *tmp = strdupa(optarg);
        char *item = nullptr;
        char *save_ptr = nullptr;
        while ((item = strtok_r(tmp, ",", &save_ptr)) != nullptr) {
                tmp = nullptr;
                char *key_cstr = item;
                const char *val_cstr = "";
                if (char *delim = strchr(item, '=')) {
                        val_cstr = delim + 1;
                        *delim = '\0';
                }
                if (!validate_param(key_cstr)) {
                        if (preinit) {
                                continue;
                        }
                        LOG(LOG_LEVEL_ERROR) << "Unknown parameter: " << key_cstr << "\n";
                        LOG(LOG_LEVEL_INFO) << "Type '" << uv_argv[0] << " --param help' for list.\n";
                        if (get_commandline_param("allow-unknown-params") ==
                            nullptr) {
                                return false;
                        }
                }
                commandline_params[key_cstr] = val_cstr;
        }
        return true;
}

References commandline_params, get_commandline_param(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, print_param_doc(), strdupa, uv_argv, and validate_param().

Referenced by parse_global_opts(), parse_options_internal(), and parse_opts_set_logging().

Here is the call graph for this function:

◆ print_backtrace()

static void print_backtrace ( )

static

Definition at line 1205 of file host.cpp.

{
#ifdef _WIN32
        print_stacktrace_win();
#else
        // print to a temporary file to avoid interleaving from multiple
        // threads
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 27)
        int fd = memfd_create("ultragrid_backtrace", MFD_CLOEXEC);
#else
        char path[MAX_PATH_SIZE];
#ifdef __APPLE__
        const unsigned long tid = pthread_mach_thread_np(pthread_self());
#else
        const unsigned long tid = syscall(__NR_gettid);
#endif
        snprintf(path, sizeof path, "%s/ug-%lu", get_temp_dir(), tid);
        int fd = open(path, O_CLOEXEC | O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
        unlink(path);
#endif
        if (fd == -1) {
                fd = STDERR_FILENO;
        }
        char backtrace_msg[] = "Backtrace:\n";
        write_all(fd, sizeof backtrace_msg, backtrace_msg);
        array<void *, 256> addresses{};
        const int num_symbols = backtrace(addresses.data(), addresses.size());
        backtrace_symbols_fd(addresses.data(), num_symbols, fd);
        if (fd == STDERR_FILENO) {
                return;
        }
 
        lseek(fd, 0, SEEK_SET);
        char buf[STR_LEN];
        ssize_t rbytes = 0;
        while ((rbytes = read(fd, buf, sizeof buf)) > 0) {
                ssize_t written = 0;
                ssize_t wbytes  = 0;
                while (written < rbytes &&
                       (wbytes = write(STDERR_FILENO, buf + written,
                                       rbytes - written)) > 0) {
                        written += wbytes;
                }
        }
        close(fd);
#endif // defined _WIN32
}

References get_temp_dir(), MAX_PATH_SIZE, STR_LEN, and write_all().

Referenced by crash_signal_handler().

Here is the call graph for this function:

◆ print_capabilities()

void print_capabilities ( const char * cfg )

Definition at line 801 of file host.cpp.

{
        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;
}

References cls, codecs, get_audio_codec_list(), get_libraries_for_class(), LIBRARY_CLASS_AUDIO_COMPRESS, LIBRARY_CLASS_UNDEFINED, LOG_LEVEL_FATAL, log_msg(), mod_classes, name, print_modules(), probe_all(), probe_print, and tokenize().

Referenced by main(), and parse_global_opts().

Here is the call graph for this function:

◆ print_configuration()

void print_configuration ( void )

Definition at line 882 of file host.cpp.

{
        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);
}

Referenced by parse_options_internal().

◆ print_device()

static void print_device	(	std::string	purpose,
		std::string const &	mod,
		const device_info &	device )

static

Definition at line 640 of file host.cpp.

                                                                                             {
        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";
}

References device_info::dev, device_option::display_desc, device_option::display_name, device_info::extra, device_info::mode::id, device_option::is_boolean, device_option::key, device_info::modes, device_info::mode::name, device_info::name, device_option::opt_str, device_info::options, and device_info::repeatable.

Referenced by probe_device().

◆ print_modules()

static void print_modules ( std::map< enum library_class, module_info_map > & class_mod_map )

static

Definition at line 791 of file host.cpp.

{
        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";
                }
        }
}

References mod_classes.

Referenced by print_capabilities().

◆ print_param_doc()

void print_param_doc ( void )

static

Definition at line 1092 of file host.cpp.

{
        for (unsigned int i = 0; i < sizeof params / sizeof params[0]; ++i) {
                if (params[i].doc != NULL) {
                        puts(params[i].doc);
                } else {
                        break;
                }
        }
}

References doc.

Referenced by parse_params().

◆ print_pixel_formats()

void print_pixel_formats ( void )

Definition at line 1103 of file host.cpp.

                               {
        cout << "codec RGB/YCbCr depth description\n";
        for (codec_t c = VIDEO_CODEC_FIRST; c != VIDEO_CODEC_COUNT; c = static_cast<codec_t>(static_cast<int>(c) + 1)) {
                if (is_codec_opaque(c)) {
                        continue;
                }
 
                char tag = codec_is_a_rgb(c) ? 'R' : 'Y';
                col() << " " << left << setw(12) << SBOLD(get_codec_name(c)) << setw(0) << " " << tag << " " << setw(2) << get_bits_per_component(c) << setw(0) << "   " << get_codec_name_long(c) << "\n";
        }
}

References codec_is_a_rgb(), get_bits_per_component(), get_codec_name(), get_codec_name_long(), is_codec_opaque(), SBOLD, VIDEO_CODEC_COUNT, and VIDEO_CODEC_FIRST.

Referenced by parse_options_internal().

Here is the call graph for this function:

◆ print_version()

void print_version ( void )

Definition at line 868 of file host.cpp.

{
        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_PEACH_FUZZ, PACKAGE_STRING <<
                (is_release ? "" : "+"))) <<
                " (" << get_version_details() << ")\n";
}

References get_version_details(), S256_FG, SBOLD, and T_PEACH_FUZZ.

Referenced by main(), and main().

Here is the call graph for this function:

◆ print_video_codecs()

void print_video_codecs ( void )

Definition at line 1115 of file host.cpp.

                              {
        for (codec_t c = VIDEO_CODEC_FIRST; c != VIDEO_CODEC_COUNT; c = static_cast<codec_t>(static_cast<int>(c) + 1)) {
                if (!is_codec_opaque(c)) {
                        continue;
                }
 
                char tag = is_codec_interframe(c) ? 'I' : '.';
                col() << " " << left << setw(12) << SBOLD(get_codec_name(c)) << setw(0) << " " << tag << " " << "   " << get_codec_name_long(c) << "\n";
        }
        cout << "\nLegend:\n" << " I - interframe codec\n";
}

References get_codec_name(), get_codec_name_long(), is_codec_interframe(), is_codec_opaque(), SBOLD, VIDEO_CODEC_COUNT, and VIDEO_CODEC_FIRST.

Referenced by parse_options_internal().

Here is the call graph for this function:

◆ probe_all()

static void probe_all ( std::map< enum library_class, module_info_map > & class_mod_map )

static

Definition at line 780 of file host.cpp.

{
        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);
                }
        }
}

References mod_classes.

Referenced by print_capabilities().

◆ probe_compress()

static void probe_compress	(	std::string const &	name,
		const void *	mod )

staticnoexcept

Definition at line 695 of file host.cpp.

                                                                             {
        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;
 
        }
}

References name.

◆ probe_device()

template<typename T >

static void probe_device	(	std::string_view	cap_str,
		std::string const &	name,
		const void *	mod )

static

Definition at line 683 of file host.cpp.

                                                                                         {
        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);
}

References cap_str, count, deleter, name, and print_device().

Here is the call graph for this function:

◆ register_mainloop()

bool register_mainloop	(	mainloop_t	m,
		void *	u )

Registers mainloop that will be run if display-owned mainloop isn't run. Currently this is only used by Syphon, that either connects to display event loop and if there isn't any, it runs its own.

Definition at line 1132 of file host.cpp.

{
        if (mainloop) {
                return false;
        }
 
        mainloop = m;
        mainloop_udata = u;
 
        return true;
}

References mainloop, and mainloop_udata.

Referenced by vidcap_syphon_init().

◆ register_param()

void register_param	(	const char *	param,
		const char *	doc )

Registers param to param database ("--param"). If param given multiple times, only first value is stored.

Definition at line 930 of file host.cpp.

{
        assert(param != NULL && doc != NULL);
        for (unsigned int i = 0; i < sizeof params / sizeof params[0]; ++i) {
                if (params[i].param == NULL) {
                        params[i].param = param;
                        params[i].doc = doc;
                        return;
                }
                if (strcmp(params[i].param, param) == 0) {
                        if (strcmp(params[i].doc, doc) != 0) {
                                log_msg(LOG_LEVEL_WARNING, "Param \"%s\" as it is already registered but with different documentation.\n", param);
                        }
                        return;
                }
        }
        log_msg(LOG_LEVEL_WARNING, "Cannot register param \"%s\", maxmimum number of parameters reached.\n", param);
}

References doc, LOG_LEVEL_WARNING, log_msg(), and param.

Here is the call graph for this function:

◆ register_should_exit_callback()

void register_should_exit_callback	(	struct module *	mod,
		void(*	callback )(void *),
		void *	udata )

Definition at line 1144 of file host.cpp.

{
        auto              *s = (state_root *) get_root_module(mod)->priv_data;
        unique_lock<mutex> lk(s->lock);
        s->should_exit_callbacks.emplace_back(callback, udata);
}

Referenced by state_uv::state_uv(), audio_cap_jack_init(), audio_init(), main(), video_rxtx::start(), vidcap_dshow_init(), vidcap_file_init(), and vidcap_syphon_init().

◆ running_in_debugger()

bool running_in_debugger ( )

Definition at line 1190 of file host.cpp.

                          {
#ifdef __linux__
        ifstream ppid_f("/proc/" + to_string(getppid()) + "/comm", ifstream::in);
        if (ppid_f.is_open()) {
                string comm;
                ppid_f >> comm;
                if (comm == "gdb") {
                        return true;
                }
        }
#endif
        return false;
}

Referenced by set_output_buffering(), and keyboard_control::impl::start().

◆ set_audio_capture_format()

int set_audio_capture_format ( const char * optarg )

Return values

-1	invalid usage
0	success
1	help was printed

Definition at line 313 of file host.cpp.

{
        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;
}

References audio_capture_bps, audio_capture_channels, audio_capture_sample_rate, desc, IF_NOT_NULL_ELSE, and parse_audio_format().

Referenced by adjust_params(), and parse_options_internal().

Here is the call graph for this function:

◆ set_audio_delay()

void set_audio_delay ( int audio_delay )

Definition at line 914 of file host.cpp.

{
        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;
}

References abs(), audio_offset, LOG_LEVEL_NOTICE, log_msg(), max, and video_offset.

Referenced by parse_options_internal(), process_msg(), and keyboard_control::impl::run().

Here is the call graph for this function:

◆ set_commandline_param()

void set_commandline_param	(	const char *	key,
		const char *	val )

Definition at line 904 of file host.cpp.

{
        commandline_params[key] = val;
}

References commandline_params, key, and val.

Referenced by display_caca_init(), and init_common().

◆ set_output_buffering()

static bool set_output_buffering ( )

static

Definition at line 237 of file host.cpp.

                                   {
        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;
}

References get_commandline_param(), LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), mode, running_in_debugger(), and ug_strerror().

Referenced by common_preinit().

Here is the call graph for this function:

◆ set_pixfmt_conv_policy()

int set_pixfmt_conv_policy ( const char * optarg )

Definition at line 327 of file host.cpp.

                                               {
        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;
}

References color_printf(), desc, LOG_LEVEL_ERROR, log_msg(), pixfmt_conv_pref, TBOLD, and wrap_paragraph().

Referenced by parse_options_internal().

Here is the call graph for this function:

◆ tok_in_argv()

bool tok_in_argv	(	char **	argv,
		const char *	tok )

Definition at line 417 of file host.cpp.

{
        while (*argv != nullptr) {
                if (strstr(*argv, tok) != nullptr) {
                        return true;
                }
                argv++;
        }
        return false;
}

Referenced by common_preinit(), and main().

◆ unregister_should_exit_callback()

void unregister_should_exit_callback	(	struct module *	mod,
		void(*	callback )(void *),
		void *	udata )

Unregisters should_exit callback registered with register_should_exit_callback

The callback must have been registered (and not unregistered), otherwise abort is (currently) called.

Definition at line 1158 of file host.cpp.

{
        auto              *s = (state_root *) get_root_module(mod)->priv_data;
        unique_lock<mutex> lk(s->lock);
        for (auto it = s->should_exit_callbacks.begin();
             it != s->should_exit_callbacks.end(); ++it) {
                if (get<0>(*it) == callback && get<1>(*it) == udata) {
                        s->should_exit_callbacks.erase(it);
                        return;
                }
        }
        abort();
}

Referenced by audio_cap_jack_done(), audio_done(), video_rxtx::join(), main(), vidcap_dshow_done(), vidcap_file_done(), and vidcap_syphon_done().

◆ validate_param()

bool validate_param ( const char * param )

static

Definition at line 949 of file host.cpp.

{
        for (unsigned int i = 0; i < sizeof params / sizeof params[0]; ++i) {
                if (params[i].param == NULL) {
                        return false;
                }
                if (strcmp(params[i].param, param) == 0) {
                        return true;
                }
        }
        return false;
}

References param.

Referenced by parse_params().

Variable Documentation

◆ abi_ver

int abi_ver

Definition at line 750 of file host.cpp.

◆ audio_capture_bps

unsigned int audio_capture_bps = 0

Definition at line 164 of file host.cpp.

Referenced by audio_cap_alsa_init(), audio_cap_ca_init(), audio_cap_portaudio_init(), audio_cap_sdl_mixer_init(), audio_cap_wasapi_init(), audio_testcard_read_wav(), configure_audio(), decklink_cap_configure_audio(), generate_signal(), and set_audio_capture_format().

◆ audio_capture_channels

unsigned int audio_capture_channels = 0

user-specified chan. count, if zero, module should choose best/native or DEFAULT_AUDIO_CAPTURE_CHANNELS

Definition at line 163 of file host.cpp.

Referenced by adjust_params(), audio_append_pcm(), audio_cap_alsa_init(), audio_cap_ca_init(), audio_cap_jack_init(), audio_cap_portaudio_init(), audio_cap_sdl_mixer_init(), audio_cap_wasapi_init(), configure_audio(), configure_audio(), decklink_cap_configure_audio(), generate_signal(), get_ach_count(), parse_options_internal(), set_audio_capture_format(), setup_audio(), vidcap_aja_init_proxy(), vidcap_dvs_init(), and wait_for_channel().

◆ audio_capture_sample_rate

unsigned int audio_capture_sample_rate = 0

Definition at line 165 of file host.cpp.

Referenced by audio_cap_alsa_init(), audio_cap_ca_init(), audio_cap_jack_init(), audio_cap_portaudio_init(), audio_cap_wasapi_init(), configure_audio(), decklink_cap_configure_audio(), generate_signal(), and set_audio_capture_format().

◆ audio_offset

volatile int audio_offset

added audio delay in ms (non-negative), can be used to tune AV sync

Definition at line 178 of file host.cpp.

Referenced by audio_init(), get_audio_delay(), and set_audio_delay().

◆ cap_str

std::string_view cap_str

Definition at line 748 of file host.cpp.

Referenced by probe_device(), and try_open_v4l2_device().

◆ cls

enum library_class cls

Definition at line 749 of file host.cpp.

Referenced by get_libraries_for_class(), list_modules(), load_library(), module_class_name(), print_capabilities(), and register_library().

◆ commandline_params

std::unordered_map<std::string, std::string> commandline_params

Definition at line 184 of file host.cpp.

Referenced by state_sdi_capture::state_sdi_capture(), adjust_params(), change_bps(), decompress_thread(), display_gl_get_property(), display_gl_init_opengl(), AudioDriftFixer::enable(), find_best_decompress(), get_commandline_param(), parse_options_internal(), parse_params(), and set_commandline_param().

◆ cuda_devices

unsigned int cuda_devices[MAX_CUDA_DEVICES] = { 0 }

Definition at line 167 of file host.cpp.

167{ 0 };

Referenced by configure_with(), do_gpu_copy(), gpujpeg_decompress(), gpujpeg_decompress_init(), gpujpeg_to_dxt_decompress_init(), j2k_compress_push(), j2k_decompress_reconfigure(), parse_cuda_device(), reconfigure_thread(), and set_codec_context_params().

◆ cuda_devices_count

unsigned int cuda_devices_count = 1

Definition at line 168 of file host.cpp.

Referenced by configure_with(), flush(), gpujpeg_to_dxt_decompress(), gpujpeg_to_dxt_decompress_done(), gpujpeg_to_dxt_decompress_init(), gpujpeg_to_dxt_decompress_reconfigure(), j2k_decompress_reconfigure(), parse_cuda_device(), set_pool(), and set_postprocess_convert().

◆ cuda_devices_explicit

bool cuda_devices_explicit = false

–cuda-device/-D specified expilcitly

Definition at line 169 of file host.cpp.

Referenced by cuda_conv_enabled(), cuda_conv_enabled(), and parse_cuda_device().

◆ desc

std::string_view desc

Definition at line 747 of file host.cpp.

Referenced by set_audio_capture_format(), and set_pixfmt_conv_policy().

◆ doc

const char* doc

Definition at line 923 of file host.cpp.

Referenced by print_param_doc(), AvailableSettings::queryDevice(), AvailableSettings::queryVideoCompress(), and register_param().

◆ export_dir

char* export_dir = NULL

Definition at line 176 of file host.cpp.

◆ glfw_init_count

int glfw_init_count

0->1 - call glfwInit, 1->0 call glfwTerminate; glfw{Init,Terminate} should be called from main thr, thus no need to synchronize

Definition at line 182 of file host.cpp.

Referenced by state_gl::~state_gl(), display_gl_init_opengl(), and gl_print_monitors().

◆ mainloop

mainloop_t mainloop

mainloop to be run if display mainloop isn't run

Definition at line 186 of file host.cpp.

Referenced by display_run_mainloop(), and register_mainloop().

◆ mainloop_udata

void* mainloop_udata

Definition at line 187 of file host.cpp.

Referenced by display_run_mainloop(), and register_mainloop().

◆ [struct]

const struct { ... } mod_classes[]

Initial value:

= {
        {"Compressions", "compress",
                LIBRARY_CLASS_VIDEO_COMPRESS, VIDEO_COMPRESS_ABI_VERSION,
                [](std::string name, const void *m) { probe_compress(name, m); }},
        {"Capture filters", "capture_filter",
                LIBRARY_CLASS_CAPTURE_FILTER, CAPTURE_FILTER_ABI_VERSION,
                nullptr},
        {"Capturers", "capture",
                LIBRARY_CLASS_VIDEO_CAPTURE, VIDEO_CAPTURE_ABI_VERSION,
                [](std::string name, const void *m){ probe_device<const video_capture_info *>("capture", name, m); }},
        {"Displays", "display",
                LIBRARY_CLASS_VIDEO_DISPLAY, VIDEO_DISPLAY_ABI_VERSION,
                [](std::string name, const void *m){ probe_device<const video_display_info *>("video_disp", name, m); }},
        {"Audio capturers", "audio_cap",
                LIBRARY_CLASS_AUDIO_CAPTURE, AUDIO_CAPTURE_ABI_VERSION,
                [](std::string name, const void *m){ probe_device<const audio_capture_info *>("audio_cap", name, m); }},
        {"Audio filters", "audio_filter",
                LIBRARY_CLASS_AUDIO_FILTER, AUDIO_FILTER_ABI_VERSION,
                nullptr},
        {"Audio compress", "audio_compress",
                LIBRARY_CLASS_AUDIO_COMPRESS, AUDIO_COMPRESS_ABI_VERSION,
                nullptr},
        {"Audio playback", "audio_play",
                LIBRARY_CLASS_AUDIO_PLAYBACK, AUDIO_PLAYBACK_ABI_VERSION,
                [](std::string name, const void *m){ probe_device<const audio_playback_info *>("audio_play", name, m); }},
}

Referenced by print_capabilities(), print_modules(), and probe_all().

◆ param

const char* param

Definition at line 922 of file host.cpp.

Referenced by register_param(), and validate_param().

◆ [struct]

struct { ... } params[100]

Referenced by recompress_output_port::recompress_output_port(), audio_cap_alsa_init(), audio_play_alsa_query_format(), audio_play_alsa_reconfigure(), c_start_server(), hd_rum_decompress_init(), main(), parse(), parse_audio_codec_params(), ScreenCastPortal_impl::run(), ScreenCastPortal_impl::session_created(), vidcap_aggregate_init(), vidcap_gpustitch_init(), vidcap_switcher_init(), vidcap_ug_input_init(), and video_pattern_generator_create().

◆ probe_print

void(* probe_print) (std::string name, const void *)	(	std::string	name,
		const void *	)

Definition at line 751 of file host.cpp.

Referenced by print_capabilities().

◆ RTT

uint32_t RTT = 0

Definition at line 171 of file host.cpp.

Referenced by process_rr().

◆ state_root_static

state_root* volatile state_root_static

static

used by exit_uv() called from signal handler

Definition at line 602 of file host.cpp.

Referenced by exit_uv(), and init_root_module().

◆ unexpected_exit_called

bool unexpected_exit_called = true

static

Definition at line 202 of file host.cpp.

Referenced by common_cleanup(), and echeck_unexpected_exit().

◆ uv_argc

int uv_argc

Definition at line 173 of file host.cpp.

Referenced by ihdtv_video_rxtx::ihdtv_video_rxtx(), common_preinit(), and run_child_process().

◆ uv_argv

char** uv_argv

Definition at line 174 of file host.cpp.

Referenced by ihdtv_video_rxtx::ihdtv_video_rxtx(), audio_play_mixer_help(), common_preinit(), decklink_help(), get_argv_program_name(), main(), open_all(), parse_control_port(), parse_options_internal(), parse_params(), parse_port(), register_screen_cap_rec_library(), run_child_process(), show_help(), show_help(), and vidcap_screen_win_init().

◆ video_offset

volatile int video_offset

added video delay in ms (non-negative), can be used to tune AV sync

Definition at line 179 of file host.cpp.

Referenced by rtp_video_rxtx::rtp_video_rxtx(), get_audio_delay(), and set_audio_delay().

Classes

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ MOD_NAME

Typedef Documentation

◆ module_info_map

Function Documentation

◆ ADD_TO_PARAM() [1/10]

◆ ADD_TO_PARAM() [2/10]

◆ ADD_TO_PARAM() [3/10]

◆ ADD_TO_PARAM() [4/10]

◆ ADD_TO_PARAM() [5/10]

◆ ADD_TO_PARAM() [6/10]

◆ ADD_TO_PARAM() [7/10]

◆ ADD_TO_PARAM() [8/10]

◆ ADD_TO_PARAM() [9/10]

◆ ADD_TO_PARAM() [10/10]

◆ common_cleanup()

◆ common_preinit()

◆ crash_signal_handler()

◆ echeck_unexpected_exit()

◆ exit_uv()

◆ get_audio_delay()

◆ get_commandline_param()

◆ get_exit_status()

◆ get_version_details()

◆ handle_error()

◆ hang_signal_handler()

◆ init_root_module()

◆ load_libgcc()

◆ parse_bitrate()

◆ parse_opts_set_logging()

◆ parse_params()

◆ print_backtrace()

◆ print_capabilities()

◆ print_configuration()

◆ print_device()

◆ print_modules()

◆ print_param_doc()

◆ print_pixel_formats()

◆ print_version()

◆ print_video_codecs()

◆ probe_all()

◆ probe_compress()

◆ probe_device()

◆ register_mainloop()

◆ register_param()

◆ register_should_exit_callback()

◆ running_in_debugger()

◆ set_audio_capture_format()

◆ set_audio_delay()

◆ set_commandline_param()

◆ set_output_buffering()

◆ set_pixfmt_conv_policy()

◆ tok_in_argv()

◆ unregister_should_exit_callback()

◆ validate_param()

Variable Documentation

◆ abi_ver

◆ audio_capture_bps

◆ audio_capture_channels

◆ audio_capture_sample_rate

◆ audio_offset

◆ cap_str

◆ cls

◆ commandline_params

◆ cuda_devices

◆ cuda_devices_count

◆ cuda_devices_explicit

◆ desc

◆ doc

◆ export_dir

◆ glfw_init_count

◆ mainloop

◆ mainloop_udata

◆ [struct]