/*

 * This file is part of mpv.

 *

 * mpv is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * mpv is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <float.h>

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <stdbool.h>

#include <libavcodec/avcodec.h>

#include <libavformat/version.h>

#include <libavutil/common.h>

#include <libavutil/hwcontext.h>

#include <libavutil/opt.h>

#include <libavutil/intreadwrite.h>

#include <libavutil/pixdesc.h>

#include "mpv_talloc.h"

#include "common/msg.h"

#include "options/m_config.h"

#include "options/options.h"

#include "osdep/threads.h"

#include "misc/bstr.h"

#include "common/av_common.h"

#include "common/codecs.h"

#include "video/fmt-conversion.h"

#include "filters/f_decoder_wrapper.h"

#include "filters/filter_internal.h"

#include "video/hwdec.h"

#include "video/img_format.h"

#include "video/mp_image.h"

#include "video/mp_image_pool.h"

#include "demux/demux.h"

#include "demux/stheader.h"

#include "demux/packet.h"

#include "demux/packet_pool.h"

#include "video/csputils.h"

#include "video/sws_utils.h"

#include "video/out/vo.h"

#include "options/m_option.h"

static void init_avctx(struct mp_filter *vd);

static void uninit_avctx(struct mp_filter *vd);

static int get_buffer2_direct(AVCodecContext *avctx, AVFrame *pic, int flags);

static enum AVPixelFormat get_format_hwdec(struct AVCodecContext *avctx,

                                           const enum AVPixelFormat *pix_fmt);

static int hwdec_opt_help(struct mp_log *log, const m_option_t *opt,

                          struct bstr name);

#define HWDEC_DELAY_QUEUE_COUNT 2

#define HWDEC_WAIT_KEYFRAME_COUNT 96

#define OPT_BASE_STRUCT struct vd_lavc_params

struct vd_lavc_params {

    bool fast;

    int film_grain;

    bool show_all;

    int skip_loop_filter;

    int skip_idct;

    int skip_frame;

    int framedrop;

    int threads;

    bool bitexact;

    bool old_x264;

    bool apply_cropping;

    bool check_hw_profile;

    char **avopts;

    int dr;

};

static const struct m_opt_choice_alternatives discard_names[] = {

    {"none",        AVDISCARD_NONE},

    {"default",     AVDISCARD_DEFAULT},

    {"nonref",      AVDISCARD_NONREF},

    {"bidir",       AVDISCARD_BIDIR},

    {"nonkey",      AVDISCARD_NONKEY},

    {"all",         AVDISCARD_ALL},

    {0}

};

#define OPT_DISCARD(field) OPT_CHOICE_C(field, discard_names)

const struct m_sub_options vd_lavc_conf = {

    .opts = (const m_option_t[]){

        {"vd-lavc-fast", OPT_BOOL(fast)},

        {"vd-lavc-film-grain", OPT_CHOICE(film_grain,

            {"auto", -1}, {"cpu", 0}, {"gpu", 1})},

        {"vd-lavc-show-all", OPT_BOOL(show_all)},

        {"vd-lavc-skiploopfilter", OPT_DISCARD(skip_loop_filter)},

        {"vd-lavc-skipidct", OPT_DISCARD(skip_idct)},

        {"vd-lavc-skipframe", OPT_DISCARD(skip_frame)},

        {"vd-lavc-framedrop", OPT_DISCARD(framedrop)},

        {"vd-lavc-threads", OPT_INT(threads), M_RANGE(0, DBL_MAX)},

        {"vd-lavc-bitexact", OPT_BOOL(bitexact)},

        {"vd-lavc-assume-old-x264", OPT_BOOL(old_x264)},

        {"vd-lavc-check-hw-profile", OPT_BOOL(check_hw_profile)},

        {"vd-lavc-o", OPT_KEYVALUELIST(avopts)},

        {"vd-lavc-dr", OPT_CHOICE(dr,

            {"auto", -1}, {"no", 0}, {"yes", 1})},

        {"vd-apply-cropping", OPT_BOOL(apply_cropping)},

        {0}

    },

    .change_flags = UPDATE_VD,

    .size = sizeof(struct vd_lavc_params),

    .defaults = &(const struct vd_lavc_params){

        .film_grain = -1 /*auto*/,

        .check_hw_profile = true,

        .skip_loop_filter = AVDISCARD_DEFAULT,

        .skip_idct = AVDISCARD_DEFAULT,

        .skip_frame = AVDISCARD_DEFAULT,

        .framedrop = AVDISCARD_NONREF,

        .dr = -1,

        .apply_cropping = true,

    },

};

