Inheritance diagram for hd_rum_decompress::state_transcoder_decompress:

Collaboration diagram for hd_rum_decompress::state_transcoder_decompress:

Public Member Functions
virtual	~state_transcoder_decompress ()

void	frame_arrived (struct video_frame f, struct audio_frame a)

void	worker ()

Public Member Functions inherited from frame_recv_delegate

Public Attributes
struct capture_filter *	capture_filter_state

struct common_opts	common = { COMMON_OPTS_INIT }

struct control_state *	control

struct display *	display

condition_variable	frame_consumed_cv

condition_variable	have_frame_cv

mutex	lock

std::queue< std::shared_ptr< video_frame > >	received_frame

thread	receiver_thread

struct state_recompress *	recompress

ultragrid_rtp_video_rxtx *	video_rxtx

thread	worker_thread

Detailed Description

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

Constructor & Destructor Documentation

◆ ~state_transcoder_decompress()

virtual hd_rum_decompress::state_transcoder_decompress::~state_transcoder_decompress ( )

inlinevirtual

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

94{}

Member Function Documentation

◆ frame_arrived()

void hd_rum_decompress::state_transcoder_decompress::frame_arrived	(	struct video_frame *	,
		struct audio_frame *	)

virtual

Implementing method must release both audio and video frame received as parameters with AUDIO_FRAME_DISPOSE() and VIDEO_FRAME_DISPOSE().

Implements frame_recv_delegate.

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

{
        PROFILE_FUNC;
        if (a) {
                LOG(LOG_LEVEL_WARNING) << "Unexpectedly receiving audio!\n";
                AUDIO_FRAME_DISPOSE(a);
        }
        auto deleter = vf_free;
        // apply capture filter
        if (f) {
                f = capture_filter(capture_filter_state, f);
        }
        if (f && f->callbacks.dispose) {
                deleter = f->callbacks.dispose;
        }
        if (!f) {
                return;
        }
 
        unique_lock<mutex> l(lock);
        if (received_frame.size() >= MAX_QUEUE_SIZE) {
                fprintf(stderr, "Hd-rum-decompress max queue size (%d) reached!\n", MAX_QUEUE_SIZE);
        }
        frame_consumed_cv.wait(l, [this]{ return received_frame.size() < MAX_QUEUE_SIZE; });
        received_frame.emplace(f, deleter);
        l.unlock();
        have_frame_cv.notify_one();
}

References AUDIO_FRAME_DISPOSE, video_frame::callbacks, capture_filter(), capture_filter_state, deleter, video_frame_callbacks::dispose, frame_consumed_cv, have_frame_cv, LOG, LOG_LEVEL_WARNING, MAX_QUEUE_SIZE, PROFILE_FUNC, received_frame, and vf_free().

Here is the call graph for this function:

◆ worker()

void state_transcoder_decompress::worker ( )

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

{
        PROFILE_FUNC;
        bool should_exit = false;
        while (!should_exit) {
                unique_lock<mutex> l(lock);
                PROFILE_DETAIL("wait for received frame");
                have_frame_cv.wait(l, [this]{return !received_frame.empty();});
 
                auto frame = std::move(received_frame.front());
                l.unlock();
                PROFILE_DETAIL("");
 
                if(!frame){
                        should_exit = true;
                } else {
                        recompress_process_async(recompress, std::move(frame));
                }
 
                // we are removing from queue now because special messages are "accepted" when queue is empty
                l.lock();
                received_frame.pop();
                l.unlock();
                frame_consumed_cv.notify_one();
        }
}