main.cpp File Reference

#include <array>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <execinfo.h>
#include <getopt.h>
#include <iostream>
#include <list>
#include <memory>
#include <mutex>
#include <pthread.h>
#include <stdexcept>
#include <string>
#include <string.h>
#include <thread>
#include <tuple>
#include <utility>
#include "compat/misc.h"
#include "control_socket.h"
#include "cuda_wrapper.h"
#include "debug.h"
#include "host.h"
#include "keyboard_control.h"
#include "lib_common.h"
#include "messaging.h"
#include "module.h"
#include "playback.h"
#include "rtp/rtp.h"
#include "rtsp/rtsp_utils.h"
#include "tv.h"
#include "ug_runtime_error.hpp"
#include "utils/color_out.h"
#include "utils/misc.h"
#include "utils/nat.h"
#include "utils/net.h"
#include "utils/sdp.h"
#include "utils/string_view_utils.hpp"
#include "utils/thread.h"
#include "utils/wait_obj.h"
#include "utils/udp_holepunch.h"
#include "video.h"
#include "video_capture.h"
#include "video_display.h"
#include "video_compress.h"
#include "export.h"
#include "video_rxtx.hpp"
#include "audio/audio.h"
#include "audio/audio_capture.h"
#include "audio/audio_playback.h"
#include "audio/codec.h"
#include "audio/utils.h"

Go to the source code of this file.

Classes
struct	state_uv
struct	ug_options

Macros
#define	EXIT(expr)
#define	MAX_CAPTURE_COUNT   17
#define	MOD_NAME   "[main] "
#define	OPT_AUDIO_CAPTURE_CHANNELS   (('a' << 8) | 'c')
#define	OPT_AUDIO_DELAY   (('A' << 8) | 'D')
#define	OPT_AUDIO_HOST   (('A' << 8) | 'H')
#define	OPT_AUDIO_PROTOCOL   (('A' << 8) | 'P')
#define	OPT_AUDIO_SCALE   (('a' << 8) | 's')
#define	OPT_CONTROL_PORT   (('C' << 8) | 'P')
#define	OPT_ECHO_CANCELLATION   (('E' << 8) | 'C')
#define	OPT_MCAST_IF   (('M' << 8) | 'I')
#define	OPT_PIX_FMTS   (('P' << 8) | 'F')
#define	OPT_PIXFMT_CONV_POLICY   (('P' << 8) | 'C')
#define	OPT_RTSP_SERVER   (('R' << 8) | 'S')
#define	OPT_VIDEO_CODECS   (('V' << 8) | 'C')
#define	OPT_VIDEO_PROTOCOL   (('V' << 8) | 'P')
#define	OPT_WINDOW_TITLE   (('W' << 8) | 'T')
#define	PORT_BASE   5004

Functions
static int	adjust_params (struct ug_options *opt)
static void *	capture_thread (void *arg)
template<int N>
static void	copy_sv_to_c_buf (char(&dest)[N], std::string_view sv)
int	main (int argc, char *argv[])
static int	parse_audio_capture (struct ug_options *opt, char *optarg)
static bool	parse_control_port (char *optarg, struct ug_options *opt)
static int	parse_cuda_device (char *optarg)
static bool	parse_holepunch_conf (char *conf, struct Holepunch_config *punch_c)
static int	parse_options (int argc, char *argv[], struct ug_options *opt)
static int	parse_options_internal (int argc, char *argv[], struct ug_options *opt)
static bool	parse_port (char *optarg, struct ug_options *opt)
static bool	parse_protocol (int ch, char *optarg, struct ug_options *opt)
static void	print_fps (const char *prefix, steady_clock::time_point *t0, int *frames, double nominal_fps)
static void	print_help_item (const string &name, const vector< string > &help)
static void	signal_handler (int signum)
static void	usage (const char *exec_path, bool full=false)

Variables
static constexpr const char *	DEFAULT_AUDIO_CODEC = "PCM"
static constexpr const char *	DEFAULT_VIDEO_COMPRESSION = "none"

Macro Definition Documentation

EXIT

#define EXIT

(

expr

)

Value:

{ int rc = expr; common_cleanup(init); return rc; }

Definition at line 1251 of file main.cpp.

Referenced by main().

MAX_CAPTURE_COUNT

#define MAX_CAPTURE_COUNT   17

Definition at line 142 of file main.cpp.

MOD_NAME

#define MOD_NAME   "[main] "

Definition at line 121 of file main.cpp.

Referenced by parse_options(), parse_port(), and parse_protocol().

OPT_AUDIO_CAPTURE_CHANNELS

#define OPT_AUDIO_CAPTURE_CHANNELS   (('a' << 8) | 'c')

Definition at line 127 of file main.cpp.

Referenced by parse_options_internal().

OPT_AUDIO_DELAY

#define OPT_AUDIO_DELAY   (('A' << 8) | 'D')

Definition at line 128 of file main.cpp.

Referenced by parse_options_internal().

OPT_AUDIO_HOST

#define OPT_AUDIO_HOST   (('A' << 8) | 'H')

Definition at line 129 of file main.cpp.

Referenced by parse_options_internal().

OPT_AUDIO_PROTOCOL

#define OPT_AUDIO_PROTOCOL   (('A' << 8) | 'P')

Definition at line 130 of file main.cpp.

Referenced by parse_options_internal(), and parse_protocol().

OPT_AUDIO_SCALE

#define OPT_AUDIO_SCALE   (('a' << 8) | 's')

Definition at line 131 of file main.cpp.

Referenced by parse_options_internal().

OPT_CONTROL_PORT

#define OPT_CONTROL_PORT   (('C' << 8) | 'P')

Definition at line 132 of file main.cpp.

Referenced by parse_options_internal().

OPT_ECHO_CANCELLATION

#define OPT_ECHO_CANCELLATION   (('E' << 8) | 'C')

Definition at line 133 of file main.cpp.

Referenced by parse_options_internal().

OPT_MCAST_IF

#define OPT_MCAST_IF   (('M' << 8) | 'I')

Definition at line 134 of file main.cpp.

Referenced by parse_options_internal().

OPT_PIX_FMTS

#define OPT_PIX_FMTS   (('P' << 8) | 'F')

Definition at line 135 of file main.cpp.

Referenced by parse_options_internal().

OPT_PIXFMT_CONV_POLICY

#define OPT_PIXFMT_CONV_POLICY   (('P' << 8) | 'C')

Definition at line 136 of file main.cpp.

Referenced by parse_options_internal().

OPT_RTSP_SERVER

#define OPT_RTSP_SERVER   (('R' << 8) | 'S')

Definition at line 137 of file main.cpp.

Referenced by parse_options_internal().

OPT_VIDEO_CODECS

#define OPT_VIDEO_CODECS   (('V' << 8) | 'C')

Definition at line 138 of file main.cpp.

Referenced by parse_options_internal().

OPT_VIDEO_PROTOCOL

#define OPT_VIDEO_PROTOCOL   (('V' << 8) | 'P')

Definition at line 139 of file main.cpp.

Referenced by parse_options_internal(), and parse_protocol().

OPT_WINDOW_TITLE

#define OPT_WINDOW_TITLE   (('W' << 8) | 'T')

Definition at line 140 of file main.cpp.

Referenced by parse_options_internal().

PORT_BASE

#define PORT_BASE   5004

Definition at line 122 of file main.cpp.

Referenced by usage().

Function Documentation

adjust_params()

static int adjust_params ( struct ug_options * opt )

static

