Video Decoder

Files
file	video_decoders.cpp
file	video_decoders.h
	Video RTP decoder.

Functions
int	decode_video_frame (struct coded_data *received_data, void *decoder_data, struct pbuf_stats *stats)
	Decodes a participant buffer representing one video frame.
bool	parse_video_hdr (const uint32_t *hdr, struct video_desc *desc)
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, struct display *display, const char *encryption)
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.

Detailed Description

Function Documentation

decode_video_frame()

int decode_video_frame	(	struct coded_data *	cdata,
		void *	decoder_data,
		struct pbuf_stats *	stats )

Decodes a participant buffer representing one video frame.

Parameters

cdata	PBUF buffer
decoder_data	vcodec_state containing decoder state and some additional data

Return values

true	if decoding was successful. It stil doesn't mean that the frame will be correctly displayed, decoding may fail in some subsequent (asynchronous) steps.
false	if decoding failed

Zero missing parts of framebuffer - this may be useful for compressed video (which may be also with FEC - but we use systematic codes therefore it may benefit from that as well).

Definition at line 1502 of file video_decoders.cpp.

{
        struct vcodec_state *pbuf_data = (struct vcodec_state *) decoder_data;
        struct state_video_decoder *decoder = pbuf_data->decoder;
 
        bool ret = true;
        int prints=0;
        int max_substreams = decoder->max_substreams;
 
        vector<uint32_t> buffer_num(max_substreams);
        // the following is just FEC related optimalization - normally we fill up
        // allocated buffers when we have compressed data. But in case of FEC, there
        // is just the FEC buffer present, so we point to it instead to copying
        struct video_frame *frame = vf_alloc(max_substreams);
        frame->callbacks.data_deleter = vf_data_deleter;
        unique_ptr<map<int, int>[]> pckt_list(new map<int, int>[max_substreams]);
 
        int buffer_number = 0;
        bool buffer_swapped = false;
 
        // We have no framebuffer assigned, exitting
        if(!decoder->display) {
                vf_free(frame);
                return false;
        }
 
        main_msg_reconfigure *msg_reconf;
        while ((msg_reconf = decoder->msg_queue.pop(true /* nonblock */))) {
                if (msg_reconf->force) {
                        reconfigure_helper(decoder, msg_reconf->desc,
                                           msg_reconf->compress_internal_prop);
                        log_msg(LOG_LEVEL_VERBOSE, "forced reconf\n");
                } else {
                        reconfigure_if_needed(
                            decoder, msg_reconf->desc,
                            msg_reconf->compress_internal_prop);
                }
                if (msg_reconf->last_frame) {
                        decoder->fec_queue.push(std::move(msg_reconf->last_frame));
                }
                delete msg_reconf;
        }
 
        frame->ssrc = cdata->data->ssrc;
        frame->timestamp = cdata->data->ts;
        int pt = cdata->data->pt;
        if (PT_VIDEO_HAS_FEC(pt)) {
                const uint32_t *hdr = (uint32_t *)(void *)cdata->data->data;
                const uint32_t tmp = ntohl(hdr[3]);
                const int k = tmp >> 19;
                const int m = 0x1fff & (tmp >> 6);
                const int c = 0x3f & tmp;
                const int seed = ntohl(hdr[4]);
                frame->fec_params =
                    fec_desc(fec::fec_type_from_pt(pt), k, m, c, seed);
        }
 
        while (cdata != NULL) {
                int len;
                const char *data;
                rtp_packet *pckt = cdata->data;
                enum openssl_mode crypto_mode = MODE_AES128_NONE;
 
                pt = pckt->pt;
                const uint32_t *hdr = (uint32_t *)(void *) pckt->data;
                const uint32_t data_pos = ntohl(hdr[1]);
                uint32_t tmp = ntohl(hdr[0]);
                const uint32_t substream = tmp >> 22;
                buffer_number = tmp & 0x3fffff;
                const int buffer_length = ntohl(hdr[2]);
 
                if (PT_VIDEO_IS_ENCRYPTED(pt)) {
                        if(!decoder->decrypt) {
                                log_msg(LOG_LEVEL_ERROR, ENCRYPTED_ERR);
                                ERROR_GOTO_CLEANUP
                        }
                } else {
                        if(decoder->decrypt) {
                                log_msg(LOG_LEVEL_ERROR, NOT_ENCRYPTED_ERR);
                                ERROR_GOTO_CLEANUP
                        }
                }
 
                switch (pt) {
                case PT_VIDEO:
                        len = pckt->data_len - sizeof(video_payload_hdr_t);
                        data = (const char *) hdr + sizeof(video_payload_hdr_t);
                        break;
                case PT_VIDEO_RS:
                case PT_VIDEO_LDGM:
                        len = pckt->data_len - sizeof(fec_payload_hdr_t);
                        data = (const char *) hdr + sizeof(fec_payload_hdr_t);
                        break;
                case PT_ENCRYPT_VIDEO:
                case PT_ENCRYPT_VIDEO_LDGM:
                case PT_ENCRYPT_VIDEO_RS:
                        {
                                size_t media_hdr_len = pt == PT_ENCRYPT_VIDEO ? sizeof(video_payload_hdr_t) : sizeof(fec_payload_hdr_t);
                                len = pckt->data_len - sizeof(crypto_payload_hdr_t) - media_hdr_len;
                                data = (const char *)hdr + sizeof(crypto_payload_hdr_t) + media_hdr_len;
                                uint32_t crypto_hdr = ntohl(*(const uint32_t *)(const void *)((const char *)hdr + media_hdr_len));
                                crypto_mode = (enum openssl_mode) (crypto_hdr >> 24);
                                if (crypto_mode == MODE_AES128_NONE || crypto_mode > MODE_AES128_MAX) {
                                        log_msg(LOG_LEVEL_WARNING, "Unknown cipher mode: %d\n", (int) crypto_mode);
                                        ret = false;
                                        goto cleanup;
                                }
                        }
                        break;
                default:
                        if (pt == PT_Unassign_Type95) {
                                log_msg_once(LOG_LEVEL_WARNING, to_fourcc('U', 'V', 'P', 'T'), MOD_NAME "Unassigned PT 95 received, ignoring.\n");
                        } else {
                                LOG(LOG_LEVEL_WARNING) << MOD_NAME "Unknown packet type: " << pckt->pt << ".\n";
                        }
                        ret = false;
                        goto cleanup;
                }
 
                if ((int) substream >= max_substreams) {
                        log_msg(LOG_LEVEL_WARNING, "[decoder] received substream ID %d. Expecting at most %d substreams. Did you set -M option?\n",
                                        substream, max_substreams);
                        // the guess is valid - we start with highest substream number (anytime - since it holds a m-bit)
                        // in next iterations, index is valid
                        enum video_mode video_mode =
                                guess_video_mode(substream + 1);
                        if (video_mode != VIDEO_UNKNOWN) {
                                log_msg(LOG_LEVEL_NOTICE, "[decoder] Guessing mode: ");
                                decoder_set_video_mode(decoder, video_mode);
                                decoder->received_vid_desc.width = 0; // just for sure, that we reconfigure in next iteration
                                log_msg(LOG_LEVEL_NOTICE, "%s. Check if it is correct.\n", get_video_mode_description(decoder->video_mode));
                        } else {
                                log_msg(LOG_LEVEL_FATAL, "[decoder] Unknown video mode!\n");
                                handle_error(1);
                        }
                        // we need skip this frame (variables are illegal in this iteration
                        // and in case that we got unrecognized number of substreams - exit
                        ret = false;
                        goto cleanup;
                }
 
                char plaintext[RTP_MAX_PACKET_LEN]; // will be actually shorter
                if (PT_VIDEO_IS_ENCRYPTED(pt)) {
                        int data_len;
 
                        if((data_len = decoder->dec_funcs->decrypt(decoder->decrypt,
                                        data, len,
                                        (const char *) hdr, pt == PT_ENCRYPT_VIDEO ?
                                        sizeof(video_payload_hdr_t) : sizeof(fec_payload_hdr_t),
                                        plaintext, crypto_mode)) == 0) {
                                goto next_packet;
                        }
                        data = (char *) plaintext;
                        len = data_len;
                }
 
                if (!PT_VIDEO_HAS_FEC(pt))
                {
                        /* Critical section
                         * each thread *MUST* wait here if this condition is true
                         */
                        check_for_mode_change(decoder, hdr);
 
                        // hereafter, display framebuffer can be used, so we
                        // check if we got it
                        if (FRAMEBUFFER_NOT_READY(decoder)) {
                                vf_free(frame);
                                return false;
                        }
                }
 
                buffer_num[substream] = buffer_number;
                frame->tiles[substream].data_len = buffer_length;
                pckt_list[substream][data_pos] = len;
 
                if ((pt == PT_VIDEO || pt == PT_ENCRYPT_VIDEO) && decoder->decoder_type == LINE_DECODER) {
                        struct tile *tile = NULL;
                        if(!buffer_swapped) {
                                wait_for_framebuffer_swap(decoder);
                                buffer_swapped = true;
                                unique_lock<mutex> lk(decoder->lock);
                                decoder->buffer_swapped = false;
                        }
 
                        if (!decoder->merged_fb) {
                                tile = vf_get_tile(decoder->frame, substream);
                        } else {
                                tile = vf_get_tile(decoder->frame, 0);
                        }
 
                        struct line_decoder *line_decoder =
                                &decoder->line_decoder[substream];
 
                        /* End of critical section */
 
                        /* MAGIC, don't touch it, you definitely break it
                         *  *source* is data from network, *destination* is frame buffer
                         */
 
                        /* compute Y pos in source frame and convert it to
                         * byte offset in the destination frame
                         */
                        int y = (data_pos / line_decoder->src_linesize) * line_decoder->dst_pitch;
 
                        /* compute X pos in source frame */
                        int s_x = data_pos % line_decoder->src_linesize;
 
                        /* convert X pos from source frame into the destination frame.
                         * it is byte offset from the beginning of a line.
                         */
                        int d_x = s_x * line_decoder->conv_num / line_decoder->conv_den;
 
                        /* pointer to data payload in packet */
                        auto *source = (const unsigned char *)(data);
 
                        /* copy whole packet that can span several lines.
                         * we need to clip data (v210 case) or center data (RGBA, R10k cases)
                         */
                        while (len > 0) {
                                /* len id payload length in source BPP
                                 * decoder needs len in destination BPP, so convert it
                                 */
                                int l = len * line_decoder->conv_num / line_decoder->conv_den;
 
                                /* do not copy multiple lines, we need to
                                 * copy (& clip, center) line by line
                                 */
                                if (l + d_x > (int) line_decoder->dst_linesize) {
                                        l = line_decoder->dst_linesize - d_x;
                                }
 
                                /* compute byte offset in destination frame */
                                const uint32_t offset = y + d_x;
 
                                /* watch the SEGV */
                                if (l + line_decoder->base_offset + offset <= tile->data_len) {
                                        /*decode frame:
                                         * we have offset for destination
                                         * we update source contiguously
                                         * we pass {r,g,b}shifts */
                                        line_decoder->decode_line((unsigned char*)tile->data + line_decoder->base_offset + offset, source, l,
                                                        line_decoder->shifts[0], line_decoder->shifts[1],
                                                        line_decoder->shifts[2]);
                                        /* we decoded one line (or a part of one line) to the end of the line
                                         * so decrease *source* len by 1 line (or that part of the line */
                                        len -= line_decoder->src_linesize - s_x;
                                        /* jump in source by the same amount */
                                        source += line_decoder->src_linesize - s_x;
                                } else {
                                        /* this should not ever happen as we call reconfigure before each packet
                                         * iff reconfigure is needed. But if it still happens, something is terribly wrong
                                         * say it loudly
                                         */
                                        if((prints % 100) == 0) {
                                                log_msg(LOG_LEVEL_ERROR, "WARNING!! Discarding input data as frame buffer is too small.\n"
                                                                "Well this should not happened. Expect troubles pretty soon.\n");
                                        }
                                        prints++;
                                        len = 0;
                                }
                                /* each new line continues from the beginning */
                                d_x = 0;        /* next line from beginning */
                                s_x = 0;
                                y += line_decoder->dst_pitch;  /* next line */
                        }
                } else { /* PT_VIDEO_LDGM or external decoder */
                        if(!frame->tiles[substream].data) {
                                frame->tiles[substream].data = (char *) malloc(buffer_length + PADDING);
                        }
 
                        if (data_pos + len > (unsigned) buffer_length) {
                                if((prints % 100) == 0) {
                                        log_msg(LOG_LEVEL_ERROR, "WARNING!! Discarding input data as frame buffer is too small.\n"
                                                        "Well this should not happened. Expect troubles pretty soon.\n");
                                }
                                prints++;
                                len = max<int>(0, buffer_length - data_pos);
                        }
                        memcpy(frame->tiles[substream].data + data_pos,
                               (const unsigned char *)data, len);
                }
 
next_packet:
                cdata = cdata->nxt;
        }
 
        if (FRAMEBUFFER_NOT_READY(decoder) && (pt == PT_VIDEO || pt == PT_ENCRYPT_VIDEO)) {
                ret = false;
                goto cleanup;
        }
 
        assert(ret);
 
        if (decoder->decoder_type != LINE_DECODER) {
                for(int i = 0; i < max_substreams; ++i) {
                        unsigned int last_end = 0;
                        for (auto const & packets : pckt_list[i]) {
                                unsigned int start = packets.first;
                                unsigned int len = packets.second;
                                if (last_end < start) {
                                        memset(frame->tiles[i].data + last_end, 0, start - last_end);
                                }
                                last_end = start + len;
                        }
                        if (last_end < frame->tiles[i].data_len) {
                                memset(frame->tiles[i].data + last_end, 0, frame->tiles[i].data_len - last_end);
                        }
                }
        }
 
        {
                unsigned int frame_size = 0;
                for (int i = 0; i < max_substreams; ++i) {
                        frame_size += frame->tiles[i].data_len;
                }
                pbuf_data->max_frame_size =
                    max(pbuf_data->max_frame_size, frame_size);
                // format message
                unique_ptr <frame_msg> fec_msg (new frame_msg(decoder->control, decoder->stats));
                fec_msg->buffer_num = std::move(buffer_num);
                fec_msg->recv_frame = frame;
                frame = NULL;
                fec_msg->pckt_list = std::move(pckt_list);
                fec_msg->received_pkts_cum = stats->received_pkts_cum;
                fec_msg->expected_pkts_cum = stats->expected_pkts_cum;
 
                auto t0 = std::chrono::high_resolution_clock::now();
                decoder->fec_queue.push(std::move(fec_msg));
                auto t1 = std::chrono::high_resolution_clock::now();
                double tpf = 1.0 / decoder->display_desc.fps;
                if (std::chrono::duration_cast<std::chrono::duration<double>>(t1 - t0).count() > tpf && decoder->stats.displayed > 20) {
                        decoder->slow_msg.print("Your computer may be too SLOW to play this !!!\n");
                }
 
        }
cleanup:
        ;
        if (ret) {
                vf_free(frame);
        }
        pbuf_data->decoded++;
 
        decoder->stats.update(buffer_number);
 
        return ret;
}

