path: root/demux/demux_lavf.c

/*
 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
 * Copyright (C) 2018 Google LLC
 *
 * 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 <strings.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/mathematics.h>
#include <libavutil/replaygain.h>
#include <libavutil/spherical.h>
#include <libavutil/display.h>
#include <libavutil/opt.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"

#ifndef AV_DISPOSITION_TIMED_THUMBNAILS
#define AV_DISPOSITION_TIMED_THUMBNAILS 0
#endif
#ifndef AV_DISPOSITION_STILL_IMAGE
#define AV_DISPOSITION_STILL_IMAGE 0
#endif

#define INITIAL_PROBE_SIZE STREAM_BUFFER_SIZE
#define PROBE_BUF_SIZE (2 * 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;
    int allow_mimetype;
    char *format;
    char **avopts;
    int hacks;
    char *sub_cp;
    int rtsp_transport;
};

const struct m_sub_options demux_lavf_conf = {
    .opts = (const m_option_t[]) {
        OPT_INTRANGE("demuxer-lavf-probesize", probesize, 0, 32, INT_MAX),
        OPT_CHOICE("demuxer-lavf-probe-info", probeinfo, 0,
                   ({"no", 0}, {"yes", 1}, {"auto", -1}, {"nostreams", -2})),
        OPT_STRING("demuxer-lavf-format", format, 0),
        OPT_FLOATRANGE("demuxer-lavf-analyzeduration", analyzeduration, 0,
                       0, 3600),
        OPT_INTRANGE("demuxer-lavf-buffersize", buffersize, 0, 1,
                     10 * 1024 * 1024, OPTDEF_INT(BIO_BUFFER_SIZE)),
        OPT_FLAG("demuxer-lavf-allow-mimetype", allow_mimetype, 0),
        OPT_INTRANGE("demuxer-lavf-probescore", probescore, 0,
                     1, AVPROBE_SCORE_MAX),
        OPT_FLAG("demuxer-lavf-hacks", hacks, 0),
        OPT_KEYVALUELIST("demuxer-lavf-o", avopts, 0),
        OPT_STRING("sub-codepage", sub_cp, 0),
        OPT_CHOICE("rtsp-transport", rtsp_transport, 0,
               ({"lavf", 0},
                {"udp", 1},
                {"tcp", 2},
                {"http", 3})),
        {0}
    },
    .size = sizeof(struct demux_lavf_opts),
    .defaults = &(const struct demux_lavf_opts){
        .probeinfo = -1,
        .allow_mimetype = 1,
        .hacks = 1,
        // 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,
    },
};

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;    // export the native stream IDs
    bool fully_read : 1;        // set demuxer.fully_read flag
    bool detect_charset : 1;    // format is a small text file, possibly not UTF8
    bool image_format : 1;      // expected to contain exactly 1 frame
    // 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 ignore_start : 1;
    bool fix_editlists : 1;
    bool is_network : 1;
    bool no_seek : 1;
};

#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},
    {"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},

    {"mp4", .skipinfo = true, .fix_editlists = true},
    {"matroska", .skipinfo = true},

    {"v4l2", .no_seek = true},

    // In theory, such streams might contain timestamps, but virtually none do.
    {"h264", .if_flags = AVFMT_NOTIMESTAMPS },
    {"hevc", .if_flags = AVFMT_NOTIMESTAMPS },

    // Rebasing start time to 0 is very weird with ogg shoutcast streams.
    {"ogg", .ignore_start = 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"),
    // Let's open files with extremely generic extensions (.bin) with a
    // demuxer that doesn't have a probe function! NO.
    BLACKLIST("bin"),
    // Useless, does not work with custom streams.
    BLACKLIST("image2"),
    // Image demuxers ("<name>_pipe" is detected explicitly)
    {"image2pipe", .image_format = true},
    {0}
};

struct nested_stream {
    AVIOContext *id;
    int64_t last_bytes;
};

typedef struct lavf_priv {
    struct stream *stream;
    bool own_stream;
    char *filename;
    struct format_hack format_hack;
    AVInputFormat *avif;
    int avif_flags;
    AVFormatContext *avfc;
    bstr init_fragment;
    int64_t stream_pos;
    AVIOContext *pb;
    struct sh_stream **streams; // NULL for unknown streams
    int num_streams;
    char *mime_type;
    double seek_delay;
    bool optical_crap_hack;

    struct demux_lavf_opts *opts;
    double mf_fps;

    // 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);
    void (*default_io_close)(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;
        demuxer->total_unbuffered_read_bytes += 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;
    int ret;

    if (priv->stream_pos < priv->init_fragment.len) {
        ret = MPMIN(size, priv->init_fragment.len - priv->stream_pos);
        memcpy(buf, priv->init_fragment.start + priv->stream_pos, ret);
        priv->stream_pos += ret;
    } else {
        ret = stream_read_partial(stream, buf, size);
        priv->stream_pos = priv->init_fragment.len + stream_tell(stream);
    }

    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;

    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;
        end += priv->init_fragment.len;
        if (whence == AVSEEK_SIZE)
            return end;
        pos += end;
    } else if (whence == SEEK_CUR) {
        pos += priv->stream_pos;
    } else if (whence != SEEK_SET) {
        return -1;
    }

    if (pos < 0)
        return -1;

    int64_t stream_target = pos - priv->init_fragment.len;
    bool seek_before = stream_target < 0;
    if (seek_before)
        stream_target = 0; // within init segment - seek real stream to 0

    int64_t current_pos = stream_tell(stream);
    if (stream_seek(stream, stream_target) == 0) {
        stream_seek(stream, current_pos);
        return -1;
    }

    if (seek_before) {
        priv->stream_pos = pos;
    } else {
        priv->stream_pos = priv->init_fragment.len + stream_tell(stream);
    }

    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_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 || 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 = open_memory_stream(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 = "";

    AVInputFormat *forced_format = NULL;
    const char *format = lavfdopts->format;
    if (!format)
        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;
        }
    }

    AVProbeData avpd = {
        // Disable file-extension matching with normal checks
        .filename = priv->filename,
        .buf_size = 0,
        .buf = av_mallocz(PROBE_BUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE),
    };
    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);
            bstr buf = stream_peek(s, nsize);
            if (demuxer->params && demuxer->params->init_fragment.len) {
                buf = demuxer->params->init_fragment;
                buf.len = MPMIN(buf.len, nsize);
            }
            if (buf.len <= avpd.buf_size)
                final_probe = true;
            memcpy(avpd.buf, buf.start, buf.len);
            avpd.buf_size = buf.len;

            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;
            }

            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 (bstr_endswith0(bstr0(priv->avif->name), "_pipe")) {
        MP_VERBOSE(demuxer, "Assuming this is an image format.\n");
        priv->format_hack.image_format = true;
    }

    if (lavfdopts->hacks)
        priv->avif_flags = priv->avif->flags | priv->format_hack.if_flags;

    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