Definition at line 1034 of file main.cpp.

                                                 {
        unsigned int audio_rxtx_mode = 0;
        if (opt->is_server) {
                commandline_params["udp-disable-multi-socket"] = string();
                if (opt->requested_receiver != nullptr) {
                        LOG(LOG_LEVEL_ERROR) << "Receiver must not be given in server mode!\n";
                        return EXIT_FAIL_USAGE;
                }
                opt->requested_receiver = IN6_BLACKHOLE_SERVER_MODE_STR;
                if (strcmp(opt->requested_display, "none") == 0 && strcmp("none", vidcap_params_get_driver(opt->vidcap_params_head)) != 0) {
                        opt->requested_display = "dummy";
                }
                if (strcmp(opt->audio.recv_cfg, "none") == 0 && strcmp(opt->audio.send_cfg, "none") != 0) {
                        opt->audio.recv_cfg = "dummy";
                }
        }
        if (opt->is_client) {
                commandline_params["udp-disable-multi-socket"] = string();
                if (opt->requested_receiver == nullptr) {
                        LOG(LOG_LEVEL_ERROR) << "Server address required in client mode!\n";
                        return EXIT_FAIL_USAGE;
                }
                if (strcmp("none", vidcap_params_get_driver(opt->vidcap_params_head)) == 0 && strcmp(opt->requested_display, "none") != 0) {
                        vidcap_params_set_device(opt->vidcap_params_tail, "testcard:2:1:1:UYVY");
                }
                if (strcmp("none", opt->audio.send_cfg) == 0 && strcmp("none", opt->audio.recv_cfg) != 0) {
                        set_audio_capture_format("sample_rate=1");
                        opt->audio.send_cfg = "testcard:frames=1";
                }
        }
 
        if (opt->requested_receiver == nullptr) {
                opt->requested_receiver = "localhost";
        }
 
        if (opt->audio.host == nullptr) {
                opt->audio.host = opt->requested_receiver;
        }
 
        if (!is_ipv6_supported()) {
                LOG(LOG_LEVEL_WARNING) << "IPv6 support missing, setting IPv4-only mode.\n";
                opt->common.force_ip_version = 4;
        }
 
        // default values for different RXTX protocols
        if (strcasecmp(opt->video_protocol, "rtsp") == 0 || strcasecmp(opt->video_protocol, "sdp") == 0) {
                if (opt->requested_compression == nullptr) {
                        if (strcasecmp(opt->video_protocol, "rtsp") == 0) {
                                opt->requested_compression = "lavc:enc=libx264:safe";
                        } else {
                                opt->requested_compression = "none"; // will be set later by h264_sdp_video_rxtx::send_frame()
                        }
                }
        } else {
                if (opt->requested_compression == nullptr) {
                        opt->requested_compression = DEFAULT_VIDEO_COMPRESSION;
                }
        }
 
        const bool tx_audio_std = strcasecmp(opt->audio.proto, "rtsp") == 0 ||
                                  strcasecmp(opt->audio.proto, "sdp") == 0;
        if (opt->audio.codec_cfg == nullptr) {
                opt->audio.codec_cfg =
                    tx_audio_std ? "mp3" : DEFAULT_AUDIO_CODEC;
        }
 
        if (tx_audio_std && audio_capture_channels == 0) {
                audio_capture_channels = 1; // needed to be known early
        }
 
        if(opt->nat_traverse_config && strncmp(opt->nat_traverse_config, "holepunch", strlen("holepunch")) == 0){
#ifndef HAVE_LIBJUICE
                log_msg(LOG_LEVEL_ERROR, "Ultragrid was compiled without holepunch support\n");
                return EXIT_FAILURE;
#else
                static char punched_host[512];
                Holepunch_config punch_c = {};
 
                if(!parse_holepunch_conf(opt->nat_traverse_config, &punch_c)){
                        return EXIT_FAILURE;
                }
 
                commandline_params["udp-disable-multi-socket"] = string();
 
                if (strcmp("none", vidcap_params_get_driver(opt->vidcap_params_head)) == 0
                                && strcmp("none", opt->requested_display) != 0)
                {
                        vidcap_params_set_device(opt->vidcap_params_tail, "testcard:2:2:1:UYVY");
                        opt->vidcap_params_tail = vidcap_params_allocate_next(opt->vidcap_params_tail);
                }
 
                if (strcmp("none", opt->audio.send_cfg) == 0
                                && strcmp("none", opt->audio.recv_cfg) != 0)
                {
                        set_audio_capture_format("sample_rate=5");
                        opt->audio.send_cfg = "testcard:frames=1";
                }
 
                punch_c.video_rx_port = &opt->video_rx_port;
                punch_c.video_tx_port = &opt->video_tx_port;
                punch_c.audio_rx_port = &opt->audio.recv_port;
                punch_c.audio_tx_port = &opt->audio.send_port;
 
                punch_c.host_addr = punched_host;
                punch_c.host_addr_len = sizeof(punched_host);
 
                auto punch_fcn = reinterpret_cast<bool(*)(Holepunch_config *)>(
                                const_cast<void *>(
                                        load_library("udp_holepunch", LIBRARY_CLASS_UNDEFINED, HOLEPUNCH_ABI_VERSION)));
 
                if(!punch_fcn){
                        log_msg(LOG_LEVEL_ERROR, "Failed to load holepunching module\n");
                        return EXIT_FAILURE;
                }
 
                if(!punch_fcn(&punch_c)){
                        log_msg(LOG_LEVEL_ERROR, "Hole punching failed.\n");
                        return EXIT_FAILURE;
                }
 
                log_msg(LOG_LEVEL_INFO, "[holepunch] remote: %s\n rx: %d\n tx: %d\n",
                                punched_host, opt->video_rx_port, opt->video_tx_port);
                opt->requested_receiver = punched_host;
                opt->audio.host = punched_host;
#endif //HAVE_LIBJUICE
        }
 
 
        if (strcmp("none", opt->audio.recv_cfg) != 0) {
                audio_rxtx_mode |= MODE_RECEIVER;
        }
 
        if (strcmp("none", opt->audio.send_cfg) != 0) {
                audio_rxtx_mode |= MODE_SENDER;
        }
 
        if (strcmp("none", opt->requested_display) != 0) {
                opt->video_rxtx_mode |= MODE_RECEIVER;
        }
        if (strcmp("none", vidcap_params_get_driver(opt->vidcap_params_head)) != 0) {
                opt->video_rxtx_mode |= MODE_SENDER;
        }
 
        // use dyn ports if sending only to ourselves or neither sending nor receiving
        const unsigned mode_both = MODE_RECEIVER | MODE_SENDER;
        if (is_host_loopback(opt->requested_receiver) && ((opt->video_rxtx_mode & mode_both) == mode_both || (opt->video_rxtx_mode & mode_both) == 0)
                        && (opt->video_rx_port == -1 && opt->video_tx_port == -1)) {
                opt->video_rx_port = opt->video_tx_port = 0;
        }
        if (is_host_loopback(opt->requested_receiver) && ((audio_rxtx_mode & mode_both) == mode_both || (audio_rxtx_mode & mode_both) == 0)
                        && (opt->audio.recv_port == -1 && opt->audio.send_port == -1)) {
                opt->audio.recv_port = opt->audio.send_port = 0;
        }
 
        if (opt->video_rx_port == -1) {
                if ((opt->video_rxtx_mode & MODE_RECEIVER) == 0U) {
                        // do not occupy recv port if we are not receiving (note that this disables communication with
                        // our receiver, because RTCP ports are changed as well)
                        opt->video_rx_port = 0;
                } else {
                        opt->video_rx_port = opt->port_base;
                }
        }
 
        if (opt->video_tx_port == -1) {
                if ((opt->video_rxtx_mode & MODE_SENDER) == 0U) {
                        opt->video_tx_port = 0; // does not matter, we are receiver
                } else {
                        opt->video_tx_port = opt->port_base;
                }
        }
 
        if (opt->audio.recv_port == -1) {
                if ((audio_rxtx_mode & MODE_RECEIVER) == 0U) {
                        // do not occupy recv port if we are not receiving (note that this disables communication with
                        // our receiver, because RTCP ports are changed as well)
                        opt->audio.recv_port = 0;
                } else {
                        opt->audio.recv_port = opt->video_rx_port ? opt->video_rx_port + 2 : opt->port_base + 2;
                }
        }
 
        if (opt->audio.send_port == -1) {
                if ((audio_rxtx_mode & MODE_SENDER) == 0U) {
                        opt->audio.send_port = 0;
                } else {
                        opt->audio.send_port = opt->video_tx_port ? opt->video_tx_port + 2 : opt->port_base + 2;
                }
        }
 
        // If we are sure that this UltraGrid is sending to itself we can optimize some parameters
        // (aka "-m 9000 -l unlimited"). If ports weren't equal it is possibile that we are sending
        // to a reflector, thats why we require equal ports (we are a receiver as well).
        if (is_host_loopback(opt->requested_receiver)
                        && (opt->video_rx_port == opt->video_tx_port || opt->video_tx_port == 0)
                        && (opt->audio.recv_port == opt->audio.send_port || opt->audio.send_port == 0)) {
                opt->common.mtu = opt->common.mtu == 0 ? min(RTP_MAX_MTU, 65535)
                                                       : opt->common.mtu;
                opt->bitrate = opt->bitrate == RATE_DEFAULT ? RATE_UNLIMITED : opt->bitrate;
        } else {
                opt->common.mtu = opt->common.mtu == 0 ? 1500 : opt->common.mtu;
                opt->bitrate = opt->bitrate == RATE_DEFAULT ? RATE_DYNAMIC : opt->bitrate;
        }
 
        if((strcmp("none", opt->audio.send_cfg) != 0 || strcmp("none", opt->audio.recv_cfg) != 0) && strcmp(opt->video_protocol, "rtsp") == 0){
            //TODO: to implement a high level rxtx struct to manage different standards (i.e.:H264_STD, VP8_STD,...)
            if (strcmp(opt->audio.proto, "rtsp") != 0) {
                    LOG(LOG_LEVEL_WARNING) << "Using RTSP for video but not for audio is not recommended. Consider adding '--audio-protocol rtsp'.\n";
            }
        }
        if (strcmp(opt->audio.proto, "rtsp") == 0 && strcmp(opt->video_protocol, "rtsp") != 0) {
                LOG(LOG_LEVEL_WARNING) << "Using RTSP for audio but not for video is not recommended and might not work.\n";
        }
 
        return 0;
}

