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