hd-rum-decompress.cpp File Reference

decompressing part of transcoding reflector More...

#include <condition_variable>
#include <iostream>
#include <map>
#include <memory>
#include <mutex>
#include <queue>
#include <thread>
#include "hd-rum-translator/hd-rum-decompress.h"
#include "hd-rum-translator/hd-rum-recompress.h"
#include "audio/types.h"
#include "capture_filter.h"
#include "debug.h"
#include "host.h"
#include "rtp/rtp.h"
#include "tv.h"
#include "video.h"
#include "video_display.h"
#include "video_display/pipe.hpp"
#include "video_rxtx.hpp"
#include "video_rxtx/ultragrid_rtp.hpp"
#include "utils/profile_timer.hpp"

Include dependency graph for hd-rum-decompress.cpp:

Go to the source code of this file.

Classes
struct	hd_rum_decompress::state_transcoder_decompress

Namespaces
namespace	hd_rum_decompress

Functions
void	hd_rum_decompress_done (void *state)
void *	hd_rum_decompress_init (struct module *parent, struct hd_rum_output_conf conf, const char *capture_filter, struct state_recompress *recompress)
ssize_t	hd_rum_decompress_write (void *state, void *buf, size_t count)

Variables
static constexpr int	MAX_QUEUE_SIZE = 2

Detailed Description

decompressing part of transcoding reflector

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 hd-rum-decompress.cpp.

Function Documentation

hd_rum_decompress_done()

void hd_rum_decompress_done

(

void *

state

)

Definition at line 250 of file hd-rum-decompress.cpp.

                                         {
        struct state_transcoder_decompress *s = (struct state_transcoder_decompress *) state;
 
        s->receiver_thread.join();
 
        {
                unique_lock<mutex> l(s->lock);
                s->received_frame.push({});
                l.unlock();
                s->have_frame_cv.notify_one();
        }
 
        s->worker_thread.join();
 
        display_put_frame(s->display, NULL, 0);
        s->video_rxtx->join();
 
        delete s->video_rxtx;
 
        display_join(s->display);
        display_done(s->display);
        capture_filter_destroy(s->capture_filter_state);
 
        delete s;
}

References capture_filter_destroy(), hd_rum_decompress::state_transcoder_decompress::capture_filter_state, hd_rum_decompress::state_transcoder_decompress::display, display_done(), display_join(), display_put_frame(), hd_rum_decompress::state_transcoder_decompress::have_frame_cv, ultragrid_rtp_video_rxtx::join(), hd_rum_decompress::state_transcoder_decompress::lock, hd_rum_decompress::state_transcoder_decompress::received_frame, hd_rum_decompress::state_transcoder_decompress::receiver_thread, state, hd_rum_decompress::state_transcoder_decompress::video_rxtx, and hd_rum_decompress::state_transcoder_decompress::worker_thread.

Referenced by hd_rum_translator_deinit().

Here is the call graph for this function:

hd_rum_decompress_init()

void * hd_rum_decompress_init	(	struct module *	parent,
		struct hd_rum_output_conf	conf,
		const char *	capture_filter,
		struct state_recompress *	recompress )

Definition at line 169 of file hd-rum-decompress.cpp.