References ug_options::audio, audio_capture_channels, Holepunch_config::audio_rx_port, Holepunch_config::audio_tx_port, ug_options::bitrate, audio_options::codec_cfg, commandline_params, ug_options::common, DEFAULT_AUDIO_CODEC, DEFAULT_VIDEO_COMPRESSION, EXIT_FAIL_USAGE, common_opts::force_ip_version, HOLEPUNCH_ABI_VERSION, audio_options::host, Holepunch_config::host_addr, Holepunch_config::host_addr_len, IN6_BLACKHOLE_SERVER_MODE_STR, ug_options::is_client, is_host_loopback(), is_ipv6_supported(), ug_options::is_server, LIBRARY_CLASS_UNDEFINED, load_library(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), min, MODE_RECEIVER, MODE_SENDER, common_opts::mtu, ug_options::nat_traverse_config, parse_holepunch_conf(), ug_options::port_base, audio_options::proto, RATE_DEFAULT, RATE_DYNAMIC, RATE_UNLIMITED, audio_options::recv_cfg, audio_options::recv_port, ug_options::requested_compression, ug_options::requested_display, ug_options::requested_receiver, RTP_MAX_MTU, audio_options::send_cfg, audio_options::send_port, set_audio_capture_format(), vidcap_params_allocate_next(), vidcap_params_get_driver(), ug_options::vidcap_params_head, vidcap_params_set_device(), ug_options::vidcap_params_tail, ug_options::video_protocol, Holepunch_config::video_rx_port, ug_options::video_rx_port, ug_options::video_rxtx_mode, Holepunch_config::video_tx_port, and ug_options::video_tx_port.

Referenced by main().

Here is the call graph for this function:

capture_thread()

static void * capture_thread ( void * arg )

static

This function captures video and possibly compresses it. It then delegates sending to another thread.

Parameters

[in]

arg

pointer to UltraGrid (root) module

Definition at line 330 of file main.cpp.

{
        set_thread_name(__func__);
 
        struct state_uv *uv = (struct state_uv *) arg;
        assert(uv->magic == state_uv::state_magic);
        struct wait_obj *wait_obj = wait_obj_init();
        steady_clock::time_point t0 = steady_clock::now();
        int frames = 0;
        const char              *print_fps_prefix =
            vidcap_get_fps_print_prefix(uv->capture_device);
 
        while (!uv->should_exit_capture) {
                /* Capture and transmit video... */
                struct audio_frame *audio = nullptr;
                struct video_frame *tx_frame = vidcap_grab(uv->capture_device, &audio);
 
                if (audio != nullptr) {
                        audio_sdi_send(uv->audio, audio);
                        AUDIO_FRAME_DISPOSE(audio);
                }
 
                if (tx_frame == nullptr) {
                        continue;
                }
                print_fps(print_fps_prefix, &t0, &frames, tx_frame->fps);
                // tx_frame = vf_get_copy(tx_frame);
                bool                    wait_for_cur_uncompressed_frame = false;
                shared_ptr<video_frame> frame;
                if (tx_frame->callbacks.dispose == nullptr) {
                        wait_obj_reset(wait_obj);
                        wait_for_cur_uncompressed_frame = true;
                        frame = shared_ptr<video_frame>(
                            tx_frame, [wait_obj](struct video_frame *) {
                                    wait_obj_notify(wait_obj);
                            });
                } else {
                        frame = shared_ptr<video_frame>(
                            tx_frame, tx_frame->callbacks.dispose);
                }
 
                uv->state_video_rxtx->send(
                    std::move(frame)); // std::move really important here (!)
 
                // wait for frame frame to be processed, eg. by compress
                // or sender (uncompressed video). Grab invalidates previous
                // frame (if not defined dispose function).
                if (wait_for_cur_uncompressed_frame) {
                        wait_obj_wait(wait_obj);
                        tx_frame->callbacks.dispose       = nullptr;
                        tx_frame->callbacks.dispose_udata = nullptr;
                }
        }
 
        wait_obj_done(wait_obj);
 
        return NULL;
}

References audio, AUDIO_FRAME_DISPOSE, audio_sdi_send(), video_frame::callbacks, video_frame_callbacks::dispose, video_frame_callbacks::dispose_udata, video_frame::fps, frame, print_fps(), set_thread_name(), state_uv::state_magic, uv, vidcap_get_fps_print_prefix(), vidcap_grab(), wait_obj_done(), wait_obj_init(), wait_obj_notify(), wait_obj_reset(), and wait_obj_wait().

Referenced by main().

Here is the call graph for this function:

copy_sv_to_c_buf()

template<int N>

static void copy_sv_to_c_buf ( char(&) dest[N], std::string_view sv )

static

Definition at line 418 of file main.cpp.

                                                                {
        sv.copy(dest, N - 1);
        dest[N - 1] = '\0';
}

References N.

Referenced by parse_holepunch_conf().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 1253 of file main.cpp.

