git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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