video_decoders.cpp File Reference

#include "rtp/video_decoders.h"
#include <cassert>
#include <chrono>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <atomic>
#include <condition_variable>
#include <iterator>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
#include <utility>
#include <vector>
#include "compat/htonl.h"
#include "crypto/openssl_decrypt.h"
#include "crypto/openssl_encrypt.h"
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "messaging.h"
#include "module.h"
#include "pixfmt_conv.h"
#include "rtp/fec.h"
#include "rtp/pbuf.h"
#include "rtp/rtp.h"
#include "rtp/rtp_types.h"
#include "tv.h"
#include "utils/color_out.h"
#include "utils/macros.h"
#include "utils/misc.h"
#include "utils/synchronized_queue.h"
#include "utils/thread.h"
#include "utils/timed_message.h"
#include "utils/worker.h"
#include "video.h"
#include "video_decompress.h"
#include "video_display.h"

Include dependency graph for video_decoders.cpp:

Go to the source code of this file.

Classes
struct	decompress_data
struct	state_video_decoder
	Decoder state. More...

Macros
#define	ENCRYPTED_ERR
#define	ERROR_GOTO_CLEANUP   ret = false; goto cleanup;
#define	FRAMEBUFFER_NOT_READY(decoder)
#define	max(a, b)
#define	MOD_NAME   "[video dec.] "
#define	NOT_ENCRYPTED_ERR

Typedefs
typedef void(*	change_il_t) (char *dst, char *src, int linesize, int height, void **state)

Functions
	ADD_TO_PARAM ("decoder-drop-policy", "* decoder-drop-policy=blocking|nonblock|<sec>\n" " Force specified blocking policy (default nonblock).\n" " <sec> - specifies frame timeout in seconds (can have suffixes, eg. \"20ms\")\n")
	ADD_TO_PARAM ("decoder-use-codec", "* decoder-use-codec=<codec>\n" " Use specified pixel format for decoding (eg. v210). This overrides automatic\n" " choice. The pixel format must be supported by the video display. Use 'help' to see\n" " available options for a display (eg.: 'uv -d gl --param decoder-use-codec=help').\n" "* decoder-use-codec=!<codec>\n" " Blacklist specified pixel format ('!<codec' may need to be quoted).\n")
static bool	blacklist_current_out_codec (struct state_video_decoder *decoder)
static void	check_for_mode_change (struct state_video_decoder *decoder, const uint32_t *hdr)
static codec_t	choose_codec_and_decoder (struct state_video_decoder *decoder, struct video_desc desc, decoder_t *decode_line, struct pixfmt_desc comp_int_prop)
static void	cleanup (struct state_video_decoder *decoder)
static auto	codec_list_to_str (vector< codec_t > const &codecs)
int	decode_video_frame (struct coded_data *cdata, void *decoder_data, struct pbuf_stats *stats)
	Decodes a participant buffer representing one video frame.
static void	decoder_process_message (struct module *)
static void	decoder_set_video_mode (struct state_video_decoder *decoder, enum video_mode video_mode)
static void *	decompress_thread (void *args)
static void *	decompress_worker (void *data)
static void *	fec_thread (void *args)
bool	parse_video_hdr (const uint32_t *hdr, struct video_desc *desc)
static bool	reconfigure_decoder (struct state_video_decoder *decoder, struct video_desc desc, struct pixfmt_desc comp_int_desc)
static void	reconfigure_helper (struct state_video_decoder *decoder, struct video_desc network_desc, struct pixfmt_desc comp_int_desc)
static void	reconfigure_if_needed (struct state_video_decoder *decoder, struct video_desc network_desc, struct pixfmt_desc comp_int_desc)
static change_il_t	select_il_func (enum interlacing_t in_il, enum interlacing_t *supported, int il_out_cnt, enum interlacing_t *out_il)
static int	sum_map (map< int, int > const &m)
void	video_decoder_destroy (struct state_video_decoder *decoder)
	Destroys decoder created with decoder_init()
struct state_video_decoder *	video_decoder_init (struct module *parent, enum video_mode video_mode, struct display *display, const char *encryption)
	Initializes video decompress state.
static vector< pair< struct pixfmt_desc, codec_t > >	video_decoder_order_output_codecs (struct pixfmt_desc comp_int_prop, vector< codec_t > const &display_codecs)
bool	video_decoder_register_display (struct state_video_decoder *decoder, struct display *display)
	Registers video display to be used for displaying decoded video frames.
void	video_decoder_remove_display (struct state_video_decoder *decoder)
	This removes display from current decoder.
static void	video_decoder_start_threads (struct state_video_decoder *decoder)
	starts decompress and ldmg threads
static void	video_decoder_stop_threads (struct state_video_decoder *decoder)
	This function stops running threads.
static void	wait_for_framebuffer_swap (struct state_video_decoder *decoder)

Variables
constexpr int	PADDING = MAX_PADDING

Detailed Description

Author

Colin Perkins

Ladan Gharai

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

Workflow

Normal workflow through threads is following:

1. decode data from in context of receiving thread with function decode_frame(), it will decode it to framebuffer, passes it to FEC thread
2. fec_thread() passes frame to decompress thread
3. thread running decompress_thread(), displays the frame

Uncompressed video (without FEC)

In step one, the decoder is a linedecoder and framebuffer is the display framebuffer

Compressed video

Data is saved to decompress buffer. The decompression itself is done by decompress_thread().

video with FEC

Data is saved to FEC buffer. Decoded with fec_thread().

Encrypted video (without FEC)

Prior to decoding, packet is decompressed.

Encrypted video (with FEC)

After FEC decoding, the whole block is decompressed.

Probing compressed video codecs

When video is received, it is probed for an internal format:

• compression is reconfigured to (VIDEO_CODEC_NONE, VIDEO_CODEC_NONE) - internal and out codecs are set to 0
• if any decoder for the codec supports probing, s->out_codec is set to VIDEO_CODEC_END (otherwise a decompression is directly configured)
• decompression is done as usual (display is not reconfigured and output is put to a dummy framebuffer)
• when decoder is able to establish the codec, it returns DECODER_GOT_CODEC, thread send a reconf message to the main threads and the reconfiguration shall begin - display codecs are reordered ideally to match the incoming stream

• BUGS: usually multiple reconf messages are sent, decompress priority is evaluated only when there are multiple same (in_codec,internal_codec,out_codec) tuples.

  Todo

  This code is very very messy, it needs to be rewritten.

Note

The properties of DXTn do not exactly match - bpp is 0.5, but line (actually 4 lines) is (2 * width) long, so it makes troubles when using line decoder and tiles. So the fallback is external decoder. The DXT compression is exceptional in that, that it can be both internally and externally decompressed.

Definition in file video_decoders.cpp.

Macro Definition Documentation

ENCRYPTED_ERR

#define ENCRYPTED_ERR

Value:

        "Receiving encrypted video data but " \
        "no decryption key entered!\n"

Definition at line 411 of file video_decoders.cpp.

#define ENCRYPTED_ERR "Receiving encrypted video data but " \
        "no decryption key entered!\n"

Referenced by decode_video_frame().

ERROR_GOTO_CLEANUP

#define ERROR_GOTO_CLEANUP   ret = false; goto cleanup;

Definition at line 1490 of file video_decoders.cpp.

Referenced by decode_video_frame().