References state_video_decoder::buffer_swapped, video_frame::callbacks, check_for_mode_change(), cleanup(), state_video_decoder::control, count, coded_data::data, tile::data, video_frame_callbacks::data_deleter, tile::data_len, state_video_decoder::dec_funcs, vcodec_state::decoded, vcodec_state::decoder, decoder_set_video_mode(), state_video_decoder::decoder_type, openssl_decrypt_info::decrypt, state_video_decoder::decrypt, state_video_decoder::display, state_video_decoder::display_desc, ENCRYPTED_ERR, ERROR_GOTO_CLEANUP, pbuf_stats::expected_pkts_cum, video_frame::fec_params, state_video_decoder::fec_queue, fec::fec_type_from_pt(), video_desc::fps, frame, state_video_decoder::frame, FRAMEBUFFER_NOT_READY, get_video_mode_description(), guess_video_mode(), handle_error(), len, state_video_decoder::line_decoder, state_video_decoder::lock, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_FATAL, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), log_msg_once(), max, vcodec_state::max_frame_size, state_video_decoder::max_substreams, state_video_decoder::merged_fb, MOD_NAME, MODE_AES128_MAX, MODE_AES128_NONE, state_video_decoder::msg_queue, NOT_ENCRYPTED_ERR, coded_data::nxt, offset, PADDING, synchronized_queue< T, max_len >::pop(), timed_message< log_level >::print(), PT_ENCRYPT_VIDEO, PT_ENCRYPT_VIDEO_LDGM, PT_ENCRYPT_VIDEO_RS, PT_Unassign_Type95, PT_VIDEO, PT_VIDEO_HAS_FEC, PT_VIDEO_IS_ENCRYPTED, PT_VIDEO_LDGM, PT_VIDEO_RS, synchronized_queue< T, max_len >::push(), pbuf_stats::received_pkts_cum, state_video_decoder::received_vid_desc, reconfigure_helper(), reconfigure_if_needed(), RTP_MAX_PACKET_LEN, rtp_packet, state_video_decoder::slow_msg, video_frame::ssrc, start(), state_video_decoder::stats, video_frame::tiles, video_frame::timestamp, to_fourcc, vf_alloc(), vf_data_deleter(), vf_free(), vf_get_tile(), state_video_decoder::video_mode, VIDEO_UNKNOWN, wait_for_framebuffer_swap(), and video_desc::width.

