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         /* Ensure that subtitle_header is properly set. */
3751         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3752             && codec && !avctx->codec) {
3753             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3754                 av_log(ic, AV_LOG_WARNING,
3755                        "Failed to open codec in %s\n",__FUNCTION__);
3756         }
3757
3758         // Try to just open decoders, in case this is enough to get parameters.
3759         if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0) {
3760             if (codec && !avctx->codec)
3761                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3762                     av_log(ic, AV_LOG_WARNING,
3763                            "Failed to open codec in %s\n",__FUNCTION__);
3764         }
3765         if (!options)
3766             av_dict_free(&thread_opt);
3767     }
3768
3769     for (i = 0; i < ic->nb_streams; i++) {
3770 #if FF_API_R_FRAME_RATE
3771         ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3772 #endif
3773         ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3774         ic->streams[i]->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
3775     }
3776
3777     read_size = 0;
3778     for (;;) {
3779         const AVPacket *pkt;
3780         int analyzed_all_streams;
3781         if (ff_check_interrupt(&ic->interrupt_callback)) {
3782             ret = AVERROR_EXIT;
3783             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3784             break;
3785         }
3786
3787         /* check if one codec still needs to be handled */
3788         for (i = 0; i < ic->nb_streams; i++) {
3789             int fps_analyze_framecount = 20;
3790             int count;
3791
3792             st = ic->streams[i];
3793             if (!has_codec_parameters(st, NULL))
3794                 break;
3795             /* If the timebase is coarse (like the usual millisecond precision
3796              * of mkv), we need to analyze more frames to reliably arrive at
3797              * the correct fps. */
3798             if (av_q2d(st->time_base) > 0.0005)
3799                 fps_analyze_framecount *= 2;
3800             if (!tb_unreliable(st->internal->avctx))
3801                 fps_analyze_framecount = 0;
3802             if (ic->fps_probe_size >= 0)
3803                 fps_analyze_framecount = ic->fps_probe_size;
3804             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3805                 fps_analyze_framecount = 0;
3806             /* variable fps and no guess at the real fps */
3807             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3808                        st->internal->info->codec_info_duration_fields/2 :
3809                        st->internal->info->duration_count;
3810             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3811                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3812                 if (count < fps_analyze_framecount)
3813                     break;
3814             }
3815             // Look at the first 3 frames if there is evidence of frame delay
3816             // but the decoder delay is not set.
3817             if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3818                 break;
3819             if (!st->internal->avctx->extradata &&
3820                 (!st->internal->extract_extradata.inited ||
3821                  st->internal->extract_extradata.bsf) &&
3822                 extract_extradata_check(st))
3823                 break;
3824             if (st->first_dts == AV_NOPTS_VALUE &&
3825                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3826                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3827                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3828                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3829                 break;
3830         }
3831         analyzed_all_streams = 0;
3832         if (!missing_streams || !*missing_streams)
3833             if (i == ic->nb_streams) {
3834                 analyzed_all_streams = 1;
3835                 /* NOTE: If the format has no header, then we need to read some
3836                  * packets to get most of the streams, so we cannot stop here. */
3837                 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3838                     /* If we found the info for all the codecs, we can stop. */
3839                     ret = count;
3840                     av_log(ic, AV_LOG_DEBUG, "All info found\n");
3841                     flush_codecs = 0;
3842                     break;
3843                 }
3844             }
3845         /* We did not get all the codec info, but we read too much data. */
3846         if (read_size >= probesize) {
3847             ret = count;
3848             av_log(ic, AV_LOG_DEBUG,
3849                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3850             for (i = 0; i < ic->nb_streams; i++)
3851                 if (!ic->streams[i]->r_frame_rate.num &&
3852                     ic->streams[i]->internal->info->duration_count <= 1 &&
3853                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3854                     strcmp(ic->iformat->name, "image2"))
3855                     av_log(ic, AV_LOG_WARNING,
3856                            "Stream #%d: not enough frames to estimate rate; "
3857                            "consider increasing probesize\n", i);
3858             break;
3859         }
3860
3861         /* NOTE: A new stream can be added there if no header in file
3862          * (AVFMTCTX_NOHEADER). */
3863         ret = read_frame_internal(ic, pkt1);
3864         if (ret == AVERROR(EAGAIN))
3865             continue;
3866
3867         if (ret < 0) {
3868             /* EOF or error*/
3869             eof_reached = 1;
3870             break;
3871         }
3872
3873         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3874             ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3875                                      &ic->internal->packet_buffer_end,
3876                                      pkt1, NULL, 0);
3877             if (ret < 0)
3878                 goto unref_then_goto_end;
3879
3880             pkt = &ic->internal->packet_buffer_end->pkt;
3881         } else {
3882             pkt = pkt1;
3883         }
3884
3885         st = ic->streams[pkt->stream_index];
3886         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3887             read_size += pkt->size;
3888
3889         avctx = st->internal->avctx;
3890         if (!st->internal->avctx_inited) {
3891             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3892             if (ret < 0)
3893                 goto unref_then_goto_end;
3894             st->internal->avctx_inited = 1;
3895         }
3896
3897         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3898             /* check for non-increasing dts */
3899             if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3900                 st->internal->info->fps_last_dts >= pkt->dts) {
3901                 av_log(ic, AV_LOG_DEBUG,
3902                        "Non-increasing DTS in stream %d: packet %d with DTS "
3903                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3904                        st->index, st->internal->info->fps_last_dts_idx,
3905                        st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3906                        pkt->dts);
3907                 st->internal->info->fps_first_dts =
3908                 st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
3909             }
3910             /* Check for a discontinuity in dts. If the difference in dts
3911              * is more than 1000 times the average packet duration in the
3912              * sequence, we treat it as a discontinuity. */
3913             if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3914                 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3915                 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3916                 (st->internal->info->fps_last_dts     - (uint64_t)st->internal->info->fps_first_dts) /
3917                 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3918                 av_log(ic, AV_LOG_WARNING,
3919                        "DTS discontinuity in stream %d: packet %d with DTS "
3920                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3921                        st->index, st->internal->info->fps_last_dts_idx,
3922                        st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3923                        pkt->dts);
3924                 st->internal->info->fps_first_dts =
3925                 st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
3926             }
3927
3928             /* update stored dts values */
3929             if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3930                 st->internal->info->fps_first_dts     = pkt->dts;
3931                 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3932             }
3933             st->internal->info->fps_last_dts     = pkt->dts;
3934             st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3935         }
3936         if (st->codec_info_nb_frames>1) {
3937             int64_t t = 0;
3938             int64_t limit;
3939
3940             if (st->time_base.den > 0)
3941                 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3942             if (st->avg_frame_rate.num > 0)
3943                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3944
3945             if (   t == 0
3946                 && st->codec_info_nb_frames>30
3947                 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3948                 && st->internal->info->fps_last_dts  != AV_NOPTS_VALUE) {
3949                 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3950                 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3951             }
3952
3953             if (analyzed_all_streams)                                limit = max_analyze_duration;
3954             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3955             else                                                     limit = max_stream_analyze_duration;
3956
3957             if (t >= limit) {
3958                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3959                        limit,
3960                        t, pkt->stream_index);
3961                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3962                     av_packet_unref(pkt1);
3963                 break;
3964             }
3965             if (pkt->duration) {
3966                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3967                     st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3968                 } else
3969                     st->internal->info->codec_info_duration += pkt->duration;
3970                 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3971             }
3972         }
3973         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3974 #if FF_API_R_FRAME_RATE
3975             ff_rfps_add_frame(ic, st, pkt->dts);
3976 #endif
3977             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3978                 st->internal->info->frame_delay_evidence = 1;
3979         }
3980         if (!st->internal->avctx->extradata) {
3981             ret = extract_extradata(ic, st, pkt);
3982             if (ret < 0)
3983                 goto unref_then_goto_end;
3984         }
3985
3986         /* If still no information, we try to open the codec and to
3987          * decompress the frame. We try to avoid that in most cases as
3988          * it takes longer and uses more memory. For MPEG-4, we need to
3989          * decompress for QuickTime.
3990          *
3991          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3992          * least one frame of codec data, this makes sure the codec initializes
3993          * the channel configuration and does not only trust the values from
3994          * the container. */
3995         try_decode_frame(ic, st, pkt,
3996                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3997
3998         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3999             av_packet_unref(pkt1);
4000
4001         st->codec_info_nb_frames++;
4002         count++;
4003     }
4004
4005     if (eof_reached) {
4006         int stream_index;
4007         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
4008             st = ic->streams[stream_index];
4009             avctx = st->internal->avctx;
4010             if (!has_codec_parameters(st, NULL)) {
4011                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
4012                 if (codec && !avctx->codec) {
4013                     AVDictionary *opts = NULL;
4014                     if (ic->codec_whitelist)
4015                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
4016                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
4017                         av_log(ic, AV_LOG_WARNING,
4018                                "Failed to open codec in %s\n",__FUNCTION__);
4019                     av_dict_free(&opts);
4020                 }
4021             }
4022
4023             // EOF already reached while reading the stream above.
4024             // So continue with reoordering DTS with whatever delay we have.
4025             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
4026                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
4027             }
4028         }
4029     }
4030
4031     if (flush_codecs) {
4032         AVPacket *empty_pkt = ic->internal->pkt;
4033         int err = 0;
4034         av_packet_unref(empty_pkt);
4035
4036         for (i = 0; i < ic->nb_streams; i++) {
4037
4038             st = ic->streams[i];
4039
4040             /* flush the decoders */
4041             if (st->internal->info->found_decoder == 1) {
4042                 do {
4043                     err = try_decode_frame(ic, st, empty_pkt,
4044                                             (options && i < orig_nb_streams)
4045                                             ? &options[i] : NULL);
4046                 } while (err > 0 && !has_codec_parameters(st, NULL));
4047
4048                 if (err < 0) {
4049                     av_log(ic, AV_LOG_INFO,
4050                         "decoding for stream %d failed\n", st->index);
4051                 }
4052             }
4053         }
4054     }
4055
4056     ff_rfps_calculate(ic);
4057
4058     for (i = 0; i < ic->nb_streams; i++) {
4059         st = ic->streams[i];
4060         avctx = st->internal->avctx;
4061         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4062             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4063                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4064                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4065                     avctx->codec_tag= tag;
4066             }
4067
4068             /* estimate average framerate if not set by demuxer */
4069             if (st->internal->info->codec_info_duration_fields &&
4070                 !st->avg_frame_rate.num &&
4071                 st->internal->info->codec_info_duration) {
4072                 int best_fps      = 0;
4073                 double best_error = 0.01;
4074                 AVRational codec_frame_rate = avctx->framerate;
4075
4076                 if (st->internal->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
4077                     st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4078                     st->internal->info->codec_info_duration        < 0)
4079                     continue;
4080                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4081                           st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4082                           st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4083
4084                 /* Round guessed framerate to a "standard" framerate if it's
4085                  * within 1% of the original estimate. */
4086                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4087                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4088                     double error       = fabs(av_q2d(st->avg_frame_rate) /
4089                                               av_q2d(std_fps) - 1);
4090
4091                     if (error < best_error) {
4092                         best_error = error;
4093                         best_fps   = std_fps.num;
4094                     }
4095
4096                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4097                         error       = fabs(av_q2d(codec_frame_rate) /
4098                                            av_q2d(std_fps) - 1);
4099                         if (error < best_error) {
4100                             best_error = error;
4101                             best_fps   = std_fps.num;
4102                         }
4103                     }
4104                 }
4105                 if (best_fps)
4106                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4107                               best_fps, 12 * 1001, INT_MAX);
4108             }
4109
4110             if (!st->r_frame_rate.num) {
4111                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4112                     <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4113                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4114                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4115                 } else {
4116                     st->r_frame_rate.num = st->time_base.den;
4117                     st->r_frame_rate.den = st->time_base.num;
4118                 }
4119             }
4120             if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4121                 AVRational hw_ratio = { avctx->height, avctx->width };
4122                 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4123                                                    hw_ratio);
4124             }
4125         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4126             if (!avctx->bits_per_coded_sample)
4127                 avctx->bits_per_coded_sample =
4128                     av_get_bits_per_sample(avctx->codec_id);
4129             // set stream disposition based on audio service type
4130             switch (avctx->audio_service_type) {
4131             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4132                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4133                 break;
4134             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4135                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4136                 break;
4137             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4138                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4139                 break;
4140             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4141                 st->disposition = AV_DISPOSITION_COMMENT;
4142                 break;
4143             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4144                 st->disposition = AV_DISPOSITION_KARAOKE;
4145                 break;
4146             }
4147         }
4148     }
4149
4150     if (probesize)
4151         estimate_timings(ic, old_offset);
4152
4153     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4154
4155     if (ret >= 0 && ic->nb_streams)
4156         /* We could not have all the codec parameters before EOF. */
4157         ret = -1;
4158     for (i = 0; i < ic->nb_streams; i++) {
4159         const char *errmsg;
4160         st = ic->streams[i];
4161
4162         /* if no packet was ever seen, update context now for has_codec_parameters */
4163         if (!st->internal->avctx_inited) {
4164             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4165                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4166                 st->codecpar->format = st->internal->avctx->sample_fmt;
4167             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4168             if (ret < 0)
4169                 goto find_stream_info_err;
4170         }
4171         if (!has_codec_parameters(st, &errmsg)) {
4172             char buf[256];
4173             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4174             av_log(ic, AV_LOG_WARNING,
4175                    "Could not find codec parameters for stream %d (%s): %s\n"
4176                    "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4177                    i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4178         } else {
4179             ret = 0;
4180         }
4181     }
4182
4183     ret = compute_chapters_end(ic);
4184     if (ret < 0)
4185         goto find_stream_info_err;
4186
4187     /* update the stream parameters from the internal codec contexts */
4188     for (i = 0; i < ic->nb_streams; i++) {
4189         st = ic->streams[i];
4190
4191         if (st->internal->avctx_inited) {
4192             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4193             if (ret < 0)
4194                 goto find_stream_info_err;
4195             ret = add_coded_side_data(st, st->internal->avctx);
4196             if (ret < 0)
4197                 goto find_stream_info_err;
4198         }
4199
4200 #if FF_API_LAVF_AVCTX
4201 FF_DISABLE_DEPRECATION_WARNINGS
4202         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4203         if (ret < 0)
4204             goto find_stream_info_err;
4205
4206         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4207         // by the lowres factor.
4208         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4209             st->codec->lowres = st->internal->avctx->lowres;
4210             st->codec->width = st->internal->avctx->width;
4211             st->codec->height = st->internal->avctx->height;
4212         }
4213
4214         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4215             st->codec->time_base = st->internal->avctx->time_base;
4216             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4217         }
4218         st->codec->framerate = st->avg_frame_rate;
4219
4220         if (st->internal->avctx->subtitle_header) {
4221             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4222             if (!st->codec->subtitle_header)
4223                 goto find_stream_info_err;
4224             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4225             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4226                    st->codec->subtitle_header_size);
4227         }
4228
4229         // Fields unavailable in AVCodecParameters
4230         st->codec->coded_width = st->internal->avctx->coded_width;
4231         st->codec->coded_height = st->internal->avctx->coded_height;
4232         st->codec->properties = st->internal->avctx->properties;
4233 FF_ENABLE_DEPRECATION_WARNINGS
4234 #endif
4235
4236         st->internal->avctx_inited = 0;
4237     }
4238
4239 find_stream_info_err:
4240     for (i = 0; i < ic->nb_streams; i++) {
4241         st = ic->streams[i];
4242         if (st->internal->info)
4243             av_freep(&st->internal->info->duration_error);
4244         avcodec_close(ic->streams[i]->internal->avctx);
4245         av_freep(&ic->streams[i]->internal->info);
4246         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4247     }
4248     if (ic->pb)
4249         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4250                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4251     return ret;
4252
4253 unref_then_goto_end:
4254     av_packet_unref(pkt1);
4255     goto find_stream_info_err;
4256 }
4257
4258 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4259 {
4260     int i, j;
4261
4262     for (i = 0; i < ic->nb_programs; i++) {
4263         if (ic->programs[i] == last) {
4264             last = NULL;
4265         } else {
4266             if (!last)
4267                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4268                     if (ic->programs[i]->stream_index[j] == s)
4269                         return ic->programs[i];
4270         }
4271     }
4272     return NULL;
4273 }
4274
4275 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4276                         int wanted_stream_nb, int related_stream,
4277                         AVCodec **decoder_ret, int flags)
4278 {
4279     int i, nb_streams = ic->nb_streams;
4280     int ret = AVERROR_STREAM_NOT_FOUND;
4281     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4282     int count, multiframe, disposition;
4283     int64_t best_bitrate = -1;
4284     int64_t bitrate;
4285     unsigned *program = NULL;
4286     const AVCodec *decoder = NULL, *best_decoder = NULL;
4287
4288     if (related_stream >= 0 && wanted_stream_nb < 0) {
4289         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4290         if (p) {
4291             program    = p->stream_index;
4292             nb_streams = p->nb_stream_indexes;
4293         }
4294     }
4295     for (i = 0; i < nb_streams; i++) {
4296         int real_stream_index = program ? program[i] : i;
4297         AVStream *st          = ic->streams[real_stream_index];
4298         AVCodecParameters *par = st->codecpar;
4299         if (par->codec_type != type)
4300             continue;
4301         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4302             continue;
4303         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4304             continue;
4305         if (decoder_ret) {
4306             decoder = find_decoder(ic, st, par->codec_id);
4307             if (!decoder) {
4308                 if (ret < 0)
4309                     ret = AVERROR_DECODER_NOT_FOUND;
4310                 continue;
4311             }
4312         }
4313         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4314                       + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4315         count = st->codec_info_nb_frames;
4316         bitrate = par->bit_rate;
4317         multiframe = FFMIN(5, count);
4318         if ((best_disposition >  disposition) ||
4319             (best_disposition == disposition && best_multiframe >  multiframe) ||
4320             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4321             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4322             continue;
4323         best_disposition = disposition;
4324         best_count   = count;
4325         best_bitrate = bitrate;
4326         best_multiframe = multiframe;
4327         ret          = real_stream_index;
4328         best_decoder = decoder;
4329         if (program && i == nb_streams - 1 && ret < 0) {
4330             program    = NULL;
4331             nb_streams = ic->nb_streams;
4332             /* no related stream found, try again with everything */
4333             i = 0;
4334         }
4335     }
4336     if (decoder_ret)
4337         *decoder_ret = (AVCodec*)best_decoder;
4338     return ret;
4339 }
4340
4341 /*******************************************************/
4342
4343 int av_read_play(AVFormatContext *s)
4344 {
4345     if (s->iformat->read_play)
4346         return s->iformat->read_play(s);
4347     if (s->pb)
4348         return avio_pause(s->pb, 0);
4349     return AVERROR(ENOSYS);
4350 }
4351
4352 int av_read_pause(AVFormatContext *s)
4353 {
4354     if (s->iformat->read_pause)
4355         return s->iformat->read_pause(s);
4356     if (s->pb)
4357         return avio_pause(s->pb, 1);
4358     return AVERROR(ENOSYS);
4359 }
4360
4361 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4362 {
4363     int ret, i;
4364
4365     dst->id                  = src->id;
4366     dst->time_base           = src->time_base;
4367     dst->nb_frames           = src->nb_frames;
4368     dst->disposition         = src->disposition;
4369     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4370     dst->avg_frame_rate      = src->avg_frame_rate;
4371     dst->r_frame_rate        = src->r_frame_rate;
4372
4373     av_dict_free(&dst->metadata);
4374     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4375     if (ret < 0)
4376         return ret;
4377
4378     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4379     if (ret < 0)
4380         return ret;
4381
4382     /* Free existing side data*/
4383     for (i = 0; i < dst->nb_side_data; i++)
4384         av_free(dst->side_data[i].data);
4385     av_freep(&dst->side_data);
4386     dst->nb_side_data = 0;
4387
4388     /* Copy side data if present */
4389     if (src->nb_side_data) {
4390         dst->side_data = av_mallocz_array(src->nb_side_data,
4391                                           sizeof(AVPacketSideData));
4392         if (!dst->side_data)
4393             return AVERROR(ENOMEM);
4394         dst->nb_side_data = src->nb_side_data;
4395
4396         for (i = 0; i < src->nb_side_data; i++) {
4397             uint8_t *data = av_memdup(src->side_data[i].data,
4398                                       src->side_data[i].size);
4399             if (!data)
4400                 return AVERROR(ENOMEM);
4401             dst->side_data[i].type = src->side_data[i].type;
4402             dst->side_data[i].size = src->side_data[i].size;
4403             dst->side_data[i].data = data;
4404         }
4405     }
4406
4407 #if FF_API_LAVF_FFSERVER
4408 FF_DISABLE_DEPRECATION_WARNINGS
4409     av_freep(&dst->recommended_encoder_configuration);
4410     if (src->recommended_encoder_configuration) {
4411         const char *conf_str = src->recommended_encoder_configuration;
4412         dst->recommended_encoder_configuration = av_strdup(conf_str);
4413         if (!dst->recommended_encoder_configuration)
4414             return AVERROR(ENOMEM);
4415     }
4416 FF_ENABLE_DEPRECATION_WARNINGS
4417 #endif
4418
4419     return 0;
4420 }
4421
4422 static void free_stream(AVStream **pst)
4423 {
4424     AVStream *st = *pst;
4425     int i;
4426
4427     if (!st)
4428         return;
4429
4430     for (i = 0; i < st->nb_side_data; i++)
4431         av_freep(&st->side_data[i].data);
4432     av_freep(&st->side_data);
4433
4434     if (st->parser)
4435         av_parser_close(st->parser);
4436
4437     if (st->attached_pic.data)
4438         av_packet_unref(&st->attached_pic);
4439
4440     if (st->internal) {
4441         avcodec_free_context(&st->internal->avctx);
4442         av_bsf_free(&st->internal->bsfc);
4443         av_freep(&st->internal->priv_pts);
4444         av_freep(&st->internal->index_entries);
4445         av_freep(&st->internal->probe_data.buf);
4446
4447         av_bsf_free(&st->internal->extract_extradata.bsf);
4448
4449         if (st->internal->info)
4450             av_freep(&st->internal->info->duration_error);
4451         av_freep(&st->internal->info);
4452     }
4453     av_freep(&st->internal);
4454
4455     av_dict_free(&st->metadata);
4456     avcodec_parameters_free(&st->codecpar);
4457 #if FF_API_LAVF_AVCTX
4458 FF_DISABLE_DEPRECATION_WARNINGS
4459     avcodec_free_context(&st->codec);
4460 FF_ENABLE_DEPRECATION_WARNINGS
4461 #endif
4462     av_freep(&st->priv_data);
4463 #if FF_API_LAVF_FFSERVER
4464 FF_DISABLE_DEPRECATION_WARNINGS
4465     av_freep(&st->recommended_encoder_configuration);
4466 FF_ENABLE_DEPRECATION_WARNINGS
4467 #endif
4468
4469     av_freep(pst);
4470 }
4471
4472 void ff_free_stream(AVFormatContext *s, AVStream *st)
4473 {
4474     av_assert0(s->nb_streams>0);
4475     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4476
4477     free_stream(&s->streams[ --s->nb_streams ]);
4478 }
4479
4480 void avformat_free_context(AVFormatContext *s)
4481 {
4482     int i;
4483
4484     if (!s)
4485         return;
4486
4487     if (s->oformat && s->oformat->deinit && s->internal->initialized)
4488         s->oformat->deinit(s);
4489
4490     av_opt_free(s);
4491     if (s->iformat && s->iformat->priv_class && s->priv_data)
4492         av_opt_free(s->priv_data);
4493     if (s->oformat && s->oformat->priv_class && s->priv_data)
4494         av_opt_free(s->priv_data);
4495
4496     for (i = 0; i < s->nb_streams; i++)
4497         free_stream(&s->streams[i]);
4498     s->nb_streams = 0;
4499
4500     for (i = 0; i < s->nb_programs; i++) {
4501         av_dict_free(&s->programs[i]->metadata);
4502         av_freep(&s->programs[i]->stream_index);
4503         av_freep(&s->programs[i]);
4504     }
4505     s->nb_programs = 0;
4506
4507     av_freep(&s->programs);
4508     av_freep(&s->priv_data);
4509     while (s->nb_chapters--) {
4510         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4511         av_freep(&s->chapters[s->nb_chapters]);
4512     }
4513     av_freep(&s->chapters);
4514     av_dict_free(&s->metadata);
4515     av_dict_free(&s->internal->id3v2_meta);
4516     av_packet_free(&s->internal->pkt);
4517     av_packet_free(&s->internal->parse_pkt);
4518     av_freep(&s->streams);
4519     flush_packet_queue(s);
4520     av_freep(&s->internal);
4521     av_freep(&s->url);
4522     av_free(s);
4523 }
4524
4525 void avformat_close_input(AVFormatContext **ps)
4526 {
4527     AVFormatContext *s;
4528     AVIOContext *pb;
4529
4530     if (!ps || !*ps)
4531         return;
4532
4533     s  = *ps;
4534     pb = s->pb;
4535
4536     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4537         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4538         pb = NULL;
4539
4540     flush_packet_queue(s);
4541
4542     if (s->iformat)
4543         if (s->iformat->read_close)
4544             s->iformat->read_close(s);
4545
4546     avformat_free_context(s);
4547
4548     *ps = NULL;
4549
4550     avio_close(pb);
4551 }
4552
4553 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4554 {
4555     AVStream *st;
4556     int i;
4557     AVStream **streams;
4558
4559     if (s->nb_streams >= s->max_streams) {
4560         av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
4561                " (%d), see the documentation if you wish to increase it\n",
4562                s->max_streams);
4563         return NULL;
4564     }
4565     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4566     if (!streams)
4567         return NULL;
4568     s->streams = streams;
4569
4570     st = av_mallocz(sizeof(AVStream));
4571     if (!st)
4572         return NULL;
4573
4574 #if FF_API_LAVF_AVCTX
4575 FF_DISABLE_DEPRECATION_WARNINGS
4576     st->codec = avcodec_alloc_context3(c);
4577     if (!st->codec) {
4578         av_free(st);
4579         return NULL;
4580     }
4581 FF_ENABLE_DEPRECATION_WARNINGS
4582 #endif
4583
4584     st->internal = av_mallocz(sizeof(*st->internal));
4585     if (!st->internal)
4586         goto fail;
4587
4588     st->internal->info = av_mallocz(sizeof(*st->internal->info));
4589     if (!st->internal->info)
4590         goto fail;
4591     st->internal->info->last_dts = AV_NOPTS_VALUE;
4592
4593     st->codecpar = avcodec_parameters_alloc();
4594     if (!st->codecpar)
4595         goto fail;
4596
4597     st->internal->avctx = avcodec_alloc_context3(NULL);
4598     if (!st->internal->avctx)
4599         goto fail;
4600
4601     if (s->iformat) {
4602 #if FF_API_LAVF_AVCTX
4603 FF_DISABLE_DEPRECATION_WARNINGS
4604         /* no default bitrate if decoding */
4605         st->codec->bit_rate = 0;
4606 FF_ENABLE_DEPRECATION_WARNINGS
4607 #endif
4608
4609         /* default pts setting is MPEG-like */
4610         avpriv_set_pts_info(st, 33, 1, 90000);
4611         /* we set the current DTS to 0 so that formats without any timestamps
4612          * but durations get some timestamps, formats with some unknown
4613          * timestamps have their first few packets buffered and the
4614          * timestamps corrected before they are returned to the user */
4615         st->cur_dts = RELATIVE_TS_BASE;
4616     } else {
4617         st->cur_dts = AV_NOPTS_VALUE;
4618     }
4619
4620     st->index      = s->nb_streams;
4621     st->start_time = AV_NOPTS_VALUE;
4622     st->duration   = AV_NOPTS_VALUE;
4623     st->first_dts     = AV_NOPTS_VALUE;
4624     st->probe_packets = s->max_probe_packets;
4625     st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4626     st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4627
4628     st->last_IP_pts = AV_NOPTS_VALUE;
4629     st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4630     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4631         st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4632
4633     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4634
4635 #if FF_API_R_FRAME_RATE
4636     st->internal->info->last_dts      = AV_NOPTS_VALUE;
4637 #endif
4638     st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4639     st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
4640
4641     st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4642
4643     st->internal->need_context_update = 1;
4644
4645     s->streams[s->nb_streams++] = st;
4646     return st;
4647 fail:
4648     free_stream(&st);
4649     return NULL;
4650 }
4651
4652 AVProgram *av_new_program(AVFormatContext *ac, int id)
4653 {
4654     AVProgram *program = NULL;
4655     int i, ret;
4656
4657     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4658
4659     for (i = 0; i < ac->nb_programs; i++)
4660         if (ac->programs[i]->id == id)
4661             program = ac->programs[i];
4662
4663     if (!program) {
4664         program = av_mallocz(sizeof(AVProgram));
4665         if (!program)
4666             return NULL;
4667         ret = av_dynarray_add_nofree(&ac->programs, &ac->nb_programs, program);
4668         if (ret < 0) {
4669             av_free(program);
4670             return NULL;
4671         }
4672         program->discard = AVDISCARD_NONE;
4673         program->pmt_version = -1;
4674         program->id = id;
4675         program->pts_wrap_reference = AV_NOPTS_VALUE;
4676         program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4677         program->start_time =
4678         program->end_time   = AV_NOPTS_VALUE;
4679     }
4680     return program;
4681 }
4682
4683 #if FF_API_CHAPTER_ID_INT
4684 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4685 #else
4686 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
4687 #endif
4688                               int64_t start, int64_t end, const char *title)
4689 {
4690     AVChapter *chapter = NULL;
4691     int i, ret;
4692
4693     if (end != AV_NOPTS_VALUE && start > end) {
4694         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4695         return NULL;
4696     }
4697
4698     if (!s->nb_chapters) {
4699         s->internal->chapter_ids_monotonic = 1;
4700     } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4701         s->internal->chapter_ids_monotonic = 0;
4702         for (i = 0; i < s->nb_chapters; i++)
4703             if (s->chapters[i]->id == id)
4704                 chapter = s->chapters[i];
4705     }
4706
4707     if (!chapter) {
4708         chapter = av_mallocz(sizeof(AVChapter));
4709         if (!chapter)
4710             return NULL;
4711         ret = av_dynarray_add_nofree(&s->chapters, &s->nb_chapters, chapter);
4712         if (ret < 0) {
4713             av_free(chapter);
4714             return NULL;
4715         }
4716     }
4717     av_dict_set(&chapter->metadata, "title", title, 0);
4718     chapter->id        = id;
4719     chapter->time_base = time_base;
4720     chapter->start     = start;
4721     chapter->end       = end;
4722
4723     return chapter;
4724 }
4725
4726 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4727 {
4728     int i, j;
4729     AVProgram *program = NULL;
4730     void *tmp;
4731
4732     if (idx >= ac->nb_streams) {
4733         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4734         return;
4735     }
4736
4737     for (i = 0; i < ac->nb_programs; i++) {
4738         if (ac->programs[i]->id != progid)
4739             continue;
4740         program = ac->programs[i];
4741         for (j = 0; j < program->nb_stream_indexes; j++)
4742             if (program->stream_index[j] == idx)
4743                 return;
4744
4745         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4746         if (!tmp)
4747             return;
4748         program->stream_index = tmp;
4749         program->stream_index[program->nb_stream_indexes++] = idx;
4750         return;
4751     }
4752 }
4753
4754 uint64_t ff_ntp_time(void)
4755 {
4756     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4757 }
4758
4759 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4760 {
4761     uint64_t ntp_ts, frac_part, sec;
4762     uint32_t usec;
4763
4764     //current ntp time in seconds and micro seconds
4765     sec = ntp_time_us / 1000000;
4766     usec = ntp_time_us % 1000000;
4767
4768     //encoding in ntp timestamp format
4769     frac_part = usec * 0xFFFFFFFFULL;
4770     frac_part /= 1000000;
4771
4772     if (sec > 0xFFFFFFFFULL)
4773         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4774
4775     ntp_ts = sec << 32;
4776     ntp_ts |= frac_part;
4777
4778     return ntp_ts;
4779 }
4780
4781 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
4782 {
4783     uint64_t sec = ntp_ts >> 32;
4784     uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
4785     uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
4786
4787     return (sec * 1000000) + usec;
4788 }
4789
4790 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4791 {
4792     const char *p;
4793     char *q, buf1[20], c;
4794     int nd, len, percentd_found;
4795
4796     q = buf;
4797     p = path;
4798     percentd_found = 0;
4799     for (;;) {
4800         c = *p++;
4801         if (c == '\0')
4802             break;
4803         if (c == '%') {
4804             do {
4805                 nd = 0;
4806                 while (av_isdigit(*p)) {
4807                     if (nd >= INT_MAX / 10 - 255)
4808                         goto fail;
4809                     nd = nd * 10 + *p++ - '0';
4810                 }
4811                 c = *p++;
4812             } while (av_isdigit(c));
4813
4814             switch (c) {
4815             case '%':
4816                 goto addchar;
4817             case 'd':
4818                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4819                     goto fail;
4820                 percentd_found = 1;
4821                 if (number < 0)
4822                     nd += 1;
4823                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4824                 len = strlen(buf1);
4825                 if ((q - buf + len) > buf_size - 1)
4826                     goto fail;
4827                 memcpy(q, buf1, len);
4828                 q += len;
4829                 break;
4830             default:
4831                 goto fail;
4832             }
4833         } else {
4834 addchar:
4835             if ((q - buf) < buf_size - 1)
4836                 *q++ = c;
4837         }
4838     }
4839     if (!percentd_found)
4840         goto fail;
4841     *q = '\0';
4842     return 0;
4843 fail:
4844     *q = '\0';
4845     return -1;
4846 }
4847
4848 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4849 {
4850     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4851 }
4852
4853 void av_url_split(char *proto, int proto_size,
4854                   char *authorization, int authorization_size,
4855                   char *hostname, int hostname_size,
4856                   int *port_ptr, char *path, int path_size, const char *url)
4857 {
4858     const char *p, *ls, *at, *at2, *col, *brk;
4859
4860     if (port_ptr)
4861         *port_ptr = -1;
4862     if (proto_size > 0)
4863         proto[0] = 0;
4864     if (authorization_size > 0)
4865         authorization[0] = 0;
4866     if (hostname_size > 0)
4867         hostname[0] = 0;
4868     if (path_size > 0)
4869         path[0] = 0;
4870
4871     /* parse protocol */
4872     if ((p = strchr(url, ':'))) {
4873         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4874         p++; /* skip ':' */
4875         if (*p == '/')
4876             p++;
4877         if (*p == '/')
4878             p++;
4879     } else {
4880         /* no protocol means plain filename */
4881         av_strlcpy(path, url, path_size);
4882         return;
4883     }
4884
4885     /* separate path from hostname */
4886     ls = p + strcspn(p, "/?#");
4887     av_strlcpy(path, ls, path_size);
4888
4889     /* the rest is hostname, use that to parse auth/port */
4890     if (ls != p) {
4891         /* authorization (user[:pass]@hostname) */
4892         at2 = p;
4893         while ((at = strchr(p, '@')) && at < ls) {
4894             av_strlcpy(authorization, at2,
4895                        FFMIN(authorization_size, at + 1 - at2));
4896             p = at + 1; /* skip '@' */
4897         }
4898
4899         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4900             /* [host]:port */
4901             av_strlcpy(hostname, p + 1,
4902                        FFMIN(hostname_size, brk - p));
4903             if (brk[1] == ':' && port_ptr)
4904                 *port_ptr = atoi(brk + 2);
4905         } else if ((col = strchr(p, ':')) && col < ls) {
4906             av_strlcpy(hostname, p,
4907                        FFMIN(col + 1 - p, hostname_size));
4908             if (port_ptr)
4909                 *port_ptr = atoi(col + 1);
4910         } else
4911             av_strlcpy(hostname, p,
4912                        FFMIN(ls + 1 - p, hostname_size));
4913     }
4914 }
4915
4916 int ff_mkdir_p(const char *path)
4917 {
4918     int ret = 0;
4919     char *temp = av_strdup(path);
4920     char *pos = temp;
4921     char tmp_ch = '\0';
4922
4923     if (!path || !temp) {
4924         return -1;
4925     }
4926
4927     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4928         pos++;
4929     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4930         pos += 2;
4931     }
4932
4933     for ( ; *pos != '\0'; ++pos) {
4934         if (*pos == '/' || *pos == '\\') {
4935             tmp_ch = *pos;
4936             *pos = '\0';
4937             ret = mkdir(temp, 0755);
4938             *pos = tmp_ch;
4939         }
4940     }
4941
4942     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4943         ret = mkdir(temp, 0755);
4944     }
4945
4946     av_free(temp);
4947     return ret;
4948 }
4949
4950 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4951 {
4952     int i;
4953     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4954                                            '4', '5', '6', '7',
4955                                            '8', '9', 'A', 'B',
4956                                            'C', 'D', 'E', 'F' };
4957     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4958                                            '4', '5', '6', '7',
4959                                            '8', '9', 'a', 'b',
4960                                            'c', 'd', 'e', 'f' };
4961     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4962
4963     for (i = 0; i < s; i++) {
4964         buff[i * 2]     = hex_table[src[i] >> 4];
4965         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4966     }
4967
4968     return buff;
4969 }
4970
4971 int ff_hex_to_data(uint8_t *data, const char *p)
4972 {
4973     int c, len, v;
4974
4975     len = 0;
4976     v   = 1;
4977     for (;;) {
4978         p += strspn(p, SPACE_CHARS);
4979         if (*p == '\0')
4980             break;
4981         c = av_toupper((unsigned char) *p++);
4982         if (c >= '0' && c <= '9')
4983             c = c - '0';
4984         else if (c >= 'A' && c <= 'F')
4985             c = c - 'A' + 10;
4986         else
4987             break;
4988         v = (v << 4) | c;
4989         if (v & 0x100) {
4990             if (data)
4991                 data[len] = v;
4992             len++;
4993             v = 1;
4994         }
4995     }
4996     return len;
4997 }
4998
4999 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
5000                          unsigned int pts_num, unsigned int pts_den)
5001 {
5002     AVRational new_tb;
5003     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
5004         if (new_tb.num != pts_num)
5005             av_log(NULL, AV_LOG_DEBUG,
5006                    "st:%d removing common factor %d from timebase\n",
5007                    s->index, pts_num / new_tb.num);
5008     } else
5009         av_log(NULL, AV_LOG_WARNING,
5010                "st:%d has too large timebase, reducing\n", s->index);
5011
5012     if (new_tb.num <= 0 || new_tb.den <= 0) {
5013         av_log(NULL, AV_LOG_ERROR,
5014                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
5015                new_tb.num, new_tb.den,
5016                s->index);
5017         return;
5018     }
5019     s->time_base     = new_tb;
5020 #if FF_API_LAVF_AVCTX
5021 FF_DISABLE_DEPRECATION_WARNINGS
5022     s->codec->pkt_timebase = new_tb;
5023 FF_ENABLE_DEPRECATION_WARNINGS
5024 #endif
5025     s->internal->avctx->pkt_timebase = new_tb;
5026     s->pts_wrap_bits = pts_wrap_bits;
5027 }
5028
5029 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
5030                         void *context)
5031 {
5032     const char *ptr = str;
5033
5034     /* Parse key=value pairs. */
5035     for (;;) {
5036         const char *key;
5037         char *dest = NULL, *dest_end;
5038         int key_len, dest_len = 0;
5039
5040         /* Skip whitespace and potential commas. */
5041         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
5042             ptr++;
5043         if (!*ptr)
5044             break;
5045
5046         key = ptr;
5047
5048         if (!(ptr = strchr(key, '=')))
5049             break;
5050         ptr++;
5051         key_len = ptr - key;
5052
5053         callback_get_buf(context, key, key_len, &dest, &dest_len);
5054         dest_end = dest + dest_len - 1;
5055
5056         if (*ptr == '\"') {
5057             ptr++;
5058             while (*ptr && *ptr != '\"') {
5059                 if (*ptr == '\\') {
5060                     if (!ptr[1])
5061                         break;
5062                     if (dest && dest < dest_end)
5063                         *dest++ = ptr[1];
5064                     ptr += 2;
5065                 } else {
5066                     if (dest && dest < dest_end)
5067                         *dest++ = *ptr;
5068                     ptr++;
5069                 }
5070             }
5071             if (*ptr == '\"')
5072                 ptr++;
5073         } else {
5074             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5075                 if (dest && dest < dest_end)
5076                     *dest++ = *ptr;
5077         }
5078         if (dest)
5079             *dest = 0;
5080     }
5081 }
5082
5083 int ff_find_stream_index(AVFormatContext *s, int id)
5084 {
5085     int i;
5086     for (i = 0; i < s->nb_streams; i++)
5087         if (s->streams[i]->id == id)
5088             return i;
5089     return -1;
5090 }
5091
5092 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5093                          int std_compliance)
5094 {
5095     if (ofmt) {
5096         unsigned int codec_tag;
5097         if (ofmt->query_codec)
5098             return ofmt->query_codec(codec_id, std_compliance);
5099         else if (ofmt->codec_tag)
5100             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5101         else if (codec_id == ofmt->video_codec ||
5102                  codec_id == ofmt->audio_codec ||
5103                  codec_id == ofmt->subtitle_codec ||
5104                  codec_id == ofmt->data_codec)
5105             return 1;
5106     }
5107     return AVERROR_PATCHWELCOME;
5108 }
5109
5110 int avformat_network_init(void)
5111 {
5112 #if CONFIG_NETWORK
5113     int ret;
5114     if ((ret = ff_network_init()) < 0)
5115         return ret;
5116     if ((ret = ff_tls_init()) < 0)
5117         return ret;
5118 #endif
5119     return 0;
5120 }
5121
5122 int avformat_network_deinit(void)
5123 {
5124 #if CONFIG_NETWORK
5125     ff_network_close();
5126     ff_tls_deinit();
5127 #endif
5128     return 0;
5129 }
5130
5131 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5132                         uint64_t channel_layout, int32_t sample_rate,
5133                         int32_t width, int32_t height)
5134 {
5135     uint32_t flags = 0;
5136     int size = 4;
5137     uint8_t *data;
5138     if (!pkt)
5139         return AVERROR(EINVAL);
5140     if (channels) {
5141         size  += 4;
5142         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5143     }
5144     if (channel_layout) {
5145         size  += 8;
5146         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5147     }
5148     if (sample_rate) {
5149         size  += 4;
5150         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5151     }
5152     if (width || height) {
5153         size  += 8;
5154         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5155     }
5156     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5157     if (!data)
5158         return AVERROR(ENOMEM);
5159     bytestream_put_le32(&data, flags);
5160     if (channels)
5161         bytestream_put_le32(&data, channels);
5162     if (channel_layout)
5163         bytestream_put_le64(&data, channel_layout);
5164     if (sample_rate)
5165         bytestream_put_le32(&data, sample_rate);
5166     if (width || height) {
5167         bytestream_put_le32(&data, width);
5168         bytestream_put_le32(&data, height);
5169     }
5170     return 0;
5171 }
5172
5173 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5174 {
5175     AVRational undef = {0, 1};
5176     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5177     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5178     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5179
5180     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5181                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5182     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5183         stream_sample_aspect_ratio = undef;
5184
5185     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5186                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5187     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5188         frame_sample_aspect_ratio = undef;
5189
5190     if (stream_sample_aspect_ratio.num)
5191         return stream_sample_aspect_ratio;
5192     else
5193         return frame_sample_aspect_ratio;
5194 }
5195
5196 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5197 {
5198     AVRational fr = st->r_frame_rate;
5199     AVRational codec_fr = st->internal->avctx->framerate;
5200     AVRational   avg_fr = st->avg_frame_rate;
5201
5202     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5203         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5204         fr = avg_fr;
5205     }
5206
5207
5208     if (st->internal->avctx->ticks_per_frame > 1) {
5209         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5210             (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))
5211             fr = codec_fr;
5212     }
5213
5214     return fr;
5215 }
5216
5217 /**
5218  * Matches a stream specifier (but ignores requested index).
5219  *
5220  * @param indexptr set to point to the requested stream index if there is one
5221  *
5222  * @return <0 on error
5223  *         0  if st is NOT a matching stream
5224  *         >0 if st is a matching stream
5225  */
5226 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5227                                   const char *spec, const char **indexptr, AVProgram **p)
5228 {
5229     int match = 1;                      /* Stores if the specifier matches so far. */
5230     while (*spec) {
5231         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5232             if (indexptr)
5233                 *indexptr = spec;
5234             return match;
5235         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5236                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5237             enum AVMediaType type;
5238             int nopic = 0;
5239
5240             switch (*spec++) {
5241             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5242             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5243             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5244             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5245             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5246             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5247             default:  av_assert0(0);
5248             }
5249             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5250                 return AVERROR(EINVAL);
5251
5252 #if FF_API_LAVF_AVCTX
5253 FF_DISABLE_DEPRECATION_WARNINGS
5254             if (type != st->codecpar->codec_type
5255                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5256                 match = 0;
5257     FF_ENABLE_DEPRECATION_WARNINGS
5258 #else
5259             if (type != st->codecpar->codec_type)
5260                 match = 0;
5261 #endif
5262             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5263                 match = 0;
5264         } else if (*spec == 'p' && *(spec + 1) == ':') {
5265             int prog_id, i, j;
5266             int found = 0;
5267             char *endptr;
5268             spec += 2;
5269             prog_id = strtol(spec, &endptr, 0);
5270             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5271             if (spec == endptr || (*endptr && *endptr++ != ':'))
5272                 return AVERROR(EINVAL);
5273             spec = endptr;
5274             if (match) {
5275                 for (i = 0; i < s->nb_programs; i++) {
5276                     if (s->programs[i]->id != prog_id)
5277                         continue;
5278
5279                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5280                         if (st->index == s->programs[i]->stream_index[j]) {
5281                             found = 1;
5282                             if (p)
5283                                 *p = s->programs[i];
5284                             i = s->nb_programs;
5285                             break;
5286                         }
5287                     }
5288                 }
5289             }
5290             if (!found)
5291                 match = 0;
5292         } else if (*spec == '#' ||
5293                    (*spec == 'i' && *(spec + 1) == ':')) {
5294             int stream_id;
5295             char *endptr;
5296             spec += 1 + (*spec == 'i');
5297             stream_id = strtol(spec, &endptr, 0);
5298             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5299                 return AVERROR(EINVAL);
5300             return match && (stream_id == st->id);
5301         } else if (*spec == 'm' && *(spec + 1) == ':') {
5302             AVDictionaryEntry *tag;
5303             char *key, *val;
5304             int ret;
5305
5306             if (match) {
5307                spec += 2;
5308                val = strchr(spec, ':');
5309
5310                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5311                if (!key)
5312                    return AVERROR(ENOMEM);
5313
5314                tag = av_dict_get(st->metadata, key, NULL, 0);
5315                if (tag) {
5316                    if (!val || !strcmp(tag->value, val + 1))
5317                        ret = 1;
5318                    else
5319                        ret = 0;
5320                } else
5321                    ret = 0;
5322
5323                av_freep(&key);
5324             }
5325             return match && ret;
5326         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5327             AVCodecParameters *par = st->codecpar;
5328 #if FF_API_LAVF_AVCTX
5329 FF_DISABLE_DEPRECATION_WARNINGS
5330             AVCodecContext *codec = st->codec;
5331 FF_ENABLE_DEPRECATION_WARNINGS
5332 #endif
5333             int val;
5334             switch (par->codec_type) {
5335             case AVMEDIA_TYPE_AUDIO:
5336                 val = par->sample_rate && par->channels;
5337 #if FF_API_LAVF_AVCTX
5338                 val = val || (codec->sample_rate && codec->channels);
5339 #endif
5340                 if (par->format == AV_SAMPLE_FMT_NONE
5341 #if FF_API_LAVF_AVCTX
5342                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5343 #endif
5344                     )
5345                     return 0;
5346                 break;
5347             case AVMEDIA_TYPE_VIDEO:
5348                 val = par->width && par->height;
5349 #if FF_API_LAVF_AVCTX
5350                 val = val || (codec->width && codec->height);
5351 #endif
5352                 if (par->format == AV_PIX_FMT_NONE
5353 #if FF_API_LAVF_AVCTX
5354                     && codec->pix_fmt == AV_PIX_FMT_NONE
5355 #endif
5356                     )
5357                     return 0;
5358                 break;
5359             case AVMEDIA_TYPE_UNKNOWN:
5360                 val = 0;
5361                 break;
5362             default:
5363                 val = 1;
5364                 break;
5365             }
5366 #if FF_API_LAVF_AVCTX
5367             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5368 #else
5369             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5370 #endif
5371         } else {
5372             return AVERROR(EINVAL);
5373         }
5374     }
5375
5376     return match;
5377 }
5378
5379
5380 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5381                                     const char *spec)
5382 {
5383     int ret, index;
5384     char *endptr;
5385     const char *indexptr = NULL;
5386     AVProgram *p = NULL;
5387     int nb_streams;
5388
5389     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5390     if (ret < 0)
5391         goto error;
5392
5393     if (!indexptr)
5394         return ret;
5395
5396     index = strtol(indexptr, &endptr, 0);
5397     if (*endptr) {                  /* We can't have anything after the requested index. */
5398         ret = AVERROR(EINVAL);
5399         goto error;
5400     }
5401
5402     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5403     if (spec == indexptr)
5404         return (index == st->index);
5405
5406     /* If we requested a matching stream index, we have to ensure st is that. */
5407     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5408     for (int i = 0; i < nb_streams && index >= 0; i++) {
5409         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5410         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5411         if (ret < 0)
5412             goto error;
5413         if (ret > 0 && index-- == 0 && st == candidate)
5414             return 1;
5415     }
5416     return 0;
5417
5418 error:
5419     if (ret == AVERROR(EINVAL))
5420         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5421     return ret;
5422 }
5423
5424 int ff_generate_avci_extradata(AVStream *st)
5425 {
5426     static const uint8_t avci100_1080p_extradata[] = {
5427         // SPS
5428         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5429         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5430         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5431         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5432         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5433         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5434         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5435         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5436         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5437         // PPS
5438         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5439         0xd0
5440     };
5441     static const uint8_t avci100_1080i_extradata[] = {
5442         // SPS
5443         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5444         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5445         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5446         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5447         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5448         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5449         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5450         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5451         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5452         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5453         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5454         // PPS
5455         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5456         0xd0
5457     };
5458     static const uint8_t avci50_1080p_extradata[] = {
5459         // SPS
5460         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5461         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5462         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5463         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5464         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5465         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5466         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5467         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5468         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5469         // PPS
5470         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5471         0x11
5472     };
5473     static const uint8_t avci50_1080i_extradata[] = {
5474         // SPS
5475         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5476         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5477         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5478         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5479         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5480         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5481         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5482         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5483         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5484         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5485         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5486         // PPS
5487         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5488         0x11
5489     };
5490     static const uint8_t avci100_720p_extradata[] = {
5491         // SPS
5492         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5493         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5494         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5495         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5496         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5497         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5498         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5499         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5500         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5501         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5502         // PPS
5503         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5504         0x11
5505     };
5506     static const uint8_t avci50_720p_extradata[] = {
5507         // SPS
5508         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5509         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5510         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5511         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5512         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5513         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5514         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5515         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5516         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5517         // PPS
5518         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5519         0x11
5520     };
5521
5522     const uint8_t *data = NULL;
5523     int ret, size       = 0;
5524
5525     if (st->codecpar->width == 1920) {
5526         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5527             data = avci100_1080p_extradata;
5528             size = sizeof(avci100_1080p_extradata);
5529         } else {
5530             data = avci100_1080i_extradata;
5531             size = sizeof(avci100_1080i_extradata);
5532         }
5533     } else if (st->codecpar->width == 1440) {
5534         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5535             data = avci50_1080p_extradata;
5536             size = sizeof(avci50_1080p_extradata);
5537         } else {
5538             data = avci50_1080i_extradata;
5539             size = sizeof(avci50_1080i_extradata);
5540         }
5541     } else if (st->codecpar->width == 1280) {
5542         data = avci100_720p_extradata;
5543         size = sizeof(avci100_720p_extradata);
5544     } else if (st->codecpar->width == 960) {
5545         data = avci50_720p_extradata;
5546         size = sizeof(avci50_720p_extradata);
5547     }
5548
5549     if (!size)
5550         return 0;
5551
5552     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5553         return ret;
5554     memcpy(st->codecpar->extradata, data, size);
5555
5556     return 0;
5557 }
5558
5559 uint8_t *av_stream_get_side_data(const AVStream *st,
5560                                  enum AVPacketSideDataType type, buffer_size_t *size)
5561 {
5562     int i;
5563
5564     for (i = 0; i < st->nb_side_data; i++) {
5565         if (st->side_data[i].type == type) {
5566             if (size)
5567                 *size = st->side_data[i].size;
5568             return st->side_data[i].data;
5569         }
5570     }
5571     if (size)
5572         *size = 0;
5573     return NULL;
5574 }
5575
5576 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5577                             uint8_t *data, size_t size)
5578 {
5579     AVPacketSideData *sd, *tmp;
5580     int i;
5581
5582     for (i = 0; i < st->nb_side_data; i++) {
5583         sd = &st->side_data[i];
5584
5585         if (sd->type == type) {
5586             av_freep(&sd->data);
5587             sd->data = data;
5588             sd->size = size;
5589             return 0;
5590         }
5591     }
5592
5593     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5594         return AVERROR(ERANGE);
5595
5596     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5597     if (!tmp) {
5598         return AVERROR(ENOMEM);
5599     }
5600
5601     st->side_data = tmp;
5602     st->nb_side_data++;
5603
5604     sd = &st->side_data[st->nb_side_data - 1];
5605     sd->type = type;
5606     sd->data = data;
5607     sd->size = size;
5608
5609     return 0;
5610 }
5611
5612 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5613                                  buffer_size_t size)
5614 {
5615     int ret;
5616     uint8_t *data = av_malloc(size);
5617
5618     if (!data)
5619         return NULL;
5620
5621     ret = av_stream_add_side_data(st, type, data, size);
5622     if (ret < 0) {
5623         av_freep(&data);
5624         return NULL;
5625     }
5626
5627     return data;
5628 }
5629
5630 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5631 {
5632     int ret;
5633     const AVBitStreamFilter *bsf;
5634     AVBSFContext *bsfc;
5635
5636     av_assert0(!st->internal->bsfc);
5637
5638     if (!(bsf = av_bsf_get_by_name(name))) {
5639         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5640         return AVERROR_BSF_NOT_FOUND;
5641     }
5642
5643     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5644         return ret;
5645
5646     bsfc->time_base_in = st->time_base;
5647     if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5648         av_bsf_free(&bsfc);
5649         return ret;
5650     }
5651
5652     if (args && bsfc->filter->priv_class) {
5653         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5654         const char * shorthand[2] = {NULL};
5655
5656         if (opt)
5657             shorthand[0] = opt->name;
5658
5659         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5660             av_bsf_free(&bsfc);
5661             return ret;
5662         }
5663     }
5664
5665     if ((ret = av_bsf_init(bsfc)) < 0) {
5666         av_bsf_free(&bsfc);
5667         return ret;
5668     }
5669
5670     st->internal->bsfc = bsfc;
5671
5672     av_log(NULL, AV_LOG_VERBOSE,
5673            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5674            name, args ? args : "");
5675     return 1;
5676 }
5677
5678 #if FF_API_OLD_BSF
5679 FF_DISABLE_DEPRECATION_WARNINGS
5680 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5681                                AVBitStreamFilterContext *bsfc)
5682 {
5683     int ret = 0;
5684     while (bsfc) {
5685         AVPacket new_pkt = *pkt;
5686         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5687                                            &new_pkt.data, &new_pkt.size,
5688                                            pkt->data, pkt->size,
5689                                            pkt->flags & AV_PKT_FLAG_KEY);
5690         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5691             av_packet_unref(pkt);
5692             memset(pkt, 0, sizeof(*pkt));
5693             return 0;
5694         }
5695         if(a == 0 && new_pkt.data != pkt->data) {
5696             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
5697             if (t) {
5698                 memcpy(t, new_pkt.data, new_pkt.size);
5699                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5700                 new_pkt.data = t;
5701                 new_pkt.buf = NULL;
5702                 a = 1;
5703             } else {
5704                 a = AVERROR(ENOMEM);
5705             }
5706         }
5707         if (a > 0) {
5708             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5709                                            av_buffer_default_free, NULL, 0);
5710             if (new_pkt.buf) {
5711                 pkt->side_data = NULL;
5712                 pkt->side_data_elems = 0;
5713                 av_packet_unref(pkt);
5714             } else {
5715                 av_freep(&new_pkt.data);
5716                 a = AVERROR(ENOMEM);
5717             }
5718         }
5719         if (a < 0) {
5720             av_log(codec, AV_LOG_ERROR,
5721                    "Failed to open bitstream filter %s for stream %d with codec %s",
5722                    bsfc->filter->name, pkt->stream_index,
5723                    codec->codec ? codec->codec->name : "copy");
5724             ret = a;
5725             break;
5726         }
5727         *pkt = new_pkt;
5728
5729         bsfc = bsfc->next;
5730     }
5731     return ret;
5732 }
5733 FF_ENABLE_DEPRECATION_WARNINGS
5734 #endif
5735
5736 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5737 {
5738     if (!s->oformat)
5739         return AVERROR(EINVAL);
5740
5741     if (!(s->oformat->flags & AVFMT_NOFILE))
5742         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5743     return 0;
5744 }
5745
5746 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5747 {
5748     if (*pb)
5749         s->io_close(s, *pb);
5750     *pb = NULL;
5751 }
5752
5753 int ff_is_http_proto(char *filename) {
5754     const char *proto = avio_find_protocol_name(filename);
5755     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5756 }
5757
5758 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5759 {
5760     AVDictionaryEntry *entry;
5761     int64_t parsed_timestamp;
5762     int ret;
5763     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5764         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5765             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5766             return 1;
5767         } else {
5768             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5769             return ret;
5770         }
5771     }
5772     return 0;
5773 }
5774
5775 int ff_standardize_creation_time(AVFormatContext *s)
5776 {
5777     int64_t timestamp;
5778     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5779     if (ret == 1)
5780         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5781     return ret;
5782 }
5783
5784 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5785 {
5786     uint8_t *side_data;
5787     buffer_size_t size;
5788
5789     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5790     if (side_data) {
5791         if (size != AVPALETTE_SIZE) {
5792             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5793             return AVERROR_INVALIDDATA;
5794         }
5795         memcpy(palette, side_data, AVPALETTE_SIZE);
5796         return 1;
5797     }
5798
5799     if (ret == CONTAINS_PAL) {
5800         int i;
5801         for (i = 0; i < AVPALETTE_COUNT; i++)
5802             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5803         return 1;
5804     }
5805
5806     return 0;
5807 }
5808
5809 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5810 {
5811     int ret;
5812     char *str;
5813
5814     ret = av_bprint_finalize(buf, &str);
5815     if (ret < 0)
5816         return ret;
5817     if (!av_bprint_is_complete(buf)) {
5818         av_free(str);
5819         return AVERROR(ENOMEM);
5820     }
5821
5822     par->extradata = str;
5823     /* Note: the string is NUL terminated (so extradata can be read as a
5824      * string), but the ending character is not accounted in the size (in
5825      * binary formats you are likely not supposed to mux that character). When
5826      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5827      * zeros. */
5828     par->extradata_size = buf->len;
5829     return 0;
5830 }
5831
5832 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5833                                                   AVStream *ost, const AVStream *ist,
5834                                                   enum AVTimebaseSource copy_tb)
5835 {
5836     //TODO: use [io]st->internal->avctx
5837     const AVCodecContext *dec_ctx;
5838     AVCodecContext       *enc_ctx;
5839
5840 #if FF_API_LAVF_AVCTX
5841 FF_DISABLE_DEPRECATION_WARNINGS
5842     dec_ctx = ist->codec;
5843     enc_ctx = ost->codec;
5844 FF_ENABLE_DEPRECATION_WARNINGS
5845 #else
5846     dec_ctx = ist->internal->avctx;
5847     enc_ctx = ost->internal->avctx;
5848 #endif
5849
5850     enc_ctx->time_base = ist->time_base;
5851     /*
5852      * Avi is a special case here because it supports variable fps but
5853      * having the fps and timebase differe significantly adds quite some
5854      * overhead
5855      */
5856     if (!strcmp(ofmt->name, "avi")) {
5857 #if FF_API_R_FRAME_RATE
5858         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5859             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5860             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5861             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5862             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5863             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5864             enc_ctx->time_base.num = ist->r_frame_rate.den;
5865             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5866             enc_ctx->ticks_per_frame = 2;
5867         } else
5868 #endif
5869             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5870                    && av_q2d(ist->time_base) < 1.0/500
5871                    || copy_tb == AVFMT_TBCF_DECODER) {
5872             enc_ctx->time_base = dec_ctx->time_base;
5873             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5874             enc_ctx->time_base.den *= 2;
5875             enc_ctx->ticks_per_frame = 2;
5876         }
5877     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5878                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5879         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5880             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5881             && av_q2d(ist->time_base) < 1.0/500
5882             || copy_tb == AVFMT_TBCF_DECODER) {
5883             enc_ctx->time_base = dec_ctx->time_base;
5884             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5885         }
5886     }
5887
5888     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5889         && dec_ctx->time_base.num < dec_ctx->time_base.den
5890         && dec_ctx->time_base.num > 0
5891         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5892         enc_ctx->time_base = dec_ctx->time_base;
5893     }
5894
5895     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5896               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5897
5898     return 0;
5899 }
5900
5901 AVRational av_stream_get_codec_timebase(const AVStream *st)
5902 {
5903     // See avformat_transfer_internal_stream_timing_info() TODO.
5904 #if FF_API_LAVF_AVCTX
5905 FF_DISABLE_DEPRECATION_WARNINGS
5906     return st->codec->time_base;
5907 FF_ENABLE_DEPRECATION_WARNINGS
5908 #else
5909     return st->internal->avctx->time_base;
5910 #endif
5911 }
5912
5913 void ff_format_set_url(AVFormatContext *s, char *url)
5914 {
5915     av_assert0(url);
5916     av_freep(&s->url);
5917     s->url = url;
5918 #if FF_API_FORMAT_FILENAME
5919 FF_DISABLE_DEPRECATION_WARNINGS
5920     av_strlcpy(s->filename, url, sizeof(s->filename));
5921 FF_ENABLE_DEPRECATION_WARNINGS
5922 #endif
5923 }