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