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