#undef OPT_BASE_STRUCT

#define OPT_BASE_STRUCT struct hwdec_opts

struct hwdec_opts {

    int software_fallback;

    char **hwdec_api;

    char *hwdec_codecs;

    int hwdec_image_format;

    int hwdec_extra_frames;

    int hwdec_threads;

};

const struct m_sub_options hwdec_conf = {

    .opts = (const m_option_t[]){

        {"hwdec", OPT_STRINGLIST(hwdec_api),

            .help = hwdec_opt_help,

            .flags = M_OPT_OPTIONAL_PARAM | M_OPT_ALLOW_NO | UPDATE_HWDEC},

        {"hwdec-codecs", OPT_STRING(hwdec_codecs),

            .flags = UPDATE_HWDEC},

        {"hwdec-extra-frames", OPT_INT(hwdec_extra_frames), M_RANGE(0, 256),

            .flags = UPDATE_VD},

        {"hwdec-image-format", OPT_IMAGEFORMAT(hwdec_image_format),

            .flags = UPDATE_VO},

        {"hwdec-software-fallback", OPT_CHOICE(software_fallback,

            {"no", INT_MAX}, {"yes", 1}), M_RANGE(1, INT_MAX),

            .flags = UPDATE_HWDEC},

        {"hwdec-threads", OPT_INT(hwdec_threads), M_RANGE(0, DBL_MAX)},

        {"vd-lavc-software-fallback", OPT_REPLACED("hwdec-software-fallback")},

        {0}

    },

    .size = sizeof(struct hwdec_opts),

    .defaults = &(const struct hwdec_opts){

        .software_fallback = 3,

        .hwdec_api = (char *[]){"no", NULL,},

        .hwdec_codecs = "h264,vc1,hevc,vp8,vp9,av1,prores,prores_raw,ffv1,dpx",

        // Maximum number of surfaces the player wants to buffer. This number

        // might require adjustment depending on whatever the player does;

        // for example, if vo_gpu increases the number of reference surfaces for

        // interpolation, this value has to be increased too.

        .hwdec_extra_frames = 6,

        .hwdec_threads = 4,

    },

};

struct hwdec_info {

    char name[64];

    char method_name[24]; // non-unique name describing the hwdec method

    const AVCodec *codec; // implemented by this codec

    enum AVHWDeviceType lavc_device; // if not NONE, get a hwdevice

    bool copying; // if true, outputs sw frames, or copy to sw ourselves

    enum AVPixelFormat pix_fmt; // if not NONE, select in get_format

    bool use_hw_frames; // set AVCodecContext.hw_frames_ctx

    bool use_hw_device; // set AVCodecContext.hw_device_ctx

    unsigned int flags; // HWDEC_FLAG_*

    // for internal sorting

    int auto_pos;

    int rank;

};

typedef struct lavc_ctx {

    struct mp_log *log;

    struct m_config_cache *opts_cache;

    struct vd_lavc_params *opts;

    struct m_config_cache *hwdec_opts_cache;

    struct hwdec_opts *hwdec_opts;

    struct mp_codec_params *codec;

    AVCodecContext *avctx;

    AVFrame *pic;

    AVPacket *avpkt;

    bool use_hwdec;

    struct hwdec_info hwdec; // valid only if use_hwdec==true

    bstr *attempted_hwdecs;

    int num_attempted_hwdecs;

    AVRational codec_timebase;

    enum AVDiscard skip_frame;

    bool flushing;

    struct lavc_state state;

    const char *decoder;

    bool hwdec_failed;

    bool hwdec_notified;

    bool force_eof;

    int wait_for_keyframe; // max number of frames to wait for keyframe after reset

    bool intra_only;

    int framedrop_flags;

    bool hw_probing;

    struct demux_packet **sent_packets;

    int num_sent_packets;

    struct demux_packet **requeue_packets;

    int num_requeue_packets;

    struct mp_image **delay_queue;

    int num_delay_queue;

    int max_delay_queue;

    // From VO

    struct vo *vo;

    struct mp_hwdec_devices *hwdec_devs;

    bool force_swdec;

    // Wrapped AVHWDeviceContext* used for decoding.

    AVBufferRef *hwdec_dev;

    bool hwdec_request_reinit;

    int hwdec_fail_count;

    struct mp_image_pool *hwdec_swpool;

    AVBufferRef *cached_hw_frames_ctx;

    // --- The following fields are protected by dr_lock.

    mp_mutex dr_lock;

    bool dr_failed;

    struct mp_image_pool *dr_pool;

    int dr_imgfmt, dr_w, dr_h, dr_stride_align;

    struct mp_decoder public;

} vd_ffmpeg_ctx;

