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                 av_assert2(wrap_bits <= 64);
1741                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1742                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1743                         av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1744                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1745                             // not B-frame
1746                             next_pkt->pts = pktl->pkt.dts;
1747                         }
1748                         if (last_dts != AV_NOPTS_VALUE) {
1749                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1750                             last_dts = pktl->pkt.dts;
1751                         }
1752                     }
1753                     pktl = pktl->next;
1754                 }
1755                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1756                     // Fixing the last reference frame had none pts issue (For MXF etc).
1757                     // We only do this when
1758                     // 1. eof.
1759                     // 2. we are not able to resolve a pts value for current packet.
1760                     // 3. the packets for this stream at the end of the files had valid dts.
1761                     next_pkt->pts = last_dts + next_pkt->duration;
1762                 }
1763                 pktl = s->internal->packet_buffer;
1764             }
1765
1766             /* read packet from packet buffer, if there is data */
1767             st = s->streams[next_pkt->stream_index];
1768             if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1769                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1770                 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1771                                                &s->internal->packet_buffer_end, pkt);
1772                 goto return_packet;
1773             }
1774         }
1775
1776         ret = read_frame_internal(s, pkt);
1777         if (ret < 0) {
1778             if (pktl && ret != AVERROR(EAGAIN)) {
1779                 eof = 1;
1780                 continue;
1781             } else
1782                 return ret;
1783         }
1784
1785         ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1786                             &s->internal->packet_buffer_end, 1);
1787         av_packet_unref(pkt);
1788         if (ret < 0)
1789             return ret;
1790     }
1791
1792 return_packet:
1793
1794     st = s->streams[pkt->stream_index];
1795     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1796         ff_reduce_index(s, st->index);
1797         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1798     }
1799
1800     if (is_relative(pkt->dts))
1801         pkt->dts -= RELATIVE_TS_BASE;
1802     if (is_relative(pkt->pts))
1803         pkt->pts -= RELATIVE_TS_BASE;
1804
1805     return ret;
1806 }
1807
1808 /* XXX: suppress the packet queue */
1809 static void flush_packet_queue(AVFormatContext *s)
1810 {
1811     if (!s->internal)
1812         return;
1813     free_packet_buffer(&s->internal->parse_queue,       &s->internal->parse_queue_end);
1814     free_packet_buffer(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
1815     free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1816
1817     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1818 }
1819
1820 /*******************************************************/
1821 /* seek support */
1822
1823 int av_find_default_stream_index(AVFormatContext *s)
1824 {
1825     int i;
1826     AVStream *st;
1827     int best_stream = 0;
1828     int best_score = INT_MIN;
1829
1830     if (s->nb_streams <= 0)
1831         return -1;
1832     for (i = 0; i < s->nb_streams; i++) {
1833         int score = 0;
1834         st = s->streams[i];
1835         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1836             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1837                 score -= 400;
1838             if (st->codecpar->width && st->codecpar->height)
1839                 score += 50;
1840             score+= 25;
1841         }
1842         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1843             if (st->codecpar->sample_rate)
1844                 score += 50;
1845         }
1846         if (st->codec_info_nb_frames)
1847             score += 12;
1848
1849         if (st->discard != AVDISCARD_ALL)
1850             score += 200;
1851
1852         if (score > best_score) {
1853             best_score = score;
1854             best_stream = i;
1855         }
1856     }
1857     return best_stream;
1858 }
1859
1860 /** Flush the frame reader. */
1861 void ff_read_frame_flush(AVFormatContext *s)
1862 {
1863     AVStream *st;
1864     int i, j;
1865
1866     flush_packet_queue(s);
1867
1868     /* Reset read state for each stream. */
1869     for (i = 0; i < s->nb_streams; i++) {
1870         st = s->streams[i];
1871
1872         if (st->parser) {
1873             av_parser_close(st->parser);
1874             st->parser = NULL;
1875         }
1876         st->last_IP_pts = AV_NOPTS_VALUE;
1877         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1878         if (st->first_dts == AV_NOPTS_VALUE)
1879             st->cur_dts = RELATIVE_TS_BASE;
1880         else
1881             /* We set the current DTS to an unspecified origin. */
1882             st->cur_dts = AV_NOPTS_VALUE;
1883
1884         st->probe_packets = MAX_PROBE_PACKETS;
1885
1886         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1887             st->pts_buffer[j] = AV_NOPTS_VALUE;
1888
1889         if (s->internal->inject_global_side_data)
1890             st->inject_global_side_data = 1;
1891
1892         st->skip_samples = 0;
1893     }
1894 }
1895
1896 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1897 {
1898     int i;
1899
1900     for (i = 0; i < s->nb_streams; i++) {
1901         AVStream *st = s->streams[i];
1902
1903         st->cur_dts =
1904             av_rescale(timestamp,
1905                        st->time_base.den * (int64_t) ref_st->time_base.num,
1906                        st->time_base.num * (int64_t) ref_st->time_base.den);
1907     }
1908 }
1909
1910 void ff_reduce_index(AVFormatContext *s, int stream_index)
1911 {
1912     AVStream *st             = s->streams[stream_index];
1913     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1914
1915     if ((unsigned) st->nb_index_entries >= max_entries) {
1916         int i;
1917         for (i = 0; 2 * i < st->nb_index_entries; i++)
1918             st->index_entries[i] = st->index_entries[2 * i];
1919         st->nb_index_entries = i;
1920     }
1921 }
1922
1923 int ff_add_index_entry(AVIndexEntry **index_entries,
1924                        int *nb_index_entries,
1925                        unsigned int *index_entries_allocated_size,
1926                        int64_t pos, int64_t timestamp,
1927                        int size, int distance, int flags)
1928 {
1929     AVIndexEntry *entries, *ie;
1930     int index;
1931
1932     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1933         return -1;
1934
1935     if (timestamp == AV_NOPTS_VALUE)
1936         return AVERROR(EINVAL);
1937
1938     if (size < 0 || size > 0x3FFFFFFF)
1939         return AVERROR(EINVAL);
1940
1941     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1942         timestamp -= RELATIVE_TS_BASE;
1943
1944     entries = av_fast_realloc(*index_entries,
1945                               index_entries_allocated_size,
1946                               (*nb_index_entries + 1) *
1947                               sizeof(AVIndexEntry));
1948     if (!entries)
1949         return -1;
1950
1951     *index_entries = entries;
1952
1953     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1954                                       timestamp, AVSEEK_FLAG_ANY);
1955
1956     if (index < 0) {
1957         index = (*nb_index_entries)++;
1958         ie    = &entries[index];
1959         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1960     } else {
1961         ie = &entries[index];
1962         if (ie->timestamp != timestamp) {
1963             if (ie->timestamp <= timestamp)
1964                 return -1;
1965             memmove(entries + index + 1, entries + index,
1966                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1967             (*nb_index_entries)++;
1968         } else if (ie->pos == pos && distance < ie->min_distance)
1969             // do not reduce the distance
1970             distance = ie->min_distance;
1971     }
1972
1973     ie->pos          = pos;
1974     ie->timestamp    = timestamp;
1975     ie->min_distance = distance;
1976     ie->size         = size;
1977     ie->flags        = flags;
1978
1979     return index;
1980 }
1981
1982 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1983                        int size, int distance, int flags)
1984 {
1985     timestamp = wrap_timestamp(st, timestamp);
1986     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1987                               &st->index_entries_allocated_size, pos,
1988                               timestamp, size, distance, flags);
1989 }
1990
1991 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1992                               int64_t wanted_timestamp, int flags)
1993 {
1994     int a, b, m;
1995     int64_t timestamp;
1996
1997     a = -1;
1998     b = nb_entries;
1999
2000     // Optimize appending index entries at the end.
2001     if (b && entries[b - 1].timestamp < wanted_timestamp)
2002         a = b - 1;
2003
2004     while (b - a > 1) {
2005         m         = (a + b) >> 1;
2006
2007         // Search for the next non-discarded packet.
2008         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2009             m++;
2010             if (m == b && entries[m].timestamp >= wanted_timestamp) {
2011                 m = b - 1;
2012                 break;
2013             }
2014         }
2015
2016         timestamp = entries[m].timestamp;
2017         if (timestamp >= wanted_timestamp)
2018             b = m;
2019         if (timestamp <= wanted_timestamp)
2020             a = m;
2021     }
2022     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2023
2024     if (!(flags & AVSEEK_FLAG_ANY))
2025         while (m >= 0 && m < nb_entries &&
2026                !(entries[m].flags & AVINDEX_KEYFRAME))
2027             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2028
2029     if (m == nb_entries)
2030         return -1;
2031     return m;
2032 }
2033
2034 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2035 {
2036     int ist1, ist2;
2037     int64_t pos_delta = 0;
2038     int64_t skip = 0;
2039     //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2040     const char *proto = avio_find_protocol_name(s->filename);
2041
2042     if (!proto) {
2043         av_log(s, AV_LOG_INFO,
2044                "Protocol name not provided, cannot determine if input is local or "
2045                "a network protocol, buffers and access patterns cannot be configured "
2046                "optimally without knowing the protocol\n");
2047     }
2048
2049     if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2050         return;
2051
2052     for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2053         AVStream *st1 = s->streams[ist1];
2054         for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2055             AVStream *st2 = s->streams[ist2];
2056             int i1, i2;
2057
2058             if (ist1 == ist2)
2059                 continue;
2060
2061             for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2062                 AVIndexEntry *e1 = &st1->index_entries[i1];
2063                 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2064
2065                 skip = FFMAX(skip, e1->size);
2066                 for (; i2 < st2->nb_index_entries; i2++) {
2067                     AVIndexEntry *e2 = &st2->index_entries[i2];
2068                     int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2069                     if (e2_pts - e1_pts < time_tolerance)
2070                         continue;
2071                     pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2072                     break;
2073                 }
2074             }
2075         }
2076     }
2077
2078     pos_delta *= 2;
2079     /* XXX This could be adjusted depending on protocol*/
2080     if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2081         av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2082         ffio_set_buf_size(s->pb, pos_delta);
2083         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2084     }
2085
2086     if (skip < (1<<23)) {
2087         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2088     }
2089 }
2090
2091 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2092 {
2093     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2094                                      wanted_timestamp, flags);
2095 }
2096
2097 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2098                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2099 {
2100     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2101     if (stream_index >= 0)
2102         ts = wrap_timestamp(s->streams[stream_index], ts);
2103     return ts;
2104 }
2105
2106 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2107                          int64_t target_ts, int flags)
2108 {
2109     AVInputFormat *avif = s->iformat;
2110     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2111     int64_t ts_min, ts_max, ts;
2112     int index;
2113     int64_t ret;
2114     AVStream *st;
2115
2116     if (stream_index < 0)
2117         return -1;
2118
2119     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2120
2121     ts_max =
2122     ts_min = AV_NOPTS_VALUE;
2123     pos_limit = -1; // GCC falsely says it may be uninitialized.
2124
2125     st = s->streams[stream_index];
2126     if (st->index_entries) {
2127         AVIndexEntry *e;
2128
2129         /* FIXME: Whole function must be checked for non-keyframe entries in
2130          * index case, especially read_timestamp(). */
2131         index = av_index_search_timestamp(st, target_ts,
2132                                           flags | AVSEEK_FLAG_BACKWARD);
2133         index = FFMAX(index, 0);
2134         e     = &st->index_entries[index];
2135
2136         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2137             pos_min = e->pos;
2138             ts_min  = e->timestamp;
2139             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2140                     pos_min, av_ts2str(ts_min));
2141         } else {
2142             av_assert1(index == 0);
2143         }
2144
2145         index = av_index_search_timestamp(st, target_ts,
2146                                           flags & ~AVSEEK_FLAG_BACKWARD);
2147         av_assert0(index < st->nb_index_entries);
2148         if (index >= 0) {
2149             e = &st->index_entries[index];
2150             av_assert1(e->timestamp >= target_ts);
2151             pos_max   = e->pos;
2152             ts_max    = e->timestamp;
2153             pos_limit = pos_max - e->min_distance;
2154             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2155                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2156         }
2157     }
2158
2159     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2160                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
2161     if (pos < 0)
2162         return -1;
2163
2164     /* do the seek */
2165     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2166         return ret;
2167
2168     ff_read_frame_flush(s);
2169     ff_update_cur_dts(s, st, ts);
2170
2171     return 0;
2172 }
2173
2174 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2175                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2176 {
2177     int64_t step = 1024;
2178     int64_t limit, ts_max;
2179     int64_t filesize = avio_size(s->pb);
2180     int64_t pos_max  = filesize - 1;
2181     do {
2182         limit = pos_max;
2183         pos_max = FFMAX(0, (pos_max) - step);
2184         ts_max  = ff_read_timestamp(s, stream_index,
2185                                     &pos_max, limit, read_timestamp);
2186         step   += step;
2187     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2188     if (ts_max == AV_NOPTS_VALUE)
2189         return -1;
2190
2191     for (;;) {
2192         int64_t tmp_pos = pos_max + 1;
2193         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
2194                                             &tmp_pos, INT64_MAX, read_timestamp);
2195         if (tmp_ts == AV_NOPTS_VALUE)
2196             break;
2197         av_assert0(tmp_pos > pos_max);
2198         ts_max  = tmp_ts;
2199         pos_max = tmp_pos;
2200         if (tmp_pos >= filesize)
2201             break;
2202     }
2203
2204     if (ts)
2205         *ts = ts_max;
2206     if (pos)
2207         *pos = pos_max;
2208
2209     return 0;
2210 }
2211
2212 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2213                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2214                       int64_t ts_min, int64_t ts_max,
2215                       int flags, int64_t *ts_ret,
2216                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
2217                                                 int64_t *, int64_t))
2218 {
2219     int64_t pos, ts;
2220     int64_t start_pos;
2221     int no_change;
2222     int ret;
2223
2224     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2225
2226     if (ts_min == AV_NOPTS_VALUE) {
2227         pos_min = s->internal->data_offset;
2228         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2229         if (ts_min == AV_NOPTS_VALUE)
2230             return -1;
2231     }
2232
2233     if (ts_min >= target_ts) {
2234         *ts_ret = ts_min;
2235         return pos_min;
2236     }
2237
2238     if (ts_max == AV_NOPTS_VALUE) {
2239         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2240             return ret;
2241         pos_limit = pos_max;
2242     }
2243
2244     if (ts_max <= target_ts) {
2245         *ts_ret = ts_max;
2246         return pos_max;
2247     }
2248
2249     av_assert0(ts_min < ts_max);
2250
2251     no_change = 0;
2252     while (pos_min < pos_limit) {
2253         av_log(s, AV_LOG_TRACE,
2254                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2255                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2256         av_assert0(pos_limit <= pos_max);
2257
2258         if (no_change == 0) {
2259             int64_t approximate_keyframe_distance = pos_max - pos_limit;
2260             // interpolate position (better than dichotomy)
2261             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2262                              ts_max - ts_min) +
2263                   pos_min - approximate_keyframe_distance;
2264         } else if (no_change == 1) {
2265             // bisection if interpolation did not change min / max pos last time
2266             pos = (pos_min + pos_limit) >> 1;
2267         } else {
2268             /* linear search if bisection failed, can only happen if there
2269              * are very few or no keyframes between min/max */
2270             pos = pos_min;
2271         }
2272         if (pos <= pos_min)
2273             pos = pos_min + 1;
2274         else if (pos > pos_limit)
2275             pos = pos_limit;
2276         start_pos = pos;
2277
2278         // May pass pos_limit instead of -1.
2279         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2280         if (pos == pos_max)
2281             no_change++;
2282         else
2283             no_change = 0;
2284         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2285                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2286                 pos_min, pos, pos_max,
2287                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2288                 pos_limit, start_pos, no_change);
2289         if (ts == AV_NOPTS_VALUE) {
2290             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2291             return -1;
2292         }
2293         if (target_ts <= ts) {
2294             pos_limit = start_pos - 1;
2295             pos_max   = pos;
2296             ts_max    = ts;
2297         }
2298         if (target_ts >= ts) {
2299             pos_min = pos;
2300             ts_min  = ts;
2301         }
2302     }
2303
2304     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2305     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
2306 #if 0
2307     pos_min = pos;
2308     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2309     pos_min++;
2310     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2311     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2312             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2313 #endif
2314     *ts_ret = ts;
2315     return pos;
2316 }
2317
2318 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2319                            int64_t pos, int flags)
2320 {
2321     int64_t pos_min, pos_max;
2322
2323     pos_min = s->internal->data_offset;
2324     pos_max = avio_size(s->pb) - 1;
2325
2326     if (pos < pos_min)
2327         pos = pos_min;
2328     else if (pos > pos_max)
2329         pos = pos_max;
2330
2331     avio_seek(s->pb, pos, SEEK_SET);
2332
2333     s->io_repositioned = 1;
2334
2335     return 0;
2336 }
2337
2338 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2339                               int64_t timestamp, int flags)
2340 {
2341     int index;
2342     int64_t ret;
2343     AVStream *st;
2344     AVIndexEntry *ie;
2345
2346     st = s->streams[stream_index];
2347
2348     index = av_index_search_timestamp(st, timestamp, flags);
2349
2350     if (index < 0 && st->nb_index_entries &&
2351         timestamp < st->index_entries[0].timestamp)
2352         return -1;
2353
2354     if (index < 0 || index == st->nb_index_entries - 1) {
2355         AVPacket pkt;
2356         int nonkey = 0;
2357
2358         if (st->nb_index_entries) {
2359             av_assert0(st->index_entries);
2360             ie = &st->index_entries[st->nb_index_entries - 1];
2361             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2362                 return ret;
2363             ff_update_cur_dts(s, st, ie->timestamp);
2364         } else {
2365             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2366                 return ret;
2367         }
2368         for (;;) {
2369             int read_status;
2370             do {
2371                 read_status = av_read_frame(s, &pkt);
2372             } while (read_status == AVERROR(EAGAIN));
2373             if (read_status < 0)
2374                 break;
2375             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2376                 if (pkt.flags & AV_PKT_FLAG_KEY) {
2377                     av_packet_unref(&pkt);
2378                     break;
2379                 }
2380                 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2381                     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);
2382                     av_packet_unref(&pkt);
2383                     break;
2384                 }
2385             }
2386             av_packet_unref(&pkt);
2387         }
2388         index = av_index_search_timestamp(st, timestamp, flags);
2389     }
2390     if (index < 0)
2391         return -1;
2392
2393     ff_read_frame_flush(s);
2394     if (s->iformat->read_seek)
2395         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2396             return 0;
2397     ie = &st->index_entries[index];
2398     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2399         return ret;
2400     ff_update_cur_dts(s, st, ie->timestamp);
2401
2402     return 0;
2403 }
2404
2405 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2406                                int64_t timestamp, int flags)
2407 {
2408     int ret;
2409     AVStream *st;
2410
2411     if (flags & AVSEEK_FLAG_BYTE) {
2412         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2413             return -1;
2414         ff_read_frame_flush(s);
2415         return seek_frame_byte(s, stream_index, timestamp, flags);
2416     }
2417
2418     if (stream_index < 0) {
2419         stream_index = av_find_default_stream_index(s);
2420         if (stream_index < 0)
2421             return -1;
2422
2423         st = s->streams[stream_index];
2424         /* timestamp for default must be expressed in AV_TIME_BASE units */
2425         timestamp = av_rescale(timestamp, st->time_base.den,
2426                                AV_TIME_BASE * (int64_t) st->time_base.num);
2427     }
2428
2429     /* first, we try the format specific seek */
2430     if (s->iformat->read_seek) {
2431         ff_read_frame_flush(s);
2432         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2433     } else
2434         ret = -1;
2435     if (ret >= 0)
2436         return 0;
2437
2438     if (s->iformat->read_timestamp &&
2439         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2440         ff_read_frame_flush(s);
2441         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2442     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2443         ff_read_frame_flush(s);
2444         return seek_frame_generic(s, stream_index, timestamp, flags);
2445     } else
2446         return -1;
2447 }
2448
2449 int av_seek_frame(AVFormatContext *s, int stream_index,
2450                   int64_t timestamp, int flags)
2451 {
2452     int ret;
2453
2454     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2455         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2456         if ((flags & AVSEEK_FLAG_BACKWARD))
2457             max_ts = timestamp;
2458         else
2459             min_ts = timestamp;
2460         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2461                                   flags & ~AVSEEK_FLAG_BACKWARD);
2462     }
2463
2464     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2465
2466     if (ret >= 0)
2467         ret = avformat_queue_attached_pictures(s);
2468
2469     return ret;
2470 }
2471
2472 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2473                        int64_t ts, int64_t max_ts, int flags)
2474 {
2475     if (min_ts > ts || max_ts < ts)
2476         return -1;
2477     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2478         return AVERROR(EINVAL);
2479
2480     if (s->seek2any>0)
2481         flags |= AVSEEK_FLAG_ANY;
2482     flags &= ~AVSEEK_FLAG_BACKWARD;
2483
2484     if (s->iformat->read_seek2) {
2485         int ret;
2486         ff_read_frame_flush(s);
2487
2488         if (stream_index == -1 && s->nb_streams == 1) {
2489             AVRational time_base = s->streams[0]->time_base;
2490             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2491             min_ts = av_rescale_rnd(min_ts, time_base.den,
2492                                     time_base.num * (int64_t)AV_TIME_BASE,
2493                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2494             max_ts = av_rescale_rnd(max_ts, time_base.den,
2495                                     time_base.num * (int64_t)AV_TIME_BASE,
2496                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2497             stream_index = 0;
2498         }
2499
2500         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2501                                      ts, max_ts, flags);
2502
2503         if (ret >= 0)
2504             ret = avformat_queue_attached_pictures(s);
2505         return ret;
2506     }
2507
2508     if (s->iformat->read_timestamp) {
2509         // try to seek via read_timestamp()
2510     }
2511
2512     // Fall back on old API if new is not implemented but old is.
2513     // Note the old API has somewhat different semantics.
2514     if (s->iformat->read_seek || 1) {
2515         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2516         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2517         if (ret<0 && ts != min_ts && max_ts != ts) {
2518             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2519             if (ret >= 0)
2520                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2521         }
2522         return ret;
2523     }
2524
2525     // try some generic seek like seek_frame_generic() but with new ts semantics
2526     return -1; //unreachable
2527 }
2528
2529 int avformat_flush(AVFormatContext *s)
2530 {
2531     ff_read_frame_flush(s);
2532     return 0;
2533 }
2534
2535 /*******************************************************/
2536
2537 /**
2538  * Return TRUE if the stream has accurate duration in any stream.
2539  *
2540  * @return TRUE if the stream has accurate duration for at least one component.
2541  */
2542 static int has_duration(AVFormatContext *ic)
2543 {
2544     int i;
2545     AVStream *st;
2546
2547     for (i = 0; i < ic->nb_streams; i++) {
2548         st = ic->streams[i];
2549         if (st->duration != AV_NOPTS_VALUE)
2550             return 1;
2551     }
2552     if (ic->duration != AV_NOPTS_VALUE)
2553         return 1;
2554     return 0;
2555 }
2556
2557 /**
2558  * Estimate the stream timings from the one of each components.
2559  *
2560  * Also computes the global bitrate if possible.
2561  */
2562 static void update_stream_timings(AVFormatContext *ic)
2563 {
2564     int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2565     int64_t duration, duration1, filesize;
2566     int i;
2567     AVStream *st;
2568     AVProgram *p;
2569
2570     start_time = INT64_MAX;
2571     start_time_text = INT64_MAX;
2572     end_time   = INT64_MIN;
2573     end_time_text   = INT64_MIN;
2574     duration   = INT64_MIN;
2575     for (i = 0; i < ic->nb_streams; i++) {
2576         st = ic->streams[i];
2577         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2578             start_time1 = av_rescale_q(st->start_time, st->time_base,
2579                                        AV_TIME_BASE_Q);
2580             if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2581                 if (start_time1 < start_time_text)
2582                     start_time_text = start_time1;
2583             } else
2584                 start_time = FFMIN(start_time, start_time1);
2585             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2586                                          AV_TIME_BASE_Q,
2587                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2588             if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2589                 end_time1 += start_time1;
2590                 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2591                     end_time_text = FFMAX(end_time_text, end_time1);
2592                 else
2593                     end_time = FFMAX(end_time, end_time1);
2594             }
2595             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2596                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2597                     p->start_time = start_time1;
2598                 if (p->end_time < end_time1)
2599                     p->end_time = end_time1;
2600             }
2601         }
2602         if (st->duration != AV_NOPTS_VALUE) {
2603             duration1 = av_rescale_q(st->duration, st->time_base,
2604                                      AV_TIME_BASE_Q);
2605             duration  = FFMAX(duration, duration1);
2606         }
2607     }
2608     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2609         start_time = start_time_text;
2610     else if (start_time > start_time_text)
2611         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2612
2613     if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2614         end_time = end_time_text;
2615     } else if (end_time < end_time_text) {
2616         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2617     }
2618
2619     if (start_time != INT64_MAX) {
2620         ic->start_time = start_time;
2621         if (end_time != INT64_MIN) {
2622             if (ic->nb_programs > 1) {
2623                 for (i = 0; i < ic->nb_programs; i++) {
2624                     p = ic->programs[i];
2625                     if (p->start_time != AV_NOPTS_VALUE &&
2626                         p->end_time > p->start_time &&
2627                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2628                         duration = FFMAX(duration, p->end_time - p->start_time);
2629                 }
2630             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2631                 duration = FFMAX(duration, end_time - start_time);
2632             }
2633         }
2634     }
2635     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2636         ic->duration = duration;
2637     }
2638     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2639         /* compute the bitrate */
2640         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2641                          (double) ic->duration;
2642         if (bitrate >= 0 && bitrate <= INT64_MAX)
2643             ic->bit_rate = bitrate;
2644     }
2645 }
2646
2647 static void fill_all_stream_timings(AVFormatContext *ic)
2648 {
2649     int i;
2650     AVStream *st;
2651
2652     update_stream_timings(ic);
2653     for (i = 0; i < ic->nb_streams; i++) {
2654         st = ic->streams[i];
2655         if (st->start_time == AV_NOPTS_VALUE) {
2656             if (ic->start_time != AV_NOPTS_VALUE)
2657                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2658                                               st->time_base);
2659             if (ic->duration != AV_NOPTS_VALUE)
2660                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2661                                             st->time_base);
2662         }
2663     }
2664 }
2665
2666 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2667 {
2668     int64_t filesize, duration;
2669     int i, show_warning = 0;
2670     AVStream *st;
2671
2672     /* if bit_rate is already set, we believe it */
2673     if (ic->bit_rate <= 0) {
2674         int64_t bit_rate = 0;
2675         for (i = 0; i < ic->nb_streams; i++) {
2676             st = ic->streams[i];
2677             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2678                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2679             if (st->codecpar->bit_rate > 0) {
2680                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2681                     bit_rate = 0;
2682                     break;
2683                 }
2684                 bit_rate += st->codecpar->bit_rate;
2685             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2686                 // If we have a videostream with packets but without a bitrate
2687                 // then consider the sum not known
2688                 bit_rate = 0;
2689                 break;
2690             }
2691         }
2692         ic->bit_rate = bit_rate;
2693     }
2694
2695     /* if duration is already set, we believe it */
2696     if (ic->duration == AV_NOPTS_VALUE &&
2697         ic->bit_rate != 0) {
2698         filesize = ic->pb ? avio_size(ic->pb) : 0;
2699         if (filesize > ic->internal->data_offset) {
2700             filesize -= ic->internal->data_offset;
2701             for (i = 0; i < ic->nb_streams; i++) {
2702                 st      = ic->streams[i];
2703                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2704                     && st->duration == AV_NOPTS_VALUE) {
2705                     duration = av_rescale(8 * filesize, st->time_base.den,
2706                                           ic->bit_rate *
2707                                           (int64_t) st->time_base.num);
2708                     st->duration = duration;
2709                     show_warning = 1;
2710                 }
2711             }
2712         }
2713     }
2714     if (show_warning)
2715         av_log(ic, AV_LOG_WARNING,
2716                "Estimating duration from bitrate, this may be inaccurate\n");
2717 }
2718
2719 #define DURATION_MAX_READ_SIZE 250000LL
2720 #define DURATION_MAX_RETRY 6
2721
2722 /* only usable for MPEG-PS streams */
2723 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2724 {
2725     AVPacket pkt1, *pkt = &pkt1;
2726     AVStream *st;
2727     int num, den, read_size, i, ret;
2728     int found_duration = 0;
2729     int is_end;
2730     int64_t filesize, offset, duration;
2731     int retry = 0;
2732
2733     /* flush packet queue */
2734     flush_packet_queue(ic);
2735
2736     for (i = 0; i < ic->nb_streams; i++) {
2737         st = ic->streams[i];
2738         if (st->start_time == AV_NOPTS_VALUE &&
2739             st->first_dts == AV_NOPTS_VALUE &&
2740             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2741             av_log(ic, AV_LOG_WARNING,
2742                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2743
2744         if (st->parser) {
2745             av_parser_close(st->parser);
2746             st->parser = NULL;
2747         }
2748     }
2749
2750     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2751     /* estimate the end time (duration) */
2752     /* XXX: may need to support wrapping */
2753     filesize = ic->pb ? avio_size(ic->pb) : 0;
2754     do {
2755         is_end = found_duration;
2756         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2757         if (offset < 0)
2758             offset = 0;
2759
2760         avio_seek(ic->pb, offset, SEEK_SET);
2761         read_size = 0;
2762         for (;;) {
2763             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2764                 break;
2765
2766             do {
2767                 ret = ff_read_packet(ic, pkt);
2768             } while (ret == AVERROR(EAGAIN));
2769             if (ret != 0)
2770                 break;
2771             read_size += pkt->size;
2772             st         = ic->streams[pkt->stream_index];
2773             if (pkt->pts != AV_NOPTS_VALUE &&
2774                 (st->start_time != AV_NOPTS_VALUE ||
2775                  st->first_dts  != AV_NOPTS_VALUE)) {
2776                 if (pkt->duration == 0) {
2777                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2778                     if (den && num) {
2779                         pkt->duration = av_rescale_rnd(1,
2780                                            num * (int64_t) st->time_base.den,
2781                                            den * (int64_t) st->time_base.num,
2782                                            AV_ROUND_DOWN);
2783                     }
2784                 }
2785                 duration = pkt->pts + pkt->duration;
2786                 found_duration = 1;
2787                 if (st->start_time != AV_NOPTS_VALUE)
2788                     duration -= st->start_time;
2789                 else
2790                     duration -= st->first_dts;
2791                 if (duration > 0) {
2792                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2793                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2794                         st->duration = duration;
2795                     st->info->last_duration = duration;
2796                 }
2797             }
2798             av_packet_unref(pkt);
2799         }
2800
2801         /* check if all audio/video streams have valid duration */
2802         if (!is_end) {
2803             is_end = 1;
2804             for (i = 0; i < ic->nb_streams; i++) {
2805                 st = ic->streams[i];
2806                 switch (st->codecpar->codec_type) {
2807                     case AVMEDIA_TYPE_VIDEO:
2808                     case AVMEDIA_TYPE_AUDIO:
2809                         if (st->duration == AV_NOPTS_VALUE)
2810                             is_end = 0;
2811                 }
2812             }
2813         }
2814     } while (!is_end &&
2815              offset &&
2816              ++retry <= DURATION_MAX_RETRY);
2817
2818     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2819
2820     /* warn about audio/video streams which duration could not be estimated */
2821     for (i = 0; i < ic->nb_streams; i++) {
2822         st = ic->streams[i];
2823         if (st->duration == AV_NOPTS_VALUE) {
2824             switch (st->codecpar->codec_type) {
2825             case AVMEDIA_TYPE_VIDEO:
2826             case AVMEDIA_TYPE_AUDIO:
2827                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2828                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2829                 } else
2830                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2831             }
2832         }
2833     }
2834     fill_all_stream_timings(ic);
2835
2836     avio_seek(ic->pb, old_offset, SEEK_SET);
2837     for (i = 0; i < ic->nb_streams; i++) {
2838         int j;
2839
2840         st              = ic->streams[i];
2841         st->cur_dts     = st->first_dts;
2842         st->last_IP_pts = AV_NOPTS_VALUE;
2843         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2844         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2845             st->pts_buffer[j] = AV_NOPTS_VALUE;
2846     }
2847 }
2848
2849 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2850 {
2851     int64_t file_size;
2852
2853     /* get the file size, if possible */
2854     if (ic->iformat->flags & AVFMT_NOFILE) {
2855         file_size = 0;
2856     } else {
2857         file_size = avio_size(ic->pb);
2858         file_size = FFMAX(0, file_size);
2859     }
2860
2861     if ((!strcmp(ic->iformat->name, "mpeg") ||
2862          !strcmp(ic->iformat->name, "mpegts")) &&
2863         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2864         /* get accurate estimate from the PTSes */
2865         estimate_timings_from_pts(ic, old_offset);
2866         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2867     } else if (has_duration(ic)) {
2868         /* at least one component has timings - we use them for all
2869          * the components */
2870         fill_all_stream_timings(ic);
2871         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2872     } else {
2873         /* less precise: use bitrate info */
2874         estimate_timings_from_bit_rate(ic);
2875         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2876     }
2877     update_stream_timings(ic);
2878
2879     {
2880         int i;
2881         AVStream av_unused *st;
2882         for (i = 0; i < ic->nb_streams; i++) {
2883             st = ic->streams[i];
2884             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2885                    (double) st->start_time * av_q2d(st->time_base),
2886                    (double) st->duration   * av_q2d(st->time_base));
2887         }
2888         av_log(ic, AV_LOG_TRACE,
2889                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2890                 (double) ic->start_time / AV_TIME_BASE,
2891                 (double) ic->duration   / AV_TIME_BASE,
2892                 (int64_t)ic->bit_rate / 1000);
2893     }
2894 }
2895
2896 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2897 {
2898     AVCodecContext *avctx = st->internal->avctx;
2899
2900 #define FAIL(errmsg) do {                                         \
2901         if (errmsg_ptr)                                           \
2902             *errmsg_ptr = errmsg;                                 \
2903         return 0;                                                 \
2904     } while (0)
2905
2906     if (   avctx->codec_id == AV_CODEC_ID_NONE
2907         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2908         FAIL("unknown codec");
2909     switch (avctx->codec_type) {
2910     case AVMEDIA_TYPE_AUDIO:
2911         if (!avctx->frame_size && determinable_frame_size(avctx))
2912             FAIL("unspecified frame size");
2913         if (st->info->found_decoder >= 0 &&
2914             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2915             FAIL("unspecified sample format");
2916         if (!avctx->sample_rate)
2917             FAIL("unspecified sample rate");
2918         if (!avctx->channels)
2919             FAIL("unspecified number of channels");
2920         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2921             FAIL("no decodable DTS frames");
2922         break;
2923     case AVMEDIA_TYPE_VIDEO:
2924         if (!avctx->width)
2925             FAIL("unspecified size");
2926         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2927             FAIL("unspecified pixel format");
2928         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2929             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2930                 FAIL("no frame in rv30/40 and no sar");
2931         break;
2932     case AVMEDIA_TYPE_SUBTITLE:
2933         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2934             FAIL("unspecified size");
2935         break;
2936     case AVMEDIA_TYPE_DATA:
2937         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2938     }
2939
2940     return 1;
2941 }
2942
2943 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2944 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2945                             AVDictionary **options)
2946 {
2947     AVCodecContext *avctx = st->internal->avctx;
2948     const AVCodec *codec;
2949     int got_picture = 1, ret = 0;
2950     AVFrame *frame = av_frame_alloc();
2951     AVSubtitle subtitle;
2952     AVPacket pkt = *avpkt;
2953     int do_skip_frame = 0;
2954     enum AVDiscard skip_frame;
2955
2956     if (!frame)
2957         return AVERROR(ENOMEM);
2958
2959     if (!avcodec_is_open(avctx) &&
2960         st->info->found_decoder <= 0 &&
2961         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2962         AVDictionary *thread_opt = NULL;
2963
2964         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2965
2966         if (!codec) {
2967             st->info->found_decoder = -st->codecpar->codec_id;
2968             ret                     = -1;
2969             goto fail;
2970         }
2971
2972         /* Force thread count to 1 since the H.264 decoder will not extract
2973          * SPS and PPS to extradata during multi-threaded decoding. */
2974         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2975         if (s->codec_whitelist)
2976             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2977         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2978         if (!options)
2979             av_dict_free(&thread_opt);
2980         if (ret < 0) {
2981             st->info->found_decoder = -avctx->codec_id;
2982             goto fail;
2983         }
2984         st->info->found_decoder = 1;
2985     } else if (!st->info->found_decoder)
2986         st->info->found_decoder = 1;
2987
2988     if (st->info->found_decoder < 0) {
2989         ret = -1;
2990         goto fail;
2991     }
2992
2993     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2994         do_skip_frame = 1;
2995         skip_frame = avctx->skip_frame;
2996         avctx->skip_frame = AVDISCARD_ALL;
2997     }
2998
2999     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3000            ret >= 0 &&
3001            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3002             (!st->codec_info_nb_frames &&
3003              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3004         got_picture = 0;
3005         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3006             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3007             ret = avcodec_send_packet(avctx, &pkt);
3008             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3009                 break;
3010             if (ret >= 0)
3011                 pkt.size = 0;
3012             ret = avcodec_receive_frame(avctx, frame);
3013             if (ret >= 0)
3014                 got_picture = 1;
3015             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3016                 ret = 0;
3017         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3018             ret = avcodec_decode_subtitle2(avctx, &subtitle,
3019                                            &got_picture, &pkt);
3020             if (ret >= 0)
3021                 pkt.size = 0;
3022         }
3023         if (ret >= 0) {
3024             if (got_picture)
3025                 st->nb_decoded_frames++;
3026             ret       = got_picture;
3027         }
3028     }
3029
3030     if (!pkt.data && !got_picture)
3031         ret = -1;
3032
3033 fail:
3034     if (do_skip_frame) {
3035         avctx->skip_frame = skip_frame;
3036     }
3037
3038     av_frame_free(&frame);
3039     return ret;
3040 }
3041
3042 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3043 {
3044     while (tags->id != AV_CODEC_ID_NONE) {
3045         if (tags->id == id)
3046             return tags->tag;
3047         tags++;
3048     }
3049     return 0;
3050 }
3051
3052 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3053 {
3054     int i;
3055     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3056         if (tag == tags[i].tag)
3057             return tags[i].id;
3058     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3059         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3060             return tags[i].id;
3061     return AV_CODEC_ID_NONE;
3062 }
3063
3064 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3065 {
3066     if (bps <= 0 || bps > 64)
3067         return AV_CODEC_ID_NONE;
3068
3069     if (flt) {
3070         switch (bps) {
3071         case 32:
3072             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3073         case 64:
3074             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3075         default:
3076             return AV_CODEC_ID_NONE;
3077         }
3078     } else {
3079         bps  += 7;
3080         bps >>= 3;
3081         if (sflags & (1 << (bps - 1))) {
3082             switch (bps) {
3083             case 1:
3084                 return AV_CODEC_ID_PCM_S8;
3085             case 2:
3086                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3087             case 3:
3088                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3089             case 4:
3090                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3091             case 8:
3092                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3093             default:
3094                 return AV_CODEC_ID_NONE;
3095             }
3096         } else {
3097             switch (bps) {
3098             case 1:
3099                 return AV_CODEC_ID_PCM_U8;
3100             case 2:
3101                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3102             case 3:
3103                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3104             case 4:
3105                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3106             default:
3107                 return AV_CODEC_ID_NONE;
3108             }
3109         }
3110     }
3111 }
3112
3113 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3114 {
3115     unsigned int tag;
3116     if (!av_codec_get_tag2(tags, id, &tag))
3117         return 0;
3118     return tag;
3119 }
3120
3121 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3122                       unsigned int *tag)
3123 {
3124     int i;
3125     for (i = 0; tags && tags[i]; i++) {
3126         const AVCodecTag *codec_tags = tags[i];
3127         while (codec_tags->id != AV_CODEC_ID_NONE) {
3128             if (codec_tags->id == id) {
3129                 *tag = codec_tags->tag;
3130                 return 1;
3131             }
3132             codec_tags++;
3133         }
3134     }
3135     return 0;
3136 }
3137
3138 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3139 {
3140     int i;
3141     for (i = 0; tags && tags[i]; i++) {
3142         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3143         if (id != AV_CODEC_ID_NONE)
3144             return id;
3145     }
3146     return AV_CODEC_ID_NONE;
3147 }
3148
3149 static void compute_chapters_end(AVFormatContext *s)
3150 {
3151     unsigned int i, j;
3152     int64_t max_time = 0;
3153
3154     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3155         max_time = s->duration +
3156                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3157
3158     for (i = 0; i < s->nb_chapters; i++)
3159         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3160             AVChapter *ch = s->chapters[i];
3161             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3162                                                   ch->time_base)
3163                                    : INT64_MAX;
3164
3165             for (j = 0; j < s->nb_chapters; j++) {
3166                 AVChapter *ch1     = s->chapters[j];
3167                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3168                                                   ch->time_base);
3169                 if (j != i && next_start > ch->start && next_start < end)
3170                     end = next_start;
3171             }
3172             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3173         }
3174 }
3175
3176 static int get_std_framerate(int i)
3177 {
3178     if (i < 30*12)
3179         return (i + 1) * 1001;
3180     i -= 30*12;
3181
3182     if (i < 30)
3183         return (i + 31) * 1001 * 12;
3184     i -= 30;
3185
3186     if (i < 3)
3187         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3188
3189     i -= 3;
3190
3191     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3192 }
3193
3194 /* Is the time base unreliable?
3195  * This is a heuristic to balance between quick acceptance of the values in
3196  * the headers vs. some extra checks.
3197  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3198  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3199  * And there are "variable" fps files this needs to detect as well. */
3200 static int tb_unreliable(AVCodecContext *c)
3201 {
3202     if (c->time_base.den >= 101LL * c->time_base.num ||
3203         c->time_base.den <    5LL * c->time_base.num ||
3204         // c->codec_tag == AV_RL32("DIVX") ||
3205         // c->codec_tag == AV_RL32("XVID") ||
3206         c->codec_tag == AV_RL32("mp4v") ||
3207         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3208         c->codec_id == AV_CODEC_ID_GIF ||
3209         c->codec_id == AV_CODEC_ID_HEVC ||
3210         c->codec_id == AV_CODEC_ID_H264)
3211         return 1;
3212     return 0;
3213 }
3214
3215 int ff_alloc_extradata(AVCodecParameters *par, int size)
3216 {
3217     int ret;
3218
3219     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3220         par->extradata = NULL;
3221         par->extradata_size = 0;
3222         return AVERROR(EINVAL);
3223     }
3224     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3225     if (par->extradata) {
3226         memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3227         par->extradata_size = size;
3228         ret = 0;
3229     } else {
3230         par->extradata_size = 0;
3231         ret = AVERROR(ENOMEM);
3232     }
3233     return ret;
3234 }
3235
3236 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3237 {
3238     int ret = ff_alloc_extradata(par, size);
3239     if (ret < 0)
3240         return ret;
3241     ret = avio_read(pb, par->extradata, size);
3242     if (ret != size) {
3243         av_freep(&par->extradata);
3244         par->extradata_size = 0;
3245         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3246         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3247     }
3248
3249     return ret;
3250 }
3251
3252 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3253 {
3254     int i, j;
3255     int64_t last = st->info->last_dts;
3256
3257     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3258        && ts - (uint64_t)last < INT64_MAX) {
3259         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3260         int64_t duration = ts - last;
3261
3262         if (!st->info->duration_error)
3263             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3264         if (!st->info->duration_error)
3265             return AVERROR(ENOMEM);
3266
3267 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3268 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3269         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3270             if (st->info->duration_error[0][1][i] < 1e10) {
3271                 int framerate = get_std_framerate(i);
3272                 double sdts = dts*framerate/(1001*12);
3273                 for (j= 0; j<2; j++) {
3274                     int64_t ticks = llrint(sdts+j*0.5);
3275                     double error= sdts - ticks + j*0.5;
3276                     st->info->duration_error[j][0][i] += error;
3277                     st->info->duration_error[j][1][i] += error*error;
3278                 }
3279             }
3280         }
3281         st->info->duration_count++;
3282         st->info->rfps_duration_sum += duration;
3283
3284         if (st->info->duration_count % 10 == 0) {
3285             int n = st->info->duration_count;
3286             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3287                 if (st->info->duration_error[0][1][i] < 1e10) {
3288                     double a0     = st->info->duration_error[0][0][i] / n;
3289                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3290                     double a1     = st->info->duration_error[1][0][i] / n;
3291                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3292                     if (error0 > 0.04 && error1 > 0.04) {
3293                         st->info->duration_error[0][1][i] = 2e10;
3294                         st->info->duration_error[1][1][i] = 2e10;
3295                     }
3296                 }
3297             }
3298         }
3299
3300         // ignore the first 4 values, they might have some random jitter
3301         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3302             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3303     }
3304     if (ts != AV_NOPTS_VALUE)
3305         st->info->last_dts = ts;
3306
3307     return 0;
3308 }
3309
3310 void ff_rfps_calculate(AVFormatContext *ic)
3311 {
3312     int i, j;
3313
3314     for (i = 0; i < ic->nb_streams; i++) {
3315         AVStream *st = ic->streams[i];
3316
3317         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3318             continue;
3319         // the check for tb_unreliable() is not completely correct, since this is not about handling
3320         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3321         // ipmovie.c produces.
3322         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)
3323             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);
3324         if (st->info->duration_count>1 && !st->r_frame_rate.num
3325             && tb_unreliable(st->internal->avctx)) {
3326             int num = 0;
3327             double best_error= 0.01;
3328             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3329
3330             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3331                 int k;
3332
3333                 if (st->info->codec_info_duration &&
3334                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3335                     continue;
3336                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3337                     continue;
3338
3339                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3340                     continue;
3341
3342                 for (k= 0; k<2; k++) {
3343                     int n = st->info->duration_count;
3344                     double a= st->info->duration_error[k][0][j] / n;
3345                     double error= st->info->duration_error[k][1][j]/n - a*a;
3346
3347                     if (error < best_error && best_error> 0.000000001) {
3348                         best_error= error;
3349                         num = get_std_framerate(j);
3350                     }
3351                     if (error < 0.02)
3352                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3353                 }
3354             }
3355             // do not increase frame rate by more than 1 % in order to match a standard rate.
3356             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3357                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3358         }
3359         if (   !st->avg_frame_rate.num
3360             && st->r_frame_rate.num && st->info->rfps_duration_sum
3361             && st->info->codec_info_duration <= 0
3362             && st->info->duration_count > 2
3363             && 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
3364             ) {
3365             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3366             st->avg_frame_rate = st->r_frame_rate;
3367         }
3368
3369         av_freep(&st->info->duration_error);
3370         st->info->last_dts = AV_NOPTS_VALUE;
3371         st->info->duration_count = 0;
3372         st->info->rfps_duration_sum = 0;
3373     }
3374 }
3375
3376 static int extract_extradata_check(AVStream *st)
3377 {
3378     const AVBitStreamFilter *f;
3379
3380     f = av_bsf_get_by_name("extract_extradata");
3381     if (!f)
3382         return 0;
3383
3384     if (f->codec_ids) {
3385         const enum AVCodecID *ids;
3386         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3387             if (*ids == st->codecpar->codec_id)
3388                 return 1;
3389     }
3390
3391     return 0;
3392 }
3393
3394 static int extract_extradata_init(AVStream *st)
3395 {
3396     AVStreamInternal *i = st->internal;
3397     const AVBitStreamFilter *f;
3398     int ret;
3399
3400     f = av_bsf_get_by_name("extract_extradata");
3401     if (!f)
3402         goto finish;
3403
3404     /* check that the codec id is supported */
3405     ret = extract_extradata_check(st);
3406     if (!ret)
3407         goto finish;
3408
3409     i->extract_extradata.pkt = av_packet_alloc();
3410     if (!i->extract_extradata.pkt)
3411         return AVERROR(ENOMEM);
3412
3413     ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3414     if (ret < 0)
3415         goto fail;
3416
3417     ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3418                                   st->codecpar);
3419     if (ret < 0)
3420         goto fail;
3421
3422     i->extract_extradata.bsf->time_base_in = st->time_base;
3423
3424     /* if init fails here, we assume extracting extradata is just not
3425      * supported for this codec, so we return success */
3426     ret = av_bsf_init(i->extract_extradata.bsf);
3427     if (ret < 0) {
3428         av_bsf_free(&i->extract_extradata.bsf);
3429         ret = 0;
3430     }
3431
3432 finish:
3433     i->extract_extradata.inited = 1;
3434
3435     return 0;
3436 fail:
3437     av_bsf_free(&i->extract_extradata.bsf);
3438     av_packet_free(&i->extract_extradata.pkt);
3439     return ret;
3440 }
3441
3442 static int extract_extradata(AVStream *st, AVPacket *pkt)
3443 {
3444     AVStreamInternal *i = st->internal;
3445     AVPacket *pkt_ref;
3446     int ret;
3447
3448     if (!i->extract_extradata.inited) {
3449         ret = extract_extradata_init(st);
3450         if (ret < 0)
3451             return ret;
3452     }
3453
3454     if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3455         return 0;
3456
3457     pkt_ref = i->extract_extradata.pkt;
3458     ret = av_packet_ref(pkt_ref, pkt);
3459     if (ret < 0)
3460         return ret;
3461
3462     ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3463     if (ret < 0) {
3464         av_packet_unref(pkt_ref);
3465         return ret;
3466     }
3467
3468     while (ret >= 0 && !i->avctx->extradata) {
3469         int extradata_size;
3470         uint8_t *extradata;
3471
3472         ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3473         if (ret < 0) {
3474             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3475                 return ret;
3476             continue;
3477         }
3478
3479         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3480                                             &extradata_size);
3481
3482         if (extradata) {
3483             i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3484             if (!i->avctx->extradata) {
3485                 av_packet_unref(pkt_ref);
3486                 return AVERROR(ENOMEM);
3487             }
3488             memcpy(i->avctx->extradata, extradata, extradata_size);
3489             i->avctx->extradata_size = extradata_size;
3490         }
3491         av_packet_unref(pkt_ref);
3492     }
3493
3494     return 0;
3495 }
3496
3497 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3498 {
3499     int i, count = 0, ret = 0, j;
3500     int64_t read_size;
3501     AVStream *st;
3502     AVCodecContext *avctx;
3503     AVPacket pkt1, *pkt;
3504     int64_t old_offset  = avio_tell(ic->pb);
3505     // new streams might appear, no options for those
3506     int orig_nb_streams = ic->nb_streams;
3507     int flush_codecs;
3508     int64_t max_analyze_duration = ic->max_analyze_duration;
3509     int64_t max_stream_analyze_duration;
3510     int64_t max_subtitle_analyze_duration;
3511     int64_t probesize = ic->probesize;
3512     int eof_reached = 0;
3513     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3514
3515     flush_codecs = probesize > 0;
3516
3517     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3518
3519     max_stream_analyze_duration = max_analyze_duration;
3520     max_subtitle_analyze_duration = max_analyze_duration;
3521     if (!max_analyze_duration) {
3522         max_stream_analyze_duration =
3523         max_analyze_duration        = 5*AV_TIME_BASE;
3524         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3525         if (!strcmp(ic->iformat->name, "flv"))
3526             max_stream_analyze_duration = 90*AV_TIME_BASE;
3527         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3528             max_stream_analyze_duration = 7*AV_TIME_BASE;
3529     }
3530
3531     if (ic->pb)
3532         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3533                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3534
3535     for (i = 0; i < ic->nb_streams; i++) {
3536         const AVCodec *codec;
3537         AVDictionary *thread_opt = NULL;
3538         st = ic->streams[i];
3539         avctx = st->internal->avctx;
3540
3541         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3542             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3543 /*            if (!st->time_base.num)
3544                 st->time_base = */
3545             if (!avctx->time_base.num)
3546                 avctx->time_base = st->time_base;
3547         }
3548
3549         /* check if the caller has overridden the codec id */
3550 #if FF_API_LAVF_AVCTX
3551 FF_DISABLE_DEPRECATION_WARNINGS
3552         if (st->codec->codec_id != st->internal->orig_codec_id) {
3553             st->codecpar->codec_id   = st->codec->codec_id;
3554             st->codecpar->codec_type = st->codec->codec_type;
3555             st->internal->orig_codec_id = st->codec->codec_id;
3556         }
3557 FF_ENABLE_DEPRECATION_WARNINGS
3558 #endif
3559         // only for the split stuff
3560         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3561             st->parser = av_parser_init(st->codecpar->codec_id);
3562             if (st->parser) {
3563                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3564                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3565                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3566                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3567                 }
3568             } else if (st->need_parsing) {
3569                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3570                        "%s, packets or times may be invalid.\n",
3571                        avcodec_get_name(st->codecpar->codec_id));
3572             }
3573         }
3574
3575         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3576             st->internal->orig_codec_id = st->codecpar->codec_id;
3577
3578         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3579         if (ret < 0)
3580             goto find_stream_info_err;
3581         if (st->request_probe <= 0)
3582             st->internal->avctx_inited = 1;
3583
3584         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3585
3586         /* Force thread count to 1 since the H.264 decoder will not extract
3587          * SPS and PPS to extradata during multi-threaded decoding. */
3588         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3589
3590         if (ic->codec_whitelist)
3591             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3592
3593         /* Ensure that subtitle_header is properly set. */
3594         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3595             && codec && !avctx->codec) {
3596             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3597                 av_log(ic, AV_LOG_WARNING,
3598                        "Failed to open codec in %s\n",__FUNCTION__);
3599         }
3600
3601         // Try to just open decoders, in case this is enough to get parameters.
3602         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3603             if (codec && !avctx->codec)
3604                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3605                     av_log(ic, AV_LOG_WARNING,
3606                            "Failed to open codec in %s\n",__FUNCTION__);
3607         }
3608         if (!options)
3609             av_dict_free(&thread_opt);
3610     }
3611
3612     for (i = 0; i < ic->nb_streams; i++) {
3613 #if FF_API_R_FRAME_RATE
3614         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3615 #endif
3616         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3617         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3618     }
3619
3620     read_size = 0;
3621     for (;;) {
3622         int analyzed_all_streams;
3623         if (ff_check_interrupt(&ic->interrupt_callback)) {
3624             ret = AVERROR_EXIT;
3625             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3626             break;
3627         }
3628
3629         /* check if one codec still needs to be handled */
3630         for (i = 0; i < ic->nb_streams; i++) {
3631             int fps_analyze_framecount = 20;
3632             int count;
3633
3634             st = ic->streams[i];
3635             if (!has_codec_parameters(st, NULL))
3636                 break;
3637             /* If the timebase is coarse (like the usual millisecond precision
3638              * of mkv), we need to analyze more frames to reliably arrive at
3639              * the correct fps. */
3640             if (av_q2d(st->time_base) > 0.0005)
3641                 fps_analyze_framecount *= 2;
3642             if (!tb_unreliable(st->internal->avctx))
3643                 fps_analyze_framecount = 0;
3644             if (ic->fps_probe_size >= 0)
3645                 fps_analyze_framecount = ic->fps_probe_size;
3646             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3647                 fps_analyze_framecount = 0;
3648             /* variable fps and no guess at the real fps */
3649             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3650                        st->info->codec_info_duration_fields/2 :
3651                        st->info->duration_count;
3652             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3653                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3654                 if (count < fps_analyze_framecount)
3655                     break;
3656             }
3657             // Look at the first 3 frames if there is evidence of frame delay
3658             // but the decoder delay is not set.
3659             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3660                 break;
3661             if (!st->internal->avctx->extradata &&
3662                 (!st->internal->extract_extradata.inited ||
3663                  st->internal->extract_extradata.bsf) &&
3664                 extract_extradata_check(st))
3665                 break;
3666             if (st->first_dts == AV_NOPTS_VALUE &&
3667                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3668                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3669                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3670                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3671                 break;
3672         }
3673         analyzed_all_streams = 0;
3674         if (!missing_streams || !*missing_streams)
3675         if (i == ic->nb_streams) {
3676             analyzed_all_streams = 1;
3677             /* NOTE: If the format has no header, then we need to read some
3678              * packets to get most of the streams, so we cannot stop here. */
3679             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3680                 /* If we found the info for all the codecs, we can stop. */
3681                 ret = count;
3682                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3683                 flush_codecs = 0;
3684                 break;
3685             }
3686         }
3687         /* We did not get all the codec info, but we read too much data. */
3688         if (read_size >= probesize) {
3689             ret = count;
3690             av_log(ic, AV_LOG_DEBUG,
3691                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3692             for (i = 0; i < ic->nb_streams; i++)
3693                 if (!ic->streams[i]->r_frame_rate.num &&
3694                     ic->streams[i]->info->duration_count <= 1 &&
3695                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3696                     strcmp(ic->iformat->name, "image2"))
3697                     av_log(ic, AV_LOG_WARNING,
3698                            "Stream #%d: not enough frames to estimate rate; "
3699                            "consider increasing probesize\n", i);
3700             break;
3701         }
3702
3703         /* NOTE: A new stream can be added there if no header in file
3704          * (AVFMTCTX_NOHEADER). */
3705         ret = read_frame_internal(ic, &pkt1);
3706         if (ret == AVERROR(EAGAIN))
3707             continue;
3708
3709         if (ret < 0) {
3710             /* EOF or error*/
3711             eof_reached = 1;
3712             break;
3713         }
3714
3715         pkt = &pkt1;
3716
3717         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3718             ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3719                                 &ic->internal->packet_buffer_end, 0);
3720             if (ret < 0)
3721                 goto find_stream_info_err;
3722         }
3723
3724         st = ic->streams[pkt->stream_index];
3725         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3726             read_size += pkt->size;
3727
3728         avctx = st->internal->avctx;
3729         if (!st->internal->avctx_inited) {
3730             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3731             if (ret < 0)
3732                 goto find_stream_info_err;
3733             st->internal->avctx_inited = 1;
3734         }
3735
3736         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3737             /* check for non-increasing dts */
3738             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3739                 st->info->fps_last_dts >= pkt->dts) {
3740                 av_log(ic, AV_LOG_DEBUG,
3741                        "Non-increasing DTS in stream %d: packet %d with DTS "
3742                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3743                        st->index, st->info->fps_last_dts_idx,
3744                        st->info->fps_last_dts, st->codec_info_nb_frames,
3745                        pkt->dts);
3746                 st->info->fps_first_dts =
3747                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3748             }
3749             /* Check for a discontinuity in dts. If the difference in dts
3750              * is more than 1000 times the average packet duration in the
3751              * sequence, we treat it as a discontinuity. */
3752             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3753                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3754                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3755                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3756                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3757                 av_log(ic, AV_LOG_WARNING,
3758                        "DTS discontinuity in stream %d: packet %d with DTS "
3759                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3760                        st->index, st->info->fps_last_dts_idx,
3761                        st->info->fps_last_dts, st->codec_info_nb_frames,
3762                        pkt->dts);
3763                 st->info->fps_first_dts =
3764                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3765             }
3766
3767             /* update stored dts values */
3768             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3769                 st->info->fps_first_dts     = pkt->dts;
3770                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3771             }
3772             st->info->fps_last_dts     = pkt->dts;
3773             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3774         }
3775         if (st->codec_info_nb_frames>1) {
3776             int64_t t = 0;
3777             int64_t limit;
3778
3779             if (st->time_base.den > 0)
3780                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3781             if (st->avg_frame_rate.num > 0)
3782                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3783
3784             if (   t == 0
3785                 && st->codec_info_nb_frames>30
3786                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3787                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3788                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3789
3790             if (analyzed_all_streams)                                limit = max_analyze_duration;
3791             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3792             else                                                     limit = max_stream_analyze_duration;
3793
3794             if (t >= limit) {
3795                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3796                        limit,
3797                        t, pkt->stream_index);
3798                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3799                     av_packet_unref(pkt);
3800                 break;
3801             }
3802             if (pkt->duration) {
3803                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3804                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3805                 } else
3806                     st->info->codec_info_duration += pkt->duration;
3807                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3808             }
3809         }
3810         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3811 #if FF_API_R_FRAME_RATE
3812             ff_rfps_add_frame(ic, st, pkt->dts);
3813 #endif
3814             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3815                 st->info->frame_delay_evidence = 1;
3816         }
3817         if (!st->internal->avctx->extradata) {
3818             ret = extract_extradata(st, pkt);
3819             if (ret < 0)
3820                 goto find_stream_info_err;
3821         }
3822
3823         /* If still no information, we try to open the codec and to
3824          * decompress the frame. We try to avoid that in most cases as
3825          * it takes longer and uses more memory. For MPEG-4, we need to
3826          * decompress for QuickTime.
3827          *
3828          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3829          * least one frame of codec data, this makes sure the codec initializes
3830          * the channel configuration and does not only trust the values from
3831          * the container. */
3832         try_decode_frame(ic, st, pkt,
3833                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3834
3835         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3836             av_packet_unref(pkt);
3837
3838         st->codec_info_nb_frames++;
3839         count++;
3840     }
3841
3842     if (eof_reached) {
3843         int stream_index;
3844         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3845             st = ic->streams[stream_index];
3846             avctx = st->internal->avctx;
3847             if (!has_codec_parameters(st, NULL)) {
3848                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3849                 if (codec && !avctx->codec) {
3850                     AVDictionary *opts = NULL;
3851                     if (ic->codec_whitelist)
3852                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3853                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3854                         av_log(ic, AV_LOG_WARNING,
3855                                "Failed to open codec in %s\n",__FUNCTION__);
3856                     av_dict_free(&opts);
3857                 }
3858             }
3859
3860             // EOF already reached while reading the stream above.
3861             // So continue with reoordering DTS with whatever delay we have.
3862             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3863                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3864             }
3865         }
3866     }
3867
3868     if (flush_codecs) {
3869         AVPacket empty_pkt = { 0 };
3870         int err = 0;
3871         av_init_packet(&empty_pkt);
3872
3873         for (i = 0; i < ic->nb_streams; i++) {
3874
3875             st = ic->streams[i];
3876
3877             /* flush the decoders */
3878             if (st->info->found_decoder == 1) {
3879                 do {
3880                     err = try_decode_frame(ic, st, &empty_pkt,
3881                                             (options && i < orig_nb_streams)
3882                                             ? &options[i] : NULL);
3883                 } while (err > 0 && !has_codec_parameters(st, NULL));
3884
3885                 if (err < 0) {
3886                     av_log(ic, AV_LOG_INFO,
3887                         "decoding for stream %d failed\n", st->index);
3888                 }
3889             }
3890         }
3891     }
3892
3893     ff_rfps_calculate(ic);
3894
3895     for (i = 0; i < ic->nb_streams; i++) {
3896         st = ic->streams[i];
3897         avctx = st->internal->avctx;
3898         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3899             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3900                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3901                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3902                     avctx->codec_tag= tag;
3903             }
3904
3905             /* estimate average framerate if not set by demuxer */
3906             if (st->info->codec_info_duration_fields &&
3907                 !st->avg_frame_rate.num &&
3908                 st->info->codec_info_duration) {
3909                 int best_fps      = 0;
3910                 double best_error = 0.01;
3911                 AVRational codec_frame_rate = avctx->framerate;
3912
3913                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3914                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3915                     st->info->codec_info_duration        < 0)
3916                     continue;
3917                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3918                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3919                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3920
3921                 /* Round guessed framerate to a "standard" framerate if it's
3922                  * within 1% of the original estimate. */
3923                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3924                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3925                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3926                                               av_q2d(std_fps) - 1);
3927
3928                     if (error < best_error) {
3929                         best_error = error;
3930                         best_fps   = std_fps.num;
3931                     }
3932
3933                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3934                         error       = fabs(av_q2d(codec_frame_rate) /
3935                                            av_q2d(std_fps) - 1);
3936                         if (error < best_error) {
3937                             best_error = error;
3938                             best_fps   = std_fps.num;
3939                         }
3940                     }
3941                 }
3942                 if (best_fps)
3943                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3944                               best_fps, 12 * 1001, INT_MAX);
3945             }
3946
3947             if (!st->r_frame_rate.num) {
3948                 if (    avctx->time_base.den * (int64_t) st->time_base.num
3949                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3950                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3951                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3952                 } else {
3953                     st->r_frame_rate.num = st->time_base.den;
3954                     st->r_frame_rate.den = st->time_base.num;
3955                 }
3956             }
3957             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3958                 AVRational hw_ratio = { avctx->height, avctx->width };
3959                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3960                                                    hw_ratio);
3961             }
3962         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3963             if (!avctx->bits_per_coded_sample)
3964                 avctx->bits_per_coded_sample =
3965                     av_get_bits_per_sample(avctx->codec_id);
3966             // set stream disposition based on audio service type
3967             switch (avctx->audio_service_type) {
3968             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3969                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3970                 break;
3971             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3972                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3973                 break;
3974             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3975                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3976                 break;
3977             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3978                 st->disposition = AV_DISPOSITION_COMMENT;
3979                 break;
3980             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3981                 st->disposition = AV_DISPOSITION_KARAOKE;
3982                 break;
3983             }
3984         }
3985     }
3986
3987     if (probesize)
3988         estimate_timings(ic, old_offset);
3989
3990     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3991
3992     if (ret >= 0 && ic->nb_streams)
3993         /* We could not have all the codec parameters before EOF. */
3994         ret = -1;
3995     for (i = 0; i < ic->nb_streams; i++) {
3996         const char *errmsg;
3997         st = ic->streams[i];
3998
3999         /* if no packet was ever seen, update context now for has_codec_parameters */
4000         if (!st->internal->avctx_inited) {
4001             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4002                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4003                 st->codecpar->format = st->internal->avctx->sample_fmt;
4004             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4005             if (ret < 0)
4006                 goto find_stream_info_err;
4007         }
4008         if (!has_codec_parameters(st, &errmsg)) {
4009             char buf[256];
4010             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4011             av_log(ic, AV_LOG_WARNING,
4012                    "Could not find codec parameters for stream %d (%s): %s\n"
4013                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4014                    i, buf, errmsg);
4015         } else {
4016             ret = 0;
4017         }
4018     }
4019
4020     compute_chapters_end(ic);
4021
4022     /* update the stream parameters from the internal codec contexts */
4023     for (i = 0; i < ic->nb_streams; i++) {
4024         st = ic->streams[i];
4025
4026         if (st->internal->avctx_inited) {
4027             int orig_w = st->codecpar->width;
4028             int orig_h = st->codecpar->height;
4029             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4030             if (ret < 0)
4031                 goto find_stream_info_err;
4032 #if FF_API_LOWRES
4033             // The decoder might reduce the video size by the lowres factor.
4034             if (st->internal->avctx->lowres && orig_w) {
4035                 st->codecpar->width = orig_w;
4036                 st->codecpar->height = orig_h;
4037             }
4038 #endif
4039         }
4040
4041 #if FF_API_LAVF_AVCTX
4042 FF_DISABLE_DEPRECATION_WARNINGS
4043         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4044         if (ret < 0)
4045             goto find_stream_info_err;
4046
4047 #if FF_API_LOWRES
4048         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4049         // by the lowres factor.
4050         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4051             st->codec->lowres = st->internal->avctx->lowres;
4052             st->codec->width = st->internal->avctx->width;
4053             st->codec->height = st->internal->avctx->height;
4054         }
4055 #endif
4056
4057         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4058             st->codec->time_base = st->internal->avctx->time_base;
4059             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4060         }
4061         st->codec->framerate = st->avg_frame_rate;
4062
4063         if (st->internal->avctx->subtitle_header) {
4064             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4065             if (!st->codec->subtitle_header)
4066                 goto find_stream_info_err;
4067             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4068             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4069                    st->codec->subtitle_header_size);
4070         }
4071
4072         // Fields unavailable in AVCodecParameters
4073         st->codec->coded_width = st->internal->avctx->coded_width;
4074         st->codec->coded_height = st->internal->avctx->coded_height;
4075         st->codec->properties = st->internal->avctx->properties;
4076 FF_ENABLE_DEPRECATION_WARNINGS
4077 #endif
4078
4079         st->internal->avctx_inited = 0;
4080     }
4081
4082 find_stream_info_err:
4083     for (i = 0; i < ic->nb_streams; i++) {
4084         st = ic->streams[i];
4085         if (st->info)
4086             av_freep(&st->info->duration_error);
4087         avcodec_close(ic->streams[i]->internal->avctx);
4088         av_freep(&ic->streams[i]->info);
4089         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4090         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4091     }
4092     if (ic->pb)
4093         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4094                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4095     return ret;
4096 }
4097
4098 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4099 {
4100     int i, j;
4101
4102     for (i = 0; i < ic->nb_programs; i++) {
4103         if (ic->programs[i] == last) {
4104             last = NULL;
4105         } else {
4106             if (!last)
4107                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4108                     if (ic->programs[i]->stream_index[j] == s)
4109                         return ic->programs[i];
4110         }
4111     }
4112     return NULL;
4113 }
4114
4115 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4116                         int wanted_stream_nb, int related_stream,
4117                         AVCodec **decoder_ret, int flags)
4118 {
4119     int i, nb_streams = ic->nb_streams;
4120     int ret = AVERROR_STREAM_NOT_FOUND;
4121     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4122     int count, multiframe, disposition;
4123     int64_t best_bitrate = -1;
4124     int64_t bitrate;
4125     unsigned *program = NULL;
4126     const AVCodec *decoder = NULL, *best_decoder = NULL;
4127
4128     if (related_stream >= 0 && wanted_stream_nb < 0) {
4129         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4130         if (p) {
4131             program    = p->stream_index;
4132             nb_streams = p->nb_stream_indexes;
4133         }
4134     }
4135     for (i = 0; i < nb_streams; i++) {
4136         int real_stream_index = program ? program[i] : i;
4137         AVStream *st          = ic->streams[real_stream_index];
4138         AVCodecParameters *par = st->codecpar;
4139         if (par->codec_type != type)
4140             continue;
4141         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4142             continue;
4143         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4144             continue;
4145         if (decoder_ret) {
4146             decoder = find_decoder(ic, st, par->codec_id);
4147             if (!decoder) {
4148                 if (ret < 0)
4149                     ret = AVERROR_DECODER_NOT_FOUND;
4150                 continue;
4151             }
4152         }
4153         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4154         count = st->codec_info_nb_frames;
4155         bitrate = par->bit_rate;
4156         multiframe = FFMIN(5, count);
4157         if ((best_disposition >  disposition) ||
4158             (best_disposition == disposition && best_multiframe >  multiframe) ||
4159             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4160             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4161             continue;
4162         best_disposition = disposition;
4163         best_count   = count;
4164         best_bitrate = bitrate;
4165         best_multiframe = multiframe;
4166         ret          = real_stream_index;
4167         best_decoder = decoder;
4168         if (program && i == nb_streams - 1 && ret < 0) {
4169             program    = NULL;
4170             nb_streams = ic->nb_streams;
4171             /* no related stream found, try again with everything */
4172             i = 0;
4173         }
4174     }
4175     if (decoder_ret)
4176         *decoder_ret = (AVCodec*)best_decoder;
4177     return ret;
4178 }
4179
4180 /*******************************************************/
4181
4182 int av_read_play(AVFormatContext *s)
4183 {
4184     if (s->iformat->read_play)
4185         return s->iformat->read_play(s);
4186     if (s->pb)
4187         return avio_pause(s->pb, 0);
4188     return AVERROR(ENOSYS);
4189 }
4190
4191 int av_read_pause(AVFormatContext *s)
4192 {
4193     if (s->iformat->read_pause)
4194         return s->iformat->read_pause(s);
4195     if (s->pb)
4196         return avio_pause(s->pb, 1);
4197     return AVERROR(ENOSYS);
4198 }
4199
4200 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4201 {
4202     int ret, i;
4203
4204     dst->id                  = src->id;
4205     dst->time_base           = src->time_base;
4206     dst->nb_frames           = src->nb_frames;
4207     dst->disposition         = src->disposition;
4208     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4209     dst->avg_frame_rate      = src->avg_frame_rate;
4210     dst->r_frame_rate        = src->r_frame_rate;
4211
4212     av_dict_free(&dst->metadata);
4213     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4214     if (ret < 0)
4215         return ret;
4216
4217     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4218     if (ret < 0)
4219         return ret;
4220
4221     /* Free existing side data*/
4222     for (i = 0; i < dst->nb_side_data; i++)
4223         av_free(dst->side_data[i].data);
4224     av_freep(&dst->side_data);
4225     dst->nb_side_data = 0;
4226
4227     /* Copy side data if present */
4228     if (src->nb_side_data) {
4229         dst->side_data = av_mallocz_array(src->nb_side_data,
4230                                           sizeof(AVPacketSideData));
4231         if (!dst->side_data)
4232             return AVERROR(ENOMEM);
4233         dst->nb_side_data = src->nb_side_data;
4234
4235         for (i = 0; i < src->nb_side_data; i++) {
4236             uint8_t *data = av_memdup(src->side_data[i].data,
4237                                       src->side_data[i].size);
4238             if (!data)
4239                 return AVERROR(ENOMEM);
4240             dst->side_data[i].type = src->side_data[i].type;
4241             dst->side_data[i].size = src->side_data[i].size;
4242             dst->side_data[i].data = data;
4243         }
4244     }
4245
4246     av_freep(&dst->recommended_encoder_configuration);
4247     if (src->recommended_encoder_configuration) {
4248         const char *conf_str = src->recommended_encoder_configuration;
4249         dst->recommended_encoder_configuration = av_strdup(conf_str);
4250         if (!dst->recommended_encoder_configuration)
4251             return AVERROR(ENOMEM);
4252     }
4253
4254     return 0;
4255 }
4256
4257 static void free_stream(AVStream **pst)
4258 {
4259     AVStream *st = *pst;
4260     int i;
4261
4262     if (!st)
4263         return;
4264
4265     for (i = 0; i < st->nb_side_data; i++)
4266         av_freep(&st->side_data[i].data);
4267     av_freep(&st->side_data);
4268
4269     if (st->parser)
4270         av_parser_close(st->parser);
4271
4272     if (st->attached_pic.data)
4273         av_packet_unref(&st->attached_pic);
4274
4275     if (st->internal) {
4276         avcodec_free_context(&st->internal->avctx);
4277         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4278             av_bsf_free(&st->internal->bsfcs[i]);
4279             av_freep(&st->internal->bsfcs);
4280         }
4281         av_freep(&st->internal->priv_pts);
4282         av_bsf_free(&st->internal->extract_extradata.bsf);
4283         av_packet_free(&st->internal->extract_extradata.pkt);
4284     }
4285     av_freep(&st->internal);
4286
4287     av_dict_free(&st->metadata);
4288     avcodec_parameters_free(&st->codecpar);
4289     av_freep(&st->probe_data.buf);
4290     av_freep(&st->index_entries);
4291 #if FF_API_LAVF_AVCTX
4292 FF_DISABLE_DEPRECATION_WARNINGS
4293     avcodec_free_context(&st->codec);
4294 FF_ENABLE_DEPRECATION_WARNINGS
4295 #endif
4296     av_freep(&st->priv_data);
4297     if (st->info)
4298         av_freep(&st->info->duration_error);
4299     av_freep(&st->info);
4300     av_freep(&st->recommended_encoder_configuration);
4301
4302     av_freep(pst);
4303 }
4304
4305 void ff_free_stream(AVFormatContext *s, AVStream *st)
4306 {
4307     av_assert0(s->nb_streams>0);
4308     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4309
4310     free_stream(&s->streams[ --s->nb_streams ]);
4311 }
4312
4313 void avformat_free_context(AVFormatContext *s)
4314 {
4315     int i;
4316
4317     if (!s)
4318         return;
4319
4320     av_opt_free(s);
4321     if (s->iformat && s->iformat->priv_class && s->priv_data)
4322         av_opt_free(s->priv_data);
4323     if (s->oformat && s->oformat->priv_class && s->priv_data)
4324         av_opt_free(s->priv_data);
4325
4326     for (i = s->nb_streams - 1; i >= 0; i--)
4327         ff_free_stream(s, s->streams[i]);
4328
4329
4330     for (i = s->nb_programs - 1; i >= 0; i--) {
4331         av_dict_free(&s->programs[i]->metadata);
4332         av_freep(&s->programs[i]->stream_index);
4333         av_freep(&s->programs[i]);
4334     }
4335     av_freep(&s->programs);
4336     av_freep(&s->priv_data);
4337     while (s->nb_chapters--) {
4338         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4339         av_freep(&s->chapters[s->nb_chapters]);
4340     }
4341     av_freep(&s->chapters);
4342     av_dict_free(&s->metadata);
4343     av_dict_free(&s->internal->id3v2_meta);
4344     av_freep(&s->streams);
4345     flush_packet_queue(s);
4346     av_freep(&s->internal);
4347     av_free(s);
4348 }
4349
4350 void avformat_close_input(AVFormatContext **ps)
4351 {
4352     AVFormatContext *s;
4353     AVIOContext *pb;
4354
4355     if (!ps || !*ps)
4356         return;
4357
4358     s  = *ps;
4359     pb = s->pb;
4360
4361     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4362         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4363         pb = NULL;
4364
4365     flush_packet_queue(s);
4366
4367     if (s->iformat)
4368         if (s->iformat->read_close)
4369             s->iformat->read_close(s);
4370
4371     avformat_free_context(s);
4372
4373     *ps = NULL;
4374
4375     avio_close(pb);
4376 }
4377
4378 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4379 {
4380     AVStream *st;
4381     int i;
4382     AVStream **streams;
4383
4384     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4385         if (s->max_streams < INT_MAX/sizeof(*streams))
4386             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);
4387         return NULL;
4388     }
4389     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4390     if (!streams)
4391         return NULL;
4392     s->streams = streams;
4393
4394     st = av_mallocz(sizeof(AVStream));
4395     if (!st)
4396         return NULL;
4397     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4398         av_free(st);
4399         return NULL;
4400     }
4401     st->info->last_dts = AV_NOPTS_VALUE;
4402
4403 #if FF_API_LAVF_AVCTX
4404 FF_DISABLE_DEPRECATION_WARNINGS
4405     st->codec = avcodec_alloc_context3(c);
4406     if (!st->codec) {
4407         av_free(st->info);
4408         av_free(st);
4409         return NULL;
4410     }
4411 FF_ENABLE_DEPRECATION_WARNINGS
4412 #endif
4413
4414     st->internal = av_mallocz(sizeof(*st->internal));
4415     if (!st->internal)
4416         goto fail;
4417
4418     st->codecpar = avcodec_parameters_alloc();
4419     if (!st->codecpar)
4420         goto fail;
4421
4422     st->internal->avctx = avcodec_alloc_context3(NULL);
4423     if (!st->internal->avctx)
4424         goto fail;
4425
4426     if (s->iformat) {
4427 #if FF_API_LAVF_AVCTX
4428 FF_DISABLE_DEPRECATION_WARNINGS
4429         /* no default bitrate if decoding */
4430         st->codec->bit_rate = 0;
4431 FF_ENABLE_DEPRECATION_WARNINGS
4432 #endif
4433
4434         /* default pts setting is MPEG-like */
4435         avpriv_set_pts_info(st, 33, 1, 90000);
4436         /* we set the current DTS to 0 so that formats without any timestamps
4437          * but durations get some timestamps, formats with some unknown
4438          * timestamps have their first few packets buffered and the
4439          * timestamps corrected before they are returned to the user */
4440         st->cur_dts = RELATIVE_TS_BASE;
4441     } else {
4442         st->cur_dts = AV_NOPTS_VALUE;
4443     }
4444
4445     st->index      = s->nb_streams;
4446     st->start_time = AV_NOPTS_VALUE;
4447     st->duration   = AV_NOPTS_VALUE;
4448     st->first_dts     = AV_NOPTS_VALUE;
4449     st->probe_packets = MAX_PROBE_PACKETS;
4450     st->pts_wrap_reference = AV_NOPTS_VALUE;
4451     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4452
4453     st->last_IP_pts = AV_NOPTS_VALUE;
4454     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4455     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4456         st->pts_buffer[i] = AV_NOPTS_VALUE;
4457
4458     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4459
4460 #if FF_API_R_FRAME_RATE
4461     st->info->last_dts      = AV_NOPTS_VALUE;
4462 #endif
4463     st->info->fps_first_dts = AV_NOPTS_VALUE;
4464     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4465
4466     st->inject_global_side_data = s->internal->inject_global_side_data;
4467
4468     st->internal->need_context_update = 1;
4469
4470     s->streams[s->nb_streams++] = st;
4471     return st;
4472 fail:
4473     free_stream(&st);
4474     return NULL;
4475 }
4476
4477 AVProgram *av_new_program(AVFormatContext *ac, int id)
4478 {
4479     AVProgram *program = NULL;
4480     int i;
4481
4482     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4483
4484     for (i = 0; i < ac->nb_programs; i++)
4485         if (ac->programs[i]->id == id)
4486             program = ac->programs[i];
4487
4488     if (!program) {
4489         program = av_mallocz(sizeof(AVProgram));
4490         if (!program)
4491             return NULL;
4492         dynarray_add(&ac->programs, &ac->nb_programs, program);
4493         program->discard = AVDISCARD_NONE;
4494     }
4495     program->id = id;
4496     program->pts_wrap_reference = AV_NOPTS_VALUE;
4497     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4498
4499     program->start_time =
4500     program->end_time   = AV_NOPTS_VALUE;
4501
4502     return program;
4503 }
4504
4505 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4506                               int64_t start, int64_t end, const char *title)
4507 {
4508     AVChapter *chapter = NULL;
4509     int i;
4510
4511     if (end != AV_NOPTS_VALUE && start > end) {
4512         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4513         return NULL;
4514     }
4515
4516     for (i = 0; i < s->nb_chapters; i++)
4517         if (s->chapters[i]->id == id)
4518             chapter = s->chapters[i];
4519
4520     if (!chapter) {
4521         chapter = av_mallocz(sizeof(AVChapter));
4522         if (!chapter)
4523             return NULL;
4524         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4525     }
4526     av_dict_set(&chapter->metadata, "title", title, 0);
4527     chapter->id        = id;
4528     chapter->time_base = time_base;
4529     chapter->start     = start;
4530     chapter->end       = end;
4531
4532     return chapter;
4533 }
4534
4535 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4536 {
4537     int i, j;
4538     AVProgram *program = NULL;
4539     void *tmp;
4540
4541     if (idx >= ac->nb_streams) {
4542         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4543         return;
4544     }
4545
4546     for (i = 0; i < ac->nb_programs; i++) {
4547         if (ac->programs[i]->id != progid)
4548             continue;
4549         program = ac->programs[i];
4550         for (j = 0; j < program->nb_stream_indexes; j++)
4551             if (program->stream_index[j] == idx)
4552                 return;
4553
4554         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4555         if (!tmp)
4556             return;
4557         program->stream_index = tmp;
4558         program->stream_index[program->nb_stream_indexes++] = idx;
4559         return;
4560     }
4561 }
4562
4563 uint64_t ff_ntp_time(void)
4564 {
4565     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4566 }
4567
4568 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4569 {
4570     const char *p;
4571     char *q, buf1[20], c;
4572     int nd, len, percentd_found;
4573
4574     q = buf;
4575     p = path;
4576     percentd_found = 0;
4577     for (;;) {
4578         c = *p++;
4579         if (c == '\0')
4580             break;
4581         if (c == '%') {
4582             do {
4583                 nd = 0;
4584                 while (av_isdigit(*p))
4585                     nd = nd * 10 + *p++ - '0';
4586                 c = *p++;
4587             } while (av_isdigit(c));
4588
4589             switch (c) {
4590             case '%':
4591                 goto addchar;
4592             case 'd':
4593                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4594                     goto fail;
4595                 percentd_found = 1;
4596                 if (number < 0)
4597                     nd += 1;
4598                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4599                 len = strlen(buf1);
4600                 if ((q - buf + len) > buf_size - 1)
4601                     goto fail;
4602                 memcpy(q, buf1, len);
4603                 q += len;
4604                 break;
4605             default:
4606                 goto fail;
4607             }
4608         } else {
4609 addchar:
4610             if ((q - buf) < buf_size - 1)
4611                 *q++ = c;
4612         }
4613     }
4614     if (!percentd_found)
4615         goto fail;
4616     *q = '\0';
4617     return 0;
4618 fail:
4619     *q = '\0';
4620     return -1;
4621 }
4622
4623 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4624 {
4625     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4626 }
4627
4628 void av_url_split(char *proto, int proto_size,
4629                   char *authorization, int authorization_size,
4630                   char *hostname, int hostname_size,
4631                   int *port_ptr, char *path, int path_size, const char *url)
4632 {
4633     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4634
4635     if (port_ptr)
4636         *port_ptr = -1;
4637     if (proto_size > 0)
4638         proto[0] = 0;
4639     if (authorization_size > 0)
4640         authorization[0] = 0;
4641     if (hostname_size > 0)
4642         hostname[0] = 0;
4643     if (path_size > 0)
4644         path[0] = 0;
4645
4646     /* parse protocol */
4647     if ((p = strchr(url, ':'))) {
4648         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4649         p++; /* skip ':' */
4650         if (*p == '/')
4651             p++;
4652         if (*p == '/')
4653             p++;
4654     } else {
4655         /* no protocol means plain filename */
4656         av_strlcpy(path, url, path_size);
4657         return;
4658     }
4659
4660     /* separate path from hostname */
4661     ls = strchr(p, '/');
4662     ls2 = strchr(p, '?');
4663     if (!ls)
4664         ls = ls2;
4665     else if (ls && ls2)
4666         ls = FFMIN(ls, ls2);
4667     if (ls)
4668         av_strlcpy(path, ls, path_size);
4669     else
4670         ls = &p[strlen(p)];  // XXX
4671
4672     /* the rest is hostname, use that to parse auth/port */
4673     if (ls != p) {
4674         /* authorization (user[:pass]@hostname) */
4675         at2 = p;
4676         while ((at = strchr(p, '@')) && at < ls) {
4677             av_strlcpy(authorization, at2,
4678                        FFMIN(authorization_size, at + 1 - at2));
4679             p = at + 1; /* skip '@' */
4680         }
4681
4682         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4683             /* [host]:port */
4684             av_strlcpy(hostname, p + 1,
4685                        FFMIN(hostname_size, brk - p));
4686             if (brk[1] == ':' && port_ptr)
4687                 *port_ptr = atoi(brk + 2);
4688         } else if ((col = strchr(p, ':')) && col < ls) {
4689             av_strlcpy(hostname, p,
4690                        FFMIN(col + 1 - p, hostname_size));
4691             if (port_ptr)
4692                 *port_ptr = atoi(col + 1);
4693         } else
4694             av_strlcpy(hostname, p,
4695                        FFMIN(ls + 1 - p, hostname_size));
4696     }
4697 }
4698
4699 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4700 {
4701     int i;
4702     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4703                                            '4', '5', '6', '7',
4704                                            '8', '9', 'A', 'B',
4705                                            'C', 'D', 'E', 'F' };
4706     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4707                                            '4', '5', '6', '7',
4708                                            '8', '9', 'a', 'b',
4709                                            'c', 'd', 'e', 'f' };
4710     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4711
4712     for (i = 0; i < s; i++) {
4713         buff[i * 2]     = hex_table[src[i] >> 4];
4714         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4715     }
4716
4717     return buff;
4718 }
4719
4720 int ff_hex_to_data(uint8_t *data, const char *p)
4721 {
4722     int c, len, v;
4723
4724     len = 0;
4725     v   = 1;
4726     for (;;) {
4727         p += strspn(p, SPACE_CHARS);
4728         if (*p == '\0')
4729             break;
4730         c = av_toupper((unsigned char) *p++);
4731         if (c >= '0' && c <= '9')
4732             c = c - '0';
4733         else if (c >= 'A' && c <= 'F')
4734             c = c - 'A' + 10;
4735         else
4736             break;
4737         v = (v << 4) | c;
4738         if (v & 0x100) {
4739             if (data)
4740                 data[len] = v;
4741             len++;
4742             v = 1;
4743         }
4744     }
4745     return len;
4746 }
4747
4748 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4749                          unsigned int pts_num, unsigned int pts_den)
4750 {
4751     AVRational new_tb;
4752     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4753         if (new_tb.num != pts_num)
4754             av_log(NULL, AV_LOG_DEBUG,
4755                    "st:%d removing common factor %d from timebase\n",
4756                    s->index, pts_num / new_tb.num);
4757     } else
4758         av_log(NULL, AV_LOG_WARNING,
4759                "st:%d has too large timebase, reducing\n", s->index);
4760
4761     if (new_tb.num <= 0 || new_tb.den <= 0) {
4762         av_log(NULL, AV_LOG_ERROR,
4763                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4764                new_tb.num, new_tb.den,
4765                s->index);
4766         return;
4767     }
4768     s->time_base     = new_tb;
4769 #if FF_API_LAVF_AVCTX
4770 FF_DISABLE_DEPRECATION_WARNINGS
4771     s->codec->pkt_timebase = new_tb;
4772 FF_ENABLE_DEPRECATION_WARNINGS
4773 #endif
4774     s->internal->avctx->pkt_timebase = new_tb;
4775     s->pts_wrap_bits = pts_wrap_bits;
4776 }
4777
4778 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4779                         void *context)
4780 {
4781     const char *ptr = str;
4782
4783     /* Parse key=value pairs. */
4784     for (;;) {
4785         const char *key;
4786         char *dest = NULL, *dest_end;
4787         int key_len, dest_len = 0;
4788
4789         /* Skip whitespace and potential commas. */
4790         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4791             ptr++;
4792         if (!*ptr)
4793             break;
4794
4795         key = ptr;
4796
4797         if (!(ptr = strchr(key, '=')))
4798             break;
4799         ptr++;
4800         key_len = ptr - key;
4801
4802         callback_get_buf(context, key, key_len, &dest, &dest_len);
4803         dest_end = dest + dest_len - 1;
4804
4805         if (*ptr == '\"') {
4806             ptr++;
4807             while (*ptr && *ptr != '\"') {
4808                 if (*ptr == '\\') {
4809                     if (!ptr[1])
4810                         break;
4811                     if (dest && dest < dest_end)
4812                         *dest++ = ptr[1];
4813                     ptr += 2;
4814                 } else {
4815                     if (dest && dest < dest_end)
4816                         *dest++ = *ptr;
4817                     ptr++;
4818                 }
4819             }
4820             if (*ptr == '\"')
4821                 ptr++;
4822         } else {
4823             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4824                 if (dest && dest < dest_end)
4825                     *dest++ = *ptr;
4826         }
4827         if (dest)
4828             *dest = 0;
4829     }
4830 }
4831
4832 int ff_find_stream_index(AVFormatContext *s, int id)
4833 {
4834     int i;
4835     for (i = 0; i < s->nb_streams; i++)
4836         if (s->streams[i]->id == id)
4837             return i;
4838     return -1;
4839 }
4840
4841 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4842                          int std_compliance)
4843 {
4844     if (ofmt) {
4845         unsigned int codec_tag;
4846         if (ofmt->query_codec)
4847             return ofmt->query_codec(codec_id, std_compliance);
4848         else if (ofmt->codec_tag)
4849             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4850         else if (codec_id == ofmt->video_codec ||
4851                  codec_id == ofmt->audio_codec ||
4852                  codec_id == ofmt->subtitle_codec ||
4853                  codec_id == ofmt->data_codec)
4854             return 1;
4855     }
4856     return AVERROR_PATCHWELCOME;
4857 }
4858
4859 int avformat_network_init(void)
4860 {
4861 #if CONFIG_NETWORK
4862     int ret;
4863     ff_network_inited_globally = 1;
4864     if ((ret = ff_network_init()) < 0)
4865         return ret;
4866     if ((ret = ff_tls_init()) < 0)
4867         return ret;
4868 #endif
4869     return 0;
4870 }
4871
4872 int avformat_network_deinit(void)
4873 {
4874 #if CONFIG_NETWORK
4875     ff_network_close();
4876     ff_tls_deinit();
4877     ff_network_inited_globally = 0;
4878 #endif
4879     return 0;
4880 }
4881
4882 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4883                         uint64_t channel_layout, int32_t sample_rate,
4884                         int32_t width, int32_t height)
4885 {
4886     uint32_t flags = 0;
4887     int size = 4;
4888     uint8_t *data;
4889     if (!pkt)
4890         return AVERROR(EINVAL);
4891     if (channels) {
4892         size  += 4;
4893         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4894     }
4895     if (channel_layout) {
4896         size  += 8;
4897         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4898     }
4899     if (sample_rate) {
4900         size  += 4;
4901         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4902     }
4903     if (width || height) {
4904         size  += 8;
4905         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4906     }
4907     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4908     if (!data)
4909         return AVERROR(ENOMEM);
4910     bytestream_put_le32(&data, flags);
4911     if (channels)
4912         bytestream_put_le32(&data, channels);
4913     if (channel_layout)
4914         bytestream_put_le64(&data, channel_layout);
4915     if (sample_rate)
4916         bytestream_put_le32(&data, sample_rate);
4917     if (width || height) {
4918         bytestream_put_le32(&data, width);
4919         bytestream_put_le32(&data, height);
4920     }
4921     return 0;
4922 }
4923
4924 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4925 {
4926     AVRational undef = {0, 1};
4927     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4928     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4929     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4930
4931     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4932                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4933     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4934         stream_sample_aspect_ratio = undef;
4935
4936     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4937                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4938     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4939         frame_sample_aspect_ratio = undef;
4940
4941     if (stream_sample_aspect_ratio.num)
4942         return stream_sample_aspect_ratio;
4943     else
4944         return frame_sample_aspect_ratio;
4945 }
4946
4947 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4948 {
4949     AVRational fr = st->r_frame_rate;
4950     AVRational codec_fr = st->internal->avctx->framerate;
4951     AVRational   avg_fr = st->avg_frame_rate;
4952
4953     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4954         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4955         fr = avg_fr;
4956     }
4957
4958
4959     if (st->internal->avctx->ticks_per_frame > 1) {
4960         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4961             (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))
4962             fr = codec_fr;
4963     }
4964
4965     return fr;
4966 }
4967
4968 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4969                                     const char *spec)
4970 {
4971     if (*spec <= '9' && *spec >= '0') /* opt:index */
4972         return strtol(spec, NULL, 0) == st->index;
4973     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4974              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4975         enum AVMediaType type;
4976         int nopic = 0;
4977
4978         switch (*spec++) {
4979         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4980         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4981         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4982         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4983         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4984         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4985         default:  av_assert0(0);
4986         }
4987 #if FF_API_LAVF_AVCTX
4988 FF_DISABLE_DEPRECATION_WARNINGS
4989         if (type != st->codecpar->codec_type
4990            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4991             return 0;
4992 FF_ENABLE_DEPRECATION_WARNINGS
4993 #else
4994         if (type != st->codecpar->codec_type)
4995             return 0;
4996 #endif
4997         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4998             return 0;
4999         if (*spec++ == ':') { /* possibly followed by :index */
5000             int i, index = strtol(spec, NULL, 0);
5001             for (i = 0; i < s->nb_streams; i++) {
5002 #if FF_API_LAVF_AVCTX
5003 FF_DISABLE_DEPRECATION_WARNINGS
5004                 if ((s->streams[i]->codecpar->codec_type == type
5005                       || s->streams[i]->codec->codec_type == type
5006                     ) &&
5007                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5008                     index-- == 0)
5009                     return i == st->index;
5010 FF_ENABLE_DEPRECATION_WARNINGS
5011 #else
5012                 if ((s->streams[i]->codecpar->codec_type == type) &&
5013                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5014                     index-- == 0)
5015                     return i == st->index;
5016 #endif
5017             }
5018             return 0;
5019         }
5020         return 1;
5021     } else if (*spec == 'p' && *(spec + 1) == ':') {
5022         int prog_id, i, j;
5023         char *endptr;
5024         spec += 2;
5025         prog_id = strtol(spec, &endptr, 0);
5026         for (i = 0; i < s->nb_programs; i++) {
5027             if (s->programs[i]->id != prog_id)
5028                 continue;
5029
5030             if (*endptr++ == ':') {
5031                 int stream_idx = strtol(endptr, NULL, 0);
5032                 return stream_idx >= 0 &&
5033                     stream_idx < s->programs[i]->nb_stream_indexes &&
5034                     st->index == s->programs[i]->stream_index[stream_idx];
5035             }
5036
5037             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5038                 if (st->index == s->programs[i]->stream_index[j])
5039                     return 1;
5040         }
5041         return 0;
5042     } else if (*spec == '#' ||
5043                (*spec == 'i' && *(spec + 1) == ':')) {
5044         int stream_id;
5045         char *endptr;
5046         spec += 1 + (*spec == 'i');
5047         stream_id = strtol(spec, &endptr, 0);
5048         if (!*endptr)
5049             return stream_id == st->id;
5050     } else if (*spec == 'm' && *(spec + 1) == ':') {
5051         AVDictionaryEntry *tag;
5052         char *key, *val;
5053         int ret;
5054
5055         spec += 2;
5056         val = strchr(spec, ':');
5057
5058         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5059         if (!key)
5060             return AVERROR(ENOMEM);
5061
5062         tag = av_dict_get(st->metadata, key, NULL, 0);
5063         if (tag) {
5064             if (!val || !strcmp(tag->value, val + 1))
5065                 ret = 1;
5066             else
5067                 ret = 0;
5068         } else
5069             ret = 0;
5070
5071         av_freep(&key);
5072         return ret;
5073     } else if (*spec == 'u') {
5074         AVCodecParameters *par = st->codecpar;
5075 #if FF_API_LAVF_AVCTX
5076 FF_DISABLE_DEPRECATION_WARNINGS
5077         AVCodecContext *codec = st->codec;
5078 FF_ENABLE_DEPRECATION_WARNINGS
5079 #endif
5080         int val;
5081         switch (par->codec_type) {
5082         case AVMEDIA_TYPE_AUDIO:
5083             val = par->sample_rate && par->channels;
5084 #if FF_API_LAVF_AVCTX
5085             val = val || (codec->sample_rate && codec->channels);
5086 #endif
5087             if (par->format == AV_SAMPLE_FMT_NONE
5088 #if FF_API_LAVF_AVCTX
5089                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5090 #endif
5091                 )
5092                 return 0;
5093             break;
5094         case AVMEDIA_TYPE_VIDEO:
5095             val = par->width && par->height;
5096 #if FF_API_LAVF_AVCTX
5097             val = val || (codec->width && codec->height);
5098 #endif
5099             if (par->format == AV_PIX_FMT_NONE
5100 #if FF_API_LAVF_AVCTX
5101                 && codec->pix_fmt == AV_PIX_FMT_NONE
5102 #endif
5103                 )
5104                 return 0;
5105             break;
5106         case AVMEDIA_TYPE_UNKNOWN:
5107             val = 0;
5108             break;
5109         default:
5110             val = 1;
5111             break;
5112         }
5113 #if FF_API_LAVF_AVCTX
5114         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5115 #else
5116         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5117 #endif
5118     } else if (!*spec) /* empty specifier, matches everything */
5119         return 1;
5120
5121     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5122     return AVERROR(EINVAL);
5123 }
5124
5125 int ff_generate_avci_extradata(AVStream *st)
5126 {
5127     static const uint8_t avci100_1080p_extradata[] = {
5128         // SPS
5129         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5130         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5131         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5132         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5133         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5134         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5135         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5136         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5137         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5138         // PPS
5139         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5140         0xd0
5141     };
5142     static const uint8_t avci100_1080i_extradata[] = {
5143         // SPS
5144         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5145         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5146         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5147         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5148         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5149         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5150         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5151         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5152         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5153         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5154         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5155         // PPS
5156         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5157         0xd0
5158     };
5159     static const uint8_t avci50_1080p_extradata[] = {
5160         // SPS
5161         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5162         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5163         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5164         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5165         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5166         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5167         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5168         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5169         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5170         // PPS
5171         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5172         0x11
5173     };
5174     static const uint8_t avci50_1080i_extradata[] = {
5175         // SPS
5176         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5177         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5178         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5179         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5180         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5181         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5182         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5183         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5184         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5185         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5186         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5187         // PPS
5188         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5189         0x11
5190     };
5191     static const uint8_t avci100_720p_extradata[] = {
5192         // SPS
5193         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5194         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5195         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5196         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5197         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5198         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5199         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5200         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5201         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5202         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5203         // PPS
5204         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5205         0x11
5206     };
5207     static const uint8_t avci50_720p_extradata[] = {
5208         // SPS
5209         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5210         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5211         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5212         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5213         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5214         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5215         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5216         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5217         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5218         // PPS
5219         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5220         0x11
5221     };
5222
5223     const uint8_t *data = NULL;
5224     int size            = 0;
5225
5226     if (st->codecpar->width == 1920) {
5227         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5228             data = avci100_1080p_extradata;
5229             size = sizeof(avci100_1080p_extradata);
5230         } else {
5231             data = avci100_1080i_extradata;
5232             size = sizeof(avci100_1080i_extradata);
5233         }
5234     } else if (st->codecpar->width == 1440) {
5235         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5236             data = avci50_1080p_extradata;
5237             size = sizeof(avci50_1080p_extradata);
5238         } else {
5239             data = avci50_1080i_extradata;
5240             size = sizeof(avci50_1080i_extradata);
5241         }
5242     } else if (st->codecpar->width == 1280) {
5243         data = avci100_720p_extradata;
5244         size = sizeof(avci100_720p_extradata);
5245     } else if (st->codecpar->width == 960) {
5246         data = avci50_720p_extradata;
5247         size = sizeof(avci50_720p_extradata);
5248     }
5249
5250     if (!size)
5251         return 0;
5252
5253     av_freep(&st->codecpar->extradata);
5254     if (ff_alloc_extradata(st->codecpar, size))
5255         return AVERROR(ENOMEM);
5256     memcpy(st->codecpar->extradata, data, size);
5257
5258     return 0;
5259 }
5260
5261 uint8_t *av_stream_get_side_data(const AVStream *st,
5262                                  enum AVPacketSideDataType type, int *size)
5263 {
5264     int i;
5265
5266     for (i = 0; i < st->nb_side_data; i++) {
5267         if (st->side_data[i].type == type) {
5268             if (size)
5269                 *size = st->side_data[i].size;
5270             return st->side_data[i].data;
5271         }
5272     }
5273     return NULL;
5274 }
5275
5276 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5277                             uint8_t *data, size_t size)
5278 {
5279     AVPacketSideData *sd, *tmp;
5280     int i;
5281
5282     for (i = 0; i < st->nb_side_data; i++) {
5283         sd = &st->side_data[i];
5284
5285         if (sd->type == type) {
5286             av_freep(&sd->data);
5287             sd->data = data;
5288             sd->size = size;
5289             return 0;
5290         }
5291     }
5292
5293     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5294         return AVERROR(ERANGE);
5295
5296     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5297     if (!tmp) {
5298         return AVERROR(ENOMEM);
5299     }
5300
5301     st->side_data = tmp;
5302     st->nb_side_data++;
5303
5304     sd = &st->side_data[st->nb_side_data - 1];
5305     sd->type = type;
5306     sd->data = data;
5307     sd->size = size;
5308
5309     return 0;
5310 }
5311
5312 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5313                                  int size)
5314 {
5315     int ret;
5316     uint8_t *data = av_malloc(size);
5317
5318     if (!data)
5319         return NULL;
5320
5321     ret = av_stream_add_side_data(st, type, data, size);
5322     if (ret < 0) {
5323         av_freep(&data);
5324         return NULL;
5325     }
5326
5327     return data;
5328 }
5329
5330 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5331 {
5332     int ret;
5333     const AVBitStreamFilter *bsf;
5334     AVBSFContext *bsfc;
5335     AVCodecParameters *in_par;
5336
5337     if (!(bsf = av_bsf_get_by_name(name))) {
5338         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5339         return AVERROR_BSF_NOT_FOUND;
5340     }
5341
5342     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5343         return ret;
5344
5345     if (st->internal->nb_bsfcs) {
5346         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5347         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5348     } else {
5349         in_par = st->codecpar;
5350         bsfc->time_base_in = st->time_base;
5351     }
5352
5353     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5354         av_bsf_free(&bsfc);
5355         return ret;
5356     }
5357
5358     if (args && bsfc->filter->priv_class) {
5359         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5360         const char * shorthand[2] = {NULL};
5361
5362         if (opt)
5363             shorthand[0] = opt->name;
5364
5365         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5366             av_bsf_free(&bsfc);
5367             return ret;
5368         }
5369     }
5370
5371     if ((ret = av_bsf_init(bsfc)) < 0) {
5372         av_bsf_free(&bsfc);
5373         return ret;
5374     }
5375
5376     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5377         av_bsf_free(&bsfc);
5378         return ret;
5379     }
5380
5381     av_log(NULL, AV_LOG_VERBOSE,
5382            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5383            name, args ? args : "");
5384     return 1;
5385 }
5386
5387 #if FF_API_OLD_BSF
5388 FF_DISABLE_DEPRECATION_WARNINGS
5389 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5390                                AVBitStreamFilterContext *bsfc)
5391 {
5392     int ret = 0;
5393     while (bsfc) {
5394         AVPacket new_pkt = *pkt;
5395         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5396                                            &new_pkt.data, &new_pkt.size,
5397                                            pkt->data, pkt->size,
5398                                            pkt->flags & AV_PKT_FLAG_KEY);
5399         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5400             av_packet_unref(pkt);
5401             memset(pkt, 0, sizeof(*pkt));
5402             return 0;
5403         }
5404         if(a == 0 && new_pkt.data != pkt->data) {
5405             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
5406             if (t) {
5407                 memcpy(t, new_pkt.data, new_pkt.size);
5408                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5409                 new_pkt.data = t;
5410                 new_pkt.buf = NULL;
5411                 a = 1;
5412             } else {
5413                 a = AVERROR(ENOMEM);
5414             }
5415         }
5416         if (a > 0) {
5417             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5418                                            av_buffer_default_free, NULL, 0);
5419             if (new_pkt.buf) {
5420                 pkt->side_data = NULL;
5421                 pkt->side_data_elems = 0;
5422                 av_packet_unref(pkt);
5423             } else {
5424                 av_freep(&new_pkt.data);
5425                 a = AVERROR(ENOMEM);
5426             }
5427         }
5428         if (a < 0) {
5429             av_log(codec, AV_LOG_ERROR,
5430                    "Failed to open bitstream filter %s for stream %d with codec %s",
5431                    bsfc->filter->name, pkt->stream_index,
5432                    codec->codec ? codec->codec->name : "copy");
5433             ret = a;
5434             break;
5435         }
5436         *pkt = new_pkt;
5437
5438         bsfc = bsfc->next;
5439     }
5440     return ret;
5441 }
5442 FF_ENABLE_DEPRECATION_WARNINGS
5443 #endif
5444
5445 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5446 {
5447     if (!s->oformat)
5448         return AVERROR(EINVAL);
5449
5450     if (!(s->oformat->flags & AVFMT_NOFILE))
5451         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5452     return 0;
5453 }
5454
5455 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5456 {
5457     if (*pb)
5458         s->io_close(s, *pb);
5459     *pb = NULL;
5460 }
5461
5462 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5463 {
5464     AVDictionaryEntry *entry;
5465     int64_t parsed_timestamp;
5466     int ret;
5467     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5468         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5469             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5470             return 1;
5471         } else {
5472             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5473             return ret;
5474         }
5475     }
5476     return 0;
5477 }
5478
5479 int ff_standardize_creation_time(AVFormatContext *s)
5480 {
5481     int64_t timestamp;
5482     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5483     if (ret == 1)
5484         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5485     return ret;
5486 }
5487
5488 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5489 {
5490     uint8_t *side_data;
5491     int size;
5492
5493     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5494     if (side_data) {
5495         if (size != AVPALETTE_SIZE) {
5496             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5497             return AVERROR_INVALIDDATA;
5498         }
5499         memcpy(palette, side_data, AVPALETTE_SIZE);
5500         return 1;
5501     }
5502
5503     if (ret == CONTAINS_PAL) {
5504         int i;
5505         for (i = 0; i < AVPALETTE_COUNT; i++)
5506             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5507         return 1;
5508     }
5509
5510     return 0;
5511 }
5512
5513 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5514 {
5515     int ret;
5516     char *str;
5517
5518     ret = av_bprint_finalize(buf, &str);
5519     if (ret < 0)
5520         return ret;
5521     if (!av_bprint_is_complete(buf)) {
5522         av_free(str);
5523         return AVERROR(ENOMEM);
5524     }
5525
5526     par->extradata = str;
5527     /* Note: the string is NUL terminated (so extradata can be read as a
5528      * string), but the ending character is not accounted in the size (in
5529      * binary formats you are likely not supposed to mux that character). When
5530      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5531      * zeros. */
5532     par->extradata_size = buf->len;
5533     return 0;
5534 }
5535
5536 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5537                                                   AVStream *ost, const AVStream *ist,
5538                                                   enum AVTimebaseSource copy_tb)
5539 {
5540     //TODO: use [io]st->internal->avctx
5541     const AVCodecContext *dec_ctx = ist->codec;
5542     AVCodecContext       *enc_ctx = ost->codec;
5543
5544     enc_ctx->time_base = ist->time_base;
5545     /*
5546      * Avi is a special case here because it supports variable fps but
5547      * having the fps and timebase differe significantly adds quite some
5548      * overhead
5549      */
5550     if (!strcmp(ofmt->name, "avi")) {
5551 #if FF_API_R_FRAME_RATE
5552         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5553             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5554             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5555             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5556             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5557             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5558             enc_ctx->time_base.num = ist->r_frame_rate.den;
5559             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5560             enc_ctx->ticks_per_frame = 2;
5561         } else
5562 #endif
5563             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5564                    && av_q2d(ist->time_base) < 1.0/500
5565                    || copy_tb == AVFMT_TBCF_DECODER) {
5566             enc_ctx->time_base = dec_ctx->time_base;
5567             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5568             enc_ctx->time_base.den *= 2;
5569             enc_ctx->ticks_per_frame = 2;
5570         }
5571     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5572                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5573         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5574             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5575             && av_q2d(ist->time_base) < 1.0/500
5576             || copy_tb == AVFMT_TBCF_DECODER) {
5577             enc_ctx->time_base = dec_ctx->time_base;
5578             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5579         }
5580     }
5581
5582     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5583         && dec_ctx->time_base.num < dec_ctx->time_base.den
5584         && dec_ctx->time_base.num > 0
5585         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5586         enc_ctx->time_base = dec_ctx->time_base;
5587     }
5588
5589     if (ost->avg_frame_rate.num)
5590         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5591
5592     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5593               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5594
5595     return 0;
5596 }
5597
5598 AVRational av_stream_get_codec_timebase(const AVStream *st)
5599 {
5600     // See avformat_transfer_internal_stream_timing_info() TODO.
5601 #if FF_API_LAVF_AVCTX
5602 FF_DISABLE_DEPRECATION_WARNINGS
5603     return st->codec->time_base;
5604 FF_ENABLE_DEPRECATION_WARNINGS
5605 #else
5606     return st->internal->avctx->time_base;
5607 #endif
5608 }