{
 
        struct init_data *init = nullptr;
#if defined HAVE_SCHED_SETSCHEDULER && defined USE_RT
        struct sched_param sp;
#endif
        ug_options opt{};
 
        pthread_t receiver_thread_id,
                  capture_thread_id;
        bool receiver_thread_started = false,
             capture_thread_started = false;
        unsigned display_flags = 0;
        struct control_state *control = NULL;
        int ret;
 
        time_ns_t start_time = get_time_in_ns();
 
        struct ug_nat_traverse *nat_traverse = nullptr;
 
#ifndef _WIN32
        signal(SIGQUIT, crash_signal_handler);
#endif
        signal(SIGABRT, crash_signal_handler);
        signal(SIGFPE, crash_signal_handler);
        signal(SIGILL, crash_signal_handler);
        signal(SIGSEGV, crash_signal_handler);
 
        if ((init = common_preinit(argc, argv)) == nullptr) {
                log_msg(LOG_LEVEL_FATAL, "common_preinit() failed!\n");
                EXIT(EXIT_FAILURE);
        }
 
        struct state_uv uv{};
        keyboard_control kc{&uv.root_module};
        const bool show_help = tok_in_argv(uv_argv, "help");
 
        print_version();
        printf("\n");
 
        if (int ret = parse_options(argc, argv, &opt)) {
                EXIT(ret < 0 ? -ret : EXIT_SUCCESS);
        }
 
        if (int ret = adjust_params(&opt)) {
                EXIT(ret);
        }
 
        const auto ac_params = parse_audio_codec_params(opt.audio.codec_cfg);
        if (ac_params.codec == AC_NONE) {
                EXIT(EXIT_FAILURE);
        }
        if (!show_help) {
                col() << TBOLD("Display device   : ") << opt.requested_display << "\n";
                col() << TBOLD("Capture device   : ") << vidcap_params_get_driver(opt.vidcap_params_head) << "\n";
                col() << TBOLD("Audio capture    : ") << opt.audio.send_cfg << "\n";
                col() << TBOLD("Audio playback   : ") << opt.audio.recv_cfg << "\n";
                col() << TBOLD("MTU              : ") << opt.common.mtu << " B\n";
                col() << TBOLD("Video compression: ") << opt.requested_compression << "\n";
                col() << TBOLD("Audio codec      : ")
                      << get_name_to_audio_codec(ac_params.codec) << "\n";
                col() << TBOLD("Network protocol : ") << video_rxtx::get_long_name(opt.video_protocol) << "\n";
                col() << TBOLD("Audio FEC        : ") << opt.audio.fec_cfg << "\n";
                col() << TBOLD("Video FEC        : ") << opt.requested_video_fec << "\n";
                col() << "\n";
        }
 
        opt.common.parent = &uv.root_module;
 
        opt.common.exporter = export_init(&uv.root_module, opt.export_opts, opt.should_export);
        if (!opt.common.exporter) {
                log_msg(LOG_LEVEL_ERROR, "Export initialization failed.\n");
                EXIT(EXIT_FAILURE);
        }
 
        if (control_init(opt.control_port, opt.connection_type, &control,
                         &uv.root_module, opt.common.force_ip_version) != 0) {
                LOG(LOG_LEVEL_FATAL) << "Error: Unable to initialize remote control!\n";
                EXIT(EXIT_FAIL_CONTROL_SOCK);
        }
 
        if(!opt.nat_traverse_config
                        || strncmp(opt.nat_traverse_config, "holepunch", strlen("holepunch")) != 0){
                nat_traverse = start_nat_traverse(opt.nat_traverse_config, opt.requested_receiver, opt.video_rx_port, opt.audio.recv_port);
                if(!nat_traverse){
                        exit_uv(1);
                        goto cleanup;
                }
        }
 
        ret = audio_init(&uv.audio, &opt.audio, &opt.common);
        if (ret != 0) {
                exit_uv(ret < 0 ? EXIT_FAIL_AUDIO : 0);
                goto cleanup;
        }
 
        display_flags |= audio_get_display_flags(uv.audio);
 
        // Display initialization should be prior to modules that may use graphic card (eg. GLSL) in order
        // to initalize shared resource (X display) first
        ret =
             initialize_video_display(&uv.root_module, opt.requested_display, opt.display_cfg, display_flags, opt.postprocess, &uv.display_device);
        if (ret < 0) {
                printf("Unable to open display device: %s\n",
                       opt.requested_display);
                exit_uv(EXIT_FAIL_DISPLAY);
                goto cleanup;
        } else if(ret > 0) {
                exit_uv(EXIT_SUCCESS);
                goto cleanup;
        }
        log_msg(LOG_LEVEL_DEBUG, "Display initialized-%s\n", opt.requested_display);
 
        ret = initialize_video_capture(&uv.root_module, opt.vidcap_params_head, &uv.capture_device);
        if (ret < 0) {
                printf("Unable to open capture device: %s\n",
                                vidcap_params_get_driver(opt.vidcap_params_head));
                exit_uv(EXIT_FAIL_CAPTURE);
                goto cleanup;
        } else if(ret > 0) {
                exit_uv(EXIT_SUCCESS);
                goto cleanup;
        }
        log_msg(LOG_LEVEL_DEBUG, "Video capture initialized-%s\n", vidcap_params_get_driver(opt.vidcap_params_head));
 
        signal(SIGINT, signal_handler);
        signal(SIGTERM, signal_handler);
#ifndef _WIN32
        signal(SIGHUP, signal_handler);
        signal(SIGPIPE, signal_handler);
#endif
 
#ifdef USE_RT
#ifdef HAVE_SCHED_SETSCHEDULER
        sp.sched_priority = sched_get_priority_max(SCHED_FIFO);
        if (sched_setscheduler(0, SCHED_FIFO, &sp) != 0) {
                printf("WARNING: Unable to set real-time scheduling\n");
        }
#else
        printf("WARNING: System does not support real-time scheduling\n");
#endif /* HAVE_SCHED_SETSCHEDULER */
#endif /* USE_RT */
 
        try {
                map<string, param_u> params;
 
                // common
                params["compression"].str = opt.requested_compression;
                params["rxtx_mode"].i = opt.video_rxtx_mode;
 
                // iHDTV
                params["capture_device"].ptr = (opt.video_rxtx_mode & MODE_SENDER) != 0U ? uv.capture_device : nullptr;
                params["display_device"].ptr = (opt.video_rxtx_mode & MODE_RECEIVER) != 0U ? uv.display_device : nullptr;
 
                //RTP
                params["common"].cptr = &opt.common;
                params["receiver"].str = opt.requested_receiver;
                params["rx_port"].i = opt.video_rx_port;
                params["tx_port"].i = opt.video_tx_port;
                params["fec"].str = opt.requested_video_fec;
                params["bitrate"].ll = opt.bitrate;
                params["start_time"].ll = start_time;
 
                // UltraGrid RTP
                params["decoder_mode"].l = (long) opt.decoder_mode;
                params["display_device"].ptr = uv.display_device;
 
                // SAGE + RTSP
                params["opts"].str = opt.video_protocol_opts;
 
                if (strcmp(opt.video_protocol, "rtsp") == 0) {
                        rtsp_types_t avType = rtsp_type_none;
                        if ((strcmp("none", opt.audio.send_cfg) != 0)) {
                                avType = (rtsp_types_t) (avType | rtsp_type_audio); // AStream
                        }
                        if (strcmp("none", vidcap_params_get_driver(
                                               opt.vidcap_params_head)) != 0) {
                                avType = (rtsp_types_t) (avType | rtsp_type_video); // VStream
                        }
                        if (avType == rtsp_type_none) {
                                printf("[RTSP SERVER CHECK] no stream type... check capture devices input...\n");
                        }
 
                        params["avType"].l = (long) avType;
                }
 
                sdp_set_properties(opt.requested_receiver, opt.video_rxtx_mode & MODE_SENDER && strcasecmp(opt.video_protocol, "sdp") == 0, opt.audio.send_port != 0 && strcasecmp(opt.audio.proto, "sdp") == 0);
 
                uv.state_video_rxtx = video_rxtx::create(opt.video_protocol, params);
                if (!uv.state_video_rxtx) {
                        if (strcmp(opt.video_protocol, "help") != 0) {
                                throw string("Requested RX/TX cannot be created (missing library?)");
                        } else {
                                throw 0;
                        }
                }
 
                if ((opt.video_rxtx_mode & MODE_RECEIVER) != 0U) {
                        if (!uv.state_video_rxtx->supports_receiving()) {
                                fprintf(stderr, "Selected RX/TX mode doesn't support receiving.\n");
                                exit_uv(EXIT_FAILURE);
                                goto cleanup;
                        }
                        // init module here so as it is capable of receiving messages
                        if (pthread_create
                                        (&receiver_thread_id, NULL, video_rxtx::receiver_thread,
                                         (void *) uv.state_video_rxtx) != 0) {
                                perror("Unable to create display thread!\n");
                                exit_uv(EXIT_FAILURE);
                                goto cleanup;
                        } else {
                                receiver_thread_started = true;
                        }
                }
 
                if ((opt.video_rxtx_mode & MODE_SENDER) != 0U) {
                        if (pthread_create
                                        (&capture_thread_id, NULL, capture_thread,
                                         (void *) &uv) != 0) {
                                perror("Unable to create capture thread!\n");
                                exit_uv(EXIT_FAILURE);
                                goto cleanup;
                        } else {
                                capture_thread_started = true;
                        }
                }
 
                struct additional_audio_data aux = {
                        { uv.display_device, display_put_audio_frame,
                         display_reconfigure_audio, display_ctl_property },
                        uv.state_video_rxtx,
                };
                audio_register_aux_data(uv.audio, aux);
 
                if (opt.requested_capabilities != nullptr) {
                        print_capabilities(opt.requested_capabilities);
                        exit_uv(EXIT_SUCCESS);
                        goto cleanup;
                }
 
                audio_start(uv.audio);
 
                control_start(control);
                kc.start();
 
                display_run_mainloop(uv.display_device);
 
        } catch (ug_no_error const &e) {
                exit_uv(0);
        } catch (ug_runtime_error const &e) {
                LOG(LOG_LEVEL_ERROR) << e.what() << "\n";
                exit_uv(e.get_code());
        } catch (runtime_error const &e) {
                LOG(LOG_LEVEL_ERROR) << e.what() << "\n";
                exit_uv(EXIT_FAILURE);
        } catch (exception const &e) {
                LOG(LOG_LEVEL_ERROR) << e.what() << "\n";
                exit_uv(EXIT_FAILURE);
        } catch (string const &str) {
                LOG(LOG_LEVEL_ERROR) << str << "\n";
                exit_uv(EXIT_FAILURE);
        } catch (int i) {
                exit_uv(i);
        }
 
cleanup:
        if (strcmp("none", opt.requested_display) != 0 &&
                        receiver_thread_started)
                pthread_join(receiver_thread_id, NULL);
 
        if ((opt.video_rxtx_mode & MODE_SENDER) != 0U
                        && capture_thread_started) {
                pthread_join(capture_thread_id, NULL);
        }
 
        /* also wait for audio threads */
        audio_join(uv.audio);
        if (uv.state_video_rxtx)
                uv.state_video_rxtx->join();
 
        export_destroy(opt.common.exporter);
 
        signal(SIGINT, SIG_DFL);
        signal(SIGTERM, SIG_DFL);
#ifndef _WIN32
        signal(SIGHUP, SIG_DFL);
        signal(SIGALRM, hang_signal_handler);
#endif
        alarm(5); // prevent exit hangs
 
        if(uv.audio)
                audio_done(uv.audio);
        delete uv.state_video_rxtx;
 
        if (uv.capture_device)
                vidcap_done(uv.capture_device);
        if (uv.display_device)
                display_done(uv.display_device);
 
        stop_nat_traverse(nat_traverse);
 
        kc.stop();
        control_done(control);
 
        common_cleanup(init);
 
        printf("Exit\n");
 
        return get_exit_status(&uv.root_module);
}

References AC_NONE, adjust_params(), audio_done(), audio_get_display_flags(), audio_init(), audio_join(), audio_register_aux_data(), audio_start(), capture_thread(), cleanup(), common_cleanup(), common_preinit(), control_done(), control_init(), control_start(), crash_signal_handler(), video_rxtx::create(), display_ctl_property(), display_done(), display_put_audio_frame(), display_reconfigure_audio(), display_run_mainloop(), EXIT, EXIT_FAIL_AUDIO, EXIT_FAIL_CAPTURE, EXIT_FAIL_CONTROL_SOCK, EXIT_FAIL_DISPLAY, exit_uv(), export_destroy(), export_init(), get_exit_status(), video_rxtx::get_long_name(), get_name_to_audio_codec(), get_time_in_ns(), hang_signal_handler(), init(), initialize_video_capture(), initialize_video_display(), LOG, LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, log_msg(), MODE_RECEIVER, MODE_SENDER, params, parse_audio_codec_params(), parse_options(), print_capabilities(), print_version(), video_rxtx::receiver_thread(), control_state::root_module, rtsp_type_audio, rtsp_type_none, rtsp_type_video, sdp_set_properties(), show_help(), signal_handler(), start_nat_traverse(), start_time, stop_nat_traverse(), TBOLD, tok_in_argv(), uv, uv_argv, vidcap_done(), and vidcap_params_get_driver().

Here is the call graph for this function:

parse_audio_capture()

static int parse_audio_capture ( struct ug_options * opt, char * optarg )

static