enum {

    HWDEC_FLAG_AUTO         = (1 << 0), // prioritize in autoprobe order

    HWDEC_FLAG_WHITELIST    = (1 << 1), // whitelist for auto

};

struct autoprobe_info {

    const char *method_name;

    unsigned int flags;         // HWDEC_FLAG_*

};

// Things not included in this list will be tried last, in random order.

const struct autoprobe_info hwdec_autoprobe_info[] = {

    {"d3d11va",         HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"vulkan",          HWDEC_FLAG_AUTO},

    {"dxva2",           HWDEC_FLAG_AUTO},

    {"nvdec",           HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"vaapi",           HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"vdpau",           HWDEC_FLAG_AUTO},

    {"drm",             HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"mediacodec",      HWDEC_FLAG_AUTO},

    {"videotoolbox",    HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"d3d11va-copy",    HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"vulkan-copy",     HWDEC_FLAG_AUTO},

    {"dxva2-copy",      HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"nvdec-copy",      HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"vaapi-copy",      HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"vdpau-copy",      HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"drm-copy",        HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"mediacodec-copy", HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {"videotoolbox-copy", HWDEC_FLAG_AUTO | HWDEC_FLAG_WHITELIST},

    {0}

};

static int hwdec_compare(const void *p1, const void *p2)

{

    struct hwdec_info *h1 = (void *)p1;

    struct hwdec_info *h2 = (void *)p2;

    if (h1 == h2)

        return 0;

    // Strictly put non-preferred hwdecs to the end of the list.

    if ((h1->auto_pos == INT_MAX) != (h2->auto_pos == INT_MAX))

        return h1->auto_pos == INT_MAX ? 1 : -1;

    // List non-copying entries first, so --hwdec=auto takes them.

    if (h1->copying != h2->copying)

        return h1->copying ? 1 : -1;

    // Order by autoprobe preference order.

    if (h1->auto_pos != h2->auto_pos)

        return h1->auto_pos > h2->auto_pos ? 1 : -1;

    // Put hwdecs without hw_device_ctx last

    if ((!!h1->lavc_device) != (!!h2->lavc_device))

        return h1->lavc_device ? -1 : 1;

    // Fallback sort order to make sorting stable.

    return h1->rank > h2->rank ? 1 :-1;

}

// (This takes care of some bookkeeping too, like setting info.name)

static void add_hwdec_item(struct hwdec_info **infos, int *num_infos,

                           struct hwdec_info info)

{

    if (info.copying)

        mp_snprintf_cat(info.method_name, sizeof(info.method_name), "-copy");

    // (Including the codec name in case this is a wrapper looks pretty dumb,

    // but better not have them clash with hwaccels and others.)

    snprintf(info.name, sizeof(info.name), "%s-%s",

             info.codec->name, info.method_name);

    info.rank = *num_infos;

    info.auto_pos = INT_MAX;

    for (int x = 0; hwdec_autoprobe_info[x].method_name; x++) {

        const struct autoprobe_info *entry = &hwdec_autoprobe_info[x];

        if (strcmp(entry->method_name, info.method_name) == 0) {

            info.flags |= entry->flags;

            if (info.flags & HWDEC_FLAG_AUTO)

                info.auto_pos = x;

        }

    }

    MP_TARRAY_APPEND(NULL, *infos, *num_infos, info);

}

static void add_all_hwdec_methods(struct hwdec_info **infos, int *num_infos)

{

    const AVCodec *codec = NULL;

    void *iter = NULL;

    while (1) {

        codec = av_codec_iterate(&iter);

        if (!codec)

            break;

        if (codec->type != AVMEDIA_TYPE_VIDEO || !av_codec_is_decoder(codec))

            continue;

        struct hwdec_info info_template = {

            .pix_fmt = AV_PIX_FMT_NONE,

            .codec = codec,

        };

        const char *wrapper = NULL;

        if (codec->capabilities & (AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_HYBRID))

            wrapper = codec->wrapper_name;

        // A decoder can provide multiple methods. In particular, hwaccels

        // provide various methods (e.g. native h264 with vaapi & d3d11), but

        // even wrapper decoders could provide multiple methods.

        bool found_any = false;

        for (int n = 0; ; n++) {

            const AVCodecHWConfig *cfg = avcodec_get_hw_config(codec, n);

            if (!cfg)

                break;

            if ((cfg->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) ||

                (cfg->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))

            {

                struct hwdec_info info = info_template;

                info.lavc_device = cfg->device_type;

                info.pix_fmt = cfg->pix_fmt;

                const char *name = av_hwdevice_get_type_name(cfg->device_type);

                mp_assert(name); // API violation by libavcodec

                // nvdec hwaccels and the cuvid full decoder clash with their

                // naming, so fix it here; we also prefer nvdec for the hwaccel.

                if (strcmp(name, "cuda") == 0 && !wrapper)

                    name = "nvdec";

                snprintf(info.method_name, sizeof(info.method_name), "%s", name);

                // Usually we want to prefer using hw_frames_ctx for true

                // hwaccels only, but we actually don't have any way to detect

                // those, so always use hw_frames_ctx if offered.

                if (cfg->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) {

                    info.use_hw_frames = true;

                } else {

                    info.use_hw_device = true;

                }

                // Direct variant.

                add_hwdec_item(infos, num_infos, info);

                // Copy variant.

                info.copying = true;

                if (cfg->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) {

                    info.use_hw_frames = false;

                    info.use_hw_device = true;

                }

                add_hwdec_item(infos, num_infos, info);

                found_any = true;

            } else if (cfg->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {

                struct hwdec_info info = info_template;

                info.pix_fmt = cfg->pix_fmt;

                const char *name = wrapper;

                if (!name)

                    name = av_get_pix_fmt_name(info.pix_fmt);

                mp_assert(name); // API violation by libavcodec

                snprintf(info.method_name, sizeof(info.method_name), "%s", name);

                // Direct variant.

                add_hwdec_item(infos, num_infos, info);

                // Copy variant.

                info.copying = true;

                info.pix_fmt = AV_PIX_FMT_NONE; // trust it can do sw output

                add_hwdec_item(infos, num_infos, info);

                found_any = true;

            }

        }

        if (!found_any && wrapper) {

            // We _know_ there's something supported here, usually outputting

            // sw surfaces. E.g. mediacodec (before hw_device_ctx support).

            struct hwdec_info info = info_template;

            info.copying = true; // probably

            snprintf(info.method_name, sizeof(info.method_name), "%s", wrapper);

            add_hwdec_item(infos, num_infos, info);

        }

    }

    qsort(*infos, *num_infos, sizeof(struct hwdec_info), hwdec_compare);

}

static bool hwdec_codec_allowed(struct mp_filter *vd, const char *codec)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    bstr s = bstr0(ctx->hwdec_opts->hwdec_codecs);

    while (s.len) {

        bstr item;

        bstr_split_tok(s, ",", &item, &s);

        if (bstr_equals0(item, "all") || bstr_equals0(item, codec))

            return true;

    }

    return false;

}

static AVBufferRef *hwdec_create_dev(struct mp_filter *vd,

                                     struct hwdec_info *hwdec,

                                     bool autoprobe)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    mp_assert(hwdec->lavc_device);

    if (hwdec->copying) {

        const struct hwcontext_fns *fns =

            hwdec_get_hwcontext_fns(hwdec->lavc_device);

        if (fns && fns->create_dev) {

            struct hwcontext_create_dev_params params = {

                .probing = autoprobe,

            };

            return fns->create_dev(vd->global, vd->log, &params);

        } else {

            AVBufferRef* ref = NULL;

            av_hwdevice_ctx_create(&ref, hwdec->lavc_device, NULL, NULL, 0);

            return ref;

        }

    } else if (ctx->hwdec_devs) {

        int imgfmt = pixfmt2imgfmt(hwdec->pix_fmt);

        struct hwdec_imgfmt_request params = {

            .imgfmt = imgfmt,

            .probing = autoprobe,

        };

        hwdec_devices_request_for_img_fmt(ctx->hwdec_devs, &params);

        const struct mp_hwdec_ctx *hw_ctx =

            hwdec_devices_get_by_imgfmt_and_type(ctx->hwdec_devs, imgfmt,

                                                 hwdec->lavc_device);

        if (hw_ctx && hw_ctx->av_device_ref)

            return av_buffer_ref(hw_ctx->av_device_ref);

    }

    return NULL;

}