Referenced by ultragrid_rtp_video_rxtx::receiver_loop().

Here is the call graph for this function:

parse_video_hdr()

bool parse_video_hdr	(	const uint32_t *	hdr,
		struct video_desc *	desc )

Definition at line 1405 of file video_decoders.cpp.

{
        uint32_t tmp;
        int fps_pt, fpsd, fd, fi;
 
        tmp = ntohl(hdr[0]);
        desc->tile_count = (tmp >> 22) + 1; // a bit hacky - assuming this packet is from last substream
 
        desc->width = ntohl(hdr[3]) >> 16;
        desc->height = ntohl(hdr[3]) & 0xffff;
        desc->color_spec = get_codec_from_fcc(hdr[4]);
        if(desc->color_spec == VIDEO_CODEC_NONE) {
                log_msg(LOG_LEVEL_ERROR, "Unknown FourCC \"%.4s\"!\n",
                        (const char *)&hdr[4]);
                return false;
        }
 
        tmp = ntohl(hdr[5]);
        desc->interlacing = (enum interlacing_t) (tmp >> 29);
        fps_pt = (tmp >> 19) & 0x3ff;
        fpsd = (tmp >> 15) & 0xf;
        fd = (tmp >> 14) & 0x1;
        fi = (tmp >> 13) & 0x1;
 
        desc->fps = compute_fps(fps_pt, fpsd, fd, fi);
 
        if (desc->fps == -1) {
                log_msg_once(LOG_LEVEL_WARNING, to_fourcc('U', 'F', 'P', 'S'), MOD_NAME "Unsupported FPS received (newer UG?), setting to 30.\n");
                desc->fps = 30.0;
        }
 
        return true;
}

