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 #if FF_API_CHAPTER_ID_INT
4630 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4631 #else
4632 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
4633 #endif
4634                               int64_t start, int64_t end, const char *title)
4635 {
4636     AVChapter *chapter = NULL;
4637     int i;
4638
4639     if (end != AV_NOPTS_VALUE && start > end) {
4640         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4641         return NULL;
4642     }
4643
4644     if (!s->nb_chapters) {
4645         s->internal->chapter_ids_monotonic = 1;
4646     } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4647         s->internal->chapter_ids_monotonic = 0;
4648         for (i = 0; i < s->nb_chapters; i++)
4649             if (s->chapters[i]->id == id)
4650                 chapter = s->chapters[i];
4651     }
4652
4653     if (!chapter) {
4654         chapter = av_mallocz(sizeof(AVChapter));
4655         if (!chapter)
4656             return NULL;
4657         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4658     }
4659     av_dict_set(&chapter->metadata, "title", title, 0);
4660     chapter->id        = id;
4661     chapter->time_base = time_base;
4662     chapter->start     = start;
4663     chapter->end       = end;
4664
4665     return chapter;
4666 }
4667
4668 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4669 {
4670     int i, j;
4671     AVProgram *program = NULL;
4672     void *tmp;
4673
4674     if (idx >= ac->nb_streams) {
4675         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4676         return;
4677     }
4678
4679     for (i = 0; i < ac->nb_programs; i++) {
4680         if (ac->programs[i]->id != progid)
4681             continue;
4682         program = ac->programs[i];
4683         for (j = 0; j < program->nb_stream_indexes; j++)
4684             if (program->stream_index[j] == idx)
4685                 return;
4686
4687         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4688         if (!tmp)
4689             return;
4690         program->stream_index = tmp;
4691         program->stream_index[program->nb_stream_indexes++] = idx;
4692         return;
4693     }
4694 }
4695
4696 uint64_t ff_ntp_time(void)
4697 {
4698     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4699 }
4700
4701 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4702 {
4703     uint64_t ntp_ts, frac_part, sec;
4704     uint32_t usec;
4705
4706     //current ntp time in seconds and micro seconds
4707     sec = ntp_time_us / 1000000;
4708     usec = ntp_time_us % 1000000;
4709
4710     //encoding in ntp timestamp format
4711     frac_part = usec * 0xFFFFFFFFULL;
4712     frac_part /= 1000000;
4713
4714     if (sec > 0xFFFFFFFFULL)
4715         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4716
4717     ntp_ts = sec << 32;
4718     ntp_ts |= frac_part;
4719
4720     return ntp_ts;
4721 }
4722
4723 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4724 {
4725     const char *p;
4726     char *q, buf1[20], c;
4727     int nd, len, percentd_found;
4728
4729     q = buf;
4730     p = path;
4731     percentd_found = 0;
4732     for (;;) {
4733         c = *p++;
4734         if (c == '\0')
4735             break;
4736         if (c == '%') {
4737             do {
4738                 nd = 0;
4739                 while (av_isdigit(*p)) {
4740                     if (nd >= INT_MAX / 10 - 255)
4741                         goto fail;
4742                     nd = nd * 10 + *p++ - '0';
4743                 }
4744                 c = *p++;
4745             } while (av_isdigit(c));
4746
4747             switch (c) {
4748             case '%':
4749                 goto addchar;
4750             case 'd':
4751                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4752                     goto fail;
4753                 percentd_found = 1;
4754                 if (number < 0)
4755                     nd += 1;
4756                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4757                 len = strlen(buf1);
4758                 if ((q - buf + len) > buf_size - 1)
4759                     goto fail;
4760                 memcpy(q, buf1, len);
4761                 q += len;
4762                 break;
4763             default:
4764                 goto fail;
4765             }
4766         } else {
4767 addchar:
4768             if ((q - buf) < buf_size - 1)
4769                 *q++ = c;
4770         }
4771     }
4772     if (!percentd_found)
4773         goto fail;
4774     *q = '\0';
4775     return 0;
4776 fail:
4777     *q = '\0';
4778     return -1;
4779 }
4780
4781 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4782 {
4783     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4784 }
4785
4786 void av_url_split(char *proto, int proto_size,
4787                   char *authorization, int authorization_size,
4788                   char *hostname, int hostname_size,
4789                   int *port_ptr, char *path, int path_size, const char *url)
4790 {
4791     const char *p, *ls, *at, *at2, *col, *brk;
4792
4793     if (port_ptr)
4794         *port_ptr = -1;
4795     if (proto_size > 0)
4796         proto[0] = 0;
4797     if (authorization_size > 0)
4798         authorization[0] = 0;
4799     if (hostname_size > 0)
4800         hostname[0] = 0;
4801     if (path_size > 0)
4802         path[0] = 0;
4803
4804     /* parse protocol */
4805     if ((p = strchr(url, ':'))) {
4806         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4807         p++; /* skip ':' */
4808         if (*p == '/')
4809             p++;
4810         if (*p == '/')
4811             p++;
4812     } else {
4813         /* no protocol means plain filename */
4814         av_strlcpy(path, url, path_size);
4815         return;
4816     }
4817
4818     /* separate path from hostname */
4819     ls = p + strcspn(p, "/?#");
4820     av_strlcpy(path, ls, path_size);
4821
4822     /* the rest is hostname, use that to parse auth/port */
4823     if (ls != p) {
4824         /* authorization (user[:pass]@hostname) */
4825         at2 = p;
4826         while ((at = strchr(p, '@')) && at < ls) {
4827             av_strlcpy(authorization, at2,
4828                        FFMIN(authorization_size, at + 1 - at2));
4829             p = at + 1; /* skip '@' */
4830         }
4831
4832         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4833             /* [host]:port */
4834             av_strlcpy(hostname, p + 1,
4835                        FFMIN(hostname_size, brk - p));
4836             if (brk[1] == ':' && port_ptr)
4837                 *port_ptr = atoi(brk + 2);
4838         } else if ((col = strchr(p, ':')) && col < ls) {
4839             av_strlcpy(hostname, p,
4840                        FFMIN(col + 1 - p, hostname_size));
4841             if (port_ptr)
4842                 *port_ptr = atoi(col + 1);
4843         } else
4844             av_strlcpy(hostname, p,
4845                        FFMIN(ls + 1 - p, hostname_size));
4846     }
4847 }
4848
4849 int ff_mkdir_p(const char *path)
4850 {
4851     int ret = 0;
4852     char *temp = av_strdup(path);
4853     char *pos = temp;
4854     char tmp_ch = '\0';
4855
4856     if (!path || !temp) {
4857         return -1;
4858     }
4859
4860     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4861         pos++;
4862     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4863         pos += 2;
4864     }
4865
4866     for ( ; *pos != '\0'; ++pos) {
4867         if (*pos == '/' || *pos == '\\') {
4868             tmp_ch = *pos;
4869             *pos = '\0';
4870             ret = mkdir(temp, 0755);
4871             *pos = tmp_ch;
4872         }
4873     }
4874
4875     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4876         ret = mkdir(temp, 0755);
4877     }
4878
4879     av_free(temp);
4880     return ret;
4881 }
4882
4883 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4884 {
4885     int i;
4886     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4887                                            '4', '5', '6', '7',
4888                                            '8', '9', 'A', 'B',
4889                                            'C', 'D', 'E', 'F' };
4890     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4891                                            '4', '5', '6', '7',
4892                                            '8', '9', 'a', 'b',
4893                                            'c', 'd', 'e', 'f' };
4894     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4895
4896     for (i = 0; i < s; i++) {
4897         buff[i * 2]     = hex_table[src[i] >> 4];
4898         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4899     }
4900
4901     return buff;
4902 }
4903
4904 int ff_hex_to_data(uint8_t *data, const char *p)
4905 {
4906     int c, len, v;
4907
4908     len = 0;
4909     v   = 1;
4910     for (;;) {
4911         p += strspn(p, SPACE_CHARS);
4912         if (*p == '\0')
4913             break;
4914         c = av_toupper((unsigned char) *p++);
4915         if (c >= '0' && c <= '9')
4916             c = c - '0';
4917         else if (c >= 'A' && c <= 'F')
4918             c = c - 'A' + 10;
4919         else
4920             break;
4921         v = (v << 4) | c;
4922         if (v & 0x100) {
4923             if (data)
4924                 data[len] = v;
4925             len++;
4926             v = 1;
4927         }
4928     }
4929     return len;
4930 }
4931
4932 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4933                          unsigned int pts_num, unsigned int pts_den)
4934 {
4935     AVRational new_tb;
4936     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4937         if (new_tb.num != pts_num)
4938             av_log(NULL, AV_LOG_DEBUG,
4939                    "st:%d removing common factor %d from timebase\n",
4940                    s->index, pts_num / new_tb.num);
4941     } else
4942         av_log(NULL, AV_LOG_WARNING,
4943                "st:%d has too large timebase, reducing\n", s->index);
4944
4945     if (new_tb.num <= 0 || new_tb.den <= 0) {
4946         av_log(NULL, AV_LOG_ERROR,
4947                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4948                new_tb.num, new_tb.den,
4949                s->index);
4950         return;
4951     }
4952     s->time_base     = new_tb;
4953 #if FF_API_LAVF_AVCTX
4954 FF_DISABLE_DEPRECATION_WARNINGS
4955     s->codec->pkt_timebase = new_tb;
4956 FF_ENABLE_DEPRECATION_WARNINGS
4957 #endif
4958     s->internal->avctx->pkt_timebase = new_tb;
4959     s->pts_wrap_bits = pts_wrap_bits;
4960 }
4961
4962 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4963                         void *context)
4964 {
4965     const char *ptr = str;
4966
4967     /* Parse key=value pairs. */
4968     for (;;) {
4969         const char *key;
4970         char *dest = NULL, *dest_end;
4971         int key_len, dest_len = 0;
4972
4973         /* Skip whitespace and potential commas. */
4974         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4975             ptr++;
4976         if (!*ptr)
4977             break;
4978
4979         key = ptr;
4980
4981         if (!(ptr = strchr(key, '=')))
4982             break;
4983         ptr++;
4984         key_len = ptr - key;
4985
4986         callback_get_buf(context, key, key_len, &dest, &dest_len);
4987         dest_end = dest + dest_len - 1;
4988
4989         if (*ptr == '\"') {
4990             ptr++;
4991             while (*ptr && *ptr != '\"') {
4992                 if (*ptr == '\\') {
4993                     if (!ptr[1])
4994                         break;
4995                     if (dest && dest < dest_end)
4996                         *dest++ = ptr[1];
4997                     ptr += 2;
4998                 } else {
4999                     if (dest && dest < dest_end)
5000                         *dest++ = *ptr;
5001                     ptr++;
5002                 }
5003             }
5004             if (*ptr == '\"')
5005                 ptr++;
5006         } else {
5007             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5008                 if (dest && dest < dest_end)
5009                     *dest++ = *ptr;
5010         }
5011         if (dest)
5012             *dest = 0;
5013     }
5014 }
5015
5016 int ff_find_stream_index(AVFormatContext *s, int id)
5017 {
5018     int i;
5019     for (i = 0; i < s->nb_streams; i++)
5020         if (s->streams[i]->id == id)
5021             return i;
5022     return -1;
5023 }
5024
5025 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5026                          int std_compliance)
5027 {
5028     if (ofmt) {
5029         unsigned int codec_tag;
5030         if (ofmt->query_codec)
5031             return ofmt->query_codec(codec_id, std_compliance);
5032         else if (ofmt->codec_tag)
5033             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5034         else if (codec_id == ofmt->video_codec ||
5035                  codec_id == ofmt->audio_codec ||
5036                  codec_id == ofmt->subtitle_codec ||
5037                  codec_id == ofmt->data_codec)
5038             return 1;
5039     }
5040     return AVERROR_PATCHWELCOME;
5041 }
5042
5043 int avformat_network_init(void)
5044 {
5045 #if CONFIG_NETWORK
5046     int ret;
5047     if ((ret = ff_network_init()) < 0)
5048         return ret;
5049     if ((ret = ff_tls_init()) < 0)
5050         return ret;
5051 #endif
5052     return 0;
5053 }
5054
5055 int avformat_network_deinit(void)
5056 {
5057 #if CONFIG_NETWORK
5058     ff_network_close();
5059     ff_tls_deinit();
5060 #endif
5061     return 0;
5062 }
5063
5064 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5065                         uint64_t channel_layout, int32_t sample_rate,
5066                         int32_t width, int32_t height)
5067 {
5068     uint32_t flags = 0;
5069     int size = 4;
5070     uint8_t *data;
5071     if (!pkt)
5072         return AVERROR(EINVAL);
5073     if (channels) {
5074         size  += 4;
5075         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5076     }
5077     if (channel_layout) {
5078         size  += 8;
5079         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5080     }
5081     if (sample_rate) {
5082         size  += 4;
5083         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5084     }
5085     if (width || height) {
5086         size  += 8;
5087         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5088     }
5089     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5090     if (!data)
5091         return AVERROR(ENOMEM);
5092     bytestream_put_le32(&data, flags);
5093     if (channels)
5094         bytestream_put_le32(&data, channels);
5095     if (channel_layout)
5096         bytestream_put_le64(&data, channel_layout);
5097     if (sample_rate)
5098         bytestream_put_le32(&data, sample_rate);
5099     if (width || height) {
5100         bytestream_put_le32(&data, width);
5101         bytestream_put_le32(&data, height);
5102     }
5103     return 0;
5104 }
5105
5106 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5107 {
5108     AVRational undef = {0, 1};
5109     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5110     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5111     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5112
5113     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5114                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5115     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5116         stream_sample_aspect_ratio = undef;
5117
5118     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5119                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5120     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5121         frame_sample_aspect_ratio = undef;
5122
5123     if (stream_sample_aspect_ratio.num)
5124         return stream_sample_aspect_ratio;
5125     else
5126         return frame_sample_aspect_ratio;
5127 }
5128
5129 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5130 {
5131     AVRational fr = st->r_frame_rate;
5132     AVRational codec_fr = st->internal->avctx->framerate;
5133     AVRational   avg_fr = st->avg_frame_rate;
5134
5135     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5136         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5137         fr = avg_fr;
5138     }
5139
5140
5141     if (st->internal->avctx->ticks_per_frame > 1) {
5142         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5143             (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))
5144             fr = codec_fr;
5145     }
5146
5147     return fr;
5148 }
5149
5150 /**
5151  * Matches a stream specifier (but ignores requested index).
5152  *
5153  * @param indexptr set to point to the requested stream index if there is one
5154  *
5155  * @return <0 on error
5156  *         0  if st is NOT a matching stream
5157  *         >0 if st is a matching stream
5158  */
5159 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5160                                   const char *spec, const char **indexptr, AVProgram **p)
5161 {
5162     int match = 1;                      /* Stores if the specifier matches so far. */
5163     while (*spec) {
5164         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5165             if (indexptr)
5166                 *indexptr = spec;
5167             return match;
5168         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5169                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5170             enum AVMediaType type;
5171             int nopic = 0;
5172
5173             switch (*spec++) {
5174             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5175             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5176             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5177             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5178             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5179             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5180             default:  av_assert0(0);
5181             }
5182             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5183                 return AVERROR(EINVAL);
5184
5185 #if FF_API_LAVF_AVCTX
5186 FF_DISABLE_DEPRECATION_WARNINGS
5187             if (type != st->codecpar->codec_type
5188                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5189                 match = 0;
5190     FF_ENABLE_DEPRECATION_WARNINGS
5191 #else
5192             if (type != st->codecpar->codec_type)
5193                 match = 0;
5194 #endif
5195             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5196                 match = 0;
5197         } else if (*spec == 'p' && *(spec + 1) == ':') {
5198             int prog_id, i, j;
5199             int found = 0;
5200             char *endptr;
5201             spec += 2;
5202             prog_id = strtol(spec, &endptr, 0);
5203             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5204             if (spec == endptr || (*endptr && *endptr++ != ':'))
5205                 return AVERROR(EINVAL);
5206             spec = endptr;
5207             if (match) {
5208                 for (i = 0; i < s->nb_programs; i++) {
5209                     if (s->programs[i]->id != prog_id)
5210                         continue;
5211
5212                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5213                         if (st->index == s->programs[i]->stream_index[j]) {
5214                             found = 1;
5215                             if (p)
5216                                 *p = s->programs[i];
5217                             i = s->nb_programs;
5218                             break;
5219                         }
5220                     }
5221                 }
5222             }
5223             if (!found)
5224                 match = 0;
5225         } else if (*spec == '#' ||
5226                    (*spec == 'i' && *(spec + 1) == ':')) {
5227             int stream_id;
5228             char *endptr;
5229             spec += 1 + (*spec == 'i');
5230             stream_id = strtol(spec, &endptr, 0);
5231             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5232                 return AVERROR(EINVAL);
5233             return match && (stream_id == st->id);
5234         } else if (*spec == 'm' && *(spec + 1) == ':') {
5235             AVDictionaryEntry *tag;
5236             char *key, *val;
5237             int ret;
5238
5239             if (match) {
5240                spec += 2;
5241                val = strchr(spec, ':');
5242
5243                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5244                if (!key)
5245                    return AVERROR(ENOMEM);
5246
5247                tag = av_dict_get(st->metadata, key, NULL, 0);
5248                if (tag) {
5249                    if (!val || !strcmp(tag->value, val + 1))
5250                        ret = 1;
5251                    else
5252                        ret = 0;
5253                } else
5254                    ret = 0;
5255
5256                av_freep(&key);
5257             }
5258             return match && ret;
5259         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5260             AVCodecParameters *par = st->codecpar;
5261 #if FF_API_LAVF_AVCTX
5262 FF_DISABLE_DEPRECATION_WARNINGS
5263             AVCodecContext *codec = st->codec;
5264 FF_ENABLE_DEPRECATION_WARNINGS
5265 #endif
5266             int val;
5267             switch (par->codec_type) {
5268             case AVMEDIA_TYPE_AUDIO:
5269                 val = par->sample_rate && par->channels;
5270 #if FF_API_LAVF_AVCTX
5271                 val = val || (codec->sample_rate && codec->channels);
5272 #endif
5273                 if (par->format == AV_SAMPLE_FMT_NONE
5274 #if FF_API_LAVF_AVCTX
5275                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5276 #endif
5277                     )
5278                     return 0;
5279                 break;
5280             case AVMEDIA_TYPE_VIDEO:
5281                 val = par->width && par->height;
5282 #if FF_API_LAVF_AVCTX
5283                 val = val || (codec->width && codec->height);
5284 #endif
5285                 if (par->format == AV_PIX_FMT_NONE
5286 #if FF_API_LAVF_AVCTX
5287                     && codec->pix_fmt == AV_PIX_FMT_NONE
5288 #endif
5289                     )
5290                     return 0;
5291                 break;
5292             case AVMEDIA_TYPE_UNKNOWN:
5293                 val = 0;
5294                 break;
5295             default:
5296                 val = 1;
5297                 break;
5298             }
5299 #if FF_API_LAVF_AVCTX
5300             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5301 #else
5302             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5303 #endif
5304         } else {
5305             return AVERROR(EINVAL);
5306         }
5307     }
5308
5309     return match;
5310 }
5311
5312
5313 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5314                                     const char *spec)
5315 {
5316     int ret, index;
5317     char *endptr;
5318     const char *indexptr = NULL;
5319     AVProgram *p = NULL;
5320     int nb_streams;
5321
5322     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5323     if (ret < 0)
5324         goto error;
5325
5326     if (!indexptr)
5327         return ret;
5328
5329     index = strtol(indexptr, &endptr, 0);
5330     if (*endptr) {                  /* We can't have anything after the requested index. */
5331         ret = AVERROR(EINVAL);
5332         goto error;
5333     }
5334
5335     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5336     if (spec == indexptr)
5337         return (index == st->index);
5338
5339     /* If we requested a matching stream index, we have to ensure st is that. */
5340     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5341     for (int i = 0; i < nb_streams && index >= 0; i++) {
5342         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5343         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5344         if (ret < 0)
5345             goto error;
5346         if (ret > 0 && index-- == 0 && st == candidate)
5347             return 1;
5348     }
5349     return 0;
5350
5351 error:
5352     if (ret == AVERROR(EINVAL))
5353         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5354     return ret;
5355 }
5356
5357 int ff_generate_avci_extradata(AVStream *st)
5358 {
5359     static const uint8_t avci100_1080p_extradata[] = {
5360         // SPS
5361         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5362         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5363         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5364         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5365         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5366         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5367         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5368         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5369         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5370         // PPS
5371         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5372         0xd0
5373     };
5374     static const uint8_t avci100_1080i_extradata[] = {
5375         // SPS
5376         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5377         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5378         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5379         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5380         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5381         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5382         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5383         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5384         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5385         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5386         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5387         // PPS
5388         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5389         0xd0
5390     };
5391     static const uint8_t avci50_1080p_extradata[] = {
5392         // SPS
5393         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5394         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5395         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5396         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5397         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5398         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5399         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5400         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5401         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5402         // PPS
5403         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5404         0x11
5405     };
5406     static const uint8_t avci50_1080i_extradata[] = {
5407         // SPS
5408         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5409         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5410         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5411         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5412         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5413         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5414         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5415         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5416         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5417         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5418         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5419         // PPS
5420         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5421         0x11
5422     };
5423     static const uint8_t avci100_720p_extradata[] = {
5424         // SPS
5425         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5426         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5427         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5428         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5429         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5430         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5431         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5432         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5433         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5434         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5435         // PPS
5436         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5437         0x11
5438     };
5439     static const uint8_t avci50_720p_extradata[] = {
5440         // SPS
5441         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5442         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5443         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5444         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5445         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5446         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5447         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5448         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5449         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5450         // PPS
5451         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5452         0x11
5453     };
5454
5455     const uint8_t *data = NULL;
5456     int ret, size       = 0;
5457
5458     if (st->codecpar->width == 1920) {
5459         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5460             data = avci100_1080p_extradata;
5461             size = sizeof(avci100_1080p_extradata);
5462         } else {
5463             data = avci100_1080i_extradata;
5464             size = sizeof(avci100_1080i_extradata);
5465         }
5466     } else if (st->codecpar->width == 1440) {
5467         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5468             data = avci50_1080p_extradata;
5469             size = sizeof(avci50_1080p_extradata);
5470         } else {
5471             data = avci50_1080i_extradata;
5472             size = sizeof(avci50_1080i_extradata);
5473         }
5474     } else if (st->codecpar->width == 1280) {
5475         data = avci100_720p_extradata;
5476         size = sizeof(avci100_720p_extradata);
5477     } else if (st->codecpar->width == 960) {
5478         data = avci50_720p_extradata;
5479         size = sizeof(avci50_720p_extradata);
5480     }
5481
5482     if (!size)
5483         return 0;
5484
5485     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5486         return ret;
5487     memcpy(st->codecpar->extradata, data, size);
5488
5489     return 0;
5490 }
5491
5492 uint8_t *av_stream_get_side_data(const AVStream *st,
5493                                  enum AVPacketSideDataType type, buffer_size_t *size)
5494 {
5495     int i;
5496
5497     for (i = 0; i < st->nb_side_data; i++) {
5498         if (st->side_data[i].type == type) {
5499             if (size)
5500                 *size = st->side_data[i].size;
5501             return st->side_data[i].data;
5502         }
5503     }
5504     if (size)
5505         *size = 0;
5506     return NULL;
5507 }
5508
5509 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5510                             uint8_t *data, size_t size)
5511 {
5512     AVPacketSideData *sd, *tmp;
5513     int i;
5514
5515     for (i = 0; i < st->nb_side_data; i++) {
5516         sd = &st->side_data[i];
5517
5518         if (sd->type == type) {
5519             av_freep(&sd->data);
5520             sd->data = data;
5521             sd->size = size;
5522             return 0;
5523         }
5524     }
5525
5526     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5527         return AVERROR(ERANGE);
5528
5529     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5530     if (!tmp) {
5531         return AVERROR(ENOMEM);
5532     }
5533
5534     st->side_data = tmp;
5535     st->nb_side_data++;
5536
5537     sd = &st->side_data[st->nb_side_data - 1];
5538     sd->type = type;
5539     sd->data = data;
5540     sd->size = size;
5541
5542     return 0;
5543 }
5544
5545 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5546                                  buffer_size_t size)
5547 {
5548     int ret;
5549     uint8_t *data = av_malloc(size);
5550
5551     if (!data)
5552         return NULL;
5553
5554     ret = av_stream_add_side_data(st, type, data, size);
5555     if (ret < 0) {
5556         av_freep(&data);
5557         return NULL;
5558     }
5559
5560     return data;
5561 }
5562
5563 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5564 {
5565     int ret;
5566     const AVBitStreamFilter *bsf;
5567     AVBSFContext *bsfc;
5568
5569     av_assert0(!st->internal->bsfc);
5570
5571     if (!(bsf = av_bsf_get_by_name(name))) {
5572         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5573         return AVERROR_BSF_NOT_FOUND;
5574     }
5575
5576     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5577         return ret;
5578
5579     bsfc->time_base_in = st->time_base;
5580     if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5581         av_bsf_free(&bsfc);
5582         return ret;
5583     }
5584
5585     if (args && bsfc->filter->priv_class) {
5586         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5587         const char * shorthand[2] = {NULL};
5588
5589         if (opt)
5590             shorthand[0] = opt->name;
5591
5592         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5593             av_bsf_free(&bsfc);
5594             return ret;
5595         }
5596     }
5597
5598     if ((ret = av_bsf_init(bsfc)) < 0) {
5599         av_bsf_free(&bsfc);
5600         return ret;
5601     }
5602
5603     st->internal->bsfc = bsfc;
5604
5605     av_log(NULL, AV_LOG_VERBOSE,
5606            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5607            name, args ? args : "");
5608     return 1;
5609 }
5610
5611 #if FF_API_OLD_BSF
5612 FF_DISABLE_DEPRECATION_WARNINGS
5613 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5614                                AVBitStreamFilterContext *bsfc)
5615 {
5616     int ret = 0;
5617     while (bsfc) {
5618         AVPacket new_pkt = *pkt;
5619         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5620                                            &new_pkt.data, &new_pkt.size,
5621                                            pkt->data, pkt->size,
5622                                            pkt->flags & AV_PKT_FLAG_KEY);
5623         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5624             av_packet_unref(pkt);
5625             memset(pkt, 0, sizeof(*pkt));
5626             return 0;
5627         }
5628         if(a == 0 && new_pkt.data != pkt->data) {
5629             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
5630             if (t) {
5631                 memcpy(t, new_pkt.data, new_pkt.size);
5632                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5633                 new_pkt.data = t;
5634                 new_pkt.buf = NULL;
5635                 a = 1;
5636             } else {
5637                 a = AVERROR(ENOMEM);
5638             }
5639         }
5640         if (a > 0) {
5641             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5642                                            av_buffer_default_free, NULL, 0);
5643             if (new_pkt.buf) {
5644                 pkt->side_data = NULL;
5645                 pkt->side_data_elems = 0;
5646                 av_packet_unref(pkt);
5647             } else {
5648                 av_freep(&new_pkt.data);
5649                 a = AVERROR(ENOMEM);
5650             }
5651         }
5652         if (a < 0) {
5653             av_log(codec, AV_LOG_ERROR,
5654                    "Failed to open bitstream filter %s for stream %d with codec %s",
5655                    bsfc->filter->name, pkt->stream_index,
5656                    codec->codec ? codec->codec->name : "copy");
5657             ret = a;
5658             break;
5659         }
5660         *pkt = new_pkt;
5661
5662         bsfc = bsfc->next;
5663     }
5664     return ret;
5665 }
5666 FF_ENABLE_DEPRECATION_WARNINGS
5667 #endif
5668
5669 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5670 {
5671     if (!s->oformat)
5672         return AVERROR(EINVAL);
5673
5674     if (!(s->oformat->flags & AVFMT_NOFILE))
5675         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5676     return 0;
5677 }
5678
5679 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5680 {
5681     if (*pb)
5682         s->io_close(s, *pb);
5683     *pb = NULL;
5684 }
5685
5686 int ff_is_http_proto(char *filename) {
5687     const char *proto = avio_find_protocol_name(filename);
5688     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5689 }
5690
5691 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5692 {
5693     AVDictionaryEntry *entry;
5694     int64_t parsed_timestamp;
5695     int ret;
5696     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5697         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5698             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5699             return 1;
5700         } else {
5701             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5702             return ret;
5703         }
5704     }
5705     return 0;
5706 }
5707
5708 int ff_standardize_creation_time(AVFormatContext *s)
5709 {
5710     int64_t timestamp;
5711     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5712     if (ret == 1)
5713         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5714     return ret;
5715 }
5716
5717 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5718 {
5719     uint8_t *side_data;
5720     buffer_size_t size;
5721
5722     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5723     if (side_data) {
5724         if (size != AVPALETTE_SIZE) {
5725             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5726             return AVERROR_INVALIDDATA;
5727         }
5728         memcpy(palette, side_data, AVPALETTE_SIZE);
5729         return 1;
5730     }
5731
5732     if (ret == CONTAINS_PAL) {
5733         int i;
5734         for (i = 0; i < AVPALETTE_COUNT; i++)
5735             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5736         return 1;
5737     }
5738
5739     return 0;
5740 }
5741
5742 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5743 {
5744     int ret;
5745     char *str;
5746
5747     ret = av_bprint_finalize(buf, &str);
5748     if (ret < 0)
5749         return ret;
5750     if (!av_bprint_is_complete(buf)) {
5751         av_free(str);
5752         return AVERROR(ENOMEM);
5753     }
5754
5755     par->extradata = str;
5756     /* Note: the string is NUL terminated (so extradata can be read as a
5757      * string), but the ending character is not accounted in the size (in
5758      * binary formats you are likely not supposed to mux that character). When
5759      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5760      * zeros. */
5761     par->extradata_size = buf->len;
5762     return 0;
5763 }
5764
5765 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5766                                                   AVStream *ost, const AVStream *ist,
5767                                                   enum AVTimebaseSource copy_tb)
5768 {
5769     //TODO: use [io]st->internal->avctx
5770     const AVCodecContext *dec_ctx;
5771     AVCodecContext       *enc_ctx;
5772
5773 #if FF_API_LAVF_AVCTX
5774 FF_DISABLE_DEPRECATION_WARNINGS
5775     dec_ctx = ist->codec;
5776     enc_ctx = ost->codec;
5777 FF_ENABLE_DEPRECATION_WARNINGS
5778 #else
5779     dec_ctx = ist->internal->avctx;
5780     enc_ctx = ost->internal->avctx;
5781 #endif
5782
5783     enc_ctx->time_base = ist->time_base;
5784     /*
5785      * Avi is a special case here because it supports variable fps but
5786      * having the fps and timebase differe significantly adds quite some
5787      * overhead
5788      */
5789     if (!strcmp(ofmt->name, "avi")) {
5790 #if FF_API_R_FRAME_RATE
5791         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5792             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5793             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5794             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5795             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5796             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5797             enc_ctx->time_base.num = ist->r_frame_rate.den;
5798             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5799             enc_ctx->ticks_per_frame = 2;
5800         } else
5801 #endif
5802             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5803                    && av_q2d(ist->time_base) < 1.0/500
5804                    || copy_tb == AVFMT_TBCF_DECODER) {
5805             enc_ctx->time_base = dec_ctx->time_base;
5806             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5807             enc_ctx->time_base.den *= 2;
5808             enc_ctx->ticks_per_frame = 2;
5809         }
5810     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5811                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5812         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5813             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5814             && av_q2d(ist->time_base) < 1.0/500
5815             || copy_tb == AVFMT_TBCF_DECODER) {
5816             enc_ctx->time_base = dec_ctx->time_base;
5817             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5818         }
5819     }
5820
5821     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5822         && dec_ctx->time_base.num < dec_ctx->time_base.den
5823         && dec_ctx->time_base.num > 0
5824         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5825         enc_ctx->time_base = dec_ctx->time_base;
5826     }
5827
5828     if (ost->avg_frame_rate.num)
5829         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5830
5831     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5832               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5833
5834     return 0;
5835 }
5836
5837 AVRational av_stream_get_codec_timebase(const AVStream *st)
5838 {
5839     // See avformat_transfer_internal_stream_timing_info() TODO.
5840 #if FF_API_LAVF_AVCTX
5841 FF_DISABLE_DEPRECATION_WARNINGS
5842     return st->codec->time_base;
5843 FF_ENABLE_DEPRECATION_WARNINGS
5844 #else
5845     return st->internal->avctx->time_base;
5846 #endif
5847 }
5848
5849 void ff_format_set_url(AVFormatContext *s, char *url)
5850 {
5851     av_assert0(url);
5852     av_freep(&s->url);
5853     s->url = url;
5854 #if FF_API_FORMAT_FILENAME
5855 FF_DISABLE_DEPRECATION_WARNINGS
5856     av_strlcpy(s->filename, url, sizeof(s->filename));
5857 FF_ENABLE_DEPRECATION_WARNINGS
5858 #endif
5859 }