// Select if and which hwdec to use. Also makes sure to get the decode device.

static void select_and_set_hwdec(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    const char *codec = ctx->codec->codec;

    m_config_cache_update(ctx->hwdec_opts_cache);

    struct hwdec_info *hwdecs = NULL;

    int num_hwdecs = 0;

    add_all_hwdec_methods(&hwdecs, &num_hwdecs);

    char **hwdec_api = ctx->hwdec_opts->hwdec_api;

    for (int i = 0; hwdec_api && hwdec_api[i]; i++) {

        bstr opt = bstr0(hwdec_api[i]);

        bool hwdec_requested = !bstr_equals0(opt, "no");

        bool hwdec_auto_safe = bstr_equals0(opt, "auto") ||

                            bstr_equals0(opt, "auto-safe") ||

                            bstr_equals0(opt, "auto-copy") ||

                            bstr_equals0(opt, "auto-copy-safe") ||

                            bstr_equals0(opt, "yes") ||

                            bstr_equals0(opt, "");

        bool hwdec_auto_unsafe = bstr_equals0(opt, "auto-unsafe");

        bool hwdec_auto_copy = bstr_equals0(opt, "auto-copy") ||

                            bstr_equals0(opt, "auto-copy-safe") ||

                            bstr_equals0(opt, "auto-copy-unsafe");

        bool hwdec_auto = hwdec_auto_unsafe || hwdec_auto_copy || hwdec_auto_safe;

        if (!hwdec_requested) {

            MP_VERBOSE(vd, "No hardware decoding requested.\n");

            break;

        } else if (!hwdec_codec_allowed(vd, codec)) {

            MP_VERBOSE(vd, "Not trying to use hardware decoding: codec %s is not "

                    "on whitelist.\n", codec);

            break;

        } else if (ctx->force_swdec) {

            MP_VERBOSE(vd, "Not trying to use hardware decoding: disallowed\n");

            break;

        } else {

            bool hwdec_name_supported = false;  // relevant only if !hwdec_auto

            for (int n = 0; n < num_hwdecs; n++) {

                struct hwdec_info *hwdec = &hwdecs[n];

                if (!hwdec_auto && !(bstr_equals0(opt, hwdec->method_name) ||

                                    bstr_equals0(opt, hwdec->name)))

                    continue;

                hwdec_name_supported = true;

                bool already_attempted = false;

                for (int j = 0; j < ctx->num_attempted_hwdecs; j++) {

                    if (bstr_equals0(ctx->attempted_hwdecs[j], hwdec->name)) {

                        MP_DBG(vd, "Skipping previously attempted hwdec: %s\n",

                               hwdec->name);

                        already_attempted = true;

                        break;

                    }

                }

                if (already_attempted)

                    continue;

                const char *hw_codec = mp_codec_from_av_codec_id(hwdec->codec->id);

                if (!hw_codec || strcmp(hw_codec, codec) != 0)

                    continue;

                if (hwdec_auto_safe && !(hwdec->flags & HWDEC_FLAG_WHITELIST))

                    continue;

                MP_VERBOSE(vd, "Looking at hwdec %s...\n", hwdec->name);

                /*

                 * Past this point, any kind of failure that results in us

                 * looking for a new hwdec should not lead to use trying this

                 * hwdec again - so add it to the list, regardless of whether

                 * initialisation will succeed or not.

                 */

                MP_TARRAY_APPEND(ctx, ctx->attempted_hwdecs,

                                 ctx->num_attempted_hwdecs,

                                 bstrdup(ctx, bstr0(hwdec->name)));

                if (hwdec_auto_copy && !hwdec->copying) {

                    MP_VERBOSE(vd, "Not using this for auto-copy.\n");

                    continue;

                }

                if (hwdec->lavc_device) {

                    ctx->hwdec_dev = hwdec_create_dev(vd, hwdec, hwdec_auto);

                    if (!ctx->hwdec_dev) {

                        MP_VERBOSE(vd, "Could not create device.\n");

                        continue;

                    }

                    const struct hwcontext_fns *fns =

                                hwdec_get_hwcontext_fns(hwdec->lavc_device);

                    if (fns && fns->is_emulated && fns->is_emulated(ctx->hwdec_dev)) {

                        if (hwdec_auto) {

                            MP_VERBOSE(vd, "Not using emulated API.\n");

                            av_buffer_unref(&ctx->hwdec_dev);

                            continue;

                        }

                        MP_WARN(vd, "Using emulated hardware decoding API.\n");

                    }

                } else if (!hwdec->copying) {

                    // Most likely METHOD_INTERNAL, which often use delay-loaded

                    // VO support as well.

                    if (ctx->hwdec_devs) {

                        struct hwdec_imgfmt_request params = {

                            .imgfmt = pixfmt2imgfmt(hwdec->pix_fmt),

                            .probing = hwdec_auto,

                        };

                        hwdec_devices_request_for_img_fmt(

                            ctx->hwdec_devs, &params);

                    }

                }

                ctx->use_hwdec = true;

                ctx->hwdec = *hwdec;

                break;

            }

            if (ctx->use_hwdec)

                break;

            else if (!hwdec_auto && !hwdec_name_supported)

                MP_WARN(vd, "Unsupported hwdec: %.*s\n", BSTR_P(opt));

        }

    }

    talloc_free(hwdecs);

    if (ctx->use_hwdec) {

        MP_VERBOSE(vd, "Trying hardware decoding via %s.\n", ctx->hwdec.name);

        if (strcmp(ctx->decoder, ctx->hwdec.codec->name) != 0)

            MP_VERBOSE(vd, "Using underlying hw-decoder '%s'\n",

                       ctx->hwdec.codec->name);

    } else {

        // If software fallback is disabled and we get here, all hwdec must

        // have failed. Tell the ctx to always force an eof.

        if (ctx->hwdec_opts->software_fallback == INT_MAX) {

            MP_WARN(ctx, "Software decoding fallback is disabled.\n");

            ctx->force_eof = true;

        } else {

            MP_VERBOSE(vd, "Using software decoding.\n");

        }

    }

}