References video_desc::color_spec, compute_fps(), desc, video_desc::fps, get_codec_from_fcc(), video_desc::height, video_desc::interlacing, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), log_msg_once(), MOD_NAME, video_desc::tile_count, to_fourcc, VIDEO_CODEC_NONE, and video_desc::width.

Referenced by check_for_mode_change(), decode_yuri_video_frame(), and fec_thread().

Here is the call graph for this function:

video_decoder_destroy()

void video_decoder_destroy

(

struct state_video_decoder *

decoder

)

Destroys decoder created with decoder_init()

Parameters

decoder

decoder to be destroyed. If NULL, no action is performed.

Definition at line 976 of file video_decoders.cpp.

{
        if(!decoder)
                return;
 
        if (decoder->dec_funcs) {
                decoder->dec_funcs->destroy(decoder->decrypt);
        }
 
        video_decoder_remove_display(decoder);
 
        cleanup(decoder);
 
        free(decoder->disp_supported_il);
 
        delete decoder;
}

References cleanup(), state_video_decoder::dec_funcs, state_video_decoder::decrypt, openssl_decrypt_info::destroy, state_video_decoder::disp_supported_il, and video_decoder_remove_display().

Referenced by ultragrid_rtp_video_rxtx::destroy_video_decoder().

Here is the call graph for this function:

