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