static int hwdec_opt_help(struct mp_log *log, const m_option_t *opt,

                          struct bstr name)

{

    struct hwdec_info *hwdecs = NULL;

    int num_hwdecs = 0;

    add_all_hwdec_methods(&hwdecs, &num_hwdecs);

    mp_info(log, "Valid values (with alternative full names):\n");

    for (int n = 0; n < num_hwdecs; n++) {

        struct hwdec_info *hwdec = &hwdecs[n];

        mp_info(log, "  %s (%s)\n", hwdec->method_name, hwdec->name);

    }

    talloc_free(hwdecs);

    mp_info(log, "  auto (yes '')\n");

    mp_info(log, "  no\n");

    mp_info(log, "  auto-safe\n");

    mp_info(log, "  auto-copy\n");

    mp_info(log, "  auto-unsafe\n");

    mp_info(log, "  auto-copy-safe\n");

    mp_info(log, "  auto-copy-unsafe\n");

    return M_OPT_EXIT;

}

static void force_fallback(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    uninit_avctx(vd);

    int lev = ctx->hwdec_notified ? MSGL_WARN : MSGL_V;

    mp_msg(vd->log, lev, "Attempting next decoding method after failure of %.*s.\n",

           BSTR_P(ctx->attempted_hwdecs[ctx->num_attempted_hwdecs - 1]));

    select_and_set_hwdec(vd);

    init_avctx(vd);

}

