LCOV - code coverage report
Current view: top level - libavformat - utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2504 3276 76.4 %
Date: 2017-12-18 06:23:41 Functions: 120 152 78.9 %

          Line data    Source code
       1             : /*
       2             :  * various utility functions for use within FFmpeg
       3             :  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include <stdarg.h>
      23             : #include <stdint.h>
      24             : 
      25             : #include "config.h"
      26             : 
      27             : #include "libavutil/avassert.h"
      28             : #include "libavutil/avstring.h"
      29             : #include "libavutil/dict.h"
      30             : #include "libavutil/internal.h"
      31             : #include "libavutil/mathematics.h"
      32             : #include "libavutil/opt.h"
      33             : #include "libavutil/parseutils.h"
      34             : #include "libavutil/pixdesc.h"
      35             : #include "libavutil/time.h"
      36             : #include "libavutil/time_internal.h"
      37             : #include "libavutil/timestamp.h"
      38             : 
      39             : #include "libavcodec/bytestream.h"
      40             : #include "libavcodec/internal.h"
      41             : #include "libavcodec/raw.h"
      42             : 
      43             : #include "audiointerleave.h"
      44             : #include "avformat.h"
      45             : #include "avio_internal.h"
      46             : #include "id3v2.h"
      47             : #include "internal.h"
      48             : #include "metadata.h"
      49             : #if CONFIG_NETWORK
      50             : #include "network.h"
      51             : #endif
      52             : #include "riff.h"
      53             : #include "url.h"
      54             : 
      55             : #include "libavutil/ffversion.h"
      56             : const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
      57             : 
      58             : /**
      59             :  * @file
      60             :  * various utility functions for use within FFmpeg
      61             :  */
      62             : 
      63        5466 : unsigned avformat_version(void)
      64             : {
      65             :     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
      66        5466 :     return LIBAVFORMAT_VERSION_INT;
      67             : }
      68             : 
      69        5466 : const char *avformat_configuration(void)
      70             : {
      71        5466 :     return FFMPEG_CONFIGURATION;
      72             : }
      73             : 
      74           0 : const char *avformat_license(void)
      75             : {
      76             : #define LICENSE_PREFIX "libavformat license: "
      77           0 :     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
      78             : }
      79             : 
      80             : #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
      81             : 
      82     1442815 : static int is_relative(int64_t ts) {
      83     1442815 :     return ts > (RELATIVE_TS_BASE - (1LL<<48));
      84             : }
      85             : 
      86             : /**
      87             :  * Wrap a given time stamp, if there is an indication for an overflow
      88             :  *
      89             :  * @param st stream
      90             :  * @param timestamp the time stamp to wrap
      91             :  * @return resulting time stamp
      92             :  */
      93     2232318 : static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
      94             : {
      95     2335250 :     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
      96      205864 :         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
      97      105472 :         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
      98       51823 :             timestamp < st->pts_wrap_reference)
      99           0 :             return timestamp + (1ULL << st->pts_wrap_bits);
     100       55475 :         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
     101        1826 :             timestamp >= st->pts_wrap_reference)
     102          50 :             return timestamp - (1ULL << st->pts_wrap_bits);
     103             :     }
     104     2232268 :     return timestamp;
     105             : }
     106             : 
     107             : #if FF_API_FORMAT_GET_SET
     108           0 : MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
     109           0 : MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
     110           0 : MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
     111           0 : MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
     112           0 : MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
     113           0 : MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
     114           0 : MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
     115           0 : MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
     116           0 : MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
     117             : #if FF_API_OLD_OPEN_CALLBACKS
     118             : FF_DISABLE_DEPRECATION_WARNINGS
     119           0 : MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
     120             : FF_ENABLE_DEPRECATION_WARNINGS
     121             : #endif
     122             : #endif
     123             : 
     124       16627 : int64_t av_stream_get_end_pts(const AVStream *st)
     125             : {
     126       16627 :     if (st->internal->priv_pts) {
     127       16627 :         return st->internal->priv_pts->val;
     128             :     } else
     129           0 :         return AV_NOPTS_VALUE;
     130             : }
     131             : 
     132        9155 : struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
     133             : {
     134        9155 :     return st->parser;
     135             : }
     136             : 
     137           0 : void av_format_inject_global_side_data(AVFormatContext *s)
     138             : {
     139             :     int i;
     140           0 :     s->internal->inject_global_side_data = 1;
     141           0 :     for (i = 0; i < s->nb_streams; i++) {
     142           0 :         AVStream *st = s->streams[i];
     143           0 :         st->inject_global_side_data = 1;
     144             :     }
     145           0 : }
     146             : 
     147          73 : int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
     148             : {
     149          73 :     av_assert0(!dst->codec_whitelist &&
     150             :                !dst->format_whitelist &&
     151             :                !dst->protocol_whitelist &&
     152             :                !dst->protocol_blacklist);
     153          73 :     dst-> codec_whitelist = av_strdup(src->codec_whitelist);
     154          73 :     dst->format_whitelist = av_strdup(src->format_whitelist);
     155          73 :     dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
     156          73 :     dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
     157          73 :     if (   (src-> codec_whitelist && !dst-> codec_whitelist)
     158          73 :         || (src->  format_whitelist && !dst->  format_whitelist)
     159          73 :         || (src->protocol_whitelist && !dst->protocol_whitelist)
     160          73 :         || (src->protocol_blacklist && !dst->protocol_blacklist)) {
     161           0 :         av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
     162           0 :         return AVERROR(ENOMEM);
     163             :     }
     164          73 :     return 0;
     165             : }
     166             : 
     167        6931 : static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
     168             : {
     169             : #if FF_API_LAVF_AVCTX
     170             : FF_DISABLE_DEPRECATION_WARNINGS
     171        6931 :     if (st->codec->codec)
     172           0 :         return st->codec->codec;
     173             : FF_ENABLE_DEPRECATION_WARNINGS
     174             : #endif
     175             : 
     176        6931 :     switch (st->codecpar->codec_type) {
     177        4835 :     case AVMEDIA_TYPE_VIDEO:
     178        4835 :         if (s->video_codec)    return s->video_codec;
     179        2835 :         break;
     180        1940 :     case AVMEDIA_TYPE_AUDIO:
     181        1940 :         if (s->audio_codec)    return s->audio_codec;
     182        1929 :         break;
     183          45 :     case AVMEDIA_TYPE_SUBTITLE:
     184          45 :         if (s->subtitle_codec) return s->subtitle_codec;
     185          45 :         break;
     186             :     }
     187             : 
     188        4920 :     return avcodec_find_decoder(codec_id);
     189             : }
     190             : 
     191        7198 : static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
     192             : {
     193             :     const AVCodec *codec;
     194             : 
     195             : #if CONFIG_H264_DECODER
     196             :     /* Other parts of the code assume this decoder to be used for h264,
     197             :      * so force it if possible. */
     198        7198 :     if (codec_id == AV_CODEC_ID_H264)
     199         267 :         return avcodec_find_decoder_by_name("h264");
     200             : #endif
     201             : 
     202        6931 :     codec = find_decoder(s, st, codec_id);
     203        6931 :     if (!codec)
     204         116 :         return NULL;
     205             : 
     206        6815 :     if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
     207           0 :         const AVCodec *probe_codec = NULL;
     208           0 :         while (probe_codec = av_codec_next(probe_codec)) {
     209           0 :             if (probe_codec->id == codec_id &&
     210           0 :                     av_codec_is_decoder(probe_codec) &&
     211           0 :                     !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
     212           0 :                 return probe_codec;
     213             :             }
     214             :         }
     215             :     }
     216             : 
     217        6815 :     return codec;
     218             : }
     219             : 
     220             : #if FF_API_FORMAT_GET_SET
     221           0 : int av_format_get_probe_score(const AVFormatContext *s)
     222             : {
     223           0 :     return s->probe_score;
     224             : }
     225             : #endif
     226             : 
     227             : /* an arbitrarily chosen "sane" max packet size -- 50M */
     228             : #define SANE_CHUNK_SIZE (50000000)
     229             : 
     230        4611 : int ffio_limit(AVIOContext *s, int size)
     231             : {
     232        4611 :     if (s->maxsize>= 0) {
     233        4587 :         int64_t remaining= s->maxsize - avio_tell(s);
     234        4587 :         if (remaining < size) {
     235         326 :             int64_t newsize = avio_size(s);
     236         326 :             if (!s->maxsize || s->maxsize<newsize)
     237         324 :                 s->maxsize = newsize - !newsize;
     238         326 :             remaining= s->maxsize - avio_tell(s);
     239         326 :             remaining= FFMAX(remaining, 0);
     240             :         }
     241             : 
     242        4587 :         if (s->maxsize>= 0 && remaining+1 < size) {
     243           2 :             av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
     244           2 :             size = remaining+1;
     245             :         }
     246             :     }
     247        4611 :     return size;
     248             : }
     249             : 
     250             : /* Read the data in sane-sized chunks and append to pkt.
     251             :  * Return the number of bytes read or an error. */
     252      286466 : static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
     253             : {
     254      286466 :     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
     255      286466 :     int orig_size      = pkt->size;
     256             :     int ret;
     257             : 
     258             :     do {
     259      286466 :         int prev_size = pkt->size;
     260             :         int read_size;
     261             : 
     262             :         /* When the caller requests a lot of data, limit it to the amount
     263             :          * left in file or SANE_CHUNK_SIZE when it is not known. */
     264      286466 :         read_size = size;
     265      286466 :         if (read_size > SANE_CHUNK_SIZE/10) {
     266           0 :             read_size = ffio_limit(s, read_size);
     267             :             // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
     268           0 :             if (s->maxsize < 0)
     269           0 :                 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
     270             :         }
     271             : 
     272      286466 :         ret = av_grow_packet(pkt, read_size);
     273      286466 :         if (ret < 0)
     274           0 :             break;
     275             : 
     276      286466 :         ret = avio_read(s, pkt->data + prev_size, read_size);
     277      286466 :         if (ret != read_size) {
     278         683 :             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
     279         683 :             break;
     280             :         }
     281             : 
     282      285783 :         size -= read_size;
     283      285783 :     } while (size > 0);
     284      286466 :     if (size > 0)
     285         662 :         pkt->flags |= AV_PKT_FLAG_CORRUPT;
     286             : 
     287      286466 :     pkt->pos = orig_pos;
     288      286466 :     if (!pkt->size)
     289        2118 :         av_packet_unref(pkt);
     290      286466 :     return pkt->size > orig_size ? pkt->size - orig_size : ret;
     291             : }
     292             : 
     293      275602 : int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
     294             : {
     295      275602 :     av_init_packet(pkt);
     296      275602 :     pkt->data = NULL;
     297      275602 :     pkt->size = 0;
     298      275602 :     pkt->pos  = avio_tell(s);
     299             : 
     300      275602 :     return append_packet_chunked(s, pkt, size);
     301             : }
     302             : 
     303       11020 : int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
     304             : {
     305       11020 :     if (!pkt->size)
     306         156 :         return av_get_packet(s, pkt, size);
     307       10864 :     return append_packet_chunked(s, pkt, size);
     308             : }
     309             : 
     310         792 : int av_filename_number_test(const char *filename)
     311             : {
     312             :     char buf[1024];
     313        1584 :     return filename &&
     314         792 :            (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
     315             : }
     316             : 
     317        2712 : static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
     318             :                                      AVProbeData *pd)
     319             : {
     320             :     static const struct {
     321             :         const char *name;
     322             :         enum AVCodecID id;
     323             :         enum AVMediaType type;
     324             :     } fmt_id_type[] = {
     325             :         { "aac",       AV_CODEC_ID_AAC,        AVMEDIA_TYPE_AUDIO },
     326             :         { "ac3",       AV_CODEC_ID_AC3,        AVMEDIA_TYPE_AUDIO },
     327             :         { "aptx",      AV_CODEC_ID_APTX,       AVMEDIA_TYPE_AUDIO },
     328             :         { "dts",       AV_CODEC_ID_DTS,        AVMEDIA_TYPE_AUDIO },
     329             :         { "dvbsub",    AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
     330             :         { "dvbtxt",    AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
     331             :         { "eac3",      AV_CODEC_ID_EAC3,       AVMEDIA_TYPE_AUDIO },
     332             :         { "h264",      AV_CODEC_ID_H264,       AVMEDIA_TYPE_VIDEO },
     333             :         { "hevc",      AV_CODEC_ID_HEVC,       AVMEDIA_TYPE_VIDEO },
     334             :         { "loas",      AV_CODEC_ID_AAC_LATM,   AVMEDIA_TYPE_AUDIO },
     335             :         { "m4v",       AV_CODEC_ID_MPEG4,      AVMEDIA_TYPE_VIDEO },
     336             :         { "mjpeg_2000",AV_CODEC_ID_JPEG2000,   AVMEDIA_TYPE_VIDEO },
     337             :         { "mp3",       AV_CODEC_ID_MP3,        AVMEDIA_TYPE_AUDIO },
     338             :         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
     339             :         { "truehd",    AV_CODEC_ID_TRUEHD,     AVMEDIA_TYPE_AUDIO },
     340             :         { 0 }
     341             :     };
     342             :     int score;
     343        2712 :     AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
     344             : 
     345        2712 :     if (fmt) {
     346             :         int i;
     347        2830 :         av_log(s, AV_LOG_DEBUG,
     348             :                "Probe with size=%d, packets=%d detected %s with score=%d\n",
     349        1415 :                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
     350             :                fmt->name, score);
     351       22527 :         for (i = 0; fmt_id_type[i].name; i++) {
     352       21133 :             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
     353         655 :                 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
     354          12 :                     st->codecpar->sample_rate)
     355           0 :                     continue;
     356        1269 :                 if (st->request_probe > score &&
     357         626 :                     st->codecpar->codec_id != fmt_id_type[i].id)
     358         622 :                     continue;
     359          21 :                 st->codecpar->codec_id   = fmt_id_type[i].id;
     360          21 :                 st->codecpar->codec_type = fmt_id_type[i].type;
     361          21 :                 st->internal->need_context_update = 1;
     362             : #if FF_API_LAVF_AVCTX
     363             : FF_DISABLE_DEPRECATION_WARNINGS
     364          21 :                 st->codec->codec_type = st->codecpar->codec_type;
     365          21 :                 st->codec->codec_id   = st->codecpar->codec_id;
     366             : FF_ENABLE_DEPRECATION_WARNINGS
     367             : #endif
     368          21 :                 return score;
     369             :             }
     370             :         }
     371             :     }
     372        2691 :     return 0;
     373             : }
     374             : 
     375             : /************************************************************/
     376             : /* input media file */
     377             : 
     378           0 : int av_demuxer_open(AVFormatContext *ic) {
     379             :     int err;
     380             : 
     381           0 :     if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
     382           0 :         av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
     383           0 :         return AVERROR(EINVAL);
     384             :     }
     385             : 
     386           0 :     if (ic->iformat->read_header) {
     387           0 :         err = ic->iformat->read_header(ic);
     388           0 :         if (err < 0)
     389           0 :             return err;
     390             :     }
     391             : 
     392           0 :     if (ic->pb && !ic->internal->data_offset)
     393           0 :         ic->internal->data_offset = avio_tell(ic->pb);
     394             : 
     395           0 :     return 0;
     396             : }
     397             : 
     398             : /* Open input file and probe the format if necessary. */
     399        5723 : static int init_input(AVFormatContext *s, const char *filename,
     400             :                       AVDictionary **options)
     401             : {
     402             :     int ret;
     403        5723 :     AVProbeData pd = { filename, NULL, 0 };
     404        5723 :     int score = AVPROBE_SCORE_RETRY;
     405             : 
     406        5723 :     if (s->pb) {
     407           4 :         s->flags |= AVFMT_FLAG_CUSTOM_IO;
     408           4 :         if (!s->iformat)
     409           0 :             return av_probe_input_buffer2(s->pb, &s->iformat, filename,
     410           0 :                                          s, 0, s->format_probesize);
     411           4 :         else if (s->iformat->flags & AVFMT_NOFILE)
     412           0 :             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
     413             :                                       "will be ignored with AVFMT_NOFILE format.\n");
     414           4 :         return 0;
     415             :     }
     416             : 
     417        9544 :     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
     418        7034 :         (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
     419        2054 :         return score;
     420             : 
     421        3665 :     if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
     422           0 :         return ret;
     423             : 
     424        3665 :     if (s->iformat)
     425         616 :         return 0;
     426        3049 :     return av_probe_input_buffer2(s->pb, &s->iformat, filename,
     427        3049 :                                  s, 0, s->format_probesize);
     428             : }
     429             : 
     430      290672 : static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
     431             :                          AVPacketList **plast_pktl, int ref)
     432             : {
     433      290672 :     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
     434             :     int ret;
     435             : 
     436      290672 :     if (!pktl)
     437           0 :         return AVERROR(ENOMEM);
     438             : 
     439      290672 :     if (ref) {
     440      131519 :         if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
     441           0 :             av_free(pktl);
     442           0 :             return ret;
     443             :         }
     444             :     } else {
     445      159153 :         pktl->pkt = *pkt;
     446             :     }
     447             : 
     448      290672 :     if (*packet_buffer)
     449      185279 :         (*plast_pktl)->next = pktl;
     450             :     else
     451      105393 :         *packet_buffer = pktl;
     452             : 
     453             :     /* Add the packet in the buffered packet list. */
     454      290672 :     *plast_pktl = pktl;
     455      290672 :     return 0;
     456             : }
     457             : 
     458        8251 : int avformat_queue_attached_pictures(AVFormatContext *s)
     459             : {
     460             :     int i, ret;
     461       17295 :     for (i = 0; i < s->nb_streams; i++)
     462        9061 :         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
     463          17 :             s->streams[i]->discard < AVDISCARD_ALL) {
     464          17 :             if (s->streams[i]->attached_pic.size <= 0) {
     465           0 :                 av_log(s, AV_LOG_WARNING,
     466             :                     "Attached picture on stream %d has invalid size, "
     467             :                     "ignoring\n", i);
     468           0 :                 continue;
     469             :             }
     470             : 
     471          17 :             ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
     472          17 :                                 &s->streams[i]->attached_pic,
     473          17 :                                 &s->internal->raw_packet_buffer_end, 1);
     474          17 :             if (ret < 0)
     475           0 :                 return ret;
     476             :         }
     477        8251 :     return 0;
     478             : }
     479             : 
     480      505067 : static int update_stream_avctx(AVFormatContext *s)
     481             : {
     482             :     int i, ret;
     483     1073509 :     for (i = 0; i < s->nb_streams; i++) {
     484      568442 :         AVStream *st = s->streams[i];
     485             : 
     486      568442 :         if (!st->internal->need_context_update)
     487      562389 :             continue;
     488             : 
     489             :         /* close parser, because it depends on the codec */
     490        6053 :         if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
     491           0 :             av_parser_close(st->parser);
     492           0 :             st->parser = NULL;
     493             :         }
     494             : 
     495             :         /* update internal codec context, for the parser */
     496        6053 :         ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
     497        6053 :         if (ret < 0)
     498           0 :             return ret;
     499             : 
     500             : #if FF_API_LAVF_AVCTX
     501             : FF_DISABLE_DEPRECATION_WARNINGS
     502             :         /* update deprecated public codec context */
     503        6053 :         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
     504        6053 :         if (ret < 0)
     505           0 :             return ret;
     506             : FF_ENABLE_DEPRECATION_WARNINGS
     507             : #endif
     508             : 
     509        6053 :         st->internal->need_context_update = 0;
     510             :     }
     511      505067 :     return 0;
     512             : }
     513             : 
     514             : 
     515        5723 : int avformat_open_input(AVFormatContext **ps, const char *filename,
     516             :                         AVInputFormat *fmt, AVDictionary **options)
     517             : {
     518        5723 :     AVFormatContext *s = *ps;
     519        5723 :     int i, ret = 0;
     520        5723 :     AVDictionary *tmp = NULL;
     521        5723 :     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
     522             : 
     523        5723 :     if (!s && !(s = avformat_alloc_context()))
     524           0 :         return AVERROR(ENOMEM);
     525        5723 :     if (!s->av_class) {
     526           0 :         av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
     527           0 :         return AVERROR(EINVAL);
     528             :     }
     529        5723 :     if (fmt)
     530        2514 :         s->iformat = fmt;
     531             : 
     532        5723 :     if (options)
     533        5633 :         av_dict_copy(&tmp, *options, 0);
     534             : 
     535        5723 :     if (s->pb) // must be before any goto fail
     536           4 :         s->flags |= AVFMT_FLAG_CUSTOM_IO;
     537             : 
     538        5723 :     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
     539           0 :         goto fail;
     540             : 
     541        5723 :     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
     542        5723 :     if ((ret = init_input(s, filename, &tmp)) < 0)
     543           0 :         goto fail;
     544        5723 :     s->probe_score = ret;
     545             : 
     546        5723 :     if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
     547        3595 :         s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
     548        3595 :         if (!s->protocol_whitelist) {
     549           0 :             ret = AVERROR(ENOMEM);
     550           0 :             goto fail;
     551             :         }
     552             :     }
     553             : 
     554        5723 :     if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
     555           0 :         s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
     556           0 :         if (!s->protocol_blacklist) {
     557           0 :             ret = AVERROR(ENOMEM);
     558           0 :             goto fail;
     559             :         }
     560             :     }
     561             : 
     562        5723 :     if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
     563           0 :         av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
     564           0 :         ret = AVERROR(EINVAL);
     565           0 :         goto fail;
     566             :     }
     567             : 
     568        5723 :     avio_skip(s->pb, s->skip_initial_bytes);
     569             : 
     570             :     /* Check filename in case an image number is expected. */
     571        5723 :     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
     572           0 :         if (!av_filename_number_test(filename)) {
     573           0 :             ret = AVERROR(EINVAL);
     574           0 :             goto fail;
     575             :         }
     576             :     }
     577             : 
     578        5723 :     s->duration = s->start_time = AV_NOPTS_VALUE;
     579             : 
     580             :     /* Allocate private data. */
     581        5723 :     if (s->iformat->priv_data_size > 0) {
     582        5595 :         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
     583           0 :             ret = AVERROR(ENOMEM);
     584           0 :             goto fail;
     585             :         }
     586        5595 :         if (s->iformat->priv_class) {
     587        4814 :             *(const AVClass **) s->priv_data = s->iformat->priv_class;
     588        4814 :             av_opt_set_defaults(s->priv_data);
     589        4814 :             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
     590           0 :                 goto fail;
     591             :         }
     592             :     }
     593             : 
     594             :     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
     595        5723 :     if (s->pb)
     596        3669 :         ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
     597             : 
     598             : 
     599        5723 :     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
     600        5723 :         if ((ret = s->iformat->read_header(s)) < 0)
     601           0 :             goto fail;
     602             : 
     603        5723 :     if (!s->metadata) {
     604        4737 :         s->metadata = s->internal->id3v2_meta;
     605        4737 :         s->internal->id3v2_meta = NULL;
     606         986 :     } else if (s->internal->id3v2_meta) {
     607           0 :         int level = AV_LOG_WARNING;
     608           0 :         if (s->error_recognition & AV_EF_COMPLIANT)
     609           0 :             level = AV_LOG_ERROR;
     610           0 :         av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
     611           0 :         av_dict_free(&s->internal->id3v2_meta);
     612           0 :         if (s->error_recognition & AV_EF_EXPLODE)
     613           0 :             return AVERROR_INVALIDDATA;
     614             :     }
     615             : 
     616        5723 :     if (id3v2_extra_meta) {
     617           1 :         if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
     618           0 :             !strcmp(s->iformat->name, "tta")) {
     619           1 :             if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
     620           0 :                 goto fail;
     621           2 :             if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
     622           0 :                 goto fail;
     623             :         } else
     624           0 :             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
     625             :     }
     626        5723 :     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
     627             : 
     628        5723 :     if ((ret = avformat_queue_attached_pictures(s)) < 0)
     629           0 :         goto fail;
     630             : 
     631        5723 :     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
     632        3611 :         s->internal->data_offset = avio_tell(s->pb);
     633             : 
     634        5723 :     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
     635             : 
     636        5723 :     update_stream_avctx(s);
     637             : 
     638       11768 :     for (i = 0; i < s->nb_streams; i++)
     639        6045 :         s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
     640             : 
     641        5723 :     if (options) {
     642        5633 :         av_dict_free(options);
     643        5633 :         *options = tmp;
     644             :     }
     645        5723 :     *ps = s;
     646        5723 :     return 0;
     647             : 
     648           0 : fail:
     649           0 :     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
     650           0 :     av_dict_free(&tmp);
     651           0 :     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
     652           0 :         avio_closep(&s->pb);
     653           0 :     avformat_free_context(s);
     654           0 :     *ps = NULL;
     655           0 :     return ret;
     656             : }
     657             : 
     658             : /*******************************************************/
     659             : 
     660      934899 : static void force_codec_ids(AVFormatContext *s, AVStream *st)
     661             : {
     662      934899 :     switch (st->codecpar->codec_type) {
     663      607828 :     case AVMEDIA_TYPE_VIDEO:
     664      607828 :         if (s->video_codec_id)
     665       66540 :             st->codecpar->codec_id = s->video_codec_id;
     666      607828 :         break;
     667      325281 :     case AVMEDIA_TYPE_AUDIO:
     668      325281 :         if (s->audio_codec_id)
     669        1032 :             st->codecpar->codec_id = s->audio_codec_id;
     670      325281 :         break;
     671        1680 :     case AVMEDIA_TYPE_SUBTITLE:
     672        1680 :         if (s->subtitle_codec_id)
     673           0 :             st->codecpar->codec_id = s->subtitle_codec_id;
     674        1680 :         break;
     675         108 :     case AVMEDIA_TYPE_DATA:
     676         108 :         if (s->data_codec_id)
     677           0 :             st->codecpar->codec_id = s->data_codec_id;
     678         108 :         break;
     679             :     }
     680      934899 : }
     681             : 
     682       13458 : static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
     683             : {
     684       13458 :     if (st->request_probe>0) {
     685       13416 :         AVProbeData *pd = &st->probe_data;
     686             :         int end;
     687       13416 :         av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
     688       13416 :         --st->probe_packets;
     689             : 
     690       13416 :         if (pkt) {
     691       13282 :             uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
     692       13282 :             if (!new_buf) {
     693           0 :                 av_log(s, AV_LOG_WARNING,
     694             :                        "Failed to reallocate probe buffer for stream %d\n",
     695             :                        st->index);
     696           0 :                 goto no_packet;
     697             :             }
     698       13282 :             pd->buf = new_buf;
     699       13282 :             memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
     700       13282 :             pd->buf_size += pkt->size;
     701       13282 :             memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
     702             :         } else {
     703         134 : no_packet:
     704         134 :             st->probe_packets = 0;
     705         134 :             if (!pd->buf_size) {
     706           0 :                 av_log(s, AV_LOG_WARNING,
     707             :                        "nothing to probe for stream %d\n", st->index);
     708             :             }
     709             :         }
     710             : 
     711       26832 :         end=    s->internal->raw_packet_buffer_remaining_size <= 0
     712       13416 :                 || st->probe_packets<= 0;
     713             : 
     714       13416 :         if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
     715        2712 :             int score = set_codec_from_probe_data(s, st, pd);
     716        2712 :             if (    (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
     717        2695 :                 || end) {
     718         478 :                 pd->buf_size = 0;
     719         478 :                 av_freep(&pd->buf);
     720         478 :                 st->request_probe = -1;
     721         478 :                 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
     722         478 :                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
     723             :                 } else
     724           0 :                     av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
     725             :             }
     726        2712 :             force_codec_ids(s, st);
     727             :         }
     728             :     }
     729       13458 :     return 0;
     730             : }
     731             : 
     732      932187 : static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
     733             : {
     734      932187 :     int64_t ref = pkt->dts;
     735             :     int i, pts_wrap_behavior;
     736             :     int64_t pts_wrap_reference;
     737             :     AVProgram *first_program;
     738             : 
     739      932187 :     if (ref == AV_NOPTS_VALUE)
     740      773739 :         ref = pkt->pts;
     741      932187 :     if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
     742      932010 :         return 0;
     743         177 :     ref &= (1LL << st->pts_wrap_bits)-1;
     744             : 
     745             :     // reference time stamp should be 60 s before first time stamp
     746         177 :     pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
     747             :     // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
     748         358 :     pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
     749           4 :         (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
     750         350 :         AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
     751             : 
     752         177 :     first_program = av_find_program_from_stream(s, NULL, stream_index);
     753             : 
     754         177 :     if (!first_program) {
     755         143 :         int default_stream_index = av_find_default_stream_index(s);
     756         143 :         if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
     757         339 :             for (i = 0; i < s->nb_streams; i++) {
     758         207 :                 if (av_find_program_from_stream(s, NULL, i))
     759           0 :                     continue;
     760         207 :                 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
     761         207 :                 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
     762             :             }
     763             :         }
     764             :         else {
     765          11 :             st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
     766          11 :             st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
     767             :         }
     768             :     }
     769             :     else {
     770          34 :         AVProgram *program = first_program;
     771         102 :         while (program) {
     772          34 :             if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
     773           0 :                 pts_wrap_reference = program->pts_wrap_reference;
     774           0 :                 pts_wrap_behavior = program->pts_wrap_behavior;
     775           0 :                 break;
     776             :             }
     777          34 :             program = av_find_program_from_stream(s, program, stream_index);
     778             :         }
     779             : 
     780             :         // update every program with differing pts_wrap_reference
     781          34 :         program = first_program;
     782         102 :         while (program) {
     783          34 :             if (program->pts_wrap_reference != pts_wrap_reference) {
     784          84 :                 for (i = 0; i<program->nb_stream_indexes; i++) {
     785          50 :                     s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
     786          50 :                     s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
     787             :                 }
     788             : 
     789          34 :                 program->pts_wrap_reference = pts_wrap_reference;
     790          34 :                 program->pts_wrap_behavior = pts_wrap_behavior;
     791             :             }
     792          34 :             program = av_find_program_from_stream(s, program, stream_index);
     793             :         }
     794             :     }
     795         177 :     return 1;
     796             : }
     797             : 
     798      951750 : int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
     799             : {
     800             :     int ret, i, err;
     801             :     AVStream *st;
     802             : 
     803       13781 :     for (;;) {
     804      951750 :         AVPacketList *pktl = s->internal->raw_packet_buffer;
     805             : 
     806      951750 :         if (pktl) {
     807       26207 :             *pkt = pktl->pkt;
     808       26207 :             st   = s->streams[pkt->stream_index];
     809       26207 :             if (s->internal->raw_packet_buffer_remaining_size <= 0)
     810           0 :                 if ((err = probe_codec(s, st, NULL)) < 0)
     811           0 :                     return err;
     812       26207 :             if (st->request_probe <= 0) {
     813       13227 :                 s->internal->raw_packet_buffer                 = pktl->next;
     814       13227 :                 s->internal->raw_packet_buffer_remaining_size += pkt->size;
     815       13227 :                 av_free(pktl);
     816       13227 :                 return 0;
     817             :             }
     818             :         }
     819             : 
     820      938523 :         pkt->data = NULL;
     821      938523 :         pkt->size = 0;
     822      938523 :         av_init_packet(pkt);
     823      938523 :         ret = s->iformat->read_packet(s, pkt);
     824      938523 :         if (ret < 0) {
     825             :             /* Some demuxers return FFERROR_REDO when they consume
     826             :                data and discard it (ignored streams, junk, extradata).
     827             :                We must re-call the demuxer to get the real packet. */
     828        6336 :             if (ret == FFERROR_REDO)
     829         323 :                 continue;
     830        6013 :             if (!pktl || ret == AVERROR(EAGAIN))
     831        5879 :                 return ret;
     832         268 :             for (i = 0; i < s->nb_streams; i++) {
     833         134 :                 st = s->streams[i];
     834         134 :                 if (st->probe_packets || st->request_probe > 0)
     835         134 :                     if ((err = probe_codec(s, st, NULL)) < 0)
     836           0 :                         return err;
     837         134 :                 av_assert0(st->request_probe <= 0);
     838             :             }
     839         134 :             continue;
     840             :         }
     841             : 
     842      932187 :         if (!pkt->buf) {
     843        2296 :             AVPacket tmp = { 0 };
     844        2296 :             ret = av_packet_ref(&tmp, pkt);
     845        2296 :             if (ret < 0)
     846           0 :                 return ret;
     847        2296 :             *pkt = tmp;
     848             :         }
     849             : 
     850      932187 :         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
     851           0 :             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
     852           0 :             av_log(s, AV_LOG_WARNING,
     853             :                    "Dropped corrupted packet (stream = %d)\n",
     854             :                    pkt->stream_index);
     855           0 :             av_packet_unref(pkt);
     856           0 :             continue;
     857             :         }
     858             : 
     859      932187 :         if (pkt->stream_index >= (unsigned)s->nb_streams) {
     860           0 :             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
     861           0 :             continue;
     862             :         }
     863             : 
     864      932187 :         st = s->streams[pkt->stream_index];
     865             : 
     866      932187 :         if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
     867             :             // correct first time stamps to negative values
     868           4 :             if (!is_relative(st->first_dts))
     869           4 :                 st->first_dts = wrap_timestamp(st, st->first_dts);
     870           4 :             if (!is_relative(st->start_time))
     871           4 :                 st->start_time = wrap_timestamp(st, st->start_time);
     872           4 :             if (!is_relative(st->cur_dts))
     873           0 :                 st->cur_dts = wrap_timestamp(st, st->cur_dts);
     874             :         }
     875             : 
     876      932187 :         pkt->dts = wrap_timestamp(st, pkt->dts);
     877      932187 :         pkt->pts = wrap_timestamp(st, pkt->pts);
     878             : 
     879      932187 :         force_codec_ids(s, st);
     880             : 
     881             :         /* TODO: audio: time filter; video: frame reordering (pts != dts) */
     882      932187 :         if (s->use_wallclock_as_timestamps)
     883           0 :             pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
     884             : 
     885      932187 :         if (!pktl && st->request_probe <= 0)
     886      918863 :             return ret;
     887             : 
     888       13324 :         err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
     889       13324 :                             &s->internal->raw_packet_buffer_end, 0);
     890       13324 :         if (err)
     891           0 :             return err;
     892       13324 :         s->internal->raw_packet_buffer_remaining_size -= pkt->size;
     893             : 
     894       13324 :         if ((err = probe_codec(s, st, pkt)) < 0)
     895           0 :             return err;
     896             :     }
     897             : }
     898             : 
     899             : 
     900             : /**********************************************************/
     901             : 
     902       74731 : static int determinable_frame_size(AVCodecContext *avctx)
     903             : {
     904       74731 :     switch(avctx->codec_id) {
     905         167 :     case AV_CODEC_ID_MP1:
     906             :     case AV_CODEC_ID_MP2:
     907             :     case AV_CODEC_ID_MP3:
     908         167 :         return 1;
     909             :     }
     910             : 
     911       74564 :     return 0;
     912             : }
     913             : 
     914             : /**
     915             :  * Return the frame duration in seconds. Return 0 if not available.
     916             :  */
     917      378695 : void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
     918             :                                AVCodecParserContext *pc, AVPacket *pkt)
     919             : {
     920      466710 :     AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
     921       88015 :                                               av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
     922             :     int frame_size, sample_rate;
     923             : 
     924             : #if FF_API_LAVF_AVCTX
     925             : FF_DISABLE_DEPRECATION_WARNINGS
     926      378695 :     if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
     927      211447 :         codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
     928             : FF_ENABLE_DEPRECATION_WARNINGS
     929             : #endif
     930             : 
     931      378695 :     *pnum = 0;
     932      378695 :     *pden = 0;
     933      378695 :     switch (st->codecpar->codec_type) {
     934      257745 :     case AVMEDIA_TYPE_VIDEO:
     935      257745 :         if (st->r_frame_rate.num && !pc && s->iformat) {
     936       45544 :             *pnum = st->r_frame_rate.den;
     937       45544 :             *pden = st->r_frame_rate.num;
     938      212201 :         } else if (st->time_base.num * 1000LL > st->time_base.den) {
     939      161263 :             *pnum = st->time_base.num;
     940      161263 :             *pden = st->time_base.den;
     941       50938 :         } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
     942       49737 :             av_assert0(st->internal->avctx->ticks_per_frame);
     943       99474 :             av_reduce(pnum, pden,
     944       49737 :                       codec_framerate.den,
     945       49737 :                       codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
     946             :                       INT_MAX);
     947             : 
     948       49737 :             if (pc && pc->repeat_pict) {
     949       23900 :                 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
     950       47800 :                 av_reduce(pnum, pden,
     951       23900 :                           (*pnum) * (1LL + pc->repeat_pict),
     952       23900 :                           (*pden),
     953             :                           INT_MAX);
     954             :             }
     955             :             /* If this codec can be interlaced or progressive then we need
     956             :              * a parser to compute duration of a packet. Thus if we have
     957             :              * no parser in such case leave duration undefined. */
     958       49737 :             if (st->internal->avctx->ticks_per_frame > 1 && !pc)
     959          51 :                 *pnum = *pden = 0;
     960             :         }
     961      257745 :         break;
     962      120285 :     case AVMEDIA_TYPE_AUDIO:
     963      120285 :         if (st->internal->avctx_inited) {
     964       33308 :             frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
     965       33308 :             sample_rate = st->internal->avctx->sample_rate;
     966             :         } else {
     967       86977 :             frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
     968       86977 :             sample_rate = st->codecpar->sample_rate;
     969             :         }
     970      236360 :         if (frame_size <= 0 || sample_rate <= 0)
     971             :             break;
     972      116064 :         *pnum = frame_size;
     973      116064 :         *pden = sample_rate;
     974      116064 :         break;
     975         665 :     default:
     976         665 :         break;
     977             :     }
     978      382916 : }
     979             : 
     980      495216 : static int is_intra_only(enum AVCodecID id)
     981             : {
     982      495216 :     const AVCodecDescriptor *d = avcodec_descriptor_get(id);
     983      495216 :     if (!d)
     984          74 :         return 0;
     985      495142 :     if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
     986       83233 :         return 0;
     987      411909 :     return 1;
     988             : }
     989             : 
     990      606946 : static int has_decode_delay_been_guessed(AVStream *st)
     991             : {
     992      606946 :     if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
     993       19878 :     if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
     994        3875 :         return 1;
     995             : #if CONFIG_H264_DECODER
     996       26102 :     if (st->internal->avctx->has_b_frames &&
     997       10099 :        avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
     998         948 :         return 1;
     999             : #endif
    1000       15055 :     if (st->internal->avctx->has_b_frames<3)
    1001       14565 :         return st->nb_decoded_frames >= 7;
    1002         490 :     else if (st->internal->avctx->has_b_frames<4)
    1003          36 :         return st->nb_decoded_frames >= 18;
    1004             :     else
    1005         454 :         return st->nb_decoded_frames >= 20;
    1006             : }
    1007             : 
    1008       16557 : static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
    1009             : {
    1010       16557 :     if (pktl->next)
    1011       15387 :         return pktl->next;
    1012        1170 :     if (pktl == s->internal->packet_buffer_end)
    1013        1154 :         return s->internal->parse_queue;
    1014          16 :     return NULL;
    1015             : }
    1016             : 
    1017      456223 : static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
    1018      907921 :     int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
    1019      451698 :                        st->codecpar->codec_id != AV_CODEC_ID_HEVC;
    1020             : 
    1021      456223 :     if(!onein_oneout) {
    1022        4647 :         int delay = st->internal->avctx->has_b_frames;
    1023             :         int i;
    1024             : 
    1025        4647 :         if (dts == AV_NOPTS_VALUE) {
    1026         682 :             int64_t best_score = INT64_MAX;
    1027        1232 :             for (i = 0; i<delay; i++) {
    1028         550 :                 if (st->pts_reorder_error_count[i]) {
    1029           0 :                     int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
    1030           0 :                     if (score < best_score) {
    1031           0 :                         best_score = score;
    1032           0 :                         dts = pts_buffer[i];
    1033             :                     }
    1034             :                 }
    1035             :             }
    1036             :         } else {
    1037        7651 :             for (i = 0; i<delay; i++) {
    1038        3686 :                 if (pts_buffer[i] != AV_NOPTS_VALUE) {
    1039        7154 :                     int64_t diff =  FFABS(pts_buffer[i] - dts)
    1040        3577 :                                     + (uint64_t)st->pts_reorder_error[i];
    1041        3577 :                     diff = FFMAX(diff, st->pts_reorder_error[i]);
    1042        3577 :                     st->pts_reorder_error[i] = diff;
    1043        3577 :                     st->pts_reorder_error_count[i]++;
    1044        3577 :                     if (st->pts_reorder_error_count[i] > 250) {
    1045           1 :                         st->pts_reorder_error[i] >>= 1;
    1046           1 :                         st->pts_reorder_error_count[i] >>= 1;
    1047             :                     }
    1048             :                 }
    1049             :             }
    1050             :         }
    1051             :     }
    1052             : 
    1053      456223 :     if (dts == AV_NOPTS_VALUE)
    1054         857 :         dts = pts_buffer[0];
    1055             : 
    1056      456223 :     return dts;
    1057             : }
    1058             : 
    1059             : /**
    1060             :  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
    1061             :  * of the packets in a window.
    1062             :  */
    1063        4420 : static void update_dts_from_pts(AVFormatContext *s, int stream_index,
    1064             :                                 AVPacketList *pkt_buffer)
    1065             : {
    1066        4420 :     AVStream *st       = s->streams[stream_index];
    1067        4420 :     int delay          = st->internal->avctx->has_b_frames;
    1068             :     int i;
    1069             : 
    1070             :     int64_t pts_buffer[MAX_REORDER_DELAY+1];
    1071             : 
    1072       79560 :     for (i = 0; i<MAX_REORDER_DELAY+1; i++)
    1073       75140 :         pts_buffer[i] = AV_NOPTS_VALUE;
    1074             : 
    1075        7488 :     for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
    1076        3068 :         if (pkt_buffer->pkt.stream_index != stream_index)
    1077        2583 :             continue;
    1078             : 
    1079         485 :         if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
    1080         393 :             pts_buffer[0] = pkt_buffer->pkt.pts;
    1081         470 :             for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
    1082          77 :                 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
    1083             : 
    1084         393 :             pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
    1085             :         }
    1086             :     }
    1087        4420 : }
    1088             : 
    1089      491890 : static void update_initial_timestamps(AVFormatContext *s, int stream_index,
    1090             :                                       int64_t dts, int64_t pts, AVPacket *pkt)
    1091             : {
    1092      491890 :     AVStream *st       = s->streams[stream_index];
    1093      491890 :     AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
    1094             :     AVPacketList *pktl_it;
    1095             : 
    1096             :     uint64_t shift;
    1097             : 
    1098      491890 :     if (st->first_dts != AV_NOPTS_VALUE ||
    1099        4447 :         dts           == AV_NOPTS_VALUE ||
    1100        8894 :         st->cur_dts   == AV_NOPTS_VALUE ||
    1101        4447 :         is_relative(dts))
    1102      487443 :         return;
    1103             : 
    1104        4447 :     st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
    1105        4447 :     st->cur_dts   = dts;
    1106        4447 :     shift         = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
    1107             : 
    1108        4447 :     if (is_relative(pts))
    1109           0 :         pts += shift;
    1110             : 
    1111        7214 :     for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
    1112        2767 :         if (pktl_it->pkt.stream_index != stream_index)
    1113        2460 :             continue;
    1114         307 :         if (is_relative(pktl_it->pkt.pts))
    1115         205 :             pktl_it->pkt.pts += shift;
    1116             : 
    1117         307 :         if (is_relative(pktl_it->pkt.dts))
    1118         228 :             pktl_it->pkt.dts += shift;
    1119             : 
    1120         307 :         if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
    1121          17 :             st->start_time = pktl_it->pkt.pts;
    1122          17 :             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
    1123           0 :                 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
    1124             :         }
    1125             :     }
    1126             : 
    1127        4447 :     if (has_decode_delay_been_guessed(st)) {
    1128        4404 :         update_dts_from_pts(s, stream_index, pktl);
    1129             :     }
    1130             : 
    1131        4447 :     if (st->start_time == AV_NOPTS_VALUE) {
    1132        1595 :         st->start_time = pts;
    1133        1595 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
    1134         376 :             st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
    1135             :     }
    1136             : }
    1137             : 
    1138      161550 : static void update_initial_durations(AVFormatContext *s, AVStream *st,
    1139             :                                      int stream_index, int duration)
    1140             : {
    1141      161550 :     AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
    1142      161550 :     int64_t cur_dts    = RELATIVE_TS_BASE;
    1143             : 
    1144      161550 :     if (st->first_dts != AV_NOPTS_VALUE) {
    1145       79991 :         if (st->update_initial_durations_done)
    1146       77518 :             return;
    1147        2473 :         st->update_initial_durations_done = 1;
    1148        2473 :         cur_dts = st->first_dts;
    1149        3123 :         for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
    1150        3123 :             if (pktl->pkt.stream_index == stream_index) {
    1151        4884 :                 if (pktl->pkt.pts != pktl->pkt.dts  ||
    1152        2411 :                     pktl->pkt.dts != AV_NOPTS_VALUE ||
    1153          11 :                     pktl->pkt.duration)
    1154             :                     break;
    1155          11 :                 cur_dts -= duration;
    1156             :             }
    1157             :         }
    1158        2473 :         if (pktl && pktl->pkt.dts != st->first_dts) {
    1159         100 :             av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
    1160          75 :                    av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
    1161          25 :             return;
    1162             :         }
    1163        2448 :         if (!pktl) {
    1164           0 :             av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
    1165           0 :             return;
    1166             :         }
    1167        2448 :         pktl          = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
    1168        2448 :         st->first_dts = cur_dts;
    1169       81559 :     } else if (st->cur_dts != RELATIVE_TS_BASE)
    1170       54851 :         return;
    1171             : 
    1172       39228 :     for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
    1173       38827 :         if (pktl->pkt.stream_index != stream_index)
    1174        9960 :             continue;
    1175       29298 :         if ((pktl->pkt.pts == pktl->pkt.dts ||
    1176       28880 :              pktl->pkt.pts == AV_NOPTS_VALUE) &&
    1177       30937 :             (pktl->pkt.dts == AV_NOPTS_VALUE ||
    1178        2612 :              pktl->pkt.dts == st->first_dts ||
    1179       28451 :              pktl->pkt.dts == RELATIVE_TS_BASE) &&
    1180       28327 :             !pktl->pkt.duration) {
    1181         112 :             pktl->pkt.dts = cur_dts;
    1182         112 :             if (!st->internal->avctx->has_b_frames)
    1183          96 :                 pktl->pkt.pts = cur_dts;
    1184             : //            if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
    1185         112 :                 pktl->pkt.duration = duration;
    1186             :         } else
    1187             :             break;
    1188         112 :         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
    1189             :     }
    1190       29156 :     if (!pktl)
    1191         401 :         st->cur_dts = cur_dts;
    1192             : }
    1193             : 
    1194      495216 : static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
    1195             :                                AVCodecParserContext *pc, AVPacket *pkt,
    1196             :                                int64_t next_dts, int64_t next_pts)
    1197             : {
    1198             :     int num, den, presentation_delayed, delay, i;
    1199             :     int64_t offset;
    1200             :     AVRational duration;
    1201      962358 :     int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
    1202      467142 :                        st->codecpar->codec_id != AV_CODEC_ID_HEVC;
    1203             : 
    1204      495216 :     if (s->flags & AVFMT_FLAG_NOFILLIN)
    1205           0 :         return;
    1206             : 
    1207      495216 :     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
    1208       56103 :         if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
    1209       29830 :             if (st->last_dts_for_order_check <= pkt->dts) {
    1210       29827 :                 st->dts_ordered++;
    1211             :             } else {
    1212           3 :                 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
    1213             :                        "DTS %"PRIi64" < %"PRIi64" out of order\n",
    1214             :                        pkt->dts,
    1215             :                        st->last_dts_for_order_check);
    1216           3 :                 st->dts_misordered++;
    1217             :             }
    1218       29830 :             if (st->dts_ordered + st->dts_misordered > 250) {
    1219          14 :                 st->dts_ordered    >>= 1;
    1220          14 :                 st->dts_misordered >>= 1;
    1221             :             }
    1222             :         }
    1223             : 
    1224       56103 :         st->last_dts_for_order_check = pkt->dts;
    1225       56103 :         if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
    1226           8 :             pkt->dts = AV_NOPTS_VALUE;
    1227             :     }
    1228             : 
    1229      495216 :     if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
    1230           0 :         pkt->dts = AV_NOPTS_VALUE;
    1231             : 
    1232      495216 :     if (pc && pc->pict_type == AV_PICTURE_TYPE_B
    1233       21163 :         && !st->internal->avctx->has_b_frames)
    1234             :         //FIXME Set low_delay = 0 when has_b_frames = 1
    1235          50 :         st->internal->avctx->has_b_frames = 1;
    1236             : 
    1237             :     /* do we have a video B-frame ? */
    1238      495216 :     delay = st->internal->avctx->has_b_frames;
    1239      495216 :     presentation_delayed = 0;
    1240             : 
    1241             :     /* XXX: need has_b_frame, but cannot get it if the codec is
    1242             :      *  not initialized */
    1243      495216 :     if (delay &&
    1244       32777 :         pc && pc->pict_type != AV_PICTURE_TYPE_B)
    1245       11614 :         presentation_delayed = 1;
    1246             : 
    1247      624924 :     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
    1248      144104 :         st->pts_wrap_bits < 63 &&
    1249       14396 :         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
    1250           0 :         if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
    1251           0 :             pkt->dts -= 1LL << st->pts_wrap_bits;
    1252             :         } else
    1253           0 :             pkt->pts += 1LL << st->pts_wrap_bits;
    1254             :     }
    1255             : 
    1256             :     /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
    1257             :      * We take the conservative approach and discard both.
    1258             :      * Note: If this is misbehaving for an H.264 file, then possibly
    1259             :      * presentation_delayed is not set correctly. */
    1260      513728 :     if (delay == 1 && pkt->dts == pkt->pts &&
    1261       22389 :         pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
    1262         355 :         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
    1263         355 :         if (    strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
    1264         291 :              && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
    1265          20 :             pkt->dts = AV_NOPTS_VALUE;
    1266             :     }
    1267             : 
    1268      495216 :     duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
    1269      495216 :     if (pkt->duration == 0) {
    1270      289264 :         ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
    1271      289264 :         if (den && num) {
    1272      281717 :             duration = (AVRational) {num, den};
    1273      845151 :             pkt->duration = av_rescale_rnd(1,
    1274      281717 :                                            num * (int64_t) st->time_base.den,
    1275      281717 :                                            den * (int64_t) st->time_base.num,
    1276             :                                            AV_ROUND_DOWN);
    1277             :         }
    1278             :     }
    1279             : 
    1280      495216 :     if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
    1281      161550 :         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
    1282             : 
    1283             :     /* Correct timestamps with byte offset if demuxers only have timestamps
    1284             :      * on packet boundaries */
    1285      495216 :     if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
    1286             :         /* this will estimate bitrate based on this frame's duration and size */
    1287         856 :         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
    1288         856 :         if (pkt->pts != AV_NOPTS_VALUE)
    1289         547 :             pkt->pts += offset;
    1290         856 :         if (pkt->dts != AV_NOPTS_VALUE)
    1291         113 :             pkt->dts += offset;
    1292             :     }
    1293             : 
    1294             :     /* This may be redundant, but it should not hurt. */
    1295      651446 :     if (pkt->dts != AV_NOPTS_VALUE &&
    1296      285918 :         pkt->pts != AV_NOPTS_VALUE &&
    1297      129688 :         pkt->pts > pkt->dts)
    1298        3510 :         presentation_delayed = 1;
    1299             : 
    1300      495216 :     if (s->debug & FF_FDEBUG_TS)
    1301           0 :         av_log(s, AV_LOG_TRACE,
    1302             :             "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
    1303           0 :             presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
    1304             :             pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
    1305             : 
    1306             :     /* Interpolate PTS and DTS if they are not present. We skip H264
    1307             :      * currently because delay and has_b_frames are not reliably set. */
    1308      495216 :     if ((delay == 0 || (delay == 1 && pc)) &&
    1309             :         onein_oneout) {
    1310      453504 :         if (presentation_delayed) {
    1311             :             /* DTS = decompression timestamp */
    1312             :             /* PTS = presentation timestamp */
    1313        5045 :             if (pkt->dts == AV_NOPTS_VALUE)
    1314        2683 :                 pkt->dts = st->last_IP_pts;
    1315        5045 :             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
    1316        5045 :             if (pkt->dts == AV_NOPTS_VALUE)
    1317        2403 :                 pkt->dts = st->cur_dts;
    1318             : 
    1319             :             /* This is tricky: the dts must be incremented by the duration
    1320             :              * of the frame we are displaying, i.e. the last I- or P-frame. */
    1321        5045 :             if (st->last_IP_duration == 0)
    1322         341 :                 st->last_IP_duration = pkt->duration;
    1323        5045 :             if (pkt->dts != AV_NOPTS_VALUE)
    1324        5045 :                 st->cur_dts = pkt->dts + st->last_IP_duration;
    1325       10090 :             if (pkt->dts != AV_NOPTS_VALUE &&
    1326        8150 :                 pkt->pts == AV_NOPTS_VALUE &&
    1327        6208 :                 st->last_IP_duration > 0 &&
    1328        3815 :                 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
    1329         704 :                 next_dts != next_pts &&
    1330             :                 next_pts != AV_NOPTS_VALUE)
    1331          11 :                 pkt->pts = next_dts;
    1332             : 
    1333        5045 :             st->last_IP_duration = pkt->duration;
    1334        5045 :             st->last_IP_pts      = pkt->pts;
    1335             :             /* Cannot compute PTS if not present (we can compute it only
    1336             :              * by knowing the future. */
    1337      628841 :         } else if (pkt->pts != AV_NOPTS_VALUE ||
    1338      334994 :                    pkt->dts != AV_NOPTS_VALUE ||
    1339      154612 :                    pkt->duration                ) {
    1340             : 
    1341             :             /* presentation is not delayed : PTS and DTS are the same */
    1342      447271 :             if (pkt->pts == AV_NOPTS_VALUE)
    1343      179194 :                 pkt->pts = pkt->dts;
    1344      447271 :             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
    1345             :                                       pkt->pts, pkt);
    1346      447271 :             if (pkt->pts == AV_NOPTS_VALUE)
    1347      153424 :                 pkt->pts = st->cur_dts;
    1348      447271 :             pkt->dts = pkt->pts;
    1349      447271 :             if (pkt->pts != AV_NOPTS_VALUE)
    1350      447271 :                 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
    1351             :         }
    1352             :     }
    1353             : 
    1354      495216 :     if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
    1355      456224 :         st->pts_buffer[0] = pkt->pts;
    1356      464365 :         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
    1357        8141 :             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
    1358             : 
    1359      456224 :         if(has_decode_delay_been_guessed(st))
    1360      455830 :             pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
    1361             :     }
    1362             :     // We skipped it above so we try here.
    1363      495216 :     if (!onein_oneout)
    1364             :         // This should happen on the first packet
    1365       39574 :         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
    1366      495216 :     if (pkt->dts > st->cur_dts)
    1367        4674 :         st->cur_dts = pkt->dts;
    1368             : 
    1369      495216 :     if (s->debug & FF_FDEBUG_TS)
    1370           0 :         av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
    1371           0 :             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
    1372             : 
    1373             :     /* update flags */
    1374      495216 :     if (is_intra_only(st->codecpar->codec_id))
    1375      411909 :         pkt->flags |= AV_PKT_FLAG_KEY;
    1376             : #if FF_API_CONVERGENCE_DURATION
    1377             : FF_DISABLE_DEPRECATION_WARNINGS
    1378      495216 :     if (pc)
    1379      131502 :         pkt->convergence_duration = pc->convergence_duration;
    1380             : FF_ENABLE_DEPRECATION_WARNINGS
    1381             : #endif
    1382             : }
    1383             : 
    1384       64923 : static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
    1385             : {
    1386      209764 :     while (*pkt_buf) {
    1387       79918 :         AVPacketList *pktl = *pkt_buf;
    1388       79918 :         *pkt_buf = pktl->next;
    1389       79918 :         av_packet_unref(&pktl->pkt);
    1390       79918 :         av_freep(&pktl);
    1391             :     }
    1392       64923 :     *pkt_buf_end = NULL;
    1393       64923 : }
    1394             : 
    1395             : /**
    1396             :  * Parse a packet, add all split parts to parse_queue.
    1397             :  *
    1398             :  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
    1399             :  */
    1400      565086 : static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
    1401             : {
    1402      565086 :     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
    1403      565086 :     AVStream *st = s->streams[stream_index];
    1404      565086 :     uint8_t *data = pkt ? pkt->data : NULL;
    1405      565086 :     int size      = pkt ? pkt->size : 0;
    1406      565086 :     int ret = 0, got_output = 0;
    1407             : 
    1408      565086 :     if (!pkt) {
    1409        1511 :         av_init_packet(&flush_pkt);
    1410        1511 :         pkt        = &flush_pkt;
    1411        1511 :         got_output = 1;
    1412      563575 :     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
    1413             :         // preserve 0-size sync packets
    1414           0 :         compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
    1415             :     }
    1416             : 
    1417     1773527 :     while (size > 0 || (pkt == &flush_pkt && got_output)) {
    1418             :         int len;
    1419      643355 :         int64_t next_pts = pkt->pts;
    1420      643355 :         int64_t next_dts = pkt->dts;
    1421             : 
    1422      643355 :         av_init_packet(&out_pkt);
    1423      643355 :         len = av_parser_parse2(st->parser, st->internal->avctx,
    1424             :                                &out_pkt.data, &out_pkt.size, data, size,
    1425             :                                pkt->pts, pkt->dts, pkt->pos);
    1426             : 
    1427      643355 :         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
    1428      643355 :         pkt->pos = -1;
    1429             :         /* increment read pointer */
    1430      643355 :         data += len;
    1431      643355 :         size -= len;
    1432             : 
    1433      643355 :         got_output = !!out_pkt.size;
    1434             : 
    1435      643355 :         if (!out_pkt.size)
    1436      511853 :             continue;
    1437             : 
    1438      131502 :         if (pkt->side_data) {
    1439        5095 :             out_pkt.side_data       = pkt->side_data;
    1440        5095 :             out_pkt.side_data_elems = pkt->side_data_elems;
    1441        5095 :             pkt->side_data          = NULL;
    1442        5095 :             pkt->side_data_elems    = 0;
    1443             :         }
    1444             : 
    1445             :         /* set the duration */
    1446      131502 :         out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
    1447      131502 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
    1448       74222 :             if (st->internal->avctx->sample_rate > 0) {
    1449       74138 :                 out_pkt.duration =
    1450       74138 :                     av_rescale_q_rnd(st->parser->duration,
    1451       74138 :                                      (AVRational) { 1, st->internal->avctx->sample_rate },
    1452             :                                      st->time_base,
    1453             :                                      AV_ROUND_DOWN);
    1454             :             }
    1455             :         }
    1456             : 
    1457      131502 :         out_pkt.stream_index = st->index;
    1458      131502 :         out_pkt.pts          = st->parser->pts;
    1459      131502 :         out_pkt.dts          = st->parser->dts;
    1460      131502 :         out_pkt.pos          = st->parser->pos;
    1461      131502 :         out_pkt.flags       |= pkt->flags & AV_PKT_FLAG_DISCARD;
    1462             : 
    1463      131502 :         if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
    1464       80983 :             out_pkt.pos = st->parser->frame_offset;
    1465             : 
    1466      261015 :         if (st->parser->key_frame == 1 ||
    1467      220773 :             (st->parser->key_frame == -1 &&
    1468       91260 :              st->parser->pict_type == AV_PICTURE_TYPE_I))
    1469       82844 :             out_pkt.flags |= AV_PKT_FLAG_KEY;
    1470             : 
    1471      131502 :         if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
    1472         252 :             out_pkt.flags |= AV_PKT_FLAG_KEY;
    1473             : 
    1474      131502 :         compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
    1475             : 
    1476      131502 :         ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
    1477      131502 :                             &s->internal->parse_queue_end, 1);
    1478      131502 :         av_packet_unref(&out_pkt);
    1479      131502 :         if (ret < 0)
    1480           0 :             goto fail;
    1481             :     }
    1482             : 
    1483             :     /* end of the stream => close and free the parser */
    1484      565086 :     if (pkt == &flush_pkt) {
    1485        1511 :         av_parser_close(st->parser);
    1486        1511 :         st->parser = NULL;
    1487             :     }
    1488             : 
    1489     1128661 : fail:
    1490      565086 :     av_packet_unref(pkt);
    1491      565086 :     return ret;
    1492             : }
    1493             : 
    1494      197527 : static int read_from_packet_buffer(AVPacketList **pkt_buffer,
    1495             :                                    AVPacketList **pkt_buffer_end,
    1496             :                                    AVPacket      *pkt)
    1497             : {
    1498             :     AVPacketList *pktl;
    1499      197527 :     av_assert0(*pkt_buffer);
    1500      197527 :     pktl        = *pkt_buffer;
    1501      197527 :     *pkt        = pktl->pkt;
    1502      197527 :     *pkt_buffer = pktl->next;
    1503      197527 :     if (!pktl->next)
    1504      102286 :         *pkt_buffer_end = NULL;
    1505      197527 :     av_freep(&pktl);
    1506      197527 :     return 0;
    1507             : }
    1508             : 
    1509        7206 : static int64_t ts_to_samples(AVStream *st, int64_t ts)
    1510             : {
    1511        7206 :     return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
    1512             : }
    1513             : 
    1514      499345 : static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
    1515             : {
    1516      499345 :     int ret = 0, i, got_packet = 0;
    1517      499345 :     AVDictionary *metadata = NULL;
    1518             : 
    1519      499345 :     av_init_packet(pkt);
    1520             : 
    1521      499345 :     while (!got_packet && !s->internal->parse_queue) {
    1522             :         AVStream *st;
    1523             :         AVPacket cur_pkt;
    1524             : 
    1525             :         /* read next packet */
    1526      933266 :         ret = ff_read_packet(s, &cur_pkt);
    1527      933266 :         if (ret < 0) {
    1528        5837 :             if (ret == AVERROR(EAGAIN))
    1529           2 :                 return ret;
    1530             :             /* flush the parsers */
    1531       12300 :             for (i = 0; i < s->nb_streams; i++) {
    1532        6464 :                 st = s->streams[i];
    1533        6464 :                 if (st->parser && st->need_parsing)
    1534        1511 :                     parse_packet(s, NULL, st->index);
    1535             :             }
    1536             :             /* all remaining packets are now in parse_queue =>
    1537             :              * really terminate parsing */
    1538        5836 :             break;
    1539             :         }
    1540      927429 :         ret = 0;
    1541      927429 :         st  = s->streams[cur_pkt.stream_index];
    1542             : 
    1543             :         /* update context if required */
    1544      927429 :         if (st->internal->need_context_update) {
    1545         107 :             if (avcodec_is_open(st->internal->avctx)) {
    1546           3 :                 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
    1547           3 :                 avcodec_close(st->internal->avctx);
    1548           3 :                 st->info->found_decoder = 0;
    1549             :             }
    1550             : 
    1551             :             /* close parser, because it depends on the codec */
    1552         107 :             if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
    1553           2 :                 av_parser_close(st->parser);
    1554           2 :                 st->parser = NULL;
    1555             :             }
    1556             : 
    1557         107 :             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
    1558         107 :             if (ret < 0)
    1559           0 :                 return ret;
    1560             : 
    1561             : #if FF_API_LAVF_AVCTX
    1562             : FF_DISABLE_DEPRECATION_WARNINGS
    1563             :             /* update deprecated public codec context */
    1564         107 :             ret = avcodec_parameters_to_context(st->codec, st->codecpar);
    1565         107 :             if (ret < 0)
    1566           0 :                 return ret;
    1567             : FF_ENABLE_DEPRECATION_WARNINGS
    1568             : #endif
    1569             : 
    1570         107 :             st->internal->need_context_update = 0;
    1571             :         }
    1572             : 
    1573     1201890 :         if (cur_pkt.pts != AV_NOPTS_VALUE &&
    1574      404911 :             cur_pkt.dts != AV_NOPTS_VALUE &&
    1575      130450 :             cur_pkt.pts < cur_pkt.dts) {
    1576           0 :             av_log(s, AV_LOG_WARNING,
    1577             :                    "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
    1578             :                    cur_pkt.stream_index,
    1579           0 :                    av_ts2str(cur_pkt.pts),
    1580           0 :                    av_ts2str(cur_pkt.dts),
    1581             :                    cur_pkt.size);
    1582             :         }
    1583      927429 :         if (s->debug & FF_FDEBUG_TS)
    1584           0 :             av_log(s, AV_LOG_DEBUG,
    1585             :                    "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
    1586             :                    cur_pkt.stream_index,
    1587           0 :                    av_ts2str(cur_pkt.pts),
    1588           0 :                    av_ts2str(cur_pkt.dts),
    1589             :                    cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
    1590             : 
    1591      927429 :         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
    1592        2429 :             st->parser = av_parser_init(st->codecpar->codec_id);
    1593        2429 :             if (!st->parser) {
    1594        1052 :                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
    1595             :                        "%s, packets or times may be invalid.\n",
    1596        1052 :                        avcodec_get_name(st->codecpar->codec_id));
    1597             :                 /* no parser available: just output the raw packets */
    1598        1052 :                 st->need_parsing = AVSTREAM_PARSE_NONE;
    1599        1377 :             } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
    1600         584 :                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
    1601         793 :             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
    1602           0 :                 st->parser->flags |= PARSER_FLAG_ONCE;
    1603         793 :             else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
    1604         431 :                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
    1605             :         }
    1606             : 
    1607      927429 :         if (!st->need_parsing || !st->parser) {
    1608             :             /* no parsing needed: we just output the packet as is */
    1609      363714 :             *pkt = cur_pkt;
    1610      363714 :             compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
    1611      499094 :             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
    1612      268498 :                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
    1613      133111 :                 ff_reduce_index(s, st->index);
    1614      133111 :                 av_add_index_entry(st, pkt->pos, pkt->dts,
    1615             :                                    0, 0, AVINDEX_KEYFRAME);
    1616             :             }
    1617      363714 :             got_packet = 1;
    1618      563715 :         } else if (st->discard < AVDISCARD_ALL) {
    1619      563575 :             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
    1620           0 :                 return ret;
    1621      563575 :             st->codecpar->sample_rate = st->internal->avctx->sample_rate;
    1622      563575 :             st->codecpar->bit_rate = st->internal->avctx->bit_rate;
    1623      563575 :             st->codecpar->channels = st->internal->avctx->channels;
    1624      563575 :             st->codecpar->channel_layout = st->internal->avctx->channel_layout;
    1625      563575 :             st->codecpar->codec_id = st->internal->avctx->codec_id;
    1626             :         } else {
    1627             :             /* free packet */
    1628         140 :             av_packet_unref(&cur_pkt);
    1629             :         }
    1630      927429 :         if (pkt->flags & AV_PKT_FLAG_KEY)
    1631      339967 :             st->skip_to_keyframe = 0;
    1632      927429 :         if (st->skip_to_keyframe) {
    1633          49 :             av_packet_unref(&cur_pkt);
    1634          49 :             if (got_packet) {
    1635           0 :                 *pkt = cur_pkt;
    1636             :             }
    1637          49 :             got_packet = 0;
    1638             :         }
    1639             :     }
    1640             : 
    1641      499344 :     if (!got_packet && s->internal->parse_queue)
    1642      130477 :         ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
    1643             : 
    1644      499344 :     if (ret >= 0) {
    1645      494191 :         AVStream *st = s->streams[pkt->stream_index];
    1646      494191 :         int discard_padding = 0;
    1647      494191 :         if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
    1648        3603 :             int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
    1649        3603 :             int64_t sample = ts_to_samples(st, pts);
    1650        3603 :             int duration = ts_to_samples(st, pkt->duration);
    1651        3603 :             int64_t end_sample = sample + duration;
    1652        3614 :             if (duration > 0 && end_sample >= st->first_discard_sample &&
    1653          11 :                 sample < st->last_discard_sample)
    1654          11 :                 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
    1655             :         }
    1656      494191 :         if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
    1657          29 :             st->skip_samples = st->start_skip_samples;
    1658      494191 :         if (st->skip_samples || discard_padding) {
    1659          84 :             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
    1660          84 :             if (p) {
    1661          84 :                 AV_WL32(p, st->skip_samples);
    1662          84 :                 AV_WL32(p + 4, discard_padding);
    1663          84 :                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
    1664             :             }
    1665          84 :             st->skip_samples = 0;
    1666             :         }
    1667             : 
    1668      494191 :         if (st->inject_global_side_data) {
    1669           0 :             for (i = 0; i < st->nb_side_data; i++) {
    1670           0 :                 AVPacketSideData *src_sd = &st->side_data[i];
    1671             :                 uint8_t *dst_data;
    1672             : 
    1673           0 :                 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
    1674           0 :                     continue;
    1675             : 
    1676           0 :                 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
    1677           0 :                 if (!dst_data) {
    1678           0 :                     av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
    1679           0 :                     continue;
    1680             :                 }
    1681             : 
    1682           0 :                 memcpy(dst_data, src_sd->data, src_sd->size);
    1683             :             }
    1684           0 :             st->inject_global_side_data = 0;
    1685             :         }
    1686             :     }
    1687             : 
    1688      499344 :     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
    1689      499344 :     if (metadata) {
    1690           0 :         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
    1691           0 :         av_dict_copy(&s->metadata, metadata, 0);
    1692           0 :         av_dict_free(&metadata);
    1693           0 :         av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
    1694             :     }
    1695             : 
    1696             : #if FF_API_LAVF_AVCTX
    1697      499344 :     update_stream_avctx(s);
    1698             : #endif
    1699             : 
    1700      499344 :     if (s->debug & FF_FDEBUG_TS)
    1701           0 :         av_log(s, AV_LOG_DEBUG,
    1702             :                "read_frame_internal stream=%d, pts=%s, dts=%s, "
    1703             :                "size=%d, duration=%"PRId64", flags=%d\n",
    1704             :                pkt->stream_index,
    1705           0 :                av_ts2str(pkt->pts),
    1706           0 :                av_ts2str(pkt->dts),
    1707             :                pkt->size, pkt->duration, pkt->flags);
    1708             : 
    1709      499344 :     return ret;
    1710             : }
    1711             : 
    1712      419486 : int av_read_frame(AVFormatContext *s, AVPacket *pkt)
    1713             : {
    1714      419486 :     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
    1715      419486 :     int eof = 0;
    1716             :     int ret;
    1717             :     AVStream *st;
    1718             : 
    1719      419486 :     if (!genpts) {
    1720      838972 :         ret = s->internal->packet_buffer
    1721       67050 :               ? read_from_packet_buffer(&s->internal->packet_buffer,
    1722       67050 :                                         &s->internal->packet_buffer_end, pkt)
    1723      486536 :               : read_frame_internal(s, pkt);
    1724      419486 :         if (ret < 0)
    1725        4074 :             return ret;
    1726      415412 :         goto return_packet;
    1727             :     }
    1728             : 
    1729           0 :     for (;;) {
    1730           0 :         AVPacketList *pktl = s->internal->packet_buffer;
    1731             : 
    1732           0 :         if (pktl) {
    1733           0 :             AVPacket *next_pkt = &pktl->pkt;
    1734             : 
    1735           0 :             if (next_pkt->dts != AV_NOPTS_VALUE) {
    1736           0 :                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
    1737             :                 // last dts seen for this stream. if any of packets following
    1738             :                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
    1739           0 :                 int64_t last_dts = next_pkt->dts;
    1740             :                 av_assert2(wrap_bits <= 64);
    1741           0 :                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
    1742           0 :                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
    1743           0 :                         av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
    1744           0 :                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
    1745             :                             // not B-frame
    1746           0 :                             next_pkt->pts = pktl->pkt.dts;
    1747             :                         }
    1748           0 :                         if (last_dts != AV_NOPTS_VALUE) {
    1749             :                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
    1750           0 :                             last_dts = pktl->pkt.dts;
    1751             :                         }
    1752             :                     }
    1753           0 :                     pktl = pktl->next;
    1754             :                 }
    1755           0 :                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
    1756             :                     // Fixing the last reference frame had none pts issue (For MXF etc).
    1757             :                     // We only do this when
    1758             :                     // 1. eof.
    1759             :                     // 2. we are not able to resolve a pts value for current packet.
    1760             :                     // 3. the packets for this stream at the end of the files had valid dts.
    1761           0 :                     next_pkt->pts = last_dts + next_pkt->duration;
    1762             :                 }
    1763           0 :                 pktl = s->internal->packet_buffer;
    1764             :             }
    1765             : 
    1766             :             /* read packet from packet buffer, if there is data */
    1767           0 :             st = s->streams[next_pkt->stream_index];
    1768           0 :             if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
    1769           0 :                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
    1770           0 :                 ret = read_from_packet_buffer(&s->internal->packet_buffer,
    1771           0 :                                                &s->internal->packet_buffer_end, pkt);
    1772           0 :                 goto return_packet;
    1773             :             }
    1774             :         }
    1775             : 
    1776           0 :         ret = read_frame_internal(s, pkt);
    1777           0 :         if (ret < 0) {
    1778           0 :             if (pktl && ret != AVERROR(EAGAIN)) {
    1779           0 :                 eof = 1;
    1780           0 :                 continue;
    1781             :             } else
    1782           0 :                 return ret;
    1783             :         }
    1784             : 
    1785           0 :         ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
    1786           0 :                             &s->internal->packet_buffer_end, 1);
    1787           0 :         av_packet_unref(pkt);
    1788           0 :         if (ret < 0)
    1789           0 :             return ret;
    1790             :     }
    1791             : 
    1792      415412 : return_packet:
    1793             : 
    1794      415412 :     st = s->streams[pkt->stream_index];
    1795      415412 :     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
    1796      158779 :         ff_reduce_index(s, st->index);
    1797      158779 :         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
    1798             :     }
    1799             : 
    1800      415412 :     if (is_relative(pkt->dts))
    1801      123513 :         pkt->dts -= RELATIVE_TS_BASE;
    1802      415412 :     if (is_relative(pkt->pts))
    1803      121916 :         pkt->pts -= RELATIVE_TS_BASE;
    1804             : 
    1805      415412 :     return ret;
    1806             : }
    1807             : 
    1808             : /* XXX: suppress the packet queue */
    1809       21641 : static void flush_packet_queue(AVFormatContext *s)
    1810             : {
    1811       21641 :     if (!s->internal)
    1812           0 :         return;
    1813       21641 :     free_packet_buffer(&s->internal->parse_queue,       &s->internal->parse_queue_end);
    1814       21641 :     free_packet_buffer(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
    1815       21641 :     free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
    1816             : 
    1817       21641 :     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
    1818             : }
    1819             : 
    1820             : /*******************************************************/
    1821             : /* seek support */
    1822             : 
    1823        1838 : int av_find_default_stream_index(AVFormatContext *s)
    1824             : {
    1825             :     int i;
    1826             :     AVStream *st;
    1827        1838 :     int best_stream = 0;
    1828        1838 :     int best_score = INT_MIN;
    1829             : 
    1830        1838 :     if (s->nb_streams <= 0)
    1831           0 :         return -1;
    1832        3989 :     for (i = 0; i < s->nb_streams; i++) {
    1833        2151 :         int score = 0;
    1834        2151 :         st = s->streams[i];
    1835        2151 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
    1836        1260 :             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
    1837           4 :                 score -= 400;
    1838        1260 :             if (st->codecpar->width && st->codecpar->height)
    1839        1201 :                 score += 50;
    1840        1260 :             score+= 25;
    1841             :         }
    1842        2151 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
    1843         868 :             if (st->codecpar->sample_rate)
    1844         857 :                 score += 50;
    1845             :         }
    1846        2151 :         if (st->codec_info_nb_frames)
    1847        1928 :             score += 12;
    1848             : 
    1849        2151 :         if (st->discard != AVDISCARD_ALL)
    1850        2151 :             score += 200;
    1851             : 
    1852        2151 :         if (score > best_score) {
    1853        1865 :             best_score = score;
    1854        1865 :             best_stream = i;
    1855             :         }
    1856             :     }
    1857        1838 :     return best_stream;
    1858             : }
    1859             : 
    1860             : /** Flush the frame reader. */
    1861        4688 : void ff_read_frame_flush(AVFormatContext *s)
    1862             : {
    1863             :     AVStream *st;
    1864             :     int i, j;
    1865             : 
    1866        4688 :     flush_packet_queue(s);
    1867             : 
    1868             :     /* Reset read state for each stream. */
    1869       10146 :     for (i = 0; i < s->nb_streams; i++) {
    1870        5458 :         st = s->streams[i];
    1871             : 
    1872        5458 :         if (st->parser) {
    1873        1061 :             av_parser_close(st->parser);
    1874        1061 :             st->parser = NULL;
    1875             :         }
    1876        5458 :         st->last_IP_pts = AV_NOPTS_VALUE;
    1877        5458 :         st->last_dts_for_order_check = AV_NOPTS_VALUE;
    1878        5458 :         if (st->first_dts == AV_NOPTS_VALUE)
    1879        1609 :             st->cur_dts = RELATIVE_TS_BASE;
    1880             :         else
    1881             :             /* We set the current DTS to an unspecified origin. */
    1882        3849 :             st->cur_dts = AV_NOPTS_VALUE;
    1883             : 
    1884        5458 :         st->probe_packets = MAX_PROBE_PACKETS;
    1885             : 
    1886       98244 :         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
    1887       92786 :             st->pts_buffer[j] = AV_NOPTS_VALUE;
    1888             : 
    1889        5458 :         if (s->internal->inject_global_side_data)
    1890           0 :             st->inject_global_side_data = 1;
    1891             : 
    1892        5458 :         st->skip_samples = 0;
    1893             :     }
    1894        4688 : }
    1895             : 
    1896        1231 : void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
    1897             : {
    1898             :     int i;
    1899             : 
    1900        2763 :     for (i = 0; i < s->nb_streams; i++) {
    1901        1532 :         AVStream *st = s->streams[i];
    1902             : 
    1903        1532 :         st->cur_dts =
    1904        3064 :             av_rescale(timestamp,
    1905        1532 :                        st->time_base.den * (int64_t) ref_st->time_base.num,
    1906        1532 :                        st->time_base.num * (int64_t) ref_st->time_base.den);
    1907             :     }
    1908        1231 : }
    1909             : 
    1910      318262 : void ff_reduce_index(AVFormatContext *s, int stream_index)
    1911             : {
    1912      318262 :     AVStream *st             = s->streams[stream_index];
    1913      318262 :     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
    1914             : 
    1915      318262 :     if ((unsigned) st->nb_index_entries >= max_entries) {
    1916             :         int i;
    1917           0 :         for (i = 0; 2 * i < st->nb_index_entries; i++)
    1918           0 :             st->index_entries[i] = st->index_entries[2 * i];
    1919           0 :         st->nb_index_entries = i;
    1920             :     }
    1921      318262 : }
    1922             : 
    1923      367445 : int ff_add_index_entry(AVIndexEntry **index_entries,
    1924             :                        int *nb_index_entries,
    1925             :                        unsigned int *index_entries_allocated_size,
    1926             :                        int64_t pos, int64_t timestamp,
    1927             :                        int size, int distance, int flags)
    1928             : {
    1929             :     AVIndexEntry *entries, *ie;
    1930             :     int index;
    1931             : 
    1932      367445 :     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
    1933           0 :         return -1;
    1934             : 
    1935      367445 :     if (timestamp == AV_NOPTS_VALUE)
    1936        1697 :         return AVERROR(EINVAL);
    1937             : 
    1938      365748 :     if (size < 0 || size > 0x3FFFFFFF)
    1939           0 :         return AVERROR(EINVAL);
    1940             : 
    1941      365748 :     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
    1942      171485 :         timestamp -= RELATIVE_TS_BASE;
    1943             : 
    1944      365748 :     entries = av_fast_realloc(*index_entries,
    1945             :                               index_entries_allocated_size,
    1946      365748 :                               (*nb_index_entries + 1) *
    1947             :                               sizeof(AVIndexEntry));
    1948      365748 :     if (!entries)
    1949           0 :         return -1;
    1950             : 
    1951      365748 :     *index_entries = entries;
    1952             : 
    1953      365748 :     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
    1954             :                                       timestamp, AVSEEK_FLAG_ANY);
    1955             : 
    1956      365748 :     if (index < 0) {
    1957      240177 :         index = (*nb_index_entries)++;
    1958      240177 :         ie    = &entries[index];
    1959      240177 :         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
    1960             :     } else {
    1961      125571 :         ie = &entries[index];
    1962      125571 :         if (ie->timestamp != timestamp) {
    1963         411 :             if (ie->timestamp <= timestamp)
    1964           0 :                 return -1;
    1965         411 :             memmove(entries + index + 1, entries + index,
    1966         411 :                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
    1967         411 :             (*nb_index_entries)++;
    1968      125160 :         } else if (ie->pos == pos && distance < ie->min_distance)
    1969             :             // do not reduce the distance
    1970           2 :             distance = ie->min_distance;
    1971             :     }
    1972             : 
    1973      365748 :     ie->pos          = pos;
    1974      365748 :     ie->timestamp    = timestamp;
    1975      365748 :     ie->min_distance = distance;
    1976      365748 :     ie->size         = size;
    1977      365748 :     ie->flags        = flags;
    1978             : 
    1979      365748 :     return index;
    1980             : }
    1981             : 
    1982      367128 : int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
    1983             :                        int size, int distance, int flags)
    1984             : {
    1985      367128 :     timestamp = wrap_timestamp(st, timestamp);
    1986      367128 :     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
    1987             :                               &st->index_entries_allocated_size, pos,
    1988             :                               timestamp, size, distance, flags);
    1989             : }
    1990             : 
    1991      395820 : int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
    1992             :                               int64_t wanted_timestamp, int flags)
    1993             : {
    1994             :     int a, b, m;
    1995             :     int64_t timestamp;
    1996             : 
    1997      395820 :     a = -1;
    1998      395820 :     b = nb_entries;
    1999             : 
    2000             :     // Optimize appending index entries at the end.
    2001      395820 :     if (b && entries[b - 1].timestamp < wanted_timestamp)
    2002      239457 :         a = b - 1;
    2003             : 
    2004     1923799 :     while (b - a > 1) {
    2005     1132159 :         m         = (a + b) >> 1;
    2006             : 
    2007             :         // Search for the next non-discarded packet.
    2008     2264319 :         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
    2009           1 :             m++;
    2010           1 :             if (m == b && entries[m].timestamp >= wanted_timestamp) {
    2011           0 :                 m = b - 1;
    2012           0 :                 break;
    2013             :             }
    2014             :         }
    2015             : 
    2016     1132159 :         timestamp = entries[m].timestamp;
    2017     1132159 :         if (timestamp >= wanted_timestamp)
    2018      228105 :             b = m;
    2019     1132159 :         if (timestamp <= wanted_timestamp)
    2020     1050579 :             a = m;
    2021             :     }
    2022      395820 :     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
    2023             : 
    2024      395820 :     if (!(flags & AVSEEK_FLAG_ANY))
    2025       27410 :         while (m >= 0 && m < nb_entries &&
    2026        7605 :                !(entries[m].flags & AVINDEX_KEYFRAME))
    2027        2349 :             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
    2028             : 
    2029      395820 :     if (m == nb_entries)
    2030      241391 :         return -1;
    2031      154429 :     return m;
    2032             : }
    2033             : 
    2034         354 : void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
    2035             : {
    2036             :     int ist1, ist2;
    2037         354 :     int64_t pos_delta = 0;
    2038         354 :     int64_t skip = 0;
    2039             :     //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
    2040         354 :     const char *proto = avio_find_protocol_name(s->filename);
    2041             : 
    2042         354 :     if (!proto) {
    2043           0 :         av_log(s, AV_LOG_INFO,
    2044             :                "Protocol name not provided, cannot determine if input is local or "
    2045             :                "a network protocol, buffers and access patterns cannot be configured "
    2046             :                "optimally without knowing the protocol\n");
    2047             :     }
    2048             : 
    2049         354 :     if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
    2050         354 :         return;
    2051             : 
    2052           0 :     for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
    2053           0 :         AVStream *st1 = s->streams[ist1];
    2054           0 :         for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
    2055           0 :             AVStream *st2 = s->streams[ist2];
    2056             :             int i1, i2;
    2057             : 
    2058           0 :             if (ist1 == ist2)
    2059           0 :                 continue;
    2060             : 
    2061           0 :             for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
    2062           0 :                 AVIndexEntry *e1 = &st1->index_entries[i1];
    2063           0 :                 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
    2064             : 
    2065           0 :                 skip = FFMAX(skip, e1->size);
    2066           0 :                 for (; i2 < st2->nb_index_entries; i2++) {
    2067           0 :                     AVIndexEntry *e2 = &st2->index_entries[i2];
    2068           0 :                     int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
    2069           0 :                     if (e2_pts - e1_pts < time_tolerance)
    2070           0 :                         continue;
    2071           0 :                     pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
    2072           0 :                     break;
    2073             :                 }
    2074             :             }
    2075             :         }
    2076             :     }
    2077             : 
    2078           0 :     pos_delta *= 2;
    2079             :     /* XXX This could be adjusted depending on protocol*/
    2080           0 :     if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
    2081           0 :         av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
    2082           0 :         ffio_set_buf_size(s->pb, pos_delta);
    2083           0 :         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
    2084             :     }
    2085             : 
    2086           0 :     if (skip < (1<<23)) {
    2087           0 :         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
    2088             :     }
    2089             : }
    2090             : 
    2091       29992 : int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
    2092             : {
    2093       29992 :     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
    2094             :                                      wanted_timestamp, flags);
    2095             : }
    2096             : 
    2097         808 : static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
    2098             :                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
    2099             : {
    2100         808 :     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
    2101         808 :     if (stream_index >= 0)
    2102         808 :         ts = wrap_timestamp(s->streams[stream_index], ts);
    2103         808 :     return ts;
    2104             : }
    2105             : 
    2106         206 : int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
    2107             :                          int64_t target_ts, int flags)
    2108             : {
    2109         206 :     AVInputFormat *avif = s->iformat;
    2110         206 :     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
    2111             :     int64_t ts_min, ts_max, ts;
    2112             :     int index;
    2113             :     int64_t ret;
    2114             :     AVStream *st;
    2115             : 
    2116         206 :     if (stream_index < 0)
    2117           0 :         return -1;
    2118             : 
    2119         206 :     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
    2120             : 
    2121         206 :     ts_max =
    2122         206 :     ts_min = AV_NOPTS_VALUE;
    2123         206 :     pos_limit = -1; // GCC falsely says it may be uninitialized.
    2124             : 
    2125         206 :     st = s->streams[stream_index];
    2126         206 :     if (st->index_entries) {
    2127             :         AVIndexEntry *e;
    2128             : 
    2129             :         /* FIXME: Whole function must be checked for non-keyframe entries in
    2130             :          * index case, especially read_timestamp(). */
    2131         197 :         index = av_index_search_timestamp(st, target_ts,
    2132             :                                           flags | AVSEEK_FLAG_BACKWARD);
    2133         197 :         index = FFMAX(index, 0);
    2134         197 :         e     = &st->index_entries[index];
    2135             : 
    2136         197 :         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
    2137         126 :             pos_min = e->pos;
    2138         126 :             ts_min  = e->timestamp;
    2139         126 :             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
    2140         126 :                     pos_min, av_ts2str(ts_min));
    2141             :         } else {
    2142             :             av_assert1(index == 0);
    2143             :         }
    2144             : 
    2145         197 :         index = av_index_search_timestamp(st, target_ts,
    2146             :                                           flags & ~AVSEEK_FLAG_BACKWARD);
    2147         197 :         av_assert0(index < st->nb_index_entries);
    2148         197 :         if (index >= 0) {
    2149         124 :             e = &st->index_entries[index];
    2150             :             av_assert1(e->timestamp >= target_ts);
    2151         124 :             pos_max   = e->pos;
    2152         124 :             ts_max    = e->timestamp;
    2153         124 :             pos_limit = pos_max - e->min_distance;
    2154         124 :             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
    2155         124 :                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
    2156             :         }
    2157             :     }
    2158             : 
    2159         206 :     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
    2160             :                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
    2161         206 :     if (pos < 0)
    2162           2 :         return -1;
    2163             : 
    2164             :     /* do the seek */
    2165         204 :     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
    2166           0 :         return ret;
    2167             : 
    2168         204 :     ff_read_frame_flush(s);
    2169         204 :     ff_update_cur_dts(s, st, ts);
    2170             : 
    2171         204 :     return 0;
    2172             : }
    2173             : 
    2174          81 : int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
    2175             :                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
    2176             : {
    2177          81 :     int64_t step = 1024;
    2178             :     int64_t limit, ts_max;
    2179          81 :     int64_t filesize = avio_size(s->pb);
    2180          81 :     int64_t pos_max  = filesize - 1;
    2181             :     do {
    2182         350 :         limit = pos_max;
    2183         350 :         pos_max = FFMAX(0, (pos_max) - step);
    2184         350 :         ts_max  = ff_read_timestamp(s, stream_index,
    2185             :                                     &pos_max, limit, read_timestamp);
    2186         350 :         step   += step;
    2187         350 :     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
    2188          81 :     if (ts_max == AV_NOPTS_VALUE)
    2189           0 :         return -1;
    2190             : 
    2191          54 :     for (;;) {
    2192         135 :         int64_t tmp_pos = pos_max + 1;
    2193         135 :         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
    2194             :                                             &tmp_pos, INT64_MAX, read_timestamp);
    2195         135 :         if (tmp_ts == AV_NOPTS_VALUE)
    2196         162 :             break;
    2197          54 :         av_assert0(tmp_pos > pos_max);
    2198          54 :         ts_max  = tmp_ts;
    2199          54 :         pos_max = tmp_pos;
    2200          54 :         if (tmp_pos >= filesize)
    2201           0 :             break;
    2202             :     }
    2203             : 
    2204          81 :     if (ts)
    2205          81 :         *ts = ts_max;
    2206          81 :     if (pos)
    2207          81 :         *pos = pos_max;
    2208             : 
    2209          81 :     return 0;
    2210             : }
    2211             : 
    2212         206 : int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
    2213             :                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
    2214             :                       int64_t ts_min, int64_t ts_max,
    2215             :                       int flags, int64_t *ts_ret,
    2216             :                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
    2217             :                                                 int64_t *, int64_t))
    2218             : {
    2219             :     int64_t pos, ts;
    2220             :     int64_t start_pos;
    2221             :     int no_change;
    2222             :     int ret;
    2223             : 
    2224         206 :     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
    2225             : 
    2226         206 :     if (ts_min == AV_NOPTS_VALUE) {
    2227          80 :         pos_min = s->internal->data_offset;
    2228          80 :         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
    2229          80 :         if (ts_min == AV_NOPTS_VALUE)
    2230           0 :             return -1;
    2231             :     }
    2232             : 
    2233         206 :     if (ts_min >= target_ts) {
    2234          71 :         *ts_ret = ts_min;
    2235          71 :         return pos_min;
    2236             :     }
    2237             : 
    2238         135 :     if (ts_max == AV_NOPTS_VALUE) {
    2239          81 :         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
    2240           0 :             return ret;
    2241          81 :         pos_limit = pos_max;
    2242             :     }
    2243             : 
    2244         135 :     if (ts_max <= target_ts) {
    2245          71 :         *ts_ret = ts_max;
    2246          71 :         return pos_max;
    2247             :     }
    2248             : 
    2249          64 :     av_assert0(ts_min < ts_max);
    2250             : 
    2251          64 :     no_change = 0;
    2252         369 :     while (pos_min < pos_limit) {
    2253         729 :         av_log(s, AV_LOG_TRACE,
    2254             :                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
    2255         486 :                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
    2256         243 :         av_assert0(pos_limit <= pos_max);
    2257             : 
    2258         243 :         if (no_change == 0) {
    2259         141 :             int64_t approximate_keyframe_distance = pos_max - pos_limit;
    2260             :             // interpolate position (better than dichotomy)
    2261         282 :             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
    2262         141 :                              ts_max - ts_min) +
    2263         141 :                   pos_min - approximate_keyframe_distance;
    2264         102 :         } else if (no_change == 1) {
    2265             :             // bisection if interpolation did not change min / max pos last time
    2266          62 :             pos = (pos_min + pos_limit) >> 1;
    2267             :         } else {
    2268             :             /* linear search if bisection failed, can only happen if there
    2269             :              * are very few or no keyframes between min/max */
    2270          40 :             pos = pos_min;
    2271             :         }
    2272         243 :         if (pos <= pos_min)
    2273          60 :             pos = pos_min + 1;
    2274         183 :         else if (pos > pos_limit)
    2275           0 :             pos = pos_limit;
    2276         243 :         start_pos = pos;
    2277             : 
    2278             :         // May pass pos_limit instead of -1.
    2279         243 :         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
    2280         243 :         if (pos == pos_max)
    2281         160 :             no_change++;
    2282             :         else
    2283          83 :             no_change = 0;
    2284         972 :         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
    2285             :                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
    2286             :                 pos_min, pos, pos_max,
    2287         972 :                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
    2288             :                 pos_limit, start_pos, no_change);
    2289         243 :         if (ts == AV_NOPTS_VALUE) {
    2290           2 :             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
    2291           2 :             return -1;
    2292             :         }
    2293         241 :         if (target_ts <= ts) {
    2294         199 :             pos_limit = start_pos - 1;
    2295         199 :             pos_max   = pos;
    2296         199 :             ts_max    = ts;
    2297             :         }
    2298         241 :         if (target_ts >= ts) {
    2299          44 :             pos_min = pos;
    2300          44 :             ts_min  = ts;
    2301             :         }
    2302             :     }
    2303             : 
    2304          62 :     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
    2305          62 :     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
    2306             : #if 0
    2307             :     pos_min = pos;
    2308             :     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
    2309             :     pos_min++;
    2310             :     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
    2311             :     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
    2312             :             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
    2313             : #endif
    2314          62 :     *ts_ret = ts;
    2315          62 :     return pos;
    2316             : }
    2317             : 
    2318           0 : static int seek_frame_byte(AVFormatContext *s, int stream_index,
    2319             :                            int64_t pos, int flags)
    2320             : {
    2321             :     int64_t pos_min, pos_max;
    2322             : 
    2323           0 :     pos_min = s->internal->data_offset;
    2324           0 :     pos_max = avio_size(s->pb) - 1;
    2325             : 
    2326           0 :     if (pos < pos_min)
    2327           0 :         pos = pos_min;
    2328           0 :     else if (pos > pos_max)
    2329           0 :         pos = pos_max;
    2330             : 
    2331           0 :     avio_seek(s->pb, pos, SEEK_SET);
    2332             : 
    2333           0 :     s->io_repositioned = 1;
    2334             : 
    2335           0 :     return 0;
    2336             : }
    2337             : 
    2338        1127 : static int seek_frame_generic(AVFormatContext *s, int stream_index,
    2339             :                               int64_t timestamp, int flags)
    2340             : {
    2341             :     int index;
    2342             :     int64_t ret;
    2343             :     AVStream *st;
    2344             :     AVIndexEntry *ie;
    2345             : 
    2346        1127 :     st = s->streams[stream_index];
    2347             : 
    2348        1127 :     index = av_index_search_timestamp(st, timestamp, flags);
    2349             : 
    2350        1549 :     if (index < 0 && st->nb_index_entries &&
    2351         422 :         timestamp < st->index_entries[0].timestamp)
    2352         208 :         return -1;
    2353             : 
    2354         919 :     if (index < 0 || index == st->nb_index_entries - 1) {
    2355             :         AVPacket pkt;
    2356         628 :         int nonkey = 0;
    2357             : 
    2358         628 :         if (st->nb_index_entries) {
    2359         371 :             av_assert0(st->index_entries);
    2360         371 :             ie = &st->index_entries[st->nb_index_entries - 1];
    2361         371 :             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
    2362         250 :                 return ret;
    2363         338 :             ff_update_cur_dts(s, st, ie->timestamp);
    2364             :         } else {
    2365         257 :             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
    2366         184 :                 return ret;
    2367             :         }
    2368        3511 :         for (;;) {
    2369             :             int read_status;
    2370             :             do {
    2371        3922 :                 read_status = av_read_frame(s, &pkt);
    2372        3922 :             } while (read_status == AVERROR(EAGAIN));
    2373        3922 :             if (read_status < 0)
    2374         353 :                 break;
    2375        3569 :             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
    2376         491 :                 if (pkt.flags & AV_PKT_FLAG_KEY) {
    2377          58 :                     av_packet_unref(&pkt);
    2378          58 :                     break;
    2379             :                 }
    2380         433 :                 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
    2381           0 :                     av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
    2382           0 :                     av_packet_unref(&pkt);
    2383           0 :                     break;
    2384             :                 }
    2385             :             }
    2386        3511 :             av_packet_unref(&pkt);
    2387             :         }
    2388         411 :         index = av_index_search_timestamp(st, timestamp, flags);
    2389             :     }
    2390         702 :     if (index < 0)
    2391         267 :         return -1;
    2392             : 
    2393         435 :     ff_read_frame_flush(s);
    2394         435 :     if (s->iformat->read_seek)
    2395         181 :         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
    2396           0 :             return 0;
    2397         435 :     ie = &st->index_entries[index];
    2398         435 :     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
    2399          21 :         return ret;
    2400         414 :     ff_update_cur_dts(s, st, ie->timestamp);
    2401             : 
    2402         414 :     return 0;
    2403             : }
    2404             : 
    2405        3241 : static int seek_frame_internal(AVFormatContext *s, int stream_index,
    2406             :                                int64_t timestamp, int flags)
    2407             : {
    2408             :     int ret;
    2409             :     AVStream *st;
    2410             : 
    2411        3241 :     if (flags & AVSEEK_FLAG_BYTE) {
    2412           0 :         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
    2413           0 :             return -1;
    2414           0 :         ff_read_frame_flush(s);
    2415           0 :         return seek_frame_byte(s, stream_index, timestamp, flags);
    2416             :     }
    2417             : 
    2418        3241 :     if (stream_index < 0) {
    2419        1695 :         stream_index = av_find_default_stream_index(s);
    2420        1695 :         if (stream_index < 0)
    2421           0 :             return -1;
    2422             : 
    2423        1695 :         st = s->streams[stream_index];
    2424             :         /* timestamp for default must be expressed in AV_TIME_BASE units */
    2425        1695 :         timestamp = av_rescale(timestamp, st->time_base.den,
    2426        1695 :                                AV_TIME_BASE * (int64_t) st->time_base.num);
    2427             :     }
    2428             : 
    2429             :     /* first, we try the format specific seek */
    2430        3241 :     if (s->iformat->read_seek) {
    2431        2719 :         ff_read_frame_flush(s);
    2432        2719 :         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
    2433             :     } else
    2434         522 :         ret = -1;
    2435        3241 :     if (ret >= 0)
    2436        2022 :         return 0;
    2437             : 
    2438        1311 :     if (s->iformat->read_timestamp &&
    2439          92 :         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
    2440          92 :         ff_read_frame_flush(s);
    2441          92 :         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
    2442        1127 :     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
    2443        1127 :         ff_read_frame_flush(s);
    2444        1127 :         return seek_frame_generic(s, stream_index, timestamp, flags);
    2445             :     } else
    2446           0 :         return -1;
    2447             : }
    2448             : 
    2449        3241 : int av_seek_frame(AVFormatContext *s, int stream_index,
    2450             :                   int64_t timestamp, int flags)
    2451             : {
    2452             :     int ret;
    2453             : 
    2454        3241 :     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
    2455           0 :         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
    2456           0 :         if ((flags & AVSEEK_FLAG_BACKWARD))
    2457           0 :             max_ts = timestamp;
    2458             :         else
    2459           0 :             min_ts = timestamp;
    2460           0 :         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
    2461             :                                   flags & ~AVSEEK_FLAG_BACKWARD);
    2462             :     }
    2463             : 
    2464        3241 :     ret = seek_frame_internal(s, stream_index, timestamp, flags);
    2465             : 
    2466        3241 :     if (ret >= 0)
    2467        2527 :         ret = avformat_queue_attached_pictures(s);
    2468             : 
    2469        3241 :     return ret;
    2470             : }
    2471             : 
    2472        3215 : int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
    2473             :                        int64_t ts, int64_t max_ts, int flags)
    2474             : {
    2475        3215 :     if (min_ts > ts || max_ts < ts)
    2476           0 :         return -1;
    2477        3215 :     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
    2478           0 :         return AVERROR(EINVAL);
    2479             : 
    2480        3215 :     if (s->seek2any>0)
    2481           0 :         flags |= AVSEEK_FLAG_ANY;
    2482        3215 :     flags &= ~AVSEEK_FLAG_BACKWARD;
    2483             : 
    2484        3215 :     if (s->iformat->read_seek2) {
    2485             :         int ret;
    2486           2 :         ff_read_frame_flush(s);
    2487             : 
    2488           2 :         if (stream_index == -1 && s->nb_streams == 1) {
    2489           2 :             AVRational time_base = s->streams[0]->time_base;
    2490           2 :             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
    2491           2 :             min_ts = av_rescale_rnd(min_ts, time_base.den,
    2492           2 :                                     time_base.num * (int64_t)AV_TIME_BASE,
    2493             :                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
    2494           2 :             max_ts = av_rescale_rnd(max_ts, time_base.den,
    2495           2 :                                     time_base.num * (int64_t)AV_TIME_BASE,
    2496             :                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
    2497           2 :             stream_index = 0;
    2498             :         }
    2499             : 
    2500           2 :         ret = s->iformat->read_seek2(s, stream_index, min_ts,
    2501             :                                      ts, max_ts, flags);
    2502             : 
    2503           2 :         if (ret >= 0)
    2504           1 :             ret = avformat_queue_attached_pictures(s);
    2505           2 :         return ret;
    2506             :     }
    2507             : 
    2508        3213 :     if (s->iformat->read_timestamp) {
    2509             :         // try to seek via read_timestamp()
    2510             :     }
    2511             : 
    2512             :     // Fall back on old API if new is not implemented but old is.
    2513             :     // Note the old API has somewhat different semantics.
    2514             :     if (s->iformat->read_seek || 1) {
    2515        3213 :         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
    2516        3213 :         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
    2517        3213 :         if (ret<0 && ts != min_ts && max_ts != ts) {
    2518           0 :             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
    2519           0 :             if (ret >= 0)
    2520           0 :                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
    2521             :         }
    2522        3213 :         return ret;
    2523             :     }
    2524             : 
    2525             :     // try some generic seek like seek_frame_generic() but with new ts semantics
    2526             :     return -1; //unreachable
    2527             : }
    2528             : 
    2529           0 : int avformat_flush(AVFormatContext *s)
    2530             : {
    2531           0 :     ff_read_frame_flush(s);
    2532           0 :     return 0;
    2533             : }
    2534             : 
    2535             : /*******************************************************/
    2536             : 
    2537             : /**
    2538             :  * Return TRUE if the stream has accurate duration in any stream.
    2539             :  *
    2540             :  * @return TRUE if the stream has accurate duration for at least one component.
    2541             :  */
    2542        5672 : static int has_duration(AVFormatContext *ic)
    2543             : {
    2544             :     int i;
    2545             :     AVStream *st;
    2546             : 
    2547        7709 :     for (i = 0; i < ic->nb_streams; i++) {
    2548        5791 :         st = ic->streams[i];
    2549        5791 :         if (st->duration != AV_NOPTS_VALUE)
    2550        3754 :             return 1;
    2551             :     }
    2552        1918 :     if (ic->duration != AV_NOPTS_VALUE)
    2553         331 :         return 1;
    2554        1587 :     return 0;
    2555             : }
    2556             : 
    2557             : /**
    2558             :  * Estimate the stream timings from the one of each components.
    2559             :  *
    2560             :  * Also computes the global bitrate if possible.
    2561             :  */
    2562        9841 : static void update_stream_timings(AVFormatContext *ic)
    2563             : {
    2564             :     int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
    2565             :     int64_t duration, duration1, filesize;
    2566             :     int i;
    2567             :     AVStream *st;
    2568             :     AVProgram *p;
    2569             : 
    2570        9841 :     start_time = INT64_MAX;
    2571        9841 :     start_time_text = INT64_MAX;
    2572        9841 :     end_time   = INT64_MIN;
    2573        9841 :     end_time_text   = INT64_MIN;
    2574        9841 :     duration   = INT64_MIN;
    2575       20470 :     for (i = 0; i < ic->nb_streams; i++) {
    2576       10629 :         st = ic->streams[i];
    2577       10629 :         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
    2578        8457 :             start_time1 = av_rescale_q(st->start_time, st->time_base,
    2579        8457 :                                        AV_TIME_BASE_Q);
    2580        8457 :             if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
    2581         154 :                 if (start_time1 < start_time_text)
    2582          54 :                     start_time_text = start_time1;
    2583             :             } else
    2584        8380 :                 start_time = FFMIN(start_time, start_time1);
    2585        8457 :             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
    2586        8457 :                                          AV_TIME_BASE_Q,
    2587             :                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
    2588        8457 :             if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
    2589        7482 :                 end_time1 += start_time1;
    2590        7482 :                 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
    2591          68 :                     end_time_text = FFMAX(end_time_text, end_time1);
    2592             :                 else
    2593        7414 :                     end_time = FFMAX(end_time, end_time1);
    2594             :             }
    2595       17010 :             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
    2596          96 :                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
    2597          47 :                     p->start_time = start_time1;
    2598          96 :                 if (p->end_time < end_time1)
    2599          28 :                     p->end_time = end_time1;
    2600             :             }
    2601             :         }
    2602       10629 :         if (st->duration != AV_NOPTS_VALUE) {
    2603        8827 :             duration1 = av_rescale_q(st->duration, st->time_base,
    2604        8827 :                                      AV_TIME_BASE_Q);
    2605        8827 :             duration  = FFMAX(duration, duration1);
    2606             :         }
    2607             :     }
    2608        9841 :     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
    2609        2071 :         start_time = start_time_text;
    2610        7770 :     else if (start_time > start_time_text)
    2611           0 :         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
    2612             : 
    2613        9841 :     if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
    2614        2838 :         end_time = end_time_text;
    2615        7003 :     } else if (end_time < end_time_text) {
    2616           0 :         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
    2617             :     }
    2618             : 
    2619        9841 :     if (start_time != INT64_MAX) {
    2620        7770 :         ic->start_time = start_time;
    2621        7770 :         if (end_time != INT64_MIN) {
    2622        7007 :             if (ic->nb_programs > 1) {
    2623           0 :                 for (i = 0; i < ic->nb_programs; i++) {
    2624           0 :                     p = ic->programs[i];
    2625           0 :                     if (p->start_time != AV_NOPTS_VALUE &&
    2626           0 :                         p->end_time > p->start_time &&
    2627           0 :                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
    2628           0 :                         duration = FFMAX(duration, p->end_time - p->start_time);
    2629             :                 }
    2630        7007 :             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
    2631        7007 :                 duration = FFMAX(duration, end_time - start_time);
    2632             :             }
    2633             :         }
    2634             :     }
    2635        9841 :     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
    2636        4140 :         ic->duration = duration;
    2637             :     }
    2638        9841 :     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
    2639             :         /* compute the bitrate */
    2640        9712 :         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
    2641        4856 :                          (double) ic->duration;
    2642        4856 :         if (bitrate >= 0 && bitrate <= INT64_MAX)
    2643        4856 :             ic->bit_rate = bitrate;
    2644             :     }
    2645        9841 : }
    2646             : 
    2647        4127 : static void fill_all_stream_timings(AVFormatContext *ic)
    2648             : {
    2649             :     int i;
    2650             :     AVStream *st;
    2651             : 
    2652        4127 :     update_stream_timings(ic);
    2653        8612 :     for (i = 0; i < ic->nb_streams; i++) {
    2654        4485 :         st = ic->streams[i];
    2655        4485 :         if (st->start_time == AV_NOPTS_VALUE) {
    2656         659 :             if (ic->start_time != AV_NOPTS_VALUE)
    2657          74 :                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
    2658             :                                               st->time_base);
    2659         659 :             if (ic->duration != AV_NOPTS_VALUE)
    2660         645 :                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
    2661             :                                             st->time_base);
    2662             :         }
    2663             :     }
    2664        4127 : }
    2665             : 
    2666        1587 : static void estimate_timings_from_bit_rate(AVFormatContext *ic)
    2667             : {
    2668             :     int64_t filesize, duration;
    2669        1587 :     int i, show_warning = 0;
    2670             :     AVStream *st;
    2671             : 
    2672             :     /* if bit_rate is already set, we believe it */
    2673        1587 :     if (ic->bit_rate <= 0) {
    2674        1567 :         int64_t bit_rate = 0;
    2675        2619 :         for (i = 0; i < ic->nb_streams; i++) {
    2676        1614 :             st = ic->streams[i];
    2677        1614 :             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
    2678          87 :                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
    2679        1614 :             if (st->codecpar->bit_rate > 0) {
    2680         730 :                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
    2681           0 :                     bit_rate = 0;
    2682           0 :                     break;
    2683             :                 }
    2684         730 :                 bit_rate += st->codecpar->bit_rate;
    2685         884 :             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
    2686             :                 // If we have a videostream with packets but without a bitrate
    2687             :                 // then consider the sum not known
    2688         562 :                 bit_rate = 0;
    2689         562 :                 break;
    2690             :             }
    2691             :         }
    2692        1567 :         ic->bit_rate = bit_rate;
    2693             :     }
    2694             : 
    2695             :     /* if duration is already set, we believe it */
    2696        3174 :     if (ic->duration == AV_NOPTS_VALUE &&
    2697        1587 :         ic->bit_rate != 0) {
    2698         724 :         filesize = ic->pb ? avio_size(ic->pb) : 0;
    2699         724 :         if (filesize > ic->internal->data_offset) {
    2700         710 :             filesize -= ic->internal->data_offset;
    2701        1456 :             for (i = 0; i < ic->nb_streams; i++) {
    2702         746 :                 st      = ic->streams[i];
    2703         746 :                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
    2704         746 :                     && st->duration == AV_NOPTS_VALUE) {
    2705         746 :                     duration = av_rescale(8 * filesize, st->time_base.den,
    2706         746 :                                           ic->bit_rate *
    2707         746 :                                           (int64_t) st->time_base.num);
    2708         746 :                     st->duration = duration;
    2709         746 :                     show_warning = 1;
    2710             :                 }
    2711             :             }
    2712             :         }
    2713             :     }
    2714        1587 :     if (show_warning)
    2715         710 :         av_log(ic, AV_LOG_WARNING,
    2716             :                "Estimating duration from bitrate, this may be inaccurate\n");
    2717        1587 : }
    2718             : 
    2719             : #define DURATION_MAX_READ_SIZE 250000LL
    2720             : #define DURATION_MAX_RETRY 6
    2721             : 
    2722             : /* only usable for MPEG-PS streams */
    2723          42 : static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
    2724             : {
    2725          42 :     AVPacket pkt1, *pkt = &pkt1;
    2726             :     AVStream *st;
    2727             :     int num, den, read_size, i, ret;
    2728          42 :     int found_duration = 0;
    2729             :     int is_end;
    2730             :     int64_t filesize, offset, duration;
    2731          42 :     int retry = 0;
    2732             : 
    2733             :     /* flush packet queue */
    2734          42 :     flush_packet_queue(ic);
    2735             : 
    2736         114 :     for (i = 0; i < ic->nb_streams; i++) {
    2737          72 :         st = ic->streams[i];
    2738          74 :         if (st->start_time == AV_NOPTS_VALUE &&
    2739           4 :             st->first_dts == AV_NOPTS_VALUE &&
    2740           2 :             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
    2741           2 :             av_log(ic, AV_LOG_WARNING,
    2742             :                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
    2743             : 
    2744          72 :         if (st->parser) {
    2745          22 :             av_parser_close(st->parser);
    2746          22 :             st->parser = NULL;
    2747             :         }
    2748             :     }
    2749             : 
    2750          42 :     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
    2751             :     /* estimate the end time (duration) */
    2752             :     /* XXX: may need to support wrapping */
    2753          42 :     filesize = ic->pb ? avio_size(ic->pb) : 0;
    2754             :     do {
    2755          45 :         is_end = found_duration;
    2756          45 :         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
    2757          45 :         if (offset < 0)
    2758          10 :             offset = 0;
    2759             : 
    2760          45 :         avio_seek(ic->pb, offset, SEEK_SET);
    2761          45 :         read_size = 0;
    2762             :         for (;;) {
    2763        9367 :             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
    2764           3 :                 break;
    2765             : 
    2766             :             do {
    2767        4703 :                 ret = ff_read_packet(ic, pkt);
    2768        4703 :             } while (ret == AVERROR(EAGAIN));
    2769        4703 :             if (ret != 0)
    2770          42 :                 break;
    2771        4661 :             read_size += pkt->size;
    2772        4661 :             st         = ic->streams[pkt->stream_index];
    2773        6077 :             if (pkt->pts != AV_NOPTS_VALUE &&
    2774        1416 :                 (st->start_time != AV_NOPTS_VALUE ||
    2775           0 :                  st->first_dts  != AV_NOPTS_VALUE)) {
    2776        1416 :                 if (pkt->duration == 0) {
    2777        1416 :                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
    2778        1416 :                     if (den && num) {
    2779        3063 :                         pkt->duration = av_rescale_rnd(1,
    2780        1021 :                                            num * (int64_t) st->time_base.den,
    2781        1021 :                                            den * (int64_t) st->time_base.num,
    2782             :                                            AV_ROUND_DOWN);
    2783             :                     }
    2784             :                 }
    2785        1416 :                 duration = pkt->pts + pkt->duration;
    2786        1416 :                 found_duration = 1;
    2787        1416 :                 if (st->start_time != AV_NOPTS_VALUE)
    2788        1416 :                     duration -= st->start_time;
    2789             :                 else
    2790           0 :                     duration -= st->first_dts;
    2791        1416 :                 if (duration > 0) {
    2792        2757 :                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
    2793        2510 :                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
    2794        1232 :                         st->duration = duration;
    2795        1412 :                     st->info->last_duration = duration;
    2796             :                 }
    2797             :             }
    2798        4661 :             av_packet_unref(pkt);
    2799             :         }
    2800             : 
    2801             :         /* check if all audio/video streams have valid duration */
    2802          45 :         if (!is_end) {
    2803          42 :             is_end = 1;
    2804         114 :             for (i = 0; i < ic->nb_streams; i++) {
    2805          72 :                 st = ic->streams[i];
    2806          72 :                 switch (st->codecpar->codec_type) {
    2807          67 :                     case AVMEDIA_TYPE_VIDEO:
    2808             :                     case AVMEDIA_TYPE_AUDIO:
    2809          67 :                         if (st->duration == AV_NOPTS_VALUE)
    2810           3 :                             is_end = 0;
    2811             :                 }
    2812             :             }
    2813             :         }
    2814           3 :     } while (!is_end &&
    2815           3 :              offset &&
    2816          45 :              ++retry <= DURATION_MAX_RETRY);
    2817             : 
    2818          42 :     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
    2819             : 
    2820             :     /* warn about audio/video streams which duration could not be estimated */
    2821         114 :     for (i = 0; i < ic->nb_streams; i++) {
    2822          72 :         st = ic->streams[i];
    2823          72 :         if (st->duration == AV_NOPTS_VALUE) {
    2824           5 :             switch (st->codecpar->codec_type) {
    2825           0 :             case AVMEDIA_TYPE_VIDEO:
    2826             :             case AVMEDIA_TYPE_AUDIO:
    2827           0 :                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
    2828           0 :                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
    2829             :                 } else
    2830           0 :                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
    2831             :             }
    2832             :         }
    2833             :     }
    2834          42 :     fill_all_stream_timings(ic);
    2835             : 
    2836          42 :     avio_seek(ic->pb, old_offset, SEEK_SET);
    2837         114 :     for (i = 0; i < ic->nb_streams; i++) {
    2838             :         int j;
    2839             : 
    2840          72 :         st              = ic->streams[i];
    2841          72 :         st->cur_dts     = st->first_dts;
    2842          72 :         st->last_IP_pts = AV_NOPTS_VALUE;
    2843          72 :         st->last_dts_for_order_check = AV_NOPTS_VALUE;
    2844        1296 :         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
    2845        1224 :             st->pts_buffer[j] = AV_NOPTS_VALUE;
    2846             :     }
    2847          42 : }
    2848             : 
    2849        5714 : static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
    2850             : {
    2851             :     int64_t file_size;
    2852             : 
    2853             :     /* get the file size, if possible */
    2854        5714 :     if (ic->iformat->flags & AVFMT_NOFILE) {
    2855        2074 :         file_size = 0;
    2856             :     } else {
    2857        3640 :         file_size = avio_size(ic->pb);
    2858        3640 :         file_size = FFMAX(0, file_size);
    2859             :     }
    2860             : 
    2861       11414 :     if ((!strcmp(ic->iformat->name, "mpeg") ||
    2862        5742 :          !strcmp(ic->iformat->name, "mpegts")) &&
    2863          42 :         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
    2864             :         /* get accurate estimate from the PTSes */
    2865          42 :         estimate_timings_from_pts(ic, old_offset);
    2866          42 :         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
    2867        5672 :     } else if (has_duration(ic)) {
    2868             :         /* at least one component has timings - we use them for all
    2869             :          * the components */
    2870        4085 :         fill_all_stream_timings(ic);
    2871        4085 :         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
    2872             :     } else {
    2873             :         /* less precise: use bitrate info */
    2874        1587 :         estimate_timings_from_bit_rate(ic);
    2875        1587 :         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
    2876             :     }
    2877        5714 :     update_stream_timings(ic);
    2878             : 
    2879             :     {
    2880             :         int i;
    2881             :         AVStream av_unused *st;
    2882       11858 :         for (i = 0; i < ic->nb_streams; i++) {
    2883        6144 :             st = ic->streams[i];
    2884       12288 :             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
    2885        6144 :                    (double) st->start_time * av_q2d(st->time_base),
    2886        6144 :                    (double) st->duration   * av_q2d(st->time_base));
    2887             :         }
    2888       17142 :         av_log(ic, AV_LOG_TRACE,
    2889             :                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
    2890        5714 :                 (double) ic->start_time / AV_TIME_BASE,
    2891        5714 :                 (double) ic->duration   / AV_TIME_BASE,
    2892        5714 :                 (int64_t)ic->bit_rate / 1000);
    2893             :     }
    2894        5714 : }
    2895             : 
    2896      320788 : static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
    2897             : {
    2898      320788 :     AVCodecContext *avctx = st->internal->avctx;
    2899             : 
    2900             : #define FAIL(errmsg) do {                                         \
    2901             :         if (errmsg_ptr)                                           \
    2902             :             *errmsg_ptr = errmsg;                                 \
    2903             :         return 0;                                                 \
    2904             :     } while (0)
    2905             : 
    2906      320788 :     if (   avctx->codec_id == AV_CODEC_ID_NONE
    2907         553 :         && avctx->codec_type != AVMEDIA_TYPE_DATA)
    2908         370 :         FAIL("unknown codec");
    2909      320418 :     switch (avctx->codec_type) {
    2910       86245 :     case AVMEDIA_TYPE_AUDIO:
    2911       86245 :         if (!avctx->frame_size && determinable_frame_size(avctx))
    2912         167 :             FAIL("unspecified frame size");
    2913      172154 :         if (st->info->found_decoder >= 0 &&
    2914       86076 :             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
    2915        1982 :             FAIL("unspecified sample format");
    2916       84096 :         if (!avctx->sample_rate)
    2917          92 :             FAIL("unspecified sample rate");
    2918       84004 :         if (!avctx->channels)
    2919           0 :             FAIL("unspecified number of channels");
    2920       84004 :         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
    2921           0 :             FAIL("no decodable DTS frames");
    2922       84004 :         break;
    2923      232893 :     case AVMEDIA_TYPE_VIDEO:
    2924      232893 :         if (!avctx->width)
    2925        9313 :             FAIL("unspecified size");
    2926      223580 :         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
    2927        2799 :             FAIL("unspecified pixel format");
    2928      220781 :         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
    2929         186 :             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
    2930          67 :                 FAIL("no frame in rv30/40 and no sar");
    2931      220714 :         break;
    2932         445 :     case AVMEDIA_TYPE_SUBTITLE:
    2933         445 :         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
    2934           0 :             FAIL("unspecified size");
    2935         445 :         break;
    2936         835 :     case AVMEDIA_TYPE_DATA:
    2937         835 :         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
    2938             :     }
    2939             : 
    2940      305815 :     return 1;
    2941             : }
    2942             : 
    2943             : /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
    2944      149075 : static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
    2945             :                             AVDictionary **options)
    2946             : {
    2947      149075 :     AVCodecContext *avctx = st->internal->avctx;
    2948             :     const AVCodec *codec;
    2949      149075 :     int got_picture = 1, ret = 0;
    2950      149075 :     AVFrame *frame = av_frame_alloc();
    2951             :     AVSubtitle subtitle;
    2952      149075 :     AVPacket pkt = *avpkt;
    2953      149075 :     int do_skip_frame = 0;
    2954             :     enum AVDiscard skip_frame;
    2955             : 
    2956      149075 :     if (!frame)
    2957           0 :         return AVERROR(ENOMEM);
    2958             : 
    2959      150232 :     if (!avcodec_is_open(avctx) &&
    2960        2314 :         st->info->found_decoder <= 0 &&
    2961        2310 :         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
    2962        1157 :         AVDictionary *thread_opt = NULL;
    2963             : 
    2964        1157 :         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
    2965             : 
    2966        1157 :         if (!codec) {
    2967          63 :             st->info->found_decoder = -st->codecpar->codec_id;
    2968          63 :             ret                     = -1;
    2969         128 :             goto fail;
    2970             :         }
    2971             : 
    2972             :         /* Force thread count to 1 since the H.264 decoder will not extract
    2973             :          * SPS and PPS to extradata during multi-threaded decoding. */
    2974        1094 :         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
    2975        1094 :         if (s->codec_whitelist)
    2976           0 :             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
    2977        1094 :         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
    2978        1094 :         if (!options)
    2979         105 :             av_dict_free(&thread_opt);
    2980        1094 :         if (ret < 0) {
    2981           2 :             st->info->found_decoder = -avctx->codec_id;
    2982           2 :             goto fail;
    2983             :         }
    2984        1092 :         st->info->found_decoder = 1;
    2985      147918 :     } else if (!st->info->found_decoder)
    2986        4945 :         st->info->found_decoder = 1;
    2987             : 
    2988      149010 :     if (st->info->found_decoder < 0) {
    2989           0 :         ret = -1;
    2990           0 :         goto fail;
    2991             :     }
    2992             : 
    2993      149010 :     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
    2994        7212 :         do_skip_frame = 1;
    2995        7212 :         skip_frame = avctx->skip_frame;
    2996        7212 :         avctx->skip_frame = AVDISCARD_ALL;
    2997             :     }
    2998             : 
    2999      303971 :     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
    3000      149016 :            ret >= 0 &&
    3001      437105 :            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
    3002      145285 :             (!st->codec_info_nb_frames &&
    3003        2239 :              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
    3004        6084 :         got_picture = 0;
    3005        6402 :         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
    3006         318 :             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
    3007        6084 :             ret = avcodec_send_packet(avctx, &pkt);
    3008        6084 :             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
    3009         133 :                 break;
    3010        5951 :             if (ret >= 0)
    3011        5944 :                 pkt.size = 0;
    3012        5951 :             ret = avcodec_receive_frame(avctx, frame);
    3013        5951 :             if (ret >= 0)
    3014        4684 :                 got_picture = 1;
    3015       11902 :             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
    3016        1267 :                 ret = 0;
    3017           0 :         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
    3018           0 :             ret = avcodec_decode_subtitle2(avctx, &subtitle,
    3019             :                                            &got_picture, &pkt);
    3020           0 :             if (ret >= 0)
    3021           0 :                 pkt.size = 0;
    3022             :         }
    3023        5951 :         if (ret >= 0) {
    3024        5951 :             if (got_picture)
    3025        4684 :                 st->nb_decoded_frames++;
    3026        5951 :             ret       = got_picture;
    3027             :         }
    3028             :     }
    3029             : 
    3030      152464 :     if (!pkt.data && !got_picture)
    3031          17 :         ret = -1;
    3032             : 
    3033      298068 : fail:
    3034      149075 :     if (do_skip_frame) {
    3035        7212 :         avctx->skip_frame = skip_frame;
    3036             :     }
    3037             : 
    3038      149075 :     av_frame_free(&frame);
    3039      149075 :     return ret;
    3040             : }
    3041             : 
    3042         878 : unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
    3043             : {
    3044        4230 :     while (tags->id != AV_CODEC_ID_NONE) {
    3045        3352 :         if (tags->id == id)
    3046         878 :             return tags->tag;
    3047        2474 :         tags++;
    3048             :     }
    3049           0 :     return 0;
    3050             : }
    3051             : 
    3052        2626 : enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
    3053             : {
    3054             :     int i;
    3055      233909 :     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
    3056      233210 :         if (tag == tags[i].tag)
    3057        1927 :             return tags[i].id;
    3058       83142 :     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
    3059       82446 :         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
    3060           3 :             return tags[i].id;
    3061         696 :     return AV_CODEC_ID_NONE;
    3062             : }
    3063             : 
    3064         508 : enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
    3065             : {
    3066         508 :     if (bps <= 0 || bps > 64)
    3067           0 :         return AV_CODEC_ID_NONE;
    3068             : 
    3069         508 :     if (flt) {
    3070           4 :         switch (bps) {
    3071           2 :         case 32:
    3072           2 :             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
    3073           2 :         case 64:
    3074           2 :             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
    3075           0 :         default:
    3076           0 :             return AV_CODEC_ID_NONE;
    3077             :         }
    3078             :     } else {
    3079         504 :         bps  += 7;
    3080         504 :         bps >>= 3;
    3081         504 :         if (sflags & (1 << (bps - 1))) {
    3082         488 :             switch (bps) {
    3083           0 :             case 1:
    3084           0 :                 return AV_CODEC_ID_PCM_S8;
    3085         478 :             case 2:
    3086         478 :                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
    3087           8 :             case 3:
    3088           8 :                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
    3089           2 :             case 4:
    3090           2 :                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
    3091           0 :             case 8:
    3092           0 :                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
    3093           0 :             default:
    3094           0 :                 return AV_CODEC_ID_NONE;
    3095             :             }
    3096             :         } else {
    3097          16 :             switch (bps) {
    3098          16 :             case 1:
    3099          16 :                 return AV_CODEC_ID_PCM_U8;
    3100           0 :             case 2:
    3101           0 :                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
    3102           0 :             case 3:
    3103           0 :                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
    3104           0 :             case 4:
    3105           0 :                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
    3106           0 :             default:
    3107           0 :                 return AV_CODEC_ID_NONE;
    3108             :             }
    3109             :         }
    3110             :     }
    3111             : }
    3112             : 
    3113        4433 : unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
    3114             : {
    3115             :     unsigned int tag;
    3116        4433 :     if (!av_codec_get_tag2(tags, id, &tag))
    3117           5 :         return 0;
    3118        4428 :     return tag;
    3119             : }
    3120             : 
    3121        6622 : int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
    3122             :                       unsigned int *tag)
    3123             : {
    3124             :     int i;
    3125       12038 :     for (i = 0; tags && tags[i]; i++) {
    3126       12027 :         const AVCodecTag *codec_tags = tags[i];
    3127      475105 :         while (codec_tags->id != AV_CODEC_ID_NONE) {
    3128      457662 :             if (codec_tags->id == id) {
    3129        6611 :                 *tag = codec_tags->tag;
    3130        6611 :                 return 1;
    3131             :             }
    3132      451051 :             codec_tags++;
    3133             :         }
    3134             :     }
    3135          11 :     return 0;
    3136             : }
    3137             : 
    3138          73 : enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
    3139             : {
    3140             :     int i;
    3141         122 :     for (i = 0; tags && tags[i]; i++) {
    3142         109 :         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
    3143         109 :         if (id != AV_CODEC_ID_NONE)
    3144          60 :             return id;
    3145             :     }
    3146          13 :     return AV_CODEC_ID_NONE;
    3147             : }
    3148             : 
    3149        5714 : static void compute_chapters_end(AVFormatContext *s)
    3150             : {
    3151             :     unsigned int i, j;
    3152        5714 :     int64_t max_time = 0;
    3153             : 
    3154        5714 :     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
    3155        9636 :         max_time = s->duration +
    3156        4818 :                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
    3157             : 
    3158        5728 :     for (i = 0; i < s->nb_chapters; i++)
    3159          14 :         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
    3160          14 :             AVChapter *ch = s->chapters[i];
    3161          28 :             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
    3162             :                                                   ch->time_base)
    3163          28 :                                    : INT64_MAX;
    3164             : 
    3165          40 :             for (j = 0; j < s->nb_chapters; j++) {
    3166          26 :                 AVChapter *ch1     = s->chapters[j];
    3167          26 :                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
    3168             :                                                   ch->time_base);
    3169          26 :                 if (j != i && next_start > ch->start && next_start < end)
    3170           3 :                     end = next_start;
    3171             :             }
    3172          14 :             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
    3173             :         }
    3174        5714 : }
    3175             : 
    3176    14049382 : static int get_std_framerate(int i)
    3177             : {
    3178    14049382 :     if (i < 30*12)
    3179    12753864 :         return (i + 1) * 1001;
    3180     1295518 :     i -= 30*12;
    3181             : 
    3182     1295518 :     if (i < 30)
    3183      984794 :         return (i + 31) * 1001 * 12;
    3184      310724 :     i -= 30;
    3185             : 
    3186      310724 :     if (i < 3)
    3187       99659 :         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
    3188             : 
    3189      211065 :     i -= 3;
    3190             : 
    3191      211065 :     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
    3192             : }
    3193             : 
    3194             : /* Is the time base unreliable?
    3195             :  * This is a heuristic to balance between quick acceptance of the values in
    3196             :  * the headers vs. some extra checks.
    3197             :  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
    3198             :  * MPEG-2 commonly misuses field repeat flags to store different framerates.
    3199             :  * And there are "variable" fps files this needs to detect as well. */
    3200      160114 : static int tb_unreliable(AVCodecContext *c)
    3201             : {
    3202      276065 :     if (c->time_base.den >= 101LL * c->time_base.num ||
    3203      226532 :         c->time_base.den <    5LL * c->time_base.num ||
    3204             :         // c->codec_tag == AV_RL32("DIVX") ||
    3205             :         // c->codec_tag == AV_RL32("XVID") ||
    3206      221089 :         c->codec_tag == AV_RL32("mp4v") ||
    3207      213117 :         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
    3208      204688 :         c->codec_id == AV_CODEC_ID_GIF ||
    3209      195930 :         c->codec_id == AV_CODEC_ID_HEVC ||
    3210       93851 :         c->codec_id == AV_CODEC_ID_H264)
    3211       81294 :         return 1;
    3212       78820 :     return 0;
    3213             : }
    3214             : 
    3215         573 : int ff_alloc_extradata(AVCodecParameters *par, int size)
    3216             : {
    3217             :     int ret;
    3218             : 
    3219         573 :     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
    3220           0 :         par->extradata = NULL;
    3221           0 :         par->extradata_size = 0;
    3222           0 :         return AVERROR(EINVAL);
    3223             :     }
    3224         573 :     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
    3225         573 :     if (par->extradata) {
    3226         573 :         memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
    3227         573 :         par->extradata_size = size;
    3228         573 :         ret = 0;
    3229             :     } else {
    3230           0 :         par->extradata_size = 0;
    3231           0 :         ret = AVERROR(ENOMEM);
    3232             :     }
    3233         573 :     return ret;
    3234             : }
    3235             : 
    3236         457 : int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
    3237             : {
    3238         457 :     int ret = ff_alloc_extradata(par, size);
    3239         457 :     if (ret < 0)
    3240           0 :         return ret;
    3241         457 :     ret = avio_read(pb, par->extradata, size);
    3242         457 :     if (ret != size) {
    3243           0 :         av_freep(&par->extradata);
    3244           0 :         par->extradata_size = 0;
    3245           0 :         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
    3246           0 :         return ret < 0 ? ret : AVERROR_INVALIDDATA;
    3247             :     }
    3248             : 
    3249         457 :     return ret;
    3250             : }
    3251             : 
    3252      109805 : int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
    3253             : {
    3254             :     int i, j;
    3255      109805 :     int64_t last = st->info->last_dts;
    3256             : 
    3257      109805 :     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
    3258       83098 :        && ts - (uint64_t)last < INT64_MAX) {
    3259       83098 :         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
    3260       83098 :         int64_t duration = ts - last;
    3261             : 
    3262       83098 :         if (!st->info->duration_error)
    3263        2716 :             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
    3264       83098 :         if (!st->info->duration_error)
    3265           0 :             return AVERROR(ENOMEM);
    3266             : 
    3267             : //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
    3268             : //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
    3269    33239200 :         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
    3270    33156102 :             if (st->info->duration_error[0][1][i] < 1e10) {
    3271    12782432 :                 int framerate = get_std_framerate(i);
    3272    12782432 :                 double sdts = dts*framerate/(1001*12);
    3273    38347296 :                 for (j= 0; j<2; j++) {
    3274    25564864 :                     int64_t ticks = llrint(sdts+j*0.5);
    3275    25564864 :                     double error= sdts - ticks + j*0.5;
    3276    25564864 :                     st->info->duration_error[j][0][i] += error;
    3277    25564864 :                     st->info->duration_error[j][1][i] += error*error;
    3278             :                 }
    3279             :             }
    3280             :         }
    3281       83098 :         st->info->duration_count++;
    3282       83098 :         st->info->rfps_duration_sum += duration;
    3283             : 
    3284       83098 :         if (st->info->duration_count % 10 == 0) {
    3285        7551 :             int n = st->info->duration_count;
    3286     3020400 :             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
    3287     3012849 :                 if (st->info->duration_error[0][1][i] < 1e10) {
    3288     1222515 :                     double a0     = st->info->duration_error[0][0][i] / n;
    3289     1222515 :                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
    3290     1222515 :                     double a1     = st->info->duration_error[1][0][i] / n;
    3291     1222515 :                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
    3292     1222515 :                     if (error0 > 0.04 && error1 > 0.04) {
    3293      934632 :                         st->info->duration_error[0][1][i] = 2e10;
    3294      934632 :                         st->info->duration_error[1][1][i] = 2e10;
    3295             :                     }
    3296             :                 }
    3297             :             }
    3298             :         }
    3299             : 
    3300             :         // ignore the first 4 values, they might have some random jitter
    3301       83098 :         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
    3302       75011 :             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
    3303             :     }
    3304      109805 :     if (ts != AV_NOPTS_VALUE)
    3305       87485 :         st->info->last_dts = ts;
    3306             : 
    3307      109805 :     return 0;
    3308             : }
    3309             : 
    3310        6068 : void ff_rfps_calculate(AVFormatContext *ic)
    3311             : {
    3312             :     int i, j;
    3313             : 
    3314       12636 :     for (i = 0; i < ic->nb_streams; i++) {
    3315        6568 :         AVStream *st = ic->streams[i];
    3316             : 
    3317        6568 :         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
    3318        1768 :             continue;
    3319             :         // the check for tb_unreliable() is not completely correct, since this is not about handling
    3320             :         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
    3321             :         // ipmovie.c produces.
    3322        4800 :         if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
    3323         130 :             av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
    3324        4800 :         if (st->info->duration_count>1 && !st->r_frame_rate.num
    3325        2342 :             && tb_unreliable(st->internal->avctx)) {
    3326         200 :             int num = 0;
    3327         200 :             double best_error= 0.01;
    3328         200 :             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
    3329             : 
    3330       80000 :             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
    3331             :                 int k;
    3332             : 
    3333      139650 :                 if (st->info->codec_info_duration &&
    3334       59850 :                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
    3335        3713 :                     continue;
    3336       76087 :                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
    3337         550 :                     continue;
    3338             : 
    3339       75537 :                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
    3340       32500 :                     continue;
    3341             : 
    3342      129111 :                 for (k= 0; k<2; k++) {
    3343       86074 :                     int n = st->info->duration_count;
    3344       86074 :                     double a= st->info->duration_error[k][0][j] / n;
    3345       86074 :                     double error= st->info->duration_error[k][1][j]/n - a*a;
    3346             : 
    3347       86074 :                     if (error < best_error && best_error> 0.000000001) {
    3348        1577 :                         best_error= error;
    3349        1577 :                         num = get_std_framerate(j);
    3350             :                     }
    3351       86074 :                     if (error < 0.02)
    3352       11190 :                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
    3353             :                 }
    3354             :             }
    3355             :             // do not increase frame rate by more than 1 % in order to match a standard rate.
    3356         200 :             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
    3357         194 :                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
    3358             :         }
    3359        4800 :         if (   !st->avg_frame_rate.num
    3360        3645 :             && st->r_frame_rate.num && st->info->rfps_duration_sum
    3361         299 :             && st->info->codec_info_duration <= 0
    3362          53 :             && st->info->duration_count > 2
    3363          53 :             && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
    3364             :             ) {
    3365          39 :             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
    3366          39 :             st->avg_frame_rate = st->r_frame_rate;
    3367             :         }
    3368             : 
    3369        4800 :         av_freep(&st->info->duration_error);
    3370        4800 :         st->info->last_dts = AV_NOPTS_VALUE;
    3371        4800 :         st->info->duration_count = 0;
    3372        4800 :         st->info->rfps_duration_sum = 0;
    3373             :     }
    3374        6068 : }
    3375             : 
    3376        7554 : static int extract_extradata_check(AVStream *st)
    3377             : {
    3378             :     const AVBitStreamFilter *f;
    3379             : 
    3380        7554 :     f = av_bsf_get_by_name("extract_extradata");
    3381        7554 :     if (!f)
    3382           0 :         return 0;
    3383             : 
    3384        7554 :     if (f->codec_ids) {
    3385             :         const enum AVCodecID *ids;
    3386       57268 :         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
    3387       50464 :             if (*ids == st->codecpar->codec_id)
    3388         750 :                 return 1;
    3389             :     }
    3390             : 
    3391        6804 :     return 0;
    3392             : }
    3393             : 
    3394        5382 : static int extract_extradata_init(AVStream *st)
    3395             : {
    3396        5382 :     AVStreamInternal *i = st->internal;
    3397             :     const AVBitStreamFilter *f;
    3398             :     int ret;
    3399             : 
    3400        5382 :     f = av_bsf_get_by_name("extract_extradata");
    3401        5382 :     if (!f)
    3402           0 :         goto finish;
    3403             : 
    3404             :     /* check that the codec id is supported */
    3405        5382 :     ret = extract_extradata_check(st);
    3406        5382 :     if (!ret)
    3407        4742 :         goto finish;
    3408             : 
    3409         640 :     i->extract_extradata.pkt = av_packet_alloc();
    3410         640 :     if (!i->extract_extradata.pkt)
    3411           0 :         return AVERROR(ENOMEM);
    3412             : 
    3413         640 :     ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
    3414         640 :     if (ret < 0)
    3415           0 :         goto fail;
    3416             : 
    3417         640 :     ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
    3418         640 :                                   st->codecpar);
    3419         640 :     if (ret < 0)
    3420           0 :         goto fail;
    3421             : 
    3422         640 :     i->extract_extradata.bsf->time_base_in = st->time_base;
    3423             : 
    3424             :     /* if init fails here, we assume extracting extradata is just not
    3425             :      * supported for this codec, so we return success */
    3426         640 :     ret = av_bsf_init(i->extract_extradata.bsf);
    3427         640 :     if (ret < 0) {
    3428           0 :         av_bsf_free(&i->extract_extradata.bsf);
    3429           0 :         ret = 0;
    3430             :     }
    3431             : 
    3432        6022 : finish:
    3433        5382 :     i->extract_extradata.inited = 1;
    3434             : 
    3435        5382 :     return 0;
    3436           0 : fail:
    3437           0 :     av_bsf_free(&i->extract_extradata.bsf);
    3438           0 :     av_packet_free(&i->extract_extradata.pkt);
    3439           0 :     return ret;
    3440             : }
    3441             : 
    3442      112017 : static int extract_extradata(AVStream *st, AVPacket *pkt)
    3443             : {
    3444      112017 :     AVStreamInternal *i = st->internal;
    3445             :     AVPacket *pkt_ref;
    3446             :     int ret;
    3447             : 
    3448      112017 :     if (!i->extract_extradata.inited) {
    3449        5382 :         ret = extract_extradata_init(st);
    3450        5382 :         if (ret < 0)
    3451           0 :             return ret;
    3452             :     }
    3453             : 
    3454      112017 :     if (i->extract_extradata.inited && !i->extract_extradata.bsf)
    3455      111093 :         return 0;
    3456             : 
    3457         924 :     pkt_ref = i->extract_extradata.pkt;
    3458         924 :     ret = av_packet_ref(pkt_ref, pkt);
    3459         924 :     if (ret < 0)
    3460           0 :         return ret;
    3461             : 
    3462         924 :     ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
    3463         924 :     if (ret < 0) {
    3464           0 :         av_packet_unref(pkt_ref);
    3465           0 :         return ret;
    3466             :     }
    3467             : 
    3468        3059 :     while (ret >= 0 && !i->avctx->extradata) {
    3469             :         int extradata_size;
    3470             :         uint8_t *extradata;
    3471             : 
    3472        1211 :         ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
    3473        1211 :         if (ret < 0) {
    3474         287 :             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
    3475           0 :                 return ret;
    3476         287 :             continue;
    3477             :         }
    3478             : 
    3479         924 :         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
    3480             :                                             &extradata_size);
    3481             : 
    3482         924 :         if (extradata) {
    3483         637 :             i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
    3484         637 :             if (!i->avctx->extradata) {
    3485           0 :                 av_packet_unref(pkt_ref);
    3486           0 :                 return AVERROR(ENOMEM);
    3487             :             }
    3488         637 :             memcpy(i->avctx->extradata, extradata, extradata_size);
    3489         637 :             i->avctx->extradata_size = extradata_size;
    3490             :         }
    3491         924 :         av_packet_unref(pkt_ref);
    3492             :     }
    3493             : 
    3494         924 :     return 0;
    3495             : }
    3496             : 
    3497        5714 : int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
    3498             : {
    3499        5714 :     int i, count = 0, ret = 0, j;
    3500             :     int64_t read_size;
    3501             :     AVStream *st;
    3502             :     AVCodecContext *avctx;
    3503             :     AVPacket pkt1, *pkt;
    3504        5714 :     int64_t old_offset  = avio_tell(ic->pb);
    3505             :     // new streams might appear, no options for those
    3506        5714 :     int orig_nb_streams = ic->nb_streams;
    3507             :     int flush_codecs;
    3508        5714 :     int64_t max_analyze_duration = ic->max_analyze_duration;
    3509             :     int64_t max_stream_analyze_duration;
    3510             :     int64_t max_subtitle_analyze_duration;
    3511        5714 :     int64_t probesize = ic->probesize;
    3512        5714 :     int eof_reached = 0;
    3513        5714 :     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
    3514             : 
    3515        5714 :     flush_codecs = probesize > 0;
    3516             : 
    3517        5714 :     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
    3518             : 
    3519        5714 :     max_stream_analyze_duration = max_analyze_duration;
    3520        5714 :     max_subtitle_analyze_duration = max_analyze_duration;
    3521        5714 :     if (!max_analyze_duration) {
    3522        5713 :         max_stream_analyze_duration =
    3523        5713 :         max_analyze_duration        = 5*AV_TIME_BASE;
    3524        5713 :         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
    3525        5713 :         if (!strcmp(ic->iformat->name, "flv"))
    3526          27 :             max_stream_analyze_duration = 90*AV_TIME_BASE;
    3527        5713 :         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
    3528          42 :             max_stream_analyze_duration = 7*AV_TIME_BASE;
    3529             :     }
    3530             : 
    3531        5714 :     if (ic->pb)
    3532       10980 :         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
    3533        7320 :                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
    3534             : 
    3535       11751 :     for (i = 0; i < ic->nb_streams; i++) {
    3536             :         const AVCodec *codec;
    3537        6037 :         AVDictionary *thread_opt = NULL;
    3538        6037 :         st = ic->streams[i];
    3539        6037 :         avctx = st->internal->avctx;
    3540             : 
    3541        7539 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
    3542        1502 :             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
    3543             : /*            if (!st->time_base.num)
    3544             :                 st->time_base = */
    3545        4576 :             if (!avctx->time_base.num)
    3546        4576 :                 avctx->time_base = st->time_base;
    3547             :         }
    3548             : 
    3549             :         /* check if the caller has overridden the codec id */
    3550             : #if FF_API_LAVF_AVCTX
    3551             : FF_DISABLE_DEPRECATION_WARNINGS
    3552        6037 :         if (st->codec->codec_id != st->internal->orig_codec_id) {
    3553           0 :             st->codecpar->codec_id   = st->codec->codec_id;
    3554           0 :             st->codecpar->codec_type = st->codec->codec_type;
    3555           0 :             st->internal->orig_codec_id = st->codec->codec_id;
    3556             :         }
    3557             : FF_ENABLE_DEPRECATION_WARNINGS
    3558             : #endif
    3559             :         // only for the split stuff
    3560        6037 :         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
    3561        5573 :             st->parser = av_parser_init(st->codecpar->codec_id);
    3562        5573 :             if (st->parser) {
    3563        3621 :                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
    3564         515 :                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
    3565        3106 :                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
    3566         659 :                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
    3567             :                 }
    3568        1952 :             } else if (st->need_parsing) {
    3569         595 :                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
    3570             :                        "%s, packets or times may be invalid.\n",
    3571         595 :                        avcodec_get_name(st->codecpar->codec_id));
    3572             :             }
    3573             :         }
    3574             : 
    3575        6037 :         if (st->codecpar->codec_id != st->internal->orig_codec_id)
    3576           2 :             st->internal->orig_codec_id = st->codecpar->codec_id;
    3577             : 
    3578        6037 :         ret = avcodec_parameters_to_context(avctx, st->codecpar);
    3579        6037 :         if (ret < 0)
    3580           0 :             goto find_stream_info_err;
    3581        6037 :         if (st->request_probe <= 0)
    3582        5573 :             st->internal->avctx_inited = 1;
    3583             : 
    3584        6037 :         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
    3585             : 
    3586             :         /* Force thread count to 1 since the H.264 decoder will not extract
    3587             :          * SPS and PPS to extradata during multi-threaded decoding. */
    3588        6037 :         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
    3589             : 
    3590        6037 :         if (ic->codec_whitelist)
    3591           0 :             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
    3592             : 
    3593             :         /* Ensure that subtitle_header is properly set. */
    3594        6037 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
    3595          41 :             && codec && !avctx->codec) {
    3596          40 :             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
    3597           0 :                 av_log(ic, AV_LOG_WARNING,
    3598             :                        "Failed to open codec in %s\n",__FUNCTION__);
    3599             :         }
    3600             : 
    3601             :         // Try to just open decoders, in case this is enough to get parameters.
    3602        6037 :         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
    3603        4972 :             if (codec && !avctx->codec)
    3604        4967 :                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
    3605           6 :                     av_log(ic, AV_LOG_WARNING,
    3606             :                            "Failed to open codec in %s\n",__FUNCTION__);
    3607             :         }
    3608        6037 :         if (!options)
    3609         277 :             av_dict_free(&thread_opt);
    3610             :     }
    3611             : 
    3612       11751 :     for (i = 0; i < ic->nb_streams; i++) {
    3613             : #if FF_API_R_FRAME_RATE
    3614        6037 :         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
    3615             : #endif
    3616        6037 :         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
    3617        6037 :         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
    3618             :     }
    3619             : 
    3620        5714 :     read_size = 0;
    3621      145621 :     for (;;) {
    3622             :         int analyzed_all_streams;
    3623      151335 :         if (ff_check_interrupt(&ic->interrupt_callback)) {
    3624           0 :             ret = AVERROR_EXIT;
    3625           0 :             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
    3626           0 :             break;
    3627             :         }
    3628             : 
    3629             :         /* check if one codec still needs to be handled */
    3630      231400 :         for (i = 0; i < ic->nb_streams; i++) {
    3631      158345 :             int fps_analyze_framecount = 20;
    3632             :             int count;
    3633             : 
    3634      158345 :             st = ic->streams[i];
    3635      158345 :             if (!has_codec_parameters(st, NULL))
    3636        5373 :                 break;
    3637             :             /* If the timebase is coarse (like the usual millisecond precision
    3638             :              * of mkv), we need to analyze more frames to reliably arrive at
    3639             :              * the correct fps. */
    3640      152972 :             if (av_q2d(st->time_base) > 0.0005)
    3641       85970 :                 fps_analyze_framecount *= 2;
    3642      152972 :             if (!tb_unreliable(st->internal->avctx))
    3643       73263 :                 fps_analyze_framecount = 0;
    3644      152972 :             if (ic->fps_probe_size >= 0)
    3645           0 :                 fps_analyze_framecount = ic->fps_probe_size;
    3646      152972 :             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
    3647          20 :                 fps_analyze_framecount = 0;
    3648             :             /* variable fps and no guess at the real fps */
    3649      305944 :             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
    3650          10 :                        st->info->codec_info_duration_fields/2 :
    3651      152962 :                        st->info->duration_count;
    3652      302729 :             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
    3653      149757 :                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
    3654      108948 :                 if (count < fps_analyze_framecount)
    3655       33545 :                     break;
    3656             :             }
    3657             :             // Look at the first 3 frames if there is evidence of frame delay
    3658             :             // but the decoder delay is not set.
    3659      119427 :             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
    3660          17 :                 break;
    3661      228150 :             if (!st->internal->avctx->extradata &&
    3662      215418 :                 (!st->internal->extract_extradata.inited ||
    3663      108850 :                  st->internal->extract_extradata.bsf) &&
    3664        2172 :                 extract_extradata_check(st))
    3665         110 :                 break;
    3666      160369 :             if (st->first_dts == AV_NOPTS_VALUE &&
    3667       82128 :                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
    3668       81024 :                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
    3669       71747 :                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
    3670       31782 :                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
    3671             :                 break;
    3672             :         }
    3673      151335 :         analyzed_all_streams = 0;
    3674      151335 :         if (!missing_streams || !*missing_streams)
    3675      151307 :         if (i == ic->nb_streams) {
    3676       73027 :             analyzed_all_streams = 1;
    3677             :             /* NOTE: If the format has no header, then we need to read some
    3678             :              * packets to get most of the streams, so we cannot stop here. */
    3679       73027 :             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
    3680             :                 /* If we found the info for all the codecs, we can stop. */
    3681        2426 :                 ret = count;
    3682        2426 :                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
    3683        2426 :                 flush_codecs = 0;
    3684        2426 :                 break;
    3685             :             }
    3686             :         }
    3687             :         /* We did not get all the codec info, but we read too much data. */
    3688      148909 :         if (read_size >= probesize) {
    3689        2000 :             ret = count;
    3690        2000 :             av_log(ic, AV_LOG_DEBUG,
    3691             :                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
    3692        4005 :             for (i = 0; i < ic->nb_streams; i++)
    3693        4010 :                 if (!ic->streams[i]->r_frame_rate.num &&
    3694        2012 :                     ic->streams[i]->info->duration_count <= 1 &&
    3695           9 :                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
    3696           2 :                     strcmp(ic->iformat->name, "image2"))
    3697           2 :                     av_log(ic, AV_LOG_WARNING,
    3698             :                            "Stream #%d: not enough frames to estimate rate; "
    3699             :                            "consider increasing probesize\n", i);
    3700        2000 :             break;
    3701             :         }
    3702             : 
    3703             :         /* NOTE: A new stream can be added there if no header in file
    3704             :          * (AVFMTCTX_NOHEADER). */
    3705      146909 :         ret = read_frame_internal(ic, &pkt1);
    3706      146909 :         if (ret == AVERROR(EAGAIN))
    3707           0 :             continue;
    3708             : 
    3709      146909 :         if (ret < 0) {
    3710             :             /* EOF or error*/
    3711        1080 :             eof_reached = 1;
    3712        1080 :             break;
    3713             :         }
    3714             : 
    3715      145829 :         pkt = &pkt1;
    3716             : 
    3717      145829 :         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
    3718      145829 :             ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
    3719      145829 :                                 &ic->internal->packet_buffer_end, 0);
    3720      145829 :             if (ret < 0)
    3721           0 :                 goto find_stream_info_err;
    3722             :         }
    3723             : 
    3724      145829 :         st = ic->streams[pkt->stream_index];
    3725      145829 :         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
    3726      145812 :             read_size += pkt->size;
    3727             : 
    3728      145829 :         avctx = st->internal->avctx;
    3729      145829 :         if (!st->internal->avctx_inited) {
    3730         569 :             ret = avcodec_parameters_to_context(avctx, st->codecpar);
    3731         569 :             if (ret < 0)
    3732           0 :                 goto find_stream_info_err;
    3733         569 :             st->internal->avctx_inited = 1;
    3734             :         }
    3735             : 
    3736      145829 :         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
    3737             :             /* check for non-increasing dts */
    3738      224835 :             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
    3739      110645 :                 st->info->fps_last_dts >= pkt->dts) {
    3740          60 :                 av_log(ic, AV_LOG_DEBUG,
    3741             :                        "Non-increasing DTS in stream %d: packet %d with DTS "
    3742             :                        "%"PRId64", packet %d with DTS %"PRId64"\n",
    3743          20 :                        st->index, st->info->fps_last_dts_idx,
    3744          20 :                        st->info->fps_last_dts, st->codec_info_nb_frames,
    3745             :                        pkt->dts);
    3746          40 :                 st->info->fps_first_dts =
    3747          40 :                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
    3748             :             }
    3749             :             /* Check for a discontinuity in dts. If the difference in dts
    3750             :              * is more than 1000 times the average packet duration in the
    3751             :              * sequence, we treat it as a discontinuity. */
    3752      224815 :             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
    3753      217719 :                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
    3754      107094 :                 (pkt->dts - st->info->fps_last_dts) / 1000 >
    3755      214188 :                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
    3756      107094 :                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
    3757           0 :                 av_log(ic, AV_LOG_WARNING,
    3758             :                        "DTS discontinuity in stream %d: packet %d with DTS "
    3759             :                        "%"PRId64", packet %d with DTS %"PRId64"\n",
    3760           0 :                        st->index, st->info->fps_last_dts_idx,
    3761           0 :                        st->info->fps_last_dts, st->codec_info_nb_frames,
    3762             :                        pkt->dts);
    3763           0 :                 st->info->fps_first_dts =
    3764           0 :                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
    3765             :             }
    3766             : 
    3767             :             /* update stored dts values */
    3768      114190 :             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
    3769        3565 :                 st->info->fps_first_dts     = pkt->dts;
    3770        3565 :                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
    3771             :             }
    3772      114190 :             st->info->fps_last_dts     = pkt->dts;
    3773      114190 :             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
    3774             :         }
    3775      145829 :         if (st->codec_info_nb_frames>1) {
    3776      135803 :             int64_t t = 0;
    3777             :             int64_t limit;
    3778             : 
    3779      135803 :             if (st->time_base.den > 0)
    3780      135803 :                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
    3781      135803 :             if (st->avg_frame_rate.num > 0)
    3782        2883 :                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
    3783             : 
    3784      135803 :             if (   t == 0
    3785        6019 :                 && st->codec_info_nb_frames>30
    3786         676 :                 && st->info->fps_first_dts != AV_NOPTS_VALUE
    3787         676 :                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
    3788         676 :                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
    3789             : 
    3790      135803 :             if (analyzed_all_streams)                                limit = max_analyze_duration;
    3791       69369 :             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
    3792       69313 :             else                                                     limit = max_stream_analyze_duration;
    3793             : 
    3794      135803 :             if (t >= limit) {
    3795         208 :                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
    3796             :                        limit,
    3797             :                        t, pkt->stream_index);
    3798         208 :                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
    3799           0 :                     av_packet_unref(pkt);
    3800         208 :                 break;
    3801             :             }
    3802      135595 :             if (pkt->duration) {
    3803      132253 :                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
    3804           0 :                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
    3805             :                 } else
    3806      132253 :                     st->info->codec_info_duration += pkt->duration;
    3807      132253 :                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
    3808             :             }
    3809             :         }
    3810      145621 :         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
    3811             : #if FF_API_R_FRAME_RATE
    3812      103286 :             ff_rfps_add_frame(ic, st, pkt->dts);
    3813             : #endif
    3814      103286 :             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
    3815        1408 :                 st->info->frame_delay_evidence = 1;
    3816             :         }
    3817      145621 :         if (!st->internal->avctx->extradata) {
    3818      112017 :             ret = extract_extradata(st, pkt);
    3819      112017 :             if (ret < 0)
    3820           0 :                 goto find_stream_info_err;
    3821             :         }
    3822             : 
    3823             :         /* If still no information, we try to open the codec and to
    3824             :          * decompress the frame. We try to avoid that in most cases as
    3825             :          * it takes longer and uses more memory. For MPEG-4, we need to
    3826             :          * decompress for QuickTime.
    3827             :          *
    3828             :          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
    3829             :          * least one frame of codec data, this makes sure the codec initializes
    3830             :          * the channel configuration and does not only trust the values from
    3831             :          * the container. */
    3832      214680 :         try_decode_frame(ic, st, pkt,
    3833      134349 :                          (options && i < orig_nb_streams) ? &options[i] : NULL);
    3834             : 
    3835      145621 :         if (ic->flags & AVFMT_FLAG_NOBUFFER)
    3836           0 :             av_packet_unref(pkt);
    3837             : 
    3838      145621 :         st->codec_info_nb_frames++;
    3839      145621 :         count++;
    3840             :     }
    3841             : 
    3842        5714 :     if (eof_reached) {
    3843             :         int stream_index;
    3844        2326 :         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
    3845        1246 :             st = ic->streams[stream_index];
    3846        1246 :             avctx = st->internal->avctx;
    3847        1246 :             if (!has_codec_parameters(st, NULL)) {
    3848           4 :                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
    3849           4 :                 if (codec && !avctx->codec) {
    3850           0 :                     AVDictionary *opts = NULL;
    3851           0 :                     if (ic->codec_whitelist)
    3852           0 :                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
    3853           0 :                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
    3854           0 :                         av_log(ic, AV_LOG_WARNING,
    3855             :                                "Failed to open codec in %s\n",__FUNCTION__);
    3856           0 :                     av_dict_free(&opts);
    3857             :                 }
    3858             :             }
    3859             : 
    3860             :             // EOF already reached while reading the stream above.
    3861             :             // So continue with reoordering DTS with whatever delay we have.
    3862        1246 :             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
    3863          16 :                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
    3864             :             }
    3865             :         }
    3866             :     }
    3867             : 
    3868        5714 :     if (flush_codecs) {
    3869        3288 :         AVPacket empty_pkt = { 0 };
    3870        3288 :         int err = 0;
    3871        3288 :         av_init_packet(&empty_pkt);
    3872             : 
    3873        6771 :         for (i = 0; i < ic->nb_streams; i++) {
    3874             : 
    3875        3483 :             st = ic->streams[i];
    3876             : 
    3877             :             /* flush the decoders */
    3878        3483 :             if (st->info->found_decoder == 1) {
    3879             :                 do {
    3880        6646 :                     err = try_decode_frame(ic, st, &empty_pkt,
    3881        3197 :                                             (options && i < orig_nb_streams)
    3882        3192 :                                             ? &options[i] : NULL);
    3883        3454 :                 } while (err > 0 && !has_codec_parameters(st, NULL));
    3884             : 
    3885        3454 :                 if (err < 0) {
    3886          17 :                     av_log(ic, AV_LOG_INFO,
    3887             :                         "decoding for stream %d failed\n", st->index);
    3888             :                 }
    3889             :             }
    3890             :         }
    3891             :     }
    3892             : 
    3893        5714 :     ff_rfps_calculate(ic);
    3894             : 
    3895       11858 :     for (i = 0; i < ic->nb_streams; i++) {
    3896        6144 :         st = ic->streams[i];
    3897        6144 :         avctx = st->internal->avctx;
    3898        6144 :         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
    3899        4591 :             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
    3900         483 :                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
    3901         483 :                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
    3902         479 :                     avctx->codec_tag= tag;
    3903             :             }
    3904             : 
    3905             :             /* estimate average framerate if not set by demuxer */
    3906        7417 :             if (st->info->codec_info_duration_fields &&
    3907        5580 :                 !st->avg_frame_rate.num &&
    3908        2754 :                 st->info->codec_info_duration) {
    3909        2754 :                 int best_fps      = 0;
    3910        2754 :                 double best_error = 0.01;
    3911        2754 :                 AVRational codec_frame_rate = avctx->framerate;
    3912             : 
    3913        5508 :                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
    3914        5508 :                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
    3915        2754 :                     st->info->codec_info_duration        < 0)
    3916           0 :                     continue;
    3917        5508 :                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
    3918        2754 :                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
    3919        2754 :                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
    3920             : 
    3921             :                 /* Round guessed framerate to a "standard" framerate if it's
    3922             :                  * within 1% of the original estimate. */
    3923     1101600 :                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
    3924     1098846 :                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
    3925     3296538 :                     double error       = fabs(av_q2d(st->avg_frame_rate) /
    3926     2197692 :                                               av_q2d(std_fps) - 1);
    3927             : 
    3928     1098846 :                     if (error < best_error) {
    3929        8156 :                         best_error = error;
    3930        8156 :                         best_fps   = std_fps.num;
    3931             :                     }
    3932             : 
    3933     1098846 :                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
    3934       27531 :                         error       = fabs(av_q2d(codec_frame_rate) /
    3935       18354 :                                            av_q2d(std_fps) - 1);
    3936        9177 :                         if (error < best_error) {
    3937           7 :                             best_error = error;
    3938           7 :                             best_fps   = std_fps.num;
    3939             :                         }
    3940             :                     }
    3941             :                 }
    3942        2754 :                 if (best_fps)
    3943        2750 :                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
    3944             :                               best_fps, 12 * 1001, INT_MAX);
    3945             :             }
    3946             : 
    3947        4591 :             if (!st->r_frame_rate.num) {
    3948        7582 :                 if (    avctx->time_base.den * (int64_t) st->time_base.num
    3949        3791 :                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
    3950        7568 :                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
    3951        7568 :                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
    3952             :                 } else {
    3953           7 :                     st->r_frame_rate.num = st->time_base.den;
    3954           7 :                     st->r_frame_rate.den = st->time_base.num;
    3955             :                 }
    3956             :             }
    3957        4591 :             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
    3958         100 :                 AVRational hw_ratio = { avctx->height, avctx->width };
    3959         100 :                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
    3960             :                                                    hw_ratio);
    3961             :             }
    3962        1553 :         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
    3963        1460 :             if (!avctx->bits_per_coded_sample)
    3964         375 :                 avctx->bits_per_coded_sample =
    3965         375 :                     av_get_bits_per_sample(avctx->codec_id);
    3966             :             // set stream disposition based on audio service type
    3967        1460 :             switch (avctx->audio_service_type) {
    3968           0 :             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
    3969           0 :                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
    3970           0 :                 break;
    3971           0 :             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
    3972           0 :                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
    3973           0 :                 break;
    3974           0 :             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
    3975           0 :                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
    3976           0 :                 break;
    3977           0 :             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
    3978           0 :                 st->disposition = AV_DISPOSITION_COMMENT;
    3979           0 :                 break;
    3980           0 :             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
    3981           0 :                 st->disposition = AV_DISPOSITION_KARAOKE;
    3982           0 :                 break;
    3983             :             }
    3984             :         }
    3985             :     }
    3986             : 
    3987        5714 :     if (probesize)
    3988        5714 :         estimate_timings(ic, old_offset);
    3989             : 
    3990        5714 :     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
    3991             : 
    3992        5714 :     if (ret >= 0 && ic->nb_streams)
    3993             :         /* We could not have all the codec parameters before EOF. */
    3994        4634 :         ret = -1;
    3995       11858 :     for (i = 0; i < ic->nb_streams; i++) {
    3996             :         const char *errmsg;
    3997        6144 :         st = ic->streams[i];
    3998             : 
    3999             :         /* if no packet was ever seen, update context now for has_codec_parameters */
    4000        6144 :         if (!st->internal->avctx_inited) {
    4001           2 :             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
    4002           0 :                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
    4003           0 :                 st->codecpar->format = st->internal->avctx->sample_fmt;
    4004           2 :             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
    4005           2 :             if (ret < 0)
    4006           0 :                 goto find_stream_info_err;
    4007             :         }
    4008        6144 :         if (!has_codec_parameters(st, &errmsg)) {
    4009             :             char buf[256];
    4010           5 :             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
    4011           5 :             av_log(ic, AV_LOG_WARNING,
    4012             :                    "Could not find codec parameters for stream %d (%s): %s\n"
    4013             :                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
    4014             :                    i, buf, errmsg);
    4015             :         } else {
    4016        6139 :             ret = 0;
    4017             :         }
    4018             :     }
    4019             : 
    4020        5714 :     compute_chapters_end(ic);
    4021             : 
    4022             :     /* update the stream parameters from the internal codec contexts */
    4023       11858 :     for (i = 0; i < ic->nb_streams; i++) {
    4024        6144 :         st = ic->streams[i];
    4025             : 
    4026        6144 :         if (st->internal->avctx_inited) {
    4027        6142 :             int orig_w = st->codecpar->width;
    4028        6142 :             int orig_h = st->codecpar->height;
    4029        6142 :             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
    4030        6142 :             if (ret < 0)
    4031           0 :                 goto find_stream_info_err;
    4032             : #if FF_API_LOWRES
    4033             :             // The decoder might reduce the video size by the lowres factor.
    4034        6142 :             if (st->internal->avctx->lowres && orig_w) {
    4035           1 :                 st->codecpar->width = orig_w;
    4036           1 :                 st->codecpar->height = orig_h;
    4037             :             }
    4038             : #endif
    4039             :         }
    4040             : 
    4041             : #if FF_API_LAVF_AVCTX
    4042             : FF_DISABLE_DEPRECATION_WARNINGS
    4043        6144 :         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
    4044        6144 :         if (ret < 0)
    4045           0 :             goto find_stream_info_err;
    4046             : 
    4047             : #if FF_API_LOWRES
    4048             :         // The old API (AVStream.codec) "requires" the resolution to be adjusted
    4049             :         // by the lowres factor.
    4050        6144 :         if (st->internal->avctx->lowres && st->internal->avctx->width) {
    4051           1 :             st->codec->lowres = st->internal->avctx->lowres;
    4052           1 :             st->codec->width = st->internal->avctx->width;
    4053           1 :             st->codec->height = st->internal->avctx->height;
    4054             :         }
    4055             : #endif
    4056             : 
    4057        6144 :         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
    4058        6129 :             st->codec->time_base = st->internal->avctx->time_base;
    4059        6129 :             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
    4060             :         }
    4061        6144 :         st->codec->framerate = st->avg_frame_rate;
    4062             : 
    4063        6144 :         if (st->internal->avctx->subtitle_header) {
    4064          35 :             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
    4065          35 :             if (!st->codec->subtitle_header)
    4066           0 :                 goto find_stream_info_err;
    4067          35 :             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
    4068          35 :             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
    4069          35 :                    st->codec->subtitle_header_size);
    4070             :         }
    4071             : 
    4072             :         // Fields unavailable in AVCodecParameters
    4073        6144 :         st->codec->coded_width = st->internal->avctx->coded_width;
    4074        6144 :         st->codec->coded_height = st->internal->avctx->coded_height;
    4075        6144 :         st->codec->properties = st->internal->avctx->properties;
    4076             : FF_ENABLE_DEPRECATION_WARNINGS
    4077             : #endif
    4078             : 
    4079        6144 :         st->internal->avctx_inited = 0;
    4080             :     }
    4081             : 
    4082        5714 : find_stream_info_err:
    4083       11858 :     for (i = 0; i < ic->nb_streams; i++) {
    4084        6144 :         st = ic->streams[i];
    4085        6144 :         if (st->info)
    4086        6144 :             av_freep(&st->info->duration_error);
    4087        6144 :         avcodec_close(ic->streams[i]->internal->avctx);
    4088        6144 :         av_freep(&ic->streams[i]->info);
    4089        6144 :         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
    4090        6144 :         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
    4091             :     }
    4092        5714 :     if (ic->pb)
    4093        7320 :         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
    4094        7320 :                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
    4095        5714 :     return ret;
    4096             : }
    4097             : 
    4098        9018 : AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
    4099             : {
    4100             :     int i, j;
    4101             : 
    4102        9182 :     for (i = 0; i < ic->nb_programs; i++) {
    4103         294 :         if (ic->programs[i] == last) {
    4104         164 :             last = NULL;
    4105             :         } else {
    4106         130 :             if (!last)
    4107         170 :                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
    4108         170 :                     if (ic->programs[i]->stream_index[j] == s)
    4109         130 :                         return ic->programs[i];
    4110             :         }
    4111             :     }
    4112        8888 :     return NULL;
    4113             : }
    4114             : 
    4115          13 : int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
    4116             :                         int wanted_stream_nb, int related_stream,
    4117             :                         AVCodec **decoder_ret, int flags)
    4118             : {
    4119          13 :     int i, nb_streams = ic->nb_streams;
    4120          13 :     int ret = AVERROR_STREAM_NOT_FOUND;
    4121          13 :     int best_count = -1, best_multiframe = -1, best_disposition = -1;
    4122             :     int count, multiframe, disposition;
    4123          13 :     int64_t best_bitrate = -1;
    4124             :     int64_t bitrate;
    4125          13 :     unsigned *program = NULL;
    4126          13 :     const AVCodec *decoder = NULL, *best_decoder = NULL;
    4127             : 
    4128          13 :     if (related_stream >= 0 && wanted_stream_nb < 0) {
    4129           0 :         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
    4130           0 :         if (p) {
    4131           0 :             program    = p->stream_index;
    4132           0 :             nb_streams = p->nb_stream_indexes;
    4133             :         }
    4134             :     }
    4135          28 :     for (i = 0; i < nb_streams; i++) {
    4136          15 :         int real_stream_index = program ? program[i] : i;
    4137          15 :         AVStream *st          = ic->streams[real_stream_index];
    4138          15 :         AVCodecParameters *par = st->codecpar;
    4139          15 :         if (par->codec_type != type)
    4140           2 :             continue;
    4141          13 :         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
    4142           0 :             continue;
    4143          13 :         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
    4144           0 :             continue;
    4145          13 :         if (decoder_ret) {
    4146           0 :             decoder = find_decoder(ic, st, par->codec_id);
    4147           0 :             if (!decoder) {
    4148           0 :                 if (ret < 0)
    4149           0 :                     ret = AVERROR_DECODER_NOT_FOUND;
    4150           0 :                 continue;
    4151             :             }
    4152             :         }
    4153          13 :         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
    4154          13 :         count = st->codec_info_nb_frames;
    4155          13 :         bitrate = par->bit_rate;
    4156          13 :         multiframe = FFMIN(5, count);
    4157          13 :         if ((best_disposition >  disposition) ||
    4158           0 :             (best_disposition == disposition && best_multiframe >  multiframe) ||
    4159           0 :             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
    4160           0 :             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
    4161           0 :             continue;
    4162          13 :         best_disposition = disposition;
    4163          13 :         best_count   = count;
    4164          13 :         best_bitrate = bitrate;
    4165          13 :         best_multiframe = multiframe;
    4166          13 :         ret          = real_stream_index;
    4167          13 :         best_decoder = decoder;
    4168          13 :         if (program && i == nb_streams - 1 && ret < 0) {
    4169           0 :             program    = NULL;
    4170           0 :             nb_streams = ic->nb_streams;
    4171             :             /* no related stream found, try again with everything */
    4172           0 :             i = 0;
    4173             :         }
    4174             :     }
    4175          13 :     if (decoder_ret)
    4176           0 :         *decoder_ret = (AVCodec*)best_decoder;
    4177          13 :     return ret;
    4178             : }
    4179             : 
    4180             : /*******************************************************/
    4181             : 
    4182           0 : int av_read_play(AVFormatContext *s)
    4183             : {
    4184           0 :     if (s->iformat->read_play)
    4185           0 :         return s->iformat->read_play(s);
    4186           0 :     if (s->pb)
    4187           0 :         return avio_pause(s->pb, 0);
    4188           0 :     return AVERROR(ENOSYS);
    4189             : }
    4190             : 
    4191           0 : int av_read_pause(AVFormatContext *s)
    4192             : {
    4193           0 :     if (s->iformat->read_pause)
    4194           0 :         return s->iformat->read_pause(s);
    4195           0 :     if (s->pb)
    4196           0 :         return avio_pause(s->pb, 1);
    4197           0 :     return AVERROR(ENOSYS);
    4198             : }
    4199             : 
    4200           7 : int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
    4201             : {
    4202             :     int ret, i;
    4203             : 
    4204           7 :     dst->id                  = src->id;
    4205           7 :     dst->time_base           = src->time_base;
    4206           7 :     dst->nb_frames           = src->nb_frames;
    4207           7 :     dst->disposition         = src->disposition;
    4208           7 :     dst->sample_aspect_ratio = src->sample_aspect_ratio;
    4209           7 :     dst->avg_frame_rate      = src->avg_frame_rate;
    4210           7 :     dst->r_frame_rate        = src->r_frame_rate;
    4211             : 
    4212           7 :     av_dict_free(&dst->metadata);
    4213           7 :     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
    4214           7 :     if (ret < 0)
    4215           0 :         return ret;
    4216             : 
    4217           7 :     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
    4218           7 :     if (ret < 0)
    4219           0 :         return ret;
    4220             : 
    4221             :     /* Free existing side data*/
    4222           7 :     for (i = 0; i < dst->nb_side_data; i++)
    4223           0 :         av_free(dst->side_data[i].data);
    4224           7 :     av_freep(&dst->side_data);
    4225           7 :     dst->nb_side_data = 0;
    4226             : 
    4227             :     /* Copy side data if present */
    4228           7 :     if (src->nb_side_data) {
    4229           0 :         dst->side_data = av_mallocz_array(src->nb_side_data,
    4230             :                                           sizeof(AVPacketSideData));
    4231           0 :         if (!dst->side_data)
    4232           0 :             return AVERROR(ENOMEM);
    4233           0 :         dst->nb_side_data = src->nb_side_data;
    4234             : 
    4235           0 :         for (i = 0; i < src->nb_side_data; i++) {
    4236           0 :             uint8_t *data = av_memdup(src->side_data[i].data,
    4237           0 :                                       src->side_data[i].size);
    4238           0 :             if (!data)
    4239           0 :                 return AVERROR(ENOMEM);
    4240           0 :             dst->side_data[i].type = src->side_data[i].type;
    4241           0 :             dst->side_data[i].size = src->side_data[i].size;
    4242           0 :             dst->side_data[i].data = data;
    4243             :         }
    4244             :     }
    4245             : 
    4246           7 :     av_freep(&dst->recommended_encoder_configuration);
    4247           7 :     if (src->recommended_encoder_configuration) {
    4248           0 :         const char *conf_str = src->recommended_encoder_configuration;
    4249           0 :         dst->recommended_encoder_configuration = av_strdup(conf_str);
    4250           0 :         if (!dst->recommended_encoder_configuration)
    4251           0 :             return AVERROR(ENOMEM);
    4252             :     }
    4253             : 
    4254           7 :     return 0;
    4255             : }
    4256             : 
    4257       11795 : static void free_stream(AVStream **pst)
    4258             : {
    4259       11795 :     AVStream *st = *pst;
    4260             :     int i;
    4261             : 
    4262       11795 :     if (!st)
    4263           0 :         return;
    4264             : 
    4265       12410 :     for (i = 0; i < st->nb_side_data; i++)
    4266         615 :         av_freep(&st->side_data[i].data);
    4267       11795 :     av_freep(&st->side_data);
    4268             : 
    4269       11795 :     if (st->parser)
    4270        2402 :         av_parser_close(st->parser);
    4271             : 
    4272       11795 :     if (st->attached_pic.data)
    4273          17 :         av_packet_unref(&st->attached_pic);
    4274             : 
    4275       11795 :     if (st->internal) {
    4276       11795 :         avcodec_free_context(&st->internal->avctx);
    4277       11801 :         for (i = 0; i < st->internal->nb_bsfcs; i++) {
    4278           6 :             av_bsf_free(&st->internal->bsfcs[i]);
    4279           6 :             av_freep(&st->internal->bsfcs);
    4280             :         }
    4281       11795 :         av_freep(&st->internal->priv_pts);
    4282       11795 :         av_bsf_free(&st->internal->extract_extradata.bsf);
    4283       11795 :         av_packet_free(&st->internal->extract_extradata.pkt);
    4284             :     }
    4285       11795 :     av_freep(&st->internal);
    4286             : 
    4287       11795 :     av_dict_free(&st->metadata);
    4288       11795 :     avcodec_parameters_free(&st->codecpar);
    4289       11795 :     av_freep(&st->probe_data.buf);
    4290       11795 :     av_freep(&st->index_entries);
    4291             : #if FF_API_LAVF_AVCTX
    4292             : FF_DISABLE_DEPRECATION_WARNINGS
    4293       11795 :     avcodec_free_context(&st->codec);
    4294             : FF_ENABLE_DEPRECATION_WARNINGS
    4295             : #endif
    4296       11795 :     av_freep(&st->priv_data);
    4297       11795 :     if (st->info)
    4298        5651 :         av_freep(&st->info->duration_error);
    4299       11795 :     av_freep(&st->info);
    4300       11795 :     av_freep(&st->recommended_encoder_configuration);
    4301             : 
    4302       11795 :     av_freep(pst);
    4303             : }
    4304             : 
    4305       11795 : void ff_free_stream(AVFormatContext *s, AVStream *st)
    4306             : {
    4307       11795 :     av_assert0(s->nb_streams>0);
    4308       11795 :     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
    4309             : 
    4310       11795 :     free_stream(&s->streams[ --s->nb_streams ]);
    4311       11795 : }
    4312             : 
    4313       11193 : void avformat_free_context(AVFormatContext *s)
    4314             : {
    4315             :     int i;
    4316             : 
    4317       11193 :     if (!s)
    4318           5 :         return;
    4319             : 
    4320       11188 :     av_opt_free(s);
    4321       11188 :     if (s->iformat && s->iformat->priv_class && s->priv_data)
    4322        4814 :         av_opt_free(s->priv_data);
    4323       11188 :     if (s->oformat && s->oformat->priv_class && s->priv_data)
    4324           0 :         av_opt_free(s->priv_data);
    4325             : 
    4326       22973 :     for (i = s->nb_streams - 1; i >= 0; i--)
    4327       11785 :         ff_free_stream(s, s->streams[i]);
    4328             : 
    4329             : 
    4330       11223 :     for (i = s->nb_programs - 1; i >= 0; i--) {
    4331          35 :         av_dict_free(&s->programs[i]->metadata);
    4332          35 :         av_freep(&s->programs[i]->stream_index);
    4333          35 :         av_freep(&s->programs[i]);
    4334             :     }
    4335       11188 :     av_freep(&s->programs);
    4336       11188 :     av_freep(&s->priv_data);
    4337       22400 :     while (s->nb_chapters--) {
    4338          24 :         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
    4339          24 :         av_freep(&s->chapters[s->nb_chapters]);
    4340             :     }
    4341       11188 :     av_freep(&s->chapters);
    4342       11188 :     av_dict_free(&s->metadata);
    4343       11188 :     av_dict_free(&s->internal->id3v2_meta);
    4344       11188 :     av_freep(&s->streams);
    4345       11188 :     flush_packet_queue(s);
    4346       11188 :     av_freep(&s->internal);
    4347       11188 :     av_free(s);
    4348             : }
    4349             : 
    4350        5723 : void avformat_close_input(AVFormatContext **ps)
    4351             : {
    4352             :     AVFormatContext *s;
    4353             :     AVIOContext *pb;
    4354             : 
    4355        5723 :     if (!ps || !*ps)
    4356           0 :         return;
    4357             : 
    4358        5723 :     s  = *ps;
    4359        5723 :     pb = s->pb;
    4360             : 
    4361       11427 :     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
    4362        5704 :         (s->flags & AVFMT_FLAG_CUSTOM_IO))
    4363          23 :         pb = NULL;
    4364             : 
    4365        5723 :     flush_packet_queue(s);
    4366             : 
    4367        5723 :     if (s->iformat)
    4368        5723 :         if (s->iformat->read_close)
    4369        3513 :             s->iformat->read_close(s);
    4370             : 
    4371        5723 :     avformat_free_context(s);
    4372             : 
    4373        5723 :     *ps = NULL;
    4374             : 
    4375        5723 :     avio_close(pb);
    4376             : }
    4377             : 
    4378       11795 : AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
    4379             : {
    4380             :     AVStream *st;
    4381             :     int i;
    4382             :     AVStream **streams;
    4383             : 
    4384       11795 :     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
    4385           0 :         if (s->max_streams < INT_MAX/sizeof(*streams))
    4386           0 :             av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
    4387           0 :         return NULL;
    4388             :     }
    4389       11795 :     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
    4390       11795 :     if (!streams)
    4391           0 :         return NULL;
    4392       11795 :     s->streams = streams;
    4393             : 
    4394       11795 :     st = av_mallocz(sizeof(AVStream));
    4395       11795 :     if (!st)
    4396           0 :         return NULL;
    4397       11795 :     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
    4398           0 :         av_free(st);
    4399           0 :         return NULL;
    4400             :     }
    4401       11795 :     st->info->last_dts = AV_NOPTS_VALUE;
    4402             : 
    4403             : #if FF_API_LAVF_AVCTX
    4404             : FF_DISABLE_DEPRECATION_WARNINGS
    4405       11795 :     st->codec = avcodec_alloc_context3(c);
    4406       11795 :     if (!st->codec) {
    4407           0 :         av_free(st->info);
    4408           0 :         av_free(st);
    4409           0 :         return NULL;
    4410             :     }
    4411             : FF_ENABLE_DEPRECATION_WARNINGS
    4412             : #endif
    4413             : 
    4414       11795 :     st->internal = av_mallocz(sizeof(*st->internal));
    4415       11795 :     if (!st->internal)
    4416           0 :         goto fail;
    4417             : 
    4418       11795 :     st->codecpar = avcodec_parameters_alloc();
    4419       11795 :     if (!st->codecpar)
    4420           0 :         goto fail;
    4421             : 
    4422       11795 :     st->internal->avctx = avcodec_alloc_context3(NULL);
    4423       11795 :     if (!st->internal->avctx)
    4424           0 :         goto fail;
    4425             : 
    4426       11795 :     if (s->iformat) {
    4427             : #if FF_API_LAVF_AVCTX
    4428             : FF_DISABLE_DEPRECATION_WARNINGS
    4429             :         /* no default bitrate if decoding */
    4430        6162 :         st->codec->bit_rate = 0;
    4431             : FF_ENABLE_DEPRECATION_WARNINGS
    4432             : #endif
    4433             : 
    4434             :         /* default pts setting is MPEG-like */
    4435        6162 :         avpriv_set_pts_info(st, 33, 1, 90000);
    4436             :         /* we set the current DTS to 0 so that formats without any timestamps
    4437             :          * but durations get some timestamps, formats with some unknown
    4438             :          * timestamps have their first few packets buffered and the
    4439             :          * timestamps corrected before they are returned to the user */
    4440        6162 :         st->cur_dts = RELATIVE_TS_BASE;
    4441             :     } else {
    4442        5633 :         st->cur_dts = AV_NOPTS_VALUE;
    4443             :     }
    4444             : 
    4445       11795 :     st->index      = s->nb_streams;
    4446       11795 :     st->start_time = AV_NOPTS_VALUE;
    4447       11795 :     st->duration   = AV_NOPTS_VALUE;
    4448       11795 :     st->first_dts     = AV_NOPTS_VALUE;
    4449       11795 :     st->probe_packets = MAX_PROBE_PACKETS;
    4450       11795 :     st->pts_wrap_reference = AV_NOPTS_VALUE;
    4451       11795 :     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
    4452             : 
    4453       11795 :     st->last_IP_pts = AV_NOPTS_VALUE;
    4454       11795 :     st->last_dts_for_order_check = AV_NOPTS_VALUE;
    4455      212310 :     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
    4456      200515 :         st->pts_buffer[i] = AV_NOPTS_VALUE;
    4457             : 
    4458       11795 :     st->sample_aspect_ratio = (AVRational) { 0, 1 };
    4459             : 
    4460             : #if FF_API_R_FRAME_RATE
    4461       11795 :     st->info->last_dts      = AV_NOPTS_VALUE;
    4462             : #endif
    4463       11795 :     st->info->fps_first_dts = AV_NOPTS_VALUE;
    4464       11795 :     st->info->fps_last_dts  = AV_NOPTS_VALUE;
    4465             : 
    4466       11795 :     st->inject_global_side_data = s->internal->inject_global_side_data;
    4467             : 
    4468       11795 :     st->internal->need_context_update = 1;
    4469             : 
    4470       11795 :     s->streams[s->nb_streams++] = st;
    4471       11795 :     return st;
    4472           0 : fail:
    4473           0 :     free_stream(&st);
    4474           0 :     return NULL;
    4475             : }
    4476             : 
    4477         309 : AVProgram *av_new_program(AVFormatContext *ac, int id)
    4478             : {
    4479         309 :     AVProgram *program = NULL;
    4480             :     int i;
    4481             : 
    4482         309 :     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
    4483             : 
    4484         583 :     for (i = 0; i < ac->nb_programs; i++)
    4485         274 :         if (ac->programs[i]->id == id)
    4486         274 :             program = ac->programs[i];
    4487             : 
    4488         309 :     if (!program) {
    4489          35 :         program = av_mallocz(sizeof(AVProgram));
    4490          35 :         if (!program)
    4491           0 :             return NULL;
    4492          35 :         dynarray_add(&ac->programs, &ac->nb_programs, program);
    4493          35 :         program->discard = AVDISCARD_NONE;
    4494             :     }
    4495         309 :     program->id = id;
    4496         309 :     program->pts_wrap_reference = AV_NOPTS_VALUE;
    4497         309 :     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
    4498             : 
    4499         309 :     program->start_time =
    4500         309 :     program->end_time   = AV_NOPTS_VALUE;
    4501             : 
    4502         309 :     return program;
    4503             : }
    4504             : 
    4505          14 : AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
    4506             :                               int64_t start, int64_t end, const char *title)
    4507             : {
    4508          14 :     AVChapter *chapter = NULL;
    4509             :     int i;
    4510             : 
    4511          14 :     if (end != AV_NOPTS_VALUE && start > end) {
    4512           0 :         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
    4513           0 :         return NULL;
    4514             :     }
    4515             : 
    4516          20 :     for (i = 0; i < s->nb_chapters; i++)
    4517           6 :         if (s->chapters[i]->id == id)
    4518           0 :             chapter = s->chapters[i];
    4519             : 
    4520          14 :     if (!chapter) {
    4521          14 :         chapter = av_mallocz(sizeof(AVChapter));
    4522          14 :         if (!chapter)
    4523           0 :             return NULL;
    4524          14 :         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
    4525             :     }
    4526          14 :     av_dict_set(&chapter->metadata, "title", title, 0);
    4527          14 :     chapter->id        = id;
    4528          14 :     chapter->time_base = time_base;
    4529          14 :     chapter->start     = start;
    4530          14 :     chapter->end       = end;
    4531             : 
    4532          14 :     return chapter;
    4533             : }
    4534             : 
    4535         361 : void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
    4536             : {
    4537             :     int i, j;
    4538         361 :     AVProgram *program = NULL;
    4539             :     void *tmp;
    4540             : 
    4541         361 :     if (idx >= ac->nb_streams) {
    4542           0 :         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
    4543           0 :         return;
    4544             :     }
    4545             : 
    4546         722 :     for (i = 0; i < ac->nb_programs; i++) {
    4547         361 :         if (ac->programs[i]->id != progid)
    4548           0 :             continue;
    4549         361 :         program = ac->programs[i];
    4550         529 :         for (j = 0; j < program->nb_stream_indexes; j++)
    4551         259 :             if (program->stream_index[j] == idx)
    4552          91 :                 return;
    4553             : 
    4554         270 :         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
    4555         270 :         if (!tmp)
    4556           0 :             return;
    4557         270 :         program->stream_index = tmp;
    4558         270 :         program->stream_index[program->nb_stream_indexes++] = idx;
    4559         270 :         return;
    4560             :     }
    4561             : }
    4562             : 
    4563          66 : uint64_t ff_ntp_time(void)
    4564             : {
    4565          66 :     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
    4566             : }
    4567             : 
    4568      102463 : int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
    4569             : {
    4570             :     const char *p;
    4571             :     char *q, buf1[20], c;
    4572             :     int nd, len, percentd_found;
    4573             : 
    4574      102463 :     q = buf;
    4575      102463 :     p = path;
    4576      102463 :     percentd_found = 0;
    4577             :     for (;;) {
    4578    15473447 :         c = *p++;
    4579     7787955 :         if (c == '\0')
    4580      102463 :             break;
    4581     7685492 :         if (c == '%') {
    4582             :             do {
    4583      101902 :                 nd = 0;
    4584      407524 :                 while (av_isdigit(*p))
    4585      203720 :                     nd = nd * 10 + *p++ - '0';
    4586      101902 :                 c = *p++;
    4587      101902 :             } while (av_isdigit(c));
    4588             : 
    4589      101902 :             switch (c) {
    4590           0 :             case '%':
    4591           0 :                 goto addchar;
    4592      101902 :             case 'd':
    4593      101902 :                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
    4594           0 :                     goto fail;
    4595      101902 :                 percentd_found = 1;
    4596      101902 :                 if (number < 0)
    4597           0 :                     nd += 1;
    4598      101902 :                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
    4599      101902 :                 len = strlen(buf1);
    4600      101902 :                 if ((q - buf + len) > buf_size - 1)
    4601           0 :                     goto fail;
    4602      101902 :                 memcpy(q, buf1, len);
    4603      101902 :                 q += len;
    4604      101902 :                 break;
    4605           0 :             default:
    4606           0 :                 goto fail;
    4607             :             }
    4608             :         } else {
    4609     7583590 : addchar:
    4610     7583590 :             if ((q - buf) < buf_size - 1)
    4611     7583590 :                 *q++ = c;
    4612             :         }
    4613             :     }
    4614      102463 :     if (!percentd_found)
    4615         561 :         goto fail;
    4616      101902 :     *q = '\0';
    4617      101902 :     return 0;
    4618         561 : fail:
    4619         561 :     *q = '\0';
    4620         561 :     return -1;
    4621             : }
    4622             : 
    4623      102034 : int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
    4624             : {
    4625      102034 :     return av_get_frame_filename2(buf, buf_size, path, number, 0);
    4626             : }
    4627             : 
    4628           0 : void av_url_split(char *proto, int proto_size,
    4629             :                   char *authorization, int authorization_size,
    4630             :                   char *hostname, int hostname_size,
    4631             :                   int *port_ptr, char *path, int path_size, const char *url)
    4632             : {
    4633             :     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
    4634             : 
    4635           0 :     if (port_ptr)
    4636           0 :         *port_ptr = -1;
    4637           0 :     if (proto_size > 0)
    4638           0 :         proto[0] = 0;
    4639           0 :     if (authorization_size > 0)
    4640           0 :         authorization[0] = 0;
    4641           0 :     if (hostname_size > 0)
    4642           0 :         hostname[0] = 0;
    4643           0 :     if (path_size > 0)
    4644           0 :         path[0] = 0;
    4645             : 
    4646             :     /* parse protocol */
    4647           0 :     if ((p = strchr(url, ':'))) {
    4648           0 :         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
    4649           0 :         p++; /* skip ':' */
    4650           0 :         if (*p == '/')
    4651           0 :             p++;
    4652           0 :         if (*p == '/')
    4653           0 :             p++;
    4654             :     } else {
    4655             :         /* no protocol means plain filename */
    4656           0 :         av_strlcpy(path, url, path_size);
    4657           0 :         return;
    4658             :     }
    4659             : 
    4660             :     /* separate path from hostname */
    4661           0 :     ls = strchr(p, '/');
    4662           0 :     ls2 = strchr(p, '?');
    4663           0 :     if (!ls)
    4664           0 :         ls = ls2;
    4665           0 :     else if (ls && ls2)
    4666           0 :         ls = FFMIN(ls, ls2);
    4667           0 :     if (ls)
    4668           0 :         av_strlcpy(path, ls, path_size);
    4669             :     else
    4670           0 :         ls = &p[strlen(p)];  // XXX
    4671             : 
    4672             :     /* the rest is hostname, use that to parse auth/port */
    4673           0 :     if (ls != p) {
    4674             :         /* authorization (user[:pass]@hostname) */
    4675           0 :         at2 = p;
    4676           0 :         while ((at = strchr(p, '@')) && at < ls) {
    4677           0 :             av_strlcpy(authorization, at2,
    4678           0 :                        FFMIN(authorization_size, at + 1 - at2));
    4679           0 :             p = at + 1; /* skip '@' */
    4680             :         }
    4681             : 
    4682           0 :         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
    4683             :             /* [host]:port */
    4684           0 :             av_strlcpy(hostname, p + 1,
    4685           0 :                        FFMIN(hostname_size, brk - p));
    4686           0 :             if (brk[1] == ':' && port_ptr)
    4687           0 :                 *port_ptr = atoi(brk + 2);
    4688           0 :         } else if ((col = strchr(p, ':')) && col < ls) {
    4689           0 :             av_strlcpy(hostname, p,
    4690           0 :                        FFMIN(col + 1 - p, hostname_size));
    4691           0 :             if (port_ptr)
    4692           0 :                 *port_ptr = atoi(col + 1);
    4693             :         } else
    4694           0 :             av_strlcpy(hostname, p,
    4695           0 :                        FFMIN(ls + 1 - p, hostname_size));
    4696             :     }
    4697             : }
    4698             : 
    4699           1 : char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
    4700             : {
    4701             :     int i;
    4702             :     static const char hex_table_uc[16] = { '0', '1', '2', '3',
    4703             :                                            '4', '5', '6', '7',
    4704             :                                            '8', '9', 'A', 'B',
    4705             :                                            'C', 'D', 'E', 'F' };
    4706             :     static const char hex_table_lc[16] = { '0', '1', '2', '3',
    4707             :                                            '4', '5', '6', '7',
    4708             :                                            '8', '9', 'a', 'b',
    4709             :                                            'c', 'd', 'e', 'f' };
    4710           1 :     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
    4711             : 
    4712          31 :     for (i = 0; i < s; i++) {
    4713          30 :         buff[i * 2]     = hex_table[src[i] >> 4];
    4714          30 :         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
    4715             :     }
    4716             : 
    4717           1 :     return buff;
    4718             : }
    4719             : 
    4720           0 : int ff_hex_to_data(uint8_t *data, const char *p)
    4721             : {
    4722             :     int c, len, v;
    4723             : 
    4724           0 :     len = 0;
    4725           0 :     v   = 1;
    4726             :     for (;;) {
    4727           0 :         p += strspn(p, SPACE_CHARS);
    4728           0 :         if (*p == '\0')
    4729           0 :             break;
    4730           0 :         c = av_toupper((unsigned char) *p++);
    4731           0 :         if (c >= '0' && c <= '9')
    4732           0 :             c = c - '0';
    4733           0 :         else if (c >= 'A' && c <= 'F')
    4734           0 :             c = c - 'A' + 10;
    4735             :         else
    4736             :             break;
    4737           0 :         v = (v << 4) | c;
    4738           0 :         if (v & 0x100) {
    4739           0 :             if (data)
    4740           0 :                 data[len] = v;
    4741           0 :             len++;
    4742           0 :             v = 1;
    4743             :         }
    4744             :     }
    4745           0 :     return len;
    4746             : }
    4747             : 
    4748       15813 : void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
    4749             :                          unsigned int pts_num, unsigned int pts_den)
    4750             : {
    4751             :     AVRational new_tb;
    4752       15813 :     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
    4753       15813 :         if (new_tb.num != pts_num)
    4754         383 :             av_log(NULL, AV_LOG_DEBUG,
    4755             :                    "st:%d removing common factor %d from timebase\n",
    4756         383 :                    s->index, pts_num / new_tb.num);
    4757             :     } else
    4758           0 :         av_log(NULL, AV_LOG_WARNING,
    4759             :                "st:%d has too large timebase, reducing\n", s->index);
    4760             : 
    4761       15813 :     if (new_tb.num <= 0 || new_tb.den <= 0) {
    4762           1 :         av_log(NULL, AV_LOG_ERROR,
    4763             :                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
    4764             :                new_tb.num, new_tb.den,
    4765             :                s->index);
    4766           1 :         return;
    4767             :     }
    4768       15812 :     s->time_base     = new_tb;
    4769             : #if FF_API_LAVF_AVCTX
    4770             : FF_DISABLE_DEPRECATION_WARNINGS
    4771       15812 :     s->codec->pkt_timebase = new_tb;
    4772             : FF_ENABLE_DEPRECATION_WARNINGS
    4773             : #endif
    4774       15812 :     s->internal->avctx->pkt_timebase = new_tb;
    4775       15812 :     s->pts_wrap_bits = pts_wrap_bits;
    4776             : }
    4777             : 
    4778           0 : void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
    4779             :                         void *context)
    4780             : {
    4781           0 :     const char *ptr = str;
    4782             : 
    4783             :     /* Parse key=value pairs. */
    4784           0 :     for (;;) {
    4785             :         const char *key;
    4786           0 :         char *dest = NULL, *dest_end;
    4787           0 :         int key_len, dest_len = 0;
    4788             : 
    4789             :         /* Skip whitespace and potential commas. */
    4790           0 :         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
    4791           0 :             ptr++;
    4792           0 :         if (!*ptr)
    4793           0 :             break;
    4794             : 
    4795           0 :         key = ptr;
    4796             : 
    4797           0 :         if (!(ptr = strchr(key, '=')))
    4798           0 :             break;
    4799           0 :         ptr++;
    4800           0 :         key_len = ptr - key;
    4801             : 
    4802           0 :         callback_get_buf(context, key, key_len, &dest, &dest_len);
    4803           0 :         dest_end = dest + dest_len - 1;
    4804             : 
    4805           0 :         if (*ptr == '\"') {
    4806           0 :             ptr++;
    4807           0 :             while (*ptr && *ptr != '\"') {
    4808           0 :                 if (*ptr == '\\') {
    4809           0 :                     if (!ptr[1])
    4810           0 :                         break;
    4811           0 :                     if (dest && dest < dest_end)
    4812           0 :                         *dest++ = ptr[1];
    4813           0 :                     ptr += 2;
    4814             :                 } else {
    4815           0 :                     if (dest && dest < dest_end)
    4816           0 :                         *dest++ = *ptr;
    4817           0 :                     ptr++;
    4818             :                 }
    4819             :             }
    4820           0 :             if (*ptr == '\"')
    4821           0 :                 ptr++;
    4822             :         } else {
    4823           0 :             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
    4824           0 :                 if (dest && dest < dest_end)
    4825           0 :                     *dest++ = *ptr;
    4826             :         }
    4827           0 :         if (dest)
    4828           0 :             *dest = 0;
    4829             :     }
    4830           0 : }
    4831             : 
    4832        1021 : int ff_find_stream_index(AVFormatContext *s, int id)
    4833             : {
    4834             :     int i;
    4835        1941 :     for (i = 0; i < s->nb_streams; i++)
    4836        1897 :         if (s->streams[i]->id == id)
    4837         977 :             return i;
    4838          44 :     return -1;
    4839             : }
    4840             : 
    4841        4493 : int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
    4842             :                          int std_compliance)
    4843             : {
    4844        4493 :     if (ofmt) {
    4845             :         unsigned int codec_tag;
    4846        4493 :         if (ofmt->query_codec)
    4847        4538 :             return ofmt->query_codec(codec_id, std_compliance);
    4848        4448 :         else if (ofmt->codec_tag)
    4849        2177 :             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
    4850        2271 :         else if (codec_id == ofmt->video_codec ||
    4851           0 :                  codec_id == ofmt->audio_codec ||
    4852           0 :                  codec_id == ofmt->subtitle_codec ||
    4853           0 :                  codec_id == ofmt->data_codec)
    4854        2271 :             return 1;
    4855             :     }
    4856           0 :     return AVERROR_PATCHWELCOME;
    4857             : }
    4858             : 
    4859        5466 : int avformat_network_init(void)
    4860             : {
    4861             : #if CONFIG_NETWORK
    4862             :     int ret;
    4863        5466 :     ff_network_inited_globally = 1;
    4864        5466 :     if ((ret = ff_network_init()) < 0)
    4865           0 :         return ret;
    4866        5466 :     if ((ret = ff_tls_init()) < 0)
    4867           0 :         return ret;
    4868             : #endif
    4869        5466 :     return 0;
    4870             : }
    4871             : 
    4872        5466 : int avformat_network_deinit(void)
    4873             : {
    4874             : #if CONFIG_NETWORK
    4875        5466 :     ff_network_close();
    4876        5466 :     ff_tls_deinit();
    4877        5466 :     ff_network_inited_globally = 0;
    4878             : #endif
    4879        5466 :     return 0;
    4880             : }
    4881             : 
    4882           3 : int ff_add_param_change(AVPacket *pkt, int32_t channels,
    4883             :                         uint64_t channel_layout, int32_t sample_rate,
    4884             :                         int32_t width, int32_t height)
    4885             : {
    4886           3 :     uint32_t flags = 0;
    4887           3 :     int size = 4;
    4888             :     uint8_t *data;
    4889           3 :     if (!pkt)
    4890           0 :         return AVERROR(EINVAL);
    4891           3 :     if (channels) {
    4892           0 :         size  += 4;
    4893           0 :         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
    4894             :     }
    4895           3 :     if (channel_layout) {
    4896           0 :         size  += 8;
    4897           0 :         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
    4898             :     }
    4899           3 :     if (sample_rate) {
    4900           0 :         size  += 4;
    4901           0 :         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
    4902             :     }
    4903           3 :     if (width || height) {
    4904           3 :         size  += 8;
    4905           3 :         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
    4906             :     }
    4907           3 :     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
    4908           3 :     if (!data)
    4909           0 :         return AVERROR(ENOMEM);
    4910           3 :     bytestream_put_le32(&data, flags);
    4911           3 :     if (channels)
    4912           0 :         bytestream_put_le32(&data, channels);
    4913           3 :     if (channel_layout)
    4914           0 :         bytestream_put_le64(&data, channel_layout);
    4915           3 :     if (sample_rate)
    4916           0 :         bytestream_put_le32(&data, sample_rate);
    4917           3 :     if (width || height) {
    4918           3 :         bytestream_put_le32(&data, width);
    4919           3 :         bytestream_put_le32(&data, height);
    4920             :     }
    4921           3 :     return 0;
    4922             : }
    4923             : 
    4924         214 : AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
    4925             : {
    4926         214 :     AVRational undef = {0, 1};
    4927         214 :     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
    4928         214 :     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
    4929         214 :     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
    4930             : 
    4931         428 :     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
    4932         428 :                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
    4933         214 :     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
    4934          13 :         stream_sample_aspect_ratio = undef;
    4935             : 
    4936         428 :     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
    4937         428 :                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
    4938         214 :     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
    4939         141 :         frame_sample_aspect_ratio = undef;
    4940             : 
    4941         214 :     if (stream_sample_aspect_ratio.num)
    4942         201 :         return stream_sample_aspect_ratio;
    4943             :     else
    4944          13 :         return frame_sample_aspect_ratio;
    4945             : }
    4946             : 
    4947        4239 : AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
    4948             : {
    4949        4239 :     AVRational fr = st->r_frame_rate;
    4950        4239 :     AVRational codec_fr = st->internal->avctx->framerate;
    4951        4239 :     AVRational   avg_fr = st->avg_frame_rate;
    4952             : 
    4953        7659 :     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
    4954        6836 :         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
    4955           0 :         fr = avg_fr;
    4956             :     }
    4957             : 
    4958             : 
    4959        4239 :     if (st->internal->avctx->ticks_per_frame > 1) {
    4960         573 :         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
    4961         568 :             (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
    4962           3 :             fr = codec_fr;
    4963             :     }
    4964             : 
    4965        4239 :     return fr;
    4966             : }
    4967             : 
    4968       21524 : int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
    4969             :                                     const char *spec)
    4970             : {
    4971       21524 :     if (*spec <= '9' && *spec >= '0') /* opt:index */
    4972          51 :         return strtol(spec, NULL, 0) == st->index;
    4973       30110 :     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
    4974       17271 :              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
    4975             :         enum AVMediaType type;
    4976       12839 :         int nopic = 0;
    4977             : 
    4978       12839 :         switch (*spec++) {
    4979       11726 :         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
    4980        1097 :         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
    4981          13 :         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
    4982           0 :         case 'd': type = AVMEDIA_TYPE_DATA;       break;
    4983           3 :         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
    4984           0 :         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
    4985           0 :         default:  av_assert0(0);
    4986             :         }
    4987             : #if FF_API_LAVF_AVCTX
    4988             : FF_DISABLE_DEPRECATION_WARNINGS
    4989       12839 :         if (type != st->codecpar->codec_type
    4990         183 :            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
    4991         183 :             return 0;
    4992             : FF_ENABLE_DEPRECATION_WARNINGS
    4993             : #else
    4994             :         if (type != st->codecpar->codec_type)
    4995             :             return 0;
    4996             : #endif
    4997       12656 :         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
    4998           0 :             return 0;
    4999       12656 :         if (*spec++ == ':') { /* possibly followed by :index */
    5000           6 :             int i, index = strtol(spec, NULL, 0);
    5001          13 :             for (i = 0; i < s->nb_streams; i++) {
    5002             : #if FF_API_LAVF_AVCTX
    5003             : FF_DISABLE_DEPRECATION_WARNINGS
    5004          13 :                 if ((s->streams[i]->codecpar->codec_type == type
    5005           5 :                       || s->streams[i]->codec->codec_type == type
    5006           8 :                     ) &&
    5007           8 :                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
    5008           8 :                     index-- == 0)
    5009           6 :                     return i == st->index;
    5010             : FF_ENABLE_DEPRECATION_WARNINGS
    5011             : #else
    5012             :                 if ((s->streams[i]->codecpar->codec_type == type) &&
    5013             :                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
    5014             :                     index-- == 0)
    5015             :                     return i == st->index;
    5016             : #endif
    5017             :             }
    5018           0 :             return 0;
    5019             :         }
    5020       12650 :         return 1;
    5021        8634 :     } else if (*spec == 'p' && *(spec + 1) == ':') {
    5022             :         int prog_id, i, j;
    5023             :         char *endptr;
    5024           0 :         spec += 2;
    5025           0 :         prog_id = strtol(spec, &endptr, 0);
    5026           0 :         for (i = 0; i < s->nb_programs; i++) {
    5027           0 :             if (s->programs[i]->id != prog_id)
    5028           0 :                 continue;
    5029             : 
    5030           0 :             if (*endptr++ == ':') {
    5031           0 :                 int stream_idx = strtol(endptr, NULL, 0);
    5032           0 :                 return stream_idx >= 0 &&
    5033           0 :                     stream_idx < s->programs[i]->nb_stream_indexes &&
    5034           0 :                     st->index == s->programs[i]->stream_index[stream_idx];
    5035             :             }
    5036             : 
    5037           0 :             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
    5038           0 :                 if (st->index == s->programs[i]->stream_index[j])
    5039           0 :                     return 1;
    5040             :         }
    5041           0 :         return 0;
    5042       17268 :     } else if (*spec == '#' ||
    5043        8634 :                (*spec == 'i' && *(spec + 1) == ':')) {
    5044             :         int stream_id;
    5045             :         char *endptr;
    5046           0 :         spec += 1 + (*spec == 'i');
    5047           0 :         stream_id = strtol(spec, &endptr, 0);
    5048           0 :         if (!*endptr)
    5049           0 :             return stream_id == st->id;
    5050        8634 :     } else if (*spec == 'm' && *(spec + 1) == ':') {
    5051             :         AVDictionaryEntry *tag;
    5052             :         char *key, *val;
    5053             :         int ret;
    5054             : 
    5055           0 :         spec += 2;
    5056           0 :         val = strchr(spec, ':');
    5057             : 
    5058           0 :         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
    5059           0 :         if (!key)
    5060           0 :             return AVERROR(ENOMEM);
    5061             : 
    5062           0 :         tag = av_dict_get(st->metadata, key, NULL, 0);
    5063           0 :         if (tag) {
    5064           0 :             if (!val || !strcmp(tag->value, val + 1))
    5065           0 :                 ret = 1;
    5066             :             else
    5067           0 :                 ret = 0;
    5068             :         } else
    5069           0 :             ret = 0;
    5070             : 
    5071           0 :         av_freep(&key);
    5072           0 :         return ret;
    5073        8634 :     } else if (*spec == 'u') {
    5074           0 :         AVCodecParameters *par = st->codecpar;
    5075             : #if FF_API_LAVF_AVCTX
    5076             : FF_DISABLE_DEPRECATION_WARNINGS
    5077           0 :         AVCodecContext *codec = st->codec;
    5078             : FF_ENABLE_DEPRECATION_WARNINGS
    5079             : #endif
    5080             :         int val;
    5081           0 :         switch (par->codec_type) {
    5082           0 :         case AVMEDIA_TYPE_AUDIO:
    5083           0 :             val = par->sample_rate && par->channels;
    5084             : #if FF_API_LAVF_AVCTX
    5085           0 :             val = val || (codec->sample_rate && codec->channels);
    5086             : #endif
    5087           0 :             if (par->format == AV_SAMPLE_FMT_NONE
    5088             : #if FF_API_LAVF_AVCTX
    5089           0 :                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
    5090             : #endif
    5091             :                 )
    5092           0 :                 return 0;
    5093           0 :             break;
    5094           0 :         case AVMEDIA_TYPE_VIDEO:
    5095           0 :             val = par->width && par->height;
    5096             : #if FF_API_LAVF_AVCTX
    5097           0 :             val = val || (codec->width && codec->height);
    5098             : #endif
    5099           0 :             if (par->format == AV_PIX_FMT_NONE
    5100             : #if FF_API_LAVF_AVCTX
    5101           0 :                 && codec->pix_fmt == AV_PIX_FMT_NONE
    5102             : #endif
    5103             :                 )
    5104           0 :                 return 0;
    5105           0 :             break;
    5106           0 :         case AVMEDIA_TYPE_UNKNOWN:
    5107           0 :             val = 0;
    5108           0 :             break;
    5109           0 :         default:
    5110           0 :             val = 1;
    5111           0 :             break;
    5112             :         }
    5113             : #if FF_API_LAVF_AVCTX
    5114           0 :         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
    5115             : #else
    5116             :         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
    5117             : #endif
    5118        8634 :     } else if (!*spec) /* empty specifier, matches everything */
    5119        8634 :         return 1;
    5120             : 
    5121           0 :     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
    5122           0 :     return AVERROR(EINVAL);
    5123             : }
    5124             : 
    5125           1 : int ff_generate_avci_extradata(AVStream *st)
    5126             : {
    5127             :     static const uint8_t avci100_1080p_extradata[] = {
    5128             :         // SPS
    5129             :         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
    5130             :         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
    5131             :         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
    5132             :         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
    5133             :         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
    5134             :         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
    5135             :         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
    5136             :         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
    5137             :         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    5138             :         // PPS
    5139             :         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
    5140             :         0xd0
    5141             :     };
    5142             :     static const uint8_t avci100_1080i_extradata[] = {
    5143             :         // SPS
    5144             :         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
    5145             :         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
    5146             :         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
    5147             :         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
    5148             :         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
    5149             :         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
    5150             :         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
    5151             :         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
    5152             :         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
    5153             :         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
    5154             :         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
    5155             :         // PPS
    5156             :         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
    5157             :         0xd0
    5158             :     };
    5159             :     static const uint8_t avci50_1080p_extradata[] = {
    5160             :         // SPS
    5161             :         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
    5162             :         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
    5163             :         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
    5164             :         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
    5165             :         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
    5166             :         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
    5167             :         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
    5168             :         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
    5169             :         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
    5170             :         // PPS
    5171             :         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
    5172             :         0x11
    5173             :     };
    5174             :     static const uint8_t avci50_1080i_extradata[] = {
    5175             :         // SPS
    5176             :         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
    5177             :         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
    5178             :         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
    5179             :         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
    5180             :         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
    5181             :         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
    5182             :         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
    5183             :         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
    5184             :         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
    5185             :         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
    5186             :         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
    5187             :         // PPS
    5188             :         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
    5189             :         0x11
    5190             :     };
    5191             :     static const uint8_t avci100_720p_extradata[] = {
    5192             :         // SPS
    5193             :         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
    5194             :         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
    5195             :         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
    5196             :         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
    5197             :         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
    5198             :         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
    5199             :         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
    5200             :         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
    5201             :         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
    5202             :         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
    5203             :         // PPS
    5204             :         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
    5205             :         0x11
    5206             :     };
    5207             :     static const uint8_t avci50_720p_extradata[] = {
    5208             :         // SPS
    5209             :         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
    5210             :         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
    5211             :         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
    5212             :         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
    5213             :         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
    5214             :         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
    5215             :         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
    5216             :         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
    5217             :         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
    5218             :         // PPS
    5219             :         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
    5220             :         0x11
    5221             :     };
    5222             : 
    5223           1 :     const uint8_t *data = NULL;
    5224           1 :     int size            = 0;
    5225             : 
    5226           1 :     if (st->codecpar->width == 1920) {
    5227           1 :         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
    5228           0 :             data = avci100_1080p_extradata;
    5229           0 :             size = sizeof(avci100_1080p_extradata);
    5230             :         } else {
    5231           1 :             data = avci100_1080i_extradata;
    5232           1 :             size = sizeof(avci100_1080i_extradata);
    5233             :         }
    5234           0 :     } else if (st->codecpar->width == 1440) {
    5235           0 :         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
    5236           0 :             data = avci50_1080p_extradata;
    5237           0 :             size = sizeof(avci50_1080p_extradata);
    5238             :         } else {
    5239           0 :             data = avci50_1080i_extradata;
    5240           0 :             size = sizeof(avci50_1080i_extradata);
    5241             :         }
    5242           0 :     } else if (st->codecpar->width == 1280) {
    5243           0 :         data = avci100_720p_extradata;
    5244           0 :         size = sizeof(avci100_720p_extradata);
    5245           0 :     } else if (st->codecpar->width == 960) {
    5246           0 :         data = avci50_720p_extradata;
    5247           0 :         size = sizeof(avci50_720p_extradata);
    5248             :     }
    5249             : 
    5250           1 :     if (!size)
    5251           0 :         return 0;
    5252             : 
    5253           1 :     av_freep(&st->codecpar->extradata);
    5254           1 :     if (ff_alloc_extradata(st->codecpar, size))
    5255           0 :         return AVERROR(ENOMEM);
    5256           1 :     memcpy(st->codecpar->extradata, data, size);
    5257             : 
    5258           1 :     return 0;
    5259             : }
    5260             : 
    5261        4670 : uint8_t *av_stream_get_side_data(const AVStream *st,
    5262             :                                  enum AVPacketSideDataType type, int *size)
    5263             : {
    5264             :     int i;
    5265             : 
    5266        4908 :     for (i = 0; i < st->nb_side_data; i++) {
    5267         265 :         if (st->side_data[i].type == type) {
    5268          27 :             if (size)
    5269           1 :                 *size = st->side_data[i].size;
    5270          27 :             return st->side_data[i].data;
    5271             :         }
    5272             :     }
    5273        4643 :     return NULL;
    5274             : }
    5275             : 
    5276         616 : int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
    5277             :                             uint8_t *data, size_t size)
    5278             : {
    5279             :     AVPacketSideData *sd, *tmp;
    5280             :     int i;
    5281             : 
    5282         618 :     for (i = 0; i < st->nb_side_data; i++) {
    5283           3 :         sd = &st->side_data[i];
    5284             : 
    5285           3 :         if (sd->type == type) {
    5286           1 :             av_freep(&sd->data);
    5287           1 :             sd->data = data;
    5288           1 :             sd->size = size;
    5289           1 :             return 0;
    5290             :         }
    5291             :     }
    5292             : 
    5293         615 :     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
    5294           0 :         return AVERROR(ERANGE);
    5295             : 
    5296         615 :     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
    5297         615 :     if (!tmp) {
    5298           0 :         return AVERROR(ENOMEM);
    5299             :     }
    5300             : 
    5301         615 :     st->side_data = tmp;
    5302         615 :     st->nb_side_data++;
    5303             : 
    5304         615 :     sd = &st->side_data[st->nb_side_data - 1];
    5305         615 :     sd->type = type;
    5306         615 :     sd->data = data;
    5307         615 :     sd->size = size;
    5308             : 
    5309         615 :     return 0;
    5310             : }
    5311             : 
    5312         398 : uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
    5313             :                                  int size)
    5314             : {
    5315             :     int ret;
    5316         398 :     uint8_t *data = av_malloc(size);
    5317             : 
    5318         398 :     if (!data)
    5319           0 :         return NULL;
    5320             : 
    5321         398 :     ret = av_stream_add_side_data(st, type, data, size);
    5322         398 :     if (ret < 0) {
    5323           0 :         av_freep(&data);
    5324           0 :         return NULL;
    5325             :     }
    5326             : 
    5327         398 :     return data;
    5328             : }
    5329             : 
    5330           6 : int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
    5331             : {
    5332             :     int ret;
    5333             :     const AVBitStreamFilter *bsf;
    5334             :     AVBSFContext *bsfc;
    5335             :     AVCodecParameters *in_par;
    5336             : 
    5337           6 :     if (!(bsf = av_bsf_get_by_name(name))) {
    5338           0 :         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
    5339           0 :         return AVERROR_BSF_NOT_FOUND;
    5340             :     }
    5341             : 
    5342           6 :     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
    5343           0 :         return ret;
    5344             : 
    5345           6 :     if (st->internal->nb_bsfcs) {
    5346           0 :         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
    5347           0 :         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
    5348             :     } else {
    5349           6 :         in_par = st->codecpar;
    5350           6 :         bsfc->time_base_in = st->time_base;
    5351             :     }
    5352             : 
    5353           6 :     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
    5354           0 :         av_bsf_free(&bsfc);
    5355           0 :         return ret;
    5356             :     }
    5357             : 
    5358           6 :     if (args && bsfc->filter->priv_class) {
    5359           0 :         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
    5360           0 :         const char * shorthand[2] = {NULL};
    5361             : 
    5362           0 :         if (opt)
    5363           0 :             shorthand[0] = opt->name;
    5364             : 
    5365           0 :         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
    5366           0 :             av_bsf_free(&bsfc);
    5367           0 :             return ret;
    5368             :         }
    5369             :     }
    5370             : 
    5371           6 :     if ((ret = av_bsf_init(bsfc)) < 0) {
    5372           0 :         av_bsf_free(&bsfc);
    5373           0 :         return ret;
    5374             :     }
    5375             : 
    5376           6 :     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
    5377           0 :         av_bsf_free(&bsfc);
    5378           0 :         return ret;
    5379             :     }
    5380             : 
    5381           6 :     av_log(NULL, AV_LOG_VERBOSE,
    5382             :            "Automatically inserted bitstream filter '%s'; args='%s'\n",
    5383             :            name, args ? args : "");
    5384           6 :     return 1;
    5385             : }
    5386             : 
    5387             : #if FF_API_OLD_BSF
    5388             : FF_DISABLE_DEPRECATION_WARNINGS
    5389           0 : int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
    5390             :                                AVBitStreamFilterContext *bsfc)
    5391             : {
    5392           0 :     int ret = 0;
    5393           0 :     while (bsfc) {
    5394           0 :         AVPacket new_pkt = *pkt;
    5395           0 :         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
    5396             :                                            &new_pkt.data, &new_pkt.size,
    5397           0 :                                            pkt->data, pkt->size,
    5398           0 :                                            pkt->flags & AV_PKT_FLAG_KEY);
    5399           0 :         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
    5400           0 :             av_packet_unref(pkt);
    5401           0 :             memset(pkt, 0, sizeof(*pkt));
    5402           0 :             return 0;
    5403             :         }
    5404           0 :         if(a == 0 && new_pkt.data != pkt->data) {
    5405           0 :             uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
    5406           0 :             if (t) {
    5407           0 :                 memcpy(t, new_pkt.data, new_pkt.size);
    5408           0 :                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
    5409           0 :                 new_pkt.data = t;
    5410           0 :                 new_pkt.buf = NULL;
    5411           0 :                 a = 1;
    5412             :             } else {
    5413           0 :                 a = AVERROR(ENOMEM);
    5414             :             }
    5415             :         }
    5416           0 :         if (a > 0) {
    5417           0 :             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
    5418             :                                            av_buffer_default_free, NULL, 0);
    5419           0 :             if (new_pkt.buf) {
    5420           0 :                 pkt->side_data = NULL;
    5421           0 :                 pkt->side_data_elems = 0;
    5422           0 :                 av_packet_unref(pkt);
    5423             :             } else {
    5424           0 :                 av_freep(&new_pkt.data);
    5425           0 :                 a = AVERROR(ENOMEM);
    5426             :             }
    5427             :         }
    5428           0 :         if (a < 0) {
    5429           0 :             av_log(codec, AV_LOG_ERROR,
    5430             :                    "Failed to open bitstream filter %s for stream %d with codec %s",
    5431           0 :                    bsfc->filter->name, pkt->stream_index,
    5432           0 :                    codec->codec ? codec->codec->name : "copy");
    5433           0 :             ret = a;
    5434           0 :             break;
    5435             :         }
    5436           0 :         *pkt = new_pkt;
    5437             : 
    5438           0 :         bsfc = bsfc->next;
    5439             :     }
    5440           0 :     return ret;
    5441             : }
    5442             : FF_ENABLE_DEPRECATION_WARNINGS
    5443             : #endif
    5444             : 
    5445          51 : int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
    5446             : {
    5447          51 :     if (!s->oformat)
    5448           0 :         return AVERROR(EINVAL);
    5449             : 
    5450          51 :     if (!(s->oformat->flags & AVFMT_NOFILE))
    5451           2 :         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
    5452          49 :     return 0;
    5453             : }
    5454             : 
    5455       67462 : void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
    5456             : {
    5457       67462 :     if (*pb)
    5458       67396 :         s->io_close(s, *pb);
    5459       67462 :     *pb = NULL;
    5460       67462 : }
    5461             : 
    5462        1990 : int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
    5463             : {
    5464             :     AVDictionaryEntry *entry;
    5465             :     int64_t parsed_timestamp;
    5466             :     int ret;
    5467        1990 :     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
    5468           0 :         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
    5469           0 :             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
    5470           0 :             return 1;
    5471             :         } else {
    5472           0 :             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
    5473           0 :             return ret;
    5474             :         }
    5475             :     }
    5476        1990 :     return 0;
    5477             : }
    5478             : 
    5479        1795 : int ff_standardize_creation_time(AVFormatContext *s)
    5480             : {
    5481             :     int64_t timestamp;
    5482        1795 :     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
    5483        1795 :     if (ret == 1)
    5484           0 :         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
    5485        1795 :     return ret;
    5486             : }
    5487             : 
    5488         117 : int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
    5489             : {
    5490             :     uint8_t *side_data;
    5491             :     int size;
    5492             : 
    5493         117 :     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
    5494         117 :     if (side_data) {
    5495           4 :         if (size != AVPALETTE_SIZE) {
    5496           0 :             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
    5497           0 :             return AVERROR_INVALIDDATA;
    5498             :         }
    5499           4 :         memcpy(palette, side_data, AVPALETTE_SIZE);
    5500           4 :         return 1;
    5501             :     }
    5502             : 
    5503         113 :     if (ret == CONTAINS_PAL) {
    5504             :         int i;
    5505           0 :         for (i = 0; i < AVPALETTE_COUNT; i++)
    5506           0 :             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
    5507           0 :         return 1;
    5508             :     }
    5509             : 
    5510         113 :     return 0;
    5511             : }
    5512             : 
    5513           7 : int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
    5514             : {
    5515             :     int ret;
    5516             :     char *str;
    5517             : 
    5518           7 :     ret = av_bprint_finalize(buf, &str);
    5519           7 :     if (ret < 0)
    5520           0 :         return ret;
    5521           7 :     if (!av_bprint_is_complete(buf)) {
    5522           0 :         av_free(str);
    5523           0 :         return AVERROR(ENOMEM);
    5524             :     }
    5525             : 
    5526           7 :     par->extradata = str;
    5527             :     /* Note: the string is NUL terminated (so extradata can be read as a
    5528             :      * string), but the ending character is not accounted in the size (in
    5529             :      * binary formats you are likely not supposed to mux that character). When
    5530             :      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
    5531             :      * zeros. */
    5532           7 :     par->extradata_size = buf->len;
    5533           7 :     return 0;
    5534             : }
    5535             : 
    5536         222 : int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
    5537             :                                                   AVStream *ost, const AVStream *ist,
    5538             :                                                   enum AVTimebaseSource copy_tb)
    5539             : {
    5540             :     //TODO: use [io]st->internal->avctx
    5541         222 :     const AVCodecContext *dec_ctx = ist->codec;
    5542         222 :     AVCodecContext       *enc_ctx = ost->codec;
    5543             : 
    5544         222 :     enc_ctx->time_base = ist->time_base;
    5545             :     /*
    5546             :      * Avi is a special case here because it supports variable fps but
    5547             :      * having the fps and timebase differe significantly adds quite some
    5548             :      * overhead
    5549             :      */
    5550         222 :     if (!strcmp(ofmt->name, "avi")) {
    5551             : #if FF_API_R_FRAME_RATE
    5552           6 :         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
    5553           4 :             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
    5554           4 :             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
    5555           2 :             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
    5556           0 :             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
    5557           6 :             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
    5558           0 :             enc_ctx->time_base.num = ist->r_frame_rate.den;
    5559           0 :             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
    5560           0 :             enc_ctx->ticks_per_frame = 2;
    5561             :         } else
    5562             : #endif
    5563           6 :             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
    5564           3 :                    && av_q2d(ist->time_base) < 1.0/500
    5565           3 :                    || copy_tb == AVFMT_TBCF_DECODER) {
    5566           3 :             enc_ctx->time_base = dec_ctx->time_base;
    5567           3 :             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
    5568           3 :             enc_ctx->time_base.den *= 2;
    5569           3 :             enc_ctx->ticks_per_frame = 2;
    5570             :         }
    5571         216 :     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
    5572         128 :                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
    5573         112 :         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
    5574         108 :             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
    5575          42 :             && av_q2d(ist->time_base) < 1.0/500
    5576          70 :             || copy_tb == AVFMT_TBCF_DECODER) {
    5577          42 :             enc_ctx->time_base = dec_ctx->time_base;
    5578          42 :             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
    5579             :         }
    5580             :     }
    5581             : 
    5582         222 :     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
    5583           3 :         && dec_ctx->time_base.num < dec_ctx->time_base.den
    5584           3 :         && dec_ctx->time_base.num > 0
    5585           3 :         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
    5586           3 :         enc_ctx->time_base = dec_ctx->time_base;
    5587             :     }
    5588             : 
    5589         222 :     if (ost->avg_frame_rate.num)
    5590           2 :         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
    5591             : 
    5592         444 :     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
    5593         444 :               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
    5594             : 
    5595         222 :     return 0;
    5596             : }
    5597             : 
    5598         221 : AVRational av_stream_get_codec_timebase(const AVStream *st)
    5599             : {
    5600             :     // See avformat_transfer_internal_stream_timing_info() TODO.
    5601             : #if FF_API_LAVF_AVCTX
    5602             : FF_DISABLE_DEPRECATION_WARNINGS
    5603         221 :     return st->codec->time_base;
    5604             : FF_ENABLE_DEPRECATION_WARNINGS
    5605             : #else
    5606             :     return st->internal->avctx->time_base;
    5607             : #endif
    5608             : }

Generated by: LCOV version 1.13