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