static void reinit(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    uninit_avctx(vd);

    /*

     * Reset attempted hwdecs so that if the hwdec list is reconfigured

     * we attempt all of them from the beginning. The most practical

     * reason for this is that ctrl+h toggles between `no` and

     * `auto`, and we want to reevaluate from a clean slate each time.

     */

    TA_FREEP(&ctx->attempted_hwdecs);

    ctx->num_attempted_hwdecs = 0;

    ctx->hwdec_notified = false;

    select_and_set_hwdec(vd);

    bool use_hwdec = ctx->use_hwdec;

    init_avctx(vd);

    if (!ctx->avctx && use_hwdec) {

        do {

            force_fallback(vd);

        } while (!ctx->avctx);

    }

    // Wait for the first keyframe after reinit to ensure the decoder state is

    // valid and to avoid decoding errors that could cause hwdec to fail and

    // fall back immediately after a reinit.

    ctx->wait_for_keyframe = ctx->use_hwdec ? HWDEC_WAIT_KEYFRAME_COUNT : 0;

}

static void init_avctx(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    struct vd_lavc_params *lavc_param = ctx->opts;

    struct mp_codec_params *c = ctx->codec;

    m_config_cache_update(ctx->opts_cache);

    mp_assert(!ctx->avctx);

    const AVCodec *lavc_codec = NULL;

    if (ctx->use_hwdec) {

        lavc_codec = ctx->hwdec.codec;

    } else {

        lavc_codec = avcodec_find_decoder_by_name(ctx->decoder);

    }

    if (!lavc_codec)

        return;

    const AVCodecDescriptor *desc = avcodec_descriptor_get(lavc_codec->id);

    ctx->intra_only = desc && (desc->props & AV_CODEC_PROP_INTRA_ONLY);

    ctx->codec_timebase = mp_get_codec_timebase(ctx->codec);

    ctx->hwdec_failed = false;

    ctx->hwdec_request_reinit = false;

    ctx->avctx = avcodec_alloc_context3(lavc_codec);

    AVCodecContext *avctx = ctx->avctx;

    if (!ctx->avctx)

        goto error;

    avctx->codec_type = AVMEDIA_TYPE_VIDEO;

    avctx->codec_id = lavc_codec->id;

    avctx->pkt_timebase = ctx->codec_timebase;

    ctx->pic = av_frame_alloc();

    if (!ctx->pic)

        goto error;

    ctx->avpkt = av_packet_alloc();

    if (!ctx->avpkt)

        goto error;

    int threads = lavc_param->threads;

    if (ctx->use_hwdec) {

        avctx->opaque = vd;

        avctx->hwaccel_flags |= AV_HWACCEL_FLAG_IGNORE_LEVEL;

        if (!lavc_param->check_hw_profile)

            avctx->hwaccel_flags |= AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH;

#ifdef AV_HWACCEL_FLAG_UNSAFE_OUTPUT

        /*

         * This flag primarily exists for nvdec which has a very limited

         * output frame pool, which can get exhausted if consumers don't

         * release frames quickly. However, as an implementation

         * requirement, we have to copy the frames anyway, so we don't

         * need this extra implicit copy.

         */

        avctx->hwaccel_flags |= AV_HWACCEL_FLAG_UNSAFE_OUTPUT;

#endif

        if (ctx->hwdec.use_hw_device) {

            if (ctx->hwdec_dev)

                avctx->hw_device_ctx = av_buffer_ref(ctx->hwdec_dev);

            if (!avctx->hw_device_ctx)

                goto error;

        }

        if (ctx->hwdec.use_hw_frames) {

            if (!ctx->hwdec_dev)

                goto error;

        }

        if (ctx->hwdec.pix_fmt != AV_PIX_FMT_NONE)

            avctx->get_format = get_format_hwdec;

        // Some APIs benefit from this, for others it's additional bloat.

        if (ctx->hwdec.copying)

            ctx->max_delay_queue = HWDEC_DELAY_QUEUE_COUNT;

        ctx->hw_probing = true;

        threads = ctx->hwdec_opts->hwdec_threads;

#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(62, 11, 100)

        // Vulkan threading was not safe before 62.11.100

        bstr hwdec_name = bstr0(ctx->hwdec.name);

        if (bstr_endswith0(hwdec_name, "vulkan") || bstr_endswith0(hwdec_name, "vulkan-copy"))

            threads = 1;

#endif

    }

    mp_set_avcodec_threads(vd->log, avctx, threads);

    if (!ctx->use_hwdec && ctx->vo && lavc_param->dr) {

        avctx->opaque = vd;

        avctx->get_buffer2 = get_buffer2_direct;

    }

    avctx->flags |= lavc_param->bitexact ? AV_CODEC_FLAG_BITEXACT : 0;

    avctx->flags2 |= lavc_param->fast ? AV_CODEC_FLAG2_FAST : 0;

    if (lavc_param->show_all)

        avctx->flags |= AV_CODEC_FLAG_OUTPUT_CORRUPT;

    avctx->skip_loop_filter = lavc_param->skip_loop_filter;

    avctx->skip_idct = lavc_param->skip_idct;

    avctx->skip_frame = lavc_param->skip_frame;

    avctx->apply_cropping = lavc_param->apply_cropping;

    if (lavc_codec->id == AV_CODEC_ID_H264 && lavc_param->old_x264)

        av_opt_set(avctx, "x264_build", "150", AV_OPT_SEARCH_CHILDREN);

    switch(ctx->opts->film_grain) {

    case 0: /*CPU*/

        // default lavc flags handle film grain within the decoder.

        break;

    case 1: /*GPU*/

        if (!ctx->vo ||

            (ctx->vo && !(ctx->vo->driver->caps & VO_CAP_FILM_GRAIN))) {

            MP_MSG(vd, ctx->vo ? MSGL_WARN : MSGL_V,

                   "GPU film grain requested, but VO %s, expect wrong output.\n",

                   ctx->vo ?

                   "does not support applying film grain" :

                   "is not available at decoder initialization to verify support");

        }

        avctx->export_side_data |= AV_CODEC_EXPORT_DATA_FILM_GRAIN;

        break;

    default:

        if (ctx->vo && (ctx->vo->driver->caps & VO_CAP_FILM_GRAIN))

            avctx->export_side_data |= AV_CODEC_EXPORT_DATA_FILM_GRAIN;

        break;

    }

    mp_set_avopts(vd->log, avctx, lavc_param->avopts);

    // Do this after the above avopt handling in case it changes values

    ctx->skip_frame = avctx->skip_frame;

    if (mp_set_avctx_codec_headers(avctx, c) < 0) {

        MP_ERR(vd, "Could not set codec parameters.\n");

        goto error;

    }

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION

    if (avctx->width > 8192 || avctx->height > 8192) {

        MP_ERR(vd, "Frame size too big %" PRIu32 "x%" PRIu32 ".\n", avctx->width, avctx->height);

        goto error;

    }

#endif

    /* open it */

    if (avcodec_open2(avctx, lavc_codec, NULL) < 0)

        goto error;

    // Sometimes, the first packet contains information required for correct

    // decoding of the rest of the stream. The only currently known case is the

    // x264 build number (encoded in a SEI element), needed to enable a

    // workaround for broken 4:4:4 streams produced by older x264 versions.

    if (lavc_codec->id == AV_CODEC_ID_H264 && c->first_packet) {

        mp_set_av_packet(ctx->avpkt, c->first_packet, &ctx->codec_timebase);

        avcodec_send_packet(avctx, ctx->avpkt);

        avcodec_receive_frame(avctx, ctx->pic);

        av_frame_unref(ctx->pic);

        avcodec_flush_buffers(ctx->avctx);

    }

    return;

error:

    MP_ERR(vd, "Could not open codec.\n");

    uninit_avctx(vd);

}

