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