git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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