conference.cpp File Reference

#include <condition_variable>
#include <chrono>
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include <string_view>
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "module.h"
#include "utils/color_out.h"
#include "utils/misc.h"
#include "utils/string_view_utils.hpp"
#include "video.h"
#include "video_codec.h"
#include "video_display.h"
#include <opencv2/core/mat.hpp>
#include <opencv2/imgproc.hpp>
#include "utils/profile_timer.hpp"

Include dependency graph for conference.cpp:

Go to the source code of this file.

Classes
struct	state_conference
struct	state_conference_common

Macros
#define	FAIL_IF(x, msg)
#define	MOD_NAME   "[conference] "

Functions
static void	check_reconf (struct state_conference_common *s, struct video_desc desc)
static void	display_conference_done (void *state)
static struct display *	display_conference_fork (void *state)
static bool	display_conference_get_property (void *state, int property, void *val, size_t *len)
static struct video_frame *	display_conference_getf (void *state)
static void *	display_conference_init (struct module *parent, const char *fmt, unsigned int flags)
static void	display_conference_probe (struct device_info **available_cards, int *count, void(**deleter)(void *))
static void	display_conference_put_audio_frame (void *state, const struct audio_frame *frame)
static bool	display_conference_putf (void *state, struct video_frame *frame, long long flags)
static bool	display_conference_reconfigure (void *state, struct video_desc desc)
static bool	display_conference_reconfigure_audio (void *state, int quant_samples, int channels, int sample_rate)
static void	display_conference_run (void *state)
static void	display_conference_worker (std::shared_ptr< state_conference_common > s)
	REGISTER_HIDDEN_MODULE (conference, &display_conference_info, LIBRARY_CLASS_VIDEO_DISPLAY, VIDEO_DISPLAY_ABI_VERSION)
static void	show_help (bool from_reflector=false)
static constexpr std::chrono::milliseconds	SOURCE_TIMEOUT (500)

Variables
static const struct video_display_info	display_conference_info
static constexpr unsigned int	IN_QUEUE_MAX_BUFFER_LEN = 5

Detailed Description

Author

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

Martin Piatka piatk.nosp@m.a@ce.nosp@m.snet..nosp@m.cz

Definition in file conference.cpp.

Macro Definition Documentation

FAIL_IF

#define FAIL_IF	(		x,
			msg )

Value:

        do {\
                if(x){\
                        log_msg(LOG_LEVEL_ERROR, msg);\
                        show_help();\
                        return INIT_NOERR;\
                }\
        } while(0)\

Referenced by display_conference_init().

MOD_NAME

#define MOD_NAME   "[conference] "

Definition at line 77 of file conference.cpp.

Function Documentation

check_reconf()

static void check_reconf ( struct state_conference_common * s, struct video_desc desc )

static

Definition at line 539 of file conference.cpp.

{
        if (!video_desc_eq(desc, s->display_desc)) {
                s->display_desc = desc;
                log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "reconfiguring real display\n");
                display_reconfigure(s->real_display.get(), s->display_desc, VIDEO_NORMAL);
        }
}

References desc, state_conference_common::display_desc, display_reconfigure(), LOG_LEVEL_VERBOSE, log_msg(), MOD_NAME, state_conference_common::real_display, video_desc_eq(), and VIDEO_NORMAL.

Here is the call graph for this function:

display_conference_done()

static void display_conference_done ( void * state )

static

Definition at line 716 of file conference.cpp.

{
        auto s = static_cast<state_conference *>(state);
 
        delete s;
}

References state.

display_conference_fork()

static struct display * display_conference_fork ( void * state )

static

Definition at line 438 of file conference.cpp.

{
        auto s = ((struct state_conference *)state)->common;
        struct display *out;
        char fmt[2 + sizeof(void *) * 2 + 1] = "";
        snprintf(fmt, sizeof fmt, "%p", state);
 
        int rc = initialize_video_display(s->parent,
                        "conference", fmt, 0, NULL, &out);
        if (rc == 0) return out; else return NULL;
 
        return out;
}

References fmt, initialize_video_display(), and state.

Referenced by display_conference_get_property().

Here is the call graph for this function:

display_conference_get_property()

static bool display_conference_get_property ( void * state, int property, void * val, size_t * len )

static

Definition at line 667 of file conference.cpp.

{
        auto s = ((struct state_conference *)state)->common;
        if (property == DISPLAY_PROPERTY_SUPPORTS_MULTI_SOURCES) {
                ((struct multi_sources_supp_info *) val)->val = true;
                ((struct multi_sources_supp_info *) val)->fork_display = display_conference_fork;
                ((struct multi_sources_supp_info *) val)->state = state;
                *len = sizeof(struct multi_sources_supp_info);
                return true;
 
        } else if(property == DISPLAY_PROPERTY_CODECS) {
                codec_t codecs[] = {UYVY};
 
                memcpy(val, codecs, sizeof(codecs));
 
                *len = sizeof(codecs);
 
                return true;
        }
        
        return display_ctl_property(s->real_display.get(), property, val, len);
}

