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