FRAMEBUFFER_NOT_READY

#define FRAMEBUFFER_NOT_READY

(

decoder

)

Value:

(decoder->frame == NULL && decoder->out_codec != VIDEO_CODEC_END)

Definition at line 151 of file video_decoders.cpp.

Referenced by decode_video_frame(), and fec_thread().

max

#define max	(		a,
			b )

Value:

(((a) > (b))? (a): (b))

Definition at line 1491 of file video_decoders.cpp.

Referenced by decode_video_frame().

MOD_NAME

#define MOD_NAME   "[video dec.] "

Definition at line 149 of file video_decoders.cpp.

Referenced by decode_video_frame(), decompress_thread(), parse_video_hdr(), and video_decoder_register_display().

NOT_ENCRYPTED_ERR

#define NOT_ENCRYPTED_ERR

Value:

        "Receiving unencrypted video data " \
        "while expecting encrypted.\n"

Definition at line 413 of file video_decoders.cpp.

#define NOT_ENCRYPTED_ERR "Receiving unencrypted video data " \
        "while expecting encrypted.\n"

Referenced by decode_video_frame().

Typedef Documentation

change_il_t

typedef void(* change_il_t) (char *dst, char *src, int linesize, int height, void **state)

Interlacing changing function protoype. The function should be able to change buffer in place, that is when dst and src are the same.

Definition at line 179 of file video_decoders.cpp.

Function Documentation

ADD_TO_PARAM() [1/2]

ADD_TO_PARAM

(

"decoder-drop-policy"

)

ADD_TO_PARAM() [2/2]

ADD_TO_PARAM

(

"decoder-use-codec"

)

blacklist_current_out_codec()

static bool blacklist_current_out_codec ( struct state_video_decoder * decoder )

static

Definition at line 570 of file video_decoders.cpp.

                                                                            {
        if(decoder->out_codec == VIDEO_CODEC_NONE)
                return false;
 
        auto to_erase = find(decoder->native_codecs.begin(), decoder->native_codecs.end(), decoder->out_codec);
        if (to_erase == decoder->native_codecs.end()) {
                return true; // should it really return true?
        }
        log_msg(LOG_LEVEL_DEBUG, "Blacklisting codec %s\n", get_codec_name(decoder->out_codec));
        decoder->native_codecs.erase(to_erase);
 
        return true;
}

References get_codec_name(), LOG_LEVEL_DEBUG, log_msg(), state_video_decoder::native_codecs, state_video_decoder::out_codec, and VIDEO_CODEC_NONE.

Referenced by decompress_thread().

Here is the call graph for this function:

check_for_mode_change()

static void check_for_mode_change ( struct state_video_decoder * decoder, const uint32_t * hdr )

static

Checks if network format has changed.

Parameters

decoder	decoder state
hdr	raw RTP payload header

Definition at line 1474 of file video_decoders.cpp.

{
        struct video_desc network_desc;
 
        parse_video_hdr(hdr, &network_desc);
        if (video_desc_eq_excl_param(decoder->received_vid_desc, network_desc,
                                      PARAM_TILE_COUNT)) {
                return;
        }
        LOG(LOG_LEVEL_NOTICE)
            << "[video dec.] New incoming video format detected: "
            << network_desc << "\n";
        reconfigure_helper(decoder, network_desc, {});
}

References LOG, LOG_LEVEL_NOTICE, PARAM_TILE_COUNT, parse_video_hdr(), state_video_decoder::received_vid_desc, reconfigure_helper(), and video_desc_eq_excl_param().

Referenced by decode_video_frame().

Here is the call graph for this function:

choose_codec_and_decoder()

static codec_t choose_codec_and_decoder ( struct state_video_decoder * decoder, struct video_desc desc, decoder_t * decode_line, struct pixfmt_desc comp_int_prop )

static

This function selects, according to given video description, appropriate

Parameters

[in]	decoder	decoder to be taken parameters from (video mode, native codecs etc.)
[in]	desc	incoming video description
[out]	decode_line	If chosen decoder is a linedecoder, this variable contains the decoding function.

Returns

Output codec, if no decoding function found, -1 is returned.

DXT1 it is a exception, see vdec_note1

Definition at line 1073 of file video_decoders.cpp.

{
        codec_t out_codec = VIDEO_CODEC_NONE;
 
        /* first check if the codec is natively supported */
        for (auto &codec : decoder->native_codecs) {
                if (desc.color_spec == codec) {
                        if ((desc.color_spec == DXT1 || desc.color_spec == DXT1_YUV ||
                                        desc.color_spec == DXT5)
                                        && decoder->video_mode != VIDEO_NORMAL)
                                continue; 
 
                        *decode_line = vc_memcpy;
                        decoder->decoder_type = LINE_DECODER;
 
                        if(desc.color_spec == RGBA || /* another exception - we may change shifts */
                                        desc.color_spec == RGB) { // should RGB be also handled
                                *decode_line = get_decoder_from_to(desc.color_spec, desc.color_spec);
                        }
 
                        out_codec = codec;
                        goto after_linedecoder_lookup;
                }
        }
        /* otherwise if we have line decoder (incl. slow codecs) */
        {
                vector<codec_t> native_codecs_copy = decoder->native_codecs;
                native_codecs_copy.push_back(VIDEO_CODEC_NONE); // this needs to be NULL-terminated
                *decode_line = get_best_decoder_from(desc.color_spec, native_codecs_copy.data(), &out_codec);
                if (*decode_line) {
                        decoder->decoder_type = LINE_DECODER;
                        goto after_linedecoder_lookup;
                }
        }
 
after_linedecoder_lookup:
 
        /* we didn't find line decoder. So try now regular (aka DXT) decoder */
        if(*decode_line == NULL) {
                decoder->decompress_state.resize(decoder->max_substreams);
 
                // try to probe video format
                if (comp_int_prop.depth == 0 && decoder->out_codec != VIDEO_CODEC_END) {
                        bool supports_autodetection = decompress_init_multi(desc.color_spec,
                                        pixfmt_desc{}, VIDEO_CODEC_NONE, decoder->decompress_state.data(),
                                        decoder->decompress_state.size());
                        if (supports_autodetection) {
                                decoder->decoder_type = EXTERNAL_DECODER;
                                return VIDEO_CODEC_END;
                        }
                }
 
                vector<pair<struct pixfmt_desc, codec_t>> formats_to_try; // comp_int_prop (may be empty), display_fmt
                formats_to_try = video_decoder_order_output_codecs(comp_int_prop, decoder->native_codecs);
 
                for (auto it = formats_to_try.begin(); it != formats_to_try.end(); ++it) {
                        out_codec = (*it).second;
                        if (decompress_init_multi(desc.color_spec, (*it).first,
                                                (*it).second,
                                                decoder->decompress_state.data(),
                                                decoder->decompress_state.size())) {
                                decoder->decoder_type = EXTERNAL_DECODER;
                                goto after_decoder_lookup;
                        }
                }
                decoder->decompress_state.clear();
        }
after_decoder_lookup:
 
        if(decoder->decoder_type == UNSET) {
                log_msg(LOG_LEVEL_ERROR, "Unable to find decoder for input codec \"%s\"!!!\n", get_codec_name(desc.color_spec));
                LOG(LOG_LEVEL_INFO) << "Compression internal codec is \"" << get_pixdesc_desc(comp_int_prop) << "\". Native codecs are: " << codec_list_to_str(decoder->native_codecs) << "\n";
                return VIDEO_CODEC_NONE;
        }
 
        return out_codec;
}

