/*

 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>

 *

 * 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 <stdlib.h>

#include <limits.h>

#include <stdbool.h>

#include <string.h>

#include <errno.h>

#include <assert.h>

#include "config.h"

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libavutil/avutil.h>

#include <libavutil/avstring.h>

#include <libavutil/display.h>

#include <libavutil/dovi_meta.h>

#include <libavutil/mathematics.h>

#include <libavutil/opt.h>

#include <libavutil/pixdesc.h>

#include <libavutil/replaygain.h>

#include "audio/chmap_avchannel.h"

#include "common/common.h"

#include "common/msg.h"

#include "common/tags.h"

#include "common/av_common.h"

#include "misc/bstr.h"

#include "misc/charset_conv.h"

#include "misc/thread_tools.h"

#include "stream/stream.h"

#include "demux.h"

#include "stheader.h"

#include "options/m_config.h"

#include "options/m_option.h"

#include "options/path.h"

#define INITIAL_PROBE_SIZE STREAM_BUFFER_SIZE

#define PROBE_BUF_SIZE (10 * 1024 * 1024)

// Should correspond to IO_BUFFER_SIZE in libavformat/aviobuf.c (not public)

// libavformat (almost) always reads data in blocks of this size.

#define BIO_BUFFER_SIZE 32768

#define OPT_BASE_STRUCT struct demux_lavf_opts

struct demux_lavf_opts {

    int probesize;

    int probeinfo;

    int probescore;

    float analyzeduration;

    int buffersize;

    bool allow_mimetype;

    char *format;

    char **avopts;

    bool hacks;

    char *sub_cp;

    int rtsp_transport;

    int linearize_ts;

    bool propagate_opts;

};

const struct m_sub_options demux_lavf_conf = {

    .opts = (const m_option_t[]) {

        {"demuxer-lavf-probesize", OPT_INT(probesize), M_RANGE(32, INT_MAX)},

        {"demuxer-lavf-probe-info", OPT_CHOICE(probeinfo,

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

        {"demuxer-lavf-format", OPT_STRING(format)},

        {"demuxer-lavf-analyzeduration", OPT_FLOAT(analyzeduration),

         M_RANGE(0, 3600)},

        {"demuxer-lavf-buffersize", OPT_INT(buffersize),

         M_RANGE(1, 10 * 1024 * 1024), OPTDEF_INT(BIO_BUFFER_SIZE)},

        {"demuxer-lavf-allow-mimetype", OPT_BOOL(allow_mimetype)},

        {"demuxer-lavf-probescore", OPT_INT(probescore),

         M_RANGE(1, AVPROBE_SCORE_MAX)},

        {"demuxer-lavf-hacks", OPT_BOOL(hacks)},

#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION

        {"demuxer-lavf-o", OPT_KEYVALUELIST(avopts)},

#endif

        {"sub-codepage", OPT_STRING(sub_cp)},

        {"rtsp-transport", OPT_CHOICE(rtsp_transport,

            {"lavf", 0},

            {"udp", 1},

            {"tcp", 2},

            {"http", 3},

            {"udp_multicast", 4})},

        {"demuxer-lavf-linearize-timestamps", OPT_CHOICE(linearize_ts,

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

        {"demuxer-lavf-propagate-opts", OPT_BOOL(propagate_opts)},

        {0}

    },

    .size = sizeof(struct demux_lavf_opts),

    .defaults = &(const struct demux_lavf_opts){

        .probeinfo = -1,

        .allow_mimetype = true,

        .hacks = true,

        // AVPROBE_SCORE_MAX/4 + 1 is the "recommended" limit. Below that, the

        // user is supposed to retry with larger probe sizes until a higher

        // value is reached.

        .probescore = AVPROBE_SCORE_MAX/4 + 1,

        .sub_cp = "auto",

        .rtsp_transport = 2,

        .linearize_ts = -1,

        .propagate_opts = true,

    },

    .change_flags = UPDATE_DEMUXER,

};

struct format_hack {

    const char *ff_name;

    const char *mime_type;

    int probescore;

    float analyzeduration;

    bool skipinfo : 1;          // skip avformat_find_stream_info()

    unsigned int if_flags;      // additional AVInputFormat.flags flags

    bool max_probe : 1;         // use probescore only if max. probe size reached

    bool ignore : 1;            // blacklisted

    bool no_stream : 1;         // do not wrap struct stream as AVIOContext

    bool use_stream_ids : 1;    // has a meaningful native stream IDs (export it)

    bool fully_read : 1;        // set demuxer.fully_read flag

    bool detect_charset : 1;    // format is a small text file, possibly not UTF8

    // Do not confuse player's position estimation (position is into external

    // segment, with e.g. HLS, player knows about the playlist main file only).

    bool clear_filepos : 1;

    bool linearize_audio_ts : 1;// compensate timestamp resets (audio only)

    bool is_network : 1;

    bool no_seek : 1;

    bool no_pcm_seek : 1;

    bool no_seek_on_no_duration : 1;

    bool readall_on_no_streamseek : 1;

    bool first_frame_only : 1;

    bool no_ext_picky : 1;      // set "extension_picky" to false

};

#define BLACKLIST(fmt) {fmt, .ignore = true}

#define TEXTSUB(fmt) {fmt, .fully_read = true, .detect_charset = true}

#define TEXTSUB_UTF8(fmt) {fmt, .fully_read = true}

static const struct format_hack format_hacks[] = {

    // for webradios

    {"aac", "audio/aacp", 25, 0.5},

    {"aac", "audio/aac",  25, 0.5},

    // some mp3 files don't detect correctly (usually id3v2 too large)

    {"mp3", "audio/mpeg", 24, 0.5},

    {"mp3", NULL,         24, .max_probe = true},

    {"hls", .no_stream = true, .clear_filepos = true, .no_ext_picky = true},

    {"dash", .no_stream = true, .clear_filepos = true},

    {"sdp", .clear_filepos = true, .is_network = true, .no_seek = true},

    {"mpeg", .use_stream_ids = true},

    {"mpegts", .use_stream_ids = true},

    {"mxf", .use_stream_ids = true},

    {"avi", .use_stream_ids = true},

    {"asf", .use_stream_ids = true},

    {"mp4", .skipinfo = true, .no_pcm_seek = true, .use_stream_ids = true},

    {"matroska", .skipinfo = true, .no_pcm_seek = true, .use_stream_ids = true},

    {"v4l2", .no_seek = true},

    {"rtsp", .no_seek_on_no_duration = true},

    // In theory, such streams might contain timestamps, but virtually none do.

    {"h264", .if_flags = AVFMT_NOTIMESTAMPS },

    {"hevc", .if_flags = AVFMT_NOTIMESTAMPS },

    {"vvc", .if_flags = AVFMT_NOTIMESTAMPS },

    // Some Ogg shoutcast streams are essentially concatenated OGG files. They

    // reset timestamps, which causes all sorts of problems.

    {"ogg", .linearize_audio_ts = true, .use_stream_ids = true},

    // Ignore additional metadata as frames from some single frame JPEGs

    // (e.g. gain map)

    {"jpeg_pipe", .first_frame_only = true},

    // At some point, FFmpeg lost the ability to read gif from unseekable

    // streams.

    {"gif", .readall_on_no_streamseek = true},

    TEXTSUB("aqtitle"), TEXTSUB("jacosub"), TEXTSUB("microdvd"),

    TEXTSUB("mpl2"), TEXTSUB("mpsub"), TEXTSUB("pjs"), TEXTSUB("realtext"),

    TEXTSUB("sami"), TEXTSUB("srt"), TEXTSUB("stl"), TEXTSUB("subviewer"),

    TEXTSUB("subviewer1"), TEXTSUB("vplayer"), TEXTSUB("ass"),

    TEXTSUB_UTF8("webvtt"),

    // Useless non-sense, sometimes breaks MLP2 subreader.c fallback

    BLACKLIST("tty"),

    // Useless, does not work with custom streams.

    BLACKLIST("image2"),

    {0}

};

struct nested_stream {

    AVIOContext *id;

    int64_t last_bytes;

};

struct stream_info {

    struct sh_stream *sh;

    double last_key_pts;

    double highest_pts;

    double ts_offset;

};

typedef struct lavf_priv {

    struct stream *stream;

    bool own_stream;

    bool is_dvd_bd;

    char *filename;

    struct format_hack format_hack;

    const AVInputFormat *avif;

    int avif_flags;

    AVFormatContext *avfc;

    AVIOContext *pb;

    struct stream_info **streams; // NULL for unknown streams

    int num_streams;

    char *mime_type;

    double seek_delay;

    struct demux_lavf_opts *opts;

    bool pcm_seek_hack_disabled;

    AVStream *pcm_seek_hack;

    int pcm_seek_hack_packet_size;

    int linearize_ts;

    bool any_ts_fixed;

    int retry_counter;

    AVDictionary *av_opts;

    // Proxying nested streams.

    struct nested_stream *nested;

    int num_nested;

    int (*default_io_open)(struct AVFormatContext *s, AVIOContext **pb,

                           const char *url, int flags, AVDictionary **options);

    int (*default_io_close2)(struct AVFormatContext *s, AVIOContext *pb);

} lavf_priv_t;

static void update_read_stats(struct demuxer *demuxer)

{

    lavf_priv_t *priv = demuxer->priv;

    for (int n = 0; n < priv->num_nested; n++) {

        struct nested_stream *nest = &priv->nested[n];

        int64_t cur = nest->id->bytes_read;

        int64_t new = cur - nest->last_bytes;

        nest->last_bytes = cur;

        demux_report_unbuffered_read_bytes(demuxer, new);

    }

}

// At least mp4 has name="mov,mp4,m4a,3gp,3g2,mj2", so we split the name

// on "," in general.

static bool matches_avinputformat_name(struct lavf_priv *priv,

                                       const char *name)

{

    const char *avifname = priv->avif->name;

    while (1) {

        const char *next = strchr(avifname, ',');

        if (!next)

            return !strcmp(avifname, name);

        int len = next - avifname;

        if (len == strlen(name) && !memcmp(avifname, name, len))

            return true;

        avifname = next + 1;

    }

}

static int mp_read(void *opaque, uint8_t *buf, int size)

{

    struct demuxer *demuxer = opaque;

    lavf_priv_t *priv = demuxer->priv;

    struct stream *stream = priv->stream;

    if (!stream)

        return 0;

    int ret = stream_read_partial(stream, buf, size);

    MP_TRACE(demuxer, "%d=mp_read(%p, %p, %d), pos: %"PRId64", eof:%d\n",

             ret, stream, buf, size, stream_tell(stream), stream->eof);

    return ret ? ret : AVERROR_EOF;

}

static int64_t mp_seek(void *opaque, int64_t pos, int whence)

{

    struct demuxer *demuxer = opaque;

    lavf_priv_t *priv = demuxer->priv;

    struct stream *stream = priv->stream;

    if (!stream)

        return -1;

    MP_TRACE(demuxer, "mp_seek(%p, %"PRId64", %s)\n", stream, pos,

             whence == SEEK_END ? "end" :

             whence == SEEK_CUR ? "cur" :

             whence == SEEK_SET ? "set" : "size");

    if (whence == SEEK_END || whence == AVSEEK_SIZE) {

        int64_t end = stream_get_size(stream);

        if (end < 0)

            return -1;

        if (whence == AVSEEK_SIZE)

            return end;

        pos += end;

    } else if (whence == SEEK_CUR) {

        pos += stream_tell(stream);

    } else if (whence != SEEK_SET) {

        return -1;

    }

    if (pos < 0)

        return -1;

    int64_t current_pos = stream_tell(stream);

    if (!priv->is_dvd_bd) {

        if (stream_seek(stream, pos) == 0) {

            stream_seek(stream, current_pos);

            return -1;

        }

    } else {

        stream_drop_buffers(stream);

        stream->pos = current_pos;

    }

    return pos;

}

static int64_t mp_read_seek(void *opaque, int stream_idx, int64_t ts, int flags)

{

    struct demuxer *demuxer = opaque;

    lavf_priv_t *priv = demuxer->priv;

    struct stream *stream = priv->stream;

    struct stream_avseek cmd = {

        .stream_index = stream_idx,

        .timestamp = ts,

        .flags = flags,

    };

    if (stream && stream_control(stream, STREAM_CTRL_AVSEEK, &cmd) == STREAM_OK) {

        stream_drop_buffers(stream);

        return 0;

    }

    return AVERROR(ENOSYS);

}

static void list_formats(struct demuxer *demuxer)

{

    MP_INFO(demuxer, "Available lavf input formats:\n");

    const AVInputFormat *fmt;

    void *iter = NULL;

    while ((fmt = av_demuxer_iterate(&iter)))

        MP_INFO(demuxer, "%15s : %s\n", fmt->name, fmt->long_name);

}

static void convert_charset(struct demuxer *demuxer)

{

    lavf_priv_t *priv = demuxer->priv;

    char *cp = priv->opts->sub_cp;

    if (!cp || !cp[0] || mp_charset_is_utf8(cp))

        return;

    bstr data = stream_read_complete(priv->stream, NULL, 128 * 1024 * 1024);

    if (!data.start) {

        MP_WARN(demuxer, "File too big (or error reading) - skip charset probing.\n");

        return;

    }

    void *alloc = data.start;

    cp = (char *)mp_charset_guess(priv, demuxer->log, data, cp, 0);

    if (cp && !mp_charset_is_utf8(cp))

        MP_INFO(demuxer, "Using subtitle charset: %s\n", cp);

    // libavformat transparently converts UTF-16 to UTF-8

    if (!mp_charset_is_utf16(cp) && !mp_charset_is_utf8(cp)) {

        bstr conv = mp_iconv_to_utf8(demuxer->log, data, cp, MP_ICONV_VERBOSE);

        if (conv.start && conv.start != data.start)

            talloc_steal(alloc, conv.start);

        if (conv.start)

            data = conv;

    }

    if (data.start) {

        priv->stream = stream_memory_open(demuxer->global, data.start, data.len);

        priv->own_stream = true;

    }

    talloc_free(alloc);

}

static char *remove_prefix(char *s, const char *const *prefixes)

{

    for (int n = 0; prefixes[n]; n++) {

        int len = strlen(prefixes[n]);

        if (strncmp(s, prefixes[n], len) == 0)

            return s + len;

    }

    return s;

}

static const char *const prefixes[] =

    {"ffmpeg://", "lavf://", "avdevice://", "av://", NULL};

static int lavf_check_file(demuxer_t *demuxer, enum demux_check check)

{

    lavf_priv_t *priv = demuxer->priv;

    struct demux_lavf_opts *lavfdopts = priv->opts;

    struct stream *s = priv->stream;

    priv->filename = remove_prefix(s->url, prefixes);

    char *avdevice_format = NULL;

    if (s->info && strcmp(s->info->name, "avdevice") == 0) {

        // always require filename in the form "format:filename"

        char *sep = strchr(priv->filename, ':');

        if (!sep) {

            MP_FATAL(demuxer, "Must specify filename in 'format:filename' form\n");

            return -1;

        }

        avdevice_format = talloc_strndup(priv, priv->filename,

                                         sep - priv->filename);

        priv->filename = sep + 1;

    }

    char *mime_type = s->mime_type;

    if (!lavfdopts->allow_mimetype || !mime_type)

        mime_type = "";

    const AVInputFormat *forced_format = NULL;

    const char *format = lavfdopts->format;

    if (!format || !format[0])

        format = s->lavf_type;

    if (!format)

        format = avdevice_format;

    if (format) {

        if (strcmp(format, "help") == 0) {

            list_formats(demuxer);

            return -1;

        }

        forced_format = av_find_input_format(format);

        if (!forced_format) {

            MP_FATAL(demuxer, "Unknown lavf format %s\n", format);

            return -1;

        }

    }

    // HLS streams seems to be not well tagged, so matching mime type is not

    // enough. Strip URL parameters and match extension.

    bstr ext = bstr_get_ext(bstr_split(bstr0(priv->filename), "?#", NULL));

    AVProbeData avpd = {

        // Disable file-extension matching with normal checks, except for HLS

        .filename = !bstrcasecmp0(ext, "m3u8") || !bstrcasecmp0(ext, "m3u") ||

                    check <= DEMUX_CHECK_REQUEST ? priv->filename : "",

        .buf_size = 0,

        .buf = av_mallocz(PROBE_BUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE),

        .mime_type = lavfdopts->allow_mimetype ? mime_type : NULL,

    };

    if (!avpd.buf)

        return -1;

    bool final_probe = false;

    do {

        int score = 0;

        if (forced_format) {

            priv->avif = forced_format;

            score = AVPROBE_SCORE_MAX;

        } else {

            int nsize = av_clip(avpd.buf_size * 2, INITIAL_PROBE_SIZE,

                                PROBE_BUF_SIZE);

            nsize = stream_read_peek(s, avpd.buf, nsize);

            if (nsize <= avpd.buf_size)

                final_probe = true;

            avpd.buf_size = nsize;

            priv->avif = av_probe_input_format2(&avpd, avpd.buf_size > 0, &score);

        }

        if (priv->avif) {

            MP_VERBOSE(demuxer, "Found '%s' at score=%d size=%d%s.\n",

                       priv->avif->name, score, avpd.buf_size,

                       forced_format ? " (forced)" : "");

            for (int n = 0; lavfdopts->hacks && format_hacks[n].ff_name; n++) {

                const struct format_hack *entry = &format_hacks[n];

                if (!matches_avinputformat_name(priv, entry->ff_name))

                    continue;

                if (entry->mime_type && strcasecmp(entry->mime_type, mime_type) != 0)

                    continue;

                priv->format_hack = *entry;

                break;

            }

            // AVIF always needs to find stream info

            if (bstrcasecmp0(ext, "avif") == 0)

                priv->format_hack.skipinfo = false;

            if (score >= lavfdopts->probescore)

                break;

            if (priv->format_hack.probescore &&

                score >= priv->format_hack.probescore &&

                (!priv->format_hack.max_probe || final_probe))

                break;

        }

        priv->avif = NULL;

        priv->format_hack = (struct format_hack){0};

    } while (!final_probe);

    av_free(avpd.buf);

    if (priv->avif && !forced_format && priv->format_hack.ignore) {

        MP_VERBOSE(demuxer, "Format blacklisted.\n");

        priv->avif = NULL;

    }

    if (!priv->avif) {

        MP_VERBOSE(demuxer, "No format found, try lowering probescore or forcing the format.\n");

        return -1;

    }

    if (lavfdopts->hacks)

        priv->avif_flags = priv->avif->flags | priv->format_hack.if_flags;

    priv->linearize_ts = lavfdopts->linearize_ts;

    if (priv->linearize_ts < 0 && !priv->format_hack.linearize_audio_ts)

        priv->linearize_ts = 0;

    demuxer->filetype = priv->avif->name;

    if (priv->format_hack.detect_charset)

        convert_charset(demuxer);

    return 0;

}

static char *replace_idx_ext(void *ta_ctx, bstr f)

{

    if (f.len < 4 || f.start[f.len - 4] != '.')

        return NULL;

    char *ext = bstr_endswith0(f, "IDX") ? "SUB" : "sub"; // match case

    return talloc_asprintf(ta_ctx, "%.*s.%s", BSTR_P(bstr_splice(f, 0, -4)), ext);

}

static void guess_and_set_vobsub_name(struct demuxer *demuxer, AVDictionary **d)

{

    lavf_priv_t *priv = demuxer->priv;

    if (!matches_avinputformat_name(priv, "vobsub"))

        return;

    void *tmp = talloc_new(NULL);

    bstr bfilename = bstr0(priv->filename);

    char *subname = NULL;

    if (mp_is_url(bfilename)) {

        // It might be a http URL, which has additional parameters after the

        // end of the actual file path.

        bstr start, end;

        if (bstr_split_tok(bfilename, "?", &start, &end)) {

            subname = replace_idx_ext(tmp, start);

            if (subname)

                subname = talloc_asprintf(tmp, "%s?%.*s", subname, BSTR_P(end));

        }

    }

    if (!subname)

        subname = replace_idx_ext(tmp, bfilename);

    if (!subname)

        subname = talloc_asprintf(tmp, "%.*s.sub", BSTR_P(bfilename));

    MP_VERBOSE(demuxer, "Assuming associated .sub file: %s\n", subname);

    av_dict_set(d, "sub_name", subname, 0);

    talloc_free(tmp);

}

static void select_tracks(struct demuxer *demuxer, int start)

{

    lavf_priv_t *priv = demuxer->priv;

    for (int n = start; n < priv->num_streams; n++) {

        struct sh_stream *stream = priv->streams[n]->sh;

        AVStream *st = priv->avfc->streams[n];

        bool selected = stream && demux_stream_is_selected(stream) &&

                        !stream->attached_picture;

        st->discard = selected ? AVDISCARD_DEFAULT : AVDISCARD_ALL;

    }

}

static inline const uint8_t *mp_av_stream_get_side_data(const AVStream *st,

                                                        enum AVPacketSideDataType type)

{

    const AVPacketSideData *sd;

    sd = av_packet_side_data_get(st->codecpar->coded_side_data,

                                 st->codecpar->nb_coded_side_data,

                                 type);

    return sd ? sd->data : NULL;

}

static void export_replaygain(demuxer_t *demuxer, struct sh_stream *sh,

                              AVStream *st)

{

    const AVReplayGain *av_rgain =

        (const AVReplayGain *)mp_av_stream_get_side_data(st, AV_PKT_DATA_REPLAYGAIN);

    if (!av_rgain)

        return;

    bool track_data_available =

        av_rgain->track_gain != INT32_MIN && av_rgain->track_peak != 0;

    bool album_data_available =

        av_rgain->album_gain != INT32_MIN && av_rgain->album_peak != 0;

    if (!track_data_available && !album_data_available)

        return;

    struct replaygain_data *rgain = talloc_ptrtype(demuxer, rgain);

    rgain->track_gain = rgain->album_gain = 0;

    rgain->track_peak = rgain->album_peak = 1;

    // Set values in *rgain, using track gain as a fallback for album gain

    // if the latter is not present. This behavior matches that in

    // demux/demux.c's decode_rgain; if you change this, please make

    // equivalent changes there too.

    if (track_data_available) {

        rgain->track_gain = rgain->album_gain =

            av_rgain->track_gain / 100000.0f;

        rgain->track_peak = rgain->album_peak =

            av_rgain->track_peak / 100000.0f;

    }

    // If album data is actually available, fill it in with proper values.

    if (album_data_available) {

        rgain->album_gain = av_rgain->album_gain / 100000.0f;

        rgain->album_peak = av_rgain->album_peak / 100000.0f;

    }

    // This must be run only before the stream was added, otherwise there

    // will be race conditions with accesses from the user thread.

    mp_assert(!sh->ds);

    sh->codec->replaygain_data = rgain;

}

// Return a dictionary entry as (decimal) integer.

static int dict_get_decimal(AVDictionary *dict, const char *entry, int def)

{

    AVDictionaryEntry *e = av_dict_get(dict, entry, NULL, 0);

    if (e && e->value) {

        char *end = NULL;

        long int r = strtol(e->value, &end, 10);

        if (end && !end[0] && r >= INT_MIN && r <= INT_MAX)

            return r;

    }

    return def;

}

static bool is_image(AVStream *st, bool attached_picture, const AVInputFormat *avif)

{

    return st->nb_frames <= 1 && (

        attached_picture ||

        bstr_endswith0(bstr0(avif->name), "_pipe") ||

        strcmp(avif->name, "alias_pix") == 0 ||

        strcmp(avif->name, "gif") == 0 ||

        strcmp(avif->name, "ico") == 0 ||

        strcmp(avif->name, "image2pipe") == 0 ||

        ((st->codecpar->codec_id == AV_CODEC_ID_HEVC ||

          st->codecpar->codec_id == AV_CODEC_ID_AV1)

         && st->nb_frames == 1)

    );

}

static void handle_new_stream(demuxer_t *demuxer, int i)

{

    lavf_priv_t *priv = demuxer->priv;

    AVFormatContext *avfc = priv->avfc;

    AVStream *st = avfc->streams[i];

    struct sh_stream *sh = NULL;

    AVCodecParameters *codec = st->codecpar;

    int lavc_delay = codec->initial_padding;

    switch (codec->codec_type) {

    case AVMEDIA_TYPE_AUDIO: {

        sh = demux_alloc_sh_stream(STREAM_AUDIO);

        if (!mp_chmap_from_av_layout(&sh->codec->channels, &codec->ch_layout)) {

            char layout[128] = {0};

            MP_WARN(demuxer,

                    "Failed to convert channel layout %s to mpv one!\n",

                    av_channel_layout_describe(&codec->ch_layout,

                                               layout, 128) < 0 ?

                    "undefined" : layout);

        }

        sh->codec->samplerate = codec->sample_rate;

        sh->codec->bitrate = codec->bit_rate;

        sh->codec->format_name = talloc_strdup(sh, av_get_sample_fmt_name(codec->format));

        double delay = 0;

        if (codec->sample_rate > 0)

            delay = lavc_delay / (double)codec->sample_rate;

        priv->seek_delay = MPMAX(priv->seek_delay, delay);

        export_replaygain(demuxer, sh, st);

        sh->seek_preroll = delay;

        break;

    }

    case AVMEDIA_TYPE_VIDEO: {

        sh = demux_alloc_sh_stream(STREAM_VIDEO);

        if ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) &&

            !(st->disposition & AV_DISPOSITION_TIMED_THUMBNAILS))

        {

            sh->attached_picture =

                new_demux_packet_from_avpacket(demuxer->packet_pool, &st->attached_pic);

            if (sh->attached_picture) {

                sh->attached_picture->pts = 0;

                talloc_steal(sh, sh->attached_picture);

                sh->attached_picture->keyframe = true;

            }

        }

        if (!sh->attached_picture) {

            // A real video stream probably means it's a packet based format.

            priv->pcm_seek_hack_disabled = true;

            priv->pcm_seek_hack = NULL;

            // Also, we don't want to do this shit for ogv videos.

            if (priv->linearize_ts < 0)

                priv->linearize_ts = 0;

        }

        sh->codec->disp_w = codec->width;

        sh->codec->disp_h = codec->height;

        sh->codec->format_name = talloc_strdup(sh, av_get_pix_fmt_name(codec->format));

        if (st->avg_frame_rate.num)

            sh->codec->fps = av_q2d(st->avg_frame_rate);

        if (is_image(st, sh->attached_picture, priv->avif)) {

            MP_VERBOSE(demuxer, "Assuming this is an image format.\n");

            sh->image = true;

            sh->codec->fps = demuxer->opts->mf_fps;

        }

        sh->codec->par_w = st->sample_aspect_ratio.num;

        sh->codec->par_h = st->sample_aspect_ratio.den;

        const uint8_t *sd = mp_av_stream_get_side_data(st, AV_PKT_DATA_DISPLAYMATRIX);

        if (sd) {

            double r = av_display_rotation_get((int32_t *)sd);

            if (!isnan(r))

                sh->codec->rotate = (((int)(-r) % 360) + 360) % 360;

        }

        if ((sd = mp_av_stream_get_side_data(st, AV_PKT_DATA_DOVI_CONF))) {

            const AVDOVIDecoderConfigurationRecord *cfg = (void *) sd;

            MP_VERBOSE(demuxer, "Found Dolby Vision config record: profile "

                       "%d level %d\n", cfg->dv_profile, cfg->dv_level);

            sh->codec->dovi = true;

            sh->codec->dv_profile = cfg->dv_profile;

            sh->codec->dv_level = cfg->dv_level;

        }

        // This also applies to vfw-muxed mkv, but we can't detect these easily.

        sh->codec->avi_dts = matches_avinputformat_name(priv, "avi");

        break;

    }

    case AVMEDIA_TYPE_SUBTITLE: {

        sh = demux_alloc_sh_stream(STREAM_SUB);

        if (codec->extradata_size) {

            sh->codec->extradata = talloc_size(sh, codec->extradata_size);

            memcpy(sh->codec->extradata, codec->extradata, codec->extradata_size);

            sh->codec->extradata_size = codec->extradata_size;

        }

        if (matches_avinputformat_name(priv, "microdvd")) {

            AVRational r;

            if (av_opt_get_q(avfc, "subfps", AV_OPT_SEARCH_CHILDREN, &r) >= 0) {

                // File headers don't have a FPS set.

                if (r.num < 1 || r.den < 1)

                    sh->codec->frame_based = 23.976; // default timebase

            }

        }

        break;

    }

    case AVMEDIA_TYPE_ATTACHMENT: {

        AVDictionaryEntry *ftag = av_dict_get(st->metadata, "filename", NULL, 0);

        char *filename = ftag ? ftag->value : NULL;

        AVDictionaryEntry *mt = av_dict_get(st->metadata, "mimetype", NULL, 0);

        char *mimetype = mt ? mt->value : NULL;

        if (mimetype) {

            demuxer_add_attachment(demuxer, filename, mimetype,

                                   codec->extradata, codec->extradata_size);

        }

        break;

    }

    default: ;

    }

    struct stream_info *info = talloc_zero(priv, struct stream_info);

    *info = (struct stream_info){

        .sh = sh,

        .last_key_pts = MP_NOPTS_VALUE,

        .highest_pts = MP_NOPTS_VALUE,

    };

    mp_assert(priv->num_streams == i); // directly mapped

    MP_TARRAY_APPEND(priv, priv->streams, priv->num_streams, info);

    if (sh) {

        sh->ff_index = st->index;

        sh->codec->codec = mp_codec_from_av_codec_id(codec->codec_id);

        sh->codec->codec_tag = codec->codec_tag;

        sh->codec->lav_codecpar = avcodec_parameters_alloc();

        if (sh->codec->lav_codecpar)

            avcodec_parameters_copy(sh->codec->lav_codecpar, codec);

        sh->codec->native_tb_num = st->time_base.num;

        sh->codec->native_tb_den = st->time_base.den;

        if (st->disposition & AV_DISPOSITION_DEFAULT)

            sh->default_track = true;

        if (st->disposition & AV_DISPOSITION_FORCED)

            sh->forced_track = true;

        if (st->disposition & AV_DISPOSITION_DEPENDENT)

            sh->dependent_track = true;

        if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)

            sh->visual_impaired_track = true;

        if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)

            sh->hearing_impaired_track = true;

        if (st->disposition & AV_DISPOSITION_STILL_IMAGE)

            sh->still_image = true;

        if (priv->format_hack.use_stream_ids)

            sh->demuxer_id = st->id;

        AVDictionaryEntry *title = av_dict_get(st->metadata, "title", NULL, 0);

        if (title && title->value)

            sh->title = talloc_strdup(sh, title->value);

        if (!sh->title && st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)

            sh->title = talloc_asprintf(sh, "visual impaired");

        if (!sh->title && st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)

            sh->title = talloc_asprintf(sh, "hearing impaired");

        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);

        if (lang && lang->value && strcmp(lang->value, "und") != 0)

            sh->lang = talloc_strdup(sh, lang->value);

        sh->hls_bitrate = dict_get_decimal(st->metadata, "variant_bitrate", 0);

        AVProgram *prog = av_find_program_from_stream(avfc, NULL, i);

        if (prog)

            sh->program_id = prog->id;

        sh->missing_timestamps = !!(priv->avif_flags & AVFMT_NOTIMESTAMPS);

        mp_tags_move_from_av_dictionary(sh->tags, &st->metadata);

        demux_add_sh_stream(demuxer, sh);

        // Unfortunately, there is no better way to detect PCM codecs, other

        // than listing them all manually. (Or other "frameless" codecs. Or

        // rather, codecs with frames so small libavformat will put multiple of

        // them into a single packet, but not preserve these artificial packet

        // boundaries on seeking.)

        if (sh->codec->codec && strncmp(sh->codec->codec, "pcm_", 4) == 0 &&

            codec->block_align && !priv->pcm_seek_hack_disabled &&

            priv->opts->hacks && !priv->format_hack.no_pcm_seek &&

            st->time_base.num == 1 && st->time_base.den == codec->sample_rate)

        {

            if (priv->pcm_seek_hack) {

                // More than 1 audio stream => usually doesn't apply.

                priv->pcm_seek_hack_disabled = true;

                priv->pcm_seek_hack = NULL;

            } else {

                priv->pcm_seek_hack = st;

            }

        }

    }

    select_tracks(demuxer, i);

}

// Add any new streams that might have been added

static void add_new_streams(demuxer_t *demuxer)

{

    lavf_priv_t *priv = demuxer->priv;

    while (priv->num_streams < priv->avfc->nb_streams)

        handle_new_stream(demuxer, priv->num_streams);

}

static void update_metadata(demuxer_t *demuxer)

{

    lavf_priv_t *priv = demuxer->priv;

    if (priv->avfc->event_flags & AVFMT_EVENT_FLAG_METADATA_UPDATED) {

        mp_tags_move_from_av_dictionary(demuxer->metadata, &priv->avfc->metadata);

        priv->avfc->event_flags = 0;

        demux_metadata_changed(demuxer);

    }

}

static int interrupt_cb(void *ctx)

{

    struct demuxer *demuxer = ctx;

    return mp_cancel_test(demuxer->cancel);

}

static int block_io_open(struct AVFormatContext *s, AVIOContext **pb,

                         const char *url, int flags, AVDictionary **options)

{

    struct demuxer *demuxer = s->opaque;

    mp_require(demuxer);

    MP_ERR(demuxer, "Not opening '%s' due to --access-references=no.\n", url);

    return AVERROR(EACCES);

}

static int nested_io_open(struct AVFormatContext *s, AVIOContext **pb,

                          const char *url, int flags, AVDictionary **options)

{

    struct demuxer *demuxer = s->opaque;

    mp_require(demuxer);

    lavf_priv_t *priv = demuxer->priv;

    if (options && priv->opts->propagate_opts) {

        // Copy av_opts to options, but only entries that are not present in

        // options. (Hope this will break less by not overwriting important

        // settings.)

        AVDictionaryEntry *cur = NULL;

        while ((cur = av_dict_get(priv->av_opts, "", cur, AV_DICT_IGNORE_SUFFIX)))

        {

            if (!*options || !av_dict_get(*options, cur->key, NULL, 0)) {

                MP_TRACE(demuxer, "Nested option: '%s'='%s'\n",

                         cur->key, cur->value);

                av_dict_set(options, cur->key, cur->value, 0);

            } else {

                MP_TRACE(demuxer, "Skipping nested option: '%s'\n", cur->key);

            }

        }

    }

    int r = priv->default_io_open(s, pb, url, flags, options);

    if (r >= 0) {

        if (options)

            mp_avdict_print_unset(demuxer->log, MSGL_TRACE, *options);

        struct nested_stream nest = {

            .id = *pb,

        };

        MP_TARRAY_APPEND(priv, priv->nested, priv->num_nested, nest);

    }

    return r;

}

static int nested_io_close2(struct AVFormatContext *s, AVIOContext *pb)

{

    struct demuxer *demuxer = s->opaque;

    mp_require(demuxer);

    lavf_priv_t *priv = demuxer->priv;

    for (int n = 0; n < priv->num_nested; n++) {

        if (priv->nested[n].id == pb) {

            MP_TARRAY_REMOVE_AT(priv->nested, priv->num_nested, n);

            break;

        }

    }

    return priv->default_io_close2(s, pb);

}

static int demux_open_lavf(demuxer_t *demuxer, enum demux_check check)

{

    AVFormatContext *avfc = NULL;

    AVDictionaryEntry *t = NULL;

    float analyze_duration = 0;

    lavf_priv_t *priv = talloc_zero(NULL, lavf_priv_t);

    AVDictionary *dopts = NULL;

    demuxer->priv = priv;

    priv->stream = demuxer->stream;

    priv->opts = mp_get_config_group(priv, demuxer->global, &demux_lavf_conf);

    struct demux_lavf_opts *lavfdopts = priv->opts;

    if (lavf_check_file(demuxer, check) < 0)

        goto fail;

    avfc = avformat_alloc_context();

    if (!avfc)

        goto fail;

    if (demuxer->opts->index_mode != 1)

        avfc->flags |= AVFMT_FLAG_IGNIDX;

    if (lavfdopts->probesize) {

        if (av_opt_set_int(avfc, "probesize", lavfdopts->probesize, 0) < 0)

            MP_ERR(demuxer, "couldn't set option probesize to %u\n",

                   lavfdopts->probesize);

    }

    if (priv->format_hack.analyzeduration)

        analyze_duration = priv->format_hack.analyzeduration;

    if (lavfdopts->analyzeduration)

        analyze_duration = lavfdopts->analyzeduration;

    if (analyze_duration > 0) {

        if (av_opt_set_int(avfc, "analyzeduration",

                           analyze_duration * AV_TIME_BASE, 0) < 0)

            MP_ERR(demuxer, "demux_lavf, couldn't set option "

                   "analyzeduration to %f\n", analyze_duration);

    }

    if (priv->format_hack.no_ext_picky) {

        bool user_set_ext_picky = false;