git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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