References codec_list_to_str(), video_desc::color_spec, state_video_decoder::decoder_type, decompress_init_multi(), state_video_decoder::decompress_state, pixfmt_desc::depth, desc, DXT1, DXT1_YUV, DXT5, get_best_decoder_from(), get_codec_name(), get_decoder_from_to(), get_pixdesc_desc(), LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), state_video_decoder::max_substreams, state_video_decoder::native_codecs, state_video_decoder::out_codec, RGB, RGBA, vc_memcpy, VIDEO_CODEC_END, VIDEO_CODEC_NONE, video_decoder_order_output_codecs(), state_video_decoder::video_mode, and VIDEO_NORMAL.

Referenced by reconfigure_decoder().

Here is the call graph for this function:

cleanup()

static void cleanup ( struct state_video_decoder * decoder )

static

Definition at line 954 of file video_decoders.cpp.

{
        decoder->decoder_type = UNSET;
        for (auto &d : decoder->decompress_state) {
                decompress_done(d);
        }
        decoder->decompress_state.clear();
        if(decoder->line_decoder) {
                free(decoder->line_decoder);
                decoder->line_decoder = NULL;
        }
 
        for (auto && item : decoder->change_il_state) {
                free(item);
        }
        decoder->change_il_state.resize(0);
}

References state_video_decoder::change_il_state, state_video_decoder::decoder_type, decompress_done(), state_video_decoder::decompress_state, and state_video_decoder::line_decoder.

Here is the call graph for this function:

codec_list_to_str()

static auto codec_list_to_str ( vector< codec_t > const & codecs )

static

Definition at line 828 of file video_decoders.cpp.

                                                             {
        if (codecs.empty()) {
                return "(none)"s;
        }
        ostringstream oss;
        auto it = codecs.begin();
        oss << *it++;
        for ( ; it != codecs.end(); ++it) {
                oss << (it + 1 == codecs.end() ? " and " : ", ") << get_codec_name(*it);
        }
        return oss.str();
}

References codecs, and get_codec_name().

Referenced by choose_codec_and_decoder(), reconfigure_decoder(), and video_decoder_register_display().

Here is the call graph for this function:

decoder_process_message()

static void decoder_process_message ( struct module * m )

static

Definition at line 1852 of file video_decoders.cpp.

{
        struct state_video_decoder *s = (struct state_video_decoder *) m->priv_data;
 
        struct message *msg;
        while ((msg = check_message(m))) {
                struct response *r;
                struct msg_universal *m_univ = (struct msg_universal *) msg;
                if (strcmp(m_univ->text, "get_format") == 0) {
                        s->lock.lock();
                        string video_desc = s->received_vid_desc;
                        s->lock.unlock();
                        r = new_response(RESPONSE_OK, video_desc.c_str());
                } else {
                        r = new_response(RESPONSE_NOT_FOUND, NULL);
                }
                free_message(msg, r);
 
        }
}

References check_message(), free_message(), state_video_decoder::lock, msg, new_response(), module::priv_data, state_video_decoder::received_vid_desc, RESPONSE_NOT_FOUND, RESPONSE_OK, and msg_universal::text.

Referenced by state_video_decoder::state_video_decoder().

Here is the call graph for this function:

decoder_set_video_mode()

static void decoder_set_video_mode ( struct state_video_decoder * decoder, enum video_mode video_mode )

static

Definition at line 743 of file video_decoders.cpp.

{
        decoder->video_mode = video_mode;
        decoder->max_substreams = get_video_mode_tiles_x(decoder->video_mode)
                        * get_video_mode_tiles_y(decoder->video_mode);
}

References get_video_mode_tiles_x(), get_video_mode_tiles_y(), state_video_decoder::max_substreams, and state_video_decoder::video_mode.

Referenced by decode_video_frame(), and video_decoder_init().

Here is the call graph for this function:

decompress_thread()

static void * decompress_thread ( void * args )

static

Definition at line 614 of file video_decoders.cpp.

                                           {
        set_thread_name(__func__);
        struct state_video_decoder *decoder =
                (struct state_video_decoder *) args;
        int tile_width = decoder->received_vid_desc.width; // get_video_mode_tiles_x(decoder->video_mode);
        int tile_height = decoder->received_vid_desc.height; // get_video_mode_tiles_y(decoder->video_mode);
 
        long long force_putf_timeout = []() {
                auto drop_policy = commandline_params.find("decoder-drop-policy"s);
                if (drop_policy == commandline_params.end()) {
                        return -1LL;
                }
                if (drop_policy->second == "nonblock") {
                        return PUTF_NONBLOCK;
                }
                if (drop_policy->second == "blocking") {
                        return PUTF_BLOCKING;
                }
                return static_cast<long long>(
                    unit_evaluate_dbl(drop_policy->second.c_str(), true,
                                      nullptr) *
                    NS_IN_SEC);
        }();
 
        while(1) {
                unique_ptr<frame_msg> msg = decoder->decompress_queue.pop();
 
                if(!msg->recv_frame) { // poisoned
                        break;
                }
 
                auto t0 = std::chrono::high_resolution_clock::now();
                unique_ptr<char[]> tmp;
 
                if (decoder->out_codec == VIDEO_CODEC_END) {
                        tmp = unique_ptr<char[]>(new char[tile_height * (tile_width * MAX_BPS + PADDING)]);
                }
 
                if(decoder->decoder_type == EXTERNAL_DECODER) {
                        int tile_count = get_video_mode_tiles_x(decoder->video_mode) *
                                        get_video_mode_tiles_y(decoder->video_mode);
                        vector<task_result_handle_t> handle(tile_count);
                        vector<decompress_data> data(tile_count);
                        for (int pos = 0; pos < tile_count; ++pos) {
                                data[pos].decoder = decoder;
                                data[pos].pos = pos;
                                data[pos].compressed = msg->nofec_frame;
                                data[pos].buffer_num = msg->buffer_num[pos];
                                if (tmp.get()) {
                                        data[pos].out = (unsigned char *) tmp.get();
                                } else if (decoder->merged_fb) {
                                        // TODO: OK when rendering directly to display FB, otherwise, do not reflect pitch (we use PP)
                                        int x = pos % get_video_mode_tiles_x(decoder->video_mode),
                                            y = pos / get_video_mode_tiles_x(decoder->video_mode);
                                        data[pos].out = (unsigned char *) vf_get_tile(decoder->frame, 0)->data + y * decoder->pitch * tile_height +
                                                vc_get_linesize(tile_width, decoder->out_codec) * x;
                                } else {
                                        data[pos].out = (unsigned char *) vf_get_tile(decoder->frame, pos)->data;
                                }
                                if (tile_count > 1) {
                                        handle[pos] = task_run_async(decompress_worker, &data[pos]);
                                } else {
                                        decompress_worker(&data[pos]);
                                }
                        }
                        if (tile_count > 1) {
                                for (int pos = 0; pos < tile_count; ++pos) {
                                        wait_task(handle[pos]);
                                }
                        }
                        for (int pos = 0; pos < tile_count; ++pos) {
                                if (data[pos].ret == DECODER_GOT_CODEC) {
                                        LOG(LOG_LEVEL_NOTICE) << MOD_NAME << "Detected compression properties: " << get_pixdesc_desc(data[pos].internal_prop) << "\n";
                                        decoder->msg_queue.push(new main_msg_reconfigure(decoder->received_vid_desc, nullptr, false, data[pos].internal_prop));
                                        goto skip_frame;
                                }
                                if (data[pos].ret != DECODER_GOT_FRAME){
                                        if (data[pos].ret == DECODER_UNSUPP_PIXFMT) {
                                                if(blacklist_current_out_codec(decoder))
                                                        decoder->msg_queue.push(new main_msg_reconfigure(decoder->received_vid_desc, nullptr, true));
                                        }
                                        goto skip_frame;
                                }
                        }
                } else {
                        if (decoder->frame->decoder_overrides_data_len) {
                                for (unsigned int i = 0; i < decoder->frame->tile_count; ++i) {
                                        decoder->frame->tiles[i].data_len = msg->nofec_frame->tiles[i].data_len;
                                }
                        }
                }
 
                LOG(LOG_LEVEL_DEBUG) << MOD_NAME << "Decompress duration: " <<
                        duration_cast<nanoseconds>(high_resolution_clock::now() - t0).count() / 1000000.0 << " ms\n";
 
                if(decoder->change_il) {
                        for(unsigned int i = 0; i < decoder->frame->tile_count; ++i) {
                                struct tile *tile = vf_get_tile(decoder->frame, i);
                                decoder->change_il(tile->data, tile->data, vc_get_linesize(tile->width,
                                                        decoder->out_codec), tile->height, &decoder->change_il_state[i]);
                        }
                }
 
                {
                        long long putf_timeout = force_putf_timeout != -1 ? force_putf_timeout : PUTF_NONBLOCK; // originally was BLOCKING when !is_codec_interframe(decoder->received_vid_desc.color_spec)
 
                        decoder->frame->ssrc = msg->nofec_frame->ssrc;
                        decoder->frame->timestamp = msg->nofec_frame->timestamp;
                        const bool ret = display_put_frame(
                            decoder->display, decoder->frame, putf_timeout);
                        msg->is_displayed = ret;
                        decoder->frame = display_get_frame(decoder->display);
                        assert(decoder->frame != nullptr);
                }
 
skip_frame:
                {
                        unique_lock<mutex> lk(decoder->lock);
                        // we have put the video frame and requested another one which is
                        // writable so on
                        decoder->buffer_swapped = true;
                        lk.unlock();
                        decoder->buffer_swapped_cv.notify_one();
                }
        }
 
        return NULL;
}

