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