{
        if (conf.mode == CONFERENCE && strcmp(conf.arg, "help") == 0) {
                struct display *display = nullptr;
                const int       ret     = initialize_video_display(
                    parent, "conference", "reflhelp", 0, nullptr, &display);
                assert(ret == 1);
                return nullptr;
        }
 
        struct state_transcoder_decompress *s;
        int force_ip_version = 0;
 
        s = new state_transcoder_decompress();
 
        s->recompress = recompress;
        s->common.force_ip_version = force_ip_version;
        s->common.start_time = get_time_in_ns();
 
        char cfg[128] = "";
        int ret;
 
        switch(conf.mode){
        case NORMAL:
                snprintf(cfg, sizeof cfg, "%p", s);
                ret = initialize_video_display(parent, "pipe", cfg, 0, NULL, &s->display);
                break;
        case BLEND:
                snprintf(cfg, sizeof cfg, "pipe:%p", s);
                ret = initialize_video_display(parent, "blend", cfg, 0, NULL, &s->display);
                break;
        case CONFERENCE:
                snprintf(cfg, sizeof cfg, "pipe:%p#%s", s, conf.arg);
                ret = initialize_video_display(parent, "conference", cfg, 0, NULL, &s->display);
                break;
        }
 
        assert(ret == 0 && "Unable to initialize auxiliary display");
 
        map<string, param_u> params;
 
        // common
        s->common.parent = parent;
        params["exporter"].ptr = NULL;
        params["compression"].str = "none";
        params["rxtx_mode"].i = MODE_RECEIVER;
 
        //RTP
        // should be localhost and RX TX ports the same (here dynamic) in order to work like a pipe
        params["receiver"].str = "localhost";
        params["rx_port"].i = 0;
        params["tx_port"].i = 0;
        params["common"].ptr = &s->common;
        params["fec"].str = "none";
        params["bitrate"].ll = 0;
        params["video_delay"].vptr = 0;
 
        // UltraGrid RTP
        params["decoder_mode"].l = VIDEO_NORMAL;
        params["display_device"].ptr = s->display;
 
        try {
                s->video_rxtx = dynamic_cast<ultragrid_rtp_video_rxtx *>(video_rxtx::create("ultragrid_rtp", params));
                assert (s->video_rxtx);
 
                s->worker_thread = thread(&state_transcoder_decompress::worker, s);
                s->receiver_thread = thread(&video_rxtx::receiver_thread, s->video_rxtx);
                display_run_new_thread(s->display);
 
                if (capture_filter_init(parent, capture_filter, &s->capture_filter_state) != 0) {
                        log_msg(LOG_LEVEL_ERROR, "Unable to initialize capture filter!\n");
                        return nullptr;
                }
        } catch (string const &s) {
                LOG(LOG_LEVEL_ERROR) << s << "\n";
                return nullptr;
        }
 
        return (void *) s;
}

References hd_rum_output_conf::arg, BLEND, capture_filter_init(), hd_rum_decompress::state_transcoder_decompress::capture_filter_state, hd_rum_decompress::state_transcoder_decompress::common, CONFERENCE, video_rxtx::create(), hd_rum_decompress::state_transcoder_decompress::display, display_run_new_thread(), common_opts::force_ip_version, get_time_in_ns(), initialize_video_display(), LOG, LOG_LEVEL_ERROR, log_msg(), hd_rum_output_conf::mode, MODE_RECEIVER, NORMAL, params, common_opts::parent, parent, hd_rum_decompress::state_transcoder_decompress::receiver_thread, video_rxtx::receiver_thread(), hd_rum_decompress::state_transcoder_decompress::recompress, common_opts::start_time, VIDEO_NORMAL, hd_rum_decompress::state_transcoder_decompress::video_rxtx, hd_rum_decompress::state_transcoder_decompress::worker(), and hd_rum_decompress::state_transcoder_decompress::worker_thread.

Referenced by main().

Here is the call graph for this function:

hd_rum_decompress_write()

ssize_t hd_rum_decompress_write	(	void *	state,
		void *	buf,
		size_t	count )

Definition at line 134 of file hd-rum-decompress.cpp.

{
        struct state_transcoder_decompress *s = (struct state_transcoder_decompress *) state;
 
        return rtp_send_raw_rtp_data(s->video_rxtx->m_network_device,
                        (char *) buf, count);
}

Referenced by writer().

Variable Documentation

MAX_QUEUE_SIZE

int MAX_QUEUE_SIZE = 2

staticconstexpr

Definition at line 65 of file hd-rum-decompress.cpp.