References blacklist_current_out_codec(), state_video_decoder::buffer_swapped, state_video_decoder::buffer_swapped_cv, state_video_decoder::change_il, state_video_decoder::change_il_state, commandline_params, tile::data, tile::data_len, DECODER_GOT_CODEC, DECODER_GOT_FRAME, video_frame::decoder_overrides_data_len, state_video_decoder::decoder_type, DECODER_UNSUPP_PIXFMT, state_video_decoder::decompress_queue, decompress_worker(), state_video_decoder::display, display_get_frame(), display_put_frame(), state_video_decoder::frame, get_pixdesc_desc(), get_video_mode_tiles_x(), get_video_mode_tiles_y(), tile::height, video_desc::height, state_video_decoder::lock, LOG, LOG_LEVEL_DEBUG, LOG_LEVEL_NOTICE, MAX_BPS, state_video_decoder::merged_fb, MOD_NAME, state_video_decoder::msg_queue, NS_IN_SEC, state_video_decoder::out_codec, PADDING, state_video_decoder::pitch, synchronized_queue< T, max_len >::pop(), synchronized_queue< T, max_len >::push(), PUTF_BLOCKING, PUTF_NONBLOCK, state_video_decoder::received_vid_desc, set_thread_name(), video_frame::ssrc, task_run_async(), video_frame::tile_count, video_frame::tiles, video_frame::timestamp, unit_evaluate_dbl(), vc_get_linesize(), vf_get_tile(), VIDEO_CODEC_END, state_video_decoder::video_mode, wait_task(), tile::width, and video_desc::width.

Referenced by video_decoder_start_threads().

Here is the call graph for this function:

decompress_worker()

static void * decompress_worker ( void * data )

static

Definition at line 593 of file video_decoders.cpp.

{
        auto d = (struct decompress_data *) data;
        struct state_video_decoder *decoder = d->decoder;
 
        if (!d->compressed->tiles[d->pos].data)
                return NULL;
        d->ret = decompress_frame(decoder->decompress_state.at(d->pos),
                        (unsigned char *) d->out,
                        (unsigned char *) d->compressed->tiles[d->pos].data,
                        d->compressed->tiles[d->pos].data_len,
                        d->buffer_num,
                        &decoder->frame->callbacks,
                        &d->internal_prop);
        return d;
}

References video_frame::callbacks, decompress_frame(), state_video_decoder::decompress_state, and state_video_decoder::frame.

Referenced by decompress_thread().

Here is the call graph for this function:

fec_thread()

static void * fec_thread ( void * args )

static

