LCOV - code coverage report
Current view: top level - libavformat - utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2551 3355 76.0 %
Date: 2018-05-20 11:54:08 Functions: 122 156 78.2 %

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

Generated by: LCOV version 1.13