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