Definition at line 416 of file video_decoders.cpp.

                                    {
        set_thread_name(__func__);
        struct state_video_decoder *decoder =
                (struct state_video_decoder *) args;
 
        fec *fec_state = NULL;
        struct fec_desc desc(FEC_NONE);
 
        while(1) {
                unique_ptr<frame_msg> data = decoder->fec_queue.pop();
 
                if (!data->recv_frame) { // poisoned
                        decoder->decompress_queue.push(std::move(data));
                        break; // exit from loop
                }
 
                struct video_frame *frame = decoder->frame;
                struct tile *tile = NULL;
 
                if (data->recv_frame->fec_params.type != FEC_NONE) {
                        if(!fec_state || desc.k != data->recv_frame->fec_params.k ||
                                        desc.m != data->recv_frame->fec_params.m ||
                                        desc.c != data->recv_frame->fec_params.c ||
                                        desc.seed != data->recv_frame->fec_params.seed
                          ) {
                                delete fec_state;
                                desc = data->recv_frame->fec_params;
                                fec_state = fec::create_from_desc(desc);
                                if(fec_state == NULL) {
                                        log_msg(LOG_LEVEL_FATAL, "[decoder] Unable to initialize FEC.\n");
                                        exit_uv(1);
                                        goto cleanup;
                                }
                        }
                }
 
                data->nofec_frame = vf_alloc(data->recv_frame->tile_count);
                data->nofec_frame->ssrc = data->recv_frame->ssrc;
                data->nofec_frame->timestamp = data->recv_frame->timestamp;
 
                if (data->recv_frame->fec_params.type != FEC_NONE) {
                        bool buffer_swapped = false;
                        for (int pos = 0; pos < get_video_mode_tiles_x(decoder->video_mode)
                                        * get_video_mode_tiles_y(decoder->video_mode); ++pos) {
                                char *fec_out_buffer = NULL;
                                int fec_out_len = 0;
 
                                if (data->recv_frame->tiles[pos].data_len != (unsigned int) sum_map(data->pckt_list[pos])) {
                                        debug_msg("Frame incomplete - substream %d, buffer %d: expected %u bytes, got %u.\n", pos,
                                                        (unsigned int) data->buffer_num[pos],
                                                        data->recv_frame->tiles[pos].data_len,
                                                        (unsigned int) sum_map(data->pckt_list[pos]));
                                }
 
                                bool ret = fec_state->decode(data->recv_frame->tiles[pos].data,
                                                data->recv_frame->tiles[pos].data_len,
                                                &fec_out_buffer, &fec_out_len, data->pckt_list[pos]);
 
                                if (ret == false) {
                                        data->is_corrupted = true;
                                        verbose_msg("[decoder] FEC: unable to reconstruct data.\n");
                                        if (fec_out_len < (int) sizeof(video_payload_hdr_t)) {
                                                goto cleanup;
                                        }
                                        if (decoder->decoder_type == EXTERNAL_DECODER && !decoder->accepts_corrupted_frame) {
                                                goto cleanup;
                                        }
                                }
 
                                video_payload_hdr_t video_hdr;
                                memcpy(&video_hdr, fec_out_buffer,
                                                sizeof(video_payload_hdr_t));
                                fec_out_buffer += sizeof(video_payload_hdr_t);
                                fec_out_len -= sizeof(video_payload_hdr_t);
 
                                struct video_desc network_desc;
                                parse_video_hdr(video_hdr, &network_desc);
                                if (!video_desc_eq_excl_param(decoder->received_vid_desc,
                                                        network_desc, PARAM_TILE_COUNT)) {
                                        decoder->msg_queue.push(new main_msg_reconfigure(network_desc, std::move(data)));
                                        goto cleanup;
                                }
 
                                if (FRAMEBUFFER_NOT_READY(decoder)) {
                                        goto cleanup;
                                }
 
                                if(decoder->decoder_type == EXTERNAL_DECODER) {
                                        data->nofec_frame->tiles[pos].data_len = fec_out_len;
                                        data->nofec_frame->tiles[pos].data = fec_out_buffer;
                                } else { // linedecoder
                                        if (!buffer_swapped) {
                                                buffer_swapped = true;
                                                wait_for_framebuffer_swap(decoder);
                                                unique_lock<mutex> lk(decoder->lock);
                                                decoder->buffer_swapped = false;
                                        }
 
                                        int divisor;
 
                                        if (!decoder->merged_fb) {
                                                divisor = decoder->max_substreams;
                                        } else {
                                                divisor = 1;
                                        }
 
                                        tile = vf_get_tile(frame, pos % divisor);
 
                                        struct line_decoder *line_decoder =
                                                &decoder->line_decoder[pos];
 
                                        int data_pos = 0;
                                        char *src = fec_out_buffer;
                                        char *dst = tile->data + line_decoder->base_offset;
                                        while(data_pos < (int) fec_out_len) {
                                                line_decoder->decode_line((unsigned char*)dst, (unsigned char *) src, line_decoder->dst_linesize,
                                                                line_decoder->shifts[0],
                                                                line_decoder->shifts[1],
                                                                line_decoder->shifts[2]);
                                                src += line_decoder->src_linesize;
                                                dst += vc_get_linesize(tile->width ,frame->color_spec);
                                                data_pos += line_decoder->src_linesize;
                                        }
                                }
                        }
                } else { /* PT_VIDEO */
                        for(int i = 0; i < (int) decoder->max_substreams; ++i) {
                                data->nofec_frame->tiles[i].data_len = data->recv_frame->tiles[i].data_len;
                                data->nofec_frame->tiles[i].data = data->recv_frame->tiles[i].data;
 
                                if (data->recv_frame->tiles[i].data_len != (unsigned int) sum_map(data->pckt_list[i])) {
                                        debug_msg("Frame incomplete - substream %d, buffer %d: expected %u bytes, got %u.%s\n", i,
                                                        (unsigned int) data->buffer_num[i],
                                                        data->recv_frame->tiles[i].data_len,
                                                        (unsigned int) sum_map(data->pckt_list[i]),
                                                        decoder->decoder_type == EXTERNAL_DECODER && !decoder->accepts_corrupted_frame ? " dropped.\n" : "");
                                        data->is_corrupted = true;
                                        if(decoder->decoder_type == EXTERNAL_DECODER && !decoder->accepts_corrupted_frame) {
                                                goto cleanup;
                                        }
                                }
                        }
                }
 
                decoder->decompress_queue.push(std::move(data));
cleanup:
                ;
        }
 
        delete fec_state;
 
        return NULL;
}

References state_video_decoder::accepts_corrupted_frame, state_video_decoder::buffer_swapped, cleanup(), video_frame::color_spec, fec::create_from_desc(), tile::data, debug_msg, fec::decode(), state_video_decoder::decoder_type, state_video_decoder::decompress_queue, desc, exit_uv(), FEC_NONE, state_video_decoder::fec_queue, frame, state_video_decoder::frame, FRAMEBUFFER_NOT_READY, get_video_mode_tiles_x(), get_video_mode_tiles_y(), state_video_decoder::line_decoder, state_video_decoder::lock, LOG_LEVEL_FATAL, log_msg(), state_video_decoder::max_substreams, state_video_decoder::merged_fb, state_video_decoder::msg_queue, PARAM_TILE_COUNT, parse_video_hdr(), synchronized_queue< T, max_len >::pop(), synchronized_queue< T, max_len >::push(), state_video_decoder::received_vid_desc, set_thread_name(), sum_map(), vc_get_linesize(), verbose_msg, vf_alloc(), vf_get_tile(), video_desc_eq_excl_param(), state_video_decoder::video_mode, wait_for_framebuffer_swap(), and tile::width.

Referenced by video_decoder_start_threads().

Here is the call graph for this function:

reconfigure_decoder()

static bool reconfigure_decoder ( struct state_video_decoder * decoder, struct video_desc desc, struct pixfmt_desc comp_int_prop )

static

Reconfigures decoder if network received video data format has changed.

Parameters

decoder	the video decoder state
desc	new video description to be reconfigured to

Returns

boolean value if reconfiguration was successful

Invariant

decoder->display != NULL

Definition at line 1206 of file video_decoders.cpp.

