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 #if FF_API_LOWRES
4032             // The decoder might reduce the video size by the lowres factor.
4033             if (st->internal->avctx->lowres && orig_w) {
4034                 st->codecpar->width = orig_w;
4035                 st->codecpar->height = orig_h;
4036             }
4037 #endif
4038         }
4039
4040 #if FF_API_LAVF_AVCTX
4041 FF_DISABLE_DEPRECATION_WARNINGS
4042         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4043         if (ret < 0)
4044             goto find_stream_info_err;
4045
4046 #if FF_API_LOWRES
4047         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4048         // by the lowres factor.
4049         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4050             st->codec->lowres = st->internal->avctx->lowres;
4051             st->codec->width = st->internal->avctx->width;
4052             st->codec->height = st->internal->avctx->height;
4053         }
4054 #endif
4055
4056         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4057             st->codec->time_base = st->internal->avctx->time_base;
4058             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4059         }
4060         st->codec->framerate = st->avg_frame_rate;
4061
4062         if (st->internal->avctx->subtitle_header) {
4063             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4064             if (!st->codec->subtitle_header)
4065                 goto find_stream_info_err;
4066             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4067             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4068                    st->codec->subtitle_header_size);
4069         }
4070
4071         // Fields unavailable in AVCodecParameters
4072         st->codec->coded_width = st->internal->avctx->coded_width;
4073         st->codec->coded_height = st->internal->avctx->coded_height;
4074         st->codec->properties = st->internal->avctx->properties;
4075 FF_ENABLE_DEPRECATION_WARNINGS
4076 #endif
4077
4078         st->internal->avctx_inited = 0;
4079     }
4080
4081 find_stream_info_err:
4082     for (i = 0; i < ic->nb_streams; i++) {
4083         st = ic->streams[i];
4084         if (st->info)
4085             av_freep(&st->info->duration_error);
4086         avcodec_close(ic->streams[i]->internal->avctx);
4087         av_freep(&ic->streams[i]->info);
4088         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4089         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4090     }
4091     if (ic->pb)
4092         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4093                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4094     return ret;
4095 }
4096
4097 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4098 {
4099     int i, j;
4100
4101     for (i = 0; i < ic->nb_programs; i++) {
4102         if (ic->programs[i] == last) {
4103             last = NULL;
4104         } else {
4105             if (!last)
4106                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4107                     if (ic->programs[i]->stream_index[j] == s)
4108                         return ic->programs[i];
4109         }
4110     }
4111     return NULL;
4112 }
4113
4114 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4115                         int wanted_stream_nb, int related_stream,
4116                         AVCodec **decoder_ret, int flags)
4117 {
4118     int i, nb_streams = ic->nb_streams;
4119     int ret = AVERROR_STREAM_NOT_FOUND;
4120     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4121     int count, multiframe, disposition;
4122     int64_t best_bitrate = -1;
4123     int64_t bitrate;
4124     unsigned *program = NULL;
4125     const AVCodec *decoder = NULL, *best_decoder = NULL;
4126
4127     if (related_stream >= 0 && wanted_stream_nb < 0) {
4128         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4129         if (p) {
4130             program    = p->stream_index;
4131             nb_streams = p->nb_stream_indexes;
4132         }
4133     }
4134     for (i = 0; i < nb_streams; i++) {
4135         int real_stream_index = program ? program[i] : i;
4136         AVStream *st          = ic->streams[real_stream_index];
4137         AVCodecParameters *par = st->codecpar;
4138         if (par->codec_type != type)
4139             continue;
4140         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4141             continue;
4142         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4143             continue;
4144         if (decoder_ret) {
4145             decoder = find_decoder(ic, st, par->codec_id);
4146             if (!decoder) {
4147                 if (ret < 0)
4148                     ret = AVERROR_DECODER_NOT_FOUND;
4149                 continue;
4150             }
4151         }
4152         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4153         count = st->codec_info_nb_frames;
4154         bitrate = par->bit_rate;
4155         multiframe = FFMIN(5, count);
4156         if ((best_disposition >  disposition) ||
4157             (best_disposition == disposition && best_multiframe >  multiframe) ||
4158             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4159             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4160             continue;
4161         best_disposition = disposition;
4162         best_count   = count;
4163         best_bitrate = bitrate;
4164         best_multiframe = multiframe;
4165         ret          = real_stream_index;
4166         best_decoder = decoder;
4167         if (program && i == nb_streams - 1 && ret < 0) {
4168             program    = NULL;
4169             nb_streams = ic->nb_streams;
4170             /* no related stream found, try again with everything */
4171             i = 0;
4172         }
4173     }
4174     if (decoder_ret)
4175         *decoder_ret = (AVCodec*)best_decoder;
4176     return ret;
4177 }
4178
4179 /*******************************************************/
4180
4181 int av_read_play(AVFormatContext *s)
4182 {
4183     if (s->iformat->read_play)
4184         return s->iformat->read_play(s);
4185     if (s->pb)
4186         return avio_pause(s->pb, 0);
4187     return AVERROR(ENOSYS);
4188 }
4189
4190 int av_read_pause(AVFormatContext *s)
4191 {
4192     if (s->iformat->read_pause)
4193         return s->iformat->read_pause(s);
4194     if (s->pb)
4195         return avio_pause(s->pb, 1);
4196     return AVERROR(ENOSYS);
4197 }
4198
4199 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4200 {
4201     int ret, i;
4202
4203     dst->id                  = src->id;
4204     dst->time_base           = src->time_base;
4205     dst->nb_frames           = src->nb_frames;
4206     dst->disposition         = src->disposition;
4207     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4208     dst->avg_frame_rate      = src->avg_frame_rate;
4209     dst->r_frame_rate        = src->r_frame_rate;
4210
4211     av_dict_free(&dst->metadata);
4212     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4213     if (ret < 0)
4214         return ret;
4215
4216     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4217     if (ret < 0)
4218         return ret;
4219
4220     /* Free existing side data*/
4221     for (i = 0; i < dst->nb_side_data; i++)
4222         av_free(dst->side_data[i].data);
4223     av_freep(&dst->side_data);
4224     dst->nb_side_data = 0;
4225
4226     /* Copy side data if present */
4227     if (src->nb_side_data) {
4228         dst->side_data = av_mallocz_array(src->nb_side_data,
4229                                           sizeof(AVPacketSideData));
4230         if (!dst->side_data)
4231             return AVERROR(ENOMEM);
4232         dst->nb_side_data = src->nb_side_data;
4233
4234         for (i = 0; i < src->nb_side_data; i++) {
4235             uint8_t *data = av_memdup(src->side_data[i].data,
4236                                       src->side_data[i].size);
4237             if (!data)
4238                 return AVERROR(ENOMEM);
4239             dst->side_data[i].type = src->side_data[i].type;
4240             dst->side_data[i].size = src->side_data[i].size;
4241             dst->side_data[i].data = data;
4242         }
4243     }
4244
4245     av_freep(&dst->recommended_encoder_configuration);
4246     if (src->recommended_encoder_configuration) {
4247         const char *conf_str = src->recommended_encoder_configuration;
4248         dst->recommended_encoder_configuration = av_strdup(conf_str);
4249         if (!dst->recommended_encoder_configuration)
4250             return AVERROR(ENOMEM);
4251     }
4252
4253     return 0;
4254 }
4255
4256 static void free_stream(AVStream **pst)
4257 {
4258     AVStream *st = *pst;
4259     int i;
4260
4261     if (!st)
4262         return;
4263
4264     for (i = 0; i < st->nb_side_data; i++)
4265         av_freep(&st->side_data[i].data);
4266     av_freep(&st->side_data);
4267
4268     if (st->parser)
4269         av_parser_close(st->parser);
4270
4271     if (st->attached_pic.data)
4272         av_packet_unref(&st->attached_pic);
4273
4274     if (st->internal) {
4275         avcodec_free_context(&st->internal->avctx);
4276         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4277             av_bsf_free(&st->internal->bsfcs[i]);
4278             av_freep(&st->internal->bsfcs);
4279         }
4280         av_freep(&st->internal->priv_pts);
4281         av_bsf_free(&st->internal->extract_extradata.bsf);
4282         av_packet_free(&st->internal->extract_extradata.pkt);
4283     }
4284     av_freep(&st->internal);
4285
4286     av_dict_free(&st->metadata);
4287     avcodec_parameters_free(&st->codecpar);
4288     av_freep(&st->probe_data.buf);
4289     av_freep(&st->index_entries);
4290 #if FF_API_LAVF_AVCTX
4291 FF_DISABLE_DEPRECATION_WARNINGS
4292     avcodec_free_context(&st->codec);
4293 FF_ENABLE_DEPRECATION_WARNINGS
4294 #endif
4295     av_freep(&st->priv_data);
4296     if (st->info)
4297         av_freep(&st->info->duration_error);
4298     av_freep(&st->info);
4299     av_freep(&st->recommended_encoder_configuration);
4300
4301     av_freep(pst);
4302 }
4303
4304 void ff_free_stream(AVFormatContext *s, AVStream *st)
4305 {
4306     av_assert0(s->nb_streams>0);
4307     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4308
4309     free_stream(&s->streams[ --s->nb_streams ]);
4310 }
4311
4312 void avformat_free_context(AVFormatContext *s)
4313 {
4314     int i;
4315
4316     if (!s)
4317         return;
4318
4319     av_opt_free(s);
4320     if (s->iformat && s->iformat->priv_class && s->priv_data)
4321         av_opt_free(s->priv_data);
4322     if (s->oformat && s->oformat->priv_class && s->priv_data)
4323         av_opt_free(s->priv_data);
4324
4325     for (i = s->nb_streams - 1; i >= 0; i--)
4326         ff_free_stream(s, s->streams[i]);
4327
4328
4329     for (i = s->nb_programs - 1; i >= 0; i--) {
4330         av_dict_free(&s->programs[i]->metadata);
4331         av_freep(&s->programs[i]->stream_index);
4332         av_freep(&s->programs[i]);
4333     }
4334     av_freep(&s->programs);
4335     av_freep(&s->priv_data);
4336     while (s->nb_chapters--) {
4337         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4338         av_freep(&s->chapters[s->nb_chapters]);
4339     }
4340     av_freep(&s->chapters);
4341     av_dict_free(&s->metadata);
4342     av_dict_free(&s->internal->id3v2_meta);
4343     av_freep(&s->streams);
4344     flush_packet_queue(s);
4345     av_freep(&s->internal);
4346     av_free(s);
4347 }
4348
4349 void avformat_close_input(AVFormatContext **ps)
4350 {
4351     AVFormatContext *s;
4352     AVIOContext *pb;
4353
4354     if (!ps || !*ps)
4355         return;
4356
4357     s  = *ps;
4358     pb = s->pb;
4359
4360     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4361         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4362         pb = NULL;
4363
4364     flush_packet_queue(s);
4365
4366     if (s->iformat)
4367         if (s->iformat->read_close)
4368             s->iformat->read_close(s);
4369
4370     avformat_free_context(s);
4371
4372     *ps = NULL;
4373
4374     avio_close(pb);
4375 }
4376
4377 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4378 {
4379     AVStream *st;
4380     int i;
4381     AVStream **streams;
4382
4383     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4384         if (s->max_streams < INT_MAX/sizeof(*streams))
4385             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);
4386         return NULL;
4387     }
4388     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4389     if (!streams)
4390         return NULL;
4391     s->streams = streams;
4392
4393     st = av_mallocz(sizeof(AVStream));
4394     if (!st)
4395         return NULL;
4396     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4397         av_free(st);
4398         return NULL;
4399     }
4400     st->info->last_dts = AV_NOPTS_VALUE;
4401
4402 #if FF_API_LAVF_AVCTX
4403 FF_DISABLE_DEPRECATION_WARNINGS
4404     st->codec = avcodec_alloc_context3(c);
4405     if (!st->codec) {
4406         av_free(st->info);
4407         av_free(st);
4408         return NULL;
4409     }
4410 FF_ENABLE_DEPRECATION_WARNINGS
4411 #endif
4412
4413     st->internal = av_mallocz(sizeof(*st->internal));
4414     if (!st->internal)
4415         goto fail;
4416
4417     st->codecpar = avcodec_parameters_alloc();
4418     if (!st->codecpar)
4419         goto fail;
4420
4421     st->internal->avctx = avcodec_alloc_context3(NULL);
4422     if (!st->internal->avctx)
4423         goto fail;
4424
4425     if (s->iformat) {
4426 #if FF_API_LAVF_AVCTX
4427 FF_DISABLE_DEPRECATION_WARNINGS
4428         /* no default bitrate if decoding */
4429         st->codec->bit_rate = 0;
4430 FF_ENABLE_DEPRECATION_WARNINGS
4431 #endif
4432
4433         /* default pts setting is MPEG-like */
4434         avpriv_set_pts_info(st, 33, 1, 90000);
4435         /* we set the current DTS to 0 so that formats without any timestamps
4436          * but durations get some timestamps, formats with some unknown
4437          * timestamps have their first few packets buffered and the
4438          * timestamps corrected before they are returned to the user */
4439         st->cur_dts = RELATIVE_TS_BASE;
4440     } else {
4441         st->cur_dts = AV_NOPTS_VALUE;
4442     }
4443
4444     st->index      = s->nb_streams;
4445     st->start_time = AV_NOPTS_VALUE;
4446     st->duration   = AV_NOPTS_VALUE;
4447     st->first_dts     = AV_NOPTS_VALUE;
4448     st->probe_packets = MAX_PROBE_PACKETS;
4449     st->pts_wrap_reference = AV_NOPTS_VALUE;
4450     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4451
4452     st->last_IP_pts = AV_NOPTS_VALUE;
4453     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4454     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4455         st->pts_buffer[i] = AV_NOPTS_VALUE;
4456
4457     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4458
4459 #if FF_API_R_FRAME_RATE
4460     st->info->last_dts      = AV_NOPTS_VALUE;
4461 #endif
4462     st->info->fps_first_dts = AV_NOPTS_VALUE;
4463     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4464
4465     st->inject_global_side_data = s->internal->inject_global_side_data;
4466
4467     st->internal->need_context_update = 1;
4468
4469     s->streams[s->nb_streams++] = st;
4470     return st;
4471 fail:
4472     free_stream(&st);
4473     return NULL;
4474 }
4475
4476 AVProgram *av_new_program(AVFormatContext *ac, int id)
4477 {
4478     AVProgram *program = NULL;
4479     int i;
4480
4481     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4482
4483     for (i = 0; i < ac->nb_programs; i++)
4484         if (ac->programs[i]->id == id)
4485             program = ac->programs[i];
4486
4487     if (!program) {
4488         program = av_mallocz(sizeof(AVProgram));
4489         if (!program)
4490             return NULL;
4491         dynarray_add(&ac->programs, &ac->nb_programs, program);
4492         program->discard = AVDISCARD_NONE;
4493     }
4494     program->id = id;
4495     program->pts_wrap_reference = AV_NOPTS_VALUE;
4496     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4497
4498     program->start_time =
4499     program->end_time   = AV_NOPTS_VALUE;
4500
4501     return program;
4502 }
4503
4504 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4505                               int64_t start, int64_t end, const char *title)
4506 {
4507     AVChapter *chapter = NULL;
4508     int i;
4509
4510     if (end != AV_NOPTS_VALUE && start > end) {
4511         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4512         return NULL;
4513     }
4514
4515     for (i = 0; i < s->nb_chapters; i++)
4516         if (s->chapters[i]->id == id)
4517             chapter = s->chapters[i];
4518
4519     if (!chapter) {
4520         chapter = av_mallocz(sizeof(AVChapter));
4521         if (!chapter)
4522             return NULL;
4523         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4524     }
4525     av_dict_set(&chapter->metadata, "title", title, 0);
4526     chapter->id        = id;
4527     chapter->time_base = time_base;
4528     chapter->start     = start;
4529     chapter->end       = end;
4530
4531     return chapter;
4532 }
4533
4534 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4535 {
4536     int i, j;
4537     AVProgram *program = NULL;
4538     void *tmp;
4539
4540     if (idx >= ac->nb_streams) {
4541         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4542         return;
4543     }
4544
4545     for (i = 0; i < ac->nb_programs; i++) {
4546         if (ac->programs[i]->id != progid)
4547             continue;
4548         program = ac->programs[i];
4549         for (j = 0; j < program->nb_stream_indexes; j++)
4550             if (program->stream_index[j] == idx)
4551                 return;
4552
4553         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4554         if (!tmp)
4555             return;
4556         program->stream_index = tmp;
4557         program->stream_index[program->nb_stream_indexes++] = idx;
4558         return;
4559     }
4560 }
4561
4562 uint64_t ff_ntp_time(void)
4563 {
4564     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4565 }
4566
4567 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4568 {
4569     const char *p;
4570     char *q, buf1[20], c;
4571     int nd, len, percentd_found;
4572
4573     q = buf;
4574     p = path;
4575     percentd_found = 0;
4576     for (;;) {
4577         c = *p++;
4578         if (c == '\0')
4579             break;
4580         if (c == '%') {
4581             do {
4582                 nd = 0;
4583                 while (av_isdigit(*p))
4584                     nd = nd * 10 + *p++ - '0';
4585                 c = *p++;
4586             } while (av_isdigit(c));
4587
4588             switch (c) {
4589             case '%':
4590                 goto addchar;
4591             case 'd':
4592                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4593                     goto fail;
4594                 percentd_found = 1;
4595                 if (number < 0)
4596                     nd += 1;
4597                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4598                 len = strlen(buf1);
4599                 if ((q - buf + len) > buf_size - 1)
4600                     goto fail;
4601                 memcpy(q, buf1, len);
4602                 q += len;
4603                 break;
4604             default:
4605                 goto fail;
4606             }
4607         } else {
4608 addchar:
4609             if ((q - buf) < buf_size - 1)
4610                 *q++ = c;
4611         }
4612     }
4613     if (!percentd_found)
4614         goto fail;
4615     *q = '\0';
4616     return 0;
4617 fail:
4618     *q = '\0';
4619     return -1;
4620 }
4621
4622 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4623 {
4624     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4625 }
4626
4627 void av_url_split(char *proto, int proto_size,
4628                   char *authorization, int authorization_size,
4629                   char *hostname, int hostname_size,
4630                   int *port_ptr, char *path, int path_size, const char *url)
4631 {
4632     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4633
4634     if (port_ptr)
4635         *port_ptr = -1;
4636     if (proto_size > 0)
4637         proto[0] = 0;
4638     if (authorization_size > 0)
4639         authorization[0] = 0;
4640     if (hostname_size > 0)
4641         hostname[0] = 0;
4642     if (path_size > 0)
4643         path[0] = 0;
4644
4645     /* parse protocol */
4646     if ((p = strchr(url, ':'))) {
4647         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4648         p++; /* skip ':' */
4649         if (*p == '/')
4650             p++;
4651         if (*p == '/')
4652             p++;
4653     } else {
4654         /* no protocol means plain filename */
4655         av_strlcpy(path, url, path_size);
4656         return;
4657     }
4658
4659     /* separate path from hostname */
4660     ls = strchr(p, '/');
4661     ls2 = strchr(p, '?');
4662     if (!ls)
4663         ls = ls2;
4664     else if (ls && ls2)
4665         ls = FFMIN(ls, ls2);
4666     if (ls)
4667         av_strlcpy(path, ls, path_size);
4668     else
4669         ls = &p[strlen(p)];  // XXX
4670
4671     /* the rest is hostname, use that to parse auth/port */
4672     if (ls != p) {
4673         /* authorization (user[:pass]@hostname) */
4674         at2 = p;
4675         while ((at = strchr(p, '@')) && at < ls) {
4676             av_strlcpy(authorization, at2,
4677                        FFMIN(authorization_size, at + 1 - at2));
4678             p = at + 1; /* skip '@' */
4679         }
4680
4681         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4682             /* [host]:port */
4683             av_strlcpy(hostname, p + 1,
4684                        FFMIN(hostname_size, brk - p));
4685             if (brk[1] == ':' && port_ptr)
4686                 *port_ptr = atoi(brk + 2);
4687         } else if ((col = strchr(p, ':')) && col < ls) {
4688             av_strlcpy(hostname, p,
4689                        FFMIN(col + 1 - p, hostname_size));
4690             if (port_ptr)
4691                 *port_ptr = atoi(col + 1);
4692         } else
4693             av_strlcpy(hostname, p,
4694                        FFMIN(ls + 1 - p, hostname_size));
4695     }
4696 }
4697
4698 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4699 {
4700     int i;
4701     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4702                                            '4', '5', '6', '7',
4703                                            '8', '9', 'A', 'B',
4704                                            'C', 'D', 'E', 'F' };
4705     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4706                                            '4', '5', '6', '7',
4707                                            '8', '9', 'a', 'b',
4708                                            'c', 'd', 'e', 'f' };
4709     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4710
4711     for (i = 0; i < s; i++) {
4712         buff[i * 2]     = hex_table[src[i] >> 4];
4713         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4714     }
4715
4716     return buff;
4717 }
4718
4719 int ff_hex_to_data(uint8_t *data, const char *p)
4720 {
4721     int c, len, v;
4722
4723     len = 0;
4724     v   = 1;
4725     for (;;) {
4726         p += strspn(p, SPACE_CHARS);
4727         if (*p == '\0')
4728             break;
4729         c = av_toupper((unsigned char) *p++);
4730         if (c >= '0' && c <= '9')
4731             c = c - '0';
4732         else if (c >= 'A' && c <= 'F')
4733             c = c - 'A' + 10;
4734         else
4735             break;
4736         v = (v << 4) | c;
4737         if (v & 0x100) {
4738             if (data)
4739                 data[len] = v;
4740             len++;
4741             v = 1;
4742         }
4743     }
4744     return len;
4745 }
4746
4747 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4748                          unsigned int pts_num, unsigned int pts_den)
4749 {
4750     AVRational new_tb;
4751     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4752         if (new_tb.num != pts_num)
4753             av_log(NULL, AV_LOG_DEBUG,
4754                    "st:%d removing common factor %d from timebase\n",
4755                    s->index, pts_num / new_tb.num);
4756     } else
4757         av_log(NULL, AV_LOG_WARNING,
4758                "st:%d has too large timebase, reducing\n", s->index);
4759
4760     if (new_tb.num <= 0 || new_tb.den <= 0) {
4761         av_log(NULL, AV_LOG_ERROR,
4762                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4763                new_tb.num, new_tb.den,
4764                s->index);
4765         return;
4766     }
4767     s->time_base     = new_tb;
4768 #if FF_API_LAVF_AVCTX
4769 FF_DISABLE_DEPRECATION_WARNINGS
4770     s->codec->pkt_timebase = new_tb;
4771 FF_ENABLE_DEPRECATION_WARNINGS
4772 #endif
4773     s->internal->avctx->pkt_timebase = new_tb;
4774     s->pts_wrap_bits = pts_wrap_bits;
4775 }
4776
4777 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4778                         void *context)
4779 {
4780     const char *ptr = str;
4781
4782     /* Parse key=value pairs. */
4783     for (;;) {
4784         const char *key;
4785         char *dest = NULL, *dest_end;
4786         int key_len, dest_len = 0;
4787
4788         /* Skip whitespace and potential commas. */
4789         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4790             ptr++;
4791         if (!*ptr)
4792             break;
4793
4794         key = ptr;
4795
4796         if (!(ptr = strchr(key, '=')))
4797             break;
4798         ptr++;
4799         key_len = ptr - key;
4800
4801         callback_get_buf(context, key, key_len, &dest, &dest_len);
4802         dest_end = dest + dest_len - 1;
4803
4804         if (*ptr == '\"') {
4805             ptr++;
4806             while (*ptr && *ptr != '\"') {
4807                 if (*ptr == '\\') {
4808                     if (!ptr[1])
4809                         break;
4810                     if (dest && dest < dest_end)
4811                         *dest++ = ptr[1];
4812                     ptr += 2;
4813                 } else {
4814                     if (dest && dest < dest_end)
4815                         *dest++ = *ptr;
4816                     ptr++;
4817                 }
4818             }
4819             if (*ptr == '\"')
4820                 ptr++;
4821         } else {
4822             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4823                 if (dest && dest < dest_end)
4824                     *dest++ = *ptr;
4825         }
4826         if (dest)
4827             *dest = 0;
4828     }
4829 }
4830
4831 int ff_find_stream_index(AVFormatContext *s, int id)
4832 {
4833     int i;
4834     for (i = 0; i < s->nb_streams; i++)
4835         if (s->streams[i]->id == id)
4836             return i;
4837     return -1;
4838 }
4839
4840 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4841                          int std_compliance)
4842 {
4843     if (ofmt) {
4844         unsigned int codec_tag;
4845         if (ofmt->query_codec)
4846             return ofmt->query_codec(codec_id, std_compliance);
4847         else if (ofmt->codec_tag)
4848             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4849         else if (codec_id == ofmt->video_codec ||
4850                  codec_id == ofmt->audio_codec ||
4851                  codec_id == ofmt->subtitle_codec ||
4852                  codec_id == ofmt->data_codec)
4853             return 1;
4854     }
4855     return AVERROR_PATCHWELCOME;
4856 }
4857
4858 int avformat_network_init(void)
4859 {
4860 #if CONFIG_NETWORK
4861     int ret;
4862     ff_network_inited_globally = 1;
4863     if ((ret = ff_network_init()) < 0)
4864         return ret;
4865     if ((ret = ff_tls_init()) < 0)
4866         return ret;
4867 #endif
4868     return 0;
4869 }
4870
4871 int avformat_network_deinit(void)
4872 {
4873 #if CONFIG_NETWORK
4874     ff_network_close();
4875     ff_tls_deinit();
4876     ff_network_inited_globally = 0;
4877 #endif
4878     return 0;
4879 }
4880
4881 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4882                         uint64_t channel_layout, int32_t sample_rate,
4883                         int32_t width, int32_t height)
4884 {
4885     uint32_t flags = 0;
4886     int size = 4;
4887     uint8_t *data;
4888     if (!pkt)
4889         return AVERROR(EINVAL);
4890     if (channels) {
4891         size  += 4;
4892         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4893     }
4894     if (channel_layout) {
4895         size  += 8;
4896         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4897     }
4898     if (sample_rate) {
4899         size  += 4;
4900         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4901     }
4902     if (width || height) {
4903         size  += 8;
4904         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4905     }
4906     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4907     if (!data)
4908         return AVERROR(ENOMEM);
4909     bytestream_put_le32(&data, flags);
4910     if (channels)
4911         bytestream_put_le32(&data, channels);
4912     if (channel_layout)
4913         bytestream_put_le64(&data, channel_layout);
4914     if (sample_rate)
4915         bytestream_put_le32(&data, sample_rate);
4916     if (width || height) {
4917         bytestream_put_le32(&data, width);
4918         bytestream_put_le32(&data, height);
4919     }
4920     return 0;
4921 }
4922
4923 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4924 {
4925     AVRational undef = {0, 1};
4926     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4927     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4928     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4929
4930     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4931                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4932     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4933         stream_sample_aspect_ratio = undef;
4934
4935     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4936                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4937     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4938         frame_sample_aspect_ratio = undef;
4939
4940     if (stream_sample_aspect_ratio.num)
4941         return stream_sample_aspect_ratio;
4942     else
4943         return frame_sample_aspect_ratio;
4944 }
4945
4946 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4947 {
4948     AVRational fr = st->r_frame_rate;
4949     AVRational codec_fr = st->internal->avctx->framerate;
4950     AVRational   avg_fr = st->avg_frame_rate;
4951
4952     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4953         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4954         fr = avg_fr;
4955     }
4956
4957
4958     if (st->internal->avctx->ticks_per_frame > 1) {
4959         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4960             (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))
4961             fr = codec_fr;
4962     }
4963
4964     return fr;
4965 }
4966
4967 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4968                                     const char *spec)
4969 {
4970     if (*spec <= '9' && *spec >= '0') /* opt:index */
4971         return strtol(spec, NULL, 0) == st->index;
4972     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4973              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4974         enum AVMediaType type;
4975         int nopic = 0;
4976
4977         switch (*spec++) {
4978         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4979         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4980         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4981         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4982         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4983         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4984         default:  av_assert0(0);
4985         }
4986 #if FF_API_LAVF_AVCTX
4987 FF_DISABLE_DEPRECATION_WARNINGS
4988         if (type != st->codecpar->codec_type
4989            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4990             return 0;
4991 FF_ENABLE_DEPRECATION_WARNINGS
4992 #else
4993         if (type != st->codecpar->codec_type)
4994             return 0;
4995 #endif
4996         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4997             return 0;
4998         if (*spec++ == ':') { /* possibly followed by :index */
4999             int i, index = strtol(spec, NULL, 0);
5000             for (i = 0; i < s->nb_streams; i++) {
5001 #if FF_API_LAVF_AVCTX
5002 FF_DISABLE_DEPRECATION_WARNINGS
5003                 if ((s->streams[i]->codecpar->codec_type == type
5004                       || s->streams[i]->codec->codec_type == type
5005                     ) &&
5006                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5007                     index-- == 0)
5008                     return i == st->index;
5009 FF_ENABLE_DEPRECATION_WARNINGS
5010 #else
5011                 if ((s->streams[i]->codecpar->codec_type == type) &&
5012                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5013                     index-- == 0)
5014                     return i == st->index;
5015 #endif
5016             }
5017             return 0;
5018         }
5019         return 1;
5020     } else if (*spec == 'p' && *(spec + 1) == ':') {
5021         int prog_id, i, j;
5022         char *endptr;
5023         spec += 2;
5024         prog_id = strtol(spec, &endptr, 0);
5025         for (i = 0; i < s->nb_programs; i++) {
5026             if (s->programs[i]->id != prog_id)
5027                 continue;
5028
5029             if (*endptr++ == ':') {
5030                 int stream_idx = strtol(endptr, NULL, 0);
5031                 return stream_idx >= 0 &&
5032                     stream_idx < s->programs[i]->nb_stream_indexes &&
5033                     st->index == s->programs[i]->stream_index[stream_idx];
5034             }
5035
5036             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5037                 if (st->index == s->programs[i]->stream_index[j])
5038                     return 1;
5039         }
5040         return 0;
5041     } else if (*spec == '#' ||
5042                (*spec == 'i' && *(spec + 1) == ':')) {
5043         int stream_id;
5044         char *endptr;
5045         spec += 1 + (*spec == 'i');
5046         stream_id = strtol(spec, &endptr, 0);
5047         if (!*endptr)
5048             return stream_id == st->id;
5049     } else if (*spec == 'm' && *(spec + 1) == ':') {
5050         AVDictionaryEntry *tag;
5051         char *key, *val;
5052         int ret;
5053
5054         spec += 2;
5055         val = strchr(spec, ':');
5056
5057         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5058         if (!key)
5059             return AVERROR(ENOMEM);
5060
5061         tag = av_dict_get(st->metadata, key, NULL, 0);
5062         if (tag) {
5063             if (!val || !strcmp(tag->value, val + 1))
5064                 ret = 1;
5065             else
5066                 ret = 0;
5067         } else
5068             ret = 0;
5069
5070         av_freep(&key);
5071         return ret;
5072     } else if (*spec == 'u') {
5073         AVCodecParameters *par = st->codecpar;
5074 #if FF_API_LAVF_AVCTX
5075 FF_DISABLE_DEPRECATION_WARNINGS
5076         AVCodecContext *codec = st->codec;
5077 FF_ENABLE_DEPRECATION_WARNINGS
5078 #endif
5079         int val;
5080         switch (par->codec_type) {
5081         case AVMEDIA_TYPE_AUDIO:
5082             val = par->sample_rate && par->channels;
5083 #if FF_API_LAVF_AVCTX
5084             val = val || (codec->sample_rate && codec->channels);
5085 #endif
5086             if (par->format == AV_SAMPLE_FMT_NONE
5087 #if FF_API_LAVF_AVCTX
5088                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5089 #endif
5090                 )
5091                 return 0;
5092             break;
5093         case AVMEDIA_TYPE_VIDEO:
5094             val = par->width && par->height;
5095 #if FF_API_LAVF_AVCTX
5096             val = val || (codec->width && codec->height);
5097 #endif
5098             if (par->format == AV_PIX_FMT_NONE
5099 #if FF_API_LAVF_AVCTX
5100                 && codec->pix_fmt == AV_PIX_FMT_NONE
5101 #endif
5102                 )
5103                 return 0;
5104             break;
5105         case AVMEDIA_TYPE_UNKNOWN:
5106             val = 0;
5107             break;
5108         default:
5109             val = 1;
5110             break;
5111         }
5112 #if FF_API_LAVF_AVCTX
5113         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5114 #else
5115         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5116 #endif
5117     } else if (!*spec) /* empty specifier, matches everything */
5118         return 1;
5119
5120     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5121     return AVERROR(EINVAL);
5122 }
5123
5124 int ff_generate_avci_extradata(AVStream *st)
5125 {
5126     static const uint8_t avci100_1080p_extradata[] = {
5127         // SPS
5128         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5129         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5130         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5131         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5132         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5133         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5134         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5135         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5136         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5137         // PPS
5138         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5139         0xd0
5140     };
5141     static const uint8_t avci100_1080i_extradata[] = {
5142         // SPS
5143         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5144         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5145         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5146         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5147         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5148         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5149         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5150         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5151         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5152         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5153         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5154         // PPS
5155         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5156         0xd0
5157     };
5158     static const uint8_t avci50_1080p_extradata[] = {
5159         // SPS
5160         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5161         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5162         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5163         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5164         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5165         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5166         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5167         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5168         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5169         // PPS
5170         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5171         0x11
5172     };
5173     static const uint8_t avci50_1080i_extradata[] = {
5174         // SPS
5175         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5176         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5177         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5178         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5179         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5180         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5181         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5182         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5183         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5184         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5185         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5186         // PPS
5187         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5188         0x11
5189     };
5190     static const uint8_t avci100_720p_extradata[] = {
5191         // SPS
5192         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5193         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5194         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5195         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5196         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5197         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5198         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5199         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5200         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5201         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5202         // PPS
5203         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5204         0x11
5205     };
5206     static const uint8_t avci50_720p_extradata[] = {
5207         // SPS
5208         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5209         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5210         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5211         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5212         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5213         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5214         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5215         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5216         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5217         // PPS
5218         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5219         0x11
5220     };
5221
5222     const uint8_t *data = NULL;
5223     int size            = 0;
5224
5225     if (st->codecpar->width == 1920) {
5226         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5227             data = avci100_1080p_extradata;
5228             size = sizeof(avci100_1080p_extradata);
5229         } else {
5230             data = avci100_1080i_extradata;
5231             size = sizeof(avci100_1080i_extradata);
5232         }
5233     } else if (st->codecpar->width == 1440) {
5234         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5235             data = avci50_1080p_extradata;
5236             size = sizeof(avci50_1080p_extradata);
5237         } else {
5238             data = avci50_1080i_extradata;
5239             size = sizeof(avci50_1080i_extradata);
5240         }
5241     } else if (st->codecpar->width == 1280) {
5242         data = avci100_720p_extradata;
5243         size = sizeof(avci100_720p_extradata);
5244     } else if (st->codecpar->width == 960) {
5245         data = avci50_720p_extradata;
5246         size = sizeof(avci50_720p_extradata);
5247     }
5248
5249     if (!size)
5250         return 0;
5251
5252     av_freep(&st->codecpar->extradata);
5253     if (ff_alloc_extradata(st->codecpar, size))
5254         return AVERROR(ENOMEM);
5255     memcpy(st->codecpar->extradata, data, size);
5256
5257     return 0;
5258 }
5259
5260 uint8_t *av_stream_get_side_data(const AVStream *st,
5261                                  enum AVPacketSideDataType type, int *size)
5262 {
5263     int i;
5264
5265     for (i = 0; i < st->nb_side_data; i++) {
5266         if (st->side_data[i].type == type) {
5267             if (size)
5268                 *size = st->side_data[i].size;
5269             return st->side_data[i].data;
5270         }
5271     }
5272     return NULL;
5273 }
5274
5275 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5276                             uint8_t *data, size_t size)
5277 {
5278     AVPacketSideData *sd, *tmp;
5279     int i;
5280
5281     for (i = 0; i < st->nb_side_data; i++) {
5282         sd = &st->side_data[i];
5283
5284         if (sd->type == type) {
5285             av_freep(&sd->data);
5286             sd->data = data;
5287             sd->size = size;
5288             return 0;
5289         }
5290     }
5291
5292     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5293         return AVERROR(ERANGE);
5294
5295     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5296     if (!tmp) {
5297         return AVERROR(ENOMEM);
5298     }
5299
5300     st->side_data = tmp;
5301     st->nb_side_data++;
5302
5303     sd = &st->side_data[st->nb_side_data - 1];
5304     sd->type = type;
5305     sd->data = data;
5306     sd->size = size;
5307
5308     return 0;
5309 }
5310
5311 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5312                                  int size)
5313 {
5314     int ret;
5315     uint8_t *data = av_malloc(size);
5316
5317     if (!data)
5318         return NULL;
5319
5320     ret = av_stream_add_side_data(st, type, data, size);
5321     if (ret < 0) {
5322         av_freep(&data);
5323         return NULL;
5324     }
5325
5326     return data;
5327 }
5328
5329 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5330 {
5331     int ret;
5332     const AVBitStreamFilter *bsf;
5333     AVBSFContext *bsfc;
5334     AVCodecParameters *in_par;
5335
5336     if (!(bsf = av_bsf_get_by_name(name))) {
5337         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5338         return AVERROR_BSF_NOT_FOUND;
5339     }
5340
5341     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5342         return ret;
5343
5344     if (st->internal->nb_bsfcs) {
5345         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5346         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5347     } else {
5348         in_par = st->codecpar;
5349         bsfc->time_base_in = st->time_base;
5350     }
5351
5352     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5353         av_bsf_free(&bsfc);
5354         return ret;
5355     }
5356
5357     if (args && bsfc->filter->priv_class) {
5358         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5359         const char * shorthand[2] = {NULL};
5360
5361         if (opt)
5362             shorthand[0] = opt->name;
5363
5364         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5365             av_bsf_free(&bsfc);
5366             return ret;
5367         }
5368     }
5369
5370     if ((ret = av_bsf_init(bsfc)) < 0) {
5371         av_bsf_free(&bsfc);
5372         return ret;
5373     }
5374
5375     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5376         av_bsf_free(&bsfc);
5377         return ret;
5378     }
5379
5380     av_log(NULL, AV_LOG_VERBOSE,
5381            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5382            name, args ? args : "");
5383     return 1;
5384 }
5385
5386 #if FF_API_OLD_BSF
5387 FF_DISABLE_DEPRECATION_WARNINGS
5388 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5389                                AVBitStreamFilterContext *bsfc)
5390 {
5391     int ret = 0;
5392     while (bsfc) {
5393         AVPacket new_pkt = *pkt;
5394         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5395                                            &new_pkt.data, &new_pkt.size,
5396                                            pkt->data, pkt->size,
5397                                            pkt->flags & AV_PKT_FLAG_KEY);
5398         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5399             av_packet_unref(pkt);
5400             memset(pkt, 0, sizeof(*pkt));
5401             return 0;
5402         }
5403         if(a == 0 && new_pkt.data != pkt->data) {
5404             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
5405             if (t) {
5406                 memcpy(t, new_pkt.data, new_pkt.size);
5407                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5408                 new_pkt.data = t;
5409                 new_pkt.buf = NULL;
5410                 a = 1;
5411             } else {
5412                 a = AVERROR(ENOMEM);
5413             }
5414         }
5415         if (a > 0) {
5416             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5417                                            av_buffer_default_free, NULL, 0);
5418             if (new_pkt.buf) {
5419                 pkt->side_data = NULL;
5420                 pkt->side_data_elems = 0;
5421                 av_packet_unref(pkt);
5422             } else {
5423                 av_freep(&new_pkt.data);
5424                 a = AVERROR(ENOMEM);
5425             }
5426         }
5427         if (a < 0) {
5428             av_log(codec, AV_LOG_ERROR,
5429                    "Failed to open bitstream filter %s for stream %d with codec %s",
5430                    bsfc->filter->name, pkt->stream_index,
5431                    codec->codec ? codec->codec->name : "copy");
5432             ret = a;
5433             break;
5434         }
5435         *pkt = new_pkt;
5436
5437         bsfc = bsfc->next;
5438     }
5439     return ret;
5440 }
5441 FF_ENABLE_DEPRECATION_WARNINGS
5442 #endif
5443
5444 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5445 {
5446     if (!s->oformat)
5447         return AVERROR(EINVAL);
5448
5449     if (!(s->oformat->flags & AVFMT_NOFILE))
5450         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5451     return 0;
5452 }
5453
5454 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5455 {
5456     if (*pb)
5457         s->io_close(s, *pb);
5458     *pb = NULL;
5459 }
5460
5461 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5462 {
5463     AVDictionaryEntry *entry;
5464     int64_t parsed_timestamp;
5465     int ret;
5466     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5467         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5468             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5469             return 1;
5470         } else {
5471             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5472             return ret;
5473         }
5474     }
5475     return 0;
5476 }
5477
5478 int ff_standardize_creation_time(AVFormatContext *s)
5479 {
5480     int64_t timestamp;
5481     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5482     if (ret == 1)
5483         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5484     return ret;
5485 }
5486
5487 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5488 {
5489     uint8_t *side_data;
5490     int size;
5491
5492     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5493     if (side_data) {
5494         if (size != AVPALETTE_SIZE) {
5495             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5496             return AVERROR_INVALIDDATA;
5497         }
5498         memcpy(palette, side_data, AVPALETTE_SIZE);
5499         return 1;
5500     }
5501
5502     if (ret == CONTAINS_PAL) {
5503         int i;
5504         for (i = 0; i < AVPALETTE_COUNT; i++)
5505             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5506         return 1;
5507     }
5508
5509     return 0;
5510 }
5511
5512 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5513 {
5514     int ret;
5515     char *str;
5516
5517     ret = av_bprint_finalize(buf, &str);
5518     if (ret < 0)
5519         return ret;
5520     if (!av_bprint_is_complete(buf)) {
5521         av_free(str);
5522         return AVERROR(ENOMEM);
5523     }
5524
5525     par->extradata = str;
5526     /* Note: the string is NUL terminated (so extradata can be read as a
5527      * string), but the ending character is not accounted in the size (in
5528      * binary formats you are likely not supposed to mux that character). When
5529      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5530      * zeros. */
5531     par->extradata_size = buf->len;
5532     return 0;
5533 }
5534
5535 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5536                                                   AVStream *ost, const AVStream *ist,
5537                                                   enum AVTimebaseSource copy_tb)
5538 {
5539     //TODO: use [io]st->internal->avctx
5540     const AVCodecContext *dec_ctx = ist->codec;
5541     AVCodecContext       *enc_ctx = ost->codec;
5542
5543     enc_ctx->time_base = ist->time_base;
5544     /*
5545      * Avi is a special case here because it supports variable fps but
5546      * having the fps and timebase differe significantly adds quite some
5547      * overhead
5548      */
5549     if (!strcmp(ofmt->name, "avi")) {
5550 #if FF_API_R_FRAME_RATE
5551         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5552             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5553             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5554             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5555             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5556             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5557             enc_ctx->time_base.num = ist->r_frame_rate.den;
5558             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5559             enc_ctx->ticks_per_frame = 2;
5560         } else
5561 #endif
5562             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5563                    && av_q2d(ist->time_base) < 1.0/500
5564                    || copy_tb == AVFMT_TBCF_DECODER) {
5565             enc_ctx->time_base = dec_ctx->time_base;
5566             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5567             enc_ctx->time_base.den *= 2;
5568             enc_ctx->ticks_per_frame = 2;
5569         }
5570     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5571                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5572         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5573             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5574             && av_q2d(ist->time_base) < 1.0/500
5575             || copy_tb == AVFMT_TBCF_DECODER) {
5576             enc_ctx->time_base = dec_ctx->time_base;
5577             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5578         }
5579     }
5580
5581     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5582         && dec_ctx->time_base.num < dec_ctx->time_base.den
5583         && dec_ctx->time_base.num > 0
5584         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5585         enc_ctx->time_base = dec_ctx->time_base;
5586     }
5587
5588     if (ost->avg_frame_rate.num)
5589         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5590
5591     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5592               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5593
5594     return 0;
5595 }
5596
5597 AVRational av_stream_get_codec_timebase(const AVStream *st)
5598 {
5599     // See avformat_transfer_internal_stream_timing_info() TODO.
5600 #if FF_API_LAVF_AVCTX
5601 FF_DISABLE_DEPRECATION_WARNINGS
5602     return st->codec->time_base;
5603 FF_ENABLE_DEPRECATION_WARNINGS
5604 #else
5605     return st->internal->avctx->time_base;
5606 #endif
5607 }