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