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     avcodec_free_context(&st->codec);
4270 FF_ENABLE_DEPRECATION_WARNINGS
4271 #endif
4272     av_freep(&st->priv_data);
4273     if (st->info)
4274         av_freep(&st->info->duration_error);
4275     av_freep(&st->info);
4276     av_freep(&st->recommended_encoder_configuration);
4277     av_freep(&st->priv_pts);
4278
4279     av_freep(pst);
4280 }
4281
4282 void ff_free_stream(AVFormatContext *s, AVStream *st)
4283 {
4284     av_assert0(s->nb_streams>0);
4285     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4286
4287     free_stream(&s->streams[ --s->nb_streams ]);
4288 }
4289
4290 void avformat_free_context(AVFormatContext *s)
4291 {
4292     int i;
4293
4294     if (!s)
4295         return;
4296
4297     av_opt_free(s);
4298     if (s->iformat && s->iformat->priv_class && s->priv_data)
4299         av_opt_free(s->priv_data);
4300     if (s->oformat && s->oformat->priv_class && s->priv_data)
4301         av_opt_free(s->priv_data);
4302
4303     for (i = s->nb_streams - 1; i >= 0; i--)
4304         ff_free_stream(s, s->streams[i]);
4305
4306
4307     for (i = s->nb_programs - 1; i >= 0; i--) {
4308         av_dict_free(&s->programs[i]->metadata);
4309         av_freep(&s->programs[i]->stream_index);
4310         av_freep(&s->programs[i]);
4311     }
4312     av_freep(&s->programs);
4313     av_freep(&s->priv_data);
4314     while (s->nb_chapters--) {
4315         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4316         av_freep(&s->chapters[s->nb_chapters]);
4317     }
4318     av_freep(&s->chapters);
4319     av_dict_free(&s->metadata);
4320     av_dict_free(&s->internal->id3v2_meta);
4321     av_freep(&s->streams);
4322     av_freep(&s->internal);
4323     flush_packet_queue(s);
4324     av_free(s);
4325 }
4326
4327 void avformat_close_input(AVFormatContext **ps)
4328 {
4329     AVFormatContext *s;
4330     AVIOContext *pb;
4331
4332     if (!ps || !*ps)
4333         return;
4334
4335     s  = *ps;
4336     pb = s->pb;
4337
4338     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4339         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4340         pb = NULL;
4341
4342     flush_packet_queue(s);
4343
4344     if (s->iformat)
4345         if (s->iformat->read_close)
4346             s->iformat->read_close(s);
4347
4348     avformat_free_context(s);
4349
4350     *ps = NULL;
4351
4352     avio_close(pb);
4353 }
4354
4355 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4356 {
4357     AVStream *st;
4358     int i;
4359     AVStream **streams;
4360
4361     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4362         if (s->max_streams < INT_MAX/sizeof(*streams))
4363             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);
4364         return NULL;
4365     }
4366     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4367     if (!streams)
4368         return NULL;
4369     s->streams = streams;
4370
4371     st = av_mallocz(sizeof(AVStream));
4372     if (!st)
4373         return NULL;
4374     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4375         av_free(st);
4376         return NULL;
4377     }
4378     st->info->last_dts = AV_NOPTS_VALUE;
4379
4380 #if FF_API_LAVF_AVCTX
4381 FF_DISABLE_DEPRECATION_WARNINGS
4382     st->codec = avcodec_alloc_context3(c);
4383     if (!st->codec) {
4384         av_free(st->info);
4385         av_free(st);
4386         return NULL;
4387     }
4388 FF_ENABLE_DEPRECATION_WARNINGS
4389 #endif
4390
4391     st->internal = av_mallocz(sizeof(*st->internal));
4392     if (!st->internal)
4393         goto fail;
4394
4395     st->codecpar = avcodec_parameters_alloc();
4396     if (!st->codecpar)
4397         goto fail;
4398
4399     st->internal->avctx = avcodec_alloc_context3(NULL);
4400     if (!st->internal->avctx)
4401         goto fail;
4402
4403     if (s->iformat) {
4404 #if FF_API_LAVF_AVCTX
4405 FF_DISABLE_DEPRECATION_WARNINGS
4406         /* no default bitrate if decoding */
4407         st->codec->bit_rate = 0;
4408 FF_ENABLE_DEPRECATION_WARNINGS
4409 #endif
4410
4411         /* default pts setting is MPEG-like */
4412         avpriv_set_pts_info(st, 33, 1, 90000);
4413         /* we set the current DTS to 0 so that formats without any timestamps
4414          * but durations get some timestamps, formats with some unknown
4415          * timestamps have their first few packets buffered and the
4416          * timestamps corrected before they are returned to the user */
4417         st->cur_dts = RELATIVE_TS_BASE;
4418     } else {
4419         st->cur_dts = AV_NOPTS_VALUE;
4420     }
4421
4422     st->index      = s->nb_streams;
4423     st->start_time = AV_NOPTS_VALUE;
4424     st->duration   = AV_NOPTS_VALUE;
4425     st->first_dts     = AV_NOPTS_VALUE;
4426     st->probe_packets = MAX_PROBE_PACKETS;
4427     st->pts_wrap_reference = AV_NOPTS_VALUE;
4428     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4429
4430     st->last_IP_pts = AV_NOPTS_VALUE;
4431     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4432     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4433         st->pts_buffer[i] = AV_NOPTS_VALUE;
4434
4435     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4436
4437 #if FF_API_R_FRAME_RATE
4438     st->info->last_dts      = AV_NOPTS_VALUE;
4439 #endif
4440     st->info->fps_first_dts = AV_NOPTS_VALUE;
4441     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4442
4443     st->inject_global_side_data = s->internal->inject_global_side_data;
4444
4445     st->internal->need_context_update = 1;
4446
4447     s->streams[s->nb_streams++] = st;
4448     return st;
4449 fail:
4450     free_stream(&st);
4451     return NULL;
4452 }
4453
4454 AVProgram *av_new_program(AVFormatContext *ac, int id)
4455 {
4456     AVProgram *program = NULL;
4457     int i;
4458
4459     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4460
4461     for (i = 0; i < ac->nb_programs; i++)
4462         if (ac->programs[i]->id == id)
4463             program = ac->programs[i];
4464
4465     if (!program) {
4466         program = av_mallocz(sizeof(AVProgram));
4467         if (!program)
4468             return NULL;
4469         dynarray_add(&ac->programs, &ac->nb_programs, program);
4470         program->discard = AVDISCARD_NONE;
4471     }
4472     program->id = id;
4473     program->pts_wrap_reference = AV_NOPTS_VALUE;
4474     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4475
4476     program->start_time =
4477     program->end_time   = AV_NOPTS_VALUE;
4478
4479     return program;
4480 }
4481
4482 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4483                               int64_t start, int64_t end, const char *title)
4484 {
4485     AVChapter *chapter = NULL;
4486     int i;
4487
4488     if (end != AV_NOPTS_VALUE && start > end) {
4489         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4490         return NULL;
4491     }
4492
4493     for (i = 0; i < s->nb_chapters; i++)
4494         if (s->chapters[i]->id == id)
4495             chapter = s->chapters[i];
4496
4497     if (!chapter) {
4498         chapter = av_mallocz(sizeof(AVChapter));
4499         if (!chapter)
4500             return NULL;
4501         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4502     }
4503     av_dict_set(&chapter->metadata, "title", title, 0);
4504     chapter->id        = id;
4505     chapter->time_base = time_base;
4506     chapter->start     = start;
4507     chapter->end       = end;
4508
4509     return chapter;
4510 }
4511
4512 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4513 {
4514     int i, j;
4515     AVProgram *program = NULL;
4516     void *tmp;
4517
4518     if (idx >= ac->nb_streams) {
4519         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4520         return;
4521     }
4522
4523     for (i = 0; i < ac->nb_programs; i++) {
4524         if (ac->programs[i]->id != progid)
4525             continue;
4526         program = ac->programs[i];
4527         for (j = 0; j < program->nb_stream_indexes; j++)
4528             if (program->stream_index[j] == idx)
4529                 return;
4530
4531         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4532         if (!tmp)
4533             return;
4534         program->stream_index = tmp;
4535         program->stream_index[program->nb_stream_indexes++] = idx;
4536         return;
4537     }
4538 }
4539
4540 uint64_t ff_ntp_time(void)
4541 {
4542     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4543 }
4544
4545 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4546 {
4547     const char *p;
4548     char *q, buf1[20], c;
4549     int nd, len, percentd_found;
4550
4551     q = buf;
4552     p = path;
4553     percentd_found = 0;
4554     for (;;) {
4555         c = *p++;
4556         if (c == '\0')
4557             break;
4558         if (c == '%') {
4559             do {
4560                 nd = 0;
4561                 while (av_isdigit(*p))
4562                     nd = nd * 10 + *p++ - '0';
4563                 c = *p++;
4564             } while (av_isdigit(c));
4565
4566             switch (c) {
4567             case '%':
4568                 goto addchar;
4569             case 'd':
4570                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4571                     goto fail;
4572                 percentd_found = 1;
4573                 if (number < 0)
4574                     nd += 1;
4575                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4576                 len = strlen(buf1);
4577                 if ((q - buf + len) > buf_size - 1)
4578                     goto fail;
4579                 memcpy(q, buf1, len);
4580                 q += len;
4581                 break;
4582             default:
4583                 goto fail;
4584             }
4585         } else {
4586 addchar:
4587             if ((q - buf) < buf_size - 1)
4588                 *q++ = c;
4589         }
4590     }
4591     if (!percentd_found)
4592         goto fail;
4593     *q = '\0';
4594     return 0;
4595 fail:
4596     *q = '\0';
4597     return -1;
4598 }
4599
4600 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4601 {
4602     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4603 }
4604
4605 void av_url_split(char *proto, int proto_size,
4606                   char *authorization, int authorization_size,
4607                   char *hostname, int hostname_size,
4608                   int *port_ptr, char *path, int path_size, const char *url)
4609 {
4610     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4611
4612     if (port_ptr)
4613         *port_ptr = -1;
4614     if (proto_size > 0)
4615         proto[0] = 0;
4616     if (authorization_size > 0)
4617         authorization[0] = 0;
4618     if (hostname_size > 0)
4619         hostname[0] = 0;
4620     if (path_size > 0)
4621         path[0] = 0;
4622
4623     /* parse protocol */
4624     if ((p = strchr(url, ':'))) {
4625         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4626         p++; /* skip ':' */
4627         if (*p == '/')
4628             p++;
4629         if (*p == '/')
4630             p++;
4631     } else {
4632         /* no protocol means plain filename */
4633         av_strlcpy(path, url, path_size);
4634         return;
4635     }
4636
4637     /* separate path from hostname */
4638     ls = strchr(p, '/');
4639     ls2 = strchr(p, '?');
4640     if (!ls)
4641         ls = ls2;
4642     else if (ls && ls2)
4643         ls = FFMIN(ls, ls2);
4644     if (ls)
4645         av_strlcpy(path, ls, path_size);
4646     else
4647         ls = &p[strlen(p)];  // XXX
4648
4649     /* the rest is hostname, use that to parse auth/port */
4650     if (ls != p) {
4651         /* authorization (user[:pass]@hostname) */
4652         at2 = p;
4653         while ((at = strchr(p, '@')) && at < ls) {
4654             av_strlcpy(authorization, at2,
4655                        FFMIN(authorization_size, at + 1 - at2));
4656             p = at + 1; /* skip '@' */
4657         }
4658
4659         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4660             /* [host]:port */
4661             av_strlcpy(hostname, p + 1,
4662                        FFMIN(hostname_size, brk - p));
4663             if (brk[1] == ':' && port_ptr)
4664                 *port_ptr = atoi(brk + 2);
4665         } else if ((col = strchr(p, ':')) && col < ls) {
4666             av_strlcpy(hostname, p,
4667                        FFMIN(col + 1 - p, hostname_size));
4668             if (port_ptr)
4669                 *port_ptr = atoi(col + 1);
4670         } else
4671             av_strlcpy(hostname, p,
4672                        FFMIN(ls + 1 - p, hostname_size));
4673     }
4674 }
4675
4676 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4677 {
4678     int i;
4679     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4680                                            '4', '5', '6', '7',
4681                                            '8', '9', 'A', 'B',
4682                                            'C', 'D', 'E', 'F' };
4683     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4684                                            '4', '5', '6', '7',
4685                                            '8', '9', 'a', 'b',
4686                                            'c', 'd', 'e', 'f' };
4687     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4688
4689     for (i = 0; i < s; i++) {
4690         buff[i * 2]     = hex_table[src[i] >> 4];
4691         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4692     }
4693
4694     return buff;
4695 }
4696
4697 int ff_hex_to_data(uint8_t *data, const char *p)
4698 {
4699     int c, len, v;
4700
4701     len = 0;
4702     v   = 1;
4703     for (;;) {
4704         p += strspn(p, SPACE_CHARS);
4705         if (*p == '\0')
4706             break;
4707         c = av_toupper((unsigned char) *p++);
4708         if (c >= '0' && c <= '9')
4709             c = c - '0';
4710         else if (c >= 'A' && c <= 'F')
4711             c = c - 'A' + 10;
4712         else
4713             break;
4714         v = (v << 4) | c;
4715         if (v & 0x100) {
4716             if (data)
4717                 data[len] = v;
4718             len++;
4719             v = 1;
4720         }
4721     }
4722     return len;
4723 }
4724
4725 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4726                          unsigned int pts_num, unsigned int pts_den)
4727 {
4728     AVRational new_tb;
4729     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4730         if (new_tb.num != pts_num)
4731             av_log(NULL, AV_LOG_DEBUG,
4732                    "st:%d removing common factor %d from timebase\n",
4733                    s->index, pts_num / new_tb.num);
4734     } else
4735         av_log(NULL, AV_LOG_WARNING,
4736                "st:%d has too large timebase, reducing\n", s->index);
4737
4738     if (new_tb.num <= 0 || new_tb.den <= 0) {
4739         av_log(NULL, AV_LOG_ERROR,
4740                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4741                new_tb.num, new_tb.den,
4742                s->index);
4743         return;
4744     }
4745     s->time_base     = new_tb;
4746 #if FF_API_LAVF_AVCTX
4747 FF_DISABLE_DEPRECATION_WARNINGS
4748     av_codec_set_pkt_timebase(s->codec, new_tb);
4749 FF_ENABLE_DEPRECATION_WARNINGS
4750 #endif
4751     av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4752     s->pts_wrap_bits = pts_wrap_bits;
4753 }
4754
4755 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4756                         void *context)
4757 {
4758     const char *ptr = str;
4759
4760     /* Parse key=value pairs. */
4761     for (;;) {
4762         const char *key;
4763         char *dest = NULL, *dest_end;
4764         int key_len, dest_len = 0;
4765
4766         /* Skip whitespace and potential commas. */
4767         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4768             ptr++;
4769         if (!*ptr)
4770             break;
4771
4772         key = ptr;
4773
4774         if (!(ptr = strchr(key, '=')))
4775             break;
4776         ptr++;
4777         key_len = ptr - key;
4778
4779         callback_get_buf(context, key, key_len, &dest, &dest_len);
4780         dest_end = dest + dest_len - 1;
4781
4782         if (*ptr == '\"') {
4783             ptr++;
4784             while (*ptr && *ptr != '\"') {
4785                 if (*ptr == '\\') {
4786                     if (!ptr[1])
4787                         break;
4788                     if (dest && dest < dest_end)
4789                         *dest++ = ptr[1];
4790                     ptr += 2;
4791                 } else {
4792                     if (dest && dest < dest_end)
4793                         *dest++ = *ptr;
4794                     ptr++;
4795                 }
4796             }
4797             if (*ptr == '\"')
4798                 ptr++;
4799         } else {
4800             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4801                 if (dest && dest < dest_end)
4802                     *dest++ = *ptr;
4803         }
4804         if (dest)
4805             *dest = 0;
4806     }
4807 }
4808
4809 int ff_find_stream_index(AVFormatContext *s, int id)
4810 {
4811     int i;
4812     for (i = 0; i < s->nb_streams; i++)
4813         if (s->streams[i]->id == id)
4814             return i;
4815     return -1;
4816 }
4817
4818 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4819                          int std_compliance)
4820 {
4821     if (ofmt) {
4822         unsigned int codec_tag;
4823         if (ofmt->query_codec)
4824             return ofmt->query_codec(codec_id, std_compliance);
4825         else if (ofmt->codec_tag)
4826             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4827         else if (codec_id == ofmt->video_codec ||
4828                  codec_id == ofmt->audio_codec ||
4829                  codec_id == ofmt->subtitle_codec ||
4830                  codec_id == ofmt->data_codec)
4831             return 1;
4832     }
4833     return AVERROR_PATCHWELCOME;
4834 }
4835
4836 int avformat_network_init(void)
4837 {
4838 #if CONFIG_NETWORK
4839     int ret;
4840     ff_network_inited_globally = 1;
4841     if ((ret = ff_network_init()) < 0)
4842         return ret;
4843     if ((ret = ff_tls_init()) < 0)
4844         return ret;
4845 #endif
4846     return 0;
4847 }
4848
4849 int avformat_network_deinit(void)
4850 {
4851 #if CONFIG_NETWORK
4852     ff_network_close();
4853     ff_tls_deinit();
4854     ff_network_inited_globally = 0;
4855 #endif
4856     return 0;
4857 }
4858
4859 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4860                         uint64_t channel_layout, int32_t sample_rate,
4861                         int32_t width, int32_t height)
4862 {
4863     uint32_t flags = 0;
4864     int size = 4;
4865     uint8_t *data;
4866     if (!pkt)
4867         return AVERROR(EINVAL);
4868     if (channels) {
4869         size  += 4;
4870         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4871     }
4872     if (channel_layout) {
4873         size  += 8;
4874         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4875     }
4876     if (sample_rate) {
4877         size  += 4;
4878         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4879     }
4880     if (width || height) {
4881         size  += 8;
4882         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4883     }
4884     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4885     if (!data)
4886         return AVERROR(ENOMEM);
4887     bytestream_put_le32(&data, flags);
4888     if (channels)
4889         bytestream_put_le32(&data, channels);
4890     if (channel_layout)
4891         bytestream_put_le64(&data, channel_layout);
4892     if (sample_rate)
4893         bytestream_put_le32(&data, sample_rate);
4894     if (width || height) {
4895         bytestream_put_le32(&data, width);
4896         bytestream_put_le32(&data, height);
4897     }
4898     return 0;
4899 }
4900
4901 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4902 {
4903     AVRational undef = {0, 1};
4904     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4905     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4906     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4907
4908     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4909                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4910     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4911         stream_sample_aspect_ratio = undef;
4912
4913     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4914                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4915     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4916         frame_sample_aspect_ratio = undef;
4917
4918     if (stream_sample_aspect_ratio.num)
4919         return stream_sample_aspect_ratio;
4920     else
4921         return frame_sample_aspect_ratio;
4922 }
4923
4924 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4925 {
4926     AVRational fr = st->r_frame_rate;
4927     AVRational codec_fr = st->internal->avctx->framerate;
4928     AVRational   avg_fr = st->avg_frame_rate;
4929
4930     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4931         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4932         fr = avg_fr;
4933     }
4934
4935
4936     if (st->internal->avctx->ticks_per_frame > 1) {
4937         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4938             (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))
4939             fr = codec_fr;
4940     }
4941
4942     return fr;
4943 }
4944
4945 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4946                                     const char *spec)
4947 {
4948     if (*spec <= '9' && *spec >= '0') /* opt:index */
4949         return strtol(spec, NULL, 0) == st->index;
4950     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4951              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4952         enum AVMediaType type;
4953         int nopic = 0;
4954
4955         switch (*spec++) {
4956         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4957         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4958         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4959         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4960         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4961         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4962         default:  av_assert0(0);
4963         }
4964 #if FF_API_LAVF_AVCTX
4965 FF_DISABLE_DEPRECATION_WARNINGS
4966         if (type != st->codecpar->codec_type
4967            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4968             return 0;
4969 FF_ENABLE_DEPRECATION_WARNINGS
4970 #else
4971         if (type != st->codecpar->codec_type)
4972             return 0;
4973 #endif
4974         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4975             return 0;
4976         if (*spec++ == ':') { /* possibly followed by :index */
4977             int i, index = strtol(spec, NULL, 0);
4978             for (i = 0; i < s->nb_streams; i++) {
4979 #if FF_API_LAVF_AVCTX
4980 FF_DISABLE_DEPRECATION_WARNINGS
4981                 if ((s->streams[i]->codecpar->codec_type == type
4982                       || s->streams[i]->codec->codec_type == type
4983                     ) &&
4984                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4985                     index-- == 0)
4986                     return i == st->index;
4987 FF_ENABLE_DEPRECATION_WARNINGS
4988 #else
4989                 if ((s->streams[i]->codecpar->codec_type == type) &&
4990                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4991                     index-- == 0)
4992                     return i == st->index;
4993 #endif
4994             }
4995             return 0;
4996         }
4997         return 1;
4998     } else if (*spec == 'p' && *(spec + 1) == ':') {
4999         int prog_id, i, j;
5000         char *endptr;
5001         spec += 2;
5002         prog_id = strtol(spec, &endptr, 0);
5003         for (i = 0; i < s->nb_programs; i++) {
5004             if (s->programs[i]->id != prog_id)
5005                 continue;
5006
5007             if (*endptr++ == ':') {
5008                 int stream_idx = strtol(endptr, NULL, 0);
5009                 return stream_idx >= 0 &&
5010                     stream_idx < s->programs[i]->nb_stream_indexes &&
5011                     st->index == s->programs[i]->stream_index[stream_idx];
5012             }
5013
5014             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5015                 if (st->index == s->programs[i]->stream_index[j])
5016                     return 1;
5017         }
5018         return 0;
5019     } else if (*spec == '#' ||
5020                (*spec == 'i' && *(spec + 1) == ':')) {
5021         int stream_id;
5022         char *endptr;
5023         spec += 1 + (*spec == 'i');
5024         stream_id = strtol(spec, &endptr, 0);
5025         if (!*endptr)
5026             return stream_id == st->id;
5027     } else if (*spec == 'm' && *(spec + 1) == ':') {
5028         AVDictionaryEntry *tag;
5029         char *key, *val;
5030         int ret;
5031
5032         spec += 2;
5033         val = strchr(spec, ':');
5034
5035         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5036         if (!key)
5037             return AVERROR(ENOMEM);
5038
5039         tag = av_dict_get(st->metadata, key, NULL, 0);
5040         if (tag) {
5041             if (!val || !strcmp(tag->value, val + 1))
5042                 ret = 1;
5043             else
5044                 ret = 0;
5045         } else
5046             ret = 0;
5047
5048         av_freep(&key);
5049         return ret;
5050     } else if (*spec == 'u') {
5051         AVCodecParameters *par = st->codecpar;
5052 #if FF_API_LAVF_AVCTX
5053 FF_DISABLE_DEPRECATION_WARNINGS
5054         AVCodecContext *codec = st->codec;
5055 FF_ENABLE_DEPRECATION_WARNINGS
5056 #endif
5057         int val;
5058         switch (par->codec_type) {
5059         case AVMEDIA_TYPE_AUDIO:
5060             val = par->sample_rate && par->channels;
5061 #if FF_API_LAVF_AVCTX
5062             val = val || (codec->sample_rate && codec->channels);
5063 #endif
5064             if (par->format == AV_SAMPLE_FMT_NONE
5065 #if FF_API_LAVF_AVCTX
5066                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5067 #endif
5068                 )
5069                 return 0;
5070             break;
5071         case AVMEDIA_TYPE_VIDEO:
5072             val = par->width && par->height;
5073 #if FF_API_LAVF_AVCTX
5074             val = val || (codec->width && codec->height);
5075 #endif
5076             if (par->format == AV_PIX_FMT_NONE
5077 #if FF_API_LAVF_AVCTX
5078                 && codec->pix_fmt == AV_PIX_FMT_NONE
5079 #endif
5080                 )
5081                 return 0;
5082             break;
5083         case AVMEDIA_TYPE_UNKNOWN:
5084             val = 0;
5085             break;
5086         default:
5087             val = 1;
5088             break;
5089         }
5090 #if FF_API_LAVF_AVCTX
5091         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5092 #else
5093         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5094 #endif
5095     } else if (!*spec) /* empty specifier, matches everything */
5096         return 1;
5097
5098     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5099     return AVERROR(EINVAL);
5100 }
5101
5102 int ff_generate_avci_extradata(AVStream *st)
5103 {
5104     static const uint8_t avci100_1080p_extradata[] = {
5105         // SPS
5106         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5107         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5108         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5109         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5110         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5111         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5112         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5113         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5114         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5115         // PPS
5116         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5117         0xd0
5118     };
5119     static const uint8_t avci100_1080i_extradata[] = {
5120         // SPS
5121         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5122         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5123         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5124         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5125         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5126         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5127         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5128         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5129         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5130         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5131         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5132         // PPS
5133         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5134         0xd0
5135     };
5136     static const uint8_t avci50_1080p_extradata[] = {
5137         // SPS
5138         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5139         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5140         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5141         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5142         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5143         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5144         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5145         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5146         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5147         // PPS
5148         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5149         0x11
5150     };
5151     static const uint8_t avci50_1080i_extradata[] = {
5152         // SPS
5153         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5154         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5155         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5156         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5157         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5158         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5159         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5160         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5161         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5162         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5163         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5164         // PPS
5165         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5166         0x11
5167     };
5168     static const uint8_t avci100_720p_extradata[] = {
5169         // SPS
5170         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5171         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5172         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5173         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5174         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5175         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5176         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5177         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5178         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5179         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5180         // PPS
5181         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5182         0x11
5183     };
5184     static const uint8_t avci50_720p_extradata[] = {
5185         // SPS
5186         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5187         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5188         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5189         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5190         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5191         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5192         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5193         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5194         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5195         // PPS
5196         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5197         0x11
5198     };
5199
5200     const uint8_t *data = NULL;
5201     int size            = 0;
5202
5203     if (st->codecpar->width == 1920) {
5204         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5205             data = avci100_1080p_extradata;
5206             size = sizeof(avci100_1080p_extradata);
5207         } else {
5208             data = avci100_1080i_extradata;
5209             size = sizeof(avci100_1080i_extradata);
5210         }
5211     } else if (st->codecpar->width == 1440) {
5212         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5213             data = avci50_1080p_extradata;
5214             size = sizeof(avci50_1080p_extradata);
5215         } else {
5216             data = avci50_1080i_extradata;
5217             size = sizeof(avci50_1080i_extradata);
5218         }
5219     } else if (st->codecpar->width == 1280) {
5220         data = avci100_720p_extradata;
5221         size = sizeof(avci100_720p_extradata);
5222     } else if (st->codecpar->width == 960) {
5223         data = avci50_720p_extradata;
5224         size = sizeof(avci50_720p_extradata);
5225     }
5226
5227     if (!size)
5228         return 0;
5229
5230     av_freep(&st->codecpar->extradata);
5231     if (ff_alloc_extradata(st->codecpar, size))
5232         return AVERROR(ENOMEM);
5233     memcpy(st->codecpar->extradata, data, size);
5234
5235     return 0;
5236 }
5237
5238 #if FF_API_NOCONST_GET_SIDE_DATA
5239 uint8_t *av_stream_get_side_data(AVStream *st,
5240                                  enum AVPacketSideDataType type, int *size)
5241 #else
5242 uint8_t *av_stream_get_side_data(const AVStream *st,
5243                                  enum AVPacketSideDataType type, int *size)
5244 #endif
5245 {
5246     int i;
5247
5248     for (i = 0; i < st->nb_side_data; i++) {
5249         if (st->side_data[i].type == type) {
5250             if (size)
5251                 *size = st->side_data[i].size;
5252             return st->side_data[i].data;
5253         }
5254     }
5255     return NULL;
5256 }
5257
5258 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5259                             uint8_t *data, size_t size)
5260 {
5261     AVPacketSideData *sd, *tmp;
5262     int i;
5263
5264     for (i = 0; i < st->nb_side_data; i++) {
5265         sd = &st->side_data[i];
5266
5267         if (sd->type == type) {
5268             av_freep(&sd->data);
5269             sd->data = data;
5270             sd->size = size;
5271             return 0;
5272         }
5273     }
5274
5275     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5276         return AVERROR(ERANGE);
5277
5278     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5279     if (!tmp) {
5280         return AVERROR(ENOMEM);
5281     }
5282
5283     st->side_data = tmp;
5284     st->nb_side_data++;
5285
5286     sd = &st->side_data[st->nb_side_data - 1];
5287     sd->type = type;
5288     sd->data = data;
5289     sd->size = size;
5290
5291     return 0;
5292 }
5293
5294 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5295                                  int size)
5296 {
5297     int ret;
5298     uint8_t *data = av_malloc(size);
5299
5300     if (!data)
5301         return NULL;
5302
5303     ret = av_stream_add_side_data(st, type, data, size);
5304     if (ret < 0) {
5305         av_freep(&data);
5306         return NULL;
5307     }
5308
5309     return data;
5310 }
5311
5312 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5313 {
5314     int ret;
5315     const AVBitStreamFilter *bsf;
5316     AVBSFContext *bsfc;
5317     AVCodecParameters *in_par;
5318
5319     if (!(bsf = av_bsf_get_by_name(name))) {
5320         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5321         return AVERROR_BSF_NOT_FOUND;
5322     }
5323
5324     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5325         return ret;
5326
5327     if (st->internal->nb_bsfcs) {
5328         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5329         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5330     } else {
5331         in_par = st->codecpar;
5332         bsfc->time_base_in = st->time_base;
5333     }
5334
5335     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5336         av_bsf_free(&bsfc);
5337         return ret;
5338     }
5339
5340     if (args && bsfc->filter->priv_class) {
5341         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5342         const char * shorthand[2] = {NULL};
5343
5344         if (opt)
5345             shorthand[0] = opt->name;
5346
5347         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5348             av_bsf_free(&bsfc);
5349             return ret;
5350         }
5351     }
5352
5353     if ((ret = av_bsf_init(bsfc)) < 0) {
5354         av_bsf_free(&bsfc);
5355         return ret;
5356     }
5357
5358     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5359         av_bsf_free(&bsfc);
5360         return ret;
5361     }
5362
5363     av_log(NULL, AV_LOG_VERBOSE,
5364            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5365            name, args ? args : "");
5366     return 1;
5367 }
5368
5369 #if FF_API_OLD_BSF
5370 FF_DISABLE_DEPRECATION_WARNINGS
5371 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5372                                AVBitStreamFilterContext *bsfc)
5373 {
5374     int ret = 0;
5375     while (bsfc) {
5376         AVPacket new_pkt = *pkt;
5377         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5378                                            &new_pkt.data, &new_pkt.size,
5379                                            pkt->data, pkt->size,
5380                                            pkt->flags & AV_PKT_FLAG_KEY);
5381         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5382             av_packet_unref(pkt);
5383             memset(pkt, 0, sizeof(*pkt));
5384             return 0;
5385         }
5386         if(a == 0 && new_pkt.data != pkt->data) {
5387             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
5388             if (t) {
5389                 memcpy(t, new_pkt.data, new_pkt.size);
5390                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5391                 new_pkt.data = t;
5392                 new_pkt.buf = NULL;
5393                 a = 1;
5394             } else {
5395                 a = AVERROR(ENOMEM);
5396             }
5397         }
5398         if (a > 0) {
5399             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5400                                            av_buffer_default_free, NULL, 0);
5401             if (new_pkt.buf) {
5402                 pkt->side_data = NULL;
5403                 pkt->side_data_elems = 0;
5404                 av_packet_unref(pkt);
5405             } else {
5406                 av_freep(&new_pkt.data);
5407                 a = AVERROR(ENOMEM);
5408             }
5409         }
5410         if (a < 0) {
5411             av_log(codec, AV_LOG_ERROR,
5412                    "Failed to open bitstream filter %s for stream %d with codec %s",
5413                    bsfc->filter->name, pkt->stream_index,
5414                    codec->codec ? codec->codec->name : "copy");
5415             ret = a;
5416             break;
5417         }
5418         *pkt = new_pkt;
5419
5420         bsfc = bsfc->next;
5421     }
5422     return ret;
5423 }
5424 FF_ENABLE_DEPRECATION_WARNINGS
5425 #endif
5426
5427 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5428 {
5429     if (!s->oformat)
5430         return AVERROR(EINVAL);
5431
5432     if (!(s->oformat->flags & AVFMT_NOFILE))
5433         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5434     return 0;
5435 }
5436
5437 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5438 {
5439     if (*pb)
5440         s->io_close(s, *pb);
5441     *pb = NULL;
5442 }
5443
5444 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5445 {
5446     AVDictionaryEntry *entry;
5447     int64_t parsed_timestamp;
5448     int ret;
5449     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5450         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5451             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5452             return 1;
5453         } else {
5454             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5455             return ret;
5456         }
5457     }
5458     return 0;
5459 }
5460
5461 int ff_standardize_creation_time(AVFormatContext *s)
5462 {
5463     int64_t timestamp;
5464     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5465     if (ret == 1)
5466         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5467     return ret;
5468 }
5469
5470 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5471 {
5472     uint8_t *side_data;
5473     int size;
5474
5475     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5476     if (side_data) {
5477         if (size != AVPALETTE_SIZE) {
5478             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5479             return AVERROR_INVALIDDATA;
5480         }
5481         memcpy(palette, side_data, AVPALETTE_SIZE);
5482         return 1;
5483     }
5484
5485     if (ret == CONTAINS_PAL) {
5486         int i;
5487         for (i = 0; i < AVPALETTE_COUNT; i++)
5488             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5489         return 1;
5490     }
5491
5492     return 0;
5493 }
5494
5495 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5496 {
5497     int ret;
5498     char *str;
5499
5500     ret = av_bprint_finalize(buf, &str);
5501     if (ret < 0)
5502         return ret;
5503     if (!av_bprint_is_complete(buf)) {
5504         av_free(str);
5505         return AVERROR(ENOMEM);
5506     }
5507
5508     par->extradata = str;
5509     /* Note: the string is NUL terminated (so extradata can be read as a
5510      * string), but the ending character is not accounted in the size (in
5511      * binary formats you are likely not supposed to mux that character). When
5512      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5513      * zeros. */
5514     par->extradata_size = buf->len;
5515     return 0;
5516 }
5517
5518 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5519                                                   AVStream *ost, const AVStream *ist,
5520                                                   enum AVTimebaseSource copy_tb)
5521 {
5522     //TODO: use [io]st->internal->avctx
5523     const AVCodecContext *dec_ctx = ist->codec;
5524     AVCodecContext       *enc_ctx = ost->codec;
5525
5526     enc_ctx->time_base = ist->time_base;
5527     /*
5528      * Avi is a special case here because it supports variable fps but
5529      * having the fps and timebase differe significantly adds quite some
5530      * overhead
5531      */
5532     if (!strcmp(ofmt->name, "avi")) {
5533 #if FF_API_R_FRAME_RATE
5534         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5535             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5536             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5537             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5538             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5539             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5540             enc_ctx->time_base.num = ist->r_frame_rate.den;
5541             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5542             enc_ctx->ticks_per_frame = 2;
5543         } else
5544 #endif
5545             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5546                    && av_q2d(ist->time_base) < 1.0/500
5547                    || copy_tb == AVFMT_TBCF_DECODER) {
5548             enc_ctx->time_base = dec_ctx->time_base;
5549             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5550             enc_ctx->time_base.den *= 2;
5551             enc_ctx->ticks_per_frame = 2;
5552         }
5553     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5554                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5555         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5556             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5557             && av_q2d(ist->time_base) < 1.0/500
5558             || copy_tb == AVFMT_TBCF_DECODER) {
5559             enc_ctx->time_base = dec_ctx->time_base;
5560             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5561         }
5562     }
5563
5564     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5565         && dec_ctx->time_base.num < dec_ctx->time_base.den
5566         && dec_ctx->time_base.num > 0
5567         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5568         enc_ctx->time_base = dec_ctx->time_base;
5569     }
5570
5571     if (ost->avg_frame_rate.num)
5572         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5573
5574     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5575               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5576
5577     return 0;
5578 }
5579
5580 AVRational av_stream_get_codec_timebase(const AVStream *st)
5581 {
5582     // See avformat_transfer_internal_stream_timing_info() TODO.
5583 #if FF_API_LAVF_AVCTX
5584 FF_DISABLE_DEPRECATION_WARNINGS
5585     return st->codec->time_base;
5586 FF_ENABLE_DEPRECATION_WARNINGS
5587 #else
5588     return st->internal->avctx->time_base;
5589 #endif
5590 }