Definition at line 550 of file main.cpp.

                                                                     {
        if (strcmp(optarg, "help") == 0 || strcmp(optarg, "fullhelp") == 0) {
                audio_capture_print_help(strcmp(optarg, "full") == 0);
                return 1;
        }
        if (string(opt->audio.send_cfg) != ug_options().audio.send_cfg &&
            (audio_capture_get_vidcap_flags(opt->audio.send_cfg) == 0 ||
             audio_capture_get_vidcap_flags(optarg) == 0)) {
                log_msg(LOG_LEVEL_ERROR, "Multiple audio devices given! Only "
                                         "allowed for video-attached audio "
                                         "connection (AESEBU/analog/embedded).\n");
                return -EXIT_FAIL_USAGE;
        }
        if (audio_capture_get_vidcap_flags(optarg)) {
                vidcap_params_add_flags(opt->vidcap_params_tail,
                                        audio_capture_get_vidcap_flags(optarg));
        }
        opt->audio.send_cfg = optarg;
        return 0;
}

References audio, ug_options::audio, audio_capture_get_vidcap_flags(), audio_capture_print_help(), EXIT_FAIL_USAGE, LOG_LEVEL_ERROR, log_msg(), audio_options::send_cfg, vidcap_params_add_flags(), and ug_options::vidcap_params_tail.

Referenced by parse_options_internal().

Here is the call graph for this function:

parse_control_port()

static bool parse_control_port ( char * optarg, struct ug_options * opt )

static

Definition at line 654 of file main.cpp.

                                                                     {
        if (strchr(optarg, ':')) {
                char *save_ptr = NULL;
                char *tok;
                opt->control_port = atoi(strtok_r(optarg, ":", &save_ptr));
                opt->connection_type = atoi(strtok_r(NULL, ":", &save_ptr));
 
                if (opt->connection_type < 0 || opt->connection_type > 1){
                        usage(uv_argv[0]);
                        return false;
                }
                if ((tok = strtok_r(NULL, ":", &save_ptr))) {
                        usage(uv_argv[0]);
                        return false;
                }
        } else {
                opt->control_port = atoi(optarg);
                opt->connection_type = 0;
        }
        return true;
}

References ug_options::connection_type, ug_options::control_port, usage(), and uv_argv.

Referenced by parse_options_internal().

Here is the call graph for this function:

parse_cuda_device()

static int parse_cuda_device ( char * optarg )

static

Return values

<0	return code whose absolute value will be returned from main()
0	success
1	device list was printed

Definition at line 392 of file main.cpp.

                                           {
        if(strcmp("help", optarg) == 0) {
#ifdef HAVE_CUDA
                cuda_wrapper_print_devices_info();
#else
                LOG(LOG_LEVEL_ERROR) << "CUDA support is not enabled!\n";
                return -EXIT_FAILURE;
#endif
        }
        char *item, *save_ptr = NULL;
        unsigned int i = 0;
        while((item = strtok_r(optarg, ",", &save_ptr))) {
                if(i >= MAX_CUDA_DEVICES) {
                        LOG(LOG_LEVEL_ERROR) << "Maximal number of CUDA device exceeded.\n";
                        return -EXIT_FAILURE;
                }
                cuda_devices[i] = atoi(item);
                optarg = NULL;
                ++i;
        }
        cuda_devices_count = i;
        cuda_devices_explicit = true;
        return 0;
}

References cuda_devices, cuda_devices_count, cuda_devices_explicit, cuda_wrapper_print_devices_info(), LOG, LOG_LEVEL_ERROR, and MAX_CUDA_DEVICES.

Referenced by parse_options_internal().

Here is the call graph for this function:

parse_holepunch_conf()

static bool parse_holepunch_conf ( char * conf, struct Holepunch_config * punch_c )

static

Definition at line 423 of file main.cpp.

                                                                                               {
        std::string_view sv = conf;
        while(!sv.empty()){
                auto token = tokenize(sv, ':');
                auto key = tokenize(token, '=');
                auto val = tokenize(token, '=');
 
                if(key == "help"){
                        col() << "Usage:\n" <<
                                "\tuv " << TBOLD("-Nholepunch:room=<room>:(server=<host> | coord_srv=<host:port>:stun_srv=<host:port>)[:client_name=<name>][:bind_ip=<addr>] \n") <<
                                "\twhere\n"
                                "\t\t" << TBOLD("server") << " - used if both stun & coord server are on the same host on standard ports (3478, 12558)\n"
                                "\t\t" << TBOLD("room") << " - name of room to join\n"
                                "\t\t" << TBOLD("client_name") << " - name to identify as to the coord server, if not specified hostname is used\n"
                                "\t\t" << TBOLD("bind_ip") << " - local ip to bind to\n"
                                "\n";
                        return false;
                }
 
                if(key == "coord_srv"){
                        copy_sv_to_c_buf(punch_c->coord_srv_addr, val);
 
                        token = tokenize(sv, ':');
                        if(token.empty()){
                                log_msg(LOG_LEVEL_ERROR, "Missing hole punching coord server port.\n");
                                return false;
                        }
 
                        if(!parse_num(token, punch_c->coord_srv_port)){
                                log_msg(LOG_LEVEL_ERROR, "Failed to parse hole punching coord server port.\n");
                                return false;
                        }
                } else if(key == "stun_srv"){
                        copy_sv_to_c_buf(punch_c->stun_srv_addr, val);
 
                        token = tokenize(sv, ':');
                        if(token.empty()){
                                log_msg(LOG_LEVEL_ERROR, "Missing hole punching stun server port.\n");
                                return false;
                        }
 
                        if(!parse_num(token, punch_c->stun_srv_port)){
                                log_msg(LOG_LEVEL_ERROR, "Failed to parse hole punching stun server port.\n");
                                return false;
                        }
                } else if(key == "server"){
                        copy_sv_to_c_buf(punch_c->stun_srv_addr, val);
                        copy_sv_to_c_buf(punch_c->coord_srv_addr, val);
 
                        punch_c->stun_srv_port = 3478;
                        punch_c->coord_srv_port = 12558;
                } else if(key == "room"){
                        copy_sv_to_c_buf(punch_c->room_name, val);
                } else if(key == "client_name"){
                        copy_sv_to_c_buf(punch_c->client_name, val);
                } else if(key == "bind_ip"){
                        copy_sv_to_c_buf(punch_c->bind_addr, val);
                }
        }
 
        if(!strlen(punch_c->stun_srv_addr)
                || !strlen(punch_c->coord_srv_addr)
                || !strlen(punch_c->room_name))
        {
                log_msg(LOG_LEVEL_ERROR, "Not all hole punch params provided.\n");
                return false;
        }
 
        return true;
}

References Holepunch_config::bind_addr, Holepunch_config::client_name, Holepunch_config::coord_srv_addr, Holepunch_config::coord_srv_port, copy_sv_to_c_buf(), key, LOG_LEVEL_ERROR, log_msg(), parse_num(), Holepunch_config::room_name, Holepunch_config::stun_srv_addr, Holepunch_config::stun_srv_port, TBOLD, tokenize(), and val.

Referenced by adjust_params().

Here is the call graph for this function:

parse_options()

static int parse_options ( int argc, char * argv[], struct ug_options * opt )

static

Return values

-error	error value that should be returned from main
0	success
1	success (help written)

Definition at line 1011 of file main.cpp.

{
        try {
                return parse_options_internal(argc, argv, opt);
        } catch (logic_error &e) {
                if (!invalid_arg_is_numeric(e.what())) {
                        throw;
                }
                if (dynamic_cast<invalid_argument *>(&e) != nullptr) {
                        LOG(LOG_LEVEL_ERROR)
                            << MOD_NAME
                            << "Non-numeric value passed to option "
                               "expecting a number!\n";
                } else if (dynamic_cast<out_of_range *>(&e) != nullptr) {
                        LOG(LOG_LEVEL_ERROR)
                            << MOD_NAME << "Passed value is out of bounds!\n";
                } else {
                        throw;
                }
                return -1;
        }
}

References invalid_arg_is_numeric(), LOG, LOG_LEVEL_ERROR, MOD_NAME, and parse_options_internal().

Referenced by main().

Here is the call graph for this function:

parse_options_internal()

static int parse_options_internal ( int argc, char * argv[], struct ug_options * opt )

static

Return values

-error	error value that should be returned from main
0	success
1	success (help written)

Definition at line 682 of file main.cpp.

