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