libavcodec.c File Reference

#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "libavcodec/from_lavc_vid_conv.h"
#include "libavcodec/lavc_common.h"
#include "libavcodec/lavc_video.h"
#include "rtp/rtpdec_h264.h"
#include "rtp/rtpenc_h264.h"
#include "tv.h"
#include "utils/macros.h"
#include "video.h"
#include "video_codec.h"
#include "video_decompress.h"
#include "hwaccel_libav_common.h"
#include "hwaccel_vaapi.h"
#include "hwaccel_vdpau.h"
#include "hwaccel_videotoolbox.h"

Include dependency graph for libavcodec.c:

Go to the source code of this file.

Classes
struct	decoder_info
struct	state_libavcodec_decompress
struct	state_libavcodec_decompress::state_libavcodec_decompress_sws

Macros
#define	MOD_NAME   "[lavd] "
#define	SELECT_PIXFMT(pixfmt)

Enumerations
enum	{ MAX_PREFERED = 10 , MAX_DECODERS = MAX_PREFERED + 1 + 1 , DEC_LEN = MAX_DECODERS + 1 }

Functions
	ADD_TO_PARAM ("force-lavd-decoder", "* force-lavd-decoder=<decoder>[:<decoder2>...]\n" " Forces specified Libavcodec decoder. If more need to be specified, use colon as a delimiter.\n" " Use '-c libavcodec:help' to see available decoders.\n")
	ADD_TO_PARAM ("lavd-accept-corrupted", "* lavd-accept-corrupted[=no]\n" " Pass corrupted frames to decoder. If decoder isn't error-resilient,\n" " may crash! Use \"no\" to disable even if enabled by default.\n")
	ADD_TO_PARAM ("lavd-thread-count", "* lavd-thread-count=<thread_count>[F][S][n][d]\n" " Use <thread_count> decoding threads (0 is usually auto).\n" " Flag 'F' enables frame parallelism (disabled by default), 'S' slice based, can be both (default slice), 'n' for none; 'd' - disable low delay\n")
	ADD_TO_PARAM ("use-hw-accel", "* use-hw-accel[=<api>|help]\n" " Try to use hardware accelerated decoding with lavd " "(NVDEC/VAAPI/VDPAU/VideoToolbox).\n" " Optionally with enforced API option.\n")
static void	change_pixfmt (AVFrame *frame, unsigned char *dst, av_to_uv_convert_t *convert, codec_t out_codec, int width, int height, int pitch, int rgb_shift[static restrict 3], struct state_libavcodec_decompress_sws *sws)
static int	check_av_opt_set (void *state, const char *key, const char *val)
static void	check_duration (struct state_libavcodec_decompress *s, double duration_total_sec, double duration_pixfmt_change_sec)
	print hint to improve performance if not making it
static _Bool	check_first_sps_vps (struct state_libavcodec_decompress *s, unsigned char *src, unsigned int src_len)
static bool	configure_with (struct state_libavcodec_decompress *s, struct video_desc desc, void *extradata, int extradata_size)
static bool	decode_frame (struct state_libavcodec_decompress *s, unsigned char *src, int src_len)
static void	deconfigure (struct state_libavcodec_decompress *s)
static int	drm_prime_init (struct AVCodecContext *s, struct hw_accel_state *state, codec_t out_codec)
static enum AVPixelFormat	get_format_callback (struct AVCodecContext *s, const enum AVPixelFormat *fmt)
static bool	get_usable_decoders (enum AVCodecID avcodec_id, const char *const preferred_decoders[static MAX_PREFERED+1], const AVCodec *usable_decoders[static DEC_LEN])
static void	handle_lavd_error (const char *prefix, struct state_libavcodec_decompress *s, int ret)
static void	jpeg_callback (void)
static decompress_status	libavcodec_decompress (void *state, unsigned char *dst, unsigned char *src, unsigned int src_len, int frame_seq, struct video_frame_callbacks *callbacks, struct pixfmt_desc *internal_props)
static void	libavcodec_decompress_done (void *state)
static int	libavcodec_decompress_get_priority (codec_t compression, struct pixfmt_desc internal, codec_t ugc)
static int	libavcodec_decompress_get_property (void *state, int property, void *val, size_t *len)
static void *	libavcodec_decompress_init (void)
static int	libavcodec_decompress_reconfigure (void *state, struct video_desc desc, int rshift, int gshift, int bshift, int pitch, codec_t out_codec)
static bool	read_forced_pixfmt (codec_t compress, const unsigned char *src, unsigned int src_len, struct pixfmt_desc *internal_props)
static _Bool	reconfigure_convert_if_needed (struct state_libavcodec_decompress *s, enum AVPixelFormat av_codec, codec_t out_codec, int width, int height)
	REGISTER_MODULE (libavcodec, &libavcodec_info, LIBRARY_CLASS_VIDEO_DECOMPRESS, VIDEO_DECOMPRESS_ABI_VERSION)
static void	set_codec_context_params (struct state_libavcodec_decompress *s)
static bool	validate_hwacc_param (void)

Variables
static const struct decoder_info	decoders []
static const struct video_decompress_info	libavcodec_info

Detailed Description

Author

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

Definition in file libavcodec.c.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[lavd] "

Definition at line 70 of file libavcodec.c.

SELECT_PIXFMT

#define SELECT_PIXFMT

(

pixfmt

)

Value:

{ log_msg(LOG_LEVEL_INFO, MOD_NAME "Selected pixel format: %s\n", av_get_pix_fmt_name(pixfmt)); return pixfmt; }

Referenced by get_format_callback().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MAX_PREFERED
MAX_DECODERS	user forced + default
DEC_LEN	terminating NULL

Definition at line 215 of file libavcodec.c.

     {
        MAX_PREFERED = 10,
        MAX_DECODERS = MAX_PREFERED + 1 + 1, 
        DEC_LEN      = MAX_DECODERS + 1,     
};

Function Documentation

ADD_TO_PARAM() [1/4]

