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

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