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