{
        static struct option getopt_options[] = {                // sort by
                {"audio-capture-format",   required_argument, nullptr, 'a'},
                {"capabilities",           optional_argument, nullptr, 'b'},
                {"compress",               required_argument, nullptr, 'c'},
                {"display",                required_argument, nullptr, 'd'},
                {"encryption",             required_argument, nullptr, 'e'},
                {"fec",                    required_argument, nullptr, 'f'},
                {"help",                   no_argument,       nullptr, 'h'},
                {"audio-filter",           required_argument, nullptr, 'i'},
                {"limit-bitrate",          required_argument, nullptr, 'l'},
                {"capture",                required_argument, nullptr, 't'},
                {"mtu",                    required_argument, nullptr, 'm'},
                {"postprocess",            required_argument, nullptr, 'p'},
                {"receive",                required_argument, nullptr, 'r'},
                {"send",                   required_argument, nullptr, 's'},
                {"version",                no_argument,       nullptr, 'v'},
                {"protocol",               required_argument, nullptr, 'x'},
                {"audio-codec",            required_argument, nullptr, 'A'},
                {"client",                 no_argument,       nullptr, 'C'},
                {"cuda-device",            required_argument, nullptr, 'D'},
                {"record",                 optional_argument, nullptr, 'E'},
                {"capture-filter",         required_argument, nullptr, 'F'},
                {"fullhelp",               no_argument,       nullptr, 'H'},
                {"playback",               required_argument, nullptr, 'I'},
                {"list-modules",           no_argument,       nullptr, 'L'},
                {"mode",                   required_argument, nullptr, 'M'},
                {"nat-traverse",           optional_argument, nullptr, 'N'},
                {"param",                  required_argument, nullptr, 'O'},
                {"port",                   required_argument, nullptr, 'P'},
                {"server",                 no_argument,       nullptr, 'S'},
                {"ttl",                    required_argument, nullptr, 'T'},
                {"audio-channel-map",      required_argument, nullptr, 'U'},
                {"verbose",                optional_argument, nullptr, 'V'},
                {"audio-capture-channels", required_argument, 0, OPT_AUDIO_CAPTURE_CHANNELS},
                {"audio-delay",            required_argument, 0, OPT_AUDIO_DELAY},
                {"audio-host",             required_argument, 0, OPT_AUDIO_HOST},
                {"audio-protocol",         required_argument, 0, OPT_AUDIO_PROTOCOL},
                {"control-port",           required_argument, 0, OPT_CONTROL_PORT},
                {"audio-scale",            required_argument, 0, OPT_AUDIO_SCALE},
                {"echo-cancellation",      no_argument,       0, OPT_ECHO_CANCELLATION},
                {"mcast-if",               required_argument, 0, OPT_MCAST_IF},
                {"conv-policy",            required_argument, 0, OPT_PIXFMT_CONV_POLICY},
                {"pix-fmts",               no_argument,       0, OPT_PIX_FMTS},
                {"rtsp-server",            optional_argument, 0, OPT_RTSP_SERVER},
                {"video-codecs",           no_argument,       0, OPT_VIDEO_CODECS},
                {"video-protocol",         required_argument, 0, OPT_VIDEO_PROTOCOL},
                {"window-title",           required_argument, 0, OPT_WINDOW_TITLE},
                {0, 0, 0, 0}
        };
        const char *optstring =
            "46A:CD:E::F:HI:LM:N::O:P:ST:U:Va:b::c:e:f:d:hi:l:m:p:r:s:t:vx:";
 
        int ch = 0;
        while ((ch =
                getopt_long(argc, argv, optstring, getopt_options,
                            NULL)) != -1) {
                switch (ch) {
                case 'd':
                        if (strcmp(optarg, "help") == 0 || strcmp(optarg, "fullhelp") == 0) {
                                list_video_display_devices(strcmp(optarg, "fullhelp") == 0);
                                return 1;
                        }
                        if (opt->requested_display && strcmp(opt->requested_display, "none") != 0) {
                                log_msg(LOG_LEVEL_ERROR, "Multiple displays given!\n");
                                return -EXIT_FAIL_USAGE;
                        }
                        opt->requested_display = optarg;
                        if(strchr(optarg, ':')) {
                                char *delim = strchr(optarg, ':');
                                *delim = '\0';
                                opt->display_cfg = delim + 1;
                        }
                        break;
                case 't':
                        if (strcmp(optarg, "help") == 0 || strcmp(optarg, "fullhelp") == 0) {
                                list_video_capture_devices(strcmp(optarg, "fullhelp") == 0);
                                return 1;
                        }
                        vidcap_params_set_device(opt->vidcap_params_tail, optarg);
                        opt->vidcap_params_tail = vidcap_params_allocate_next(opt->vidcap_params_tail);
                        break;
                case 'm':
                        opt->common.mtu = atoi(optarg);
                        if (opt->common.mtu < 576 &&
                            optarg[strlen(optarg) - 1] != '!') {
                                log_msg(LOG_LEVEL_WARNING,
                                        "MTU %1$u seems to be too low, use "
                                        "\"%1$u!\" to force.\n",
                                        opt->common.mtu);
                                return -EXIT_FAIL_USAGE;
                        }
                        break;
                case 'M':
                        opt->decoder_mode = get_video_mode_from_str(optarg);
                        if (opt->decoder_mode == VIDEO_UNKNOWN) {
                                return strcasecmp(optarg, "help") == 0 ? 1 : -EXIT_FAIL_USAGE;
                        }
                        break;
                case 'p':
                        opt->postprocess = optarg;
                        break;
                case 'v':
                        print_configuration();
                        return 1;
                case 'c':
                        opt->requested_compression = optarg;
                        break;
                case OPT_RTSP_SERVER:
                        log_msg(LOG_LEVEL_WARNING, "Option \"--rtsp-server[=args]\" "
                                        "is deprecated and will be removed in future.\n"
                                        "Please use \"-x rtsp[:args]\"instead.\n");
                        opt->video_protocol = "rtsp";
                        opt->video_protocol_opts = optarg ? optarg : "";
                        break;
                case OPT_AUDIO_PROTOCOL:
                case OPT_VIDEO_PROTOCOL:
                case 'x':
                        if (!parse_protocol(ch, optarg, opt)) {
                                return 1;
                        }
                        break;
                case 'r':
                        if (strcmp(optarg, "help") == 0 || strcmp(optarg, "fullhelp") == 0) {
                                audio_playback_help(strcmp(optarg, "full") == 0);
                                return 1;
                        }
                        if (string(opt->audio.recv_cfg) != ug_options().audio.recv_cfg) {
                                log_msg(LOG_LEVEL_ERROR, "Multiple audio playback devices given!\n");
                                return -EXIT_FAIL_USAGE;
                        }
                        opt->audio.recv_cfg = optarg;
                        break;
                case 's':
                        if (int ret = parse_audio_capture(opt, optarg)) {
                                return ret;
                        }
                        break;
                case 'f':
                        if(strlen(optarg) > 2 && optarg[1] == ':' &&
                                        (toupper(optarg[0]) == 'A' || toupper(optarg[0]) == 'V')) {
                                if(toupper(optarg[0]) == 'A') {
                                        opt->audio.fec_cfg = optarg + 2;
                                } else {
                                        opt->requested_video_fec = optarg + 2;
                                }
                        } else {
                                // there should be setting for both audio and video
                                // but we conservativelly expect that the user wants
                                // only vieo and let audio default until explicitly
                                // stated otehrwise
                                opt->requested_video_fec = optarg;
                        }
                        break;
                case 'h':
                        usage(uv_argv[0], false);
                        return 1;
                case 'P':
                        if (!parse_port(optarg, opt)) {
                                return -EXIT_FAIL_USAGE;
                        }
                        break;
                case 'l':
                        if (!parse_bitrate(optarg, &opt->bitrate)) {
                                return -EXIT_FAILURE;
                        }
                        if (opt->bitrate == RATE_DEFAULT) {
                                return 1; // help written
                        }
                        break;
                case '4':
                case '6':
                        opt->common.force_ip_version = ch - '0';
                        break;
                case 'U':
                        opt->audio.channel_map = optarg;
                        break;
                case OPT_AUDIO_SCALE:
                        opt->audio.scale = optarg;
                        break;
                case OPT_AUDIO_CAPTURE_CHANNELS:
                        log_msg(LOG_LEVEL_WARNING, "Parameter --audio-capture-channels is deprecated. "
                                        "Use \"-a channels=<count>\" instead.\n");
                        audio_capture_channels = atoi(optarg);
                        if (audio_capture_channels < 1) {
                                log_msg(LOG_LEVEL_ERROR, "Invalid number of channels %d!\n", audio_capture_channels);
                                return -EXIT_FAIL_USAGE;
                        }
                        break;
                case 'a':
                        if (int ret = set_audio_capture_format(optarg)) {
                                return ret < 0 ? -EXIT_FAIL_USAGE : 1;
                        }
                        break;
                case 'i':
                        if(!opt->audio_filter_cfg.empty()){
                                opt->audio_filter_cfg += "#";
                        }
                        opt->audio_filter_cfg += optarg;
                        break;
                case OPT_ECHO_CANCELLATION:
                        opt->audio.echo_cancellation = true;
                        break;
                case 'H':
                        usage(uv_argv[0], true);
                        return 1;
                case 'D':
                        if (int ret = parse_cuda_device(optarg)) {
                                return ret;
                        }
                        break;
                case OPT_MCAST_IF:
                        snprintf_ch(opt->common.mcast_if, "%s", optarg);
                        break;
                case OPT_AUDIO_HOST:
                        opt->audio.host = optarg;
                        break;
                case 'E':
                        opt->should_export = true;
                        opt->export_opts = optarg;
                        break;
                case 'I':
                        opt->audio.send_cfg = "embedded";
                        {
                                char dev_string[1024];
                                int ret;
                                if ((ret = playback_set_device(dev_string, sizeof dev_string, optarg)) <= 0) {
                                        return ret == 0 ? 1 : -EXIT_FAIL_USAGE;
                                }
                                vidcap_params_set_device(opt->vidcap_params_tail, dev_string);
                                opt->vidcap_params_tail = vidcap_params_allocate_next(opt->vidcap_params_tail);
                        }
                        break;
                case 'A':
                        if(strcmp(optarg, "help") == 0) {
                                list_audio_codecs();
                                return 1;
                        }
                        opt->audio.codec_cfg = optarg;
                        break;
                case 'F': {
                                  std::string curr;
                                  if(auto val = vidcap_params_get_capture_filter(opt->vidcap_params_tail); val != nullptr){
                                          curr = val;
                                          curr += ",";
                                  }
                                  curr += optarg;
                                  vidcap_params_set_capture_filter(opt->vidcap_params_tail, curr.c_str());
                                  break;
                          }
                case 'e':
                        snprintf_ch(opt->common.encryption, "%s", optarg);
                        break;
                case OPT_CONTROL_PORT:
                        if (!parse_control_port(optarg, opt)) {
                                return -EXIT_FAIL_USAGE;
                        }
                        break;
                case 'V':
                        break; // already handled in common_preinit()
                case OPT_WINDOW_TITLE:
                        log_msg(LOG_LEVEL_WARNING, "Deprecated option used, please use "
                                        "--param window-title=<title>\n");
                        commandline_params["window-title"] = optarg;
                        break;
                case 'b':
                        opt->requested_capabilities = optarg ? optarg : "";
                        break;
                case OPT_AUDIO_DELAY:
                        set_audio_delay(stoi(optarg));
                        break;
                case 'L':
                        return list_all_modules() ? 1 : -EXIT_FAILURE;
                case 'O':
                        if (!parse_params(optarg, false)) {
                                return 1;
                        }
                        break;
                case OPT_PIX_FMTS:
                        print_pixel_formats();
                        return 1;
                case OPT_PIXFMT_CONV_POLICY:
                        if (int ret = set_pixfmt_conv_policy(optarg)) {
                                return ret < 0 ? -EXIT_FAIL_USAGE : 1;
                        }
                        break;
                case OPT_VIDEO_CODECS:
                        print_video_codecs();
                        return 1;
                case 'N':
                        opt->nat_traverse_config = optarg == nullptr ? const_cast<char *>("") : optarg;
                        break;
                case 'C':
                        opt->is_client = true;
                        break;
                case 'S':
                        opt->is_server = true;
                        break;
                case 'T':
                        opt->common.ttl = stoi(optarg);
                        break;
                case '?':
                default:
                        usage(uv_argv[0]);
                        return -EXIT_FAIL_USAGE;
                }
        }
 
        opt->audio.filter_cfg = opt->audio_filter_cfg.data();
 
        argc -= optind;
        argv += optind;
 
        if (argc > 1) {
                log_msg(LOG_LEVEL_ERROR, "Multiple receivers given!\n");
                usage(uv_argv[0]);
                return -EXIT_FAIL_USAGE;
        }
 
        if (argc > 0) {
                opt->requested_receiver = argv[0];
        }
 
        return 0;
}

