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