{
        codec_t out_codec;
        decoder_t decode_line;
        enum interlacing_t display_il = PROGRESSIVE;
        //struct video_frame *frame;
        int display_requested_pitch = PITCH_DEFAULT;
        int display_requested_rgb_shift[] = DEFAULT_RGB_SHIFT_INIT;
 
        // this code forces flushing the pipelined data
        video_decoder_stop_threads(decoder);
        if (decoder->frame)
                display_put_frame(decoder->display, decoder->frame, PUTF_DISCARD);
        decoder->frame = NULL;
        video_decoder_start_threads(decoder);
 
        cleanup(decoder);
 
        desc.tile_count = get_video_mode_tiles_x(decoder->video_mode)
                        * get_video_mode_tiles_y(decoder->video_mode);
 
        out_codec = choose_codec_and_decoder(decoder, desc, &decode_line, comp_int_prop);
        if (out_codec == VIDEO_CODEC_NONE) {
                LOG(LOG_LEVEL_ERROR) << "Could not find neither line conversion nor decompress from " <<
                        get_codec_name(desc.color_spec) << " to display supported formats (" << codec_list_to_str(decoder->native_codecs) << ").\n";
                return false;
        }
        decoder->out_codec = out_codec;
        struct video_desc display_desc = desc;
 
        int display_mode = DISPLAY_PROPERTY_VIDEO_MERGED; // default
        size_t len = sizeof(int);
 
        if (!display_ctl_property(decoder->display, DISPLAY_PROPERTY_VIDEO_MODE,
                        &display_mode, &len)) {
                debug_msg("Failed to get video display mode.\n");
        }
 
        if (display_mode == DISPLAY_PROPERTY_VIDEO_SEPARATE_3D) {
                display_mode = display_desc.tile_count == 2 ? DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES :
                        DISPLAY_PROPERTY_VIDEO_MERGED;
        }
 
        if (display_mode == DISPLAY_PROPERTY_VIDEO_MERGED) {
                display_desc.width *= get_video_mode_tiles_x(decoder->video_mode);
                display_desc.height *= get_video_mode_tiles_y(decoder->video_mode);
                display_desc.tile_count = 1;
        }
 
        decoder->change_il = select_il_func(desc.interlacing, decoder->disp_supported_il,
                        decoder->disp_supported_il_cnt, &display_il);
        decoder->change_il_state.resize(decoder->max_substreams);
        display_desc.interlacing = display_il;
        display_desc.color_spec  = out_codec;
        if (out_codec != VIDEO_CODEC_END && !video_desc_eq(decoder->display_desc, display_desc)) {
                /* reconfigure VO and give it opportunity to pass us pitch */
                bool ret = display_reconfigure(decoder->display, display_desc, decoder->video_mode);
                if(!ret) {
                        return false;
                }
                decoder->display_desc = display_desc;
 
                len = sizeof(display_requested_rgb_shift);
                ret = display_ctl_property(decoder->display, DISPLAY_PROPERTY_RGB_SHIFT,
                                &display_requested_rgb_shift, &len);
                if(!ret) {
                        debug_msg("Failed to get r,g,b shift property from video driver.\n");
                        int rgb_shift[] = DEFAULT_RGB_SHIFT_INIT;
                        memcpy(&display_requested_rgb_shift, rgb_shift, sizeof(rgb_shift));
                }
 
                ret = display_ctl_property(decoder->display, DISPLAY_PROPERTY_BUF_PITCH,
                                &display_requested_pitch, &len);
                if(!ret) {
                        debug_msg("Failed to get pitch from video driver.\n");
                        display_requested_pitch = PITCH_DEFAULT;
                }
        }
 
        int linewidth;
        if (display_mode == DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES) {
                linewidth = desc.width;
        } else {
                linewidth = desc.width * get_video_mode_tiles_x(decoder->video_mode);
        }
 
        if(display_requested_pitch == PITCH_DEFAULT)
                decoder->pitch = vc_get_linesize(linewidth, out_codec);
        else
                decoder->pitch = display_requested_pitch;
 
 
        int src_x_tiles = get_video_mode_tiles_x(decoder->video_mode);
        int src_y_tiles = get_video_mode_tiles_y(decoder->video_mode);
 
        if(decoder->decoder_type == LINE_DECODER) {
                decoder->line_decoder = (struct line_decoder *) malloc(src_x_tiles * src_y_tiles *
                                        sizeof(struct line_decoder));
                if(display_mode == DISPLAY_PROPERTY_VIDEO_MERGED && decoder->video_mode == VIDEO_NORMAL) {
                        struct line_decoder *out = &decoder->line_decoder[0];
                        out->base_offset = 0;
                        out->conv_num = get_pf_block_pixels(desc.color_spec) * get_pf_block_bytes(out_codec);
                        out->conv_den = get_pf_block_bytes(desc.color_spec) * get_pf_block_pixels(out_codec);
                        memcpy(out->shifts, display_requested_rgb_shift, 3 * sizeof(int));
 
                        out->decode_line = decode_line;
                        out->dst_pitch = decoder->pitch;
                        out->src_linesize = vc_get_linesize(desc.width, desc.color_spec);
                        out->dst_linesize = vc_get_linesize(desc.width, out_codec);
                        decoder->merged_fb = true;
                } else if(display_mode == DISPLAY_PROPERTY_VIDEO_MERGED
                                && decoder->video_mode != VIDEO_NORMAL) {
                        int x, y;
                        for(x = 0; x < src_x_tiles; ++x) {
                                for(y = 0; y < src_y_tiles; ++y) {
                                        struct line_decoder *out = &decoder->line_decoder[x +
                                                        src_x_tiles * y];
                                        out->base_offset = y * (desc.height)
                                                        * decoder->pitch +
                                                        vc_get_linesize(x * desc.width, out_codec);
 
                                        out->conv_num = get_pf_block_pixels(desc.color_spec) * get_pf_block_bytes(out_codec);
                                        out->conv_den = get_pf_block_bytes(desc.color_spec) * get_pf_block_pixels(out_codec);
                                        memcpy(out->shifts, display_requested_rgb_shift,
                                                        3 * sizeof(int));
 
                                        out->decode_line = decode_line;
 
                                        out->dst_pitch = decoder->pitch;
                                        out->src_linesize =
                                                vc_get_linesize(desc.width, desc.color_spec);
                                        out->dst_linesize =
                                                vc_get_linesize(desc.width, out_codec);
                                }
                        }
                        decoder->merged_fb = true;
                } else if (display_mode == DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES) {
                        int x, y;
                        for(x = 0; x < src_x_tiles; ++x) {
                                for(y = 0; y < src_y_tiles; ++y) {
                                        struct line_decoder *out = &decoder->line_decoder[x +
                                                        src_x_tiles * y];
                                        out->base_offset = 0;
                                        out->conv_num = get_pf_block_pixels(desc.color_spec) * get_pf_block_bytes(out_codec);
                                        out->conv_den = get_pf_block_bytes(desc.color_spec) * get_pf_block_pixels(out_codec);
                                        memcpy(out->shifts, display_requested_rgb_shift,
                                                        3 * sizeof(int));
 
                                        out->decode_line = decode_line;
                                        out->src_linesize =
                                                vc_get_linesize(desc.width, desc.color_spec);
                                        out->dst_pitch =
                                                out->dst_linesize =
                                                vc_get_linesize(desc.width, out_codec);
                                }
                        }
                        decoder->merged_fb = false;
                }
        } else if (decoder->decoder_type == EXTERNAL_DECODER) {
                int buf_size;
 
                for(unsigned int i = 0; i < decoder->decompress_state.size(); ++i) {
                        buf_size = decompress_reconfigure(decoder->decompress_state.at(i), desc,
                                        display_requested_rgb_shift[0],
                                        display_requested_rgb_shift[1],
                                        display_requested_rgb_shift[2],
                                        decoder->pitch,
                                        out_codec == VIDEO_CODEC_END ? VIDEO_CODEC_NONE : out_codec);
                        if(!buf_size) {
                                return false;
                        }
                }
                decoder->merged_fb = display_mode != DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES;
                int res = 0, ret;
                size_t size = sizeof(res);
                ret = decompress_get_property(decoder->decompress_state.at(0),
                                DECOMPRESS_PROPERTY_ACCEPTS_CORRUPTED_FRAME,
                                &res, &size);
                decoder->accepts_corrupted_frame = ret && res;
        }
 
        // Pass metadata to receiver thread (it can tweak parameters)
        struct msg_receiver *msg = (struct msg_receiver *)
                new_message(sizeof(struct msg_receiver));
        msg->type = RECEIVER_MSG_VIDEO_PROP_CHANGED;
        msg->new_desc = decoder->received_vid_desc;
        struct response *resp =
                send_message_to_receiver(decoder->mod.parent, (struct message *) msg);
        free_response(resp);
 
        if (out_codec != VIDEO_CODEC_END) {
                decoder->frame = display_get_frame(decoder->display);
                assert(decoder->frame != nullptr);
        }
 
        return true;
}