References codecs, display_conference_fork(), display_ctl_property(), DISPLAY_PROPERTY_CODECS, DISPLAY_PROPERTY_SUPPORTS_MULTI_SOURCES, len, property, state, UYVY, and val.

Here is the call graph for this function:

display_conference_getf()

static struct video_frame * display_conference_getf ( void * state )

static

Definition at line 723 of file conference.cpp.

{
        PROFILE_FUNC;
        auto s = static_cast<state_conference *>(state);
 
        return vf_alloc_desc_data(s->desc);
}

References PROFILE_FUNC, state, and vf_alloc_desc_data().

Here is the call graph for this function:

display_conference_init()

static void * display_conference_init ( struct module * parent, const char * fmt, unsigned int flags )

static

Definition at line 466 of file conference.cpp.

{
        auto s = std::make_unique<state_conference>();
        log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "init fmt: %s\n", fmt);
 
        if(!fmt){
                show_help();
                return INIT_NOERR;
        }
 
        if (strcmp(fmt, "reflhelp") == 0) {
                show_help(true);
                return INIT_NOERR;
        }
 
        if (isdigit(fmt[0])){ // fork
                struct state_conference *orig;
                sscanf(fmt, "%p", &orig);
                s->common = orig->common;
                return s.release();
        }
 
        std::string requested_display = "gl";
        std::string disp_conf;
 
        s->common = std::make_shared<state_conference_common>(parent);
 
        auto& desc = s->common->desc;
        desc.color_spec = UYVY;
        desc.interlacing = PROGRESSIVE;
        desc.tile_count = 1;
        desc.fps = 0;
 
        std::string_view param = fmt;
        auto disp_cfg = tokenize(param, '#');
        auto conf_cfg = tokenize(param, '#');
 
#define FAIL_IF(x, msg) \
        do {\
                if(x){\
                        log_msg(LOG_LEVEL_ERROR, msg);\
                        show_help();\
                        return INIT_NOERR;\
                }\
        } while(0)\
 
        requested_display = tokenize(disp_cfg, ':');
        FAIL_IF(requested_display.empty(), "Requested display cannot be empty\n");
        disp_conf = tokenize(disp_cfg, ':');
        FAIL_IF(!parse_num(tokenize(conf_cfg, ':'), desc.width), "Failed to parse width\n");
        FAIL_IF(!parse_num(tokenize(conf_cfg, ':'), desc.height), "Failed to parse height\n");
 
        auto tok = tokenize(conf_cfg, ':');
        FAIL_IF(!tok.empty() && !parse_num(tokenize(tok, ':'), s->common->req_fps), "Failed to parse fps\n");
 
        desc.fps = s->common->req_fps;
 
        tok = tokenize(conf_cfg, ':');
        if(tok == "one_big"){
                s->common->layout = Video_mixer::Layout::One_big;
        }
 
        int ret = initialize_video_display(parent, requested_display.c_str(), disp_conf.c_str(),
                        flags, nullptr, out_ptr(s->common->real_display));
 
        if(ret != 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to init real display\n");
                return nullptr;
        }
 
        return s.release();
}

References video_desc::color_spec, state_conference::common, desc, FAIL_IF, flags, fmt, video_desc::fps, video_desc::height, INIT_NOERR, initialize_video_display(), video_desc::interlacing, LOG_LEVEL_ERROR, LOG_LEVEL_VERBOSE, log_msg(), MOD_NAME, param, parent, parse_num(), PROGRESSIVE, show_help(), video_desc::tile_count, tokenize(), UYVY, and video_desc::width.

Here is the call graph for this function:

display_conference_probe()

static void display_conference_probe ( struct device_info ** available_cards, int * count, void(** deleter )(void *) )

static

Definition at line 758 of file conference.cpp.

                                                                                                                 {
        UNUSED(deleter);
        *available_cards = nullptr;
        *count = 0;
}

References count, deleter, and UNUSED.

display_conference_put_audio_frame()

static void display_conference_put_audio_frame ( void * state, const struct audio_frame * frame )

static

Definition at line 699 of file conference.cpp.

{
        UNUSED(state);
        UNUSED(frame);
}

References frame, state, and UNUSED.

display_conference_putf()

static bool display_conference_putf ( void * state, struct video_frame * frame, long long flags )

static

Definition at line 731 of file conference.cpp.