ADD_TO_PARAM	(	"force-lavd-decoder"	,
		"* force-lavd-	decoder = <decoder>[:<decoder2>...]\n" "  Forces specified Libavcodec decoder. If more need to be specified,
		use colon as a delimiter.\n" " Use '-c libavcodec:help' to see available decoders.\n"	)

ADD_TO_PARAM() [2/4]

ADD_TO_PARAM	(	"lavd-accept-corrupted"	,
		"* lavd-accept-corrupted\n" " Pass corrupted frames to decoder. If decoder isn't error-	resilient[=no],
		\n" " may crash! Use \"no\" to disable even if enabled by default.\n"	)

ADD_TO_PARAM() [3/4]

ADD_TO_PARAM	(	"lavd-thread-count"	,
		"* lavd-thread-	count = <thread_count>[F][S][n][d]\n" "  Use <thread_count> decoding threads (0 is usually auto).\n" "  Flag 'F' enables frame parallelism (disabled by default),
		'S' slice	based,
		can be	bothdefault slice,
		'n' for none; 'd' - disable low delay\n"	)

ADD_TO_PARAM() [4/4]

ADD_TO_PARAM	(	"use-hw-accel"	,
		"* use-hw-accel\n" " Try to use hardware accelerated decoding with lavd " "(NVDEC/VAAPI/VDPAU/VideoToolbox).\n" " Optionally with enforced API option.\n"	[=< api >|help] )

change_pixfmt()

static void change_pixfmt ( AVFrame * frame, unsigned char * dst, av_to_uv_convert_t * convert, codec_t out_codec, int width, int height, int pitch, int rgb_shift[static restrict 3], struct state_libavcodec_decompress_sws * sws )

static

Changes pixel format from frame to native

Todo

figure out color space transformations - eg. JPEG returns full-scale YUV. And not in the ITU-T Rec. 701 (eventually Rec. 609) scale.

Parameters

frame	video frame returned from libavcodec decompress
dst	destination buffer where data will be stored
av_codec	libav pixel format
out_codec	requested output codec
width	frame width
height	frame height

Definition at line 823 of file libavcodec.c.

{
        debug_file_dump("lavd-avframe", serialize_video_avframe, frame);
 
        if (!sws->ctx) {
                av_to_uv_convert(convert, (char *) dst, frame, width, height,
                                 pitch, rgb_shift);
                return;
        }
 
#ifdef HAVE_SWSCALE
        if (get_ug_to_av_pixfmt(out_codec) != AV_PIX_FMT_NONE) { // the UG pixfmt can be used directly as dst for sws
                lavd_sws_convert_to_buffer(sws, frame, (char *) dst);
                return;
        }
 
        lavd_sws_convert(sws, frame);
        av_to_uv_convert(convert, (char *) dst, sws->frame, width, height,
                         pitch, rgb_shift);
#else
        (void) out_codec;
#endif // HAVE_SWSCALE
}

References av_to_uv_convert(), convert, debug_file_dump, frame, get_ug_to_av_pixfmt(), and serialize_video_avframe().

Referenced by libavcodec_decompress().

Here is the call graph for this function:

check_av_opt_set()

static int check_av_opt_set ( void * state, const char * key, const char * val )

static

Definition at line 134 of file libavcodec.c.

                                                                           {
        int ret = av_opt_set(state, key, val, 0);
        if (ret != 0) {
                printf_libav_error(LOG_LEVEL_WARNING, ret, MOD_NAME "Unable to set %s to %s", key, val);
        }
        return ret;
}

References key, LOG_LEVEL_WARNING, MOD_NAME, printf_libav_error(), state, and val.

Referenced by set_codec_context_params().

Here is the call graph for this function:

check_duration()

static void check_duration ( struct state_libavcodec_decompress * s, double duration_total_sec, double duration_pixfmt_change_sec )

static

print hint to improve performance if not making it

Definition at line 898 of file libavcodec.c.

{
        enum {
                MOV_WIN_FRM        = 100,
                REPEAT_INT_SEC     = 30,
                TIME_SLOT_PERC_MAX = 66
        };
        double tpf = 1 / s->desc.fps;
        tpf *= TIME_SLOT_PERC_MAX / 100.;
        s->mov_avg_comp_duration =
            (s->mov_avg_comp_duration * (MOV_WIN_FRM - 1) +
             duration_total_sec) /
            MOV_WIN_FRM;
        s->mov_avg_frames += 1;
        if (s->mov_avg_frames < 2 * MOV_WIN_FRM ||
            s->mov_avg_comp_duration < tpf) {
                return;
        }
        const time_ns_t now = get_time_in_ns();
        if (now < s->duration_warn_last_print + NS_IN_SEC * REPEAT_INT_SEC) {
                return;
        }
        s->duration_warn_last_print = now;
        MSG(WARNING,
            "Avg decompress time of last %d frames is %.2f ms which exceeds %.2f "
            "ms (%d%% of TPF)!\n",
            MOV_WIN_FRM, s->mov_avg_comp_duration * MS_IN_SEC, tpf * MS_IN_SEC,
            TIME_SLOT_PERC_MAX);
        const char *hint = NULL;
        if ((s->codec_ctx->thread_type & FF_THREAD_FRAME) == 0 &&
            (s->codec_ctx->codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) !=
                0) {
                hint = "\"--param lavd-thread-count=<n>FS\" option with small <n> or 0 (nr of logical cores)";
        } else if (s->codec_ctx->thread_count == 1 && (s->codec_ctx->codec->capabilities & AV_CODEC_CAP_OTHER_THREADS) != 0) {
                hint = "\"--param lavd-thread-count=<n>\" option with small <n> or 0 (nr of logical cores)";
        }
        if (hint) {
                MSG(WARNING,
                    "Consider adding %s to increase throughput at the expense "
                    "of latency.\n",
                    hint);
        }
        if ((s->codec_ctx->flags & AV_CODEC_FLAG_LOW_DELAY) != 0) {
                MSG(WARNING,
                    "Consider %sdisabling low delay decode using 'd' flag.\n",
                    hint != NULL ? "also " : "");
        }
 
        bool in_rgb = av_pix_fmt_desc_get(s->convert_in)->flags & AV_PIX_FMT_FLAG_RGB;
        if (codec_is_a_rgb(s->out_codec) != in_rgb && duration_pixfmt_change_sec > s->mov_avg_comp_duration / 4) {
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Also pixfmt change of last frame took %f ms.\n"
                        "Consider adding \"--conv-policy cds\" to prevent color space conversion.\n", duration_pixfmt_change_sec / 1000.0);
        }
}

References AV_CODEC_CAP_OTHER_THREADS, state_libavcodec_decompress::codec_ctx, codec_is_a_rgb(), state_libavcodec_decompress::convert_in, state_libavcodec_decompress::desc, state_libavcodec_decompress::duration_warn_last_print, video_desc::fps, get_time_in_ns(), LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_libavcodec_decompress::mov_avg_comp_duration, state_libavcodec_decompress::mov_avg_frames, MS_IN_SEC, MSG, NS_IN_SEC, and state_libavcodec_decompress::out_codec.

Referenced by libavcodec_decompress().

Here is the call graph for this function:

check_first_sps_vps()

static _Bool check_first_sps_vps ( struct state_libavcodec_decompress * s, unsigned char * src, unsigned int src_len )

static

This function handles beginning of H.264 stream that usually floods terminal output with errors because it usually doesn't start with IDR frame (even if it does, codec probing swallows this). As a workaround, we wait until first SPS NAL unit to avoid initial decoding errors.

A drawback may be that it can in theory happen that the SPS NAL unit is not at the beginning of the buffer, but it is not the case of libx264 and hopefully neither other decoders (if so, it needs to be reworked/removed).

Definition at line 860 of file libavcodec.c.

                                                                                                                  {
        if (s->sps_vps_found) {
                return 1;
        }
        _Thread_local static time_ns_t t0;
        if (t0 == 0) {
                t0 = get_time_in_ns();
        }
        if (get_time_in_ns() - t0 > 10 * NS_IN_SEC) { // after 10 seconds surrender and let decoder do the job
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "No SPS found, starting decode, anyway. Please report a bug to " PACKAGE_BUGREPORT " if decoding succeeds from now.\n");
                s->sps_vps_found = 1;
                return 1;
        }
 
        const unsigned char *const nal =
            rtpenc_get_first_nal(src, src_len, s->desc.color_spec == H265);
        if (nal == NULL) {
                return 0;
        }
        const int nalu_type =
            NALU_HDR_GET_TYPE(nal[0], s->desc.color_spec == H265);
 
        switch (nalu_type) {
        case NAL_H264_SPS:
        case NAL_HEVC_VPS:
                s->sps_vps_found = 1;
                log_msg(LOG_LEVEL_VERBOSE,
                        MOD_NAME "Received %s NALU, decoding begins.\n",
                        get_nalu_name(nalu_type));
                return 1;
        default:
                log_msg(LOG_LEVEL_WARNING,
                        MOD_NAME "Waiting for first SPS/VPS NALU...\n");
                return 0;
        }
}