References state_video_decoder::accepts_corrupted_frame, state_video_decoder::change_il, state_video_decoder::change_il_state, choose_codec_and_decoder(), cleanup(), codec_list_to_str(), video_desc::color_spec, debug_msg, state_video_decoder::decoder_type, decompress_get_property(), DECOMPRESS_PROPERTY_ACCEPTS_CORRUPTED_FRAME, decompress_reconfigure(), state_video_decoder::decompress_state, DEFAULT_RGB_SHIFT_INIT, desc, state_video_decoder::disp_supported_il, state_video_decoder::disp_supported_il_cnt, state_video_decoder::display, display_ctl_property(), state_video_decoder::display_desc, display_get_frame(), DISPLAY_PROPERTY_BUF_PITCH, DISPLAY_PROPERTY_RGB_SHIFT, DISPLAY_PROPERTY_VIDEO_MERGED, DISPLAY_PROPERTY_VIDEO_MODE, DISPLAY_PROPERTY_VIDEO_SEPARATE_3D, DISPLAY_PROPERTY_VIDEO_SEPARATE_TILES, display_put_frame(), display_reconfigure(), state_video_decoder::frame, free_response(), get_codec_name(), get_pf_block_bytes(), get_pf_block_pixels(), get_video_mode_tiles_x(), get_video_mode_tiles_y(), video_desc::height, video_desc::interlacing, len, state_video_decoder::line_decoder, LOG, LOG_LEVEL_ERROR, state_video_decoder::max_substreams, state_video_decoder::merged_fb, state_video_decoder::mod, state_video_decoder::native_codecs, new_message(), state_video_decoder::out_codec, module::parent, state_video_decoder::pitch, PITCH_DEFAULT, PROGRESSIVE, PUTF_DISCARD, state_video_decoder::received_vid_desc, RECEIVER_MSG_VIDEO_PROP_CHANGED, select_il_func(), send_message_to_receiver(), video_desc::tile_count, vc_get_linesize(), VIDEO_CODEC_END, VIDEO_CODEC_NONE, video_decoder_start_threads(), video_decoder_stop_threads(), video_desc_eq(), state_video_decoder::video_mode, VIDEO_NORMAL, and video_desc::width.

Referenced by reconfigure_helper().

Here is the call graph for this function:

reconfigure_helper()

static void reconfigure_helper ( struct state_video_decoder * decoder, struct video_desc network_desc, struct pixfmt_desc comp_int_desc )

static

Definition at line 1439 of file video_decoders.cpp.

{
        decoder->received_vid_desc = network_desc;
        decoder->received_int_desc = comp_int_desc;
 
        bool ret = reconfigure_decoder(decoder, decoder->received_vid_desc, comp_int_desc);
        if (!ret) {
                log_msg(LOG_LEVEL_ERROR, "[video dec.] Reconfiguration failed!!!\n");
                decoder->frame = NULL;
                decoder->out_codec = VIDEO_CODEC_NONE;
        }
}

References state_video_decoder::frame, LOG_LEVEL_ERROR, log_msg(), state_video_decoder::out_codec, state_video_decoder::received_int_desc, state_video_decoder::received_vid_desc, reconfigure_decoder(), and VIDEO_CODEC_NONE.

Referenced by check_for_mode_change(), decode_video_frame(), and reconfigure_if_needed().

Here is the call graph for this function:

reconfigure_if_needed()

static void reconfigure_if_needed ( struct state_video_decoder * decoder, struct video_desc network_desc, struct pixfmt_desc comp_int_desc )

static

Definition at line 1454 of file video_decoders.cpp.

{
        const bool desc_eq = video_desc_eq_excl_param(
            decoder->received_vid_desc, network_desc, PARAM_TILE_COUNT);
        const bool comp_int_eq =
            pixdesc_equals(decoder->received_int_desc, comp_int_desc);
        if (desc_eq && comp_int_eq) {
                return;
        }
        reconfigure_helper(decoder, network_desc, comp_int_desc);
}

References PARAM_TILE_COUNT, pixdesc_equals(), state_video_decoder::received_int_desc, state_video_decoder::received_vid_desc, reconfigure_helper(), and video_desc_eq_excl_param().

Referenced by decode_video_frame().

Here is the call graph for this function:

select_il_func()

static change_il_t select_il_func ( enum interlacing_t in_il, enum interlacing_t * supported, int il_out_cnt, enum interlacing_t * out_il )

static

This function finds interlacing mode changing function.

Parameters

[in]	in_il	input_interlacing
[in]	supported	list of supported output interlacing modes
[in]	il_out_cnt	count of supported items
[out]	out_il	selected output interlacing

Returns

selected interlacing changing function, NULL if not needed or not found

Definition at line 1161 of file video_decoders.cpp.

{
        struct transcode_t { enum interlacing_t in; enum interlacing_t out; change_il_t func; };
 
        struct transcode_t transcode[] = {
                {LOWER_FIELD_FIRST, INTERLACED_MERGED, il_lower_to_merged},
                {UPPER_FIELD_FIRST, INTERLACED_MERGED, il_upper_to_merged},
                {INTERLACED_MERGED, UPPER_FIELD_FIRST, il_merged_to_upper}
        };
 
        int i;
        /* first try to check if it can be nativelly displayed */
        for (i = 0; i < il_out_cnt; ++i) {
                if(in_il == supported[i]) {
                        *out_il = in_il;
                        return NULL;
                }
        }
 
        for (i = 0; i < il_out_cnt; ++i) {
                size_t j;
                for (j = 0; j < sizeof(transcode) / sizeof(struct transcode_t); ++j) {
                        if(in_il == transcode[j].in && supported[i] == transcode[j].out) {
                                *out_il = transcode[j].out;
                                return transcode[j].func;
                        }
                }
        }
 
        log_msg(LOG_LEVEL_WARNING, "[Warning] Cannot find transition between incoming and display "
                        "interlacing modes!\n");
        return NULL;
}

References il_lower_to_merged(), il_merged_to_upper(), il_upper_to_merged(), INTERLACED_MERGED, LOG_LEVEL_WARNING, log_msg(), LOWER_FIELD_FIRST, and UPPER_FIELD_FIRST.

Referenced by reconfigure_decoder().

Here is the call graph for this function:

sum_map()

static int sum_map ( map< int, int > const & m )

static

Definition at line 191 of file video_decoders.cpp.

                                            {
        int ret = 0;
        for (map<int, int>::const_iterator it = m.begin();
                        it != m.end(); ++it) {
                ret += it->second;
        }
        return ret;
}

Referenced by fec_thread().

video_decoder_init()

struct state_video_decoder * video_decoder_init	(	struct module *	parent,
		enum video_mode video_mode	,
		struct display *	display,
		const char *	encryption )

Initializes video decompress state.

Parameters

video_mode	video_mode expected to be received from network
display	Video display that is supposed to be controlled from decoder. display_get_frame(), display_put_frame(), display_get_propert() and display_reconfigure() functions may be used. If set to NULL, no decoding will take place.
encryption	Encryption config string. Currently, this is a passphrase to be used. This may change eventually.