video_decoder_init()

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

video_decoder_register_display()

bool video_decoder_register_display	(	struct state_video_decoder *	decoder,
		struct display *	display )

Registers video display to be used for displaying decoded video frames.

No display should be managed by this decoder when this function is called.

See also

decoder_remove_display

Parameters

decoder	decoder state
display	new display to be registered

Returns

whether registration was successful

Definition at line 859 of file video_decoders.cpp.

{
        assert(display != NULL);
        assert(decoder->display == NULL);
 
        int ret;
 
        decoder->display = display;
 
        codec_t native_codecs[VIDEO_CODEC_COUNT];
        size_t len = sizeof native_codecs;
        ret = display_ctl_property(decoder->display, DISPLAY_PROPERTY_CODECS, native_codecs, &len);
        decoder->native_codecs.clear();
        if (!ret) {
                log_msg(LOG_LEVEL_ERROR, "Failed to query codecs from video display.\n");
        } else {
                for (size_t i = 0; i < len / sizeof(codec_t); ++i) {
                        decoder->native_codecs.push_back(native_codecs[i]);
                }
        }
        if (get_commandline_param("decoder-use-codec")) {
                const char *codec_str = get_commandline_param("decoder-use-codec");
                bool blacklist_codec = false;
                if (codec_str[0] == '!') {
                        blacklist_codec = true;
                        codec_str += 1;
                }
                codec_t req_codec = get_codec_from_name(codec_str);
                if ("help"s == codec_str) {
                        LOG(LOG_LEVEL_NOTICE) << MOD_NAME << "Supported codecs for current display are: " << codec_list_to_str(decoder->native_codecs) << "\n";
                        return false;
                }
                if (req_codec == VIDEO_CODEC_NONE) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Wrong decoder codec spec: %s.\n", codec_str);
                        LOG(LOG_LEVEL_INFO) << MOD_NAME << "Supported codecs for current display are: " << codec_list_to_str(decoder->native_codecs) << "\n";
                        return false;
                }
                if (blacklist_codec) {
                        auto to_erase = find(decoder->native_codecs.begin(),
                                             decoder->native_codecs.end(),
                                             req_codec);
                        if (to_erase != decoder->native_codecs.end()) {
                                decoder->native_codecs.erase(to_erase);
                        }
                } else if (find(decoder->native_codecs.begin(),
                                decoder->native_codecs.end(),
                                req_codec) != end(decoder->native_codecs)) {
                        decoder->native_codecs.clear();
                        decoder->native_codecs.push_back(req_codec);
                } else {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Display doesn't support requested codec: %s.\n", codec_str);
                        LOG(LOG_LEVEL_INFO) << MOD_NAME << "Supported codecs for current display are: " << codec_list_to_str(decoder->native_codecs) << "\n";
                        return false;
                }
        }
 
        free(decoder->disp_supported_il);
        decoder->disp_supported_il_cnt = 20 * sizeof(enum interlacing_t);
        decoder->disp_supported_il = (enum interlacing_t*) calloc(decoder->disp_supported_il_cnt,
                        sizeof(enum interlacing_t));
        ret = display_ctl_property(decoder->display, DISPLAY_PROPERTY_SUPPORTED_IL_MODES, decoder->disp_supported_il, &decoder->disp_supported_il_cnt);
        if(ret) {
                decoder->disp_supported_il_cnt /= sizeof(enum interlacing_t);
        } else {
                enum interlacing_t tmp[] = { PROGRESSIVE, INTERLACED_MERGED, SEGMENTED_FRAME}; /* default if not said othervise */
                memcpy(decoder->disp_supported_il, tmp, sizeof(tmp));
                decoder->disp_supported_il_cnt = sizeof(tmp) / sizeof(enum interlacing_t);
        }
 
        video_decoder_start_threads(decoder);
 
        return true;
}