References video_desc::color_spec, state_libavcodec_decompress::desc, get_nalu_name(), get_time_in_ns(), H265, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, NAL_H264_SPS, NAL_HEVC_VPS, NALU_HDR_GET_TYPE, NS_IN_SEC, rtpenc_get_first_nal(), and state_libavcodec_decompress::sps_vps_found.

Referenced by libavcodec_decompress().

Here is the call graph for this function:

configure_with()

static bool configure_with ( struct state_libavcodec_decompress * s, struct video_desc desc, void * extradata, int extradata_size )

static

Definition at line 336 of file libavcodec.c.

{
        const struct decoder_info *dec = NULL;
 
        s->consecutive_failed_decodes = 0;
 
        for (unsigned int i = 0; i < sizeof decoders / sizeof decoders[0]; ++i) {
                if (decoders[i].ug_codec == desc.color_spec) {
                        dec = &decoders[i];
                        break;
                }
        }
 
        if (dec == NULL) {
                log_msg(LOG_LEVEL_ERROR, "[lavd] Unsupported codec!!!\n");
                return false;
        }
 
        if (dec->codec_callback) {
                dec->codec_callback();
        }
 
        // priority list of decoders that can be used for the codec
        const AVCodec *usable_decoders[DEC_LEN] = { NULL };
        if (!get_usable_decoders(dec->avcodec_id, dec->preferred_decoders,
                                 usable_decoders)) {
                return false;
        }
 
        // initialize the codec - use the first decoder initialization of which succeeds
        const AVCodec **codec_it = usable_decoders;
        while (*codec_it) {
                log_msg(LOG_LEVEL_VERBOSE, "[lavd] Trying decoder: %s\n", (*codec_it)->name);
                s->codec_ctx = avcodec_alloc_context3(*codec_it);
                if(s->codec_ctx == NULL) {
                        log_msg(LOG_LEVEL_ERROR, "[lavd] Unable to allocate codec context.\n");
                        return false;
                }
                if (extradata) {
                        s->codec_ctx->extradata = malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
                        memcpy(s->codec_ctx->extradata, extradata, extradata_size);
                        s->codec_ctx->extradata_size = extradata_size;
                }
                s->codec_ctx->width = desc.width;
                s->codec_ctx->height = desc.height;
                if (desc.color_spec > PRORES && desc.color_spec <= PRORES_422_LT) {
                        s->codec_ctx->codec_tag = get_fourcc(desc.color_spec);
                }
                set_codec_context_params(s);
                if (avcodec_open2(s->codec_ctx, *codec_it, NULL) < 0) {
                        avcodec_free_context(&s->codec_ctx);
                        log_msg(LOG_LEVEL_WARNING, "[lavd] Unable to open decoder %s.\n", (*codec_it)->name);
                        codec_it++;
                        continue;
                }
                log_msg(LOG_LEVEL_NOTICE, "[lavd] Using decoder: %s\n", (*codec_it)->name);
                log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Codec %s capabilities: 0x%08X; using thread type %d, count %d\n",
                                (*codec_it)->name, (*codec_it)->capabilities, s->codec_ctx->thread_type, s->codec_ctx->thread_count);
                break;
        }
 
        if (s->codec_ctx == NULL) {
                log_msg(LOG_LEVEL_ERROR, "[lavd] Decoder could have not been initialized for codec %s.\n",
                                get_codec_name(desc.color_spec));
                return false;
        }
 
        s->frame = av_frame_alloc();
        s->tmp_frame = av_frame_alloc();
        if (s->frame == NULL || s->tmp_frame == NULL) {
                log_msg(LOG_LEVEL_ERROR, "[lavd] Unable allocate frame.\n");
                return false;
        }
 
        s->pkt = av_packet_alloc();
 
        return true;
}

References state_libavcodec_decompress::codec_ctx, video_desc::color_spec, state_libavcodec_decompress::consecutive_failed_decodes, DEC_LEN, decoders, desc, state_libavcodec_decompress::frame, get_codec_name(), get_fourcc(), get_usable_decoders(), video_desc::height, LOG_LEVEL_ERROR, LOG_LEVEL_NOTICE, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_libavcodec_decompress::pkt, PRORES, PRORES_422_LT, set_codec_context_params(), state_libavcodec_decompress::tmp_frame, ug_codec, and video_desc::width.

Referenced by handle_lavd_error(), libavcodec_decompress(), and libavcodec_decompress_reconfigure().

Here is the call graph for this function:

decode_frame()

static bool decode_frame ( struct state_libavcodec_decompress * s, unsigned char * src, int src_len )

static

Definition at line 1003 of file libavcodec.c.

{
        bool frame_decoded = false;
        s->pkt->data       = src;
        s->pkt->size       = src_len;
        int ret            = avcodec_send_packet(s->codec_ctx, s->pkt);
        if (ret != 0 && ret != AVERROR(EAGAIN)) {
                handle_lavd_error(MOD_NAME "send - ", s, ret);
                return false;
        }
        // we output to tmp_frame because even if receive fails,
        // it overrides previous potentially valid frame
        while ((ret = avcodec_receive_frame(s->codec_ctx, s->tmp_frame)) == 0) {
                if (frame_decoded) {
                        log_msg(LOG_LEVEL_WARNING,
                                MOD_NAME "Multiple frames decoded at once!\n");
                }
                frame_decoded = true;
                SWAP_PTR(s->frame, s->tmp_frame);
        }
        if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
                handle_lavd_error(MOD_NAME "recv - ", s, ret);
        }
        return frame_decoded;
}

References state_libavcodec_decompress::codec_ctx, state_libavcodec_decompress::frame, handle_lavd_error(), LOG_LEVEL_WARNING, log_msg(), MOD_NAME, state_libavcodec_decompress::pkt, SWAP_PTR, and state_libavcodec_decompress::tmp_frame.

Referenced by libavcodec_decompress().

Here is the call graph for this function:

deconfigure()

static void deconfigure ( struct state_libavcodec_decompress * s )

static

Definition at line 108 of file libavcodec.c.

