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