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