References audio, ug_options::audio, audio_capture_channels, ug_options::audio_filter_cfg, audio_playback_help(), ug_options::bitrate, audio_options::channel_map, audio_options::codec_cfg, commandline_params, ug_options::common, ug_options::decoder_mode, ug_options::display_cfg, audio_options::echo_cancellation, common_opts::encryption, EXIT_FAIL_USAGE, ug_options::export_opts, audio_options::fec_cfg, audio_options::filter_cfg, common_opts::force_ip_version, get_video_mode_from_str(), audio_options::host, ug_options::is_client, ug_options::is_server, list_all_modules(), list_audio_codecs(), list_video_capture_devices(), list_video_display_devices(), LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), common_opts::mcast_if, common_opts::mtu, ug_options::nat_traverse_config, OPT_AUDIO_CAPTURE_CHANNELS, OPT_AUDIO_DELAY, OPT_AUDIO_HOST, OPT_AUDIO_PROTOCOL, OPT_AUDIO_SCALE, OPT_CONTROL_PORT, OPT_ECHO_CANCELLATION, OPT_MCAST_IF, OPT_PIX_FMTS, OPT_PIXFMT_CONV_POLICY, OPT_RTSP_SERVER, OPT_VIDEO_CODECS, OPT_VIDEO_PROTOCOL, OPT_WINDOW_TITLE, parse_audio_capture(), parse_bitrate(), parse_control_port(), parse_cuda_device(), parse_params(), parse_port(), parse_protocol(), playback_set_device(), ug_options::postprocess, print_configuration(), print_pixel_formats(), print_video_codecs(), RATE_DEFAULT, audio_options::recv_cfg, ug_options::requested_capabilities, ug_options::requested_compression, ug_options::requested_display, ug_options::requested_receiver, ug_options::requested_video_fec, audio_options::scale, audio_options::send_cfg, set_audio_capture_format(), set_audio_delay(), set_pixfmt_conv_policy(), ug_options::should_export, snprintf_ch, common_opts::ttl, usage(), uv_argv, val, vidcap_params_allocate_next(), vidcap_params_get_capture_filter(), vidcap_params_set_capture_filter(), vidcap_params_set_device(), ug_options::vidcap_params_tail, ug_options::video_protocol, ug_options::video_protocol_opts, and VIDEO_UNKNOWN.

Referenced by parse_options().

Here is the call graph for this function:

parse_port()

static bool parse_port ( char * optarg, struct ug_options * opt )

static

Definition at line 571 of file main.cpp.

                                                             {
        char *save_ptr = nullptr;
        char *first_val = strtok_r(optarg, ":", &save_ptr);
        if (first_val == nullptr || strcmp(first_val, "help") == 0) {
                color_printf("see\n\n    " TBOLD("%s --fullhelp") "\n\nfor port specification usage\n", uv_argv[0]);
                return false;
        }
        if (char *tx_port_str = strtok_r(nullptr, ":", &save_ptr)) {
                opt->video_rx_port = stoi(first_val, nullptr, 0);
                opt->video_tx_port = stoi(tx_port_str, nullptr, 0);
                char *tok = nullptr;
                if ((tok = strtok_r(nullptr, ":", &save_ptr)) != nullptr) {
                        opt->audio.recv_port = stoi(tok, nullptr, 0);
                        if ((tok = strtok_r(nullptr, ":", &save_ptr)) != nullptr) {
                                opt->audio.send_port = stoi(tok, nullptr, 0);
                        } else {
                                usage(uv_argv[0]);
                                return false;
                        }
                }
        } else {
                opt->port_base = stoi(first_val, nullptr, 0);
        }
        if (opt->audio.recv_port < -1 || opt->audio.send_port < -1 || opt->video_rx_port < -1 || opt->video_tx_port < -1 || opt->port_base < -1 ||
                        opt->audio.recv_port > UINT16_MAX || opt->audio.send_port > UINT16_MAX || opt->video_rx_port > UINT16_MAX || opt->video_tx_port > UINT16_MAX || opt->port_base > UINT16_MAX) {
                LOG(LOG_LEVEL_ERROR) << MOD_NAME << "Invalid port value, allowed range 1-65535\n";
                return false;
        }
        return true;
}

References ug_options::audio, color_printf(), LOG, LOG_LEVEL_ERROR, MOD_NAME, ug_options::port_base, audio_options::recv_port, audio_options::send_port, TBOLD, usage(), uv_argv, ug_options::video_rx_port, and ug_options::video_tx_port.

Referenced by parse_options_internal().

Here is the call graph for this function:

parse_protocol()

static bool parse_protocol ( int ch, char * optarg, struct ug_options * opt )

static

Definition at line 602 of file main.cpp.

                                                                         {
        bool set_audio = true;
        bool set_video = true;
        if (strlen(optarg) > 2 && optarg[1] == ':') {
                set_audio = toupper(optarg[0]) == 'A';
                set_video = toupper(optarg[0]) == 'V';
                if (!set_audio && !set_video) {
                        LOG(LOG_LEVEL_ERROR) << MOD_NAME "Wrong protocol setting: " << optarg << "\n";
                        return false;
                }
                optarg += 2;
        }
        char *proto = optarg;
        const char *cfg = "";
        if (strchr(optarg, ':')) {
                char *delim = strchr(optarg, ':');
                *delim = '\0';
                cfg = delim + 1;
        }
        switch (ch) {
                case OPT_AUDIO_PROTOCOL:
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME "--audio-protocol deprecated, use '-x A:proto'\n";
                        set_video = false;
                        break;
                case OPT_VIDEO_PROTOCOL:
                        LOG(LOG_LEVEL_WARNING) << MOD_NAME "--video-protocol deprecated, use '-x V:proto'\n";
                        set_audio = false;
                        break;
        }
        if (strcmp(optarg, "help") == 0 ||
                strcmp(optarg, "fullhelp") == 0) {
                col() << "Specify a transmission protocol.\nUsage:\n";
                col() << SBOLD("\t-x proto") "   - use common protocol for audio and video\n";
                col() << SBOLD("\t-x A:proto") " - use specified audio protocol\n";
                col() << SBOLD("\t-x V:proto") " - use specified audio protocol\n";
                col() << "\nAudio protocol can be one of: " << TBOLD(AUDIO_PROTOCOLS) " (not all must be available)\n";
                video_rxtx::list(strcmp(optarg, "fullhelp") == 0);
                return false;
        }
        if (set_audio) {
                opt->audio.proto = proto;
                opt->audio.proto_cfg = cfg;
 
        }
        if (set_video) {
                opt->video_protocol = proto;
                opt->video_protocol_opts = cfg;
 
        }
        return true;
}

