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

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