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     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2816     /* estimate the end time (duration) */
2817     /* XXX: may need to support wrapping */
2818     filesize = ic->pb ? avio_size(ic->pb) : 0;
2819     do {
2820         is_end = found_duration;
2821         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2822         if (offset < 0)
2823             offset = 0;
2824
2825         avio_seek(ic->pb, offset, SEEK_SET);
2826         read_size = 0;
2827         for (;;) {
2828             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2829                 break;
2830
2831             do {
2832                 ret = ff_read_packet(ic, pkt);
2833             } while (ret == AVERROR(EAGAIN));
2834             if (ret != 0)
2835                 break;
2836             read_size += pkt->size;
2837             st         = ic->streams[pkt->stream_index];
2838             if (pkt->pts != AV_NOPTS_VALUE &&
2839                 (st->start_time != AV_NOPTS_VALUE ||
2840                  st->first_dts  != AV_NOPTS_VALUE)) {
2841                 if (pkt->duration == 0) {
2842                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2843                     if (den && num) {
2844                         pkt->duration = av_rescale_rnd(1,
2845                                            num * (int64_t) st->time_base.den,
2846                                            den * (int64_t) st->time_base.num,
2847                                            AV_ROUND_DOWN);
2848                     }
2849                 }
2850                 duration = pkt->pts + pkt->duration;
2851                 found_duration = 1;
2852                 if (st->start_time != AV_NOPTS_VALUE)
2853                     duration -= st->start_time;
2854                 else
2855                     duration -= st->first_dts;
2856                 if (duration > 0) {
2857                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2858                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2859                         st->duration = duration;
2860                     st->info->last_duration = duration;
2861                 }
2862             }
2863             av_packet_unref(pkt);
2864         }
2865
2866         /* check if all audio/video streams have valid duration */
2867         if (!is_end) {
2868             is_end = 1;
2869             for (i = 0; i < ic->nb_streams; i++) {
2870                 st = ic->streams[i];
2871                 switch (st->codecpar->codec_type) {
2872                     case AVMEDIA_TYPE_VIDEO:
2873                     case AVMEDIA_TYPE_AUDIO:
2874                         if (st->duration == AV_NOPTS_VALUE)
2875                             is_end = 0;
2876                 }
2877             }
2878         }
2879     } while (!is_end &&
2880              offset &&
2881              ++retry <= DURATION_MAX_RETRY);
2882
2883     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2884
2885     /* warn about audio/video streams which duration could not be estimated */
2886     for (i = 0; i < ic->nb_streams; i++) {
2887         st = ic->streams[i];
2888         if (st->duration == AV_NOPTS_VALUE) {
2889             switch (st->codecpar->codec_type) {
2890             case AVMEDIA_TYPE_VIDEO:
2891             case AVMEDIA_TYPE_AUDIO:
2892                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2893                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2894                 } else
2895                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2896             }
2897         }
2898     }
2899     fill_all_stream_timings(ic);
2900
2901     avio_seek(ic->pb, old_offset, SEEK_SET);
2902     for (i = 0; i < ic->nb_streams; i++) {
2903         int j;
2904
2905         st              = ic->streams[i];
2906         st->cur_dts     = st->first_dts;
2907         st->last_IP_pts = AV_NOPTS_VALUE;
2908         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2909         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2910             st->pts_buffer[j] = AV_NOPTS_VALUE;
2911     }
2912 }
2913
2914 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2915 {
2916     int64_t file_size;
2917
2918     /* get the file size, if possible */
2919     if (ic->iformat->flags & AVFMT_NOFILE) {
2920         file_size = 0;
2921     } else {
2922         file_size = avio_size(ic->pb);
2923         file_size = FFMAX(0, file_size);
2924     }
2925
2926     if ((!strcmp(ic->iformat->name, "mpeg") ||
2927          !strcmp(ic->iformat->name, "mpegts")) &&
2928         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2929         /* get accurate estimate from the PTSes */
2930         estimate_timings_from_pts(ic, old_offset);
2931         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2932     } else if (has_duration(ic)) {
2933         /* at least one component has timings - we use them for all
2934          * the components */
2935         fill_all_stream_timings(ic);
2936         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2937     } else {
2938         /* less precise: use bitrate info */
2939         estimate_timings_from_bit_rate(ic);
2940         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2941     }
2942     update_stream_timings(ic);
2943
2944     {
2945         int i;
2946         AVStream av_unused *st;
2947         for (i = 0; i < ic->nb_streams; i++) {
2948             st = ic->streams[i];
2949             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2950                    (double) st->start_time * av_q2d(st->time_base),
2951                    (double) st->duration   * av_q2d(st->time_base));
2952         }
2953         av_log(ic, AV_LOG_TRACE,
2954                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2955                 (double) ic->start_time / AV_TIME_BASE,
2956                 (double) ic->duration   / AV_TIME_BASE,
2957                 (int64_t)ic->bit_rate / 1000);
2958     }
2959 }
2960
2961 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2962 {
2963     AVCodecContext *avctx = st->internal->avctx;
2964
2965 #define FAIL(errmsg) do {                                         \
2966         if (errmsg_ptr)                                           \
2967             *errmsg_ptr = errmsg;                                 \
2968         return 0;                                                 \
2969     } while (0)
2970
2971     if (   avctx->codec_id == AV_CODEC_ID_NONE
2972         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2973         FAIL("unknown codec");
2974     switch (avctx->codec_type) {
2975     case AVMEDIA_TYPE_AUDIO:
2976         if (!avctx->frame_size && determinable_frame_size(avctx))
2977             FAIL("unspecified frame size");
2978         if (st->info->found_decoder >= 0 &&
2979             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2980             FAIL("unspecified sample format");
2981         if (!avctx->sample_rate)
2982             FAIL("unspecified sample rate");
2983         if (!avctx->channels)
2984             FAIL("unspecified number of channels");
2985         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2986             FAIL("no decodable DTS frames");
2987         break;
2988     case AVMEDIA_TYPE_VIDEO:
2989         if (!avctx->width)
2990             FAIL("unspecified size");
2991         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2992             FAIL("unspecified pixel format");
2993         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2994             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2995                 FAIL("no frame in rv30/40 and no sar");
2996         break;
2997     case AVMEDIA_TYPE_SUBTITLE:
2998         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2999             FAIL("unspecified size");
3000         break;
3001     case AVMEDIA_TYPE_DATA:
3002         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3003     }
3004
3005     return 1;
3006 }
3007
3008 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3009 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
3010                             AVDictionary **options)
3011 {
3012     AVCodecContext *avctx = st->internal->avctx;
3013     const AVCodec *codec;
3014     int got_picture = 1, ret = 0;
3015     AVFrame *frame = av_frame_alloc();
3016     AVSubtitle subtitle;
3017     AVPacket pkt = *avpkt;
3018     int do_skip_frame = 0;
3019     enum AVDiscard skip_frame;
3020
3021     if (!frame)
3022         return AVERROR(ENOMEM);
3023
3024     if (!avcodec_is_open(avctx) &&
3025         st->info->found_decoder <= 0 &&
3026         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3027         AVDictionary *thread_opt = NULL;
3028
3029         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3030
3031         if (!codec) {
3032             st->info->found_decoder = -st->codecpar->codec_id;
3033             ret                     = -1;
3034             goto fail;
3035         }
3036
3037         /* Force thread count to 1 since the H.264 decoder will not extract
3038          * SPS and PPS to extradata during multi-threaded decoding. */
3039         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3040         if (s->codec_whitelist)
3041             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3042         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3043         if (!options)
3044             av_dict_free(&thread_opt);
3045         if (ret < 0) {
3046             st->info->found_decoder = -avctx->codec_id;
3047             goto fail;
3048         }
3049         st->info->found_decoder = 1;
3050     } else if (!st->info->found_decoder)
3051         st->info->found_decoder = 1;
3052
3053     if (st->info->found_decoder < 0) {
3054         ret = -1;
3055         goto fail;
3056     }
3057
3058     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3059         do_skip_frame = 1;
3060         skip_frame = avctx->skip_frame;
3061         avctx->skip_frame = AVDISCARD_ALL;
3062     }
3063
3064     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3065            ret >= 0 &&
3066            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3067             (!st->codec_info_nb_frames &&
3068              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3069         got_picture = 0;
3070         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3071             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3072             ret = avcodec_send_packet(avctx, &pkt);
3073             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3074                 break;
3075             if (ret >= 0)
3076                 pkt.size = 0;
3077             ret = avcodec_receive_frame(avctx, frame);
3078             if (ret >= 0)
3079                 got_picture = 1;
3080             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3081                 ret = 0;
3082         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3083             ret = avcodec_decode_subtitle2(avctx, &subtitle,
3084                                            &got_picture, &pkt);
3085             if (ret >= 0)
3086                 pkt.size = 0;
3087         }
3088         if (ret >= 0) {
3089             if (got_picture)
3090                 st->nb_decoded_frames++;
3091             ret       = got_picture;
3092         }
3093     }
3094
3095     if (!pkt.data && !got_picture)
3096         ret = -1;
3097
3098 fail:
3099     if (do_skip_frame) {
3100         avctx->skip_frame = skip_frame;
3101     }
3102
3103     av_frame_free(&frame);
3104     return ret;
3105 }
3106
3107 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3108 {
3109     while (tags->id != AV_CODEC_ID_NONE) {
3110         if (tags->id == id)
3111             return tags->tag;
3112         tags++;
3113     }
3114     return 0;
3115 }
3116
3117 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3118 {
3119     int i;
3120     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3121         if (tag == tags[i].tag)
3122             return tags[i].id;
3123     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3124         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3125             return tags[i].id;
3126     return AV_CODEC_ID_NONE;
3127 }
3128
3129 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3130 {
3131     if (bps <= 0 || bps > 64)
3132         return AV_CODEC_ID_NONE;
3133
3134     if (flt) {
3135         switch (bps) {
3136         case 32:
3137             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3138         case 64:
3139             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3140         default:
3141             return AV_CODEC_ID_NONE;
3142         }
3143     } else {
3144         bps  += 7;
3145         bps >>= 3;
3146         if (sflags & (1 << (bps - 1))) {
3147             switch (bps) {
3148             case 1:
3149                 return AV_CODEC_ID_PCM_S8;
3150             case 2:
3151                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3152             case 3:
3153                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3154             case 4:
3155                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3156             case 8:
3157                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3158             default:
3159                 return AV_CODEC_ID_NONE;
3160             }
3161         } else {
3162             switch (bps) {
3163             case 1:
3164                 return AV_CODEC_ID_PCM_U8;
3165             case 2:
3166                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3167             case 3:
3168                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3169             case 4:
3170                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3171             default:
3172                 return AV_CODEC_ID_NONE;
3173             }
3174         }
3175     }
3176 }
3177
3178 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3179 {
3180     unsigned int tag;
3181     if (!av_codec_get_tag2(tags, id, &tag))
3182         return 0;
3183     return tag;
3184 }
3185
3186 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3187                       unsigned int *tag)
3188 {
3189     int i;
3190     for (i = 0; tags && tags[i]; i++) {
3191         const AVCodecTag *codec_tags = tags[i];
3192         while (codec_tags->id != AV_CODEC_ID_NONE) {
3193             if (codec_tags->id == id) {
3194                 *tag = codec_tags->tag;
3195                 return 1;
3196             }
3197             codec_tags++;
3198         }
3199     }
3200     return 0;
3201 }
3202
3203 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3204 {
3205     int i;
3206     for (i = 0; tags && tags[i]; i++) {
3207         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3208         if (id != AV_CODEC_ID_NONE)
3209             return id;
3210     }
3211     return AV_CODEC_ID_NONE;
3212 }
3213
3214 static void compute_chapters_end(AVFormatContext *s)
3215 {
3216     unsigned int i, j;
3217     int64_t max_time = 0;
3218
3219     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3220         max_time = s->duration +
3221                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3222
3223     for (i = 0; i < s->nb_chapters; i++)
3224         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3225             AVChapter *ch = s->chapters[i];
3226             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3227                                                   ch->time_base)
3228                                    : INT64_MAX;
3229
3230             for (j = 0; j < s->nb_chapters; j++) {
3231                 AVChapter *ch1     = s->chapters[j];
3232                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3233                                                   ch->time_base);
3234                 if (j != i && next_start > ch->start && next_start < end)
3235                     end = next_start;
3236             }
3237             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3238         }
3239 }
3240
3241 static int get_std_framerate(int i)
3242 {
3243     if (i < 30*12)
3244         return (i + 1) * 1001;
3245     i -= 30*12;
3246
3247     if (i < 30)
3248         return (i + 31) * 1001 * 12;
3249     i -= 30;
3250
3251     if (i < 3)
3252         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3253
3254     i -= 3;
3255
3256     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3257 }
3258
3259 /* Is the time base unreliable?
3260  * This is a heuristic to balance between quick acceptance of the values in
3261  * the headers vs. some extra checks.
3262  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3263  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3264  * And there are "variable" fps files this needs to detect as well. */
3265 static int tb_unreliable(AVCodecContext *c)
3266 {
3267     if (c->time_base.den >= 101LL * c->time_base.num ||
3268         c->time_base.den <    5LL * c->time_base.num ||
3269         // c->codec_tag == AV_RL32("DIVX") ||
3270         // c->codec_tag == AV_RL32("XVID") ||
3271         c->codec_tag == AV_RL32("mp4v") ||
3272         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3273         c->codec_id == AV_CODEC_ID_GIF ||
3274         c->codec_id == AV_CODEC_ID_HEVC ||
3275         c->codec_id == AV_CODEC_ID_H264)
3276         return 1;
3277     return 0;
3278 }
3279
3280 int ff_alloc_extradata(AVCodecParameters *par, int size)
3281 {
3282     av_freep(&par->extradata);
3283     par->extradata_size = 0;
3284
3285     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3286         return AVERROR(EINVAL);
3287
3288     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3289     if (!par->extradata)
3290         return AVERROR(ENOMEM);
3291
3292     memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3293     par->extradata_size = size;
3294
3295     return 0;
3296 }
3297
3298 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3299 {
3300     int ret = ff_alloc_extradata(par, size);
3301     if (ret < 0)
3302         return ret;
3303     ret = avio_read(pb, par->extradata, size);
3304     if (ret != size) {
3305         av_freep(&par->extradata);
3306         par->extradata_size = 0;
3307         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3308         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3309     }
3310
3311     return ret;
3312 }
3313
3314 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3315 {
3316     int i, j;
3317     int64_t last = st->info->last_dts;
3318
3319     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3320        && ts - (uint64_t)last < INT64_MAX) {
3321         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3322         int64_t duration = ts - last;
3323
3324         if (!st->info->duration_error)
3325             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3326         if (!st->info->duration_error)
3327             return AVERROR(ENOMEM);
3328
3329 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3330 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3331         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3332             if (st->info->duration_error[0][1][i] < 1e10) {
3333                 int framerate = get_std_framerate(i);
3334                 double sdts = dts*framerate/(1001*12);
3335                 for (j= 0; j<2; j++) {
3336                     int64_t ticks = llrint(sdts+j*0.5);
3337                     double error= sdts - ticks + j*0.5;
3338                     st->info->duration_error[j][0][i] += error;
3339                     st->info->duration_error[j][1][i] += error*error;
3340                 }
3341             }
3342         }
3343         st->info->duration_count++;
3344         st->info->rfps_duration_sum += duration;
3345
3346         if (st->info->duration_count % 10 == 0) {
3347             int n = st->info->duration_count;
3348             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3349                 if (st->info->duration_error[0][1][i] < 1e10) {
3350                     double a0     = st->info->duration_error[0][0][i] / n;
3351                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3352                     double a1     = st->info->duration_error[1][0][i] / n;
3353                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3354                     if (error0 > 0.04 && error1 > 0.04) {
3355                         st->info->duration_error[0][1][i] = 2e10;
3356                         st->info->duration_error[1][1][i] = 2e10;
3357                     }
3358                 }
3359             }
3360         }
3361
3362         // ignore the first 4 values, they might have some random jitter
3363         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3364             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3365     }
3366     if (ts != AV_NOPTS_VALUE)
3367         st->info->last_dts = ts;
3368
3369     return 0;
3370 }
3371
3372 void ff_rfps_calculate(AVFormatContext *ic)
3373 {
3374     int i, j;
3375
3376     for (i = 0; i < ic->nb_streams; i++) {
3377         AVStream *st = ic->streams[i];
3378
3379         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3380             continue;
3381         // the check for tb_unreliable() is not completely correct, since this is not about handling
3382         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3383         // ipmovie.c produces.
3384         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)
3385             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);
3386         if (st->info->duration_count>1 && !st->r_frame_rate.num
3387             && tb_unreliable(st->internal->avctx)) {
3388             int num = 0;
3389             double best_error= 0.01;
3390             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3391
3392             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3393                 int k;
3394
3395                 if (st->info->codec_info_duration &&
3396                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3397                     continue;
3398                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3399                     continue;
3400
3401                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3402                     continue;
3403
3404                 for (k= 0; k<2; k++) {
3405                     int n = st->info->duration_count;
3406                     double a= st->info->duration_error[k][0][j] / n;
3407                     double error= st->info->duration_error[k][1][j]/n - a*a;
3408
3409                     if (error < best_error && best_error> 0.000000001) {
3410                         best_error= error;
3411                         num = get_std_framerate(j);
3412                     }
3413                     if (error < 0.02)
3414                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3415                 }
3416             }
3417             // do not increase frame rate by more than 1 % in order to match a standard rate.
3418             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3419                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3420         }
3421         if (   !st->avg_frame_rate.num
3422             && st->r_frame_rate.num && st->info->rfps_duration_sum
3423             && st->info->codec_info_duration <= 0
3424             && st->info->duration_count > 2
3425             && 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
3426             ) {
3427             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3428             st->avg_frame_rate = st->r_frame_rate;
3429         }
3430
3431         av_freep(&st->info->duration_error);
3432         st->info->last_dts = AV_NOPTS_VALUE;
3433         st->info->duration_count = 0;
3434         st->info->rfps_duration_sum = 0;
3435     }
3436 }
3437
3438 static int extract_extradata_check(AVStream *st)
3439 {
3440     const AVBitStreamFilter *f;
3441
3442     f = av_bsf_get_by_name("extract_extradata");
3443     if (!f)
3444         return 0;
3445
3446     if (f->codec_ids) {
3447         const enum AVCodecID *ids;
3448         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3449             if (*ids == st->codecpar->codec_id)
3450                 return 1;
3451     }
3452
3453     return 0;
3454 }
3455
3456 static int extract_extradata_init(AVStream *st)
3457 {
3458     AVStreamInternal *i = st->internal;
3459     const AVBitStreamFilter *f;
3460     int ret;
3461
3462     f = av_bsf_get_by_name("extract_extradata");
3463     if (!f)
3464         goto finish;
3465
3466     /* check that the codec id is supported */
3467     ret = extract_extradata_check(st);
3468     if (!ret)
3469         goto finish;
3470
3471     i->extract_extradata.pkt = av_packet_alloc();
3472     if (!i->extract_extradata.pkt)
3473         return AVERROR(ENOMEM);
3474
3475     ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3476     if (ret < 0)
3477         goto fail;
3478
3479     ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3480                                   st->codecpar);
3481     if (ret < 0)
3482         goto fail;
3483
3484     i->extract_extradata.bsf->time_base_in = st->time_base;
3485
3486     /* if init fails here, we assume extracting extradata is just not
3487      * supported for this codec, so we return success */
3488     ret = av_bsf_init(i->extract_extradata.bsf);
3489     if (ret < 0) {
3490         av_bsf_free(&i->extract_extradata.bsf);
3491         ret = 0;
3492     }
3493
3494 finish:
3495     i->extract_extradata.inited = 1;
3496
3497     return 0;
3498 fail:
3499     av_bsf_free(&i->extract_extradata.bsf);
3500     av_packet_free(&i->extract_extradata.pkt);
3501     return ret;
3502 }
3503
3504 static int extract_extradata(AVStream *st, AVPacket *pkt)
3505 {
3506     AVStreamInternal *i = st->internal;
3507     AVPacket *pkt_ref;
3508     int ret;
3509
3510     if (!i->extract_extradata.inited) {
3511         ret = extract_extradata_init(st);
3512         if (ret < 0)
3513             return ret;
3514     }
3515
3516     if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3517         return 0;
3518
3519     pkt_ref = i->extract_extradata.pkt;
3520     ret = av_packet_ref(pkt_ref, pkt);
3521     if (ret < 0)
3522         return ret;
3523
3524     ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3525     if (ret < 0) {
3526         av_packet_unref(pkt_ref);
3527         return ret;
3528     }
3529
3530     while (ret >= 0 && !i->avctx->extradata) {
3531         int extradata_size;
3532         uint8_t *extradata;
3533
3534         ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3535         if (ret < 0) {
3536             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3537                 return ret;
3538             continue;
3539         }
3540
3541         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3542                                             &extradata_size);
3543
3544         if (extradata) {
3545             i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3546             if (!i->avctx->extradata) {
3547                 av_packet_unref(pkt_ref);
3548                 return AVERROR(ENOMEM);
3549             }
3550             memcpy(i->avctx->extradata, extradata, extradata_size);
3551             i->avctx->extradata_size = extradata_size;
3552         }
3553         av_packet_unref(pkt_ref);
3554     }
3555
3556     return 0;
3557 }
3558
3559 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3560 {
3561     int i, count = 0, ret = 0, j;
3562     int64_t read_size;
3563     AVStream *st;
3564     AVCodecContext *avctx;
3565     AVPacket pkt1, *pkt;
3566     int64_t old_offset  = avio_tell(ic->pb);
3567     // new streams might appear, no options for those
3568     int orig_nb_streams = ic->nb_streams;
3569     int flush_codecs;
3570     int64_t max_analyze_duration = ic->max_analyze_duration;
3571     int64_t max_stream_analyze_duration;
3572     int64_t max_subtitle_analyze_duration;
3573     int64_t probesize = ic->probesize;
3574     int eof_reached = 0;
3575     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3576
3577     flush_codecs = probesize > 0;
3578
3579     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3580
3581     max_stream_analyze_duration = max_analyze_duration;
3582     max_subtitle_analyze_duration = max_analyze_duration;
3583     if (!max_analyze_duration) {
3584         max_stream_analyze_duration =
3585         max_analyze_duration        = 5*AV_TIME_BASE;
3586         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3587         if (!strcmp(ic->iformat->name, "flv"))
3588             max_stream_analyze_duration = 90*AV_TIME_BASE;
3589         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3590             max_stream_analyze_duration = 7*AV_TIME_BASE;
3591     }
3592
3593     if (ic->pb)
3594         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3595                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3596
3597     for (i = 0; i < ic->nb_streams; i++) {
3598         const AVCodec *codec;
3599         AVDictionary *thread_opt = NULL;
3600         st = ic->streams[i];
3601         avctx = st->internal->avctx;
3602
3603         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3604             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3605 /*            if (!st->time_base.num)
3606                 st->time_base = */
3607             if (!avctx->time_base.num)
3608                 avctx->time_base = st->time_base;
3609         }
3610
3611         /* check if the caller has overridden the codec id */
3612 #if FF_API_LAVF_AVCTX
3613 FF_DISABLE_DEPRECATION_WARNINGS
3614         if (st->codec->codec_id != st->internal->orig_codec_id) {
3615             st->codecpar->codec_id   = st->codec->codec_id;
3616             st->codecpar->codec_type = st->codec->codec_type;
3617             st->internal->orig_codec_id = st->codec->codec_id;
3618         }
3619 FF_ENABLE_DEPRECATION_WARNINGS
3620 #endif
3621         // only for the split stuff
3622         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3623             st->parser = av_parser_init(st->codecpar->codec_id);
3624             if (st->parser) {
3625                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3626                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3627                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3628                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3629                 }
3630             } else if (st->need_parsing) {
3631                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3632                        "%s, packets or times may be invalid.\n",
3633                        avcodec_get_name(st->codecpar->codec_id));
3634             }
3635         }
3636
3637         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3638             st->internal->orig_codec_id = st->codecpar->codec_id;
3639
3640         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3641         if (ret < 0)
3642             goto find_stream_info_err;
3643         if (st->request_probe <= 0)
3644             st->internal->avctx_inited = 1;
3645
3646         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3647
3648         /* Force thread count to 1 since the H.264 decoder will not extract
3649          * SPS and PPS to extradata during multi-threaded decoding. */
3650         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3651
3652         if (ic->codec_whitelist)
3653             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3654
3655         /* Ensure that subtitle_header is properly set. */
3656         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3657             && codec && !avctx->codec) {
3658             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3659                 av_log(ic, AV_LOG_WARNING,
3660                        "Failed to open codec in %s\n",__FUNCTION__);
3661         }
3662
3663         // Try to just open decoders, in case this is enough to get parameters.
3664         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3665             if (codec && !avctx->codec)
3666                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3667                     av_log(ic, AV_LOG_WARNING,
3668                            "Failed to open codec in %s\n",__FUNCTION__);
3669         }
3670         if (!options)
3671             av_dict_free(&thread_opt);
3672     }
3673
3674     for (i = 0; i < ic->nb_streams; i++) {
3675 #if FF_API_R_FRAME_RATE
3676         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3677 #endif
3678         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3679         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3680     }
3681
3682     read_size = 0;
3683     for (;;) {
3684         int analyzed_all_streams;
3685         if (ff_check_interrupt(&ic->interrupt_callback)) {
3686             ret = AVERROR_EXIT;
3687             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3688             break;
3689         }
3690
3691         /* check if one codec still needs to be handled */
3692         for (i = 0; i < ic->nb_streams; i++) {
3693             int fps_analyze_framecount = 20;
3694             int count;
3695
3696             st = ic->streams[i];
3697             if (!has_codec_parameters(st, NULL))
3698                 break;
3699             /* If the timebase is coarse (like the usual millisecond precision
3700              * of mkv), we need to analyze more frames to reliably arrive at
3701              * the correct fps. */
3702             if (av_q2d(st->time_base) > 0.0005)
3703                 fps_analyze_framecount *= 2;
3704             if (!tb_unreliable(st->internal->avctx))
3705                 fps_analyze_framecount = 0;
3706             if (ic->fps_probe_size >= 0)
3707                 fps_analyze_framecount = ic->fps_probe_size;
3708             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3709                 fps_analyze_framecount = 0;
3710             /* variable fps and no guess at the real fps */
3711             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3712                        st->info->codec_info_duration_fields/2 :
3713                        st->info->duration_count;
3714             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3715                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3716                 if (count < fps_analyze_framecount)
3717                     break;
3718             }
3719             // Look at the first 3 frames if there is evidence of frame delay
3720             // but the decoder delay is not set.
3721             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3722                 break;
3723             if (!st->internal->avctx->extradata &&
3724                 (!st->internal->extract_extradata.inited ||
3725                  st->internal->extract_extradata.bsf) &&
3726                 extract_extradata_check(st))
3727                 break;
3728             if (st->first_dts == AV_NOPTS_VALUE &&
3729                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3730                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3731                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3732                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3733                 break;
3734         }
3735         analyzed_all_streams = 0;
3736         if (!missing_streams || !*missing_streams)
3737         if (i == ic->nb_streams) {
3738             analyzed_all_streams = 1;
3739             /* NOTE: If the format has no header, then we need to read some
3740              * packets to get most of the streams, so we cannot stop here. */
3741             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3742                 /* If we found the info for all the codecs, we can stop. */
3743                 ret = count;
3744                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3745                 flush_codecs = 0;
3746                 break;
3747             }
3748         }
3749         /* We did not get all the codec info, but we read too much data. */
3750         if (read_size >= probesize) {
3751             ret = count;
3752             av_log(ic, AV_LOG_DEBUG,
3753                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3754             for (i = 0; i < ic->nb_streams; i++)
3755                 if (!ic->streams[i]->r_frame_rate.num &&
3756                     ic->streams[i]->info->duration_count <= 1 &&
3757                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3758                     strcmp(ic->iformat->name, "image2"))
3759                     av_log(ic, AV_LOG_WARNING,
3760                            "Stream #%d: not enough frames to estimate rate; "
3761                            "consider increasing probesize\n", i);
3762             break;
3763         }
3764
3765         /* NOTE: A new stream can be added there if no header in file
3766          * (AVFMTCTX_NOHEADER). */
3767         ret = read_frame_internal(ic, &pkt1);
3768         if (ret == AVERROR(EAGAIN))
3769             continue;
3770
3771         if (ret < 0) {
3772             /* EOF or error*/
3773             eof_reached = 1;
3774             break;
3775         }
3776
3777         pkt = &pkt1;
3778
3779         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3780             ret = ff_packet_list_put(&ic->internal->packet_buffer,
3781                                      &ic->internal->packet_buffer_end,
3782                                      pkt, 0);
3783             if (ret < 0)
3784                 goto find_stream_info_err;
3785         }
3786
3787         st = ic->streams[pkt->stream_index];
3788         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3789             read_size += pkt->size;
3790
3791         avctx = st->internal->avctx;
3792         if (!st->internal->avctx_inited) {
3793             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3794             if (ret < 0)
3795                 goto find_stream_info_err;
3796             st->internal->avctx_inited = 1;
3797         }
3798
3799         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3800             /* check for non-increasing dts */
3801             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3802                 st->info->fps_last_dts >= pkt->dts) {
3803                 av_log(ic, AV_LOG_DEBUG,
3804                        "Non-increasing DTS in stream %d: packet %d with DTS "
3805                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3806                        st->index, st->info->fps_last_dts_idx,
3807                        st->info->fps_last_dts, st->codec_info_nb_frames,
3808                        pkt->dts);
3809                 st->info->fps_first_dts =
3810                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3811             }
3812             /* Check for a discontinuity in dts. If the difference in dts
3813              * is more than 1000 times the average packet duration in the
3814              * sequence, we treat it as a discontinuity. */
3815             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3816                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3817                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3818                 (st->info->fps_last_dts     - (uint64_t)st->info->fps_first_dts) /
3819                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3820                 av_log(ic, AV_LOG_WARNING,
3821                        "DTS discontinuity in stream %d: packet %d with DTS "
3822                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3823                        st->index, st->info->fps_last_dts_idx,
3824                        st->info->fps_last_dts, st->codec_info_nb_frames,
3825                        pkt->dts);
3826                 st->info->fps_first_dts =
3827                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3828             }
3829
3830             /* update stored dts values */
3831             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3832                 st->info->fps_first_dts     = pkt->dts;
3833                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3834             }
3835             st->info->fps_last_dts     = pkt->dts;
3836             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3837         }
3838         if (st->codec_info_nb_frames>1) {
3839             int64_t t = 0;
3840             int64_t limit;
3841
3842             if (st->time_base.den > 0)
3843                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3844             if (st->avg_frame_rate.num > 0)
3845                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3846
3847             if (   t == 0
3848                 && st->codec_info_nb_frames>30
3849                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3850                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3851                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3852
3853             if (analyzed_all_streams)                                limit = max_analyze_duration;
3854             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3855             else                                                     limit = max_stream_analyze_duration;
3856
3857             if (t >= limit) {
3858                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3859                        limit,
3860                        t, pkt->stream_index);
3861                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3862                     av_packet_unref(pkt);
3863                 break;
3864             }
3865             if (pkt->duration) {
3866                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3867                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3868                 } else
3869                     st->info->codec_info_duration += pkt->duration;
3870                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3871             }
3872         }
3873         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3874 #if FF_API_R_FRAME_RATE
3875             ff_rfps_add_frame(ic, st, pkt->dts);
3876 #endif
3877             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3878                 st->info->frame_delay_evidence = 1;
3879         }
3880         if (!st->internal->avctx->extradata) {
3881             ret = extract_extradata(st, pkt);
3882             if (ret < 0)
3883                 goto find_stream_info_err;
3884         }
3885
3886         /* If still no information, we try to open the codec and to
3887          * decompress the frame. We try to avoid that in most cases as
3888          * it takes longer and uses more memory. For MPEG-4, we need to
3889          * decompress for QuickTime.
3890          *
3891          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3892          * least one frame of codec data, this makes sure the codec initializes
3893          * the channel configuration and does not only trust the values from
3894          * the container. */
3895         try_decode_frame(ic, st, pkt,
3896                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3897
3898         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3899             av_packet_unref(pkt);
3900
3901         st->codec_info_nb_frames++;
3902         count++;
3903     }
3904
3905     if (eof_reached) {
3906         int stream_index;
3907         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3908             st = ic->streams[stream_index];
3909             avctx = st->internal->avctx;
3910             if (!has_codec_parameters(st, NULL)) {
3911                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3912                 if (codec && !avctx->codec) {
3913                     AVDictionary *opts = NULL;
3914                     if (ic->codec_whitelist)
3915                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3916                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3917                         av_log(ic, AV_LOG_WARNING,
3918                                "Failed to open codec in %s\n",__FUNCTION__);
3919                     av_dict_free(&opts);
3920                 }
3921             }
3922
3923             // EOF already reached while reading the stream above.
3924             // So continue with reoordering DTS with whatever delay we have.
3925             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3926                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3927             }
3928         }
3929     }
3930
3931     if (flush_codecs) {
3932         AVPacket empty_pkt = { 0 };
3933         int err = 0;
3934         av_init_packet(&empty_pkt);
3935
3936         for (i = 0; i < ic->nb_streams; i++) {
3937
3938             st = ic->streams[i];
3939
3940             /* flush the decoders */
3941             if (st->info->found_decoder == 1) {
3942                 do {
3943                     err = try_decode_frame(ic, st, &empty_pkt,
3944                                             (options && i < orig_nb_streams)
3945                                             ? &options[i] : NULL);
3946                 } while (err > 0 && !has_codec_parameters(st, NULL));
3947
3948                 if (err < 0) {
3949                     av_log(ic, AV_LOG_INFO,
3950                         "decoding for stream %d failed\n", st->index);
3951                 }
3952             }
3953         }
3954     }
3955
3956     ff_rfps_calculate(ic);
3957
3958     for (i = 0; i < ic->nb_streams; i++) {
3959         st = ic->streams[i];
3960         avctx = st->internal->avctx;
3961         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3962             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3963                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3964                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3965                     avctx->codec_tag= tag;
3966             }
3967
3968             /* estimate average framerate if not set by demuxer */
3969             if (st->info->codec_info_duration_fields &&
3970                 !st->avg_frame_rate.num &&
3971                 st->info->codec_info_duration) {
3972                 int best_fps      = 0;
3973                 double best_error = 0.01;
3974                 AVRational codec_frame_rate = avctx->framerate;
3975
3976                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3977                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3978                     st->info->codec_info_duration        < 0)
3979                     continue;
3980                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3981                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3982                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3983
3984                 /* Round guessed framerate to a "standard" framerate if it's
3985                  * within 1% of the original estimate. */
3986                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3987                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3988                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3989                                               av_q2d(std_fps) - 1);
3990
3991                     if (error < best_error) {
3992                         best_error = error;
3993                         best_fps   = std_fps.num;
3994                     }
3995
3996                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3997                         error       = fabs(av_q2d(codec_frame_rate) /
3998                                            av_q2d(std_fps) - 1);
3999                         if (error < best_error) {
4000                             best_error = error;
4001                             best_fps   = std_fps.num;
4002                         }
4003                     }
4004                 }
4005                 if (best_fps)
4006                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4007                               best_fps, 12 * 1001, INT_MAX);
4008             }
4009
4010             if (!st->r_frame_rate.num) {
4011                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4012                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
4013                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4014                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4015                 } else {
4016                     st->r_frame_rate.num = st->time_base.den;
4017                     st->r_frame_rate.den = st->time_base.num;
4018                 }
4019             }
4020             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4021                 AVRational hw_ratio = { avctx->height, avctx->width };
4022                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4023                                                    hw_ratio);
4024             }
4025         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4026             if (!avctx->bits_per_coded_sample)
4027                 avctx->bits_per_coded_sample =
4028                     av_get_bits_per_sample(avctx->codec_id);
4029             // set stream disposition based on audio service type
4030             switch (avctx->audio_service_type) {
4031             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4032                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4033                 break;
4034             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4035                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4036                 break;
4037             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4038                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4039                 break;
4040             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4041                 st->disposition = AV_DISPOSITION_COMMENT;
4042                 break;
4043             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4044                 st->disposition = AV_DISPOSITION_KARAOKE;
4045                 break;
4046             }
4047         }
4048     }
4049
4050     if (probesize)
4051         estimate_timings(ic, old_offset);
4052
4053     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4054
4055     if (ret >= 0 && ic->nb_streams)
4056         /* We could not have all the codec parameters before EOF. */
4057         ret = -1;
4058     for (i = 0; i < ic->nb_streams; i++) {
4059         const char *errmsg;
4060         st = ic->streams[i];
4061
4062         /* if no packet was ever seen, update context now for has_codec_parameters */
4063         if (!st->internal->avctx_inited) {
4064             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4065                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4066                 st->codecpar->format = st->internal->avctx->sample_fmt;
4067             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4068             if (ret < 0)
4069                 goto find_stream_info_err;
4070         }
4071         if (!has_codec_parameters(st, &errmsg)) {
4072             char buf[256];
4073             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4074             av_log(ic, AV_LOG_WARNING,
4075                    "Could not find codec parameters for stream %d (%s): %s\n"
4076                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4077                    i, buf, errmsg);
4078         } else {
4079             ret = 0;
4080         }
4081     }
4082
4083     compute_chapters_end(ic);
4084
4085     /* update the stream parameters from the internal codec contexts */
4086     for (i = 0; i < ic->nb_streams; i++) {
4087         st = ic->streams[i];
4088
4089         if (st->internal->avctx_inited) {
4090             int orig_w = st->codecpar->width;
4091             int orig_h = st->codecpar->height;
4092             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4093             if (ret < 0)
4094                 goto find_stream_info_err;
4095 #if FF_API_LOWRES
4096             // The decoder might reduce the video size by the lowres factor.
4097             if (st->internal->avctx->lowres && orig_w) {
4098                 st->codecpar->width = orig_w;
4099                 st->codecpar->height = orig_h;
4100             }
4101 #endif
4102         }
4103
4104 #if FF_API_LAVF_AVCTX
4105 FF_DISABLE_DEPRECATION_WARNINGS
4106         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4107         if (ret < 0)
4108             goto find_stream_info_err;
4109
4110 #if FF_API_LOWRES
4111         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4112         // by the lowres factor.
4113         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4114             st->codec->lowres = st->internal->avctx->lowres;
4115             st->codec->width = st->internal->avctx->width;
4116             st->codec->height = st->internal->avctx->height;
4117         }
4118 #endif
4119
4120         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4121             st->codec->time_base = st->internal->avctx->time_base;
4122             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4123         }
4124         st->codec->framerate = st->avg_frame_rate;
4125
4126         if (st->internal->avctx->subtitle_header) {
4127             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4128             if (!st->codec->subtitle_header)
4129                 goto find_stream_info_err;
4130             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4131             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4132                    st->codec->subtitle_header_size);
4133         }
4134
4135         // Fields unavailable in AVCodecParameters
4136         st->codec->coded_width = st->internal->avctx->coded_width;
4137         st->codec->coded_height = st->internal->avctx->coded_height;
4138         st->codec->properties = st->internal->avctx->properties;
4139 FF_ENABLE_DEPRECATION_WARNINGS
4140 #endif
4141
4142         st->internal->avctx_inited = 0;
4143     }
4144
4145 find_stream_info_err:
4146     for (i = 0; i < ic->nb_streams; i++) {
4147         st = ic->streams[i];
4148         if (st->info)
4149             av_freep(&st->info->duration_error);
4150         avcodec_close(ic->streams[i]->internal->avctx);
4151         av_freep(&ic->streams[i]->info);
4152         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4153         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4154     }
4155     if (ic->pb)
4156         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4157                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4158     return ret;
4159 }
4160
4161 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4162 {
4163     int i, j;
4164
4165     for (i = 0; i < ic->nb_programs; i++) {
4166         if (ic->programs[i] == last) {
4167             last = NULL;
4168         } else {
4169             if (!last)
4170                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4171                     if (ic->programs[i]->stream_index[j] == s)
4172                         return ic->programs[i];
4173         }
4174     }
4175     return NULL;
4176 }
4177
4178 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4179                         int wanted_stream_nb, int related_stream,
4180                         AVCodec **decoder_ret, int flags)
4181 {
4182     int i, nb_streams = ic->nb_streams;
4183     int ret = AVERROR_STREAM_NOT_FOUND;
4184     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4185     int count, multiframe, disposition;
4186     int64_t best_bitrate = -1;
4187     int64_t bitrate;
4188     unsigned *program = NULL;
4189     const AVCodec *decoder = NULL, *best_decoder = NULL;
4190
4191     if (related_stream >= 0 && wanted_stream_nb < 0) {
4192         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4193         if (p) {
4194             program    = p->stream_index;
4195             nb_streams = p->nb_stream_indexes;
4196         }
4197     }
4198     for (i = 0; i < nb_streams; i++) {
4199         int real_stream_index = program ? program[i] : i;
4200         AVStream *st          = ic->streams[real_stream_index];
4201         AVCodecParameters *par = st->codecpar;
4202         if (par->codec_type != type)
4203             continue;
4204         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4205             continue;
4206         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4207             continue;
4208         if (decoder_ret) {
4209             decoder = find_decoder(ic, st, par->codec_id);
4210             if (!decoder) {
4211                 if (ret < 0)
4212                     ret = AVERROR_DECODER_NOT_FOUND;
4213                 continue;
4214             }
4215         }
4216         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4217         count = st->codec_info_nb_frames;
4218         bitrate = par->bit_rate;
4219         multiframe = FFMIN(5, count);
4220         if ((best_disposition >  disposition) ||
4221             (best_disposition == disposition && best_multiframe >  multiframe) ||
4222             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4223             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4224             continue;
4225         best_disposition = disposition;
4226         best_count   = count;
4227         best_bitrate = bitrate;
4228         best_multiframe = multiframe;
4229         ret          = real_stream_index;
4230         best_decoder = decoder;
4231         if (program && i == nb_streams - 1 && ret < 0) {
4232             program    = NULL;
4233             nb_streams = ic->nb_streams;
4234             /* no related stream found, try again with everything */
4235             i = 0;
4236         }
4237     }
4238     if (decoder_ret)
4239         *decoder_ret = (AVCodec*)best_decoder;
4240     return ret;
4241 }
4242
4243 /*******************************************************/
4244
4245 int av_read_play(AVFormatContext *s)
4246 {
4247     if (s->iformat->read_play)
4248         return s->iformat->read_play(s);
4249     if (s->pb)
4250         return avio_pause(s->pb, 0);
4251     return AVERROR(ENOSYS);
4252 }
4253
4254 int av_read_pause(AVFormatContext *s)
4255 {
4256     if (s->iformat->read_pause)
4257         return s->iformat->read_pause(s);
4258     if (s->pb)
4259         return avio_pause(s->pb, 1);
4260     return AVERROR(ENOSYS);
4261 }
4262
4263 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4264 {
4265     int ret, i;
4266
4267     dst->id                  = src->id;
4268     dst->time_base           = src->time_base;
4269     dst->nb_frames           = src->nb_frames;
4270     dst->disposition         = src->disposition;
4271     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4272     dst->avg_frame_rate      = src->avg_frame_rate;
4273     dst->r_frame_rate        = src->r_frame_rate;
4274
4275     av_dict_free(&dst->metadata);
4276     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4277     if (ret < 0)
4278         return ret;
4279
4280     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4281     if (ret < 0)
4282         return ret;
4283
4284     /* Free existing side data*/
4285     for (i = 0; i < dst->nb_side_data; i++)
4286         av_free(dst->side_data[i].data);
4287     av_freep(&dst->side_data);
4288     dst->nb_side_data = 0;
4289
4290     /* Copy side data if present */
4291     if (src->nb_side_data) {
4292         dst->side_data = av_mallocz_array(src->nb_side_data,
4293                                           sizeof(AVPacketSideData));
4294         if (!dst->side_data)
4295             return AVERROR(ENOMEM);
4296         dst->nb_side_data = src->nb_side_data;
4297
4298         for (i = 0; i < src->nb_side_data; i++) {
4299             uint8_t *data = av_memdup(src->side_data[i].data,
4300                                       src->side_data[i].size);
4301             if (!data)
4302                 return AVERROR(ENOMEM);
4303             dst->side_data[i].type = src->side_data[i].type;
4304             dst->side_data[i].size = src->side_data[i].size;
4305             dst->side_data[i].data = data;
4306         }
4307     }
4308
4309 #if FF_API_LAVF_FFSERVER
4310 FF_DISABLE_DEPRECATION_WARNINGS
4311     av_freep(&dst->recommended_encoder_configuration);
4312     if (src->recommended_encoder_configuration) {
4313         const char *conf_str = src->recommended_encoder_configuration;
4314         dst->recommended_encoder_configuration = av_strdup(conf_str);
4315         if (!dst->recommended_encoder_configuration)
4316             return AVERROR(ENOMEM);
4317     }
4318 FF_ENABLE_DEPRECATION_WARNINGS
4319 #endif
4320
4321     return 0;
4322 }
4323
4324 static void free_stream(AVStream **pst)
4325 {
4326     AVStream *st = *pst;
4327     int i;
4328
4329     if (!st)
4330         return;
4331
4332     for (i = 0; i < st->nb_side_data; i++)
4333         av_freep(&st->side_data[i].data);
4334     av_freep(&st->side_data);
4335
4336     if (st->parser)
4337         av_parser_close(st->parser);
4338
4339     if (st->attached_pic.data)
4340         av_packet_unref(&st->attached_pic);
4341
4342     if (st->internal) {
4343         avcodec_free_context(&st->internal->avctx);
4344         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4345             av_bsf_free(&st->internal->bsfcs[i]);
4346             av_freep(&st->internal->bsfcs);
4347         }
4348         av_freep(&st->internal->priv_pts);
4349         av_bsf_free(&st->internal->extract_extradata.bsf);
4350         av_packet_free(&st->internal->extract_extradata.pkt);
4351     }
4352     av_freep(&st->internal);
4353
4354     av_dict_free(&st->metadata);
4355     avcodec_parameters_free(&st->codecpar);
4356     av_freep(&st->probe_data.buf);
4357     av_freep(&st->index_entries);
4358 #if FF_API_LAVF_AVCTX
4359 FF_DISABLE_DEPRECATION_WARNINGS
4360     avcodec_free_context(&st->codec);
4361 FF_ENABLE_DEPRECATION_WARNINGS
4362 #endif
4363     av_freep(&st->priv_data);
4364     if (st->info)
4365         av_freep(&st->info->duration_error);
4366     av_freep(&st->info);
4367 #if FF_API_LAVF_FFSERVER
4368 FF_DISABLE_DEPRECATION_WARNINGS
4369     av_freep(&st->recommended_encoder_configuration);
4370 FF_ENABLE_DEPRECATION_WARNINGS
4371 #endif
4372
4373     av_freep(pst);
4374 }
4375
4376 void ff_free_stream(AVFormatContext *s, AVStream *st)
4377 {
4378     av_assert0(s->nb_streams>0);
4379     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4380
4381     free_stream(&s->streams[ --s->nb_streams ]);
4382 }
4383
4384 void avformat_free_context(AVFormatContext *s)
4385 {
4386     int i;
4387
4388     if (!s)
4389         return;
4390
4391     av_opt_free(s);
4392     if (s->iformat && s->iformat->priv_class && s->priv_data)
4393         av_opt_free(s->priv_data);
4394     if (s->oformat && s->oformat->priv_class && s->priv_data)
4395         av_opt_free(s->priv_data);
4396
4397     for (i = s->nb_streams - 1; i >= 0; i--)
4398         ff_free_stream(s, s->streams[i]);
4399
4400
4401     for (i = s->nb_programs - 1; i >= 0; i--) {
4402         av_dict_free(&s->programs[i]->metadata);
4403         av_freep(&s->programs[i]->stream_index);
4404         av_freep(&s->programs[i]);
4405     }
4406     av_freep(&s->programs);
4407     av_freep(&s->priv_data);
4408     while (s->nb_chapters--) {
4409         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4410         av_freep(&s->chapters[s->nb_chapters]);
4411     }
4412     av_freep(&s->chapters);
4413     av_dict_free(&s->metadata);
4414     av_dict_free(&s->internal->id3v2_meta);
4415     av_freep(&s->streams);
4416     flush_packet_queue(s);
4417     av_freep(&s->internal);
4418     av_freep(&s->url);
4419     av_free(s);
4420 }
4421
4422 void avformat_close_input(AVFormatContext **ps)
4423 {
4424     AVFormatContext *s;
4425     AVIOContext *pb;
4426
4427     if (!ps || !*ps)
4428         return;
4429
4430     s  = *ps;
4431     pb = s->pb;
4432
4433     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4434         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4435         pb = NULL;
4436
4437     flush_packet_queue(s);
4438
4439     if (s->iformat)
4440         if (s->iformat->read_close)
4441             s->iformat->read_close(s);
4442
4443     avformat_free_context(s);
4444
4445     *ps = NULL;
4446
4447     avio_close(pb);
4448 }
4449
4450 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4451 {
4452     AVStream *st;
4453     int i;
4454     AVStream **streams;
4455
4456     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4457         if (s->max_streams < INT_MAX/sizeof(*streams))
4458             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);
4459         return NULL;
4460     }
4461     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4462     if (!streams)
4463         return NULL;
4464     s->streams = streams;
4465
4466     st = av_mallocz(sizeof(AVStream));
4467     if (!st)
4468         return NULL;
4469     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4470         av_free(st);
4471         return NULL;
4472     }
4473     st->info->last_dts = AV_NOPTS_VALUE;
4474
4475 #if FF_API_LAVF_AVCTX
4476 FF_DISABLE_DEPRECATION_WARNINGS
4477     st->codec = avcodec_alloc_context3(c);
4478     if (!st->codec) {
4479         av_free(st->info);
4480         av_free(st);
4481         return NULL;
4482     }
4483 FF_ENABLE_DEPRECATION_WARNINGS
4484 #endif
4485
4486     st->internal = av_mallocz(sizeof(*st->internal));
4487     if (!st->internal)
4488         goto fail;
4489
4490     st->codecpar = avcodec_parameters_alloc();
4491     if (!st->codecpar)
4492         goto fail;
4493
4494     st->internal->avctx = avcodec_alloc_context3(NULL);
4495     if (!st->internal->avctx)
4496         goto fail;
4497
4498     if (s->iformat) {
4499 #if FF_API_LAVF_AVCTX
4500 FF_DISABLE_DEPRECATION_WARNINGS
4501         /* no default bitrate if decoding */
4502         st->codec->bit_rate = 0;
4503 FF_ENABLE_DEPRECATION_WARNINGS
4504 #endif
4505
4506         /* default pts setting is MPEG-like */
4507         avpriv_set_pts_info(st, 33, 1, 90000);
4508         /* we set the current DTS to 0 so that formats without any timestamps
4509          * but durations get some timestamps, formats with some unknown
4510          * timestamps have their first few packets buffered and the
4511          * timestamps corrected before they are returned to the user */
4512         st->cur_dts = RELATIVE_TS_BASE;
4513     } else {
4514         st->cur_dts = AV_NOPTS_VALUE;
4515     }
4516
4517     st->index      = s->nb_streams;
4518     st->start_time = AV_NOPTS_VALUE;
4519     st->duration   = AV_NOPTS_VALUE;
4520     st->first_dts     = AV_NOPTS_VALUE;
4521     st->probe_packets = MAX_PROBE_PACKETS;
4522     st->pts_wrap_reference = AV_NOPTS_VALUE;
4523     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4524
4525     st->last_IP_pts = AV_NOPTS_VALUE;
4526     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4527     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4528         st->pts_buffer[i] = AV_NOPTS_VALUE;
4529
4530     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4531
4532 #if FF_API_R_FRAME_RATE
4533     st->info->last_dts      = AV_NOPTS_VALUE;
4534 #endif
4535     st->info->fps_first_dts = AV_NOPTS_VALUE;
4536     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4537
4538     st->inject_global_side_data = s->internal->inject_global_side_data;
4539
4540     st->internal->need_context_update = 1;
4541
4542     s->streams[s->nb_streams++] = st;
4543     return st;
4544 fail:
4545     free_stream(&st);
4546     return NULL;
4547 }
4548
4549 AVProgram *av_new_program(AVFormatContext *ac, int id)
4550 {
4551     AVProgram *program = NULL;
4552     int i;
4553
4554     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4555
4556     for (i = 0; i < ac->nb_programs; i++)
4557         if (ac->programs[i]->id == id)
4558             program = ac->programs[i];
4559
4560     if (!program) {
4561         program = av_mallocz(sizeof(AVProgram));
4562         if (!program)
4563             return NULL;
4564         dynarray_add(&ac->programs, &ac->nb_programs, program);
4565         program->discard = AVDISCARD_NONE;
4566     }
4567     program->id = id;
4568     program->pts_wrap_reference = AV_NOPTS_VALUE;
4569     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4570
4571     program->start_time =
4572     program->end_time   = AV_NOPTS_VALUE;
4573
4574     return program;
4575 }
4576
4577 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4578                               int64_t start, int64_t end, const char *title)
4579 {
4580     AVChapter *chapter = NULL;
4581     int i;
4582
4583     if (end != AV_NOPTS_VALUE && start > end) {
4584         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4585         return NULL;
4586     }
4587
4588     for (i = 0; i < s->nb_chapters; i++)
4589         if (s->chapters[i]->id == id)
4590             chapter = s->chapters[i];
4591
4592     if (!chapter) {
4593         chapter = av_mallocz(sizeof(AVChapter));
4594         if (!chapter)
4595             return NULL;
4596         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4597     }
4598     av_dict_set(&chapter->metadata, "title", title, 0);
4599     chapter->id        = id;
4600     chapter->time_base = time_base;
4601     chapter->start     = start;
4602     chapter->end       = end;
4603
4604     return chapter;
4605 }
4606
4607 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4608 {
4609     int i, j;
4610     AVProgram *program = NULL;
4611     void *tmp;
4612
4613     if (idx >= ac->nb_streams) {
4614         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4615         return;
4616     }
4617
4618     for (i = 0; i < ac->nb_programs; i++) {
4619         if (ac->programs[i]->id != progid)
4620             continue;
4621         program = ac->programs[i];
4622         for (j = 0; j < program->nb_stream_indexes; j++)
4623             if (program->stream_index[j] == idx)
4624                 return;
4625
4626         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4627         if (!tmp)
4628             return;
4629         program->stream_index = tmp;
4630         program->stream_index[program->nb_stream_indexes++] = idx;
4631         return;
4632     }
4633 }
4634
4635 uint64_t ff_ntp_time(void)
4636 {
4637     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4638 }
4639
4640 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4641 {
4642     const char *p;
4643     char *q, buf1[20], c;
4644     int nd, len, percentd_found;
4645
4646     q = buf;
4647     p = path;
4648     percentd_found = 0;
4649     for (;;) {
4650         c = *p++;
4651         if (c == '\0')
4652             break;
4653         if (c == '%') {
4654             do {
4655                 nd = 0;
4656                 while (av_isdigit(*p))
4657                     nd = nd * 10 + *p++ - '0';
4658                 c = *p++;
4659             } while (av_isdigit(c));
4660
4661             switch (c) {
4662             case '%':
4663                 goto addchar;
4664             case 'd':
4665                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4666                     goto fail;
4667                 percentd_found = 1;
4668                 if (number < 0)
4669                     nd += 1;
4670                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4671                 len = strlen(buf1);
4672                 if ((q - buf + len) > buf_size - 1)
4673                     goto fail;
4674                 memcpy(q, buf1, len);
4675                 q += len;
4676                 break;
4677             default:
4678                 goto fail;
4679             }
4680         } else {
4681 addchar:
4682             if ((q - buf) < buf_size - 1)
4683                 *q++ = c;
4684         }
4685     }
4686     if (!percentd_found)
4687         goto fail;
4688     *q = '\0';
4689     return 0;
4690 fail:
4691     *q = '\0';
4692     return -1;
4693 }
4694
4695 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4696 {
4697     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4698 }
4699
4700 void av_url_split(char *proto, int proto_size,
4701                   char *authorization, int authorization_size,
4702                   char *hostname, int hostname_size,
4703                   int *port_ptr, char *path, int path_size, const char *url)
4704 {
4705     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4706
4707     if (port_ptr)
4708         *port_ptr = -1;
4709     if (proto_size > 0)
4710         proto[0] = 0;
4711     if (authorization_size > 0)
4712         authorization[0] = 0;
4713     if (hostname_size > 0)
4714         hostname[0] = 0;
4715     if (path_size > 0)
4716         path[0] = 0;
4717
4718     /* parse protocol */
4719     if ((p = strchr(url, ':'))) {
4720         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4721         p++; /* skip ':' */
4722         if (*p == '/')
4723             p++;
4724         if (*p == '/')
4725             p++;
4726     } else {
4727         /* no protocol means plain filename */
4728         av_strlcpy(path, url, path_size);
4729         return;
4730     }
4731
4732     /* separate path from hostname */
4733     ls = strchr(p, '/');
4734     ls2 = strchr(p, '?');
4735     if (!ls)
4736         ls = ls2;
4737     else if (ls && ls2)
4738         ls = FFMIN(ls, ls2);
4739     if (ls)
4740         av_strlcpy(path, ls, path_size);
4741     else
4742         ls = &p[strlen(p)];  // XXX
4743
4744     /* the rest is hostname, use that to parse auth/port */
4745     if (ls != p) {
4746         /* authorization (user[:pass]@hostname) */
4747         at2 = p;
4748         while ((at = strchr(p, '@')) && at < ls) {
4749             av_strlcpy(authorization, at2,
4750                        FFMIN(authorization_size, at + 1 - at2));
4751             p = at + 1; /* skip '@' */
4752         }
4753
4754         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4755             /* [host]:port */
4756             av_strlcpy(hostname, p + 1,
4757                        FFMIN(hostname_size, brk - p));
4758             if (brk[1] == ':' && port_ptr)
4759                 *port_ptr = atoi(brk + 2);
4760         } else if ((col = strchr(p, ':')) && col < ls) {
4761             av_strlcpy(hostname, p,
4762                        FFMIN(col + 1 - p, hostname_size));
4763             if (port_ptr)
4764                 *port_ptr = atoi(col + 1);
4765         } else
4766             av_strlcpy(hostname, p,
4767                        FFMIN(ls + 1 - p, hostname_size));
4768     }
4769 }
4770
4771 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4772 {
4773     int i;
4774     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4775                                            '4', '5', '6', '7',
4776                                            '8', '9', 'A', 'B',
4777                                            'C', 'D', 'E', 'F' };
4778     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4779                                            '4', '5', '6', '7',
4780                                            '8', '9', 'a', 'b',
4781                                            'c', 'd', 'e', 'f' };
4782     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4783
4784     for (i = 0; i < s; i++) {
4785         buff[i * 2]     = hex_table[src[i] >> 4];
4786         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4787     }
4788
4789     return buff;
4790 }
4791
4792 int ff_hex_to_data(uint8_t *data, const char *p)
4793 {
4794     int c, len, v;
4795
4796     len = 0;
4797     v   = 1;
4798     for (;;) {
4799         p += strspn(p, SPACE_CHARS);
4800         if (*p == '\0')
4801             break;
4802         c = av_toupper((unsigned char) *p++);
4803         if (c >= '0' && c <= '9')
4804             c = c - '0';
4805         else if (c >= 'A' && c <= 'F')
4806             c = c - 'A' + 10;
4807         else
4808             break;
4809         v = (v << 4) | c;
4810         if (v & 0x100) {
4811             if (data)
4812                 data[len] = v;
4813             len++;
4814             v = 1;
4815         }
4816     }
4817     return len;
4818 }
4819
4820 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4821                          unsigned int pts_num, unsigned int pts_den)
4822 {
4823     AVRational new_tb;
4824     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4825         if (new_tb.num != pts_num)
4826             av_log(NULL, AV_LOG_DEBUG,
4827                    "st:%d removing common factor %d from timebase\n",
4828                    s->index, pts_num / new_tb.num);
4829     } else
4830         av_log(NULL, AV_LOG_WARNING,
4831                "st:%d has too large timebase, reducing\n", s->index);
4832
4833     if (new_tb.num <= 0 || new_tb.den <= 0) {
4834         av_log(NULL, AV_LOG_ERROR,
4835                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4836                new_tb.num, new_tb.den,
4837                s->index);
4838         return;
4839     }
4840     s->time_base     = new_tb;
4841 #if FF_API_LAVF_AVCTX
4842 FF_DISABLE_DEPRECATION_WARNINGS
4843     s->codec->pkt_timebase = new_tb;
4844 FF_ENABLE_DEPRECATION_WARNINGS
4845 #endif
4846     s->internal->avctx->pkt_timebase = new_tb;
4847     s->pts_wrap_bits = pts_wrap_bits;
4848 }
4849
4850 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4851                         void *context)
4852 {
4853     const char *ptr = str;
4854
4855     /* Parse key=value pairs. */
4856     for (;;) {
4857         const char *key;
4858         char *dest = NULL, *dest_end;
4859         int key_len, dest_len = 0;
4860
4861         /* Skip whitespace and potential commas. */
4862         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4863             ptr++;
4864         if (!*ptr)
4865             break;
4866
4867         key = ptr;
4868
4869         if (!(ptr = strchr(key, '=')))
4870             break;
4871         ptr++;
4872         key_len = ptr - key;
4873
4874         callback_get_buf(context, key, key_len, &dest, &dest_len);
4875         dest_end = dest + dest_len - 1;
4876
4877         if (*ptr == '\"') {
4878             ptr++;
4879             while (*ptr && *ptr != '\"') {
4880                 if (*ptr == '\\') {
4881                     if (!ptr[1])
4882                         break;
4883                     if (dest && dest < dest_end)
4884                         *dest++ = ptr[1];
4885                     ptr += 2;
4886                 } else {
4887                     if (dest && dest < dest_end)
4888                         *dest++ = *ptr;
4889                     ptr++;
4890                 }
4891             }
4892             if (*ptr == '\"')
4893                 ptr++;
4894         } else {
4895             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4896                 if (dest && dest < dest_end)
4897                     *dest++ = *ptr;
4898         }
4899         if (dest)
4900             *dest = 0;
4901     }
4902 }
4903
4904 int ff_find_stream_index(AVFormatContext *s, int id)
4905 {
4906     int i;
4907     for (i = 0; i < s->nb_streams; i++)
4908         if (s->streams[i]->id == id)
4909             return i;
4910     return -1;
4911 }
4912
4913 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4914                          int std_compliance)
4915 {
4916     if (ofmt) {
4917         unsigned int codec_tag;
4918         if (ofmt->query_codec)
4919             return ofmt->query_codec(codec_id, std_compliance);
4920         else if (ofmt->codec_tag)
4921             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4922         else if (codec_id == ofmt->video_codec ||
4923                  codec_id == ofmt->audio_codec ||
4924                  codec_id == ofmt->subtitle_codec ||
4925                  codec_id == ofmt->data_codec)
4926             return 1;
4927     }
4928     return AVERROR_PATCHWELCOME;
4929 }
4930
4931 int avformat_network_init(void)
4932 {
4933 #if CONFIG_NETWORK
4934     int ret;
4935     if ((ret = ff_network_init()) < 0)
4936         return ret;
4937     if ((ret = ff_tls_init()) < 0)
4938         return ret;
4939 #endif
4940     return 0;
4941 }
4942
4943 int avformat_network_deinit(void)
4944 {
4945 #if CONFIG_NETWORK
4946     ff_network_close();
4947     ff_tls_deinit();
4948 #endif
4949     return 0;
4950 }
4951
4952 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4953                         uint64_t channel_layout, int32_t sample_rate,
4954                         int32_t width, int32_t height)
4955 {
4956     uint32_t flags = 0;
4957     int size = 4;
4958     uint8_t *data;
4959     if (!pkt)
4960         return AVERROR(EINVAL);
4961     if (channels) {
4962         size  += 4;
4963         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4964     }
4965     if (channel_layout) {
4966         size  += 8;
4967         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4968     }
4969     if (sample_rate) {
4970         size  += 4;
4971         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4972     }
4973     if (width || height) {
4974         size  += 8;
4975         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4976     }
4977     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4978     if (!data)
4979         return AVERROR(ENOMEM);
4980     bytestream_put_le32(&data, flags);
4981     if (channels)
4982         bytestream_put_le32(&data, channels);
4983     if (channel_layout)
4984         bytestream_put_le64(&data, channel_layout);
4985     if (sample_rate)
4986         bytestream_put_le32(&data, sample_rate);
4987     if (width || height) {
4988         bytestream_put_le32(&data, width);
4989         bytestream_put_le32(&data, height);
4990     }
4991     return 0;
4992 }
4993
4994 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4995 {
4996     AVRational undef = {0, 1};
4997     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4998     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4999     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5000
5001     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5002                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5003     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5004         stream_sample_aspect_ratio = undef;
5005
5006     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5007                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5008     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5009         frame_sample_aspect_ratio = undef;
5010
5011     if (stream_sample_aspect_ratio.num)
5012         return stream_sample_aspect_ratio;
5013     else
5014         return frame_sample_aspect_ratio;
5015 }
5016
5017 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5018 {
5019     AVRational fr = st->r_frame_rate;
5020     AVRational codec_fr = st->internal->avctx->framerate;
5021     AVRational   avg_fr = st->avg_frame_rate;
5022
5023     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5024         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5025         fr = avg_fr;
5026     }
5027
5028
5029     if (st->internal->avctx->ticks_per_frame > 1) {
5030         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5031             (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))
5032             fr = codec_fr;
5033     }
5034
5035     return fr;
5036 }
5037
5038 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5039                                     const char *spec)
5040 {
5041     if (*spec <= '9' && *spec >= '0') /* opt:index */
5042         return strtol(spec, NULL, 0) == st->index;
5043     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5044              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5045         enum AVMediaType type;
5046         int nopic = 0;
5047
5048         switch (*spec++) {
5049         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5050         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5051         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5052         case 'd': type = AVMEDIA_TYPE_DATA;       break;
5053         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5054         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5055         default:  av_assert0(0);
5056         }
5057 #if FF_API_LAVF_AVCTX
5058 FF_DISABLE_DEPRECATION_WARNINGS
5059         if (type != st->codecpar->codec_type
5060            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5061             return 0;
5062 FF_ENABLE_DEPRECATION_WARNINGS
5063 #else
5064         if (type != st->codecpar->codec_type)
5065             return 0;
5066 #endif
5067         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5068             return 0;
5069         if (*spec++ == ':') { /* possibly followed by :index */
5070             int i, index = strtol(spec, NULL, 0);
5071             for (i = 0; i < s->nb_streams; i++) {
5072 #if FF_API_LAVF_AVCTX
5073 FF_DISABLE_DEPRECATION_WARNINGS
5074                 if ((s->streams[i]->codecpar->codec_type == type
5075                       || s->streams[i]->codec->codec_type == type
5076                     ) &&
5077                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5078                     index-- == 0)
5079                     return i == st->index;
5080 FF_ENABLE_DEPRECATION_WARNINGS
5081 #else
5082                 if ((s->streams[i]->codecpar->codec_type == type) &&
5083                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5084                     index-- == 0)
5085                     return i == st->index;
5086 #endif
5087             }
5088             return 0;
5089         }
5090         return 1;
5091     } else if (*spec == 'p' && *(spec + 1) == ':') {
5092         int prog_id, i, j;
5093         char *endptr;
5094         spec += 2;
5095         prog_id = strtol(spec, &endptr, 0);
5096         for (i = 0; i < s->nb_programs; i++) {
5097             if (s->programs[i]->id != prog_id)
5098                 continue;
5099
5100             if (*endptr++ == ':') {  // p:<id>:....
5101                 if ( *endptr == 'a' || *endptr == 'v' ||
5102                      *endptr == 's' || *endptr == 'd') {  // p:<id>:<st_type>[:<index>]
5103                     enum AVMediaType type;
5104
5105                     switch (*endptr++) {
5106                     case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5107                     case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5108                     case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5109                     case 'd': type = AVMEDIA_TYPE_DATA;       break;
5110                     default:  av_assert0(0);
5111                     }
5112                     if (*endptr++ == ':') {  // p:<id>:<st_type>:<index>
5113                         int stream_idx = strtol(endptr, NULL, 0), type_counter = 0;
5114                         for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5115                             int stream_index = s->programs[i]->stream_index[j];
5116                             if (st->index == s->programs[i]->stream_index[j]) {
5117 #if FF_API_LAVF_AVCTX
5118 FF_DISABLE_DEPRECATION_WARNINGS
5119                                 return type_counter == stream_idx &&
5120                                        (type == st->codecpar->codec_type ||
5121                                         type == st->codec->codec_type);
5122 FF_ENABLE_DEPRECATION_WARNINGS
5123 #else
5124                                 return type_counter == stream_idx &&
5125                                        type == st->codecpar->codec_type;
5126 #endif
5127                              }
5128 #if FF_API_LAVF_AVCTX
5129 FF_DISABLE_DEPRECATION_WARNINGS
5130                             if (type == s->streams[stream_index]->codecpar->codec_type ||
5131                                 type == s->streams[stream_index]->codec->codec_type)
5132                                 type_counter++;
5133 FF_ENABLE_DEPRECATION_WARNINGS
5134 #else
5135                             if (type == s->streams[stream_index]->codecpar->codec_type)
5136                                 type_counter++;
5137 #endif
5138                         }
5139                         return 0;
5140                     } else {  // p:<id>:<st_type>
5141                         for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5142                             if (st->index == s->programs[i]->stream_index[j]) {
5143 #if FF_API_LAVF_AVCTX
5144 FF_DISABLE_DEPRECATION_WARNINGS
5145                                  return type == st->codecpar->codec_type ||
5146                                         type == st->codec->codec_type;
5147 FF_ENABLE_DEPRECATION_WARNINGS
5148 #else
5149                                  return type == st->codecpar->codec_type;
5150 #endif
5151                             }
5152                         return 0;
5153                     }
5154
5155                 } else if ( *endptr == 'm') { // p:<id>:m:<metadata_spec>
5156                     AVDictionaryEntry *tag;
5157                     char *key, *val;
5158                     int ret = 0;
5159
5160                     if (*(++endptr) != ':') {
5161                         av_log(s, AV_LOG_ERROR, "Invalid stream specifier syntax, missing ':' sign after :m.\n");
5162                         return AVERROR(EINVAL);
5163                     }
5164
5165                     val = strchr(++endptr, ':');
5166                     key = val ? av_strndup(endptr, val - endptr) : av_strdup(endptr);
5167                     if (!key)
5168                         return AVERROR(ENOMEM);
5169
5170                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5171                         if (st->index == s->programs[i]->stream_index[j]) {
5172                             tag = av_dict_get(st->metadata, key, NULL, 0);
5173                             if (tag && (!val || !strcmp(tag->value, val + 1)))
5174                                 ret = 1;
5175
5176                             break;
5177                         }
5178
5179                     av_freep(&key);
5180                     return ret;
5181
5182                 } else {  // p:<id>:<index>
5183                     int stream_idx = strtol(endptr, NULL, 0);
5184                     return stream_idx >= 0 &&
5185                            stream_idx < s->programs[i]->nb_stream_indexes &&
5186                            st->index == s->programs[i]->stream_index[stream_idx];
5187                 }
5188             }
5189
5190             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5191                 if (st->index == s->programs[i]->stream_index[j])
5192                     return 1;
5193         }
5194         return 0;
5195     } else if (*spec == '#' ||
5196                (*spec == 'i' && *(spec + 1) == ':')) {
5197         int stream_id;
5198         char *endptr;
5199         spec += 1 + (*spec == 'i');
5200         stream_id = strtol(spec, &endptr, 0);
5201         if (!*endptr)
5202             return stream_id == st->id;
5203     } else if (*spec == 'm' && *(spec + 1) == ':') {
5204         AVDictionaryEntry *tag;
5205         char *key, *val;
5206         int ret;
5207
5208         spec += 2;
5209         val = strchr(spec, ':');
5210
5211         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5212         if (!key)
5213             return AVERROR(ENOMEM);
5214
5215         tag = av_dict_get(st->metadata, key, NULL, 0);
5216         if (tag) {
5217             if (!val || !strcmp(tag->value, val + 1))
5218                 ret = 1;
5219             else
5220                 ret = 0;
5221         } else
5222             ret = 0;
5223
5224         av_freep(&key);
5225         return ret;
5226     } else if (*spec == 'u') {
5227         AVCodecParameters *par = st->codecpar;
5228 #if FF_API_LAVF_AVCTX
5229 FF_DISABLE_DEPRECATION_WARNINGS
5230         AVCodecContext *codec = st->codec;
5231 FF_ENABLE_DEPRECATION_WARNINGS
5232 #endif
5233         int val;
5234         switch (par->codec_type) {
5235         case AVMEDIA_TYPE_AUDIO:
5236             val = par->sample_rate && par->channels;
5237 #if FF_API_LAVF_AVCTX
5238             val = val || (codec->sample_rate && codec->channels);
5239 #endif
5240             if (par->format == AV_SAMPLE_FMT_NONE
5241 #if FF_API_LAVF_AVCTX
5242                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5243 #endif
5244                 )
5245                 return 0;
5246             break;
5247         case AVMEDIA_TYPE_VIDEO:
5248             val = par->width && par->height;
5249 #if FF_API_LAVF_AVCTX
5250             val = val || (codec->width && codec->height);
5251 #endif
5252             if (par->format == AV_PIX_FMT_NONE
5253 #if FF_API_LAVF_AVCTX
5254                 && codec->pix_fmt == AV_PIX_FMT_NONE
5255 #endif
5256                 )
5257                 return 0;
5258             break;
5259         case AVMEDIA_TYPE_UNKNOWN:
5260             val = 0;
5261             break;
5262         default:
5263             val = 1;
5264             break;
5265         }
5266 #if FF_API_LAVF_AVCTX
5267         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5268 #else
5269         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5270 #endif
5271     } else if (!*spec) /* empty specifier, matches everything */
5272         return 1;
5273
5274     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5275     return AVERROR(EINVAL);
5276 }
5277
5278 int ff_generate_avci_extradata(AVStream *st)
5279 {
5280     static const uint8_t avci100_1080p_extradata[] = {
5281         // SPS
5282         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5283         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5284         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5285         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5286         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5287         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5288         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5289         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5290         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5291         // PPS
5292         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5293         0xd0
5294     };
5295     static const uint8_t avci100_1080i_extradata[] = {
5296         // SPS
5297         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5298         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5299         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5300         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5301         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5302         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5303         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5304         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5305         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5306         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5307         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5308         // PPS
5309         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5310         0xd0
5311     };
5312     static const uint8_t avci50_1080p_extradata[] = {
5313         // SPS
5314         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5315         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5316         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5317         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5318         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5319         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5320         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5321         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5322         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5323         // PPS
5324         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5325         0x11
5326     };
5327     static const uint8_t avci50_1080i_extradata[] = {
5328         // SPS
5329         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5330         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5331         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5332         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5333         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5334         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5335         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5336         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5337         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5338         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5339         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5340         // PPS
5341         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5342         0x11
5343     };
5344     static const uint8_t avci100_720p_extradata[] = {
5345         // SPS
5346         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5347         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5348         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5349         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5350         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5351         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5352         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5353         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5354         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5355         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5356         // PPS
5357         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5358         0x11
5359     };
5360     static const uint8_t avci50_720p_extradata[] = {
5361         // SPS
5362         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5363         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5364         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5365         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5366         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5367         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5368         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5369         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5370         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5371         // PPS
5372         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5373         0x11
5374     };
5375
5376     const uint8_t *data = NULL;
5377     int size            = 0;
5378
5379     if (st->codecpar->width == 1920) {
5380         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5381             data = avci100_1080p_extradata;
5382             size = sizeof(avci100_1080p_extradata);
5383         } else {
5384             data = avci100_1080i_extradata;
5385             size = sizeof(avci100_1080i_extradata);
5386         }
5387     } else if (st->codecpar->width == 1440) {
5388         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5389             data = avci50_1080p_extradata;
5390             size = sizeof(avci50_1080p_extradata);
5391         } else {
5392             data = avci50_1080i_extradata;
5393             size = sizeof(avci50_1080i_extradata);
5394         }
5395     } else if (st->codecpar->width == 1280) {
5396         data = avci100_720p_extradata;
5397         size = sizeof(avci100_720p_extradata);
5398     } else if (st->codecpar->width == 960) {
5399         data = avci50_720p_extradata;
5400         size = sizeof(avci50_720p_extradata);
5401     }
5402
5403     if (!size)
5404         return 0;
5405
5406     av_freep(&st->codecpar->extradata);
5407     if (ff_alloc_extradata(st->codecpar, size))
5408         return AVERROR(ENOMEM);
5409     memcpy(st->codecpar->extradata, data, size);
5410
5411     return 0;
5412 }
5413
5414 uint8_t *av_stream_get_side_data(const AVStream *st,
5415                                  enum AVPacketSideDataType type, int *size)
5416 {
5417     int i;
5418
5419     for (i = 0; i < st->nb_side_data; i++) {
5420         if (st->side_data[i].type == type) {
5421             if (size)
5422                 *size = st->side_data[i].size;
5423             return st->side_data[i].data;
5424         }
5425     }
5426     return NULL;
5427 }
5428
5429 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5430                             uint8_t *data, size_t size)
5431 {
5432     AVPacketSideData *sd, *tmp;
5433     int i;
5434
5435     for (i = 0; i < st->nb_side_data; i++) {
5436         sd = &st->side_data[i];
5437
5438         if (sd->type == type) {
5439             av_freep(&sd->data);
5440             sd->data = data;
5441             sd->size = size;
5442             return 0;
5443         }
5444     }
5445
5446     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5447         return AVERROR(ERANGE);
5448
5449     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5450     if (!tmp) {
5451         return AVERROR(ENOMEM);
5452     }
5453
5454     st->side_data = tmp;
5455     st->nb_side_data++;
5456
5457     sd = &st->side_data[st->nb_side_data - 1];
5458     sd->type = type;
5459     sd->data = data;
5460     sd->size = size;
5461
5462     return 0;
5463 }
5464
5465 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5466                                  int size)
5467 {
5468     int ret;
5469     uint8_t *data = av_malloc(size);
5470
5471     if (!data)
5472         return NULL;
5473
5474     ret = av_stream_add_side_data(st, type, data, size);
5475     if (ret < 0) {
5476         av_freep(&data);
5477         return NULL;
5478     }
5479
5480     return data;
5481 }
5482
5483 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5484 {
5485     int ret;
5486     const AVBitStreamFilter *bsf;
5487     AVBSFContext *bsfc;
5488     AVCodecParameters *in_par;
5489
5490     if (!(bsf = av_bsf_get_by_name(name))) {
5491         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5492         return AVERROR_BSF_NOT_FOUND;
5493     }
5494
5495     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5496         return ret;
5497
5498     if (st->internal->nb_bsfcs) {
5499         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5500         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5501     } else {
5502         in_par = st->codecpar;
5503         bsfc->time_base_in = st->time_base;
5504     }
5505
5506     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5507         av_bsf_free(&bsfc);
5508         return ret;
5509     }
5510
5511     if (args && bsfc->filter->priv_class) {
5512         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5513         const char * shorthand[2] = {NULL};
5514
5515         if (opt)
5516             shorthand[0] = opt->name;
5517
5518         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5519             av_bsf_free(&bsfc);
5520             return ret;
5521         }
5522     }
5523
5524     if ((ret = av_bsf_init(bsfc)) < 0) {
5525         av_bsf_free(&bsfc);
5526         return ret;
5527     }
5528
5529     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5530         av_bsf_free(&bsfc);
5531         return ret;
5532     }
5533
5534     av_log(NULL, AV_LOG_VERBOSE,
5535            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5536            name, args ? args : "");
5537     return 1;
5538 }
5539
5540 #if FF_API_OLD_BSF
5541 FF_DISABLE_DEPRECATION_WARNINGS
5542 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5543                                AVBitStreamFilterContext *bsfc)
5544 {
5545     int ret = 0;
5546     while (bsfc) {
5547         AVPacket new_pkt = *pkt;
5548         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5549                                            &new_pkt.data, &new_pkt.size,
5550                                            pkt->data, pkt->size,
5551                                            pkt->flags & AV_PKT_FLAG_KEY);
5552         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5553             av_packet_unref(pkt);
5554             memset(pkt, 0, sizeof(*pkt));
5555             return 0;
5556         }
5557         if(a == 0 && new_pkt.data != pkt->data) {
5558             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
5559             if (t) {
5560                 memcpy(t, new_pkt.data, new_pkt.size);
5561                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5562                 new_pkt.data = t;
5563                 new_pkt.buf = NULL;
5564                 a = 1;
5565             } else {
5566                 a = AVERROR(ENOMEM);
5567             }
5568         }
5569         if (a > 0) {
5570             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5571                                            av_buffer_default_free, NULL, 0);
5572             if (new_pkt.buf) {
5573                 pkt->side_data = NULL;
5574                 pkt->side_data_elems = 0;
5575                 av_packet_unref(pkt);
5576             } else {
5577                 av_freep(&new_pkt.data);
5578                 a = AVERROR(ENOMEM);
5579             }
5580         }
5581         if (a < 0) {
5582             av_log(codec, AV_LOG_ERROR,
5583                    "Failed to open bitstream filter %s for stream %d with codec %s",
5584                    bsfc->filter->name, pkt->stream_index,
5585                    codec->codec ? codec->codec->name : "copy");
5586             ret = a;
5587             break;
5588         }
5589         *pkt = new_pkt;
5590
5591         bsfc = bsfc->next;
5592     }
5593     return ret;
5594 }
5595 FF_ENABLE_DEPRECATION_WARNINGS
5596 #endif
5597
5598 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5599 {
5600     if (!s->oformat)
5601         return AVERROR(EINVAL);
5602
5603     if (!(s->oformat->flags & AVFMT_NOFILE))
5604         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5605     return 0;
5606 }
5607
5608 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5609 {
5610     if (*pb)
5611         s->io_close(s, *pb);
5612     *pb = NULL;
5613 }
5614
5615 int ff_is_http_proto(char *filename) {
5616     const char *proto = avio_find_protocol_name(filename);
5617     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5618 }
5619
5620 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5621 {
5622     AVDictionaryEntry *entry;
5623     int64_t parsed_timestamp;
5624     int ret;
5625     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5626         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5627             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5628             return 1;
5629         } else {
5630             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5631             return ret;
5632         }
5633     }
5634     return 0;
5635 }
5636
5637 int ff_standardize_creation_time(AVFormatContext *s)
5638 {
5639     int64_t timestamp;
5640     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5641     if (ret == 1)
5642         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5643     return ret;
5644 }
5645
5646 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5647 {
5648     uint8_t *side_data;
5649     int size;
5650
5651     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5652     if (side_data) {
5653         if (size != AVPALETTE_SIZE) {
5654             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5655             return AVERROR_INVALIDDATA;
5656         }
5657         memcpy(palette, side_data, AVPALETTE_SIZE);
5658         return 1;
5659     }
5660
5661     if (ret == CONTAINS_PAL) {
5662         int i;
5663         for (i = 0; i < AVPALETTE_COUNT; i++)
5664             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5665         return 1;
5666     }
5667
5668     return 0;
5669 }
5670
5671 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5672 {
5673     int ret;
5674     char *str;
5675
5676     ret = av_bprint_finalize(buf, &str);
5677     if (ret < 0)
5678         return ret;
5679     if (!av_bprint_is_complete(buf)) {
5680         av_free(str);
5681         return AVERROR(ENOMEM);
5682     }
5683
5684     par->extradata = str;
5685     /* Note: the string is NUL terminated (so extradata can be read as a
5686      * string), but the ending character is not accounted in the size (in
5687      * binary formats you are likely not supposed to mux that character). When
5688      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5689      * zeros. */
5690     par->extradata_size = buf->len;
5691     return 0;
5692 }
5693
5694 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5695                                                   AVStream *ost, const AVStream *ist,
5696                                                   enum AVTimebaseSource copy_tb)
5697 {
5698     //TODO: use [io]st->internal->avctx
5699     const AVCodecContext *dec_ctx = ist->codec;
5700     AVCodecContext       *enc_ctx = ost->codec;
5701
5702     enc_ctx->time_base = ist->time_base;
5703     /*
5704      * Avi is a special case here because it supports variable fps but
5705      * having the fps and timebase differe significantly adds quite some
5706      * overhead
5707      */
5708     if (!strcmp(ofmt->name, "avi")) {
5709 #if FF_API_R_FRAME_RATE
5710         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5711             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5712             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5713             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5714             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5715             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5716             enc_ctx->time_base.num = ist->r_frame_rate.den;
5717             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5718             enc_ctx->ticks_per_frame = 2;
5719         } else
5720 #endif
5721             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5722                    && av_q2d(ist->time_base) < 1.0/500
5723                    || copy_tb == AVFMT_TBCF_DECODER) {
5724             enc_ctx->time_base = dec_ctx->time_base;
5725             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5726             enc_ctx->time_base.den *= 2;
5727             enc_ctx->ticks_per_frame = 2;
5728         }
5729     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5730                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5731         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5732             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5733             && av_q2d(ist->time_base) < 1.0/500
5734             || copy_tb == AVFMT_TBCF_DECODER) {
5735             enc_ctx->time_base = dec_ctx->time_base;
5736             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5737         }
5738     }
5739
5740     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5741         && dec_ctx->time_base.num < dec_ctx->time_base.den
5742         && dec_ctx->time_base.num > 0
5743         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5744         enc_ctx->time_base = dec_ctx->time_base;
5745     }
5746
5747     if (ost->avg_frame_rate.num)
5748         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5749
5750     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5751               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5752
5753     return 0;
5754 }
5755
5756 AVRational av_stream_get_codec_timebase(const AVStream *st)
5757 {
5758     // See avformat_transfer_internal_stream_timing_info() TODO.
5759 #if FF_API_LAVF_AVCTX
5760 FF_DISABLE_DEPRECATION_WARNINGS
5761     return st->codec->time_base;
5762 FF_ENABLE_DEPRECATION_WARNINGS
5763 #else
5764     return st->internal->avctx->time_base;
5765 #endif
5766 }
5767
5768 void ff_format_set_url(AVFormatContext *s, char *url)
5769 {
5770     av_assert0(url);
5771     av_freep(&s->url);
5772     s->url = url;
5773 #if FF_API_FORMAT_FILENAME
5774 FF_DISABLE_DEPRECATION_WARNINGS
5775     av_strlcpy(s->filename, url, sizeof(s->filename));
5776 FF_ENABLE_DEPRECATION_WARNINGS
5777 #endif
5778 }