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