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