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) {
1431         av_packet_unref(out_pkt);
1432     } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1433         // preserve 0-size sync packets
1434         compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1435     }
1436
1437     while (size > 0 || (flush && got_output)) {
1438         int len;
1439         int64_t next_pts = pkt->pts;
1440         int64_t next_dts = pkt->dts;
1441
1442         len = av_parser_parse2(st->parser, st->internal->avctx,
1443                                &out_pkt->data, &out_pkt->size, data, size,
1444                                pkt->pts, pkt->dts, pkt->pos);
1445
1446         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1447         pkt->pos = -1;
1448         /* increment read pointer */
1449         av_assert1(data || !len);
1450         data  = len ? data + len : data;
1451         size -= len;
1452
1453         got_output = !!out_pkt->size;
1454
1455         if (!out_pkt->size)
1456             continue;
1457
1458         if (pkt->buf && out_pkt->data == pkt->data) {
1459             /* reference pkt->buf only when out_pkt->data is guaranteed to point
1460              * to data in it and not in the parser's internal buffer. */
1461             /* XXX: Ensure this is the case with all parsers when st->parser->flags
1462              * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1463             out_pkt->buf = av_buffer_ref(pkt->buf);
1464             if (!out_pkt->buf) {
1465                 ret = AVERROR(ENOMEM);
1466                 goto fail;
1467             }
1468         } else {
1469             ret = av_packet_make_refcounted(out_pkt);
1470             if (ret < 0)
1471                 goto fail;
1472         }
1473
1474         if (pkt->side_data) {
1475             out_pkt->side_data       = pkt->side_data;
1476             out_pkt->side_data_elems = pkt->side_data_elems;
1477             pkt->side_data          = NULL;
1478             pkt->side_data_elems    = 0;
1479         }
1480
1481         /* set the duration */
1482         out_pkt->duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1483         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1484             if (st->internal->avctx->sample_rate > 0) {
1485                 out_pkt->duration =
1486                     av_rescale_q_rnd(st->parser->duration,
1487                                      (AVRational) { 1, st->internal->avctx->sample_rate },
1488                                      st->time_base,
1489                                      AV_ROUND_DOWN);
1490             }
1491         }
1492
1493         out_pkt->stream_index = st->index;
1494         out_pkt->pts          = st->parser->pts;
1495         out_pkt->dts          = st->parser->dts;
1496         out_pkt->pos          = st->parser->pos;
1497         out_pkt->flags       |= pkt->flags & AV_PKT_FLAG_DISCARD;
1498
1499         if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1500             out_pkt->pos = st->parser->frame_offset;
1501
1502         if (st->parser->key_frame == 1 ||
1503             (st->parser->key_frame == -1 &&
1504              st->parser->pict_type == AV_PICTURE_TYPE_I))
1505             out_pkt->flags |= AV_PKT_FLAG_KEY;
1506
1507         if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1508             out_pkt->flags |= AV_PKT_FLAG_KEY;
1509
1510         compute_pkt_fields(s, st, st->parser, out_pkt, next_dts, next_pts);
1511
1512         ret = avpriv_packet_list_put(&s->internal->parse_queue,
1513                                  &s->internal->parse_queue_end,
1514                                  out_pkt, NULL, 0);
1515         if (ret < 0) {
1516             av_packet_unref(out_pkt);
1517             goto fail;
1518         }
1519     }
1520
1521     /* end of the stream => close and free the parser */
1522     if (flush) {
1523         av_parser_close(st->parser);
1524         st->parser = NULL;
1525     }
1526
1527 fail:
1528     av_packet_unref(pkt);
1529     return ret;
1530 }
1531
1532 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1533 {
1534     return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1535 }
1536
1537 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1538 {
1539     int ret, i, got_packet = 0;
1540     AVDictionary *metadata = NULL;
1541
1542     while (!got_packet && !s->internal->parse_queue) {
1543         AVStream *st;
1544
1545         /* read next packet */
1546         ret = ff_read_packet(s, pkt);
1547         if (ret < 0) {
1548             if (ret == AVERROR(EAGAIN))
1549                 return ret;
1550             /* flush the parsers */
1551             for (i = 0; i < s->nb_streams; i++) {
1552                 st = s->streams[i];
1553                 if (st->parser && st->need_parsing)
1554                     parse_packet(s, pkt, st->index, 1);
1555             }
1556             /* all remaining packets are now in parse_queue =>
1557              * really terminate parsing */
1558             break;
1559         }
1560         ret = 0;
1561         st  = s->streams[pkt->stream_index];
1562
1563         st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1564
1565         /* update context if required */
1566         if (st->internal->need_context_update) {
1567             if (avcodec_is_open(st->internal->avctx)) {
1568                 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1569                 avcodec_close(st->internal->avctx);
1570                 st->internal->info->found_decoder = 0;
1571             }
1572
1573             /* close parser, because it depends on the codec */
1574             if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1575                 av_parser_close(st->parser);
1576                 st->parser = NULL;
1577             }
1578
1579             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1580             if (ret < 0) {
1581                 av_packet_unref(pkt);
1582                 return ret;
1583             }
1584
1585 #if FF_API_LAVF_AVCTX
1586 FF_DISABLE_DEPRECATION_WARNINGS
1587             /* update deprecated public codec context */
1588             ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1589             if (ret < 0) {
1590                 av_packet_unref(pkt);
1591                 return ret;
1592             }
1593 FF_ENABLE_DEPRECATION_WARNINGS
1594 #endif
1595
1596             st->internal->need_context_update = 0;
1597         }
1598
1599         if (pkt->pts != AV_NOPTS_VALUE &&
1600             pkt->dts != AV_NOPTS_VALUE &&
1601             pkt->pts < pkt->dts) {
1602             av_log(s, AV_LOG_WARNING,
1603                    "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1604                    pkt->stream_index,
1605                    av_ts2str(pkt->pts),
1606                    av_ts2str(pkt->dts),
1607                    pkt->size);
1608         }
1609         if (s->debug & FF_FDEBUG_TS)
1610             av_log(s, AV_LOG_DEBUG,
1611                    "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1612                    pkt->stream_index,
1613                    av_ts2str(pkt->pts),
1614                    av_ts2str(pkt->dts),
1615                    pkt->size, pkt->duration, pkt->flags);
1616
1617         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1618             st->parser = av_parser_init(st->codecpar->codec_id);
1619             if (!st->parser) {
1620                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1621                        "%s, packets or times may be invalid.\n",
1622                        avcodec_get_name(st->codecpar->codec_id));
1623                 /* no parser available: just output the raw packets */
1624                 st->need_parsing = AVSTREAM_PARSE_NONE;
1625             } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1626                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1627             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1628                 st->parser->flags |= PARSER_FLAG_ONCE;
1629             else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1630                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1631         }
1632
1633         if (!st->need_parsing || !st->parser) {
1634             /* no parsing needed: we just output the packet as is */
1635             compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1636             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1637                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1638                 ff_reduce_index(s, st->index);
1639                 av_add_index_entry(st, pkt->pos, pkt->dts,
1640                                    0, 0, AVINDEX_KEYFRAME);
1641             }
1642             got_packet = 1;
1643         } else if (st->discard < AVDISCARD_ALL) {
1644             if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1645                 return ret;
1646             st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1647             st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1648             st->codecpar->channels = st->internal->avctx->channels;
1649             st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1650             st->codecpar->codec_id = st->internal->avctx->codec_id;
1651         } else {
1652             /* free packet */
1653             av_packet_unref(pkt);
1654         }
1655         if (pkt->flags & AV_PKT_FLAG_KEY)
1656             st->internal->skip_to_keyframe = 0;
1657         if (st->internal->skip_to_keyframe) {
1658             av_packet_unref(pkt);
1659             got_packet = 0;
1660         }
1661     }
1662
1663     if (!got_packet && s->internal->parse_queue)
1664         ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1665
1666     if (ret >= 0) {
1667         AVStream *st = s->streams[pkt->stream_index];
1668         int discard_padding = 0;
1669         if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1670             int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1671             int64_t sample = ts_to_samples(st, pts);
1672             int duration = ts_to_samples(st, pkt->duration);
1673             int64_t end_sample = sample + duration;
1674             if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1675                 sample < st->internal->last_discard_sample)
1676                 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1677         }
1678         if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1679             st->internal->skip_samples = st->internal->start_skip_samples;
1680         if (st->internal->skip_samples || discard_padding) {
1681             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1682             if (p) {
1683                 AV_WL32(p, st->internal->skip_samples);
1684                 AV_WL32(p + 4, discard_padding);
1685                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1686             }
1687             st->internal->skip_samples = 0;
1688         }
1689
1690         if (st->internal->inject_global_side_data) {
1691             for (i = 0; i < st->nb_side_data; i++) {
1692                 AVPacketSideData *src_sd = &st->side_data[i];
1693                 uint8_t *dst_data;
1694
1695                 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1696                     continue;
1697
1698                 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1699                 if (!dst_data) {
1700                     av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1701                     continue;
1702                 }
1703
1704                 memcpy(dst_data, src_sd->data, src_sd->size);
1705             }
1706             st->internal->inject_global_side_data = 0;
1707         }
1708     }
1709
1710     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1711     if (metadata) {
1712         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1713         av_dict_copy(&s->metadata, metadata, 0);
1714         av_dict_free(&metadata);
1715         av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1716     }
1717
1718 #if FF_API_LAVF_AVCTX
1719     update_stream_avctx(s);
1720 #endif
1721
1722     if (s->debug & FF_FDEBUG_TS)
1723         av_log(s, AV_LOG_DEBUG,
1724                "read_frame_internal stream=%d, pts=%s, dts=%s, "
1725                "size=%d, duration=%"PRId64", flags=%d\n",
1726                pkt->stream_index,
1727                av_ts2str(pkt->pts),
1728                av_ts2str(pkt->dts),
1729                pkt->size, pkt->duration, pkt->flags);
1730
1731     /* A demuxer might have returned EOF because of an IO error, let's
1732      * propagate this back to the user. */
1733     if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1734         ret = s->pb->error;
1735
1736     return ret;
1737 }
1738
1739 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1740 {
1741     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1742     int eof = 0;
1743     int ret;
1744     AVStream *st;
1745
1746     if (!genpts) {
1747         ret = s->internal->packet_buffer
1748               ? avpriv_packet_list_get(&s->internal->packet_buffer,
1749                                         &s->internal->packet_buffer_end, pkt)
1750               : read_frame_internal(s, pkt);
1751         if (ret < 0)
1752             return ret;
1753         goto return_packet;
1754     }
1755
1756     for (;;) {
1757         PacketList *pktl = s->internal->packet_buffer;
1758
1759         if (pktl) {
1760             AVPacket *next_pkt = &pktl->pkt;
1761
1762             if (next_pkt->dts != AV_NOPTS_VALUE) {
1763                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1764                 // last dts seen for this stream. if any of packets following
1765                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1766                 int64_t last_dts = next_pkt->dts;
1767                 av_assert2(wrap_bits <= 64);
1768                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1769                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1770                         av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1771                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1772                             // not B-frame
1773                             next_pkt->pts = pktl->pkt.dts;
1774                         }
1775                         if (last_dts != AV_NOPTS_VALUE) {
1776                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1777                             last_dts = pktl->pkt.dts;
1778                         }
1779                     }
1780                     pktl = pktl->next;
1781                 }
1782                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1783                     // Fixing the last reference frame had none pts issue (For MXF etc).
1784                     // We only do this when
1785                     // 1. eof.
1786                     // 2. we are not able to resolve a pts value for current packet.
1787                     // 3. the packets for this stream at the end of the files had valid dts.
1788                     next_pkt->pts = last_dts + next_pkt->duration;
1789                 }
1790                 pktl = s->internal->packet_buffer;
1791             }
1792
1793             /* read packet from packet buffer, if there is data */
1794             st = s->streams[next_pkt->stream_index];
1795             if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1796                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1797                 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1798                                                &s->internal->packet_buffer_end, pkt);
1799                 goto return_packet;
1800             }
1801         }
1802
1803         ret = read_frame_internal(s, pkt);
1804         if (ret < 0) {
1805             if (pktl && ret != AVERROR(EAGAIN)) {
1806                 eof = 1;
1807                 continue;
1808             } else
1809                 return ret;
1810         }
1811
1812         ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1813                                  &s->internal->packet_buffer_end,
1814                                  pkt, NULL, 0);
1815         if (ret < 0) {
1816             av_packet_unref(pkt);
1817             return ret;
1818         }
1819     }
1820
1821 return_packet:
1822
1823     st = s->streams[pkt->stream_index];
1824     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1825         ff_reduce_index(s, st->index);
1826         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1827     }
1828
1829     if (is_relative(pkt->dts))
1830         pkt->dts -= RELATIVE_TS_BASE;
1831     if (is_relative(pkt->pts))
1832         pkt->pts -= RELATIVE_TS_BASE;
1833
1834     return ret;
1835 }
1836
1837 /* XXX: suppress the packet queue */
1838 static void flush_packet_queue(AVFormatContext *s)
1839 {
1840     if (!s->internal)
1841         return;
1842     avpriv_packet_list_free(&s->internal->parse_queue,       &s->internal->parse_queue_end);
1843     avpriv_packet_list_free(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
1844     avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1845
1846     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1847 }
1848
1849 /*******************************************************/
1850 /* seek support */
1851
1852 int av_find_default_stream_index(AVFormatContext *s)
1853 {
1854     int i;
1855     AVStream *st;
1856     int best_stream = 0;
1857     int best_score = INT_MIN;
1858
1859     if (s->nb_streams <= 0)
1860         return -1;
1861     for (i = 0; i < s->nb_streams; i++) {
1862         int score = 0;
1863         st = s->streams[i];
1864         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1865             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1866                 score -= 400;
1867             if (st->codecpar->width && st->codecpar->height)
1868                 score += 50;
1869             score+= 25;
1870         }
1871         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1872             if (st->codecpar->sample_rate)
1873                 score += 50;
1874         }
1875         if (st->codec_info_nb_frames)
1876             score += 12;
1877
1878         if (st->discard != AVDISCARD_ALL)
1879             score += 200;
1880
1881         if (score > best_score) {
1882             best_score = score;
1883             best_stream = i;
1884         }
1885     }
1886     return best_stream;
1887 }
1888
1889 /** Flush the frame reader. */
1890 void ff_read_frame_flush(AVFormatContext *s)
1891 {
1892     AVStream *st;
1893     int i, j;
1894
1895     flush_packet_queue(s);
1896
1897     /* Reset read state for each stream. */
1898     for (i = 0; i < s->nb_streams; i++) {
1899         st = s->streams[i];
1900
1901         if (st->parser) {
1902             av_parser_close(st->parser);
1903             st->parser = NULL;
1904         }
1905         st->last_IP_pts = AV_NOPTS_VALUE;
1906         st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1907         if (st->first_dts == AV_NOPTS_VALUE)
1908             st->cur_dts = RELATIVE_TS_BASE;
1909         else
1910             /* We set the current DTS to an unspecified origin. */
1911             st->cur_dts = AV_NOPTS_VALUE;
1912
1913         st->probe_packets = s->max_probe_packets;
1914
1915         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1916             st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1917
1918         if (s->internal->inject_global_side_data)
1919             st->internal->inject_global_side_data = 1;
1920
1921         st->internal->skip_samples = 0;
1922     }
1923 }
1924
1925 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1926 {
1927     int i;
1928
1929     for (i = 0; i < s->nb_streams; i++) {
1930         AVStream *st = s->streams[i];
1931
1932         st->cur_dts =
1933             av_rescale(timestamp,
1934                        st->time_base.den * (int64_t) ref_st->time_base.num,
1935                        st->time_base.num * (int64_t) ref_st->time_base.den);
1936     }
1937 }
1938
1939 void ff_reduce_index(AVFormatContext *s, int stream_index)
1940 {
1941     AVStream *st             = s->streams[stream_index];
1942     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1943
1944     if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1945         int i;
1946         for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1947             st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1948         st->internal->nb_index_entries = i;
1949     }
1950 }
1951
1952 int ff_add_index_entry(AVIndexEntry **index_entries,
1953                        int *nb_index_entries,
1954                        unsigned int *index_entries_allocated_size,
1955                        int64_t pos, int64_t timestamp,
1956                        int size, int distance, int flags)
1957 {
1958     AVIndexEntry *entries, *ie;
1959     int index;
1960
1961     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1962         return -1;
1963
1964     if (timestamp == AV_NOPTS_VALUE)
1965         return AVERROR(EINVAL);
1966
1967     if (size < 0 || size > 0x3FFFFFFF)
1968         return AVERROR(EINVAL);
1969
1970     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1971         timestamp -= RELATIVE_TS_BASE;
1972
1973     entries = av_fast_realloc(*index_entries,
1974                               index_entries_allocated_size,
1975                               (*nb_index_entries + 1) *
1976                               sizeof(AVIndexEntry));
1977     if (!entries)
1978         return -1;
1979
1980     *index_entries = entries;
1981
1982     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1983                                       timestamp, AVSEEK_FLAG_ANY);
1984
1985     if (index < 0) {
1986         index = (*nb_index_entries)++;
1987         ie    = &entries[index];
1988         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1989     } else {
1990         ie = &entries[index];
1991         if (ie->timestamp != timestamp) {
1992             if (ie->timestamp <= timestamp)
1993                 return -1;
1994             memmove(entries + index + 1, entries + index,
1995                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1996             (*nb_index_entries)++;
1997         } else if (ie->pos == pos && distance < ie->min_distance)
1998             // do not reduce the distance
1999             distance = ie->min_distance;
2000     }
2001
2002     ie->pos          = pos;
2003     ie->timestamp    = timestamp;
2004     ie->min_distance = distance;
2005     ie->size         = size;
2006     ie->flags        = flags;
2007
2008     return index;
2009 }
2010
2011 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2012                        int size, int distance, int flags)
2013 {
2014     timestamp = wrap_timestamp(st, timestamp);
2015     return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
2016                               &st->internal->index_entries_allocated_size, pos,
2017                               timestamp, size, distance, flags);
2018 }
2019
2020 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2021                               int64_t wanted_timestamp, int flags)
2022 {
2023     int a, b, m;
2024     int64_t timestamp;
2025
2026     a = -1;
2027     b = nb_entries;
2028
2029     // Optimize appending index entries at the end.
2030     if (b && entries[b - 1].timestamp < wanted_timestamp)
2031         a = b - 1;
2032
2033     while (b - a > 1) {
2034         m         = (a + b) >> 1;
2035
2036         // Search for the next non-discarded packet.
2037         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2038             m++;
2039             if (m == b && entries[m].timestamp >= wanted_timestamp) {
2040                 m = b - 1;
2041                 break;
2042             }
2043         }
2044
2045         timestamp = entries[m].timestamp;
2046         if (timestamp >= wanted_timestamp)
2047             b = m;
2048         if (timestamp <= wanted_timestamp)
2049             a = m;
2050     }
2051     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2052
2053     if (!(flags & AVSEEK_FLAG_ANY))
2054         while (m >= 0 && m < nb_entries &&
2055                !(entries[m].flags & AVINDEX_KEYFRAME))
2056             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2057
2058     if (m == nb_entries)
2059         return -1;
2060     return m;
2061 }
2062
2063 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2064 {
2065     int ist1, ist2;
2066     int64_t pos_delta = 0;
2067     int64_t skip = 0;
2068     //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2069     const char *proto = avio_find_protocol_name(s->url);
2070
2071     av_assert0(time_tolerance >= 0);
2072
2073     if (!proto) {
2074         av_log(s, AV_LOG_INFO,
2075                "Protocol name not provided, cannot determine if input is local or "
2076                "a network protocol, buffers and access patterns cannot be configured "
2077                "optimally without knowing the protocol\n");
2078     }
2079
2080     if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2081         return;
2082
2083     for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2084         AVStream *st1 = s->streams[ist1];
2085         for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2086             AVStream *st2 = s->streams[ist2];
2087             int i1, i2;
2088
2089             if (ist1 == ist2)
2090                 continue;
2091
2092             for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2093                 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2094                 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2095
2096                 skip = FFMAX(skip, e1->size);
2097                 for (; i2 < st2->internal->nb_index_entries; i2++) {
2098                     AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2099                     int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2100                     if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2101                         continue;
2102                     pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2103                     break;
2104                 }
2105             }
2106         }
2107     }
2108
2109     pos_delta *= 2;
2110     /* XXX This could be adjusted depending on protocol*/
2111     if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2112         av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2113
2114         /* realloc the buffer and the original data will be retained */
2115         if (ffio_realloc_buf(s->pb, pos_delta)) {
2116             av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2117             return;
2118         }
2119
2120         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2121     }
2122
2123     if (skip < (1<<23)) {
2124         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2125     }
2126 }
2127
2128 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2129 {
2130     return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2131                                      wanted_timestamp, flags);
2132 }
2133
2134 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2135                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2136 {
2137     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2138     if (stream_index >= 0)
2139         ts = wrap_timestamp(s->streams[stream_index], ts);
2140     return ts;
2141 }
2142
2143 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2144                          int64_t target_ts, int flags)
2145 {
2146     const AVInputFormat *avif = s->iformat;
2147     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2148     int64_t ts_min, ts_max, ts;
2149     int index;
2150     int64_t ret;
2151     AVStream *st;
2152
2153     if (stream_index < 0)
2154         return -1;
2155
2156     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2157
2158     ts_max =
2159     ts_min = AV_NOPTS_VALUE;
2160     pos_limit = -1; // GCC falsely says it may be uninitialized.
2161
2162     st = s->streams[stream_index];
2163     if (st->internal->index_entries) {
2164         AVIndexEntry *e;
2165
2166         /* FIXME: Whole function must be checked for non-keyframe entries in
2167          * index case, especially read_timestamp(). */
2168         index = av_index_search_timestamp(st, target_ts,
2169                                           flags | AVSEEK_FLAG_BACKWARD);
2170         index = FFMAX(index, 0);
2171         e     = &st->internal->index_entries[index];
2172
2173         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2174             pos_min = e->pos;
2175             ts_min  = e->timestamp;
2176             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2177                     pos_min, av_ts2str(ts_min));
2178         } else {
2179             av_assert1(index == 0);
2180         }
2181
2182         index = av_index_search_timestamp(st, target_ts,
2183                                           flags & ~AVSEEK_FLAG_BACKWARD);
2184         av_assert0(index < st->internal->nb_index_entries);
2185         if (index >= 0) {
2186             e = &st->internal->index_entries[index];
2187             av_assert1(e->timestamp >= target_ts);
2188             pos_max   = e->pos;
2189             ts_max    = e->timestamp;
2190             pos_limit = pos_max - e->min_distance;
2191             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2192                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2193         }
2194     }
2195
2196     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2197                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
2198     if (pos < 0)
2199         return -1;
2200
2201     /* do the seek */
2202     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2203         return ret;
2204
2205     ff_read_frame_flush(s);
2206     ff_update_cur_dts(s, st, ts);
2207
2208     return 0;
2209 }
2210
2211 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2212                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2213 {
2214     int64_t step = 1024;
2215     int64_t limit, ts_max;
2216     int64_t filesize = avio_size(s->pb);
2217     int64_t pos_max  = filesize - 1;
2218     do {
2219         limit = pos_max;
2220         pos_max = FFMAX(0, (pos_max) - step);
2221         ts_max  = ff_read_timestamp(s, stream_index,
2222                                     &pos_max, limit, read_timestamp);
2223         step   += step;
2224     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2225     if (ts_max == AV_NOPTS_VALUE)
2226         return -1;
2227
2228     for (;;) {
2229         int64_t tmp_pos = pos_max + 1;
2230         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
2231                                             &tmp_pos, INT64_MAX, read_timestamp);
2232         if (tmp_ts == AV_NOPTS_VALUE)
2233             break;
2234         av_assert0(tmp_pos > pos_max);
2235         ts_max  = tmp_ts;
2236         pos_max = tmp_pos;
2237         if (tmp_pos >= filesize)
2238             break;
2239     }
2240
2241     if (ts)
2242         *ts = ts_max;
2243     if (pos)
2244         *pos = pos_max;
2245
2246     return 0;
2247 }
2248
2249 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2250                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2251                       int64_t ts_min, int64_t ts_max,
2252                       int flags, int64_t *ts_ret,
2253                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
2254                                                 int64_t *, int64_t))
2255 {
2256     int64_t pos, ts;
2257     int64_t start_pos;
2258     int no_change;
2259     int ret;
2260
2261     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2262
2263     if (ts_min == AV_NOPTS_VALUE) {
2264         pos_min = s->internal->data_offset;
2265         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2266         if (ts_min == AV_NOPTS_VALUE)
2267             return -1;
2268     }
2269
2270     if (ts_min >= target_ts) {
2271         *ts_ret = ts_min;
2272         return pos_min;
2273     }
2274
2275     if (ts_max == AV_NOPTS_VALUE) {
2276         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2277             return ret;
2278         pos_limit = pos_max;
2279     }
2280
2281     if (ts_max <= target_ts) {
2282         *ts_ret = ts_max;
2283         return pos_max;
2284     }
2285
2286     av_assert0(ts_min < ts_max);
2287
2288     no_change = 0;
2289     while (pos_min < pos_limit) {
2290         av_log(s, AV_LOG_TRACE,
2291                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2292                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2293         av_assert0(pos_limit <= pos_max);
2294
2295         if (no_change == 0) {
2296             int64_t approximate_keyframe_distance = pos_max - pos_limit;
2297             // interpolate position (better than dichotomy)
2298             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2299                              ts_max - ts_min) +
2300                   pos_min - approximate_keyframe_distance;
2301         } else if (no_change == 1) {
2302             // bisection if interpolation did not change min / max pos last time
2303             pos = (pos_min + pos_limit) >> 1;
2304         } else {
2305             /* linear search if bisection failed, can only happen if there
2306              * are very few or no keyframes between min/max */
2307             pos = pos_min;
2308         }
2309         if (pos <= pos_min)
2310             pos = pos_min + 1;
2311         else if (pos > pos_limit)
2312             pos = pos_limit;
2313         start_pos = pos;
2314
2315         // May pass pos_limit instead of -1.
2316         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2317         if (pos == pos_max)
2318             no_change++;
2319         else
2320             no_change = 0;
2321         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2322                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2323                 pos_min, pos, pos_max,
2324                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2325                 pos_limit, start_pos, no_change);
2326         if (ts == AV_NOPTS_VALUE) {
2327             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2328             return -1;
2329         }
2330         if (target_ts <= ts) {
2331             pos_limit = start_pos - 1;
2332             pos_max   = pos;
2333             ts_max    = ts;
2334         }
2335         if (target_ts >= ts) {
2336             pos_min = pos;
2337             ts_min  = ts;
2338         }
2339     }
2340
2341     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2342     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
2343 #if 0
2344     pos_min = pos;
2345     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2346     pos_min++;
2347     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2348     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2349             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2350 #endif
2351     *ts_ret = ts;
2352     return pos;
2353 }
2354
2355 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2356                            int64_t pos, int flags)
2357 {
2358     int64_t pos_min, pos_max;
2359
2360     pos_min = s->internal->data_offset;
2361     pos_max = avio_size(s->pb) - 1;
2362
2363     if (pos < pos_min)
2364         pos = pos_min;
2365     else if (pos > pos_max)
2366         pos = pos_max;
2367
2368     avio_seek(s->pb, pos, SEEK_SET);
2369
2370     s->io_repositioned = 1;
2371
2372     return 0;
2373 }
2374
2375 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2376                               int64_t timestamp, int flags)
2377 {
2378     int index;
2379     int64_t ret;
2380     AVStream *st;
2381     AVIndexEntry *ie;
2382
2383     st = s->streams[stream_index];
2384
2385     index = av_index_search_timestamp(st, timestamp, flags);
2386
2387     if (index < 0 && st->internal->nb_index_entries &&
2388         timestamp < st->internal->index_entries[0].timestamp)
2389         return -1;
2390
2391     if (index < 0 || index == st->internal->nb_index_entries - 1) {
2392         AVPacket *pkt = s->internal->pkt;
2393         int nonkey = 0;
2394
2395         if (st->internal->nb_index_entries) {
2396             av_assert0(st->internal->index_entries);
2397             ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2398             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2399                 return ret;
2400             ff_update_cur_dts(s, st, ie->timestamp);
2401         } else {
2402             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2403                 return ret;
2404         }
2405         av_packet_unref(pkt);
2406         for (;;) {
2407             int read_status;
2408             do {
2409                 read_status = av_read_frame(s, pkt);
2410             } while (read_status == AVERROR(EAGAIN));
2411             if (read_status < 0)
2412                 break;
2413             if (stream_index == pkt->stream_index && pkt->dts > timestamp) {
2414                 if (pkt->flags & AV_PKT_FLAG_KEY) {
2415                     av_packet_unref(pkt);
2416                     break;
2417                 }
2418                 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2419                     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);
2420                     av_packet_unref(pkt);
2421                     break;
2422                 }
2423             }
2424             av_packet_unref(pkt);
2425         }
2426         index = av_index_search_timestamp(st, timestamp, flags);
2427     }
2428     if (index < 0)
2429         return -1;
2430
2431     ff_read_frame_flush(s);
2432     if (s->iformat->read_seek)
2433         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2434             return 0;
2435     ie = &st->internal->index_entries[index];
2436     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2437         return ret;
2438     ff_update_cur_dts(s, st, ie->timestamp);
2439
2440     return 0;
2441 }
2442
2443 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2444                                int64_t timestamp, int flags)
2445 {
2446     int ret;
2447     AVStream *st;
2448
2449     if (flags & AVSEEK_FLAG_BYTE) {
2450         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2451             return -1;
2452         ff_read_frame_flush(s);
2453         return seek_frame_byte(s, stream_index, timestamp, flags);
2454     }
2455
2456     if (stream_index < 0) {
2457         stream_index = av_find_default_stream_index(s);
2458         if (stream_index < 0)
2459             return -1;
2460
2461         st = s->streams[stream_index];
2462         /* timestamp for default must be expressed in AV_TIME_BASE units */
2463         timestamp = av_rescale(timestamp, st->time_base.den,
2464                                AV_TIME_BASE * (int64_t) st->time_base.num);
2465     }
2466
2467     /* first, we try the format specific seek */
2468     if (s->iformat->read_seek) {
2469         ff_read_frame_flush(s);
2470         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2471     } else
2472         ret = -1;
2473     if (ret >= 0)
2474         return 0;
2475
2476     if (s->iformat->read_timestamp &&
2477         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2478         ff_read_frame_flush(s);
2479         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2480     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2481         ff_read_frame_flush(s);
2482         return seek_frame_generic(s, stream_index, timestamp, flags);
2483     } else
2484         return -1;
2485 }
2486
2487 int av_seek_frame(AVFormatContext *s, int stream_index,
2488                   int64_t timestamp, int flags)
2489 {
2490     int ret;
2491
2492     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2493         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2494         if ((flags & AVSEEK_FLAG_BACKWARD))
2495             max_ts = timestamp;
2496         else
2497             min_ts = timestamp;
2498         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2499                                   flags & ~AVSEEK_FLAG_BACKWARD);
2500     }
2501
2502     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2503
2504     if (ret >= 0)
2505         ret = avformat_queue_attached_pictures(s);
2506
2507     return ret;
2508 }
2509
2510 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2511                        int64_t ts, int64_t max_ts, int flags)
2512 {
2513     if (min_ts > ts || max_ts < ts)
2514         return -1;
2515     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2516         return AVERROR(EINVAL);
2517
2518     if (s->seek2any>0)
2519         flags |= AVSEEK_FLAG_ANY;
2520     flags &= ~AVSEEK_FLAG_BACKWARD;
2521
2522     if (s->iformat->read_seek2) {
2523         int ret;
2524         ff_read_frame_flush(s);
2525
2526         if (stream_index == -1 && s->nb_streams == 1) {
2527             AVRational time_base = s->streams[0]->time_base;
2528             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2529             min_ts = av_rescale_rnd(min_ts, time_base.den,
2530                                     time_base.num * (int64_t)AV_TIME_BASE,
2531                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2532             max_ts = av_rescale_rnd(max_ts, time_base.den,
2533                                     time_base.num * (int64_t)AV_TIME_BASE,
2534                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2535             stream_index = 0;
2536         }
2537
2538         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2539                                      ts, max_ts, flags);
2540
2541         if (ret >= 0)
2542             ret = avformat_queue_attached_pictures(s);
2543         return ret;
2544     }
2545
2546     if (s->iformat->read_timestamp) {
2547         // try to seek via read_timestamp()
2548     }
2549
2550     // Fall back on old API if new is not implemented but old is.
2551     // Note the old API has somewhat different semantics.
2552     if (s->iformat->read_seek || 1) {
2553         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2554         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2555         if (ret<0 && ts != min_ts && max_ts != ts) {
2556             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2557             if (ret >= 0)
2558                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2559         }
2560         return ret;
2561     }
2562
2563     // try some generic seek like seek_frame_generic() but with new ts semantics
2564     return -1; //unreachable
2565 }
2566
2567 int avformat_flush(AVFormatContext *s)
2568 {
2569     ff_read_frame_flush(s);
2570     return 0;
2571 }
2572
2573 /*******************************************************/
2574
2575 /**
2576  * Return TRUE if the stream has accurate duration in any stream.
2577  *
2578  * @return TRUE if the stream has accurate duration for at least one component.
2579  */
2580 static int has_duration(AVFormatContext *ic)
2581 {
2582     int i;
2583     AVStream *st;
2584
2585     for (i = 0; i < ic->nb_streams; i++) {
2586         st = ic->streams[i];
2587         if (st->duration != AV_NOPTS_VALUE)
2588             return 1;
2589     }
2590     if (ic->duration != AV_NOPTS_VALUE)
2591         return 1;
2592     return 0;
2593 }
2594
2595 /**
2596  * Estimate the stream timings from the one of each components.
2597  *
2598  * Also computes the global bitrate if possible.
2599  */
2600 static void update_stream_timings(AVFormatContext *ic)
2601 {
2602     int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2603     int64_t duration, duration1, duration_text, filesize;
2604     int i;
2605     AVProgram *p;
2606
2607     start_time = INT64_MAX;
2608     start_time_text = INT64_MAX;
2609     end_time   = INT64_MIN;
2610     end_time_text   = INT64_MIN;
2611     duration   = INT64_MIN;
2612     duration_text = INT64_MIN;
2613
2614     for (i = 0; i < ic->nb_streams; i++) {
2615         AVStream *st = ic->streams[i];
2616         int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2617                       st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2618         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2619             start_time1 = av_rescale_q(st->start_time, st->time_base,
2620                                        AV_TIME_BASE_Q);
2621             if (is_text)
2622                 start_time_text = FFMIN(start_time_text, start_time1);
2623             else
2624                 start_time = FFMIN(start_time, start_time1);
2625             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2626                                          AV_TIME_BASE_Q,
2627                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2628             if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2629                 end_time1 += start_time1;
2630                 if (is_text)
2631                     end_time_text = FFMAX(end_time_text, end_time1);
2632                 else
2633                     end_time = FFMAX(end_time, end_time1);
2634             }
2635             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2636                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2637                     p->start_time = start_time1;
2638                 if (p->end_time < end_time1)
2639                     p->end_time = end_time1;
2640             }
2641         }
2642         if (st->duration != AV_NOPTS_VALUE) {
2643             duration1 = av_rescale_q(st->duration, st->time_base,
2644                                      AV_TIME_BASE_Q);
2645             if (is_text)
2646                 duration_text = FFMAX(duration_text, duration1);
2647             else
2648                 duration = FFMAX(duration, duration1);
2649         }
2650     }
2651     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2652         start_time = start_time_text;
2653     else if (start_time > start_time_text)
2654         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2655
2656     if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2657         end_time = end_time_text;
2658     else if (end_time < end_time_text)
2659         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2660
2661      if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2662          duration = duration_text;
2663      else if (duration < duration_text)
2664          av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2665
2666     if (start_time != INT64_MAX) {
2667         ic->start_time = start_time;
2668         if (end_time != INT64_MIN) {
2669             if (ic->nb_programs > 1) {
2670                 for (i = 0; i < ic->nb_programs; i++) {
2671                     p = ic->programs[i];
2672                     if (p->start_time != AV_NOPTS_VALUE &&
2673                         p->end_time > p->start_time &&
2674                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2675                         duration = FFMAX(duration, p->end_time - p->start_time);
2676                 }
2677             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2678                 duration = FFMAX(duration, end_time - start_time);
2679             }
2680         }
2681     }
2682     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2683         ic->duration = duration;
2684     }
2685     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2686         /* compute the bitrate */
2687         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2688                          (double) ic->duration;
2689         if (bitrate >= 0 && bitrate <= INT64_MAX)
2690             ic->bit_rate = bitrate;
2691     }
2692 }
2693
2694 static void fill_all_stream_timings(AVFormatContext *ic)
2695 {
2696     int i;
2697     AVStream *st;
2698
2699     update_stream_timings(ic);
2700     for (i = 0; i < ic->nb_streams; i++) {
2701         st = ic->streams[i];
2702         if (st->start_time == AV_NOPTS_VALUE) {
2703             if (ic->start_time != AV_NOPTS_VALUE)
2704                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2705                                               st->time_base);
2706             if (ic->duration != AV_NOPTS_VALUE)
2707                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2708                                             st->time_base);
2709         }
2710     }
2711 }
2712
2713 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2714 {
2715     int64_t filesize, duration;
2716     int i, show_warning = 0;
2717     AVStream *st;
2718
2719     /* if bit_rate is already set, we believe it */
2720     if (ic->bit_rate <= 0) {
2721         int64_t bit_rate = 0;
2722         for (i = 0; i < ic->nb_streams; i++) {
2723             st = ic->streams[i];
2724             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2725                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2726             if (st->codecpar->bit_rate > 0) {
2727                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2728                     bit_rate = 0;
2729                     break;
2730                 }
2731                 bit_rate += st->codecpar->bit_rate;
2732             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2733                 // If we have a videostream with packets but without a bitrate
2734                 // then consider the sum not known
2735                 bit_rate = 0;
2736                 break;
2737             }
2738         }
2739         ic->bit_rate = bit_rate;
2740     }
2741
2742     /* if duration is already set, we believe it */
2743     if (ic->duration == AV_NOPTS_VALUE &&
2744         ic->bit_rate != 0) {
2745         filesize = ic->pb ? avio_size(ic->pb) : 0;
2746         if (filesize > ic->internal->data_offset) {
2747             filesize -= ic->internal->data_offset;
2748             for (i = 0; i < ic->nb_streams; i++) {
2749                 st      = ic->streams[i];
2750                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2751                     && st->duration == AV_NOPTS_VALUE) {
2752                     duration = av_rescale(filesize, 8LL * st->time_base.den,
2753                                           ic->bit_rate *
2754                                           (int64_t) st->time_base.num);
2755                     st->duration = duration;
2756                     show_warning = 1;
2757                 }
2758             }
2759         }
2760     }
2761     if (show_warning)
2762         av_log(ic, AV_LOG_WARNING,
2763                "Estimating duration from bitrate, this may be inaccurate\n");
2764 }
2765
2766 #define DURATION_MAX_READ_SIZE 250000LL
2767 #define DURATION_MAX_RETRY 6
2768
2769 /* only usable for MPEG-PS streams */
2770 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2771 {
2772     AVPacket *pkt = ic->internal->pkt;
2773     AVStream *st;
2774     int num, den, read_size, i, ret;
2775     int found_duration = 0;
2776     int is_end;
2777     int64_t filesize, offset, duration;
2778     int retry = 0;
2779
2780     /* flush packet queue */
2781     flush_packet_queue(ic);
2782
2783     for (i = 0; i < ic->nb_streams; i++) {
2784         st = ic->streams[i];
2785         if (st->start_time == AV_NOPTS_VALUE &&
2786             st->first_dts == AV_NOPTS_VALUE &&
2787             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2788             av_log(ic, AV_LOG_WARNING,
2789                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2790
2791         if (st->parser) {
2792             av_parser_close(st->parser);
2793             st->parser = NULL;
2794         }
2795     }
2796
2797     if (ic->skip_estimate_duration_from_pts) {
2798         av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2799         goto skip_duration_calc;
2800     }
2801
2802     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2803     /* estimate the end time (duration) */
2804     /* XXX: may need to support wrapping */
2805     filesize = ic->pb ? avio_size(ic->pb) : 0;
2806     do {
2807         is_end = found_duration;
2808         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2809         if (offset < 0)
2810             offset = 0;
2811
2812         avio_seek(ic->pb, offset, SEEK_SET);
2813         read_size = 0;
2814         for (;;) {
2815             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2816                 break;
2817
2818             do {
2819                 ret = ff_read_packet(ic, pkt);
2820             } while (ret == AVERROR(EAGAIN));
2821             if (ret != 0)
2822                 break;
2823             read_size += pkt->size;
2824             st         = ic->streams[pkt->stream_index];
2825             if (pkt->pts != AV_NOPTS_VALUE &&
2826                 (st->start_time != AV_NOPTS_VALUE ||
2827                  st->first_dts  != AV_NOPTS_VALUE)) {
2828                 if (pkt->duration == 0) {
2829                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2830                     if (den && num) {
2831                         pkt->duration = av_rescale_rnd(1,
2832                                            num * (int64_t) st->time_base.den,
2833                                            den * (int64_t) st->time_base.num,
2834                                            AV_ROUND_DOWN);
2835                     }
2836                 }
2837                 duration = pkt->pts + pkt->duration;
2838                 found_duration = 1;
2839                 if (st->start_time != AV_NOPTS_VALUE)
2840                     duration -= st->start_time;
2841                 else
2842                     duration -= st->first_dts;
2843                 if (duration > 0) {
2844                     if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2845                         (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2846                         st->duration = duration;
2847                     st->internal->info->last_duration = duration;
2848                 }
2849             }
2850             av_packet_unref(pkt);
2851         }
2852
2853         /* check if all audio/video streams have valid duration */
2854         if (!is_end) {
2855             is_end = 1;
2856             for (i = 0; i < ic->nb_streams; i++) {
2857                 st = ic->streams[i];
2858                 switch (st->codecpar->codec_type) {
2859                     case AVMEDIA_TYPE_VIDEO:
2860                     case AVMEDIA_TYPE_AUDIO:
2861                         if (st->duration == AV_NOPTS_VALUE)
2862                             is_end = 0;
2863                 }
2864             }
2865         }
2866     } while (!is_end &&
2867              offset &&
2868              ++retry <= DURATION_MAX_RETRY);
2869
2870     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2871
2872     /* warn about audio/video streams which duration could not be estimated */
2873     for (i = 0; i < ic->nb_streams; i++) {
2874         st = ic->streams[i];
2875         if (st->duration == AV_NOPTS_VALUE) {
2876             switch (st->codecpar->codec_type) {
2877             case AVMEDIA_TYPE_VIDEO:
2878             case AVMEDIA_TYPE_AUDIO:
2879                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2880                     av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2881                 } else
2882                     av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2883             }
2884         }
2885     }
2886 skip_duration_calc:
2887     fill_all_stream_timings(ic);
2888
2889     avio_seek(ic->pb, old_offset, SEEK_SET);
2890     for (i = 0; i < ic->nb_streams; i++) {
2891         int j;
2892
2893         st              = ic->streams[i];
2894         st->cur_dts     = st->first_dts;
2895         st->last_IP_pts = AV_NOPTS_VALUE;
2896         st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2897         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2898             st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2899     }
2900 }
2901
2902 /* 1:1 map to AVDurationEstimationMethod */
2903 static const char *const duration_name[] = {
2904     [AVFMT_DURATION_FROM_PTS]     = "pts",
2905     [AVFMT_DURATION_FROM_STREAM]  = "stream",
2906     [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2907 };
2908
2909 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2910 {
2911     return duration_name[method];
2912 }
2913
2914 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2915 {
2916     int64_t file_size;
2917
2918     /* get the file size, if possible */
2919     if (ic->iformat->flags & AVFMT_NOFILE) {
2920         file_size = 0;
2921     } else {
2922         file_size = avio_size(ic->pb);
2923         file_size = FFMAX(0, file_size);
2924     }
2925
2926     if ((!strcmp(ic->iformat->name, "mpeg") ||
2927          !strcmp(ic->iformat->name, "mpegts")) &&
2928         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2929         /* get accurate estimate from the PTSes */
2930         estimate_timings_from_pts(ic, old_offset);
2931         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2932     } else if (has_duration(ic)) {
2933         /* at least one component has timings - we use them for all
2934          * the components */
2935         fill_all_stream_timings(ic);
2936         /* nut demuxer estimate the duration from PTS */
2937         if(!strcmp(ic->iformat->name, "nut"))
2938             ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2939         else
2940             ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2941     } else {
2942         /* less precise: use bitrate info */
2943         estimate_timings_from_bit_rate(ic);
2944         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2945     }
2946     update_stream_timings(ic);
2947
2948     {
2949         int i;
2950         AVStream av_unused *st;
2951         for (i = 0; i < ic->nb_streams; i++) {
2952             st = ic->streams[i];
2953             if (st->time_base.den)
2954                 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2955                        av_ts2timestr(st->start_time, &st->time_base),
2956                        av_ts2timestr(st->duration, &st->time_base));
2957         }
2958         av_log(ic, AV_LOG_TRACE,
2959                "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2960                av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2961                av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2962                duration_estimate_name(ic->duration_estimation_method),
2963                (int64_t)ic->bit_rate / 1000);
2964     }
2965 }
2966
2967 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2968 {
2969     AVCodecContext *avctx = st->internal->avctx;
2970
2971 #define FAIL(errmsg) do {                                         \
2972         if (errmsg_ptr)                                           \
2973             *errmsg_ptr = errmsg;                                 \
2974         return 0;                                                 \
2975     } while (0)
2976
2977     if (   avctx->codec_id == AV_CODEC_ID_NONE
2978         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2979         FAIL("unknown codec");
2980     switch (avctx->codec_type) {
2981     case AVMEDIA_TYPE_AUDIO:
2982         if (!avctx->frame_size && determinable_frame_size(avctx))
2983             FAIL("unspecified frame size");
2984         if (st->internal->info->found_decoder >= 0 &&
2985             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2986             FAIL("unspecified sample format");
2987         if (!avctx->sample_rate)
2988             FAIL("unspecified sample rate");
2989         if (!avctx->channels)
2990             FAIL("unspecified number of channels");
2991         if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2992             FAIL("no decodable DTS frames");
2993         break;
2994     case AVMEDIA_TYPE_VIDEO:
2995         if (!avctx->width)
2996             FAIL("unspecified size");
2997         if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2998             FAIL("unspecified pixel format");
2999         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3000             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3001                 FAIL("no frame in rv30/40 and no sar");
3002         break;
3003     case AVMEDIA_TYPE_SUBTITLE:
3004         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3005             FAIL("unspecified size");
3006         break;
3007     case AVMEDIA_TYPE_DATA:
3008         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3009     }
3010
3011     return 1;
3012 }
3013
3014 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3015 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3016                             const AVPacket *avpkt, AVDictionary **options)
3017 {
3018     AVCodecContext *avctx = st->internal->avctx;
3019     const AVCodec *codec;
3020     int got_picture = 1, ret = 0;
3021     AVFrame *frame = av_frame_alloc();
3022     AVSubtitle subtitle;
3023     AVPacket pkt = *avpkt;
3024     int do_skip_frame = 0;
3025     enum AVDiscard skip_frame;
3026
3027     if (!frame)
3028         return AVERROR(ENOMEM);
3029
3030     if (!avcodec_is_open(avctx) &&
3031         st->internal->info->found_decoder <= 0 &&
3032         (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3033         AVDictionary *thread_opt = NULL;
3034
3035         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3036
3037         if (!codec) {
3038             st->internal->info->found_decoder = -st->codecpar->codec_id;
3039             ret                     = -1;
3040             goto fail;
3041         }
3042
3043         /* Force thread count to 1 since the H.264 decoder will not extract
3044          * SPS and PPS to extradata during multi-threaded decoding. */
3045         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3046         /* Force lowres to 0. The decoder might reduce the video size by the
3047          * lowres factor, and we don't want that propagated to the stream's
3048          * codecpar */
3049         av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
3050         if (s->codec_whitelist)
3051             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3052         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3053         if (!options)
3054             av_dict_free(&thread_opt);
3055         if (ret < 0) {
3056             st->internal->info->found_decoder = -avctx->codec_id;
3057             goto fail;
3058         }
3059         st->internal->info->found_decoder = 1;
3060     } else if (!st->internal->info->found_decoder)
3061         st->internal->info->found_decoder = 1;
3062
3063     if (st->internal->info->found_decoder < 0) {
3064         ret = -1;
3065         goto fail;
3066     }
3067
3068     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3069         do_skip_frame = 1;
3070         skip_frame = avctx->skip_frame;
3071         avctx->skip_frame = AVDISCARD_ALL;
3072     }
3073
3074     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3075            ret >= 0 &&
3076            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3077             (!st->codec_info_nb_frames &&
3078              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3079         got_picture = 0;
3080         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3081             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3082             ret = avcodec_send_packet(avctx, &pkt);
3083             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3084                 break;
3085             if (ret >= 0)
3086                 pkt.size = 0;
3087             ret = avcodec_receive_frame(avctx, frame);
3088             if (ret >= 0)
3089                 got_picture = 1;
3090             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3091                 ret = 0;
3092         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3093             ret = avcodec_decode_subtitle2(avctx, &subtitle,
3094                                            &got_picture, &pkt);
3095             if (got_picture)
3096                 avsubtitle_free(&subtitle);
3097             if (ret >= 0)
3098                 pkt.size = 0;
3099         }
3100         if (ret >= 0) {
3101             if (got_picture)
3102                 st->internal->nb_decoded_frames++;
3103             ret       = got_picture;
3104         }
3105     }
3106
3107     if (!pkt.data && !got_picture)
3108         ret = -1;
3109
3110 fail:
3111     if (do_skip_frame) {
3112         avctx->skip_frame = skip_frame;
3113     }
3114
3115     av_frame_free(&frame);
3116     return ret;
3117 }
3118
3119 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3120 {
3121     while (tags->id != AV_CODEC_ID_NONE) {
3122         if (tags->id == id)
3123             return tags->tag;
3124         tags++;
3125     }
3126     return 0;
3127 }
3128
3129 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3130 {
3131     int i;
3132     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3133         if (tag == tags[i].tag)
3134             return tags[i].id;
3135     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3136         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3137             return tags[i].id;
3138     return AV_CODEC_ID_NONE;
3139 }
3140
3141 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3142 {
3143     if (bps <= 0 || bps > 64)
3144         return AV_CODEC_ID_NONE;
3145
3146     if (flt) {
3147         switch (bps) {
3148         case 32:
3149             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3150         case 64:
3151             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3152         default:
3153             return AV_CODEC_ID_NONE;
3154         }
3155     } else {
3156         bps  += 7;
3157         bps >>= 3;
3158         if (sflags & (1 << (bps - 1))) {
3159             switch (bps) {
3160             case 1:
3161                 return AV_CODEC_ID_PCM_S8;
3162             case 2:
3163                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3164             case 3:
3165                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3166             case 4:
3167                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3168             case 8:
3169                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3170             default:
3171                 return AV_CODEC_ID_NONE;
3172             }
3173         } else {
3174             switch (bps) {
3175             case 1:
3176                 return AV_CODEC_ID_PCM_U8;
3177             case 2:
3178                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3179             case 3:
3180                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3181             case 4:
3182                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3183             default:
3184                 return AV_CODEC_ID_NONE;
3185             }
3186         }
3187     }
3188 }
3189
3190 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3191 {
3192     unsigned int tag;
3193     if (!av_codec_get_tag2(tags, id, &tag))
3194         return 0;
3195     return tag;
3196 }
3197
3198 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3199                       unsigned int *tag)
3200 {
3201     int i;
3202     for (i = 0; tags && tags[i]; i++) {
3203         const AVCodecTag *codec_tags = tags[i];
3204         while (codec_tags->id != AV_CODEC_ID_NONE) {
3205             if (codec_tags->id == id) {
3206                 *tag = codec_tags->tag;
3207                 return 1;
3208             }
3209             codec_tags++;
3210         }
3211     }
3212     return 0;
3213 }
3214
3215 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3216 {
3217     int i;
3218     for (i = 0; tags && tags[i]; i++) {
3219         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3220         if (id != AV_CODEC_ID_NONE)
3221             return id;
3222     }
3223     return AV_CODEC_ID_NONE;
3224 }
3225
3226 static int chapter_start_cmp(const void *p1, const void *p2)
3227 {
3228     AVChapter *ch1 = *(AVChapter**)p1;
3229     AVChapter *ch2 = *(AVChapter**)p2;
3230     int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3231     if (delta)
3232         return delta;
3233     return (ch1 > ch2) - (ch1 < ch2);
3234 }
3235
3236 static int compute_chapters_end(AVFormatContext *s)
3237 {
3238     unsigned int i;
3239     int64_t max_time = 0;
3240     AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3241
3242     if (!timetable)
3243         return AVERROR(ENOMEM);
3244
3245     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3246         max_time = s->duration +
3247                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3248
3249     for (i = 0; i < s->nb_chapters; i++)
3250         timetable[i] = s->chapters[i];
3251     qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3252
3253     for (i = 0; i < s->nb_chapters; i++)
3254         if (timetable[i]->end == AV_NOPTS_VALUE) {
3255             AVChapter *ch = timetable[i];
3256             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3257                                                 ch->time_base)
3258                                 : INT64_MAX;
3259
3260             if (i + 1 < s->nb_chapters) {
3261                 AVChapter *ch1     = timetable[i + 1];
3262                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3263                                                 ch->time_base);
3264                 if (next_start > ch->start && next_start < end)
3265                     end = next_start;
3266             }
3267             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3268         }
3269     av_free(timetable);
3270     return 0;
3271 }
3272
3273 static int get_std_framerate(int i)
3274 {
3275     if (i < 30*12)
3276         return (i + 1) * 1001;
3277     i -= 30*12;
3278
3279     if (i < 30)
3280         return (i + 31) * 1001 * 12;
3281     i -= 30;
3282
3283     if (i < 3)
3284         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3285
3286     i -= 3;
3287
3288     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3289 }
3290
3291 /* Is the time base unreliable?
3292  * This is a heuristic to balance between quick acceptance of the values in
3293  * the headers vs. some extra checks.
3294  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3295  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3296  * And there are "variable" fps files this needs to detect as well. */
3297 static int tb_unreliable(AVCodecContext *c)
3298 {
3299     if (c->time_base.den >= 101LL * c->time_base.num ||
3300         c->time_base.den <    5LL * c->time_base.num ||
3301         // c->codec_tag == AV_RL32("DIVX") ||
3302         // c->codec_tag == AV_RL32("XVID") ||
3303         c->codec_tag == AV_RL32("mp4v") ||
3304         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3305         c->codec_id == AV_CODEC_ID_GIF ||
3306         c->codec_id == AV_CODEC_ID_HEVC ||
3307         c->codec_id == AV_CODEC_ID_H264)
3308         return 1;
3309     return 0;
3310 }
3311
3312 int ff_alloc_extradata(AVCodecParameters *par, int size)
3313 {
3314     av_freep(&par->extradata);
3315     par->extradata_size = 0;
3316
3317     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3318         return AVERROR(EINVAL);
3319
3320     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3321     if (!par->extradata)
3322         return AVERROR(ENOMEM);
3323
3324     memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3325     par->extradata_size = size;
3326
3327     return 0;
3328 }
3329
3330 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3331 {
3332     int ret = ff_alloc_extradata(par, size);
3333     if (ret < 0)
3334         return ret;
3335     ret = avio_read(pb, par->extradata, size);
3336     if (ret != size) {
3337         av_freep(&par->extradata);
3338         par->extradata_size = 0;
3339         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3340         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3341     }
3342
3343     return ret;
3344 }
3345
3346 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3347 {
3348     int i, j;
3349     int64_t last = st->internal->info->last_dts;
3350
3351     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3352        && ts - (uint64_t)last < INT64_MAX) {
3353         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3354         int64_t duration = ts - last;
3355
3356         if (!st->internal->info->duration_error)
3357             st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3358         if (!st->internal->info->duration_error)
3359             return AVERROR(ENOMEM);
3360
3361 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3362 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3363         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3364             if (st->internal->info->duration_error[0][1][i] < 1e10) {
3365                 int framerate = get_std_framerate(i);
3366                 double sdts = dts*framerate/(1001*12);
3367                 for (j= 0; j<2; j++) {
3368                     int64_t ticks = llrint(sdts+j*0.5);
3369                     double error= sdts - ticks + j*0.5;
3370                     st->internal->info->duration_error[j][0][i] += error;
3371                     st->internal->info->duration_error[j][1][i] += error*error;
3372                 }
3373             }
3374         }
3375         if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3376             st->internal->info->duration_count++;
3377             st->internal->info->rfps_duration_sum += duration;
3378         }
3379
3380         if (st->internal->info->duration_count % 10 == 0) {
3381             int n = st->internal->info->duration_count;
3382             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3383                 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3384                     double a0     = st->internal->info->duration_error[0][0][i] / n;
3385                     double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3386                     double a1     = st->internal->info->duration_error[1][0][i] / n;
3387                     double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3388                     if (error0 > 0.04 && error1 > 0.04) {
3389                         st->internal->info->duration_error[0][1][i] = 2e10;
3390                         st->internal->info->duration_error[1][1][i] = 2e10;
3391                     }
3392                 }
3393             }
3394         }
3395
3396         // ignore the first 4 values, they might have some random jitter
3397         if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3398             st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3399     }
3400     if (ts != AV_NOPTS_VALUE)
3401         st->internal->info->last_dts = ts;
3402
3403     return 0;
3404 }
3405
3406 void ff_rfps_calculate(AVFormatContext *ic)
3407 {
3408     int i, j;
3409
3410     for (i = 0; i < ic->nb_streams; i++) {
3411         AVStream *st = ic->streams[i];
3412
3413         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3414             continue;
3415         // the check for tb_unreliable() is not completely correct, since this is not about handling
3416         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3417         // ipmovie.c produces.
3418         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)
3419             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);
3420         if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3421             && tb_unreliable(st->internal->avctx)) {
3422             int num = 0;
3423             double best_error= 0.01;
3424             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3425
3426             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3427                 int k;
3428
3429                 if (st->internal->info->codec_info_duration &&
3430                     st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3431                     continue;
3432                 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3433                     continue;
3434
3435                 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))
3436                     continue;
3437
3438                 for (k= 0; k<2; k++) {
3439                     int n = st->internal->info->duration_count;
3440                     double a= st->internal->info->duration_error[k][0][j] / n;
3441                     double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3442
3443                     if (error < best_error && best_error> 0.000000001) {
3444                         best_error= error;
3445                         num = get_std_framerate(j);
3446                     }
3447                     if (error < 0.02)
3448                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3449                 }
3450             }
3451             // do not increase frame rate by more than 1 % in order to match a standard rate.
3452             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3453                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3454         }
3455         if (   !st->avg_frame_rate.num
3456             && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3457             && st->internal->info->codec_info_duration <= 0
3458             && st->internal->info->duration_count > 2
3459             && 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
3460             ) {
3461             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3462             st->avg_frame_rate = st->r_frame_rate;
3463         }
3464
3465         av_freep(&st->internal->info->duration_error);
3466         st->internal->info->last_dts = AV_NOPTS_VALUE;
3467         st->internal->info->duration_count = 0;
3468         st->internal->info->rfps_duration_sum = 0;
3469     }
3470 }
3471
3472 static int extract_extradata_check(AVStream *st)
3473 {
3474     const AVBitStreamFilter *f;
3475
3476     f = av_bsf_get_by_name("extract_extradata");
3477     if (!f)
3478         return 0;
3479
3480     if (f->codec_ids) {
3481         const enum AVCodecID *ids;
3482         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3483             if (*ids == st->codecpar->codec_id)
3484                 return 1;
3485     }
3486
3487     return 0;
3488 }
3489
3490 static int extract_extradata_init(AVStream *st)
3491 {
3492     AVStreamInternal *sti = st->internal;
3493     const AVBitStreamFilter *f;
3494     int ret;
3495
3496     f = av_bsf_get_by_name("extract_extradata");
3497     if (!f)
3498         goto finish;
3499
3500     /* check that the codec id is supported */
3501     ret = extract_extradata_check(st);
3502     if (!ret)
3503         goto finish;
3504
3505     sti->extract_extradata.pkt = av_packet_alloc();
3506     if (!sti->extract_extradata.pkt)
3507         return AVERROR(ENOMEM);
3508
3509     ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3510     if (ret < 0)
3511         goto fail;
3512
3513     ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3514                                   st->codecpar);
3515     if (ret < 0)
3516         goto fail;
3517
3518     sti->extract_extradata.bsf->time_base_in = st->time_base;
3519
3520     ret = av_bsf_init(sti->extract_extradata.bsf);
3521     if (ret < 0)
3522         goto fail;
3523
3524 finish:
3525     sti->extract_extradata.inited = 1;
3526
3527     return 0;
3528 fail:
3529     av_bsf_free(&sti->extract_extradata.bsf);
3530     av_packet_free(&sti->extract_extradata.pkt);
3531     return ret;
3532 }
3533
3534 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3535 {
3536     AVStreamInternal *sti = st->internal;
3537     AVPacket *pkt_ref;
3538     int ret;
3539
3540     if (!sti->extract_extradata.inited) {
3541         ret = extract_extradata_init(st);
3542         if (ret < 0)
3543             return ret;
3544     }
3545
3546     if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3547         return 0;
3548
3549     pkt_ref = sti->extract_extradata.pkt;
3550     ret = av_packet_ref(pkt_ref, pkt);
3551     if (ret < 0)
3552         return ret;
3553
3554     ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3555     if (ret < 0) {
3556         av_packet_unref(pkt_ref);
3557         return ret;
3558     }
3559
3560     while (ret >= 0 && !sti->avctx->extradata) {
3561         ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3562         if (ret < 0) {
3563             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3564                 return ret;
3565             continue;
3566         }
3567
3568         for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3569             AVPacketSideData *side_data = &pkt_ref->side_data[i];
3570             if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3571                 sti->avctx->extradata      = side_data->data;
3572                 sti->avctx->extradata_size = side_data->size;
3573                 side_data->data = NULL;
3574                 side_data->size = 0;
3575                 break;
3576             }
3577         }
3578         av_packet_unref(pkt_ref);
3579     }
3580
3581     return 0;
3582 }
3583
3584 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3585 {
3586     int i;
3587
3588     for (i = 0; i < avctx->nb_coded_side_data; i++) {
3589         const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3590         uint8_t *dst_data;
3591         dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3592         if (!dst_data)
3593             return AVERROR(ENOMEM);
3594         memcpy(dst_data, sd_src->data, sd_src->size);
3595     }
3596     return 0;
3597 }
3598
3599 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3600 {
3601     int i, count = 0, ret = 0, j;
3602     int64_t read_size;
3603     AVStream *st;
3604     AVCodecContext *avctx;
3605     AVPacket *pkt1 = ic->internal->pkt;
3606     int64_t old_offset  = avio_tell(ic->pb);
3607     // new streams might appear, no options for those
3608     int orig_nb_streams = ic->nb_streams;
3609     int flush_codecs;
3610     int64_t max_analyze_duration = ic->max_analyze_duration;
3611     int64_t max_stream_analyze_duration;
3612     int64_t max_subtitle_analyze_duration;
3613     int64_t probesize = ic->probesize;
3614     int eof_reached = 0;
3615     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3616
3617     flush_codecs = probesize > 0;
3618
3619     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3620
3621     max_stream_analyze_duration = max_analyze_duration;
3622     max_subtitle_analyze_duration = max_analyze_duration;
3623     if (!max_analyze_duration) {
3624         max_stream_analyze_duration =
3625         max_analyze_duration        = 5*AV_TIME_BASE;
3626         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3627         if (!strcmp(ic->iformat->name, "flv"))
3628             max_stream_analyze_duration = 90*AV_TIME_BASE;
3629         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3630             max_stream_analyze_duration = 7*AV_TIME_BASE;
3631     }
3632
3633     if (ic->pb)
3634         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3635                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3636
3637     for (i = 0; i < ic->nb_streams; i++) {
3638         const AVCodec *codec;
3639         AVDictionary *thread_opt = NULL;
3640         st = ic->streams[i];
3641         avctx = st->internal->avctx;
3642
3643         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3644             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3645 /*            if (!st->time_base.num)
3646                 st->time_base = */
3647             if (!avctx->time_base.num)
3648                 avctx->time_base = st->time_base;
3649         }
3650
3651         /* check if the caller has overridden the codec id */
3652 #if FF_API_LAVF_AVCTX
3653 FF_DISABLE_DEPRECATION_WARNINGS
3654         if (st->codec->codec_id != st->internal->orig_codec_id) {
3655             st->codecpar->codec_id   = st->codec->codec_id;
3656             st->codecpar->codec_type = st->codec->codec_type;
3657             st->internal->orig_codec_id = st->codec->codec_id;
3658         }
3659 FF_ENABLE_DEPRECATION_WARNINGS
3660 #endif
3661         // only for the split stuff
3662         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3663             st->parser = av_parser_init(st->codecpar->codec_id);
3664             if (st->parser) {
3665                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3666                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3667                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3668                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3669                 }
3670             } else if (st->need_parsing) {
3671                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3672                        "%s, packets or times may be invalid.\n",
3673                        avcodec_get_name(st->codecpar->codec_id));
3674             }
3675         }
3676
3677         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3678             st->internal->orig_codec_id = st->codecpar->codec_id;
3679
3680         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3681         if (ret < 0)
3682             goto find_stream_info_err;
3683         if (st->internal->request_probe <= 0)
3684             st->internal->avctx_inited = 1;
3685
3686         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3687
3688         /* Force thread count to 1 since the H.264 decoder will not extract
3689          * SPS and PPS to extradata during multi-threaded decoding. */
3690         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3691         /* Force lowres to 0. The decoder might reduce the video size by the
3692          * lowres factor, and we don't want that propagated to the stream's
3693          * codecpar */
3694         av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
3695
3696         if (ic->codec_whitelist)
3697             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3698
3699         /* Ensure that subtitle_header is properly set. */
3700         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3701             && codec && !avctx->codec) {
3702             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3703                 av_log(ic, AV_LOG_WARNING,
3704                        "Failed to open codec in %s\n",__FUNCTION__);
3705         }
3706
3707         // Try to just open decoders, in case this is enough to get parameters.
3708         if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0) {
3709             if (codec && !avctx->codec)
3710                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3711                     av_log(ic, AV_LOG_WARNING,
3712                            "Failed to open codec in %s\n",__FUNCTION__);
3713         }
3714         if (!options)
3715             av_dict_free(&thread_opt);
3716     }
3717
3718     for (i = 0; i < ic->nb_streams; i++) {
3719 #if FF_API_R_FRAME_RATE
3720         ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3721 #endif
3722         ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3723         ic->streams[i]->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
3724     }
3725
3726     read_size = 0;
3727     for (;;) {
3728         const AVPacket *pkt;
3729         int analyzed_all_streams;
3730         if (ff_check_interrupt(&ic->interrupt_callback)) {
3731             ret = AVERROR_EXIT;
3732             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3733             break;
3734         }
3735
3736         /* check if one codec still needs to be handled */
3737         for (i = 0; i < ic->nb_streams; i++) {
3738             int fps_analyze_framecount = 20;
3739             int count;
3740
3741             st = ic->streams[i];
3742             if (!has_codec_parameters(st, NULL))
3743                 break;
3744             /* If the timebase is coarse (like the usual millisecond precision
3745              * of mkv), we need to analyze more frames to reliably arrive at
3746              * the correct fps. */
3747             if (av_q2d(st->time_base) > 0.0005)
3748                 fps_analyze_framecount *= 2;
3749             if (!tb_unreliable(st->internal->avctx))
3750                 fps_analyze_framecount = 0;
3751             if (ic->fps_probe_size >= 0)
3752                 fps_analyze_framecount = ic->fps_probe_size;
3753             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3754                 fps_analyze_framecount = 0;
3755             /* variable fps and no guess at the real fps */
3756             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3757                        st->internal->info->codec_info_duration_fields/2 :
3758                        st->internal->info->duration_count;
3759             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3760                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3761                 if (count < fps_analyze_framecount)
3762                     break;
3763             }
3764             // Look at the first 3 frames if there is evidence of frame delay
3765             // but the decoder delay is not set.
3766             if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3767                 break;
3768             if (!st->internal->avctx->extradata &&
3769                 (!st->internal->extract_extradata.inited ||
3770                  st->internal->extract_extradata.bsf) &&
3771                 extract_extradata_check(st))
3772                 break;
3773             if (st->first_dts == AV_NOPTS_VALUE &&
3774                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3775                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3776                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3777                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3778                 break;
3779         }
3780         analyzed_all_streams = 0;
3781         if (!missing_streams || !*missing_streams)
3782             if (i == ic->nb_streams) {
3783                 analyzed_all_streams = 1;
3784                 /* NOTE: If the format has no header, then we need to read some
3785                  * packets to get most of the streams, so we cannot stop here. */
3786                 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3787                     /* If we found the info for all the codecs, we can stop. */
3788                     ret = count;
3789                     av_log(ic, AV_LOG_DEBUG, "All info found\n");
3790                     flush_codecs = 0;
3791                     break;
3792                 }
3793             }
3794         /* We did not get all the codec info, but we read too much data. */
3795         if (read_size >= probesize) {
3796             ret = count;
3797             av_log(ic, AV_LOG_DEBUG,
3798                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3799             for (i = 0; i < ic->nb_streams; i++)
3800                 if (!ic->streams[i]->r_frame_rate.num &&
3801                     ic->streams[i]->internal->info->duration_count <= 1 &&
3802                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3803                     strcmp(ic->iformat->name, "image2"))
3804                     av_log(ic, AV_LOG_WARNING,
3805                            "Stream #%d: not enough frames to estimate rate; "
3806                            "consider increasing probesize\n", i);
3807             break;
3808         }
3809
3810         /* NOTE: A new stream can be added there if no header in file
3811          * (AVFMTCTX_NOHEADER). */
3812         ret = read_frame_internal(ic, pkt1);
3813         if (ret == AVERROR(EAGAIN))
3814             continue;
3815
3816         if (ret < 0) {
3817             /* EOF or error*/
3818             eof_reached = 1;
3819             break;
3820         }
3821
3822         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3823             ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3824                                      &ic->internal->packet_buffer_end,
3825                                      pkt1, NULL, 0);
3826             if (ret < 0)
3827                 goto unref_then_goto_end;
3828
3829             pkt = &ic->internal->packet_buffer_end->pkt;
3830         } else {
3831             pkt = pkt1;
3832         }
3833
3834         st = ic->streams[pkt->stream_index];
3835         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3836             read_size += pkt->size;
3837
3838         avctx = st->internal->avctx;
3839         if (!st->internal->avctx_inited) {
3840             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3841             if (ret < 0)
3842                 goto unref_then_goto_end;
3843             st->internal->avctx_inited = 1;
3844         }
3845
3846         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3847             /* check for non-increasing dts */
3848             if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3849                 st->internal->info->fps_last_dts >= pkt->dts) {
3850                 av_log(ic, AV_LOG_DEBUG,
3851                        "Non-increasing DTS in stream %d: packet %d with DTS "
3852                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3853                        st->index, st->internal->info->fps_last_dts_idx,
3854                        st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3855                        pkt->dts);
3856                 st->internal->info->fps_first_dts =
3857                 st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
3858             }
3859             /* Check for a discontinuity in dts. If the difference in dts
3860              * is more than 1000 times the average packet duration in the
3861              * sequence, we treat it as a discontinuity. */
3862             if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3863                 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3864                 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3865                 (st->internal->info->fps_last_dts     - (uint64_t)st->internal->info->fps_first_dts) /
3866                 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3867                 av_log(ic, AV_LOG_WARNING,
3868                        "DTS discontinuity in stream %d: packet %d with DTS "
3869                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3870                        st->index, st->internal->info->fps_last_dts_idx,
3871                        st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3872                        pkt->dts);
3873                 st->internal->info->fps_first_dts =
3874                 st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
3875             }
3876
3877             /* update stored dts values */
3878             if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3879                 st->internal->info->fps_first_dts     = pkt->dts;
3880                 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3881             }
3882             st->internal->info->fps_last_dts     = pkt->dts;
3883             st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3884         }
3885         if (st->codec_info_nb_frames>1) {
3886             int64_t t = 0;
3887             int64_t limit;
3888
3889             if (st->time_base.den > 0)
3890                 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3891             if (st->avg_frame_rate.num > 0)
3892                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3893
3894             if (   t == 0
3895                 && st->codec_info_nb_frames>30
3896                 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3897                 && st->internal->info->fps_last_dts  != AV_NOPTS_VALUE) {
3898                 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3899                 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3900             }
3901
3902             if (analyzed_all_streams)                                limit = max_analyze_duration;
3903             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3904             else                                                     limit = max_stream_analyze_duration;
3905
3906             if (t >= limit) {
3907                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3908                        limit,
3909                        t, pkt->stream_index);
3910                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3911                     av_packet_unref(pkt1);
3912                 break;
3913             }
3914             if (pkt->duration) {
3915                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3916                     st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3917                 } else
3918                     st->internal->info->codec_info_duration += pkt->duration;
3919                 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3920             }
3921         }
3922         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3923 #if FF_API_R_FRAME_RATE
3924             ff_rfps_add_frame(ic, st, pkt->dts);
3925 #endif
3926             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3927                 st->internal->info->frame_delay_evidence = 1;
3928         }
3929         if (!st->internal->avctx->extradata) {
3930             ret = extract_extradata(st, pkt);
3931             if (ret < 0)
3932                 goto unref_then_goto_end;
3933         }
3934
3935         /* If still no information, we try to open the codec and to
3936          * decompress the frame. We try to avoid that in most cases as
3937          * it takes longer and uses more memory. For MPEG-4, we need to
3938          * decompress for QuickTime.
3939          *
3940          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3941          * least one frame of codec data, this makes sure the codec initializes
3942          * the channel configuration and does not only trust the values from
3943          * the container. */
3944         try_decode_frame(ic, st, pkt,
3945                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3946
3947         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3948             av_packet_unref(pkt1);
3949
3950         st->codec_info_nb_frames++;
3951         count++;
3952     }
3953
3954     if (eof_reached) {
3955         int stream_index;
3956         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3957             st = ic->streams[stream_index];
3958             avctx = st->internal->avctx;
3959             if (!has_codec_parameters(st, NULL)) {
3960                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3961                 if (codec && !avctx->codec) {
3962                     AVDictionary *opts = NULL;
3963                     if (ic->codec_whitelist)
3964                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3965                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3966                         av_log(ic, AV_LOG_WARNING,
3967                                "Failed to open codec in %s\n",__FUNCTION__);
3968                     av_dict_free(&opts);
3969                 }
3970             }
3971
3972             // EOF already reached while reading the stream above.
3973             // So continue with reoordering DTS with whatever delay we have.
3974             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3975                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3976             }
3977         }
3978     }
3979
3980     if (flush_codecs) {
3981         AVPacket *empty_pkt = ic->internal->pkt;
3982         int err = 0;
3983         av_packet_unref(empty_pkt);
3984
3985         for (i = 0; i < ic->nb_streams; i++) {
3986
3987             st = ic->streams[i];
3988
3989             /* flush the decoders */
3990             if (st->internal->info->found_decoder == 1) {
3991                 do {
3992                     err = try_decode_frame(ic, st, empty_pkt,
3993                                             (options && i < orig_nb_streams)
3994                                             ? &options[i] : NULL);
3995                 } while (err > 0 && !has_codec_parameters(st, NULL));
3996
3997                 if (err < 0) {
3998                     av_log(ic, AV_LOG_INFO,
3999                         "decoding for stream %d failed\n", st->index);
4000                 }
4001             }
4002         }
4003     }
4004
4005     ff_rfps_calculate(ic);
4006
4007     for (i = 0; i < ic->nb_streams; i++) {
4008         st = ic->streams[i];
4009         avctx = st->internal->avctx;
4010         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4011             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4012                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4013                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4014                     avctx->codec_tag= tag;
4015             }
4016
4017             /* estimate average framerate if not set by demuxer */
4018             if (st->internal->info->codec_info_duration_fields &&
4019                 !st->avg_frame_rate.num &&
4020                 st->internal->info->codec_info_duration) {
4021                 int best_fps      = 0;
4022                 double best_error = 0.01;
4023                 AVRational codec_frame_rate = avctx->framerate;
4024
4025                 if (st->internal->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
4026                     st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4027                     st->internal->info->codec_info_duration        < 0)
4028                     continue;
4029                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4030                           st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4031                           st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4032
4033                 /* Round guessed framerate to a "standard" framerate if it's
4034                  * within 1% of the original estimate. */
4035                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4036                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4037                     double error       = fabs(av_q2d(st->avg_frame_rate) /
4038                                               av_q2d(std_fps) - 1);
4039
4040                     if (error < best_error) {
4041                         best_error = error;
4042                         best_fps   = std_fps.num;
4043                     }
4044
4045                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4046                         error       = fabs(av_q2d(codec_frame_rate) /
4047                                            av_q2d(std_fps) - 1);
4048                         if (error < best_error) {
4049                             best_error = error;
4050                             best_fps   = std_fps.num;
4051                         }
4052                     }
4053                 }
4054                 if (best_fps)
4055                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4056                               best_fps, 12 * 1001, INT_MAX);
4057             }
4058
4059             if (!st->r_frame_rate.num) {
4060                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4061                     <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4062                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4063                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4064                 } else {
4065                     st->r_frame_rate.num = st->time_base.den;
4066                     st->r_frame_rate.den = st->time_base.num;
4067                 }
4068             }
4069             if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4070                 AVRational hw_ratio = { avctx->height, avctx->width };
4071                 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4072                                                    hw_ratio);
4073             }
4074         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4075             if (!avctx->bits_per_coded_sample)
4076                 avctx->bits_per_coded_sample =
4077                     av_get_bits_per_sample(avctx->codec_id);
4078             // set stream disposition based on audio service type
4079             switch (avctx->audio_service_type) {
4080             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4081                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4082                 break;
4083             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4084                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4085                 break;
4086             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4087                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4088                 break;
4089             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4090                 st->disposition = AV_DISPOSITION_COMMENT;
4091                 break;
4092             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4093                 st->disposition = AV_DISPOSITION_KARAOKE;
4094                 break;
4095             }
4096         }
4097     }
4098
4099     if (probesize)
4100         estimate_timings(ic, old_offset);
4101
4102     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4103
4104     if (ret >= 0 && ic->nb_streams)
4105         /* We could not have all the codec parameters before EOF. */
4106         ret = -1;
4107     for (i = 0; i < ic->nb_streams; i++) {
4108         const char *errmsg;
4109         st = ic->streams[i];
4110
4111         /* if no packet was ever seen, update context now for has_codec_parameters */
4112         if (!st->internal->avctx_inited) {
4113             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4114                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4115                 st->codecpar->format = st->internal->avctx->sample_fmt;
4116             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4117             if (ret < 0)
4118                 goto find_stream_info_err;
4119         }
4120         if (!has_codec_parameters(st, &errmsg)) {
4121             char buf[256];
4122             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4123             av_log(ic, AV_LOG_WARNING,
4124                    "Could not find codec parameters for stream %d (%s): %s\n"
4125                    "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4126                    i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4127         } else {
4128             ret = 0;
4129         }
4130     }
4131
4132     ret = compute_chapters_end(ic);
4133     if (ret < 0)
4134         goto find_stream_info_err;
4135
4136     /* update the stream parameters from the internal codec contexts */
4137     for (i = 0; i < ic->nb_streams; i++) {
4138         st = ic->streams[i];
4139
4140         if (st->internal->avctx_inited) {
4141             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4142             if (ret < 0)
4143                 goto find_stream_info_err;
4144             ret = add_coded_side_data(st, st->internal->avctx);
4145             if (ret < 0)
4146                 goto find_stream_info_err;
4147         }
4148
4149 #if FF_API_LAVF_AVCTX
4150 FF_DISABLE_DEPRECATION_WARNINGS
4151         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4152         if (ret < 0)
4153             goto find_stream_info_err;
4154
4155         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4156         // by the lowres factor.
4157         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4158             st->codec->lowres = st->internal->avctx->lowres;
4159             st->codec->width = st->internal->avctx->width;
4160             st->codec->height = st->internal->avctx->height;
4161         }
4162
4163         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4164             st->codec->time_base = st->internal->avctx->time_base;
4165             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4166         }
4167         st->codec->framerate = st->avg_frame_rate;
4168
4169         if (st->internal->avctx->subtitle_header) {
4170             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4171             if (!st->codec->subtitle_header)
4172                 goto find_stream_info_err;
4173             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4174             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4175                    st->codec->subtitle_header_size);
4176         }
4177
4178         // Fields unavailable in AVCodecParameters
4179         st->codec->coded_width = st->internal->avctx->coded_width;
4180         st->codec->coded_height = st->internal->avctx->coded_height;
4181         st->codec->properties = st->internal->avctx->properties;
4182 FF_ENABLE_DEPRECATION_WARNINGS
4183 #endif
4184
4185         st->internal->avctx_inited = 0;
4186     }
4187
4188 find_stream_info_err:
4189     for (i = 0; i < ic->nb_streams; i++) {
4190         st = ic->streams[i];
4191         if (st->internal->info)
4192             av_freep(&st->internal->info->duration_error);
4193         avcodec_close(ic->streams[i]->internal->avctx);
4194         av_freep(&ic->streams[i]->internal->info);
4195         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4196         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4197     }
4198     if (ic->pb)
4199         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4200                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4201     return ret;
4202
4203 unref_then_goto_end:
4204     av_packet_unref(pkt1);
4205     goto find_stream_info_err;
4206 }
4207
4208 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4209 {
4210     int i, j;
4211
4212     for (i = 0; i < ic->nb_programs; i++) {
4213         if (ic->programs[i] == last) {
4214             last = NULL;
4215         } else {
4216             if (!last)
4217                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4218                     if (ic->programs[i]->stream_index[j] == s)
4219                         return ic->programs[i];
4220         }
4221     }
4222     return NULL;
4223 }
4224
4225 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4226                         int wanted_stream_nb, int related_stream,
4227                         AVCodec **decoder_ret, int flags)
4228 {
4229     int i, nb_streams = ic->nb_streams;
4230     int ret = AVERROR_STREAM_NOT_FOUND;
4231     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4232     int count, multiframe, disposition;
4233     int64_t best_bitrate = -1;
4234     int64_t bitrate;
4235     unsigned *program = NULL;
4236     const AVCodec *decoder = NULL, *best_decoder = NULL;
4237
4238     if (related_stream >= 0 && wanted_stream_nb < 0) {
4239         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4240         if (p) {
4241             program    = p->stream_index;
4242             nb_streams = p->nb_stream_indexes;
4243         }
4244     }
4245     for (i = 0; i < nb_streams; i++) {
4246         int real_stream_index = program ? program[i] : i;
4247         AVStream *st          = ic->streams[real_stream_index];
4248         AVCodecParameters *par = st->codecpar;
4249         if (par->codec_type != type)
4250             continue;
4251         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4252             continue;
4253         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4254             continue;
4255         if (decoder_ret) {
4256             decoder = find_decoder(ic, st, par->codec_id);
4257             if (!decoder) {
4258                 if (ret < 0)
4259                     ret = AVERROR_DECODER_NOT_FOUND;
4260                 continue;
4261             }
4262         }
4263         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4264                       + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4265         count = st->codec_info_nb_frames;
4266         bitrate = par->bit_rate;
4267         multiframe = FFMIN(5, count);
4268         if ((best_disposition >  disposition) ||
4269             (best_disposition == disposition && best_multiframe >  multiframe) ||
4270             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4271             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4272             continue;
4273         best_disposition = disposition;
4274         best_count   = count;
4275         best_bitrate = bitrate;
4276         best_multiframe = multiframe;
4277         ret          = real_stream_index;
4278         best_decoder = decoder;
4279         if (program && i == nb_streams - 1 && ret < 0) {
4280             program    = NULL;
4281             nb_streams = ic->nb_streams;
4282             /* no related stream found, try again with everything */
4283             i = 0;
4284         }
4285     }
4286     if (decoder_ret)
4287         *decoder_ret = (AVCodec*)best_decoder;
4288     return ret;
4289 }
4290
4291 /*******************************************************/
4292
4293 int av_read_play(AVFormatContext *s)
4294 {
4295     if (s->iformat->read_play)
4296         return s->iformat->read_play(s);
4297     if (s->pb)
4298         return avio_pause(s->pb, 0);
4299     return AVERROR(ENOSYS);
4300 }
4301
4302 int av_read_pause(AVFormatContext *s)
4303 {
4304     if (s->iformat->read_pause)
4305         return s->iformat->read_pause(s);
4306     if (s->pb)
4307         return avio_pause(s->pb, 1);
4308     return AVERROR(ENOSYS);
4309 }
4310
4311 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4312 {
4313     int ret, i;
4314
4315     dst->id                  = src->id;
4316     dst->time_base           = src->time_base;
4317     dst->nb_frames           = src->nb_frames;
4318     dst->disposition         = src->disposition;
4319     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4320     dst->avg_frame_rate      = src->avg_frame_rate;
4321     dst->r_frame_rate        = src->r_frame_rate;
4322
4323     av_dict_free(&dst->metadata);
4324     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4325     if (ret < 0)
4326         return ret;
4327
4328     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4329     if (ret < 0)
4330         return ret;
4331
4332     /* Free existing side data*/
4333     for (i = 0; i < dst->nb_side_data; i++)
4334         av_free(dst->side_data[i].data);
4335     av_freep(&dst->side_data);
4336     dst->nb_side_data = 0;
4337
4338     /* Copy side data if present */
4339     if (src->nb_side_data) {
4340         dst->side_data = av_mallocz_array(src->nb_side_data,
4341                                           sizeof(AVPacketSideData));
4342         if (!dst->side_data)
4343             return AVERROR(ENOMEM);
4344         dst->nb_side_data = src->nb_side_data;
4345
4346         for (i = 0; i < src->nb_side_data; i++) {
4347             uint8_t *data = av_memdup(src->side_data[i].data,
4348                                       src->side_data[i].size);
4349             if (!data)
4350                 return AVERROR(ENOMEM);
4351             dst->side_data[i].type = src->side_data[i].type;
4352             dst->side_data[i].size = src->side_data[i].size;
4353             dst->side_data[i].data = data;
4354         }
4355     }
4356
4357 #if FF_API_LAVF_FFSERVER
4358 FF_DISABLE_DEPRECATION_WARNINGS
4359     av_freep(&dst->recommended_encoder_configuration);
4360     if (src->recommended_encoder_configuration) {
4361         const char *conf_str = src->recommended_encoder_configuration;
4362         dst->recommended_encoder_configuration = av_strdup(conf_str);
4363         if (!dst->recommended_encoder_configuration)
4364             return AVERROR(ENOMEM);
4365     }
4366 FF_ENABLE_DEPRECATION_WARNINGS
4367 #endif
4368
4369     return 0;
4370 }
4371
4372 static void free_stream(AVStream **pst)
4373 {
4374     AVStream *st = *pst;
4375     int i;
4376
4377     if (!st)
4378         return;
4379
4380     for (i = 0; i < st->nb_side_data; i++)
4381         av_freep(&st->side_data[i].data);
4382     av_freep(&st->side_data);
4383
4384     if (st->parser)
4385         av_parser_close(st->parser);
4386
4387     if (st->attached_pic.data)
4388         av_packet_unref(&st->attached_pic);
4389
4390     if (st->internal) {
4391         avcodec_free_context(&st->internal->avctx);
4392         av_bsf_free(&st->internal->bsfc);
4393         av_freep(&st->internal->priv_pts);
4394         av_freep(&st->internal->index_entries);
4395         av_freep(&st->internal->probe_data.buf);
4396
4397         av_bsf_free(&st->internal->extract_extradata.bsf);
4398         av_packet_free(&st->internal->extract_extradata.pkt);
4399
4400         if (st->internal->info)
4401             av_freep(&st->internal->info->duration_error);
4402         av_freep(&st->internal->info);
4403     }
4404     av_freep(&st->internal);
4405
4406     av_dict_free(&st->metadata);
4407     avcodec_parameters_free(&st->codecpar);
4408 #if FF_API_LAVF_AVCTX
4409 FF_DISABLE_DEPRECATION_WARNINGS
4410     avcodec_free_context(&st->codec);
4411 FF_ENABLE_DEPRECATION_WARNINGS
4412 #endif
4413     av_freep(&st->priv_data);
4414 #if FF_API_LAVF_FFSERVER
4415 FF_DISABLE_DEPRECATION_WARNINGS
4416     av_freep(&st->recommended_encoder_configuration);
4417 FF_ENABLE_DEPRECATION_WARNINGS
4418 #endif
4419
4420     av_freep(pst);
4421 }
4422
4423 void ff_free_stream(AVFormatContext *s, AVStream *st)
4424 {
4425     av_assert0(s->nb_streams>0);
4426     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4427
4428     free_stream(&s->streams[ --s->nb_streams ]);
4429 }
4430
4431 void avformat_free_context(AVFormatContext *s)
4432 {
4433     int i;
4434
4435     if (!s)
4436         return;
4437
4438     if (s->oformat && s->oformat->deinit && s->internal->initialized)
4439         s->oformat->deinit(s);
4440
4441     av_opt_free(s);
4442     if (s->iformat && s->iformat->priv_class && s->priv_data)
4443         av_opt_free(s->priv_data);
4444     if (s->oformat && s->oformat->priv_class && s->priv_data)
4445         av_opt_free(s->priv_data);
4446
4447     for (i = 0; i < s->nb_streams; i++)
4448         free_stream(&s->streams[i]);
4449     s->nb_streams = 0;
4450
4451     for (i = 0; i < s->nb_programs; i++) {
4452         av_dict_free(&s->programs[i]->metadata);
4453         av_freep(&s->programs[i]->stream_index);
4454         av_freep(&s->programs[i]);
4455     }
4456     s->nb_programs = 0;
4457
4458     av_freep(&s->programs);
4459     av_freep(&s->priv_data);
4460     while (s->nb_chapters--) {
4461         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4462         av_freep(&s->chapters[s->nb_chapters]);
4463     }
4464     av_freep(&s->chapters);
4465     av_dict_free(&s->metadata);
4466     av_dict_free(&s->internal->id3v2_meta);
4467     av_packet_free(&s->internal->pkt);
4468     av_packet_free(&s->internal->parse_pkt);
4469     av_freep(&s->streams);
4470     flush_packet_queue(s);
4471     av_freep(&s->internal);
4472     av_freep(&s->url);
4473     av_free(s);
4474 }
4475
4476 void avformat_close_input(AVFormatContext **ps)
4477 {
4478     AVFormatContext *s;
4479     AVIOContext *pb;
4480
4481     if (!ps || !*ps)
4482         return;
4483
4484     s  = *ps;
4485     pb = s->pb;
4486
4487     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4488         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4489         pb = NULL;
4490
4491     flush_packet_queue(s);
4492
4493     if (s->iformat)
4494         if (s->iformat->read_close)
4495             s->iformat->read_close(s);
4496
4497     avformat_free_context(s);
4498
4499     *ps = NULL;
4500
4501     avio_close(pb);
4502 }
4503
4504 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4505 {
4506     AVStream *st;
4507     int i;
4508     AVStream **streams;
4509
4510     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4511         if (s->max_streams < INT_MAX/sizeof(*streams))
4512             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);
4513         return NULL;
4514     }
4515     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4516     if (!streams)
4517         return NULL;
4518     s->streams = streams;
4519
4520     st = av_mallocz(sizeof(AVStream));
4521     if (!st)
4522         return NULL;
4523
4524 #if FF_API_LAVF_AVCTX
4525 FF_DISABLE_DEPRECATION_WARNINGS
4526     st->codec = avcodec_alloc_context3(c);
4527     if (!st->codec) {
4528         av_free(st);
4529         return NULL;
4530     }
4531 FF_ENABLE_DEPRECATION_WARNINGS
4532 #endif
4533
4534     st->internal = av_mallocz(sizeof(*st->internal));
4535     if (!st->internal)
4536         goto fail;
4537
4538     st->internal->info = av_mallocz(sizeof(*st->internal->info));
4539     if (!st->internal->info)
4540         goto fail;
4541     st->internal->info->last_dts = AV_NOPTS_VALUE;
4542
4543     st->codecpar = avcodec_parameters_alloc();
4544     if (!st->codecpar)
4545         goto fail;
4546
4547     st->internal->avctx = avcodec_alloc_context3(NULL);
4548     if (!st->internal->avctx)
4549         goto fail;
4550
4551     if (s->iformat) {
4552 #if FF_API_LAVF_AVCTX
4553 FF_DISABLE_DEPRECATION_WARNINGS
4554         /* no default bitrate if decoding */
4555         st->codec->bit_rate = 0;
4556 FF_ENABLE_DEPRECATION_WARNINGS
4557 #endif
4558
4559         /* default pts setting is MPEG-like */
4560         avpriv_set_pts_info(st, 33, 1, 90000);
4561         /* we set the current DTS to 0 so that formats without any timestamps
4562          * but durations get some timestamps, formats with some unknown
4563          * timestamps have their first few packets buffered and the
4564          * timestamps corrected before they are returned to the user */
4565         st->cur_dts = RELATIVE_TS_BASE;
4566     } else {
4567         st->cur_dts = AV_NOPTS_VALUE;
4568     }
4569
4570     st->index      = s->nb_streams;
4571     st->start_time = AV_NOPTS_VALUE;
4572     st->duration   = AV_NOPTS_VALUE;
4573     st->first_dts     = AV_NOPTS_VALUE;
4574     st->probe_packets = s->max_probe_packets;
4575     st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4576     st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4577
4578     st->last_IP_pts = AV_NOPTS_VALUE;
4579     st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4580     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4581         st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4582
4583     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4584
4585 #if FF_API_R_FRAME_RATE
4586     st->internal->info->last_dts      = AV_NOPTS_VALUE;
4587 #endif
4588     st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4589     st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
4590
4591     st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4592
4593     st->internal->need_context_update = 1;
4594
4595     s->streams[s->nb_streams++] = st;
4596     return st;
4597 fail:
4598     free_stream(&st);
4599     return NULL;
4600 }
4601
4602 AVProgram *av_new_program(AVFormatContext *ac, int id)
4603 {
4604     AVProgram *program = NULL;
4605     int i;
4606
4607     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4608
4609     for (i = 0; i < ac->nb_programs; i++)
4610         if (ac->programs[i]->id == id)
4611             program = ac->programs[i];
4612
4613     if (!program) {
4614         program = av_mallocz(sizeof(AVProgram));
4615         if (!program)
4616             return NULL;
4617         dynarray_add(&ac->programs, &ac->nb_programs, program);
4618         program->discard = AVDISCARD_NONE;
4619         program->pmt_version = -1;
4620         program->id = id;
4621         program->pts_wrap_reference = AV_NOPTS_VALUE;
4622         program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4623         program->start_time =
4624         program->end_time   = AV_NOPTS_VALUE;
4625     }
4626     return program;
4627 }
4628
4629 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4630                               int64_t start, int64_t end, const char *title)
4631 {
4632     AVChapter *chapter = NULL;
4633     int i;
4634
4635     if (end != AV_NOPTS_VALUE && start > end) {
4636         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4637         return NULL;
4638     }
4639
4640     if (!s->nb_chapters) {
4641         s->internal->chapter_ids_monotonic = 1;
4642     } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4643         s->internal->chapter_ids_monotonic = 0;
4644         for (i = 0; i < s->nb_chapters; i++)
4645             if (s->chapters[i]->id == id)
4646                 chapter = s->chapters[i];
4647     }
4648
4649     if (!chapter) {
4650         chapter = av_mallocz(sizeof(AVChapter));
4651         if (!chapter)
4652             return NULL;
4653         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4654     }
4655     av_dict_set(&chapter->metadata, "title", title, 0);
4656     chapter->id        = id;
4657     chapter->time_base = time_base;
4658     chapter->start     = start;
4659     chapter->end       = end;
4660
4661     return chapter;
4662 }
4663
4664 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4665 {
4666     int i, j;
4667     AVProgram *program = NULL;
4668     void *tmp;
4669
4670     if (idx >= ac->nb_streams) {
4671         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4672         return;
4673     }
4674
4675     for (i = 0; i < ac->nb_programs; i++) {
4676         if (ac->programs[i]->id != progid)
4677             continue;
4678         program = ac->programs[i];
4679         for (j = 0; j < program->nb_stream_indexes; j++)
4680             if (program->stream_index[j] == idx)
4681                 return;
4682
4683         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4684         if (!tmp)
4685             return;
4686         program->stream_index = tmp;
4687         program->stream_index[program->nb_stream_indexes++] = idx;
4688         return;
4689     }
4690 }
4691
4692 uint64_t ff_ntp_time(void)
4693 {
4694     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4695 }
4696
4697 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4698 {
4699     uint64_t ntp_ts, frac_part, sec;
4700     uint32_t usec;
4701
4702     //current ntp time in seconds and micro seconds
4703     sec = ntp_time_us / 1000000;
4704     usec = ntp_time_us % 1000000;
4705
4706     //encoding in ntp timestamp format
4707     frac_part = usec * 0xFFFFFFFFULL;
4708     frac_part /= 1000000;
4709
4710     if (sec > 0xFFFFFFFFULL)
4711         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4712
4713     ntp_ts = sec << 32;
4714     ntp_ts |= frac_part;
4715
4716     return ntp_ts;
4717 }
4718
4719 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4720 {
4721     const char *p;
4722     char *q, buf1[20], c;
4723     int nd, len, percentd_found;
4724
4725     q = buf;
4726     p = path;
4727     percentd_found = 0;
4728     for (;;) {
4729         c = *p++;
4730         if (c == '\0')
4731             break;
4732         if (c == '%') {
4733             do {
4734                 nd = 0;
4735                 while (av_isdigit(*p)) {
4736                     if (nd >= INT_MAX / 10 - 255)
4737                         goto fail;
4738                     nd = nd * 10 + *p++ - '0';
4739                 }
4740                 c = *p++;
4741             } while (av_isdigit(c));
4742
4743             switch (c) {
4744             case '%':
4745                 goto addchar;
4746             case 'd':
4747                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4748                     goto fail;
4749                 percentd_found = 1;
4750                 if (number < 0)
4751                     nd += 1;
4752                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4753                 len = strlen(buf1);
4754                 if ((q - buf + len) > buf_size - 1)
4755                     goto fail;
4756                 memcpy(q, buf1, len);
4757                 q += len;
4758                 break;
4759             default:
4760                 goto fail;
4761             }
4762         } else {
4763 addchar:
4764             if ((q - buf) < buf_size - 1)
4765                 *q++ = c;
4766         }
4767     }
4768     if (!percentd_found)
4769         goto fail;
4770     *q = '\0';
4771     return 0;
4772 fail:
4773     *q = '\0';
4774     return -1;
4775 }
4776
4777 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4778 {
4779     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4780 }
4781
4782 void av_url_split(char *proto, int proto_size,
4783                   char *authorization, int authorization_size,
4784                   char *hostname, int hostname_size,
4785                   int *port_ptr, char *path, int path_size, const char *url)
4786 {
4787     const char *p, *ls, *at, *at2, *col, *brk;
4788
4789     if (port_ptr)
4790         *port_ptr = -1;
4791     if (proto_size > 0)
4792         proto[0] = 0;
4793     if (authorization_size > 0)
4794         authorization[0] = 0;
4795     if (hostname_size > 0)
4796         hostname[0] = 0;
4797     if (path_size > 0)
4798         path[0] = 0;
4799
4800     /* parse protocol */
4801     if ((p = strchr(url, ':'))) {
4802         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4803         p++; /* skip ':' */
4804         if (*p == '/')
4805             p++;
4806         if (*p == '/')
4807             p++;
4808     } else {
4809         /* no protocol means plain filename */
4810         av_strlcpy(path, url, path_size);
4811         return;
4812     }
4813
4814     /* separate path from hostname */
4815     ls = p + strcspn(p, "/?#");
4816     av_strlcpy(path, ls, path_size);
4817
4818     /* the rest is hostname, use that to parse auth/port */
4819     if (ls != p) {
4820         /* authorization (user[:pass]@hostname) */
4821         at2 = p;
4822         while ((at = strchr(p, '@')) && at < ls) {
4823             av_strlcpy(authorization, at2,
4824                        FFMIN(authorization_size, at + 1 - at2));
4825             p = at + 1; /* skip '@' */
4826         }
4827
4828         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4829             /* [host]:port */
4830             av_strlcpy(hostname, p + 1,
4831                        FFMIN(hostname_size, brk - p));
4832             if (brk[1] == ':' && port_ptr)
4833                 *port_ptr = atoi(brk + 2);
4834         } else if ((col = strchr(p, ':')) && col < ls) {
4835             av_strlcpy(hostname, p,
4836                        FFMIN(col + 1 - p, hostname_size));
4837             if (port_ptr)
4838                 *port_ptr = atoi(col + 1);
4839         } else
4840             av_strlcpy(hostname, p,
4841                        FFMIN(ls + 1 - p, hostname_size));
4842     }
4843 }
4844
4845 int ff_mkdir_p(const char *path)
4846 {
4847     int ret = 0;
4848     char *temp = av_strdup(path);
4849     char *pos = temp;
4850     char tmp_ch = '\0';
4851
4852     if (!path || !temp) {
4853         return -1;
4854     }
4855
4856     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4857         pos++;
4858     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4859         pos += 2;
4860     }
4861
4862     for ( ; *pos != '\0'; ++pos) {
4863         if (*pos == '/' || *pos == '\\') {
4864             tmp_ch = *pos;
4865             *pos = '\0';
4866             ret = mkdir(temp, 0755);
4867             *pos = tmp_ch;
4868         }
4869     }
4870
4871     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4872         ret = mkdir(temp, 0755);
4873     }
4874
4875     av_free(temp);
4876     return ret;
4877 }
4878
4879 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4880 {
4881     int i;
4882     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4883                                            '4', '5', '6', '7',
4884                                            '8', '9', 'A', 'B',
4885                                            'C', 'D', 'E', 'F' };
4886     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4887                                            '4', '5', '6', '7',
4888                                            '8', '9', 'a', 'b',
4889                                            'c', 'd', 'e', 'f' };
4890     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4891
4892     for (i = 0; i < s; i++) {
4893         buff[i * 2]     = hex_table[src[i] >> 4];
4894         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4895     }
4896
4897     return buff;
4898 }
4899
4900 int ff_hex_to_data(uint8_t *data, const char *p)
4901 {
4902     int c, len, v;
4903
4904     len = 0;
4905     v   = 1;
4906     for (;;) {
4907         p += strspn(p, SPACE_CHARS);
4908         if (*p == '\0')
4909             break;
4910         c = av_toupper((unsigned char) *p++);
4911         if (c >= '0' && c <= '9')
4912             c = c - '0';
4913         else if (c >= 'A' && c <= 'F')
4914             c = c - 'A' + 10;
4915         else
4916             break;
4917         v = (v << 4) | c;
4918         if (v & 0x100) {
4919             if (data)
4920                 data[len] = v;
4921             len++;
4922             v = 1;
4923         }
4924     }
4925     return len;
4926 }
4927
4928 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4929                          unsigned int pts_num, unsigned int pts_den)
4930 {
4931     AVRational new_tb;
4932     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4933         if (new_tb.num != pts_num)
4934             av_log(NULL, AV_LOG_DEBUG,
4935                    "st:%d removing common factor %d from timebase\n",
4936                    s->index, pts_num / new_tb.num);
4937     } else
4938         av_log(NULL, AV_LOG_WARNING,
4939                "st:%d has too large timebase, reducing\n", s->index);
4940
4941     if (new_tb.num <= 0 || new_tb.den <= 0) {
4942         av_log(NULL, AV_LOG_ERROR,
4943                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4944                new_tb.num, new_tb.den,
4945                s->index);
4946         return;
4947     }
4948     s->time_base     = new_tb;
4949 #if FF_API_LAVF_AVCTX
4950 FF_DISABLE_DEPRECATION_WARNINGS
4951     s->codec->pkt_timebase = new_tb;
4952 FF_ENABLE_DEPRECATION_WARNINGS
4953 #endif
4954     s->internal->avctx->pkt_timebase = new_tb;
4955     s->pts_wrap_bits = pts_wrap_bits;
4956 }
4957
4958 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4959                         void *context)
4960 {
4961     const char *ptr = str;
4962
4963     /* Parse key=value pairs. */
4964     for (;;) {
4965         const char *key;
4966         char *dest = NULL, *dest_end;
4967         int key_len, dest_len = 0;
4968
4969         /* Skip whitespace and potential commas. */
4970         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4971             ptr++;
4972         if (!*ptr)
4973             break;
4974
4975         key = ptr;
4976
4977         if (!(ptr = strchr(key, '=')))
4978             break;
4979         ptr++;
4980         key_len = ptr - key;
4981
4982         callback_get_buf(context, key, key_len, &dest, &dest_len);
4983         dest_end = dest + dest_len - 1;
4984
4985         if (*ptr == '\"') {
4986             ptr++;
4987             while (*ptr && *ptr != '\"') {
4988                 if (*ptr == '\\') {
4989                     if (!ptr[1])
4990                         break;
4991                     if (dest && dest < dest_end)
4992                         *dest++ = ptr[1];
4993                     ptr += 2;
4994                 } else {
4995                     if (dest && dest < dest_end)
4996                         *dest++ = *ptr;
4997                     ptr++;
4998                 }
4999             }
5000             if (*ptr == '\"')
5001                 ptr++;
5002         } else {
5003             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5004                 if (dest && dest < dest_end)
5005                     *dest++ = *ptr;
5006         }
5007         if (dest)
5008             *dest = 0;
5009     }
5010 }
5011
5012 int ff_find_stream_index(AVFormatContext *s, int id)
5013 {
5014     int i;
5015     for (i = 0; i < s->nb_streams; i++)
5016         if (s->streams[i]->id == id)
5017             return i;
5018     return -1;
5019 }
5020
5021 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5022                          int std_compliance)
5023 {
5024     if (ofmt) {
5025         unsigned int codec_tag;
5026         if (ofmt->query_codec)
5027             return ofmt->query_codec(codec_id, std_compliance);
5028         else if (ofmt->codec_tag)
5029             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5030         else if (codec_id == ofmt->video_codec ||
5031                  codec_id == ofmt->audio_codec ||
5032                  codec_id == ofmt->subtitle_codec ||
5033                  codec_id == ofmt->data_codec)
5034             return 1;
5035     }
5036     return AVERROR_PATCHWELCOME;
5037 }
5038
5039 int avformat_network_init(void)
5040 {
5041 #if CONFIG_NETWORK
5042     int ret;
5043     if ((ret = ff_network_init()) < 0)
5044         return ret;
5045     if ((ret = ff_tls_init()) < 0)
5046         return ret;
5047 #endif
5048     return 0;
5049 }
5050
5051 int avformat_network_deinit(void)
5052 {
5053 #if CONFIG_NETWORK
5054     ff_network_close();
5055     ff_tls_deinit();
5056 #endif
5057     return 0;
5058 }
5059
5060 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5061                         uint64_t channel_layout, int32_t sample_rate,
5062                         int32_t width, int32_t height)
5063 {
5064     uint32_t flags = 0;
5065     int size = 4;
5066     uint8_t *data;
5067     if (!pkt)
5068         return AVERROR(EINVAL);
5069     if (channels) {
5070         size  += 4;
5071         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5072     }
5073     if (channel_layout) {
5074         size  += 8;
5075         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5076     }
5077     if (sample_rate) {
5078         size  += 4;
5079         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5080     }
5081     if (width || height) {
5082         size  += 8;
5083         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5084     }
5085     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5086     if (!data)
5087         return AVERROR(ENOMEM);
5088     bytestream_put_le32(&data, flags);
5089     if (channels)
5090         bytestream_put_le32(&data, channels);
5091     if (channel_layout)
5092         bytestream_put_le64(&data, channel_layout);
5093     if (sample_rate)
5094         bytestream_put_le32(&data, sample_rate);
5095     if (width || height) {
5096         bytestream_put_le32(&data, width);
5097         bytestream_put_le32(&data, height);
5098     }
5099     return 0;
5100 }
5101
5102 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5103 {
5104     AVRational undef = {0, 1};
5105     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5106     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5107     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5108
5109     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5110                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5111     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5112         stream_sample_aspect_ratio = undef;
5113
5114     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5115                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5116     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5117         frame_sample_aspect_ratio = undef;
5118
5119     if (stream_sample_aspect_ratio.num)
5120         return stream_sample_aspect_ratio;
5121     else
5122         return frame_sample_aspect_ratio;
5123 }
5124
5125 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5126 {
5127     AVRational fr = st->r_frame_rate;
5128     AVRational codec_fr = st->internal->avctx->framerate;
5129     AVRational   avg_fr = st->avg_frame_rate;
5130
5131     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5132         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5133         fr = avg_fr;
5134     }
5135
5136
5137     if (st->internal->avctx->ticks_per_frame > 1) {
5138         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5139             (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))
5140             fr = codec_fr;
5141     }
5142
5143     return fr;
5144 }
5145
5146 /**
5147  * Matches a stream specifier (but ignores requested index).
5148  *
5149  * @param indexptr set to point to the requested stream index if there is one
5150  *
5151  * @return <0 on error
5152  *         0  if st is NOT a matching stream
5153  *         >0 if st is a matching stream
5154  */
5155 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5156                                   const char *spec, const char **indexptr, AVProgram **p)
5157 {
5158     int match = 1;                      /* Stores if the specifier matches so far. */
5159     while (*spec) {
5160         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5161             if (indexptr)
5162                 *indexptr = spec;
5163             return match;
5164         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5165                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5166             enum AVMediaType type;
5167             int nopic = 0;
5168
5169             switch (*spec++) {
5170             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5171             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5172             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5173             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5174             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5175             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5176             default:  av_assert0(0);
5177             }
5178             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5179                 return AVERROR(EINVAL);
5180
5181 #if FF_API_LAVF_AVCTX
5182 FF_DISABLE_DEPRECATION_WARNINGS
5183             if (type != st->codecpar->codec_type
5184                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5185                 match = 0;
5186     FF_ENABLE_DEPRECATION_WARNINGS
5187 #else
5188             if (type != st->codecpar->codec_type)
5189                 match = 0;
5190 #endif
5191             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5192                 match = 0;
5193         } else if (*spec == 'p' && *(spec + 1) == ':') {
5194             int prog_id, i, j;
5195             int found = 0;
5196             char *endptr;
5197             spec += 2;
5198             prog_id = strtol(spec, &endptr, 0);
5199             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5200             if (spec == endptr || (*endptr && *endptr++ != ':'))
5201                 return AVERROR(EINVAL);
5202             spec = endptr;
5203             if (match) {
5204                 for (i = 0; i < s->nb_programs; i++) {
5205                     if (s->programs[i]->id != prog_id)
5206                         continue;
5207
5208                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5209                         if (st->index == s->programs[i]->stream_index[j]) {
5210                             found = 1;
5211                             if (p)
5212                                 *p = s->programs[i];
5213                             i = s->nb_programs;
5214                             break;
5215                         }
5216                     }
5217                 }
5218             }
5219             if (!found)
5220                 match = 0;
5221         } else if (*spec == '#' ||
5222                    (*spec == 'i' && *(spec + 1) == ':')) {
5223             int stream_id;
5224             char *endptr;
5225             spec += 1 + (*spec == 'i');
5226             stream_id = strtol(spec, &endptr, 0);
5227             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5228                 return AVERROR(EINVAL);
5229             return match && (stream_id == st->id);
5230         } else if (*spec == 'm' && *(spec + 1) == ':') {
5231             AVDictionaryEntry *tag;
5232             char *key, *val;
5233             int ret;
5234
5235             if (match) {
5236                spec += 2;
5237                val = strchr(spec, ':');
5238
5239                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5240                if (!key)
5241                    return AVERROR(ENOMEM);
5242
5243                tag = av_dict_get(st->metadata, key, NULL, 0);
5244                if (tag) {
5245                    if (!val || !strcmp(tag->value, val + 1))
5246                        ret = 1;
5247                    else
5248                        ret = 0;
5249                } else
5250                    ret = 0;
5251
5252                av_freep(&key);
5253             }
5254             return match && ret;
5255         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5256             AVCodecParameters *par = st->codecpar;
5257 #if FF_API_LAVF_AVCTX
5258 FF_DISABLE_DEPRECATION_WARNINGS
5259             AVCodecContext *codec = st->codec;
5260 FF_ENABLE_DEPRECATION_WARNINGS
5261 #endif
5262             int val;
5263             switch (par->codec_type) {
5264             case AVMEDIA_TYPE_AUDIO:
5265                 val = par->sample_rate && par->channels;
5266 #if FF_API_LAVF_AVCTX
5267                 val = val || (codec->sample_rate && codec->channels);
5268 #endif
5269                 if (par->format == AV_SAMPLE_FMT_NONE
5270 #if FF_API_LAVF_AVCTX
5271                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5272 #endif
5273                     )
5274                     return 0;
5275                 break;
5276             case AVMEDIA_TYPE_VIDEO:
5277                 val = par->width && par->height;
5278 #if FF_API_LAVF_AVCTX
5279                 val = val || (codec->width && codec->height);
5280 #endif
5281                 if (par->format == AV_PIX_FMT_NONE
5282 #if FF_API_LAVF_AVCTX
5283                     && codec->pix_fmt == AV_PIX_FMT_NONE
5284 #endif
5285                     )
5286                     return 0;
5287                 break;
5288             case AVMEDIA_TYPE_UNKNOWN:
5289                 val = 0;
5290                 break;
5291             default:
5292                 val = 1;
5293                 break;
5294             }
5295 #if FF_API_LAVF_AVCTX
5296             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5297 #else
5298             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5299 #endif
5300         } else {
5301             return AVERROR(EINVAL);
5302         }
5303     }
5304
5305     return match;
5306 }
5307
5308
5309 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5310                                     const char *spec)
5311 {
5312     int ret, index;
5313     char *endptr;
5314     const char *indexptr = NULL;
5315     AVProgram *p = NULL;
5316     int nb_streams;
5317
5318     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5319     if (ret < 0)
5320         goto error;
5321
5322     if (!indexptr)
5323         return ret;
5324
5325     index = strtol(indexptr, &endptr, 0);
5326     if (*endptr) {                  /* We can't have anything after the requested index. */
5327         ret = AVERROR(EINVAL);
5328         goto error;
5329     }
5330
5331     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5332     if (spec == indexptr)
5333         return (index == st->index);
5334
5335     /* If we requested a matching stream index, we have to ensure st is that. */
5336     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5337     for (int i = 0; i < nb_streams && index >= 0; i++) {
5338         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5339         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5340         if (ret < 0)
5341             goto error;
5342         if (ret > 0 && index-- == 0 && st == candidate)
5343             return 1;
5344     }
5345     return 0;
5346
5347 error:
5348     if (ret == AVERROR(EINVAL))
5349         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5350     return ret;
5351 }
5352
5353 int ff_generate_avci_extradata(AVStream *st)
5354 {
5355     static const uint8_t avci100_1080p_extradata[] = {
5356         // SPS
5357         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5358         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5359         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5360         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5361         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5362         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5363         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5364         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5365         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5366         // PPS
5367         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5368         0xd0
5369     };
5370     static const uint8_t avci100_1080i_extradata[] = {
5371         // SPS
5372         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5373         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5374         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5375         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5376         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5377         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5378         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5379         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5380         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5381         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5382         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5383         // PPS
5384         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5385         0xd0
5386     };
5387     static const uint8_t avci50_1080p_extradata[] = {
5388         // SPS
5389         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5390         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5391         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5392         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5393         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5394         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5395         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5396         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5397         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5398         // PPS
5399         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5400         0x11
5401     };
5402     static const uint8_t avci50_1080i_extradata[] = {
5403         // SPS
5404         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5405         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5406         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5407         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5408         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5409         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5410         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5411         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5412         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5413         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5414         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5415         // PPS
5416         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5417         0x11
5418     };
5419     static const uint8_t avci100_720p_extradata[] = {
5420         // SPS
5421         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5422         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5423         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5424         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5425         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5426         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5427         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5428         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5429         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5430         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5431         // PPS
5432         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5433         0x11
5434     };
5435     static const uint8_t avci50_720p_extradata[] = {
5436         // SPS
5437         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5438         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5439         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5440         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5441         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5442         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5443         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5444         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5445         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5446         // PPS
5447         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5448         0x11
5449     };
5450
5451     const uint8_t *data = NULL;
5452     int ret, size       = 0;
5453
5454     if (st->codecpar->width == 1920) {
5455         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5456             data = avci100_1080p_extradata;
5457             size = sizeof(avci100_1080p_extradata);
5458         } else {
5459             data = avci100_1080i_extradata;
5460             size = sizeof(avci100_1080i_extradata);
5461         }
5462     } else if (st->codecpar->width == 1440) {
5463         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5464             data = avci50_1080p_extradata;
5465             size = sizeof(avci50_1080p_extradata);
5466         } else {
5467             data = avci50_1080i_extradata;
5468             size = sizeof(avci50_1080i_extradata);
5469         }
5470     } else if (st->codecpar->width == 1280) {
5471         data = avci100_720p_extradata;
5472         size = sizeof(avci100_720p_extradata);
5473     } else if (st->codecpar->width == 960) {
5474         data = avci50_720p_extradata;
5475         size = sizeof(avci50_720p_extradata);
5476     }
5477
5478     if (!size)
5479         return 0;
5480
5481     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5482         return ret;
5483     memcpy(st->codecpar->extradata, data, size);
5484
5485     return 0;
5486 }
5487
5488 uint8_t *av_stream_get_side_data(const AVStream *st,
5489                                  enum AVPacketSideDataType type, buffer_size_t *size)
5490 {
5491     int i;
5492
5493     for (i = 0; i < st->nb_side_data; i++) {
5494         if (st->side_data[i].type == type) {
5495             if (size)
5496                 *size = st->side_data[i].size;
5497             return st->side_data[i].data;
5498         }
5499     }
5500     if (size)
5501         *size = 0;
5502     return NULL;
5503 }
5504
5505 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5506                             uint8_t *data, size_t size)
5507 {
5508     AVPacketSideData *sd, *tmp;
5509     int i;
5510
5511     for (i = 0; i < st->nb_side_data; i++) {
5512         sd = &st->side_data[i];
5513
5514         if (sd->type == type) {
5515             av_freep(&sd->data);
5516             sd->data = data;
5517             sd->size = size;
5518             return 0;
5519         }
5520     }
5521
5522     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5523         return AVERROR(ERANGE);
5524
5525     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5526     if (!tmp) {
5527         return AVERROR(ENOMEM);
5528     }
5529
5530     st->side_data = tmp;
5531     st->nb_side_data++;
5532
5533     sd = &st->side_data[st->nb_side_data - 1];
5534     sd->type = type;
5535     sd->data = data;
5536     sd->size = size;
5537
5538     return 0;
5539 }
5540
5541 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5542                                  buffer_size_t size)
5543 {
5544     int ret;
5545     uint8_t *data = av_malloc(size);
5546
5547     if (!data)
5548         return NULL;
5549
5550     ret = av_stream_add_side_data(st, type, data, size);
5551     if (ret < 0) {
5552         av_freep(&data);
5553         return NULL;
5554     }
5555
5556     return data;
5557 }
5558
5559 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5560 {
5561     int ret;
5562     const AVBitStreamFilter *bsf;
5563     AVBSFContext *bsfc;
5564
5565     av_assert0(!st->internal->bsfc);
5566
5567     if (!(bsf = av_bsf_get_by_name(name))) {
5568         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5569         return AVERROR_BSF_NOT_FOUND;
5570     }
5571
5572     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5573         return ret;
5574
5575     bsfc->time_base_in = st->time_base;
5576     if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5577         av_bsf_free(&bsfc);
5578         return ret;
5579     }
5580
5581     if (args && bsfc->filter->priv_class) {
5582         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5583         const char * shorthand[2] = {NULL};
5584
5585         if (opt)
5586             shorthand[0] = opt->name;
5587
5588         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5589             av_bsf_free(&bsfc);
5590             return ret;
5591         }
5592     }
5593
5594     if ((ret = av_bsf_init(bsfc)) < 0) {
5595         av_bsf_free(&bsfc);
5596         return ret;
5597     }
5598
5599     st->internal->bsfc = bsfc;
5600
5601     av_log(NULL, AV_LOG_VERBOSE,
5602            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5603            name, args ? args : "");
5604     return 1;
5605 }
5606
5607 #if FF_API_OLD_BSF
5608 FF_DISABLE_DEPRECATION_WARNINGS
5609 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5610                                AVBitStreamFilterContext *bsfc)
5611 {
5612     int ret = 0;
5613     while (bsfc) {
5614         AVPacket new_pkt = *pkt;
5615         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5616                                            &new_pkt.data, &new_pkt.size,
5617                                            pkt->data, pkt->size,
5618                                            pkt->flags & AV_PKT_FLAG_KEY);
5619         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5620             av_packet_unref(pkt);
5621             memset(pkt, 0, sizeof(*pkt));
5622             return 0;
5623         }
5624         if(a == 0 && new_pkt.data != pkt->data) {
5625             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
5626             if (t) {
5627                 memcpy(t, new_pkt.data, new_pkt.size);
5628                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5629                 new_pkt.data = t;
5630                 new_pkt.buf = NULL;
5631                 a = 1;
5632             } else {
5633                 a = AVERROR(ENOMEM);
5634             }
5635         }
5636         if (a > 0) {
5637             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5638                                            av_buffer_default_free, NULL, 0);
5639             if (new_pkt.buf) {
5640                 pkt->side_data = NULL;
5641                 pkt->side_data_elems = 0;
5642                 av_packet_unref(pkt);
5643             } else {
5644                 av_freep(&new_pkt.data);
5645                 a = AVERROR(ENOMEM);
5646             }
5647         }
5648         if (a < 0) {
5649             av_log(codec, AV_LOG_ERROR,
5650                    "Failed to open bitstream filter %s for stream %d with codec %s",
5651                    bsfc->filter->name, pkt->stream_index,
5652                    codec->codec ? codec->codec->name : "copy");
5653             ret = a;
5654             break;
5655         }
5656         *pkt = new_pkt;
5657
5658         bsfc = bsfc->next;
5659     }
5660     return ret;
5661 }
5662 FF_ENABLE_DEPRECATION_WARNINGS
5663 #endif
5664
5665 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5666 {
5667     if (!s->oformat)
5668         return AVERROR(EINVAL);
5669
5670     if (!(s->oformat->flags & AVFMT_NOFILE))
5671         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5672     return 0;
5673 }
5674
5675 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5676 {
5677     if (*pb)
5678         s->io_close(s, *pb);
5679     *pb = NULL;
5680 }
5681
5682 int ff_is_http_proto(char *filename) {
5683     const char *proto = avio_find_protocol_name(filename);
5684     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5685 }
5686
5687 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5688 {
5689     AVDictionaryEntry *entry;
5690     int64_t parsed_timestamp;
5691     int ret;
5692     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5693         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5694             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5695             return 1;
5696         } else {
5697             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5698             return ret;
5699         }
5700     }
5701     return 0;
5702 }
5703
5704 int ff_standardize_creation_time(AVFormatContext *s)
5705 {
5706     int64_t timestamp;
5707     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5708     if (ret == 1)
5709         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5710     return ret;
5711 }
5712
5713 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5714 {
5715     uint8_t *side_data;
5716     buffer_size_t size;
5717
5718     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5719     if (side_data) {
5720         if (size != AVPALETTE_SIZE) {
5721             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5722             return AVERROR_INVALIDDATA;
5723         }
5724         memcpy(palette, side_data, AVPALETTE_SIZE);
5725         return 1;
5726     }
5727
5728     if (ret == CONTAINS_PAL) {
5729         int i;
5730         for (i = 0; i < AVPALETTE_COUNT; i++)
5731             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5732         return 1;
5733     }
5734
5735     return 0;
5736 }
5737
5738 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5739 {
5740     int ret;
5741     char *str;
5742
5743     ret = av_bprint_finalize(buf, &str);
5744     if (ret < 0)
5745         return ret;
5746     if (!av_bprint_is_complete(buf)) {
5747         av_free(str);
5748         return AVERROR(ENOMEM);
5749     }
5750
5751     par->extradata = str;
5752     /* Note: the string is NUL terminated (so extradata can be read as a
5753      * string), but the ending character is not accounted in the size (in
5754      * binary formats you are likely not supposed to mux that character). When
5755      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5756      * zeros. */
5757     par->extradata_size = buf->len;
5758     return 0;
5759 }
5760
5761 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5762                                                   AVStream *ost, const AVStream *ist,
5763                                                   enum AVTimebaseSource copy_tb)
5764 {
5765     //TODO: use [io]st->internal->avctx
5766     const AVCodecContext *dec_ctx;
5767     AVCodecContext       *enc_ctx;
5768
5769 #if FF_API_LAVF_AVCTX
5770 FF_DISABLE_DEPRECATION_WARNINGS
5771     dec_ctx = ist->codec;
5772     enc_ctx = ost->codec;
5773 FF_ENABLE_DEPRECATION_WARNINGS
5774 #else
5775     dec_ctx = ist->internal->avctx;
5776     enc_ctx = ost->internal->avctx;
5777 #endif
5778
5779     enc_ctx->time_base = ist->time_base;
5780     /*
5781      * Avi is a special case here because it supports variable fps but
5782      * having the fps and timebase differe significantly adds quite some
5783      * overhead
5784      */
5785     if (!strcmp(ofmt->name, "avi")) {
5786 #if FF_API_R_FRAME_RATE
5787         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5788             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5789             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5790             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5791             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5792             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5793             enc_ctx->time_base.num = ist->r_frame_rate.den;
5794             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5795             enc_ctx->ticks_per_frame = 2;
5796         } else
5797 #endif
5798             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5799                    && av_q2d(ist->time_base) < 1.0/500
5800                    || copy_tb == AVFMT_TBCF_DECODER) {
5801             enc_ctx->time_base = dec_ctx->time_base;
5802             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5803             enc_ctx->time_base.den *= 2;
5804             enc_ctx->ticks_per_frame = 2;
5805         }
5806     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5807                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5808         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5809             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5810             && av_q2d(ist->time_base) < 1.0/500
5811             || copy_tb == AVFMT_TBCF_DECODER) {
5812             enc_ctx->time_base = dec_ctx->time_base;
5813             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5814         }
5815     }
5816
5817     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5818         && dec_ctx->time_base.num < dec_ctx->time_base.den
5819         && dec_ctx->time_base.num > 0
5820         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5821         enc_ctx->time_base = dec_ctx->time_base;
5822     }
5823
5824     if (ost->avg_frame_rate.num)
5825         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5826
5827     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5828               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5829
5830     return 0;
5831 }
5832
5833 AVRational av_stream_get_codec_timebase(const AVStream *st)
5834 {
5835     // See avformat_transfer_internal_stream_timing_info() TODO.
5836 #if FF_API_LAVF_AVCTX
5837 FF_DISABLE_DEPRECATION_WARNINGS
5838     return st->codec->time_base;
5839 FF_ENABLE_DEPRECATION_WARNINGS
5840 #else
5841     return st->internal->avctx->time_base;
5842 #endif
5843 }
5844
5845 void ff_format_set_url(AVFormatContext *s, char *url)
5846 {
5847     av_assert0(url);
5848     av_freep(&s->url);
5849     s->url = url;
5850 #if FF_API_FORMAT_FILENAME
5851 FF_DISABLE_DEPRECATION_WARNINGS
5852     av_strlcpy(s->filename, url, sizeof(s->filename));
5853 FF_ENABLE_DEPRECATION_WARNINGS
5854 #endif
5855 }