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                 t = FFMAX(t, av_rescale_q(st->internal->info->fps_last_dts - st->internal->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3869
3870             if (analyzed_all_streams)                                limit = max_analyze_duration;
3871             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3872             else                                                     limit = max_stream_analyze_duration;
3873
3874             if (t >= limit) {
3875                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3876                        limit,
3877                        t, pkt->stream_index);
3878                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3879                     av_packet_unref(&pkt1);
3880                 break;
3881             }
3882             if (pkt->duration) {
3883                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3884                     st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3885                 } else
3886                     st->internal->info->codec_info_duration += pkt->duration;
3887                 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3888             }
3889         }
3890         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3891 #if FF_API_R_FRAME_RATE
3892             ff_rfps_add_frame(ic, st, pkt->dts);
3893 #endif
3894             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3895                 st->internal->info->frame_delay_evidence = 1;
3896         }
3897         if (!st->internal->avctx->extradata) {
3898             ret = extract_extradata(st, pkt);
3899             if (ret < 0)
3900                 goto unref_then_goto_end;
3901         }
3902
3903         /* If still no information, we try to open the codec and to
3904          * decompress the frame. We try to avoid that in most cases as
3905          * it takes longer and uses more memory. For MPEG-4, we need to
3906          * decompress for QuickTime.
3907          *
3908          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3909          * least one frame of codec data, this makes sure the codec initializes
3910          * the channel configuration and does not only trust the values from
3911          * the container. */
3912         try_decode_frame(ic, st, pkt,
3913                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3914
3915         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3916             av_packet_unref(&pkt1);
3917
3918         st->codec_info_nb_frames++;
3919         count++;
3920     }
3921
3922     if (eof_reached) {
3923         int stream_index;
3924         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3925             st = ic->streams[stream_index];
3926             avctx = st->internal->avctx;
3927             if (!has_codec_parameters(st, NULL)) {
3928                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3929                 if (codec && !avctx->codec) {
3930                     AVDictionary *opts = NULL;
3931                     if (ic->codec_whitelist)
3932                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3933                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3934                         av_log(ic, AV_LOG_WARNING,
3935                                "Failed to open codec in %s\n",__FUNCTION__);
3936                     av_dict_free(&opts);
3937                 }
3938             }
3939
3940             // EOF already reached while reading the stream above.
3941             // So continue with reoordering DTS with whatever delay we have.
3942             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3943                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3944             }
3945         }
3946     }
3947
3948     if (flush_codecs) {
3949         AVPacket empty_pkt = { 0 };
3950         int err = 0;
3951         av_init_packet(&empty_pkt);
3952
3953         for (i = 0; i < ic->nb_streams; i++) {
3954
3955             st = ic->streams[i];
3956
3957             /* flush the decoders */
3958             if (st->internal->info->found_decoder == 1) {
3959                 do {
3960                     err = try_decode_frame(ic, st, &empty_pkt,
3961                                             (options && i < orig_nb_streams)
3962                                             ? &options[i] : NULL);
3963                 } while (err > 0 && !has_codec_parameters(st, NULL));
3964
3965                 if (err < 0) {
3966                     av_log(ic, AV_LOG_INFO,
3967                         "decoding for stream %d failed\n", st->index);
3968                 }
3969             }
3970         }
3971     }
3972
3973     ff_rfps_calculate(ic);
3974
3975     for (i = 0; i < ic->nb_streams; i++) {
3976         st = ic->streams[i];
3977         avctx = st->internal->avctx;
3978         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3979             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3980                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3981                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3982                     avctx->codec_tag= tag;
3983             }
3984
3985             /* estimate average framerate if not set by demuxer */
3986             if (st->internal->info->codec_info_duration_fields &&
3987                 !st->avg_frame_rate.num &&
3988                 st->internal->info->codec_info_duration) {
3989                 int best_fps      = 0;
3990                 double best_error = 0.01;
3991                 AVRational codec_frame_rate = avctx->framerate;
3992
3993                 if (st->internal->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3994                     st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3995                     st->internal->info->codec_info_duration        < 0)
3996                     continue;
3997                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3998                           st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3999                           st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4000
4001                 /* Round guessed framerate to a "standard" framerate if it's
4002                  * within 1% of the original estimate. */
4003                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4004                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4005                     double error       = fabs(av_q2d(st->avg_frame_rate) /
4006                                               av_q2d(std_fps) - 1);
4007
4008                     if (error < best_error) {
4009                         best_error = error;
4010                         best_fps   = std_fps.num;
4011                     }
4012
4013                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4014                         error       = fabs(av_q2d(codec_frame_rate) /
4015                                            av_q2d(std_fps) - 1);
4016                         if (error < best_error) {
4017                             best_error = error;
4018                             best_fps   = std_fps.num;
4019                         }
4020                     }
4021                 }
4022                 if (best_fps)
4023                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4024                               best_fps, 12 * 1001, INT_MAX);
4025             }
4026
4027             if (!st->r_frame_rate.num) {
4028                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4029                     <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4030                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4031                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4032                 } else {
4033                     st->r_frame_rate.num = st->time_base.den;
4034                     st->r_frame_rate.den = st->time_base.num;
4035                 }
4036             }
4037             if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4038                 AVRational hw_ratio = { avctx->height, avctx->width };
4039                 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4040                                                    hw_ratio);
4041             }
4042         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4043             if (!avctx->bits_per_coded_sample)
4044                 avctx->bits_per_coded_sample =
4045                     av_get_bits_per_sample(avctx->codec_id);
4046             // set stream disposition based on audio service type
4047             switch (avctx->audio_service_type) {
4048             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4049                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4050                 break;
4051             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4052                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4053                 break;
4054             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4055                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4056                 break;
4057             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4058                 st->disposition = AV_DISPOSITION_COMMENT;
4059                 break;
4060             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4061                 st->disposition = AV_DISPOSITION_KARAOKE;
4062                 break;
4063             }
4064         }
4065     }
4066
4067     if (probesize)
4068         estimate_timings(ic, old_offset);
4069
4070     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4071
4072     if (ret >= 0 && ic->nb_streams)
4073         /* We could not have all the codec parameters before EOF. */
4074         ret = -1;
4075     for (i = 0; i < ic->nb_streams; i++) {
4076         const char *errmsg;
4077         st = ic->streams[i];
4078
4079         /* if no packet was ever seen, update context now for has_codec_parameters */
4080         if (!st->internal->avctx_inited) {
4081             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4082                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4083                 st->codecpar->format = st->internal->avctx->sample_fmt;
4084             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4085             if (ret < 0)
4086                 goto find_stream_info_err;
4087         }
4088         if (!has_codec_parameters(st, &errmsg)) {
4089             char buf[256];
4090             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4091             av_log(ic, AV_LOG_WARNING,
4092                    "Could not find codec parameters for stream %d (%s): %s\n"
4093                    "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4094                    i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4095         } else {
4096             ret = 0;
4097         }
4098     }
4099
4100     ret = compute_chapters_end(ic);
4101     if (ret < 0)
4102         goto find_stream_info_err;
4103
4104     /* update the stream parameters from the internal codec contexts */
4105     for (i = 0; i < ic->nb_streams; i++) {
4106         st = ic->streams[i];
4107
4108         if (st->internal->avctx_inited) {
4109             int orig_w = st->codecpar->width;
4110             int orig_h = st->codecpar->height;
4111             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4112             if (ret < 0)
4113                 goto find_stream_info_err;
4114             ret = add_coded_side_data(st, st->internal->avctx);
4115             if (ret < 0)
4116                 goto find_stream_info_err;
4117 #if FF_API_LOWRES
4118             // The decoder might reduce the video size by the lowres factor.
4119             if (st->internal->avctx->lowres && orig_w) {
4120                 st->codecpar->width = orig_w;
4121                 st->codecpar->height = orig_h;
4122             }
4123 #endif
4124         }
4125
4126 #if FF_API_LAVF_AVCTX
4127 FF_DISABLE_DEPRECATION_WARNINGS
4128         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4129         if (ret < 0)
4130             goto find_stream_info_err;
4131
4132 #if FF_API_LOWRES
4133         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4134         // by the lowres factor.
4135         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4136             st->codec->lowres = st->internal->avctx->lowres;
4137             st->codec->width = st->internal->avctx->width;
4138             st->codec->height = st->internal->avctx->height;
4139         }
4140 #endif
4141
4142         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4143             st->codec->time_base = st->internal->avctx->time_base;
4144             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4145         }
4146         st->codec->framerate = st->avg_frame_rate;
4147
4148         if (st->internal->avctx->subtitle_header) {
4149             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4150             if (!st->codec->subtitle_header)
4151                 goto find_stream_info_err;
4152             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4153             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4154                    st->codec->subtitle_header_size);
4155         }
4156
4157         // Fields unavailable in AVCodecParameters
4158         st->codec->coded_width = st->internal->avctx->coded_width;
4159         st->codec->coded_height = st->internal->avctx->coded_height;
4160         st->codec->properties = st->internal->avctx->properties;
4161 FF_ENABLE_DEPRECATION_WARNINGS
4162 #endif
4163
4164         st->internal->avctx_inited = 0;
4165     }
4166
4167 find_stream_info_err:
4168     for (i = 0; i < ic->nb_streams; i++) {
4169         st = ic->streams[i];
4170         if (st->internal->info)
4171             av_freep(&st->internal->info->duration_error);
4172         avcodec_close(ic->streams[i]->internal->avctx);
4173         av_freep(&ic->streams[i]->internal->info);
4174         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4175         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4176     }
4177     if (ic->pb)
4178         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4179                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4180     return ret;
4181
4182 unref_then_goto_end:
4183     av_packet_unref(&pkt1);
4184     goto find_stream_info_err;
4185 }
4186
4187 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4188 {
4189     int i, j;
4190
4191     for (i = 0; i < ic->nb_programs; i++) {
4192         if (ic->programs[i] == last) {
4193             last = NULL;
4194         } else {
4195             if (!last)
4196                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4197                     if (ic->programs[i]->stream_index[j] == s)
4198                         return ic->programs[i];
4199         }
4200     }
4201     return NULL;
4202 }
4203
4204 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4205                         int wanted_stream_nb, int related_stream,
4206                         AVCodec **decoder_ret, int flags)
4207 {
4208     int i, nb_streams = ic->nb_streams;
4209     int ret = AVERROR_STREAM_NOT_FOUND;
4210     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4211     int count, multiframe, disposition;
4212     int64_t best_bitrate = -1;
4213     int64_t bitrate;
4214     unsigned *program = NULL;
4215     const AVCodec *decoder = NULL, *best_decoder = NULL;
4216
4217     if (related_stream >= 0 && wanted_stream_nb < 0) {
4218         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4219         if (p) {
4220             program    = p->stream_index;
4221             nb_streams = p->nb_stream_indexes;
4222         }
4223     }
4224     for (i = 0; i < nb_streams; i++) {
4225         int real_stream_index = program ? program[i] : i;
4226         AVStream *st          = ic->streams[real_stream_index];
4227         AVCodecParameters *par = st->codecpar;
4228         if (par->codec_type != type)
4229             continue;
4230         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4231             continue;
4232         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4233             continue;
4234         if (decoder_ret) {
4235             decoder = find_decoder(ic, st, par->codec_id);
4236             if (!decoder) {
4237                 if (ret < 0)
4238                     ret = AVERROR_DECODER_NOT_FOUND;
4239                 continue;
4240             }
4241         }
4242         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4243                       + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4244         count = st->codec_info_nb_frames;
4245         bitrate = par->bit_rate;
4246         multiframe = FFMIN(5, count);
4247         if ((best_disposition >  disposition) ||
4248             (best_disposition == disposition && best_multiframe >  multiframe) ||
4249             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4250             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4251             continue;
4252         best_disposition = disposition;
4253         best_count   = count;
4254         best_bitrate = bitrate;
4255         best_multiframe = multiframe;
4256         ret          = real_stream_index;
4257         best_decoder = decoder;
4258         if (program && i == nb_streams - 1 && ret < 0) {
4259             program    = NULL;
4260             nb_streams = ic->nb_streams;
4261             /* no related stream found, try again with everything */
4262             i = 0;
4263         }
4264     }
4265     if (decoder_ret)
4266         *decoder_ret = (AVCodec*)best_decoder;
4267     return ret;
4268 }
4269
4270 /*******************************************************/
4271
4272 int av_read_play(AVFormatContext *s)
4273 {
4274     if (s->iformat->read_play)
4275         return s->iformat->read_play(s);
4276     if (s->pb)
4277         return avio_pause(s->pb, 0);
4278     return AVERROR(ENOSYS);
4279 }
4280
4281 int av_read_pause(AVFormatContext *s)
4282 {
4283     if (s->iformat->read_pause)
4284         return s->iformat->read_pause(s);
4285     if (s->pb)
4286         return avio_pause(s->pb, 1);
4287     return AVERROR(ENOSYS);
4288 }
4289
4290 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4291 {
4292     int ret, i;
4293
4294     dst->id                  = src->id;
4295     dst->time_base           = src->time_base;
4296     dst->nb_frames           = src->nb_frames;
4297     dst->disposition         = src->disposition;
4298     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4299     dst->avg_frame_rate      = src->avg_frame_rate;
4300     dst->r_frame_rate        = src->r_frame_rate;
4301
4302     av_dict_free(&dst->metadata);
4303     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4304     if (ret < 0)
4305         return ret;
4306
4307     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4308     if (ret < 0)
4309         return ret;
4310
4311     /* Free existing side data*/
4312     for (i = 0; i < dst->nb_side_data; i++)
4313         av_free(dst->side_data[i].data);
4314     av_freep(&dst->side_data);
4315     dst->nb_side_data = 0;
4316
4317     /* Copy side data if present */
4318     if (src->nb_side_data) {
4319         dst->side_data = av_mallocz_array(src->nb_side_data,
4320                                           sizeof(AVPacketSideData));
4321         if (!dst->side_data)
4322             return AVERROR(ENOMEM);
4323         dst->nb_side_data = src->nb_side_data;
4324
4325         for (i = 0; i < src->nb_side_data; i++) {
4326             uint8_t *data = av_memdup(src->side_data[i].data,
4327                                       src->side_data[i].size);
4328             if (!data)
4329                 return AVERROR(ENOMEM);
4330             dst->side_data[i].type = src->side_data[i].type;
4331             dst->side_data[i].size = src->side_data[i].size;
4332             dst->side_data[i].data = data;
4333         }
4334     }
4335
4336 #if FF_API_LAVF_FFSERVER
4337 FF_DISABLE_DEPRECATION_WARNINGS
4338     av_freep(&dst->recommended_encoder_configuration);
4339     if (src->recommended_encoder_configuration) {
4340         const char *conf_str = src->recommended_encoder_configuration;
4341         dst->recommended_encoder_configuration = av_strdup(conf_str);
4342         if (!dst->recommended_encoder_configuration)
4343             return AVERROR(ENOMEM);
4344     }
4345 FF_ENABLE_DEPRECATION_WARNINGS
4346 #endif
4347
4348     return 0;
4349 }
4350
4351 static void free_stream(AVStream **pst)
4352 {
4353     AVStream *st = *pst;
4354     int i;
4355
4356     if (!st)
4357         return;
4358
4359     for (i = 0; i < st->nb_side_data; i++)
4360         av_freep(&st->side_data[i].data);
4361     av_freep(&st->side_data);
4362
4363     if (st->parser)
4364         av_parser_close(st->parser);
4365
4366     if (st->attached_pic.data)
4367         av_packet_unref(&st->attached_pic);
4368
4369     if (st->internal) {
4370         avcodec_free_context(&st->internal->avctx);
4371         av_bsf_free(&st->internal->bsfc);
4372         av_freep(&st->internal->priv_pts);
4373         av_freep(&st->internal->index_entries);
4374         av_freep(&st->internal->probe_data.buf);
4375
4376         av_bsf_free(&st->internal->extract_extradata.bsf);
4377         av_packet_free(&st->internal->extract_extradata.pkt);
4378
4379         if (st->internal->info)
4380             av_freep(&st->internal->info->duration_error);
4381         av_freep(&st->internal->info);
4382     }
4383     av_freep(&st->internal);
4384
4385     av_dict_free(&st->metadata);
4386     avcodec_parameters_free(&st->codecpar);
4387 #if FF_API_LAVF_AVCTX
4388 FF_DISABLE_DEPRECATION_WARNINGS
4389     avcodec_free_context(&st->codec);
4390 FF_ENABLE_DEPRECATION_WARNINGS
4391 #endif
4392     av_freep(&st->priv_data);
4393 #if FF_API_LAVF_FFSERVER
4394 FF_DISABLE_DEPRECATION_WARNINGS
4395     av_freep(&st->recommended_encoder_configuration);
4396 FF_ENABLE_DEPRECATION_WARNINGS
4397 #endif
4398
4399     av_freep(pst);
4400 }
4401
4402 void ff_free_stream(AVFormatContext *s, AVStream *st)
4403 {
4404     av_assert0(s->nb_streams>0);
4405     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4406
4407     free_stream(&s->streams[ --s->nb_streams ]);
4408 }
4409
4410 void avformat_free_context(AVFormatContext *s)
4411 {
4412     int i;
4413
4414     if (!s)
4415         return;
4416
4417     if (s->oformat && s->oformat->deinit && s->internal->initialized)
4418         s->oformat->deinit(s);
4419
4420     av_opt_free(s);
4421     if (s->iformat && s->iformat->priv_class && s->priv_data)
4422         av_opt_free(s->priv_data);
4423     if (s->oformat && s->oformat->priv_class && s->priv_data)
4424         av_opt_free(s->priv_data);
4425
4426     for (i = 0; i < s->nb_streams; i++)
4427         free_stream(&s->streams[i]);
4428     s->nb_streams = 0;
4429
4430     for (i = 0; i < s->nb_programs; i++) {
4431         av_dict_free(&s->programs[i]->metadata);
4432         av_freep(&s->programs[i]->stream_index);
4433         av_freep(&s->programs[i]);
4434     }
4435     s->nb_programs = 0;
4436
4437     av_freep(&s->programs);
4438     av_freep(&s->priv_data);
4439     while (s->nb_chapters--) {
4440         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4441         av_freep(&s->chapters[s->nb_chapters]);
4442     }
4443     av_freep(&s->chapters);
4444     av_dict_free(&s->metadata);
4445     av_dict_free(&s->internal->id3v2_meta);
4446     av_freep(&s->streams);
4447     flush_packet_queue(s);
4448     av_freep(&s->internal);
4449     av_freep(&s->url);
4450     av_free(s);
4451 }
4452
4453 void avformat_close_input(AVFormatContext **ps)
4454 {
4455     AVFormatContext *s;
4456     AVIOContext *pb;
4457
4458     if (!ps || !*ps)
4459         return;
4460
4461     s  = *ps;
4462     pb = s->pb;
4463
4464     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4465         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4466         pb = NULL;
4467
4468     flush_packet_queue(s);
4469
4470     if (s->iformat)
4471         if (s->iformat->read_close)
4472             s->iformat->read_close(s);
4473
4474     avformat_free_context(s);
4475
4476     *ps = NULL;
4477
4478     avio_close(pb);
4479 }
4480
4481 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4482 {
4483     AVStream *st;
4484     int i;
4485     AVStream **streams;
4486
4487     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4488         if (s->max_streams < INT_MAX/sizeof(*streams))
4489             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);
4490         return NULL;
4491     }
4492     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4493     if (!streams)
4494         return NULL;
4495     s->streams = streams;
4496
4497     st = av_mallocz(sizeof(AVStream));
4498     if (!st)
4499         return NULL;
4500
4501 #if FF_API_LAVF_AVCTX
4502 FF_DISABLE_DEPRECATION_WARNINGS
4503     st->codec = avcodec_alloc_context3(c);
4504     if (!st->codec) {
4505         av_free(st);
4506         return NULL;
4507     }
4508 FF_ENABLE_DEPRECATION_WARNINGS
4509 #endif
4510
4511     st->internal = av_mallocz(sizeof(*st->internal));
4512     if (!st->internal)
4513         goto fail;
4514
4515     st->internal->info = av_mallocz(sizeof(*st->internal->info));
4516     if (!st->internal->info)
4517         goto fail;
4518     st->internal->info->last_dts = AV_NOPTS_VALUE;
4519
4520     st->codecpar = avcodec_parameters_alloc();
4521     if (!st->codecpar)
4522         goto fail;
4523
4524     st->internal->avctx = avcodec_alloc_context3(NULL);
4525     if (!st->internal->avctx)
4526         goto fail;
4527
4528     if (s->iformat) {
4529 #if FF_API_LAVF_AVCTX
4530 FF_DISABLE_DEPRECATION_WARNINGS
4531         /* no default bitrate if decoding */
4532         st->codec->bit_rate = 0;
4533 FF_ENABLE_DEPRECATION_WARNINGS
4534 #endif
4535
4536         /* default pts setting is MPEG-like */
4537         avpriv_set_pts_info(st, 33, 1, 90000);
4538         /* we set the current DTS to 0 so that formats without any timestamps
4539          * but durations get some timestamps, formats with some unknown
4540          * timestamps have their first few packets buffered and the
4541          * timestamps corrected before they are returned to the user */
4542         st->cur_dts = RELATIVE_TS_BASE;
4543     } else {
4544         st->cur_dts = AV_NOPTS_VALUE;
4545     }
4546
4547     st->index      = s->nb_streams;
4548     st->start_time = AV_NOPTS_VALUE;
4549     st->duration   = AV_NOPTS_VALUE;
4550     st->first_dts     = AV_NOPTS_VALUE;
4551     st->probe_packets = s->max_probe_packets;
4552     st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4553     st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4554
4555     st->last_IP_pts = AV_NOPTS_VALUE;
4556     st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4557     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4558         st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4559
4560     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4561
4562 #if FF_API_R_FRAME_RATE
4563     st->internal->info->last_dts      = AV_NOPTS_VALUE;
4564 #endif
4565     st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4566     st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
4567
4568     st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4569
4570     st->internal->need_context_update = 1;
4571
4572     s->streams[s->nb_streams++] = st;
4573     return st;
4574 fail:
4575     free_stream(&st);
4576     return NULL;
4577 }
4578
4579 AVProgram *av_new_program(AVFormatContext *ac, int id)
4580 {
4581     AVProgram *program = NULL;
4582     int i;
4583
4584     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4585
4586     for (i = 0; i < ac->nb_programs; i++)
4587         if (ac->programs[i]->id == id)
4588             program = ac->programs[i];
4589
4590     if (!program) {
4591         program = av_mallocz(sizeof(AVProgram));
4592         if (!program)
4593             return NULL;
4594         dynarray_add(&ac->programs, &ac->nb_programs, program);
4595         program->discard = AVDISCARD_NONE;
4596         program->pmt_version = -1;
4597         program->id = id;
4598         program->pts_wrap_reference = AV_NOPTS_VALUE;
4599         program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4600         program->start_time =
4601         program->end_time   = AV_NOPTS_VALUE;
4602     }
4603     return program;
4604 }
4605
4606 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4607                               int64_t start, int64_t end, const char *title)
4608 {
4609     AVChapter *chapter = NULL;
4610     int i;
4611
4612     if (end != AV_NOPTS_VALUE && start > end) {
4613         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4614         return NULL;
4615     }
4616
4617     for (i = 0; i < s->nb_chapters; i++)
4618         if (s->chapters[i]->id == id)
4619             chapter = s->chapters[i];
4620
4621     if (!chapter) {
4622         chapter = av_mallocz(sizeof(AVChapter));
4623         if (!chapter)
4624             return NULL;
4625         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4626     }
4627     av_dict_set(&chapter->metadata, "title", title, 0);
4628     chapter->id        = id;
4629     chapter->time_base = time_base;
4630     chapter->start     = start;
4631     chapter->end       = end;
4632
4633     return chapter;
4634 }
4635
4636 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4637 {
4638     int i, j;
4639     AVProgram *program = NULL;
4640     void *tmp;
4641
4642     if (idx >= ac->nb_streams) {
4643         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4644         return;
4645     }
4646
4647     for (i = 0; i < ac->nb_programs; i++) {
4648         if (ac->programs[i]->id != progid)
4649             continue;
4650         program = ac->programs[i];
4651         for (j = 0; j < program->nb_stream_indexes; j++)
4652             if (program->stream_index[j] == idx)
4653                 return;
4654
4655         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4656         if (!tmp)
4657             return;
4658         program->stream_index = tmp;
4659         program->stream_index[program->nb_stream_indexes++] = idx;
4660         return;
4661     }
4662 }
4663
4664 uint64_t ff_ntp_time(void)
4665 {
4666     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4667 }
4668
4669 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4670 {
4671     uint64_t ntp_ts, frac_part, sec;
4672     uint32_t usec;
4673
4674     //current ntp time in seconds and micro seconds
4675     sec = ntp_time_us / 1000000;
4676     usec = ntp_time_us % 1000000;
4677
4678     //encoding in ntp timestamp format
4679     frac_part = usec * 0xFFFFFFFFULL;
4680     frac_part /= 1000000;
4681
4682     if (sec > 0xFFFFFFFFULL)
4683         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4684
4685     ntp_ts = sec << 32;
4686     ntp_ts |= frac_part;
4687
4688     return ntp_ts;
4689 }
4690
4691 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4692 {
4693     const char *p;
4694     char *q, buf1[20], c;
4695     int nd, len, percentd_found;
4696
4697     q = buf;
4698     p = path;
4699     percentd_found = 0;
4700     for (;;) {
4701         c = *p++;
4702         if (c == '\0')
4703             break;
4704         if (c == '%') {
4705             do {
4706                 nd = 0;
4707                 while (av_isdigit(*p)) {
4708                     if (nd >= INT_MAX / 10 - 255)
4709                         goto fail;
4710                     nd = nd * 10 + *p++ - '0';
4711                 }
4712                 c = *p++;
4713             } while (av_isdigit(c));
4714
4715             switch (c) {
4716             case '%':
4717                 goto addchar;
4718             case 'd':
4719                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4720                     goto fail;
4721                 percentd_found = 1;
4722                 if (number < 0)
4723                     nd += 1;
4724                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4725                 len = strlen(buf1);
4726                 if ((q - buf + len) > buf_size - 1)
4727                     goto fail;
4728                 memcpy(q, buf1, len);
4729                 q += len;
4730                 break;
4731             default:
4732                 goto fail;
4733             }
4734         } else {
4735 addchar:
4736             if ((q - buf) < buf_size - 1)
4737                 *q++ = c;
4738         }
4739     }
4740     if (!percentd_found)
4741         goto fail;
4742     *q = '\0';
4743     return 0;
4744 fail:
4745     *q = '\0';
4746     return -1;
4747 }
4748
4749 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4750 {
4751     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4752 }
4753
4754 void av_url_split(char *proto, int proto_size,
4755                   char *authorization, int authorization_size,
4756                   char *hostname, int hostname_size,
4757                   int *port_ptr, char *path, int path_size, const char *url)
4758 {
4759     const char *p, *ls, *at, *at2, *col, *brk;
4760
4761     if (port_ptr)
4762         *port_ptr = -1;
4763     if (proto_size > 0)
4764         proto[0] = 0;
4765     if (authorization_size > 0)
4766         authorization[0] = 0;
4767     if (hostname_size > 0)
4768         hostname[0] = 0;
4769     if (path_size > 0)
4770         path[0] = 0;
4771
4772     /* parse protocol */
4773     if ((p = strchr(url, ':'))) {
4774         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4775         p++; /* skip ':' */
4776         if (*p == '/')
4777             p++;
4778         if (*p == '/')
4779             p++;
4780     } else {
4781         /* no protocol means plain filename */
4782         av_strlcpy(path, url, path_size);
4783         return;
4784     }
4785
4786     /* separate path from hostname */
4787     ls = p + strcspn(p, "/?#");
4788     av_strlcpy(path, ls, path_size);
4789
4790     /* the rest is hostname, use that to parse auth/port */
4791     if (ls != p) {
4792         /* authorization (user[:pass]@hostname) */
4793         at2 = p;
4794         while ((at = strchr(p, '@')) && at < ls) {
4795             av_strlcpy(authorization, at2,
4796                        FFMIN(authorization_size, at + 1 - at2));
4797             p = at + 1; /* skip '@' */
4798         }
4799
4800         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4801             /* [host]:port */
4802             av_strlcpy(hostname, p + 1,
4803                        FFMIN(hostname_size, brk - p));
4804             if (brk[1] == ':' && port_ptr)
4805                 *port_ptr = atoi(brk + 2);
4806         } else if ((col = strchr(p, ':')) && col < ls) {
4807             av_strlcpy(hostname, p,
4808                        FFMIN(col + 1 - p, hostname_size));
4809             if (port_ptr)
4810                 *port_ptr = atoi(col + 1);
4811         } else
4812             av_strlcpy(hostname, p,
4813                        FFMIN(ls + 1 - p, hostname_size));
4814     }
4815 }
4816
4817 int ff_mkdir_p(const char *path)
4818 {
4819     int ret = 0;
4820     char *temp = av_strdup(path);
4821     char *pos = temp;
4822     char tmp_ch = '\0';
4823
4824     if (!path || !temp) {
4825         return -1;
4826     }
4827
4828     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4829         pos++;
4830     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4831         pos += 2;
4832     }
4833
4834     for ( ; *pos != '\0'; ++pos) {
4835         if (*pos == '/' || *pos == '\\') {
4836             tmp_ch = *pos;
4837             *pos = '\0';
4838             ret = mkdir(temp, 0755);
4839             *pos = tmp_ch;
4840         }
4841     }
4842
4843     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4844         ret = mkdir(temp, 0755);
4845     }
4846
4847     av_free(temp);
4848     return ret;
4849 }
4850
4851 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4852 {
4853     int i;
4854     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4855                                            '4', '5', '6', '7',
4856                                            '8', '9', 'A', 'B',
4857                                            'C', 'D', 'E', 'F' };
4858     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4859                                            '4', '5', '6', '7',
4860                                            '8', '9', 'a', 'b',
4861                                            'c', 'd', 'e', 'f' };
4862     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4863
4864     for (i = 0; i < s; i++) {
4865         buff[i * 2]     = hex_table[src[i] >> 4];
4866         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4867     }
4868
4869     return buff;
4870 }
4871
4872 int ff_hex_to_data(uint8_t *data, const char *p)
4873 {
4874     int c, len, v;
4875
4876     len = 0;
4877     v   = 1;
4878     for (;;) {
4879         p += strspn(p, SPACE_CHARS);
4880         if (*p == '\0')
4881             break;
4882         c = av_toupper((unsigned char) *p++);
4883         if (c >= '0' && c <= '9')
4884             c = c - '0';
4885         else if (c >= 'A' && c <= 'F')
4886             c = c - 'A' + 10;
4887         else
4888             break;
4889         v = (v << 4) | c;
4890         if (v & 0x100) {
4891             if (data)
4892                 data[len] = v;
4893             len++;
4894             v = 1;
4895         }
4896     }
4897     return len;
4898 }
4899
4900 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4901                          unsigned int pts_num, unsigned int pts_den)
4902 {
4903     AVRational new_tb;
4904     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4905         if (new_tb.num != pts_num)
4906             av_log(NULL, AV_LOG_DEBUG,
4907                    "st:%d removing common factor %d from timebase\n",
4908                    s->index, pts_num / new_tb.num);
4909     } else
4910         av_log(NULL, AV_LOG_WARNING,
4911                "st:%d has too large timebase, reducing\n", s->index);
4912
4913     if (new_tb.num <= 0 || new_tb.den <= 0) {
4914         av_log(NULL, AV_LOG_ERROR,
4915                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4916                new_tb.num, new_tb.den,
4917                s->index);
4918         return;
4919     }
4920     s->time_base     = new_tb;
4921 #if FF_API_LAVF_AVCTX
4922 FF_DISABLE_DEPRECATION_WARNINGS
4923     s->codec->pkt_timebase = new_tb;
4924 FF_ENABLE_DEPRECATION_WARNINGS
4925 #endif
4926     s->internal->avctx->pkt_timebase = new_tb;
4927     s->pts_wrap_bits = pts_wrap_bits;
4928 }
4929
4930 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4931                         void *context)
4932 {
4933     const char *ptr = str;
4934
4935     /* Parse key=value pairs. */
4936     for (;;) {
4937         const char *key;
4938         char *dest = NULL, *dest_end;
4939         int key_len, dest_len = 0;
4940
4941         /* Skip whitespace and potential commas. */
4942         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4943             ptr++;
4944         if (!*ptr)
4945             break;
4946
4947         key = ptr;
4948
4949         if (!(ptr = strchr(key, '=')))
4950             break;
4951         ptr++;
4952         key_len = ptr - key;
4953
4954         callback_get_buf(context, key, key_len, &dest, &dest_len);
4955         dest_end = dest + dest_len - 1;
4956
4957         if (*ptr == '\"') {
4958             ptr++;
4959             while (*ptr && *ptr != '\"') {
4960                 if (*ptr == '\\') {
4961                     if (!ptr[1])
4962                         break;
4963                     if (dest && dest < dest_end)
4964                         *dest++ = ptr[1];
4965                     ptr += 2;
4966                 } else {
4967                     if (dest && dest < dest_end)
4968                         *dest++ = *ptr;
4969                     ptr++;
4970                 }
4971             }
4972             if (*ptr == '\"')
4973                 ptr++;
4974         } else {
4975             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4976                 if (dest && dest < dest_end)
4977                     *dest++ = *ptr;
4978         }
4979         if (dest)
4980             *dest = 0;
4981     }
4982 }
4983
4984 int ff_find_stream_index(AVFormatContext *s, int id)
4985 {
4986     int i;
4987     for (i = 0; i < s->nb_streams; i++)
4988         if (s->streams[i]->id == id)
4989             return i;
4990     return -1;
4991 }
4992
4993 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4994                          int std_compliance)
4995 {
4996     if (ofmt) {
4997         unsigned int codec_tag;
4998         if (ofmt->query_codec)
4999             return ofmt->query_codec(codec_id, std_compliance);
5000         else if (ofmt->codec_tag)
5001             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5002         else if (codec_id == ofmt->video_codec ||
5003                  codec_id == ofmt->audio_codec ||
5004                  codec_id == ofmt->subtitle_codec ||
5005                  codec_id == ofmt->data_codec)
5006             return 1;
5007     }
5008     return AVERROR_PATCHWELCOME;
5009 }
5010
5011 int avformat_network_init(void)
5012 {
5013 #if CONFIG_NETWORK
5014     int ret;
5015     if ((ret = ff_network_init()) < 0)
5016         return ret;
5017     if ((ret = ff_tls_init()) < 0)
5018         return ret;
5019 #endif
5020     return 0;
5021 }
5022
5023 int avformat_network_deinit(void)
5024 {
5025 #if CONFIG_NETWORK
5026     ff_network_close();
5027     ff_tls_deinit();
5028 #endif
5029     return 0;
5030 }
5031
5032 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5033                         uint64_t channel_layout, int32_t sample_rate,
5034                         int32_t width, int32_t height)
5035 {
5036     uint32_t flags = 0;
5037     int size = 4;
5038     uint8_t *data;
5039     if (!pkt)
5040         return AVERROR(EINVAL);
5041     if (channels) {
5042         size  += 4;
5043         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5044     }
5045     if (channel_layout) {
5046         size  += 8;
5047         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5048     }
5049     if (sample_rate) {
5050         size  += 4;
5051         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5052     }
5053     if (width || height) {
5054         size  += 8;
5055         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5056     }
5057     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5058     if (!data)
5059         return AVERROR(ENOMEM);
5060     bytestream_put_le32(&data, flags);
5061     if (channels)
5062         bytestream_put_le32(&data, channels);
5063     if (channel_layout)
5064         bytestream_put_le64(&data, channel_layout);
5065     if (sample_rate)
5066         bytestream_put_le32(&data, sample_rate);
5067     if (width || height) {
5068         bytestream_put_le32(&data, width);
5069         bytestream_put_le32(&data, height);
5070     }
5071     return 0;
5072 }
5073
5074 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5075 {
5076     AVRational undef = {0, 1};
5077     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5078     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5079     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5080
5081     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5082                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5083     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5084         stream_sample_aspect_ratio = undef;
5085
5086     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5087                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5088     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5089         frame_sample_aspect_ratio = undef;
5090
5091     if (stream_sample_aspect_ratio.num)
5092         return stream_sample_aspect_ratio;
5093     else
5094         return frame_sample_aspect_ratio;
5095 }
5096
5097 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5098 {
5099     AVRational fr = st->r_frame_rate;
5100     AVRational codec_fr = st->internal->avctx->framerate;
5101     AVRational   avg_fr = st->avg_frame_rate;
5102
5103     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5104         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5105         fr = avg_fr;
5106     }
5107
5108
5109     if (st->internal->avctx->ticks_per_frame > 1) {
5110         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5111             (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))
5112             fr = codec_fr;
5113     }
5114
5115     return fr;
5116 }
5117
5118 /**
5119  * Matches a stream specifier (but ignores requested index).
5120  *
5121  * @param indexptr set to point to the requested stream index if there is one
5122  *
5123  * @return <0 on error
5124  *         0  if st is NOT a matching stream
5125  *         >0 if st is a matching stream
5126  */
5127 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5128                                   const char *spec, const char **indexptr, AVProgram **p)
5129 {
5130     int match = 1;                      /* Stores if the specifier matches so far. */
5131     while (*spec) {
5132         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5133             if (indexptr)
5134                 *indexptr = spec;
5135             return match;
5136         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5137                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5138             enum AVMediaType type;
5139             int nopic = 0;
5140
5141             switch (*spec++) {
5142             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5143             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5144             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5145             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5146             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5147             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5148             default:  av_assert0(0);
5149             }
5150             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5151                 return AVERROR(EINVAL);
5152
5153 #if FF_API_LAVF_AVCTX
5154 FF_DISABLE_DEPRECATION_WARNINGS
5155             if (type != st->codecpar->codec_type
5156                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5157                 match = 0;
5158     FF_ENABLE_DEPRECATION_WARNINGS
5159 #else
5160             if (type != st->codecpar->codec_type)
5161                 match = 0;
5162 #endif
5163             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5164                 match = 0;
5165         } else if (*spec == 'p' && *(spec + 1) == ':') {
5166             int prog_id, i, j;
5167             int found = 0;
5168             char *endptr;
5169             spec += 2;
5170             prog_id = strtol(spec, &endptr, 0);
5171             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5172             if (spec == endptr || (*endptr && *endptr++ != ':'))
5173                 return AVERROR(EINVAL);
5174             spec = endptr;
5175             if (match) {
5176                 for (i = 0; i < s->nb_programs; i++) {
5177                     if (s->programs[i]->id != prog_id)
5178                         continue;
5179
5180                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5181                         if (st->index == s->programs[i]->stream_index[j]) {
5182                             found = 1;
5183                             if (p)
5184                                 *p = s->programs[i];
5185                             i = s->nb_programs;
5186                             break;
5187                         }
5188                     }
5189                 }
5190             }
5191             if (!found)
5192                 match = 0;
5193         } else if (*spec == '#' ||
5194                    (*spec == 'i' && *(spec + 1) == ':')) {
5195             int stream_id;
5196             char *endptr;
5197             spec += 1 + (*spec == 'i');
5198             stream_id = strtol(spec, &endptr, 0);
5199             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5200                 return AVERROR(EINVAL);
5201             return match && (stream_id == st->id);
5202         } else if (*spec == 'm' && *(spec + 1) == ':') {
5203             AVDictionaryEntry *tag;
5204             char *key, *val;
5205             int ret;
5206
5207             if (match) {
5208                spec += 2;
5209                val = strchr(spec, ':');
5210
5211                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5212                if (!key)
5213                    return AVERROR(ENOMEM);
5214
5215                tag = av_dict_get(st->metadata, key, NULL, 0);
5216                if (tag) {
5217                    if (!val || !strcmp(tag->value, val + 1))
5218                        ret = 1;
5219                    else
5220                        ret = 0;
5221                } else
5222                    ret = 0;
5223
5224                av_freep(&key);
5225             }
5226             return match && ret;
5227         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5228             AVCodecParameters *par = st->codecpar;
5229 #if FF_API_LAVF_AVCTX
5230 FF_DISABLE_DEPRECATION_WARNINGS
5231             AVCodecContext *codec = st->codec;
5232 FF_ENABLE_DEPRECATION_WARNINGS
5233 #endif
5234             int val;
5235             switch (par->codec_type) {
5236             case AVMEDIA_TYPE_AUDIO:
5237                 val = par->sample_rate && par->channels;
5238 #if FF_API_LAVF_AVCTX
5239                 val = val || (codec->sample_rate && codec->channels);
5240 #endif
5241                 if (par->format == AV_SAMPLE_FMT_NONE
5242 #if FF_API_LAVF_AVCTX
5243                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5244 #endif
5245                     )
5246                     return 0;
5247                 break;
5248             case AVMEDIA_TYPE_VIDEO:
5249                 val = par->width && par->height;
5250 #if FF_API_LAVF_AVCTX
5251                 val = val || (codec->width && codec->height);
5252 #endif
5253                 if (par->format == AV_PIX_FMT_NONE
5254 #if FF_API_LAVF_AVCTX
5255                     && codec->pix_fmt == AV_PIX_FMT_NONE
5256 #endif
5257                     )
5258                     return 0;
5259                 break;
5260             case AVMEDIA_TYPE_UNKNOWN:
5261                 val = 0;
5262                 break;
5263             default:
5264                 val = 1;
5265                 break;
5266             }
5267 #if FF_API_LAVF_AVCTX
5268             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5269 #else
5270             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5271 #endif
5272         } else {
5273             return AVERROR(EINVAL);
5274         }
5275     }
5276
5277     return match;
5278 }
5279
5280
5281 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5282                                     const char *spec)
5283 {
5284     int ret, index;
5285     char *endptr;
5286     const char *indexptr = NULL;
5287     AVProgram *p = NULL;
5288     int nb_streams;
5289
5290     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5291     if (ret < 0)
5292         goto error;
5293
5294     if (!indexptr)
5295         return ret;
5296
5297     index = strtol(indexptr, &endptr, 0);
5298     if (*endptr) {                  /* We can't have anything after the requested index. */
5299         ret = AVERROR(EINVAL);
5300         goto error;
5301     }
5302
5303     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5304     if (spec == indexptr)
5305         return (index == st->index);
5306
5307     /* If we requested a matching stream index, we have to ensure st is that. */
5308     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5309     for (int i = 0; i < nb_streams && index >= 0; i++) {
5310         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5311         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5312         if (ret < 0)
5313             goto error;
5314         if (ret > 0 && index-- == 0 && st == candidate)
5315             return 1;
5316     }
5317     return 0;
5318
5319 error:
5320     if (ret == AVERROR(EINVAL))
5321         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5322     return ret;
5323 }
5324
5325 int ff_generate_avci_extradata(AVStream *st)
5326 {
5327     static const uint8_t avci100_1080p_extradata[] = {
5328         // SPS
5329         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5330         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5331         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5332         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5333         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5334         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5335         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5336         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5337         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5338         // PPS
5339         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5340         0xd0
5341     };
5342     static const uint8_t avci100_1080i_extradata[] = {
5343         // SPS
5344         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5345         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5346         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5347         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5348         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5349         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5350         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5351         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5352         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5353         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5354         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5355         // PPS
5356         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5357         0xd0
5358     };
5359     static const uint8_t avci50_1080p_extradata[] = {
5360         // SPS
5361         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5362         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5363         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5364         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5365         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5366         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5367         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5368         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5369         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5370         // PPS
5371         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5372         0x11
5373     };
5374     static const uint8_t avci50_1080i_extradata[] = {
5375         // SPS
5376         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5377         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5378         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5379         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5380         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5381         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5382         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5383         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5384         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5385         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5386         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5387         // PPS
5388         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5389         0x11
5390     };
5391     static const uint8_t avci100_720p_extradata[] = {
5392         // SPS
5393         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5394         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5395         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5396         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5397         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5398         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5399         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5400         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5401         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5402         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5403         // PPS
5404         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5405         0x11
5406     };
5407     static const uint8_t avci50_720p_extradata[] = {
5408         // SPS
5409         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5410         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5411         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5412         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5413         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5414         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5415         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5416         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5417         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5418         // PPS
5419         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5420         0x11
5421     };
5422
5423     const uint8_t *data = NULL;
5424     int ret, size       = 0;
5425
5426     if (st->codecpar->width == 1920) {
5427         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5428             data = avci100_1080p_extradata;
5429             size = sizeof(avci100_1080p_extradata);
5430         } else {
5431             data = avci100_1080i_extradata;
5432             size = sizeof(avci100_1080i_extradata);
5433         }
5434     } else if (st->codecpar->width == 1440) {
5435         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5436             data = avci50_1080p_extradata;
5437             size = sizeof(avci50_1080p_extradata);
5438         } else {
5439             data = avci50_1080i_extradata;
5440             size = sizeof(avci50_1080i_extradata);
5441         }
5442     } else if (st->codecpar->width == 1280) {
5443         data = avci100_720p_extradata;
5444         size = sizeof(avci100_720p_extradata);
5445     } else if (st->codecpar->width == 960) {
5446         data = avci50_720p_extradata;
5447         size = sizeof(avci50_720p_extradata);
5448     }
5449
5450     if (!size)
5451         return 0;
5452
5453     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5454         return ret;
5455     memcpy(st->codecpar->extradata, data, size);
5456
5457     return 0;
5458 }
5459
5460 uint8_t *av_stream_get_side_data(const AVStream *st,
5461                                  enum AVPacketSideDataType type, int *size)
5462 {
5463     int i;
5464
5465     for (i = 0; i < st->nb_side_data; i++) {
5466         if (st->side_data[i].type == type) {
5467             if (size)
5468                 *size = st->side_data[i].size;
5469             return st->side_data[i].data;
5470         }
5471     }
5472     if (size)
5473         *size = 0;
5474     return NULL;
5475 }
5476
5477 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5478                             uint8_t *data, size_t size)
5479 {
5480     AVPacketSideData *sd, *tmp;
5481     int i;
5482
5483     for (i = 0; i < st->nb_side_data; i++) {
5484         sd = &st->side_data[i];
5485
5486         if (sd->type == type) {
5487             av_freep(&sd->data);
5488             sd->data = data;
5489             sd->size = size;
5490             return 0;
5491         }
5492     }
5493
5494     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5495         return AVERROR(ERANGE);
5496
5497     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5498     if (!tmp) {
5499         return AVERROR(ENOMEM);
5500     }
5501
5502     st->side_data = tmp;
5503     st->nb_side_data++;
5504
5505     sd = &st->side_data[st->nb_side_data - 1];
5506     sd->type = type;
5507     sd->data = data;
5508     sd->size = size;
5509
5510     return 0;
5511 }
5512
5513 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5514                                  int size)
5515 {
5516     int ret;
5517     uint8_t *data = av_malloc(size);
5518
5519     if (!data)
5520         return NULL;
5521
5522     ret = av_stream_add_side_data(st, type, data, size);
5523     if (ret < 0) {
5524         av_freep(&data);
5525         return NULL;
5526     }
5527
5528     return data;
5529 }
5530
5531 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5532 {
5533     int ret;
5534     const AVBitStreamFilter *bsf;
5535     AVBSFContext *bsfc;
5536
5537     av_assert0(!st->internal->bsfc);
5538
5539     if (!(bsf = av_bsf_get_by_name(name))) {
5540         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5541         return AVERROR_BSF_NOT_FOUND;
5542     }
5543
5544     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5545         return ret;
5546
5547     bsfc->time_base_in = st->time_base;
5548     if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5549         av_bsf_free(&bsfc);
5550         return ret;
5551     }
5552
5553     if (args && bsfc->filter->priv_class) {
5554         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5555         const char * shorthand[2] = {NULL};
5556
5557         if (opt)
5558             shorthand[0] = opt->name;
5559
5560         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5561             av_bsf_free(&bsfc);
5562             return ret;
5563         }
5564     }
5565
5566     if ((ret = av_bsf_init(bsfc)) < 0) {
5567         av_bsf_free(&bsfc);
5568         return ret;
5569     }
5570
5571     st->internal->bsfc = bsfc;
5572
5573     av_log(NULL, AV_LOG_VERBOSE,
5574            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5575            name, args ? args : "");
5576     return 1;
5577 }
5578
5579 #if FF_API_OLD_BSF
5580 FF_DISABLE_DEPRECATION_WARNINGS
5581 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5582                                AVBitStreamFilterContext *bsfc)
5583 {
5584     int ret = 0;
5585     while (bsfc) {
5586         AVPacket new_pkt = *pkt;
5587         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5588                                            &new_pkt.data, &new_pkt.size,
5589                                            pkt->data, pkt->size,
5590                                            pkt->flags & AV_PKT_FLAG_KEY);
5591         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5592             av_packet_unref(pkt);
5593             memset(pkt, 0, sizeof(*pkt));
5594             return 0;
5595         }
5596         if(a == 0 && new_pkt.data != pkt->data) {
5597             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
5598             if (t) {
5599                 memcpy(t, new_pkt.data, new_pkt.size);
5600                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5601                 new_pkt.data = t;
5602                 new_pkt.buf = NULL;
5603                 a = 1;
5604             } else {
5605                 a = AVERROR(ENOMEM);
5606             }
5607         }
5608         if (a > 0) {
5609             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5610                                            av_buffer_default_free, NULL, 0);
5611             if (new_pkt.buf) {
5612                 pkt->side_data = NULL;
5613                 pkt->side_data_elems = 0;
5614                 av_packet_unref(pkt);
5615             } else {
5616                 av_freep(&new_pkt.data);
5617                 a = AVERROR(ENOMEM);
5618             }
5619         }
5620         if (a < 0) {
5621             av_log(codec, AV_LOG_ERROR,
5622                    "Failed to open bitstream filter %s for stream %d with codec %s",
5623                    bsfc->filter->name, pkt->stream_index,
5624                    codec->codec ? codec->codec->name : "copy");
5625             ret = a;
5626             break;
5627         }
5628         *pkt = new_pkt;
5629
5630         bsfc = bsfc->next;
5631     }
5632     return ret;
5633 }
5634 FF_ENABLE_DEPRECATION_WARNINGS
5635 #endif
5636
5637 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5638 {
5639     if (!s->oformat)
5640         return AVERROR(EINVAL);
5641
5642     if (!(s->oformat->flags & AVFMT_NOFILE))
5643         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5644     return 0;
5645 }
5646
5647 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5648 {
5649     if (*pb)
5650         s->io_close(s, *pb);
5651     *pb = NULL;
5652 }
5653
5654 int ff_is_http_proto(char *filename) {
5655     const char *proto = avio_find_protocol_name(filename);
5656     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5657 }
5658
5659 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5660 {
5661     AVDictionaryEntry *entry;
5662     int64_t parsed_timestamp;
5663     int ret;
5664     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5665         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5666             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5667             return 1;
5668         } else {
5669             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5670             return ret;
5671         }
5672     }
5673     return 0;
5674 }
5675
5676 int ff_standardize_creation_time(AVFormatContext *s)
5677 {
5678     int64_t timestamp;
5679     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5680     if (ret == 1)
5681         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5682     return ret;
5683 }
5684
5685 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5686 {
5687     uint8_t *side_data;
5688     int size;
5689
5690     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5691     if (side_data) {
5692         if (size != AVPALETTE_SIZE) {
5693             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5694             return AVERROR_INVALIDDATA;
5695         }
5696         memcpy(palette, side_data, AVPALETTE_SIZE);
5697         return 1;
5698     }
5699
5700     if (ret == CONTAINS_PAL) {
5701         int i;
5702         for (i = 0; i < AVPALETTE_COUNT; i++)
5703             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5704         return 1;
5705     }
5706
5707     return 0;
5708 }
5709
5710 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5711 {
5712     int ret;
5713     char *str;
5714
5715     ret = av_bprint_finalize(buf, &str);
5716     if (ret < 0)
5717         return ret;
5718     if (!av_bprint_is_complete(buf)) {
5719         av_free(str);
5720         return AVERROR(ENOMEM);
5721     }
5722
5723     par->extradata = str;
5724     /* Note: the string is NUL terminated (so extradata can be read as a
5725      * string), but the ending character is not accounted in the size (in
5726      * binary formats you are likely not supposed to mux that character). When
5727      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5728      * zeros. */
5729     par->extradata_size = buf->len;
5730     return 0;
5731 }
5732
5733 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5734                                                   AVStream *ost, const AVStream *ist,
5735                                                   enum AVTimebaseSource copy_tb)
5736 {
5737     //TODO: use [io]st->internal->avctx
5738     const AVCodecContext *dec_ctx;
5739     AVCodecContext       *enc_ctx;
5740
5741 #if FF_API_LAVF_AVCTX
5742 FF_DISABLE_DEPRECATION_WARNINGS
5743     dec_ctx = ist->codec;
5744     enc_ctx = ost->codec;
5745 FF_ENABLE_DEPRECATION_WARNINGS
5746 #else
5747     dec_ctx = ist->internal->avctx;
5748     enc_ctx = ost->internal->avctx;
5749 #endif
5750
5751     enc_ctx->time_base = ist->time_base;
5752     /*
5753      * Avi is a special case here because it supports variable fps but
5754      * having the fps and timebase differe significantly adds quite some
5755      * overhead
5756      */
5757     if (!strcmp(ofmt->name, "avi")) {
5758 #if FF_API_R_FRAME_RATE
5759         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5760             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5761             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5762             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5763             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5764             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5765             enc_ctx->time_base.num = ist->r_frame_rate.den;
5766             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5767             enc_ctx->ticks_per_frame = 2;
5768         } else
5769 #endif
5770             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5771                    && av_q2d(ist->time_base) < 1.0/500
5772                    || copy_tb == AVFMT_TBCF_DECODER) {
5773             enc_ctx->time_base = dec_ctx->time_base;
5774             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5775             enc_ctx->time_base.den *= 2;
5776             enc_ctx->ticks_per_frame = 2;
5777         }
5778     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5779                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5780         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5781             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5782             && av_q2d(ist->time_base) < 1.0/500
5783             || copy_tb == AVFMT_TBCF_DECODER) {
5784             enc_ctx->time_base = dec_ctx->time_base;
5785             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5786         }
5787     }
5788
5789     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5790         && dec_ctx->time_base.num < dec_ctx->time_base.den
5791         && dec_ctx->time_base.num > 0
5792         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5793         enc_ctx->time_base = dec_ctx->time_base;
5794     }
5795
5796     if (ost->avg_frame_rate.num)
5797         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5798
5799     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5800               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5801
5802     return 0;
5803 }
5804
5805 AVRational av_stream_get_codec_timebase(const AVStream *st)
5806 {
5807     // See avformat_transfer_internal_stream_timing_info() TODO.
5808 #if FF_API_LAVF_AVCTX
5809 FF_DISABLE_DEPRECATION_WARNINGS
5810     return st->codec->time_base;
5811 FF_ENABLE_DEPRECATION_WARNINGS
5812 #else
5813     return st->internal->avctx->time_base;
5814 #endif
5815 }
5816
5817 void ff_format_set_url(AVFormatContext *s, char *url)
5818 {
5819     av_assert0(url);
5820     av_freep(&s->url);
5821     s->url = url;
5822 #if FF_API_FORMAT_FILENAME
5823 FF_DISABLE_DEPRECATION_WARNINGS
5824     av_strlcpy(s->filename, url, sizeof(s->filename));
5825 FF_ENABLE_DEPRECATION_WARNINGS
5826 #endif
5827 }