static void reset_avctx(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    if (ctx->avctx && avcodec_is_open(ctx->avctx))

        avcodec_flush_buffers(ctx->avctx);

    ctx->flushing = false;

    ctx->hwdec_request_reinit = false;

    // Wait for the first keyframe after reset to ensure the decoder state is

    // valid. Seeking should already jump to a keyframe, so this is safe.

    ctx->wait_for_keyframe = ctx->use_hwdec ? HWDEC_WAIT_KEYFRAME_COUNT : 0;

}

static void flush_all(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    for (int n = 0; n < ctx->num_delay_queue; n++)

        talloc_free(ctx->delay_queue[n]);

    ctx->num_delay_queue = 0;

    for (int n = 0; n < ctx->num_sent_packets; n++)

        talloc_free(ctx->sent_packets[n]);

    ctx->num_sent_packets = 0;

    for (int n = 0; n < ctx->num_requeue_packets; n++)

        talloc_free(ctx->requeue_packets[n]);

    ctx->num_requeue_packets = 0;

    reset_avctx(vd);

}

static void uninit_avctx(struct mp_filter *vd)

{

    vd_ffmpeg_ctx *ctx = vd->priv;

    flush_all(vd);

    av_frame_free(&ctx->pic);

    mp_free_av_packet(&ctx->avpkt);

    av_buffer_unref(&ctx->cached_hw_frames_ctx);

    avcodec_free_context(&ctx->avctx);

    av_buffer_unref(&ctx->hwdec_dev);

    ctx->hwdec_failed = false;

    ctx->hwdec_fail_count = 0;

    ctx->max_delay_queue = 0;

    ctx->hw_probing = false;

    ctx->hwdec = (struct hwdec_info){0};

    ctx->use_hwdec = false;

}