{
        av_to_uv_conversion_destroy(&s->convert);
 
        if(s->codec_ctx) {
                lavd_flush(s->codec_ctx);
                avcodec_free_context(&s->codec_ctx);
        }
        av_frame_free(&s->frame);
        av_frame_free(&s->tmp_frame);
        av_packet_free(&s->pkt);
 
        hwaccel_state_reset(&s->hwaccel);
 
        s->convert_in = AV_PIX_FMT_NONE;
 
#ifdef HAVE_SWSCALE
        sws_freeContext(s->sws.ctx);
        s->sws.ctx = NULL;
        if (s->sws.frame) {
                av_freep(s->sws.frame->data);
        }
        av_frame_free(&s->sws.frame);
#endif // defined HAVE_SWSCALE
}

References av_to_uv_conversion_destroy(), state_libavcodec_decompress::codec_ctx, state_libavcodec_decompress::convert, state_libavcodec_decompress::convert_in, state_libavcodec_decompress::state_libavcodec_decompress_sws::ctx, state_libavcodec_decompress::frame, state_libavcodec_decompress::state_libavcodec_decompress_sws::frame, state_libavcodec_decompress::hwaccel, hwaccel_state_reset(), lavd_flush(), state_libavcodec_decompress::pkt, state_libavcodec_decompress::sws, and state_libavcodec_decompress::tmp_frame.

Referenced by handle_lavd_error(), libavcodec_decompress_done(), and libavcodec_decompress_reconfigure().

Here is the call graph for this function:

drm_prime_init()

static int drm_prime_init ( struct AVCodecContext * s, struct hw_accel_state * state, codec_t out_codec )

static

Definition at line 490 of file libavcodec.c.

{
        UNUSED(s), UNUSED(out_codec);
        state->type = HWACCEL_DRM_PRIME;
        AVBufferRef *ref = NULL;
        int ret = create_hw_device_ctx(AV_HWDEVICE_TYPE_DRM, &ref);
        if(ret < 0)
                return ret;
 
        s->hw_device_ctx = ref;
        state->copy = out_codec != DRM_PRIME;
        state->tmp_frame = av_frame_alloc();
        if(!state->tmp_frame){
                av_buffer_unref(&ref);
                return -1;
        }
        return 0;
}

References DRM_PRIME, HWACCEL_DRM_PRIME, state_libavcodec_decompress::out_codec, state, and UNUSED.

Referenced by get_format_callback().

get_format_callback()

static enum AVPixelFormat get_format_callback ( struct AVCodecContext * s, const enum AVPixelFormat * fmt )

static

Definition at line 596 of file libavcodec.c.

{
#define SELECT_PIXFMT(pixfmt) { log_msg(LOG_LEVEL_INFO, MOD_NAME "Selected pixel format: %s\n", av_get_pix_fmt_name(pixfmt)); return pixfmt; }
        MSG(VERBOSE, "Available output pixel formats: %s\n",
            get_avpixfmts_names(fmt));
 
        struct state_libavcodec_decompress *state = (struct state_libavcodec_decompress *) s->opaque;
        const char *hwaccel = get_commandline_param("use-hw-accel");
#ifdef HWACC_COMMON_IMPL
        hwaccel_state_reset(&state->hwaccel);
 
        static const struct{
                enum AVPixelFormat pix_fmt;
                int (*init_func)(AVCodecContext *, struct hw_accel_state *, codec_t);
        } accels[] = {
#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(56, 39, 100)
                {AV_PIX_FMT_VULKAN, vulkan_init},
#endif
#ifdef HWACC_VDPAU
                {AV_PIX_FMT_VDPAU, vdpau_init},
#endif
                {AV_PIX_FMT_CUDA, hwacc_cuda_init},
#ifdef HWACC_VAAPI
                {AV_PIX_FMT_VAAPI, vaapi_init},
#endif
#ifdef __APPLE__
                {AV_PIX_FMT_VIDEOTOOLBOX, videotoolbox_init},
#endif
#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(55, 75, 100)
                {AV_PIX_FMT_DRM_PRIME, drm_prime_init},
#endif
                {AV_PIX_FMT_NONE, NULL}
        };
 
        if (hwaccel != NULL) {
                struct state_libavcodec_decompress *state = (struct state_libavcodec_decompress *) s->opaque; 
                check_pixfmt_hw_eligibility(s->sw_pix_fmt);
                const enum hw_accel_type forced_hwaccel =
                    strlen(hwaccel) > 0 ? hw_accel_from_str(hwaccel)
                                        : HWACCEL_NONE;
                for(const enum AVPixelFormat *it = fmt; *it != AV_PIX_FMT_NONE; it++){
                        for(unsigned i = 0; i < sizeof(accels) / sizeof(accels[0]); i++){
                                if (*it != accels[i].pix_fmt ||
                                    state->block_accel[hw_accel_from_pixfmt(accels[i].pix_fmt)]) {
                                        continue;
                                }
                                if (forced_hwaccel != HWACCEL_NONE &&
                                    hw_accel_from_pixfmt(accels[i].pix_fmt) !=
                                        forced_hwaccel) {
                                        break;
                                }
                                int ret = accels[i].init_func(s, &state->hwaccel, state->out_codec);
                                if(ret < 0){
                                        hwaccel_state_reset(&state->hwaccel);
                                        break;
                                }
                                SELECT_PIXFMT(accels[i].pix_fmt);
                        }
                }
                if(forced_hwaccel != HWACCEL_NONE){
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Requested hw accel \"%s\" is not available\n", hwaccel);
                        return AV_PIX_FMT_NONE;
                }
                log_msg(LOG_LEVEL_WARNING, "[lavd] Falling back to software decoding!\n");
                if (state->out_codec == HW_VDPAU) {
                        return AV_PIX_FMT_NONE;
                }
        }
#endif
 
        if (state->out_codec == VIDEO_CODEC_NONE) { // probe
                codec_t c = get_best_ug_codec_to_av(fmt, hwaccel);
                if (c != VIDEO_CODEC_NONE) {
                        enum AVPixelFormat selected_fmt = lavd_get_av_to_ug_codec(fmt, c, hwaccel);
                        return selected_fmt;
                }
        } else {
                enum AVPixelFormat f = lavd_get_av_to_ug_codec(fmt, state->out_codec, hwaccel);
                if (f != AV_PIX_FMT_NONE) {
                        SELECT_PIXFMT(f);
                }
        }
 
#ifdef HAVE_SWSCALE
        for (const enum AVPixelFormat *fmt_it = fmt; *fmt_it != AV_PIX_FMT_NONE; fmt_it++) {
                const AVPixFmtDescriptor *fmt_desc = av_pix_fmt_desc_get(*fmt_it);
                if (fmt_desc && (fmt_desc->flags & AV_PIX_FMT_FLAG_HWACCEL) == 0U) {
                        SELECT_PIXFMT(*fmt_it);
                }
        }
#endif
 
        return AV_PIX_FMT_NONE;
}

