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