static int init_generic_hwaccel(struct AVCodecContext *avctx, enum AVPixelFormat hw_fmt)

{

    struct mp_filter *vd = avctx->opaque;

    vd_ffmpeg_ctx *ctx = vd->priv;

    AVBufferRef *new_frames_ctx = NULL;

    if (!ctx->hwdec.use_hw_frames)

        return 0;

    if (!ctx->hwdec_dev) {

        MP_ERR(ctx, "Missing device context.\n");

        goto error;

    }

    if (avcodec_get_hw_frames_parameters(avctx,

                                ctx->hwdec_dev, hw_fmt, &new_frames_ctx) < 0)

    {

        MP_VERBOSE(ctx, "Hardware decoding of this stream is unsupported?\n");

        goto error;

    }

    AVHWFramesContext *new_fctx = (void *)new_frames_ctx->data;

    if (ctx->hwdec_opts->hwdec_image_format)

        new_fctx->sw_format = imgfmt2pixfmt(ctx->hwdec_opts->hwdec_image_format);

    // 1 surface is already included by libavcodec. The field is 0 if the

    // hwaccel supports dynamic surface allocation.

    if (new_fctx->initial_pool_size)

        new_fctx->initial_pool_size += ctx->hwdec_opts->hwdec_extra_frames - 1;

    const struct hwcontext_fns *fns =

        hwdec_get_hwcontext_fns(new_fctx->device_ctx->type);

    if (fns && fns->refine_hwframes)

        fns->refine_hwframes(new_frames_ctx);

    // We might be able to reuse a previously allocated frame pool.

    if (ctx->cached_hw_frames_ctx) {

        AVHWFramesContext *old_fctx = (void *)ctx->cached_hw_frames_ctx->data;

        if (new_fctx->format            != old_fctx->format ||

            new_fctx->sw_format         != old_fctx->sw_format ||