References ug_options::audio, AUDIO_PROTOCOLS, video_rxtx::list(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, MOD_NAME, OPT_AUDIO_PROTOCOL, OPT_VIDEO_PROTOCOL, audio_options::proto, audio_options::proto_cfg, SBOLD, TBOLD, ug_options::video_protocol, and ug_options::video_protocol_opts.

Referenced by parse_options_internal().

Here is the call graph for this function:

print_fps()

static void print_fps ( const char * prefix, steady_clock::time_point * t0, int * frames, double nominal_fps )

static

Definition at line 293 of file main.cpp.

{
        enum {
                MIN_FPS_PERC_WARN  = 98,
                MIN_FPS_PERC_WARN2 = 90,
        };
        if (prefix == nullptr) {
                return;
        }
        *frames += 1;
        steady_clock::time_point t1 = steady_clock::now();
        double seconds = duration_cast<duration<double>>(t1 - *t0).count();
        if (seconds < 5.0) {
                return;
        }
        const double fps      = *frames / seconds;
        const int    fps_perc = (int) floor(fps / nominal_fps * 100.);
        const char  *fps_col  = fps_perc >= MIN_FPS_PERC_WARN ? ""
                                : fps_perc >= MIN_FPS_PERC_WARN2
                                    ? T256_FG_SYM(T_ARCTIC_LIME)
                                    : T256_FG_SYM(T_DARKER_ORANGE);
        log_msg(LOG_LEVEL_INFO,
                TERM_BOLD TERM_BG_BLACK TERM_FG_BRIGHT_GREEN
                "%s" TERM_RESET " %d frames in %g seconds = " TERM_BOLD
                "%s%g FPS" TERM_RESET "\n",
                prefix, *frames, seconds, fps_col, fps);
        *t0     = t1;
        *frames = 0;
}

References count, LOG_LEVEL_INFO, log_msg(), T256_FG_SYM, T_ARCTIC_LIME, T_DARKER_ORANGE, TERM_BG_BLACK, TERM_BOLD, TERM_FG_BRIGHT_GREEN, and TERM_RESET.

Referenced by capture_thread().

Here is the call graph for this function:

print_help_item()

static void print_help_item ( const string & name, const vector< string > & help )

static

Definition at line 197 of file main.cpp.

                                                                            {
        int help_lines = 0;
 
        col() << "\t" << TBOLD(<< name <<);
 
        for (auto const &line : help) {
                int spaces = help_lines == 0 ? 31 - (int) name.length() : 39;
                for (int i = 0; i < max(spaces, 0) + 1; ++i) {
                        cout << " ";
                }
                cout << line << "\n";
                help_lines += 1;
        }
 
        if (help_lines == 0) {
                cout << "\n";
        }
        cout << "\n";
}

References max, name, and TBOLD.

Referenced by usage().

signal_handler()

static void signal_handler ( int signum )

static

Definition at line 174 of file main.cpp.

{
#ifdef SIGPIPE
        if (signum == SIGPIPE) {
                signal(SIGPIPE, SIG_IGN);
        }
#endif // defined SIGPIPE
        if (log_level >= LOG_LEVEL_VERBOSE) {
                char buf[128];
                char *ptr = buf;
                char *ptr_end = buf + sizeof buf;
                strappend(&ptr, ptr_end, "Caught signal ");
                if (signum / 10 != 0) {
                        *ptr++ = (char) ('0' + signum / 10);
                }
                *ptr++ = (char) ('0' + signum % 10);
                append_sig_desc(&ptr, ptr_end - 1, signum);
                *ptr++ = '\n';
                write_all(STDERR_FILENO, ptr - buf, buf);
        }
        exit_uv(0);
}

References append_sig_desc(), exit_uv(), log_level, LOG_LEVEL_VERBOSE, strappend(), and write_all().

Referenced by main().

Here is the call graph for this function:

usage()

static void usage ( const char * exec_path, bool full = false )

static

Definition at line 217 of file main.cpp.

{
        col() << "Usage: " << SBOLD(SRED((exec_path ? exec_path : "<executable_path>")) << " [options] address\n\n");
        printf("Options:\n");
        print_help_item("-h | -H, --fullhelp", {"show usage (basic/full)"});
        print_help_item("-d <display_device>", {"select display device, use '-d help'",
                        "to get list of supported devices"});
        print_help_item("-t <capture_device>", {"select capture device, use '-t help'",
                        "to get list of supported devices"});
        print_help_item("-c <cfg>", {"video compression (see '-c help')"});
        print_help_item("-r <playback_device>", {"audio playback device (see '-r help')"});
        print_help_item("-s <capture_device>", {"audio capture device (see '-s help')"});
        if (full) {
                print_help_item(
                    "-V, --verbose[=<level>]",
                    { "print verbose messages (optionally specify level [0-" +
                      to_string(LOG_LEVEL_MAX) + "])" });
                print_help_item("--list-modules", {"prints list of modules"});
                print_help_item("--control-port <port>[:0|1]", {"set control port (default port: " + to_string(DEFAULT_CONTROL_PORT) + ")",
                                "connection types: 0- Server (default), 1- Client"});
                print_help_item("-x, --protocol <proto>", {"transmission protocol to use (see `-x help`)"});
#ifdef HAVE_IPv6
                print_help_item("-4/-6", {"force IPv4/IPv6 resolving"});
#endif //  HAVE_IPv6
                print_help_item("--mcast-if <iface>", {"bind to specified interface for multicast"});
                print_help_item("-m <mtu>", {"set path MTU assumption towards receiver"});
                print_help_item("-M <video_mode>", {"received video mode (eg tiled-4K, 3D,",
                                "dual-link)"});
                print_help_item("-N, --nat-traverse"s, {"try to deploy NAT traversal techniques"s});
                print_help_item("-p <postprocess> | help", {"postprocess module"});
                print_help_item("-T, --ttl <num>", {"Use specified TTL for multicast/unicast (0..255, -1 for default)"});
        }
        print_help_item("-f [A:|V:]<settings>", {"FEC settings (audio or video) - use",
                        "\"none\", \"mult:<nr>\",", "\"ldgm:<max_expected_loss>%\" or", "\"ldgm:<k>:<m>:<c>\"",
                        "\"rs:<k>:<n>\""});
        if (full) {
                print_help_item("-P <port> | <video_rx>:<video_tx>[:<audio_rx>:<audio_tx>]", { "",
                                "<port> is base port number, also 3",
                                "subsequent ports can be used for RTCP",
                                "and audio streams. Default: " + to_string(PORT_BASE) + ".",
                                "You can also specify all two or four", "ports directly."});
                print_help_item("-l <limit_bitrate> | unlimited | auto", {"limit sending bitrate",
                                "to <limit_bitrate> (with optional k/M/G suffix)"});
                print_help_item("--audio-host <address>", {"audio destination address",
                                "If not specified, will use same as for video"});
        }
        print_help_item("-a, --audio-capture-format <fmt> | help", {"format of captured audio"});
        if (full) {
                print_help_item("--audio-channel-map <mapping> | help", {});
                print_help_item("--audio-filter <filter>[:<config>][#<filter>[:<config>]]...", {});
        }
        print_help_item("-A, --audio-codec "
                        "<codec>[:sample_rate=<sr>][:bitrate=<br>] | help",
                        { "audio codec" });
        if (full) {
                print_help_item("--audio-delay <delay_ms>", {"amount of time audio should be delayed to video",
                                "(may be also negative to delay video)"});
                print_help_item("--audio-scale <factor> | <method> | help",
                                {"scales received audio"});
                print_help_item("--echo-cancellation", {"apply acoustic echo cancellation to audio (experimental)"});
                print_help_item("-D, --cuda-device <index> | help", {"use specified GPU"});
                print_help_item("-e, --encryption <passphrase>", {"key material for encryption"});
                print_help_item("-I, --playback <directory> | help", {"replays recorded audio and video"});
                print_help_item("-E, --record[=<directory>]", {"record captured audio and video"});
                print_help_item("-F, --capture-filter <filter> | help",
                                {"capture filter, must precede -t if more device used"});
                print_help_item("--param <params> | help", {"additional advanced parameters, use help for list"});
                print_help_item("--pix-fmts", {"list of pixel formats"});
                print_help_item("--conv-policy [cds]{3} | help", {"pixel format conversion policy"});
                print_help_item("--video-codecs", {"list of video codecs"});
        }
        print_help_item("address", {"destination address"});
        printf("\n");
}

References DEFAULT_CONTROL_PORT, LOG_LEVEL_MAX, PORT_BASE, print_help_item(), SBOLD, and SRED.

Here is the call graph for this function:

Variable Documentation

DEFAULT_AUDIO_CODEC

const char* DEFAULT_AUDIO_CODEC = "PCM"

staticconstexpr

Definition at line 125 of file main.cpp.

Referenced by adjust_params().

DEFAULT_VIDEO_COMPRESSION

const char* DEFAULT_VIDEO_COMPRESSION = "none"

staticconstexpr

Definition at line 124 of file main.cpp.

Referenced by adjust_params().