{
        auto s = static_cast<state_conference *>(state)->common;
 
        if (flags == PUTF_DISCARD) {
                vf_free(frame);
        } else {
                std::unique_lock<std::mutex> lg(s->incoming_frames_lock);
                if (s->incoming_frames.size() >= IN_QUEUE_MAX_BUFFER_LEN) {
                        log_msg(LOG_LEVEL_WARNING, "[conference] queue full!\n");
                        if(flags != PUTF_BLOCKING){
                                vf_free(frame);
                                return 1;
                        }
                }
                s->incoming_frame_consumed.wait(lg,
                                [s]{
                                return s->incoming_frames.size() < IN_QUEUE_MAX_BUFFER_LEN;
                                });
                s->incoming_frames.emplace(frame);
                lg.unlock();    
                s->new_incoming_frame_cv.notify_one();
        }
 
        return true;
}

References flags, frame, IN_QUEUE_MAX_BUFFER_LEN, LOG_LEVEL_WARNING, log_msg(), PUTF_BLOCKING, PUTF_DISCARD, state, and vf_free().

Here is the call graph for this function:

display_conference_reconfigure()

static bool display_conference_reconfigure ( void * state, struct video_desc desc )

static

Definition at line 690 of file conference.cpp.

{
        struct state_conference *s = (struct state_conference *) state;
 
        s->desc = desc;
 
        return true;
}

References desc, state_conference::desc, and state.

display_conference_reconfigure_audio()

static bool display_conference_reconfigure_audio ( void * state, int quant_samples, int channels, int sample_rate )

static

Definition at line 705 of file conference.cpp.

{
        UNUSED(state);
        UNUSED(quant_samples);
        UNUSED(channels);
        UNUSED(sample_rate);
 
        return false;
}

References channels, quant_samples, sample_rate, state, and UNUSED.

display_conference_run()

static void display_conference_run ( void * state )

static

Definition at line 655 of file conference.cpp.

{
        PROFILE_FUNC;
        auto s = static_cast<state_conference *>(state)->common;
 
        std::thread worker = std::thread(display_conference_worker, s);
 
        display_run_mainloop(s->real_display.get());
 
        worker.join();
}

References display_conference_worker(), display_run_mainloop(), PROFILE_FUNC, state, and worker().

Here is the call graph for this function:

display_conference_worker()

static void display_conference_worker ( std::shared_ptr< state_conference_common > s )

static

We initially set next_frame_time to infinity (or a very long time from now) to avoid uselessly outputing the same frame twice in a row if we haven't received any new input, because then any new input would have to wait up to 1 frametime adding needless latency.

