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