References AV_PIX_FMT_VULKAN, drm_prime_init(), fmt, get_avpixfmts_names(), get_best_ug_codec_to_av(), get_commandline_param(), hw_accel_from_pixfmt(), hw_accel_from_str(), HW_VDPAU, state_libavcodec_decompress::hwaccel, HWACCEL_NONE, hwaccel_state_reset(), lavd_get_av_to_ug_codec(), LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, MSG, SELECT_PIXFMT, state, vaapi_init(), vdpau_init(), VIDEO_CODEC_NONE, and videotoolbox_init().

Referenced by set_codec_context_params().

Here is the call graph for this function:

get_usable_decoders()

static bool get_usable_decoders ( enum AVCodecID avcodec_id, const char *const preferred_decoders[static MAX_PREFERED+1], const AVCodec * usable_decoders[static DEC_LEN] )

static

Definition at line 259 of file libavcodec.c.

{
        unsigned int codec_index = 0;
        // first try codec specified from cmdline if any
        const char *param = get_commandline_param("force-lavd-decoder");
        if (param != NULL) {
                char *val = alloca(strlen(param) + 1);
                strcpy(val, param);
                char *item     = NULL;
                char *save_ptr = NULL;
                while ((item = strtok_r(val, ":", &save_ptr))) {
                        val = NULL;
                        const AVCodec *codec =
                            avcodec_find_decoder_by_name(item);
                        if (codec == NULL) {
                                log_msg(LOG_LEVEL_ERROR,
                                        MOD_NAME
                                        "Forced decoder not found: %s\n",
                                        item);
                                exit_uv(1);
                                return false;
                        }
                        if (codec->id != avcodec_id) {
                                log_msg(
                                    LOG_LEVEL_WARNING,
                                    MOD_NAME
                                    "Forced decoder not valid for codec: %s\n",
                                    item);
                                continue;
                        }
                        assert(codec_index < MAX_DECODERS);
                        usable_decoders[codec_index++] = codec;
                }
        }
        // then try preferred codecs
        const char *const *preferred_decoders_it = preferred_decoders;
        while (*preferred_decoders_it) {
                const AVCodec *codec =
                    avcodec_find_decoder_by_name(*preferred_decoders_it);
                if (codec == NULL) {
                        log_msg(LOG_LEVEL_VERBOSE,
                                "[lavd] Decoder not available: %s\n",
                                *preferred_decoders_it);
                        preferred_decoders_it++;
                        continue;
                }
                assert(codec_index < MAX_DECODERS);
                preferred_decoders_it++;
        }
        // finally, add a default one if there are no preferred enc. or all fail
        assert(codec_index < MAX_DECODERS);
        const AVCodec *default_decoder = avcodec_find_decoder(avcodec_id);
        if (default_decoder == NULL) {
                log_msg(LOG_LEVEL_WARNING,
                        "[lavd] No decoder found for the input codec "
                        "(libavcodec perhaps compiled without any)!\n"
                        "Use \"--param force-lavd-decoder=<d> to select a "
                        "different decoder than libavcodec if there is "
                        "any eligibe.\n");
        } else {
                usable_decoders[codec_index++] = default_decoder;
        }
        usable_decoders[codec_index] = NULL;
        return true;
}

References decoder_info::avcodec_id, exit_uv(), get_commandline_param(), LOG_LEVEL_ERROR, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MAX_DECODERS, MOD_NAME, param, decoder_info::preferred_decoders, and val.

Referenced by configure_with().

Here is the call graph for this function:

handle_lavd_error()

static void handle_lavd_error ( const char * prefix, struct state_libavcodec_decompress * s, int ret )

static

Definition at line 954 of file libavcodec.c.

{
        print_decoder_error(prefix, ret);
        if(ret == AVERROR(EIO)){
                s->consecutive_failed_decodes++;
                if(s->consecutive_failed_decodes > 70 && !s->block_accel[s->hwaccel.type]){
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Decode failing, "
                                        " blacklisting hw. accelerator...\n");
                        s->block_accel[s->hwaccel.type] = true;
                        deconfigure(s);
                        configure_with(s, s->desc, NULL, 0);
                }
        } else if (ret == AVERROR(EAGAIN) && strcmp(s->codec_ctx->codec->name, "hevc_qsv") == 0) {
                if (s->consecutive_failed_decodes++ == 70) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "hevc_qsv decoder keeps failing, which may be caused by intra refresh period.\n"
                                        "Try disabling intra refresh on encoder: `-c libavcodec:encoder=libx265:disable_intra_refresh`\n");
                }
        }
}

References state_libavcodec_decompress::block_accel, state_libavcodec_decompress::codec_ctx, configure_with(), state_libavcodec_decompress::consecutive_failed_decodes, deconfigure(), state_libavcodec_decompress::desc, state_libavcodec_decompress::hwaccel, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, print_decoder_error(), and hw_accel_state::type.

Referenced by decode_frame().

Here is the call graph for this function:

jpeg_callback()

static void jpeg_callback ( void )

static

Definition at line 209 of file libavcodec.c.

{
        log_msg(LOG_LEVEL_WARNING, "[lavd] Warning: JPEG decoder "
                        "will use full-scale YUV.\n");
}

References LOG_LEVEL_WARNING, and log_msg().

Here is the call graph for this function:

libavcodec_decompress()

static decompress_status libavcodec_decompress ( void * state, unsigned char * dst, unsigned char * src, unsigned int src_len, int frame_seq, struct video_frame_callbacks * callbacks, struct pixfmt_desc * internal_props )

static

Definition at line 1030 of file libavcodec.c.

{
        UNUSED(frame_seq);
        struct state_libavcodec_decompress *s = (struct state_libavcodec_decompress *) state;
 
        if (s->desc.color_spec == H264 || s->desc.color_spec == H265) {
                if (s->out_codec == VIDEO_CODEC_NONE &&
                    read_forced_pixfmt(s->desc.color_spec, src, src_len,
                                        internal_props)) {
                        return DECODER_GOT_CODEC;
                }
                if (!check_first_sps_vps(s, src, src_len)) {
                        return DECODER_NO_FRAME;
                }
        }
 
        if (libav_codec_has_extradata(s->desc.color_spec)) {
                int extradata_size = *(uint32_t *)(void *) src;
                if (s->codec_ctx == NULL) {
                        if (!configure_with(s, s->desc, src + sizeof(uint32_t),
                                            extradata_size)) {
                                return DECODER_NO_FRAME;
                        }
                }
                src += extradata_size + sizeof(uint32_t);
                src_len -= extradata_size + sizeof(uint32_t);
        }
 
        time_ns_t t0 = get_time_in_ns();
 
        if (!decode_frame(s, src, src_len)) {
                log_msg(LOG_LEVEL_DEBUG, MOD_NAME "No frame was decoded!\n");
                return DECODER_NO_FRAME;
        }
        s->consecutive_failed_decodes = 0;
 
        time_ns_t t1 = get_time_in_ns();
 
        s->frame->opaque = callbacks;
#ifdef HWACC_COMMON_IMPL
        if(s->hwaccel.copy){
                transfer_frame(&s->hwaccel, s->frame);
        }
#endif
        if (s->out_codec != VIDEO_CODEC_NONE) {
                if (!reconfigure_convert_if_needed(s, s->frame->format, s->out_codec, s->desc.width, s->desc.height)) {
                        return DECODER_UNSUPP_PIXFMT;
                }
                change_pixfmt(s->frame, dst, s->convert, s->out_codec,
                              s->desc.width, s->desc.height, s->pitch,
                              s->rgb_shift, &s->sws);
        }
        time_ns_t t2 = get_time_in_ns();
        log_msg(LOG_LEVEL_DEBUG, MOD_NAME "Decompressing %c frame took %f ms, pixfmt change %f ms.\n", av_get_picture_type_char(s->frame->pict_type),
                NS_TO_MS((double) (t1 - t0)), NS_TO_MS((double) (t2 - t1)));
        check_duration(s, (t2 - t0) / NS_IN_SEC_DBL, (t2 - t1) / NS_IN_SEC_DBL);
 
        if (s->out_codec == VIDEO_CODEC_NONE) {
                log_msg(LOG_LEVEL_VERBOSE,
                        MOD_NAME "Probed output pixel format: %s (%s)\n",
                        av_get_pix_fmt_name(s->codec_ctx->pix_fmt),
                        av_get_pix_fmt_name(s->codec_ctx->sw_pix_fmt));
                enum AVPixelFormat sw_fmt = s->codec_ctx->sw_pix_fmt == AV_PIX_FMT_NONE ? s->codec_ctx->pix_fmt : s->codec_ctx->sw_pix_fmt;
                *internal_props = av_pixfmt_get_desc(sw_fmt);
                internal_props->accel_type =
                    hw_accel_from_pixfmt(s->codec_ctx->pix_fmt);
                return DECODER_GOT_CODEC;
        }
 
        return DECODER_GOT_FRAME;
}

