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