References codec_list_to_str(), state_video_decoder::disp_supported_il, state_video_decoder::disp_supported_il_cnt, state_video_decoder::display, display_ctl_property(), DISPLAY_PROPERTY_CODECS, DISPLAY_PROPERTY_SUPPORTED_IL_MODES, get_codec_from_name(), get_commandline_param(), INTERLACED_MERGED, len, LOG, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE, log_msg(), MOD_NAME, state_video_decoder::native_codecs, PROGRESSIVE, SEGMENTED_FRAME, VIDEO_CODEC_COUNT, VIDEO_CODEC_NONE, and video_decoder_start_threads().

Referenced by video_decoder_init().

Here is the call graph for this function:

video_decoder_remove_display()

void video_decoder_remove_display

(

struct state_video_decoder *

decoder

)

This removes display from current decoder.

From now on, no video frames will be decoded with current decoder.

See also

decoder_register_display - the counterpart of this functon

Parameters

decoder

decoder from which will the decoder be removed

Definition at line 941 of file video_decoders.cpp.

{
        if (decoder->display) {
                video_decoder_stop_threads(decoder);
                if (decoder->frame) {
                        display_put_frame(decoder->display, decoder->frame, PUTF_DISCARD);
                        decoder->frame = NULL;
                }
                decoder->display = NULL;
                memset(&decoder->display_desc, 0, sizeof(decoder->display_desc));
        }
}

References state_video_decoder::display, state_video_decoder::display_desc, display_put_frame(), state_video_decoder::frame, PUTF_DISCARD, and video_decoder_stop_threads().

Referenced by ultragrid_rtp_video_rxtx::remove_display_from_decoders(), and video_decoder_destroy().

Here is the call graph for this function: