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