Returns

Newly created decoder state. If an error occured, returns NULL.

Definition at line 761 of file video_decoders.cpp.

{
        struct state_video_decoder *s;
 
        s = new state_video_decoder(parent);
 
        if (strlen(encryption) > 0) {
                s->dec_funcs = static_cast<const struct openssl_decrypt_info *>(load_library("openssl_decrypt",
                                        LIBRARY_CLASS_UNDEFINED, OPENSSL_DECRYPT_ABI_VERSION));
                if (!s->dec_funcs) {
                                log_msg(LOG_LEVEL_FATAL, "UltraGrid was build without OpenSSL support!\n");
                                delete s;
                                return NULL;
                }
                if (s->dec_funcs->init(&s->decrypt, encryption) != 0) {
                        log_msg(LOG_LEVEL_FATAL, "Unable to create decompress!\n");
                        delete s;
                        return NULL;
                }
        }
 
        decoder_set_video_mode(s, video_mode);
 
        if(!video_decoder_register_display(s, display)) {
                delete s;
                return NULL;
        }
 
        return s;
}

References state_video_decoder::state_video_decoder(), state_video_decoder::dec_funcs, decoder_set_video_mode(), state_video_decoder::decrypt, openssl_decrypt_info::init, LIBRARY_CLASS_UNDEFINED, load_library(), LOG_LEVEL_FATAL, log_msg(), OPENSSL_DECRYPT_ABI_VERSION, parent, and video_decoder_register_display().

Referenced by ultragrid_rtp_video_rxtx::new_video_decoder().

Here is the call graph for this function:

video_decoder_order_output_codecs()

static vector< pair< struct pixfmt_desc, codec_t > > video_decoder_order_output_codecs ( struct pixfmt_desc comp_int_prop, vector< codec_t > const & display_codecs )

static

Reorders display codecs to match compression internal format.

First try to add HW-accelerated codecs, then exactly comp_int_fmt (if available) and then sort the rest - matching color-space first, higher bit depths first.

Always first try "native" than generic decoder (native is the one matching comp_int_fmt, generic should be catch-all allowing decompression of arbitrary compressed stream of received codec).

Definition at line 1005 of file video_decoders.cpp.

{
        vector<pair<struct pixfmt_desc, codec_t>> ret;
        set<codec_t> used;
        // first add hw-accelerated codecs
        for (auto codec : display_codecs) {
                if (codec_is_hw_accelerated(codec)) {
                        ret.emplace_back(comp_int_prop, codec);
                        if (comp_int_prop.depth != 0) {
                                ret.emplace_back(pixfmt_desc{}, codec);
                        }
                        used.insert(codec);
                }
        }
        // then codecs matching exactly internal codec
        for (auto codec : display_codecs) {
                if (used.find(codec) != used.end()) {
                        continue;
                };
                if (pixdesc_equals(get_pixfmt_desc(codec), comp_int_prop)) {
                        ret.emplace_back(comp_int_prop, codec);
                        if (comp_int_prop.depth != 0) {
                                ret.emplace_back(pixfmt_desc{}, codec);
                        }
                        used.insert(codec);
                }
        }
        // then add also all other codecs
        vector<codec_t> remaining;
        for (auto codec : display_codecs) {
                if (used.find(codec) != used.end()) {
                        continue;
                };
                remaining.emplace_back(codec);
        }
        if (comp_int_prop.depth != 0) {
                sort(remaining.begin(), remaining.end(), [comp_int_prop](const codec_t &a, const codec_t &b) {
                                struct pixfmt_desc desc_a = get_pixfmt_desc(a);
                                struct pixfmt_desc desc_b = get_pixfmt_desc(b);
                                return compare_pixdesc(&desc_a, &desc_b, &comp_int_prop) < 0;
                        });
        }
        for (auto & c : remaining) {
                ret.emplace_back(comp_int_prop, c);
                if (comp_int_prop.depth != 0) {
                        ret.emplace_back(pixfmt_desc{}, c);
                }
        }
 
        if (log_level >= LOG_LEVEL_VERBOSE) {
                LOG(LOG_LEVEL_VERBOSE) << "Trying codecs in this order:\n";
                for (auto it = ret.begin(); it != ret.end(); ++it) {
                        LOG(LOG_LEVEL_VERBOSE) << "\t" << get_codec_name((*it).second) << ", internal: " << get_pixdesc_desc((*it).first) << "\n";
                }
        }
 
        return ret;
}

References codec_is_hw_accelerated(), pixfmt_desc::depth, get_codec_name(), get_pixdesc_desc(), get_pixfmt_desc(), LOG, log_level, LOG_LEVEL_VERBOSE, and pixdesc_equals().

Referenced by choose_codec_and_decoder().

Here is the call graph for this function:

video_decoder_start_threads()

static void video_decoder_start_threads ( struct state_video_decoder * decoder )

static

starts decompress and ldmg threads

Called from video_decoder_register_display(). It is also called after video_decoder_stop_threads() in reconfiguration.

Invariant

decoder->display != NULL

Definition at line 803 of file video_decoders.cpp.

{
        assert(decoder->display); // we want to run threads only if decoder is active
 
        decoder->decompress_thread_id = thread(decompress_thread, decoder);
        decoder->fec_thread_id = thread(fec_thread, decoder);
}

References decompress_thread(), state_video_decoder::decompress_thread_id, state_video_decoder::display, fec_thread(), and state_video_decoder::fec_thread_id.

Referenced by reconfigure_decoder(), and video_decoder_register_display().

Here is the call graph for this function:

video_decoder_stop_threads()

static void video_decoder_stop_threads ( struct state_video_decoder * decoder )

static

This function stops running threads.

Invariant

decoder->display != NULL

Definition at line 817 of file video_decoders.cpp.

{
        assert(decoder->display);
 
        unique_ptr<frame_msg> msg(new frame_msg(decoder->control, decoder->stats));
        decoder->fec_queue.push(std::move(msg));
 
        decoder->fec_thread_id.join();
        decoder->decompress_thread_id.join();
}

References state_video_decoder::control, state_video_decoder::decompress_thread_id, state_video_decoder::display, state_video_decoder::fec_queue, state_video_decoder::fec_thread_id, msg, synchronized_queue< T, max_len >::push(), and state_video_decoder::stats.

Referenced by reconfigure_decoder(), and video_decoder_remove_display().

Here is the call graph for this function:

wait_for_framebuffer_swap()

static void wait_for_framebuffer_swap ( struct state_video_decoder * decoder )

static

This function blocks until video frame is displayed and decoder::frame can be filled with new data. Until this point, the video frame is not considered valid.

Definition at line 406 of file video_decoders.cpp.

                                                                           {
        unique_lock<mutex> lk(decoder->lock);
        decoder->buffer_swapped_cv.wait(lk, [decoder]{return decoder->buffer_swapped;});
}

References state_video_decoder::buffer_swapped, state_video_decoder::buffer_swapped_cv, and state_video_decoder::lock.

Referenced by decode_video_frame(), and fec_thread().

Variable Documentation

PADDING

int PADDING = MAX_PADDING

constexpr

Definition at line 146 of file video_decoders.cpp.

Referenced by decode_video_frame(), and decompress_thread().