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