References pixfmt_desc::accel_type, av_pixfmt_get_desc(), change_pixfmt(), check_duration(), check_first_sps_vps(), state_libavcodec_decompress::codec_ctx, video_desc::color_spec, configure_with(), state_libavcodec_decompress::consecutive_failed_decodes, state_libavcodec_decompress::convert, hw_accel_state::copy, decode_frame(), DECODER_GOT_CODEC, DECODER_GOT_FRAME, DECODER_NO_FRAME, DECODER_UNSUPP_PIXFMT, state_libavcodec_decompress::desc, state_libavcodec_decompress::frame, get_time_in_ns(), H264, H265, video_desc::height, hw_accel_from_pixfmt(), state_libavcodec_decompress::hwaccel, libav_codec_has_extradata(), LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, log_msg(), MOD_NAME, NS_IN_SEC_DBL, NS_TO_MS, state_libavcodec_decompress::out_codec, state_libavcodec_decompress::pitch, read_forced_pixfmt(), reconfigure_convert_if_needed(), state_libavcodec_decompress::rgb_shift, state, state_libavcodec_decompress::sws, UNUSED, VIDEO_CODEC_NONE, and video_desc::width.

Here is the call graph for this function:

libavcodec_decompress_done()

static void libavcodec_decompress_done ( void * state )

static

Definition at line 1135 of file libavcodec.c.

{
        struct state_libavcodec_decompress *s =
                (struct state_libavcodec_decompress *) state;
 
        deconfigure(s);
 
        free(s);
}

References deconfigure(), and state.

Here is the call graph for this function:

libavcodec_decompress_get_priority()

static int libavcodec_decompress_get_priority ( codec_t compression, struct pixfmt_desc internal, codec_t ugc )

static

Todo

This should be take into account existing conversions.

Definition at line 1149 of file libavcodec.c.

                                                                                                             {
        if (internal.accel_type != HWACCEL_NONE &&
            hw_accel_to_ug_pixfmt(internal.accel_type) == ugc) {
                return VDEC_PRIO_PREFERRED;
        }
 
        unsigned i = 0;
        for ( ; i < sizeof decoders / sizeof decoders[0]; ++i) {
                if (decoders[i].ug_codec == compression) {
                        const AVCodec *const decoder =
                            avcodec_find_decoder(decoders[i].avcodec_id);
                        if (decoder != NULL) {
                                break;
                        }
                        MSG(WARNING,
                            "Codec %s supported by lavd but "
                            "not compiled in FFmpeg build.\n",
                            get_codec_name(compression));
                }
        }
        if (i == sizeof decoders / sizeof decoders[0]) { // lavd doesn't handle this compression
                return VDEC_PRIO_NA;
        }
 
        switch (ugc) {
                case VIDEO_CODEC_NONE:
                        return VDEC_PRIO_PROBE_LO; // for probe
                case UYVY:
                case RG48:
                case RGB:
                case RGBA:
                case R10k:
                case R12L:
                case v210:
                case Y416:
                        break;
                default:
                        return VDEC_PRIO_NA;
        }
        if (internal.depth == 0) { // unspecified internal format
                return VDEC_PRIO_LOW;
        }
        return codec_is_a_rgb(ugc) == internal.rgb ? VDEC_PRIO_NORMAL
                                                   : VDEC_PRIO_NOT_PREFERRED;
}

References codec_is_a_rgb(), decoders, get_codec_name(), hw_accel_to_ug_pixfmt(), HWACCEL_NONE, MSG, R10k, R12L, RG48, RGB, RGBA, ug_codec, UYVY, v210, VDEC_PRIO_LOW, VDEC_PRIO_NA, VDEC_PRIO_NORMAL, VDEC_PRIO_NOT_PREFERRED, VDEC_PRIO_PREFERRED, VDEC_PRIO_PROBE_LO, VIDEO_CODEC_NONE, and Y416.

Here is the call graph for this function:

libavcodec_decompress_get_property()

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

static

Definition at line 1107 of file libavcodec.c.

{
        struct state_libavcodec_decompress *s =
                (struct state_libavcodec_decompress *) state;
        int ret = false;
 
        switch(property) {
                case DECOMPRESS_PROPERTY_ACCEPTS_CORRUPTED_FRAME:
                        if (*len < sizeof(int)) {
                                return false;
                        }
                        *(int *) val = false;
                        if (s->codec_ctx && strcmp(s->codec_ctx->codec->name, "h264") == 0) {
                                *(int *) val = true;
                        }
                        if (get_commandline_param("lavd-accept-corrupted")) {
                                *(int *) val =
                                        strcmp(get_commandline_param("lavd-accept-corrupted"), "no") != 0;
                        }
 
                        *len = sizeof(int);
                        ret = true;
                        break;
        }
 
        return ret;
}

References state_libavcodec_decompress::codec_ctx, DECOMPRESS_PROPERTY_ACCEPTS_CORRUPTED_FRAME, get_commandline_param(), len, property, state, and val.

Here is the call graph for this function:

libavcodec_decompress_init()

static void * libavcodec_decompress_init ( void )

static

Definition at line 442 of file libavcodec.c.

{
        if (!validate_hwacc_param()) {
                return NULL;
        }
 
        struct state_libavcodec_decompress *s =
                calloc(1, sizeof(struct state_libavcodec_decompress));
 
        ug_set_av_logging();
 
#if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58, 9, 100)
        /*   register all the codecs (you can also register only the codec
         *         you wish to have smaller code */
        avcodec_register_all();
#endif
 
        hwaccel_state_init(&s->hwaccel);
 
        return s;
}