Definition at line 548 of file conference.cpp.

                                                                               {
        PROFILE_FUNC;
        Video_mixer mixer(s->desc.width, s->desc.height, s->layout);
 
        auto next_frame_time = clock::now() + std::chrono::hours(1); //workaround for gcc bug 58931
        auto last_frame_time = clock::time_point::min();
        for(;;){
                struct message *msg;
                while ((msg = check_message(s->mod.get()))) {
                        auto msg_univ = reinterpret_cast<struct msg_universal *>(msg);
                        std::string_view msg_text = msg_univ->text;
                        auto key = tokenize(msg_text, '=');
                        auto val = tokenize(msg_text, '=');
 
                        log_msg(LOG_LEVEL_NOTICE, MOD_NAME "Received message: %s\n", msg_univ->text);
                        struct response *r;
                        if (key == "layout") {
                                Video_mixer::Layout new_layout = layout_from_name(val);
 
                                if(new_layout == Video_mixer::Layout::Invalid){
                                        log_msg(LOG_LEVEL_ERROR, "Unknown layout %s\n", std::string(val).c_str());
                                        r = new_response(RESPONSE_BAD_REQUEST, "Unknown layout!");
                                } else {
                                        log_msg(LOG_LEVEL_NOTICE, "Setting layout to %s\n", std::string(val).c_str());
                                        mixer.set_layout(new_layout);
                                        r = new_response(RESPONSE_OK, NULL);
                                }
 
                        } else if (key == "primary_ssrc"){
                                uint32_t parsed_ssrc = 0;
                                if(!parse_num(val, parsed_ssrc, 16)){
                                        log_msg(LOG_LEVEL_ERROR, "Unable to parse ssrc!\n");
                                        r = new_response(RESPONSE_BAD_REQUEST, "Unable to parse ssrc!");
                                } else {
                                        log_msg(LOG_LEVEL_NOTICE, "Setting primary ssrc to %x\n", parsed_ssrc);
                                        mixer.set_primary_ssrc(parsed_ssrc);
                                        r = new_response(RESPONSE_OK, NULL);
                                }
 
                        } else if (key == "info"){
                                auto ssrcs = mixer.get_participant_ssrc_list();
                                log_msg(LOG_LEVEL_NOTICE, "Conference layout: %s\n", layout_get_name(mixer.get_layout()));
                                log_msg(LOG_LEVEL_NOTICE, "%zu participants \n", ssrcs.size());
                                for(const auto& p : ssrcs){
                                        log_msg(LOG_LEVEL_NOTICE, "%s   %x\n", p == mixer.get_primary_ssrc() ? "*" : " ", p);
                                }
                                r = new_response(RESPONSE_OK, NULL);
                        } else {
                                r = new_response(RESPONSE_BAD_REQUEST, "Wrong message!");
                        }
                        free_message(msg, r);
                }
 
                unique_frame frame;
 
                auto wait_p = [s]{ return !s->incoming_frames.empty(); };
                std::unique_lock<std::mutex> lock(s->incoming_frames_lock);
                bool have_frame = s->new_incoming_frame_cv.wait_until(lock, next_frame_time, wait_p);
                if(have_frame){
                        frame = std::move(s->incoming_frames.front());
                        s->incoming_frames.pop();
                }
                lock.unlock();
 
                if(have_frame){
                        s->incoming_frame_consumed.notify_one();
                        if(!frame){
                                display_put_frame(s->real_display.get(), nullptr, PUTF_BLOCKING);
                                break;
                        }
                        if(s->req_fps <= 0){
                                s->desc.fps = std::max(s->desc.fps, frame->fps);
                        }
                        mixer.process_frame(std::move(frame));
                }
 
                auto now = clock::now();
                if(next_frame_time <= now){
                        check_reconf(s.get(), s->desc);
                        auto disp_frame = display_get_frame(s->real_display.get());
 
                        mixer.get_mixed(disp_frame);
 
                        display_put_frame(s->real_display.get(), disp_frame, PUTF_BLOCKING);
 
                        last_frame_time = next_frame_time;
                        next_frame_time = now + std::chrono::hours(1);
                } else {
                        if(!have_frame)
                                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Woke up without new frame and before render time. This should not happen.\n");
                        using namespace std::chrono_literals;
                        next_frame_time = last_frame_time + std::chrono::duration_cast<clock::duration>(1s / s->desc.fps);
                        if(next_frame_time <= now){
                                next_frame_time = now;
                        }
                }
        }
 
        return;
}

References check_message(), check_reconf(), display_get_frame(), display_put_frame(), video_frame::fps, frame, free_message(), key, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, msg, new_response(), parse_num(), PROFILE_FUNC, PUTF_BLOCKING, RESPONSE_BAD_REQUEST, RESPONSE_OK, msg_universal::text, tokenize(), and val.

Referenced by display_conference_run().

Here is the call graph for this function:

REGISTER_HIDDEN_MODULE()

REGISTER_HIDDEN_MODULE	(	conference	,
		&	display_conference_info,
		LIBRARY_CLASS_VIDEO_DISPLAY	,
		VIDEO_DISPLAY_ABI_VERSION	)

show_help()

static void show_help ( bool from_reflector = false )

static

Definition at line 452 of file conference.cpp.

                                                  {
        if (from_reflector) {
                color_printf(TBOLD("conference")
                             " options:\n");
                color_printf("\t" TBOLD(
                    "-r <width>:<height>[:<fps>]")
                             "\n");
                return;
        }
        printf("Conference display\n");
        printf("Usage:\n");
        printf("\t-d conference:<display_config>#<width>:<height>:[fps]:[layout]\n");
}

References color_printf(), and TBOLD.

Here is the call graph for this function:

SOURCE_TIMEOUT()

static constexpr std::chrono::milliseconds SOURCE_TIMEOUT ( 500 )

staticconstexpr

Variable Documentation

display_conference_info

const struct video_display_info display_conference_info

static

Initial value:

= {
        display_conference_probe,
        display_conference_init,
        display_conference_run,
        display_conference_done,
        display_conference_getf,
        display_conference_putf,
        display_conference_reconfigure,
        display_conference_get_property,
        display_conference_put_audio_frame,
        display_conference_reconfigure_audio,
        DISPLAY_NO_GENERIC_FPS_INDICATOR,
}

Definition at line 764 of file conference.cpp.

                                                                 {
        display_conference_probe,
        display_conference_init,
        display_conference_run,
        display_conference_done,
        display_conference_getf,
        display_conference_putf,
        display_conference_reconfigure,
        display_conference_get_property,
        display_conference_put_audio_frame,
        display_conference_reconfigure_audio,
        DISPLAY_NO_GENERIC_FPS_INDICATOR,
};

IN_QUEUE_MAX_BUFFER_LEN

unsigned int IN_QUEUE_MAX_BUFFER_LEN = 5

staticconstexpr

Definition at line 410 of file conference.cpp.