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

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