References state_libavcodec_decompress::hwaccel, hwaccel_state_init(), ug_set_av_logging(), and validate_hwacc_param().

Here is the call graph for this function:

libavcodec_decompress_reconfigure()

static int libavcodec_decompress_reconfigure ( void * state, struct video_desc desc, int rshift, int gshift, int bshift, int pitch, codec_t out_codec )

static

Definition at line 464 of file libavcodec.c.

{
        struct state_libavcodec_decompress *s =
                (struct state_libavcodec_decompress *) state;
 
        s->pitch = pitch;
        s->rgb_shift[R_SHIFT_IDX] = rshift;
        s->rgb_shift[G_SHIFT_IDX] = gshift;
        s->rgb_shift[B_SHIFT_IDX] = bshift;
        for(int i = 0; i < HWACCEL_COUNT; i++){
                s->block_accel[i] = get_commandline_param("use-hw-accel") == NULL;
        }
        s->out_codec = out_codec;
        s->desc = desc;
 
        deconfigure(s);
        if (libav_codec_has_extradata(desc.color_spec)) {
                // for codecs that have metadata we have to defer initialization
                // because we don't have the data right now
                return true;
        }
        return configure_with(s, desc, NULL, 0);
}

References B_SHIFT_IDX, state_libavcodec_decompress::block_accel, video_desc::color_spec, configure_with(), deconfigure(), desc, state_libavcodec_decompress::desc, G_SHIFT_IDX, get_commandline_param(), HWACCEL_COUNT, libav_codec_has_extradata(), state_libavcodec_decompress::out_codec, state_libavcodec_decompress::pitch, R_SHIFT_IDX, state_libavcodec_decompress::rgb_shift, and state.

Here is the call graph for this function:

read_forced_pixfmt()

static bool read_forced_pixfmt ( codec_t compress, const unsigned char * src, unsigned int src_len, struct pixfmt_desc * internal_props )

static

Definition at line 976 of file libavcodec.c.

{
        if (compress == H264) {
                char expected_prefix[] = { START_CODE_3B, H264_NAL_SEI_PREFIX, sizeof (unsigned char[]) { UG_ORIG_FORMAT_ISO_IEC_11578_GUID } + 1, UG_ORIG_FORMAT_ISO_IEC_11578_GUID };
                if (src_len < sizeof expected_prefix + 2 || memcmp(src + src_len - sizeof expected_prefix - 2, expected_prefix, sizeof expected_prefix) != 0) {
                        return false;
                }
        } else if (compress == H265) {
                char expected_prefix[] = { START_CODE_3B, HEVC_NAL_SEI_PREFIX, sizeof (unsigned char []) { UG_ORIG_FORMAT_ISO_IEC_11578_GUID } + 1, UG_ORIG_FORMAT_ISO_IEC_11578_GUID };
                if (src_len < sizeof expected_prefix + 2 || memcmp(src + src_len - sizeof expected_prefix - 2, expected_prefix, sizeof expected_prefix) != 0) {
                        return false;
                }
        } else {
                return false;
        }
        unsigned format = src[src_len - 2];
        internal_props->depth = 8 + (format >> 4) * 2;
        int subs_a = ((format >> 2) & 0x3) + 1;
        int subs_b = ((format >> 1) & 0x1) * subs_a;
        internal_props->subsampling = 4000 + subs_a * 100 + subs_b * 10;
        internal_props->rgb = format & 0x1;
        log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Stream properties read from metadata.\n");
        return true;
}

References pixfmt_desc::depth, H264, H264_NAL_SEI_PREFIX, H265, HEVC_NAL_SEI_PREFIX, LOG_LEVEL_VERBOSE, log_msg(), MOD_NAME, pixfmt_desc::rgb, START_CODE_3B, pixfmt_desc::subsampling, and UG_ORIG_FORMAT_ISO_IEC_11578_GUID.

Referenced by libavcodec_decompress().

Here is the call graph for this function:

reconfigure_convert_if_needed()

static _Bool reconfigure_convert_if_needed ( struct state_libavcodec_decompress * s, enum AVPixelFormat av_codec, codec_t out_codec, int width, int height )

static

Definition at line 772 of file libavcodec.c.

                                                                                                                                                         {
        assert(av_codec != AV_PIX_FMT_NONE);
        if (s->convert_in == av_codec) {
                return 1;
        }
        av_to_uv_conversion_destroy(&s->convert);
        s->convert = get_av_to_uv_conversion(av_codec, out_codec);
        if (s->convert != NULL) {
                s->convert_in = av_codec;
                return 1;
        }
#ifdef HAVE_SWSCALE
        if (get_ug_to_av_pixfmt(out_codec) != AV_PIX_FMT_NONE) { // the UG pixfmt can be used directly as dst for sws
                if (!lavd_sws_convert_reconfigure(&s->sws, av_codec, get_ug_to_av_pixfmt(out_codec), width, height)) {
                        return 0;
                }
                s->convert_in = av_codec;
                return 1;
        }
 
        // else try to find swscale
        enum AVPixelFormat sws_out_codec = pick_av_convertible_to_ug(out_codec, &s->convert);
        if (!sws_out_codec) {
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unsupported pixel format: %s (id %d)\n",
                                av_get_pix_fmt_name(av_codec), av_codec);
                return 0;
        }
        if (!lavd_sws_convert_reconfigure(&s->sws, av_codec, sws_out_codec, width, height)) {
                return 0;
        }
        s->convert_in = av_codec;
        return 1;
#else
        UNUSED(width), UNUSED(height);
        return 0;
#endif
}

References av_to_uv_conversion_destroy(), state_libavcodec_decompress::convert, state_libavcodec_decompress::convert_in, get_av_to_uv_conversion(), get_ug_to_av_pixfmt(), LOG_LEVEL_ERROR, log_msg(), MOD_NAME, pick_av_convertible_to_ug(), state_libavcodec_decompress::sws, and UNUSED.

Referenced by libavcodec_decompress().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	libavcodec	,
		&	libavcodec_info,
		LIBRARY_CLASS_VIDEO_DECOMPRESS	,
		VIDEO_DECOMPRESS_ABI_VERSION	)

set_codec_context_params()

static void set_codec_context_params ( struct state_libavcodec_decompress * s )

static

< decoder may use <cpu_count> frame threads with AV_CODEC_CAP_OTHER_THREADS (latency)

Definition at line 145 of file libavcodec.c.

{
        int thread_count = 0; 
        int req_thread_type = 0;
        bool req_low_delay = true;
        const char *thread_count_opt = get_commandline_param("lavd-thread-count");
        if (thread_count_opt != NULL) {
                char *endptr = NULL;
                errno = 0;
                long val = strtol(thread_count_opt, &endptr, 0);
                if (errno == 0 && thread_count_opt[0] != '\0' && val >= 0 && val <= INT_MAX && (*endptr == '\0' || toupper(*endptr) == 'F' || toupper(*endptr) == 'S')) {
                        thread_count = val;
                        while (*endptr) {
                                switch (toupper(*endptr)) {
                                        case 'F': req_thread_type |= FF_THREAD_FRAME; break;
                                        case 'S': req_thread_type |= FF_THREAD_SLICE; break;
                                        case 'n': req_thread_type = -1; break;
                                        case 'd': req_low_delay = false; break;
                                }
                                endptr++;
                        }
                } else {
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "Wrong value for thread count: %s\n", thread_count_opt);
                }
        }
 
        s->codec_ctx->thread_count = thread_count; // zero should mean count equal to the number of virtual cores
        s->codec_ctx->thread_type = 0;
        if (req_thread_type == 0) {
                req_thread_type = FF_THREAD_SLICE;
        } if (req_thread_type == -1) {
                req_thread_type = 0;
        }
        if ((req_thread_type & FF_THREAD_FRAME) != 0U) {
                if (s->codec_ctx->codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) {
                        s->codec_ctx->thread_type |= FF_THREAD_FRAME;
                } else {
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "Warning: Codec doesn't support frame-based multithreading but requested.\n");
                }
        }
        if ((req_thread_type & FF_THREAD_SLICE) != 0U) {
                if (s->codec_ctx->codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) {
                        s->codec_ctx->thread_type |= FF_THREAD_SLICE;
                } else {
                        log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Warning: Codec doesn't support slice-based multithreading.\n");
                }
        }
        log_msg(LOG_LEVEL_INFO, MOD_NAME "Setting thread count to %d, type: %s\n", s->codec_ctx->thread_count, lavc_thread_type_to_str(s->codec_ctx->thread_type));
 
        s->codec_ctx->flags |= req_low_delay ? AV_CODEC_FLAG_LOW_DELAY : 0;
        s->codec_ctx->flags2 |= AV_CODEC_FLAG2_FAST;
        // set by decoder
        s->codec_ctx->pix_fmt = AV_PIX_FMT_NONE;
        // callback to negotiate pixel format that is supported by UG
        s->codec_ctx->get_format = get_format_callback;
        s->codec_ctx->opaque = s;
 
        if (strstr(s->codec_ctx->codec->name, "cuvid") != NULL) {
                char gpu[3];
                snprintf(gpu, sizeof gpu, "%u", cuda_devices[0]);
                check_av_opt_set(s->codec_ctx->priv_data, "gpu", gpu);
        }
}

References check_av_opt_set(), state_libavcodec_decompress::codec_ctx, cuda_devices, get_commandline_param(), get_format_callback(), lavc_thread_type_to_str(), LOG_LEVEL_INFO, LOG_LEVEL_VERBOSE, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, and val.

Referenced by configure_with().

Here is the call graph for this function:

validate_hwacc_param()

static bool validate_hwacc_param ( void )

static

Return values

false

if 1. hwacc not enabled; 2. help; 3. incorect hwacc spec

Definition at line 418 of file libavcodec.c.

{
        const char *const hwaccel = get_commandline_param("use-hw-accel");
        if (hwaccel == NULL) {
                return true;
        }
#if !defined HWACC_COMMON_IMPL
        MSG(FATAL, "HW acceleration not compiled in!\n");
        exit_uv(1);
        return NULL;
#endif
        if (strlen(hwaccel) == 0 ||
            hw_accel_from_str(hwaccel) != HWACCEL_NONE) {
                return true;
        }
        if (strcmp(hwaccel, "help") == 0) {
                exit_uv(0);
                return false;
        }
        MSG(ERROR, "Wrong HW acceleration specified: %s\n", hwaccel);
        exit_uv(1);
        return false;
}

References exit_uv(), get_commandline_param(), hw_accel_from_str(), HWACCEL_NONE, and MSG.

Referenced by libavcodec_decompress_init().

Here is the call graph for this function:

Variable Documentation

decoders

const struct decoder_info decoders[]

static

Initial value:

= {
        { H264, AV_CODEC_ID_H264, NULL, { NULL  } },
        { H265, AV_CODEC_ID_HEVC, NULL, { NULL  } },
        { MJPG, AV_CODEC_ID_MJPEG, jpeg_callback, { NULL } },
        { JPEG, AV_CODEC_ID_MJPEG, jpeg_callback, { NULL } },
        { J2K, AV_CODEC_ID_JPEG2000, NULL, { NULL } },
        { J2KR, AV_CODEC_ID_JPEG2000, NULL, { NULL } },
        { VP8, AV_CODEC_ID_VP8, NULL, { NULL } },
        { VP9, AV_CODEC_ID_VP9, NULL, { NULL } },
        { HFYU, AV_CODEC_ID_HUFFYUV, NULL, { NULL } },
        { FFV1, AV_CODEC_ID_FFV1, NULL, { NULL } },
        { AV1, AV_CODEC_ID_AV1, NULL, { "libdav1d" } },
        { PRORES_4444, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_4444_XQ, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422_HQ, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422_PROXY, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422_LT, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { CFHD, AV_CODEC_ID_CFHD, NULL, { NULL } }
}

Definition at line 237 of file libavcodec.c.

                                              {
        { H264, AV_CODEC_ID_H264, NULL, { NULL /* "h264_cuvid" */ } },
        { H265, AV_CODEC_ID_HEVC, NULL, { NULL /* "hevc_cuvid" */ } },
        { MJPG, AV_CODEC_ID_MJPEG, jpeg_callback, { NULL } },
        { JPEG, AV_CODEC_ID_MJPEG, jpeg_callback, { NULL } },
        { J2K, AV_CODEC_ID_JPEG2000, NULL, { NULL } },
        { J2KR, AV_CODEC_ID_JPEG2000, NULL, { NULL } },
        { VP8, AV_CODEC_ID_VP8, NULL, { NULL } },
        { VP9, AV_CODEC_ID_VP9, NULL, { NULL } },
        { HFYU, AV_CODEC_ID_HUFFYUV, NULL, { NULL } },
        { FFV1, AV_CODEC_ID_FFV1, NULL, { NULL } },
        { AV1, AV_CODEC_ID_AV1, NULL, { "libdav1d" } },
        { PRORES_4444, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_4444_XQ, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422_HQ, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422_PROXY, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { PRORES_422_LT, AV_CODEC_ID_PRORES, NULL, { NULL } },
        { CFHD, AV_CODEC_ID_CFHD, NULL, { NULL } }
};

libavcodec_info

const struct video_decompress_info libavcodec_info

static

Initial value:

= {
        libavcodec_decompress_init,
        libavcodec_decompress_reconfigure,
        libavcodec_decompress,
        libavcodec_decompress_get_property,
        libavcodec_decompress_done,
        libavcodec_decompress_get_priority,
}

Definition at line 1195 of file libavcodec.c.

                                                            {
        libavcodec_decompress_init,
        libavcodec_decompress_reconfigure,
        libavcodec_decompress,
        libavcodec_decompress_get_property,
        libavcodec_decompress_done,
        libavcodec_decompress_get_priority,
};