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 &&
2601                         p->end_time > p->start_time &&
2602                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2603                         duration = FFMAX(duration, p->end_time - p->start_time);
2604                 }
2605             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2606                 duration = FFMAX(duration, end_time - start_time);
2607             }
2608         }
2609     }
2610     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2611         ic->duration = duration;
2612     }
2613     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2614         /* compute the bitrate */
2615         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2616                          (double) ic->duration;
2617         if (bitrate >= 0 && bitrate <= INT64_MAX)
2618             ic->bit_rate = bitrate;
2619     }
2620 }
2621
2622 static void fill_all_stream_timings(AVFormatContext *ic)
2623 {
2624     int i;
2625     AVStream *st;
2626
2627     update_stream_timings(ic);
2628     for (i = 0; i < ic->nb_streams; i++) {
2629         st = ic->streams[i];
2630         if (st->start_time == AV_NOPTS_VALUE) {
2631             if (ic->start_time != AV_NOPTS_VALUE)
2632                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2633                                               st->time_base);
2634             if (ic->duration != AV_NOPTS_VALUE)
2635                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2636                                             st->time_base);
2637         }
2638     }
2639 }
2640
2641 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2642 {
2643     int64_t filesize, duration;
2644     int i, show_warning = 0;
2645     AVStream *st;
2646
2647     /* if bit_rate is already set, we believe it */
2648     if (ic->bit_rate <= 0) {
2649         int64_t bit_rate = 0;
2650         for (i = 0; i < ic->nb_streams; i++) {
2651             st = ic->streams[i];
2652             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2653                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2654             if (st->codecpar->bit_rate > 0) {
2655                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2656                     bit_rate = 0;
2657                     break;
2658                 }
2659                 bit_rate += st->codecpar->bit_rate;
2660             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2661                 // If we have a videostream with packets but without a bitrate
2662                 // then consider the sum not known
2663                 bit_rate = 0;
2664                 break;
2665             }
2666         }
2667         ic->bit_rate = bit_rate;
2668     }
2669
2670     /* if duration is already set, we believe it */
2671     if (ic->duration == AV_NOPTS_VALUE &&
2672         ic->bit_rate != 0) {
2673         filesize = ic->pb ? avio_size(ic->pb) : 0;
2674         if (filesize > ic->internal->data_offset) {
2675             filesize -= ic->internal->data_offset;
2676             for (i = 0; i < ic->nb_streams; i++) {
2677                 st      = ic->streams[i];
2678                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2679                     && st->duration == AV_NOPTS_VALUE) {
2680                     duration = av_rescale(8 * filesize, st->time_base.den,
2681                                           ic->bit_rate *
2682                                           (int64_t) st->time_base.num);
2683                     st->duration = duration;
2684                     show_warning = 1;
2685                 }
2686             }
2687         }
2688     }
2689     if (show_warning)
2690         av_log(ic, AV_LOG_WARNING,
2691                "Estimating duration from bitrate, this may be inaccurate\n");
2692 }
2693
2694 #define DURATION_MAX_READ_SIZE 250000LL
2695 #define DURATION_MAX_RETRY 6
2696
2697 /* only usable for MPEG-PS streams */
2698 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2699 {
2700     AVPacket pkt1, *pkt = &pkt1;
2701     AVStream *st;
2702     int num, den, read_size, i, ret;
2703     int found_duration = 0;
2704     int is_end;
2705     int64_t filesize, offset, duration;
2706     int retry = 0;
2707
2708     /* flush packet queue */
2709     flush_packet_queue(ic);
2710
2711     for (i = 0; i < ic->nb_streams; i++) {
2712         st = ic->streams[i];
2713         if (st->start_time == AV_NOPTS_VALUE &&
2714             st->first_dts == AV_NOPTS_VALUE &&
2715             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2716             av_log(ic, AV_LOG_WARNING,
2717                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2718
2719         if (st->parser) {
2720             av_parser_close(st->parser);
2721             st->parser = NULL;
2722         }
2723     }
2724
2725     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2726     /* estimate the end time (duration) */
2727     /* XXX: may need to support wrapping */
2728     filesize = ic->pb ? avio_size(ic->pb) : 0;
2729     do {
2730         is_end = found_duration;
2731         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2732         if (offset < 0)
2733             offset = 0;
2734
2735         avio_seek(ic->pb, offset, SEEK_SET);
2736         read_size = 0;
2737         for (;;) {
2738             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2739                 break;
2740
2741             do {
2742                 ret = ff_read_packet(ic, pkt);
2743             } while (ret == AVERROR(EAGAIN));
2744             if (ret != 0)
2745                 break;
2746             read_size += pkt->size;
2747             st         = ic->streams[pkt->stream_index];
2748             if (pkt->pts != AV_NOPTS_VALUE &&
2749                 (st->start_time != AV_NOPTS_VALUE ||
2750                  st->first_dts  != AV_NOPTS_VALUE)) {
2751                 if (pkt->duration == 0) {
2752                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2753                     if (den && num) {
2754                         pkt->duration = av_rescale_rnd(1,
2755                                            num * (int64_t) st->time_base.den,
2756                                            den * (int64_t) st->time_base.num,
2757                                            AV_ROUND_DOWN);
2758                     }
2759                 }
2760                 duration = pkt->pts + pkt->duration;
2761                 found_duration = 1;
2762                 if (st->start_time != AV_NOPTS_VALUE)
2763                     duration -= st->start_time;
2764                 else
2765                     duration -= st->first_dts;
2766                 if (duration > 0) {
2767                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2768                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2769                         st->duration = duration;
2770                     st->info->last_duration = duration;
2771                 }
2772             }
2773             av_packet_unref(pkt);
2774         }
2775
2776         /* check if all audio/video streams have valid duration */
2777         if (!is_end) {
2778             is_end = 1;
2779             for (i = 0; i < ic->nb_streams; i++) {
2780                 st = ic->streams[i];
2781                 switch (st->codecpar->codec_type) {
2782                     case AVMEDIA_TYPE_VIDEO:
2783                     case AVMEDIA_TYPE_AUDIO:
2784                         if (st->duration == AV_NOPTS_VALUE)
2785                             is_end = 0;
2786                 }
2787             }
2788         }
2789     } while (!is_end &&
2790              offset &&
2791              ++retry <= DURATION_MAX_RETRY);
2792
2793     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2794
2795     /* warn about audio/video streams which duration could not be estimated */
2796     for (i = 0; i < ic->nb_streams; i++) {
2797         st = ic->streams[i];
2798         if (st->duration == AV_NOPTS_VALUE) {
2799             switch (st->codecpar->codec_type) {
2800             case AVMEDIA_TYPE_VIDEO:
2801             case AVMEDIA_TYPE_AUDIO:
2802                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2803                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2804                 } else
2805                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2806             }
2807         }
2808     }
2809     fill_all_stream_timings(ic);
2810
2811     avio_seek(ic->pb, old_offset, SEEK_SET);
2812     for (i = 0; i < ic->nb_streams; i++) {
2813         int j;
2814
2815         st              = ic->streams[i];
2816         st->cur_dts     = st->first_dts;
2817         st->last_IP_pts = AV_NOPTS_VALUE;
2818         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2819         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2820             st->pts_buffer[j] = AV_NOPTS_VALUE;
2821     }
2822 }
2823
2824 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2825 {
2826     int64_t file_size;
2827
2828     /* get the file size, if possible */
2829     if (ic->iformat->flags & AVFMT_NOFILE) {
2830         file_size = 0;
2831     } else {
2832         file_size = avio_size(ic->pb);
2833         file_size = FFMAX(0, file_size);
2834     }
2835
2836     if ((!strcmp(ic->iformat->name, "mpeg") ||
2837          !strcmp(ic->iformat->name, "mpegts")) &&
2838         file_size && ic->pb->seekable) {
2839         /* get accurate estimate from the PTSes */
2840         estimate_timings_from_pts(ic, old_offset);
2841         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2842     } else if (has_duration(ic)) {
2843         /* at least one component has timings - we use them for all
2844          * the components */
2845         fill_all_stream_timings(ic);
2846         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2847     } else {
2848         /* less precise: use bitrate info */
2849         estimate_timings_from_bit_rate(ic);
2850         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2851     }
2852     update_stream_timings(ic);
2853
2854     {
2855         int i;
2856         AVStream av_unused *st;
2857         for (i = 0; i < ic->nb_streams; i++) {
2858             st = ic->streams[i];
2859             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2860                    (double) st->start_time * av_q2d(st->time_base),
2861                    (double) st->duration   * av_q2d(st->time_base));
2862         }
2863         av_log(ic, AV_LOG_TRACE,
2864                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2865                 (double) ic->start_time / AV_TIME_BASE,
2866                 (double) ic->duration   / AV_TIME_BASE,
2867                 (int64_t)ic->bit_rate / 1000);
2868     }
2869 }
2870
2871 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2872 {
2873     AVCodecContext *avctx = st->internal->avctx;
2874
2875 #define FAIL(errmsg) do {                                         \
2876         if (errmsg_ptr)                                           \
2877             *errmsg_ptr = errmsg;                                 \
2878         return 0;                                                 \
2879     } while (0)
2880
2881     if (   avctx->codec_id == AV_CODEC_ID_NONE
2882         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2883         FAIL("unknown codec");
2884     switch (avctx->codec_type) {
2885     case AVMEDIA_TYPE_AUDIO:
2886         if (!avctx->frame_size && determinable_frame_size(avctx))
2887             FAIL("unspecified frame size");
2888         if (st->info->found_decoder >= 0 &&
2889             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2890             FAIL("unspecified sample format");
2891         if (!avctx->sample_rate)
2892             FAIL("unspecified sample rate");
2893         if (!avctx->channels)
2894             FAIL("unspecified number of channels");
2895         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2896             FAIL("no decodable DTS frames");
2897         break;
2898     case AVMEDIA_TYPE_VIDEO:
2899         if (!avctx->width)
2900             FAIL("unspecified size");
2901         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2902             FAIL("unspecified pixel format");
2903         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2904             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2905                 FAIL("no frame in rv30/40 and no sar");
2906         break;
2907     case AVMEDIA_TYPE_SUBTITLE:
2908         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2909             FAIL("unspecified size");
2910         break;
2911     case AVMEDIA_TYPE_DATA:
2912         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2913     }
2914
2915     return 1;
2916 }
2917
2918 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2919 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2920                             AVDictionary **options)
2921 {
2922     AVCodecContext *avctx = st->internal->avctx;
2923     const AVCodec *codec;
2924     int got_picture = 1, ret = 0;
2925     AVFrame *frame = av_frame_alloc();
2926     AVSubtitle subtitle;
2927     AVPacket pkt = *avpkt;
2928     int do_skip_frame = 0;
2929     enum AVDiscard skip_frame;
2930
2931     if (!frame)
2932         return AVERROR(ENOMEM);
2933
2934     if (!avcodec_is_open(avctx) &&
2935         st->info->found_decoder <= 0 &&
2936         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2937         AVDictionary *thread_opt = NULL;
2938
2939         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2940
2941         if (!codec) {
2942             st->info->found_decoder = -st->codecpar->codec_id;
2943             ret                     = -1;
2944             goto fail;
2945         }
2946
2947         /* Force thread count to 1 since the H.264 decoder will not extract
2948          * SPS and PPS to extradata during multi-threaded decoding. */
2949         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2950         if (s->codec_whitelist)
2951             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2952         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2953         if (!options)
2954             av_dict_free(&thread_opt);
2955         if (ret < 0) {
2956             st->info->found_decoder = -avctx->codec_id;
2957             goto fail;
2958         }
2959         st->info->found_decoder = 1;
2960     } else if (!st->info->found_decoder)
2961         st->info->found_decoder = 1;
2962
2963     if (st->info->found_decoder < 0) {
2964         ret = -1;
2965         goto fail;
2966     }
2967
2968     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2969         do_skip_frame = 1;
2970         skip_frame = avctx->skip_frame;
2971         avctx->skip_frame = AVDISCARD_ALL;
2972     }
2973
2974     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2975            ret >= 0 &&
2976            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2977             (!st->codec_info_nb_frames &&
2978              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2979         got_picture = 0;
2980         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2981             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2982             ret = avcodec_send_packet(avctx, &pkt);
2983             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2984                 break;
2985             if (ret >= 0)
2986                 pkt.size = 0;
2987             ret = avcodec_receive_frame(avctx, frame);
2988             if (ret >= 0)
2989                 got_picture = 1;
2990             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2991                 ret = 0;
2992         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2993             ret = avcodec_decode_subtitle2(avctx, &subtitle,
2994                                            &got_picture, &pkt);
2995             if (ret >= 0)
2996                 pkt.size = 0;
2997         }
2998         if (ret >= 0) {
2999             if (got_picture)
3000                 st->nb_decoded_frames++;
3001             ret       = got_picture;
3002         }
3003     }
3004
3005     if (!pkt.data && !got_picture)
3006         ret = -1;
3007
3008 fail:
3009     if (do_skip_frame) {
3010         avctx->skip_frame = skip_frame;
3011     }
3012
3013     av_frame_free(&frame);
3014     return ret;
3015 }
3016
3017 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3018 {
3019     while (tags->id != AV_CODEC_ID_NONE) {
3020         if (tags->id == id)
3021             return tags->tag;
3022         tags++;
3023     }
3024     return 0;
3025 }
3026
3027 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3028 {
3029     int i;
3030     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3031         if (tag == tags[i].tag)
3032             return tags[i].id;
3033     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3034         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3035             return tags[i].id;
3036     return AV_CODEC_ID_NONE;
3037 }
3038
3039 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3040 {
3041     if (bps <= 0 || bps > 64)
3042         return AV_CODEC_ID_NONE;
3043
3044     if (flt) {
3045         switch (bps) {
3046         case 32:
3047             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3048         case 64:
3049             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3050         default:
3051             return AV_CODEC_ID_NONE;
3052         }
3053     } else {
3054         bps  += 7;
3055         bps >>= 3;
3056         if (sflags & (1 << (bps - 1))) {
3057             switch (bps) {
3058             case 1:
3059                 return AV_CODEC_ID_PCM_S8;
3060             case 2:
3061                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3062             case 3:
3063                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3064             case 4:
3065                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3066             case 8:
3067                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3068             default:
3069                 return AV_CODEC_ID_NONE;
3070             }
3071         } else {
3072             switch (bps) {
3073             case 1:
3074                 return AV_CODEC_ID_PCM_U8;
3075             case 2:
3076                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3077             case 3:
3078                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3079             case 4:
3080                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3081             default:
3082                 return AV_CODEC_ID_NONE;
3083             }
3084         }
3085     }
3086 }
3087
3088 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3089 {
3090     unsigned int tag;
3091     if (!av_codec_get_tag2(tags, id, &tag))
3092         return 0;
3093     return tag;
3094 }
3095
3096 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3097                       unsigned int *tag)
3098 {
3099     int i;
3100     for (i = 0; tags && tags[i]; i++) {
3101         const AVCodecTag *codec_tags = tags[i];
3102         while (codec_tags->id != AV_CODEC_ID_NONE) {
3103             if (codec_tags->id == id) {
3104                 *tag = codec_tags->tag;
3105                 return 1;
3106             }
3107             codec_tags++;
3108         }
3109     }
3110     return 0;
3111 }
3112
3113 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3114 {
3115     int i;
3116     for (i = 0; tags && tags[i]; i++) {
3117         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3118         if (id != AV_CODEC_ID_NONE)
3119             return id;
3120     }
3121     return AV_CODEC_ID_NONE;
3122 }
3123
3124 static void compute_chapters_end(AVFormatContext *s)
3125 {
3126     unsigned int i, j;
3127     int64_t max_time = 0;
3128
3129     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3130         max_time = s->duration +
3131                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3132
3133     for (i = 0; i < s->nb_chapters; i++)
3134         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3135             AVChapter *ch = s->chapters[i];
3136             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3137                                                   ch->time_base)
3138                                    : INT64_MAX;
3139
3140             for (j = 0; j < s->nb_chapters; j++) {
3141                 AVChapter *ch1     = s->chapters[j];
3142                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3143                                                   ch->time_base);
3144                 if (j != i && next_start > ch->start && next_start < end)
3145                     end = next_start;
3146             }
3147             ch->end = (end == INT64_MAX) ? ch->start : end;
3148         }
3149 }
3150
3151 static int get_std_framerate(int i)
3152 {
3153     if (i < 30*12)
3154         return (i + 1) * 1001;
3155     i -= 30*12;
3156
3157     if (i < 30)
3158         return (i + 31) * 1001 * 12;
3159     i -= 30;
3160
3161     if (i < 3)
3162         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3163
3164     i -= 3;
3165
3166     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3167 }
3168
3169 /* Is the time base unreliable?
3170  * This is a heuristic to balance between quick acceptance of the values in
3171  * the headers vs. some extra checks.
3172  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3173  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3174  * And there are "variable" fps files this needs to detect as well. */
3175 static int tb_unreliable(AVCodecContext *c)
3176 {
3177     if (c->time_base.den >= 101LL * c->time_base.num ||
3178         c->time_base.den <    5LL * c->time_base.num ||
3179         // c->codec_tag == AV_RL32("DIVX") ||
3180         // c->codec_tag == AV_RL32("XVID") ||
3181         c->codec_tag == AV_RL32("mp4v") ||
3182         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3183         c->codec_id == AV_CODEC_ID_GIF ||
3184         c->codec_id == AV_CODEC_ID_HEVC ||
3185         c->codec_id == AV_CODEC_ID_H264)
3186         return 1;
3187     return 0;
3188 }
3189
3190 int ff_alloc_extradata(AVCodecParameters *par, int size)
3191 {
3192     int ret;
3193
3194     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3195         par->extradata = NULL;
3196         par->extradata_size = 0;
3197         return AVERROR(EINVAL);
3198     }
3199     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3200     if (par->extradata) {
3201         memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3202         par->extradata_size = size;
3203         ret = 0;
3204     } else {
3205         par->extradata_size = 0;
3206         ret = AVERROR(ENOMEM);
3207     }
3208     return ret;
3209 }
3210
3211 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3212 {
3213     int ret = ff_alloc_extradata(par, size);
3214     if (ret < 0)
3215         return ret;
3216     ret = avio_read(pb, par->extradata, size);
3217     if (ret != size) {
3218         av_freep(&par->extradata);
3219         par->extradata_size = 0;
3220         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3221         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3222     }
3223
3224     return ret;
3225 }
3226
3227 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3228 {
3229     int i, j;
3230     int64_t last = st->info->last_dts;
3231
3232     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3233        && ts - (uint64_t)last < INT64_MAX) {
3234         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3235         int64_t duration = ts - last;
3236
3237         if (!st->info->duration_error)
3238             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3239         if (!st->info->duration_error)
3240             return AVERROR(ENOMEM);
3241
3242 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3243 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3244         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3245             if (st->info->duration_error[0][1][i] < 1e10) {
3246                 int framerate = get_std_framerate(i);
3247                 double sdts = dts*framerate/(1001*12);
3248                 for (j= 0; j<2; j++) {
3249                     int64_t ticks = llrint(sdts+j*0.5);
3250                     double error= sdts - ticks + j*0.5;
3251                     st->info->duration_error[j][0][i] += error;
3252                     st->info->duration_error[j][1][i] += error*error;
3253                 }
3254             }
3255         }
3256         st->info->duration_count++;
3257         st->info->rfps_duration_sum += duration;
3258
3259         if (st->info->duration_count % 10 == 0) {
3260             int n = st->info->duration_count;
3261             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3262                 if (st->info->duration_error[0][1][i] < 1e10) {
3263                     double a0     = st->info->duration_error[0][0][i] / n;
3264                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3265                     double a1     = st->info->duration_error[1][0][i] / n;
3266                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3267                     if (error0 > 0.04 && error1 > 0.04) {
3268                         st->info->duration_error[0][1][i] = 2e10;
3269                         st->info->duration_error[1][1][i] = 2e10;
3270                     }
3271                 }
3272             }
3273         }
3274
3275         // ignore the first 4 values, they might have some random jitter
3276         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3277             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3278     }
3279     if (ts != AV_NOPTS_VALUE)
3280         st->info->last_dts = ts;
3281
3282     return 0;
3283 }
3284
3285 void ff_rfps_calculate(AVFormatContext *ic)
3286 {
3287     int i, j;
3288
3289     for (i = 0; i < ic->nb_streams; i++) {
3290         AVStream *st = ic->streams[i];
3291
3292         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3293             continue;
3294         // the check for tb_unreliable() is not completely correct, since this is not about handling
3295         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3296         // ipmovie.c produces.
3297         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)
3298             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);
3299         if (st->info->duration_count>1 && !st->r_frame_rate.num
3300             && tb_unreliable(st->internal->avctx)) {
3301             int num = 0;
3302             double best_error= 0.01;
3303             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3304
3305             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3306                 int k;
3307
3308                 if (st->info->codec_info_duration &&
3309                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3310                     continue;
3311                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3312                     continue;
3313
3314                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3315                     continue;
3316
3317                 for (k= 0; k<2; k++) {
3318                     int n = st->info->duration_count;
3319                     double a= st->info->duration_error[k][0][j] / n;
3320                     double error= st->info->duration_error[k][1][j]/n - a*a;
3321
3322                     if (error < best_error && best_error> 0.000000001) {
3323                         best_error= error;
3324                         num = get_std_framerate(j);
3325                     }
3326                     if (error < 0.02)
3327                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3328                 }
3329             }
3330             // do not increase frame rate by more than 1 % in order to match a standard rate.
3331             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3332                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3333         }
3334         if (   !st->avg_frame_rate.num
3335             && st->r_frame_rate.num && st->info->rfps_duration_sum
3336             && st->info->codec_info_duration <= 0
3337             && st->info->duration_count > 2
3338             && 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
3339             ) {
3340             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3341             st->avg_frame_rate = st->r_frame_rate;
3342         }
3343
3344         av_freep(&st->info->duration_error);
3345         st->info->last_dts = AV_NOPTS_VALUE;
3346         st->info->duration_count = 0;
3347         st->info->rfps_duration_sum = 0;
3348     }
3349 }
3350
3351 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3352 {
3353     int i, count = 0, ret = 0, j;
3354     int64_t read_size;
3355     AVStream *st;
3356     AVCodecContext *avctx;
3357     AVPacket pkt1, *pkt;
3358     int64_t old_offset  = avio_tell(ic->pb);
3359     // new streams might appear, no options for those
3360     int orig_nb_streams = ic->nb_streams;
3361     int flush_codecs;
3362     int64_t max_analyze_duration = ic->max_analyze_duration;
3363     int64_t max_stream_analyze_duration;
3364     int64_t max_subtitle_analyze_duration;
3365     int64_t probesize = ic->probesize;
3366     int eof_reached = 0;
3367     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3368
3369     flush_codecs = probesize > 0;
3370
3371     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3372
3373     max_stream_analyze_duration = max_analyze_duration;
3374     max_subtitle_analyze_duration = max_analyze_duration;
3375     if (!max_analyze_duration) {
3376         max_stream_analyze_duration =
3377         max_analyze_duration        = 5*AV_TIME_BASE;
3378         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3379         if (!strcmp(ic->iformat->name, "flv"))
3380             max_stream_analyze_duration = 90*AV_TIME_BASE;
3381         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3382             max_stream_analyze_duration = 7*AV_TIME_BASE;
3383     }
3384
3385     if (ic->pb)
3386         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3387                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3388
3389     for (i = 0; i < ic->nb_streams; i++) {
3390         const AVCodec *codec;
3391         AVDictionary *thread_opt = NULL;
3392         st = ic->streams[i];
3393         avctx = st->internal->avctx;
3394
3395         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3396             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3397 /*            if (!st->time_base.num)
3398                 st->time_base = */
3399             if (!avctx->time_base.num)
3400                 avctx->time_base = st->time_base;
3401         }
3402
3403         /* check if the caller has overridden the codec id */
3404 #if FF_API_LAVF_AVCTX
3405 FF_DISABLE_DEPRECATION_WARNINGS
3406         if (st->codec->codec_id != st->internal->orig_codec_id) {
3407             st->codecpar->codec_id   = st->codec->codec_id;
3408             st->codecpar->codec_type = st->codec->codec_type;
3409             st->internal->orig_codec_id = st->codec->codec_id;
3410         }
3411 FF_ENABLE_DEPRECATION_WARNINGS
3412 #endif
3413         // only for the split stuff
3414         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3415             st->parser = av_parser_init(st->codecpar->codec_id);
3416             if (st->parser) {
3417                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3418                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3419                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3420                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3421                 }
3422             } else if (st->need_parsing) {
3423                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3424                        "%s, packets or times may be invalid.\n",
3425                        avcodec_get_name(st->codecpar->codec_id));
3426             }
3427         }
3428
3429         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3430             st->internal->orig_codec_id = st->codecpar->codec_id;
3431
3432         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3433         if (ret < 0)
3434             goto find_stream_info_err;
3435         if (st->request_probe <= 0)
3436             st->internal->avctx_inited = 1;
3437
3438         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3439
3440         /* Force thread count to 1 since the H.264 decoder will not extract
3441          * SPS and PPS to extradata during multi-threaded decoding. */
3442         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3443
3444         if (ic->codec_whitelist)
3445             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3446
3447         /* Ensure that subtitle_header is properly set. */
3448         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3449             && codec && !avctx->codec) {
3450             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3451                 av_log(ic, AV_LOG_WARNING,
3452                        "Failed to open codec in %s\n",__FUNCTION__);
3453         }
3454
3455         // Try to just open decoders, in case this is enough to get parameters.
3456         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3457             if (codec && !avctx->codec)
3458                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3459                     av_log(ic, AV_LOG_WARNING,
3460                            "Failed to open codec in %s\n",__FUNCTION__);
3461         }
3462         if (!options)
3463             av_dict_free(&thread_opt);
3464     }
3465
3466     for (i = 0; i < ic->nb_streams; i++) {
3467 #if FF_API_R_FRAME_RATE
3468         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3469 #endif
3470         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3471         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3472     }
3473
3474     read_size = 0;
3475     for (;;) {
3476         int analyzed_all_streams;
3477         if (ff_check_interrupt(&ic->interrupt_callback)) {
3478             ret = AVERROR_EXIT;
3479             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3480             break;
3481         }
3482
3483         /* check if one codec still needs to be handled */
3484         for (i = 0; i < ic->nb_streams; i++) {
3485             int fps_analyze_framecount = 20;
3486
3487             st = ic->streams[i];
3488             if (!has_codec_parameters(st, NULL))
3489                 break;
3490             /* If the timebase is coarse (like the usual millisecond precision
3491              * of mkv), we need to analyze more frames to reliably arrive at
3492              * the correct fps. */
3493             if (av_q2d(st->time_base) > 0.0005)
3494                 fps_analyze_framecount *= 2;
3495             if (!tb_unreliable(st->internal->avctx))
3496                 fps_analyze_framecount = 0;
3497             if (ic->fps_probe_size >= 0)
3498                 fps_analyze_framecount = ic->fps_probe_size;
3499             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3500                 fps_analyze_framecount = 0;
3501             /* variable fps and no guess at the real fps */
3502             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3503                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3504                 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3505                     st->info->codec_info_duration_fields/2 :
3506                     st->info->duration_count;
3507                 if (count < fps_analyze_framecount)
3508                     break;
3509             }
3510             if (st->parser && st->parser->parser->split &&
3511                 !st->internal->avctx->extradata)
3512                 break;
3513             if (st->first_dts == AV_NOPTS_VALUE &&
3514                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3515                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3516                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3517                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3518                 break;
3519         }
3520         analyzed_all_streams = 0;
3521         if (!missing_streams || !*missing_streams)
3522         if (i == ic->nb_streams) {
3523             analyzed_all_streams = 1;
3524             /* NOTE: If the format has no header, then we need to read some
3525              * packets to get most of the streams, so we cannot stop here. */
3526             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3527                 /* If we found the info for all the codecs, we can stop. */
3528                 ret = count;
3529                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3530                 flush_codecs = 0;
3531                 break;
3532             }
3533         }
3534         /* We did not get all the codec info, but we read too much data. */
3535         if (read_size >= probesize) {
3536             ret = count;
3537             av_log(ic, AV_LOG_DEBUG,
3538                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3539             for (i = 0; i < ic->nb_streams; i++)
3540                 if (!ic->streams[i]->r_frame_rate.num &&
3541                     ic->streams[i]->info->duration_count <= 1 &&
3542                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3543                     strcmp(ic->iformat->name, "image2"))
3544                     av_log(ic, AV_LOG_WARNING,
3545                            "Stream #%d: not enough frames to estimate rate; "
3546                            "consider increasing probesize\n", i);
3547             break;
3548         }
3549
3550         /* NOTE: A new stream can be added there if no header in file
3551          * (AVFMTCTX_NOHEADER). */
3552         ret = read_frame_internal(ic, &pkt1);
3553         if (ret == AVERROR(EAGAIN))
3554             continue;
3555
3556         if (ret < 0) {
3557             /* EOF or error*/
3558             eof_reached = 1;
3559             break;
3560         }
3561
3562         pkt = &pkt1;
3563
3564         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3565             ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3566                                 &ic->internal->packet_buffer_end, 0);
3567             if (ret < 0)
3568                 goto find_stream_info_err;
3569         }
3570
3571         st = ic->streams[pkt->stream_index];
3572         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3573             read_size += pkt->size;
3574
3575         avctx = st->internal->avctx;
3576         if (!st->internal->avctx_inited) {
3577             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3578             if (ret < 0)
3579                 goto find_stream_info_err;
3580             st->internal->avctx_inited = 1;
3581         }
3582
3583         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3584             /* check for non-increasing dts */
3585             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3586                 st->info->fps_last_dts >= pkt->dts) {
3587                 av_log(ic, AV_LOG_DEBUG,
3588                        "Non-increasing DTS in stream %d: packet %d with DTS "
3589                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3590                        st->index, st->info->fps_last_dts_idx,
3591                        st->info->fps_last_dts, st->codec_info_nb_frames,
3592                        pkt->dts);
3593                 st->info->fps_first_dts =
3594                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3595             }
3596             /* Check for a discontinuity in dts. If the difference in dts
3597              * is more than 1000 times the average packet duration in the
3598              * sequence, we treat it as a discontinuity. */
3599             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3600                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3601                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3602                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3603                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3604                 av_log(ic, AV_LOG_WARNING,
3605                        "DTS discontinuity in stream %d: packet %d with DTS "
3606                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3607                        st->index, st->info->fps_last_dts_idx,
3608                        st->info->fps_last_dts, st->codec_info_nb_frames,
3609                        pkt->dts);
3610                 st->info->fps_first_dts =
3611                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3612             }
3613
3614             /* update stored dts values */
3615             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3616                 st->info->fps_first_dts     = pkt->dts;
3617                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3618             }
3619             st->info->fps_last_dts     = pkt->dts;
3620             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3621         }
3622         if (st->codec_info_nb_frames>1) {
3623             int64_t t = 0;
3624             int64_t limit;
3625
3626             if (st->time_base.den > 0)
3627                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3628             if (st->avg_frame_rate.num > 0)
3629                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3630
3631             if (   t == 0
3632                 && st->codec_info_nb_frames>30
3633                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3634                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3635                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3636
3637             if (analyzed_all_streams)                                limit = max_analyze_duration;
3638             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3639             else                                                     limit = max_stream_analyze_duration;
3640
3641             if (t >= limit) {
3642                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3643                        limit,
3644                        t, pkt->stream_index);
3645                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3646                     av_packet_unref(pkt);
3647                 break;
3648             }
3649             if (pkt->duration) {
3650                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3651                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3652                 } else
3653                     st->info->codec_info_duration += pkt->duration;
3654                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3655             }
3656         }
3657 #if FF_API_R_FRAME_RATE
3658         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3659             ff_rfps_add_frame(ic, st, pkt->dts);
3660 #endif
3661         if (st->parser && st->parser->parser->split && !avctx->extradata) {
3662             int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
3663             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3664                 avctx->extradata_size = i;
3665                 avctx->extradata      = av_mallocz(avctx->extradata_size +
3666                                                    AV_INPUT_BUFFER_PADDING_SIZE);
3667                 if (!avctx->extradata)
3668                     return AVERROR(ENOMEM);
3669                 memcpy(avctx->extradata, pkt->data,
3670                        avctx->extradata_size);
3671             }
3672         }
3673
3674         /* If still no information, we try to open the codec and to
3675          * decompress the frame. We try to avoid that in most cases as
3676          * it takes longer and uses more memory. For MPEG-4, we need to
3677          * decompress for QuickTime.
3678          *
3679          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3680          * least one frame of codec data, this makes sure the codec initializes
3681          * the channel configuration and does not only trust the values from
3682          * the container. */
3683         try_decode_frame(ic, st, pkt,
3684                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3685
3686         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3687             av_packet_unref(pkt);
3688
3689         st->codec_info_nb_frames++;
3690         count++;
3691     }
3692
3693     if (eof_reached) {
3694         int stream_index;
3695         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3696             st = ic->streams[stream_index];
3697             avctx = st->internal->avctx;
3698             if (!has_codec_parameters(st, NULL)) {
3699                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3700                 if (codec && !avctx->codec) {
3701                     AVDictionary *opts = NULL;
3702                     if (ic->codec_whitelist)
3703                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3704                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3705                         av_log(ic, AV_LOG_WARNING,
3706                                "Failed to open codec in %s\n",__FUNCTION__);
3707                     av_dict_free(&opts);
3708                 }
3709             }
3710
3711             // EOF already reached while reading the stream above.
3712             // So continue with reoordering DTS with whatever delay we have.
3713             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3714                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3715             }
3716         }
3717     }
3718
3719     if (flush_codecs) {
3720         AVPacket empty_pkt = { 0 };
3721         int err = 0;
3722         av_init_packet(&empty_pkt);
3723
3724         for (i = 0; i < ic->nb_streams; i++) {
3725
3726             st = ic->streams[i];
3727
3728             /* flush the decoders */
3729             if (st->info->found_decoder == 1) {
3730                 do {
3731                     err = try_decode_frame(ic, st, &empty_pkt,
3732                                             (options && i < orig_nb_streams)
3733                                             ? &options[i] : NULL);
3734                 } while (err > 0 && !has_codec_parameters(st, NULL));
3735
3736                 if (err < 0) {
3737                     av_log(ic, AV_LOG_INFO,
3738                         "decoding for stream %d failed\n", st->index);
3739                 }
3740             }
3741         }
3742     }
3743
3744     // close codecs which were opened in try_decode_frame()
3745     for (i = 0; i < ic->nb_streams; i++) {
3746         st = ic->streams[i];
3747         avcodec_close(st->internal->avctx);
3748     }
3749
3750     ff_rfps_calculate(ic);
3751
3752     for (i = 0; i < ic->nb_streams; i++) {
3753         st = ic->streams[i];
3754         avctx = st->internal->avctx;
3755         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3756             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3757                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3758                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3759                     avctx->codec_tag= tag;
3760             }
3761
3762             /* estimate average framerate if not set by demuxer */
3763             if (st->info->codec_info_duration_fields &&
3764                 !st->avg_frame_rate.num &&
3765                 st->info->codec_info_duration) {
3766                 int best_fps      = 0;
3767                 double best_error = 0.01;
3768
3769                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3770                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3771                     st->info->codec_info_duration        < 0)
3772                     continue;
3773                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3774                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3775                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3776
3777                 /* Round guessed framerate to a "standard" framerate if it's
3778                  * within 1% of the original estimate. */
3779                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3780                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3781                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3782                                               av_q2d(std_fps) - 1);
3783
3784                     if (error < best_error) {
3785                         best_error = error;
3786                         best_fps   = std_fps.num;
3787                     }
3788                 }
3789                 if (best_fps)
3790                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3791                               best_fps, 12 * 1001, INT_MAX);
3792             }
3793
3794             if (!st->r_frame_rate.num) {
3795                 if (    avctx->time_base.den * (int64_t) st->time_base.num
3796                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3797                     st->r_frame_rate.num = avctx->time_base.den;
3798                     st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
3799                 } else {
3800                     st->r_frame_rate.num = st->time_base.den;
3801                     st->r_frame_rate.den = st->time_base.num;
3802                 }
3803             }
3804             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3805                 AVRational hw_ratio = { avctx->height, avctx->width };
3806                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3807                                                    hw_ratio);
3808             }
3809         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3810             if (!avctx->bits_per_coded_sample)
3811                 avctx->bits_per_coded_sample =
3812                     av_get_bits_per_sample(avctx->codec_id);
3813             // set stream disposition based on audio service type
3814             switch (avctx->audio_service_type) {
3815             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3816                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3817                 break;
3818             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3819                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3820                 break;
3821             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3822                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3823                 break;
3824             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3825                 st->disposition = AV_DISPOSITION_COMMENT;
3826                 break;
3827             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3828                 st->disposition = AV_DISPOSITION_KARAOKE;
3829                 break;
3830             }
3831         }
3832     }
3833
3834     if (probesize)
3835         estimate_timings(ic, old_offset);
3836
3837     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3838
3839     if (ret >= 0 && ic->nb_streams)
3840         /* We could not have all the codec parameters before EOF. */
3841         ret = -1;
3842     for (i = 0; i < ic->nb_streams; i++) {
3843         const char *errmsg;
3844         st = ic->streams[i];
3845
3846         /* if no packet was ever seen, update context now for has_codec_parameters */
3847         if (!st->internal->avctx_inited) {
3848             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3849                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3850                 st->codecpar->format = st->internal->avctx->sample_fmt;
3851             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3852             if (ret < 0)
3853                 goto find_stream_info_err;
3854         }
3855         if (!has_codec_parameters(st, &errmsg)) {
3856             char buf[256];
3857             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
3858             av_log(ic, AV_LOG_WARNING,
3859                    "Could not find codec parameters for stream %d (%s): %s\n"
3860                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3861                    i, buf, errmsg);
3862         } else {
3863             ret = 0;
3864         }
3865     }
3866
3867     compute_chapters_end(ic);
3868
3869     /* update the stream parameters from the internal codec contexts */
3870     for (i = 0; i < ic->nb_streams; i++) {
3871         st = ic->streams[i];
3872
3873         if (st->internal->avctx_inited) {
3874             int orig_w = st->codecpar->width;
3875             int orig_h = st->codecpar->height;
3876             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
3877             if (ret < 0)
3878                 goto find_stream_info_err;
3879             // The decoder might reduce the video size by the lowres factor.
3880             if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
3881                 st->codecpar->width = orig_w;
3882                 st->codecpar->height = orig_h;
3883             }
3884         }
3885
3886 #if FF_API_LAVF_AVCTX
3887 FF_DISABLE_DEPRECATION_WARNINGS
3888         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
3889         if (ret < 0)
3890             goto find_stream_info_err;
3891
3892         // The old API (AVStream.codec) "requires" the resolution to be adjusted
3893         // by the lowres factor.
3894         if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
3895             av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
3896             st->codec->width = st->internal->avctx->width;
3897             st->codec->height = st->internal->avctx->height;
3898         }
3899
3900         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
3901             st->codec->time_base = st->internal->avctx->time_base;
3902             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
3903         }
3904         st->codec->framerate = st->avg_frame_rate;
3905
3906         if (st->internal->avctx->subtitle_header) {
3907             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
3908             if (!st->codec->subtitle_header)
3909                 goto find_stream_info_err;
3910             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
3911             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
3912                    st->codec->subtitle_header_size);
3913         }
3914
3915         // Fields unavailable in AVCodecParameters
3916         st->codec->coded_width = st->internal->avctx->coded_width;
3917         st->codec->coded_height = st->internal->avctx->coded_height;
3918         st->codec->properties = st->internal->avctx->properties;
3919 FF_ENABLE_DEPRECATION_WARNINGS
3920 #endif
3921
3922         st->internal->avctx_inited = 0;
3923     }
3924
3925 find_stream_info_err:
3926     for (i = 0; i < ic->nb_streams; i++) {
3927         st = ic->streams[i];
3928         if (st->info)
3929             av_freep(&st->info->duration_error);
3930         av_freep(&ic->streams[i]->info);
3931     }
3932     if (ic->pb)
3933         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3934                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3935     return ret;
3936 }
3937
3938 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3939 {
3940     int i, j;
3941
3942     for (i = 0; i < ic->nb_programs; i++) {
3943         if (ic->programs[i] == last) {
3944             last = NULL;
3945         } else {
3946             if (!last)
3947                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3948                     if (ic->programs[i]->stream_index[j] == s)
3949                         return ic->programs[i];
3950         }
3951     }
3952     return NULL;
3953 }
3954
3955 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3956                         int wanted_stream_nb, int related_stream,
3957                         AVCodec **decoder_ret, int flags)
3958 {
3959     int i, nb_streams = ic->nb_streams;
3960     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3961     unsigned *program = NULL;
3962     const AVCodec *decoder = NULL, *best_decoder = NULL;
3963
3964     if (related_stream >= 0 && wanted_stream_nb < 0) {
3965         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3966         if (p) {
3967             program    = p->stream_index;
3968             nb_streams = p->nb_stream_indexes;
3969         }
3970     }
3971     for (i = 0; i < nb_streams; i++) {
3972         int real_stream_index = program ? program[i] : i;
3973         AVStream *st          = ic->streams[real_stream_index];
3974         AVCodecParameters *par = st->codecpar;
3975         if (par->codec_type != type)
3976             continue;
3977         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3978             continue;
3979         if (wanted_stream_nb != real_stream_index &&
3980             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3981                                AV_DISPOSITION_VISUAL_IMPAIRED))
3982             continue;
3983         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
3984             continue;
3985         if (decoder_ret) {
3986             decoder = find_decoder(ic, st, par->codec_id);
3987             if (!decoder) {
3988                 if (ret < 0)
3989                     ret = AVERROR_DECODER_NOT_FOUND;
3990                 continue;
3991             }
3992         }
3993         count = st->codec_info_nb_frames;
3994         bitrate = par->bit_rate;
3995         multiframe = FFMIN(5, count);
3996         if ((best_multiframe >  multiframe) ||
3997             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3998             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3999             continue;
4000         best_count   = count;
4001         best_bitrate = bitrate;
4002         best_multiframe = multiframe;
4003         ret          = real_stream_index;
4004         best_decoder = decoder;
4005         if (program && i == nb_streams - 1 && ret < 0) {
4006             program    = NULL;
4007             nb_streams = ic->nb_streams;
4008             /* no related stream found, try again with everything */
4009             i = 0;
4010         }
4011     }
4012     if (decoder_ret)
4013         *decoder_ret = (AVCodec*)best_decoder;
4014     return ret;
4015 }
4016
4017 /*******************************************************/
4018
4019 int av_read_play(AVFormatContext *s)
4020 {
4021     if (s->iformat->read_play)
4022         return s->iformat->read_play(s);
4023     if (s->pb)
4024         return avio_pause(s->pb, 0);
4025     return AVERROR(ENOSYS);
4026 }
4027
4028 int av_read_pause(AVFormatContext *s)
4029 {
4030     if (s->iformat->read_pause)
4031         return s->iformat->read_pause(s);
4032     if (s->pb)
4033         return avio_pause(s->pb, 1);
4034     return AVERROR(ENOSYS);
4035 }
4036
4037 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4038 {
4039     int ret, i;
4040
4041     dst->id                  = src->id;
4042     dst->time_base           = src->time_base;
4043     dst->nb_frames           = src->nb_frames;
4044     dst->disposition         = src->disposition;
4045     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4046     dst->avg_frame_rate      = src->avg_frame_rate;
4047     dst->r_frame_rate        = src->r_frame_rate;
4048
4049     av_dict_free(&dst->metadata);
4050     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4051     if (ret < 0)
4052         return ret;
4053
4054     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4055     if (ret < 0)
4056         return ret;
4057
4058     /* Free existing side data*/
4059     for (i = 0; i < dst->nb_side_data; i++)
4060         av_free(dst->side_data[i].data);
4061     av_freep(&dst->side_data);
4062     dst->nb_side_data = 0;
4063
4064     /* Copy side data if present */
4065     if (src->nb_side_data) {
4066         dst->side_data = av_mallocz_array(src->nb_side_data,
4067                                           sizeof(AVPacketSideData));
4068         if (!dst->side_data)
4069             return AVERROR(ENOMEM);
4070         dst->nb_side_data = src->nb_side_data;
4071
4072         for (i = 0; i < src->nb_side_data; i++) {
4073             uint8_t *data = av_memdup(src->side_data[i].data,
4074                                       src->side_data[i].size);
4075             if (!data)
4076                 return AVERROR(ENOMEM);
4077             dst->side_data[i].type = src->side_data[i].type;
4078             dst->side_data[i].size = src->side_data[i].size;
4079             dst->side_data[i].data = data;
4080         }
4081     }
4082
4083     av_freep(&dst->recommended_encoder_configuration);
4084     if (src->recommended_encoder_configuration) {
4085         const char *conf_str = src->recommended_encoder_configuration;
4086         dst->recommended_encoder_configuration = av_strdup(conf_str);
4087         if (!dst->recommended_encoder_configuration)
4088             return AVERROR(ENOMEM);
4089     }
4090
4091     return 0;
4092 }
4093
4094 static void free_stream(AVStream **pst)
4095 {
4096     AVStream *st = *pst;
4097     int i;
4098
4099     if (!st)
4100         return;
4101
4102     for (i = 0; i < st->nb_side_data; i++)
4103         av_freep(&st->side_data[i].data);
4104     av_freep(&st->side_data);
4105
4106     if (st->parser)
4107         av_parser_close(st->parser);
4108
4109     if (st->attached_pic.data)
4110         av_packet_unref(&st->attached_pic);
4111
4112     if (st->internal) {
4113         avcodec_free_context(&st->internal->avctx);
4114         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4115             av_bsf_free(&st->internal->bsfcs[i]);
4116             av_freep(&st->internal->bsfcs);
4117         }
4118     }
4119     av_freep(&st->internal);
4120
4121     av_dict_free(&st->metadata);
4122     avcodec_parameters_free(&st->codecpar);
4123     av_freep(&st->probe_data.buf);
4124     av_freep(&st->index_entries);
4125 #if FF_API_LAVF_AVCTX
4126 FF_DISABLE_DEPRECATION_WARNINGS
4127     av_freep(&st->codec->extradata);
4128     av_freep(&st->codec->subtitle_header);
4129     av_freep(&st->codec);
4130 FF_ENABLE_DEPRECATION_WARNINGS
4131 #endif
4132     av_freep(&st->priv_data);
4133     if (st->info)
4134         av_freep(&st->info->duration_error);
4135     av_freep(&st->info);
4136     av_freep(&st->recommended_encoder_configuration);
4137     av_freep(&st->priv_pts);
4138
4139     av_freep(pst);
4140 }
4141
4142 void ff_free_stream(AVFormatContext *s, AVStream *st)
4143 {
4144     av_assert0(s->nb_streams>0);
4145     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4146
4147     free_stream(&s->streams[ --s->nb_streams ]);
4148 }
4149
4150 void avformat_free_context(AVFormatContext *s)
4151 {
4152     int i;
4153
4154     if (!s)
4155         return;
4156
4157     av_opt_free(s);
4158     if (s->iformat && s->iformat->priv_class && s->priv_data)
4159         av_opt_free(s->priv_data);
4160     if (s->oformat && s->oformat->priv_class && s->priv_data)
4161         av_opt_free(s->priv_data);
4162
4163     for (i = s->nb_streams - 1; i >= 0; i--)
4164         ff_free_stream(s, s->streams[i]);
4165
4166
4167     for (i = s->nb_programs - 1; i >= 0; i--) {
4168         av_dict_free(&s->programs[i]->metadata);
4169         av_freep(&s->programs[i]->stream_index);
4170         av_freep(&s->programs[i]);
4171     }
4172     av_freep(&s->programs);
4173     av_freep(&s->priv_data);
4174     while (s->nb_chapters--) {
4175         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4176         av_freep(&s->chapters[s->nb_chapters]);
4177     }
4178     av_freep(&s->chapters);
4179     av_dict_free(&s->metadata);
4180     av_freep(&s->streams);
4181     av_freep(&s->internal);
4182     flush_packet_queue(s);
4183     av_free(s);
4184 }
4185
4186 void avformat_close_input(AVFormatContext **ps)
4187 {
4188     AVFormatContext *s;
4189     AVIOContext *pb;
4190
4191     if (!ps || !*ps)
4192         return;
4193
4194     s  = *ps;
4195     pb = s->pb;
4196
4197     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4198         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4199         pb = NULL;
4200
4201     flush_packet_queue(s);
4202
4203     if (s->iformat)
4204         if (s->iformat->read_close)
4205             s->iformat->read_close(s);
4206
4207     avformat_free_context(s);
4208
4209     *ps = NULL;
4210
4211     avio_close(pb);
4212 }
4213
4214 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4215 {
4216     AVStream *st;
4217     int i;
4218     AVStream **streams;
4219
4220     if (s->nb_streams >= INT_MAX/sizeof(*streams))
4221         return NULL;
4222     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4223     if (!streams)
4224         return NULL;
4225     s->streams = streams;
4226
4227     st = av_mallocz(sizeof(AVStream));
4228     if (!st)
4229         return NULL;
4230     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4231         av_free(st);
4232         return NULL;
4233     }
4234     st->info->last_dts = AV_NOPTS_VALUE;
4235
4236 #if FF_API_LAVF_AVCTX
4237 FF_DISABLE_DEPRECATION_WARNINGS
4238     st->codec = avcodec_alloc_context3(c);
4239     if (!st->codec) {
4240         av_free(st->info);
4241         av_free(st);
4242         return NULL;
4243     }
4244 FF_ENABLE_DEPRECATION_WARNINGS
4245 #endif
4246
4247     st->internal = av_mallocz(sizeof(*st->internal));
4248     if (!st->internal)
4249         goto fail;
4250
4251     st->codecpar = avcodec_parameters_alloc();
4252     if (!st->codecpar)
4253         goto fail;
4254
4255     st->internal->avctx = avcodec_alloc_context3(NULL);
4256     if (!st->internal->avctx)
4257         goto fail;
4258
4259     if (s->iformat) {
4260 #if FF_API_LAVF_AVCTX
4261 FF_DISABLE_DEPRECATION_WARNINGS
4262         /* no default bitrate if decoding */
4263         st->codec->bit_rate = 0;
4264 FF_ENABLE_DEPRECATION_WARNINGS
4265 #endif
4266
4267         /* default pts setting is MPEG-like */
4268         avpriv_set_pts_info(st, 33, 1, 90000);
4269         /* we set the current DTS to 0 so that formats without any timestamps
4270          * but durations get some timestamps, formats with some unknown
4271          * timestamps have their first few packets buffered and the
4272          * timestamps corrected before they are returned to the user */
4273         st->cur_dts = RELATIVE_TS_BASE;
4274     } else {
4275         st->cur_dts = AV_NOPTS_VALUE;
4276     }
4277
4278     st->index      = s->nb_streams;
4279     st->start_time = AV_NOPTS_VALUE;
4280     st->duration   = AV_NOPTS_VALUE;
4281     st->first_dts     = AV_NOPTS_VALUE;
4282     st->probe_packets = MAX_PROBE_PACKETS;
4283     st->pts_wrap_reference = AV_NOPTS_VALUE;
4284     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4285
4286     st->last_IP_pts = AV_NOPTS_VALUE;
4287     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4288     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4289         st->pts_buffer[i] = AV_NOPTS_VALUE;
4290
4291     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4292
4293 #if FF_API_R_FRAME_RATE
4294     st->info->last_dts      = AV_NOPTS_VALUE;
4295 #endif
4296     st->info->fps_first_dts = AV_NOPTS_VALUE;
4297     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4298
4299     st->inject_global_side_data = s->internal->inject_global_side_data;
4300
4301     st->internal->need_context_update = 1;
4302
4303     s->streams[s->nb_streams++] = st;
4304     return st;
4305 fail:
4306     free_stream(&st);
4307     return NULL;
4308 }
4309
4310 AVProgram *av_new_program(AVFormatContext *ac, int id)
4311 {
4312     AVProgram *program = NULL;
4313     int i;
4314
4315     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4316
4317     for (i = 0; i < ac->nb_programs; i++)
4318         if (ac->programs[i]->id == id)
4319             program = ac->programs[i];
4320
4321     if (!program) {
4322         program = av_mallocz(sizeof(AVProgram));
4323         if (!program)
4324             return NULL;
4325         dynarray_add(&ac->programs, &ac->nb_programs, program);
4326         program->discard = AVDISCARD_NONE;
4327     }
4328     program->id = id;
4329     program->pts_wrap_reference = AV_NOPTS_VALUE;
4330     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4331
4332     program->start_time =
4333     program->end_time   = AV_NOPTS_VALUE;
4334
4335     return program;
4336 }
4337
4338 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4339                               int64_t start, int64_t end, const char *title)
4340 {
4341     AVChapter *chapter = NULL;
4342     int i;
4343
4344     if (end != AV_NOPTS_VALUE && start > end) {
4345         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4346         return NULL;
4347     }
4348
4349     for (i = 0; i < s->nb_chapters; i++)
4350         if (s->chapters[i]->id == id)
4351             chapter = s->chapters[i];
4352
4353     if (!chapter) {
4354         chapter = av_mallocz(sizeof(AVChapter));
4355         if (!chapter)
4356             return NULL;
4357         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4358     }
4359     av_dict_set(&chapter->metadata, "title", title, 0);
4360     chapter->id        = id;
4361     chapter->time_base = time_base;
4362     chapter->start     = start;
4363     chapter->end       = end;
4364
4365     return chapter;
4366 }
4367
4368 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4369 {
4370     int i, j;
4371     AVProgram *program = NULL;
4372     void *tmp;
4373
4374     if (idx >= ac->nb_streams) {
4375         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4376         return;
4377     }
4378
4379     for (i = 0; i < ac->nb_programs; i++) {
4380         if (ac->programs[i]->id != progid)
4381             continue;
4382         program = ac->programs[i];
4383         for (j = 0; j < program->nb_stream_indexes; j++)
4384             if (program->stream_index[j] == idx)
4385                 return;
4386
4387         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4388         if (!tmp)
4389             return;
4390         program->stream_index = tmp;
4391         program->stream_index[program->nb_stream_indexes++] = idx;
4392         return;
4393     }
4394 }
4395
4396 uint64_t ff_ntp_time(void)
4397 {
4398     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4399 }
4400
4401 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4402 {
4403     const char *p;
4404     char *q, buf1[20], c;
4405     int nd, len, percentd_found;
4406
4407     q = buf;
4408     p = path;
4409     percentd_found = 0;
4410     for (;;) {
4411         c = *p++;
4412         if (c == '\0')
4413             break;
4414         if (c == '%') {
4415             do {
4416                 nd = 0;
4417                 while (av_isdigit(*p))
4418                     nd = nd * 10 + *p++ - '0';
4419                 c = *p++;
4420             } while (av_isdigit(c));
4421
4422             switch (c) {
4423             case '%':
4424                 goto addchar;
4425             case 'd':
4426                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4427                     goto fail;
4428                 percentd_found = 1;
4429                 if (number < 0)
4430                     nd += 1;
4431                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4432                 len = strlen(buf1);
4433                 if ((q - buf + len) > buf_size - 1)
4434                     goto fail;
4435                 memcpy(q, buf1, len);
4436                 q += len;
4437                 break;
4438             default:
4439                 goto fail;
4440             }
4441         } else {
4442 addchar:
4443             if ((q - buf) < buf_size - 1)
4444                 *q++ = c;
4445         }
4446     }
4447     if (!percentd_found)
4448         goto fail;
4449     *q = '\0';
4450     return 0;
4451 fail:
4452     *q = '\0';
4453     return -1;
4454 }
4455
4456 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4457 {
4458     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4459 }
4460
4461 void av_url_split(char *proto, int proto_size,
4462                   char *authorization, int authorization_size,
4463                   char *hostname, int hostname_size,
4464                   int *port_ptr, char *path, int path_size, const char *url)
4465 {
4466     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4467
4468     if (port_ptr)
4469         *port_ptr = -1;
4470     if (proto_size > 0)
4471         proto[0] = 0;
4472     if (authorization_size > 0)
4473         authorization[0] = 0;
4474     if (hostname_size > 0)
4475         hostname[0] = 0;
4476     if (path_size > 0)
4477         path[0] = 0;
4478
4479     /* parse protocol */
4480     if ((p = strchr(url, ':'))) {
4481         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4482         p++; /* skip ':' */
4483         if (*p == '/')
4484             p++;
4485         if (*p == '/')
4486             p++;
4487     } else {
4488         /* no protocol means plain filename */
4489         av_strlcpy(path, url, path_size);
4490         return;
4491     }
4492
4493     /* separate path from hostname */
4494     ls = strchr(p, '/');
4495     ls2 = strchr(p, '?');
4496     if (!ls)
4497         ls = ls2;
4498     else if (ls && ls2)
4499         ls = FFMIN(ls, ls2);
4500     if (ls)
4501         av_strlcpy(path, ls, path_size);
4502     else
4503         ls = &p[strlen(p)];  // XXX
4504
4505     /* the rest is hostname, use that to parse auth/port */
4506     if (ls != p) {
4507         /* authorization (user[:pass]@hostname) */
4508         at2 = p;
4509         while ((at = strchr(p, '@')) && at < ls) {
4510             av_strlcpy(authorization, at2,
4511                        FFMIN(authorization_size, at + 1 - at2));
4512             p = at + 1; /* skip '@' */
4513         }
4514
4515         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4516             /* [host]:port */
4517             av_strlcpy(hostname, p + 1,
4518                        FFMIN(hostname_size, brk - p));
4519             if (brk[1] == ':' && port_ptr)
4520                 *port_ptr = atoi(brk + 2);
4521         } else if ((col = strchr(p, ':')) && col < ls) {
4522             av_strlcpy(hostname, p,
4523                        FFMIN(col + 1 - p, hostname_size));
4524             if (port_ptr)
4525                 *port_ptr = atoi(col + 1);
4526         } else
4527             av_strlcpy(hostname, p,
4528                        FFMIN(ls + 1 - p, hostname_size));
4529     }
4530 }
4531
4532 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4533 {
4534     int i;
4535     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4536                                            '4', '5', '6', '7',
4537                                            '8', '9', 'A', 'B',
4538                                            'C', 'D', 'E', 'F' };
4539     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4540                                            '4', '5', '6', '7',
4541                                            '8', '9', 'a', 'b',
4542                                            'c', 'd', 'e', 'f' };
4543     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4544
4545     for (i = 0; i < s; i++) {
4546         buff[i * 2]     = hex_table[src[i] >> 4];
4547         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4548     }
4549
4550     return buff;
4551 }
4552
4553 int ff_hex_to_data(uint8_t *data, const char *p)
4554 {
4555     int c, len, v;
4556
4557     len = 0;
4558     v   = 1;
4559     for (;;) {
4560         p += strspn(p, SPACE_CHARS);
4561         if (*p == '\0')
4562             break;
4563         c = av_toupper((unsigned char) *p++);
4564         if (c >= '0' && c <= '9')
4565             c = c - '0';
4566         else if (c >= 'A' && c <= 'F')
4567             c = c - 'A' + 10;
4568         else
4569             break;
4570         v = (v << 4) | c;
4571         if (v & 0x100) {
4572             if (data)
4573                 data[len] = v;
4574             len++;
4575             v = 1;
4576         }
4577     }
4578     return len;
4579 }
4580
4581 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4582                          unsigned int pts_num, unsigned int pts_den)
4583 {
4584     AVRational new_tb;
4585     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4586         if (new_tb.num != pts_num)
4587             av_log(NULL, AV_LOG_DEBUG,
4588                    "st:%d removing common factor %d from timebase\n",
4589                    s->index, pts_num / new_tb.num);
4590     } else
4591         av_log(NULL, AV_LOG_WARNING,
4592                "st:%d has too large timebase, reducing\n", s->index);
4593
4594     if (new_tb.num <= 0 || new_tb.den <= 0) {
4595         av_log(NULL, AV_LOG_ERROR,
4596                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4597                new_tb.num, new_tb.den,
4598                s->index);
4599         return;
4600     }
4601     s->time_base     = new_tb;
4602 #if FF_API_LAVF_AVCTX
4603 FF_DISABLE_DEPRECATION_WARNINGS
4604     av_codec_set_pkt_timebase(s->codec, new_tb);
4605 FF_ENABLE_DEPRECATION_WARNINGS
4606 #endif
4607     av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4608     s->pts_wrap_bits = pts_wrap_bits;
4609 }
4610
4611 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4612                         void *context)
4613 {
4614     const char *ptr = str;
4615
4616     /* Parse key=value pairs. */
4617     for (;;) {
4618         const char *key;
4619         char *dest = NULL, *dest_end;
4620         int key_len, dest_len = 0;
4621
4622         /* Skip whitespace and potential commas. */
4623         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4624             ptr++;
4625         if (!*ptr)
4626             break;
4627
4628         key = ptr;
4629
4630         if (!(ptr = strchr(key, '=')))
4631             break;
4632         ptr++;
4633         key_len = ptr - key;
4634
4635         callback_get_buf(context, key, key_len, &dest, &dest_len);
4636         dest_end = dest + dest_len - 1;
4637
4638         if (*ptr == '\"') {
4639             ptr++;
4640             while (*ptr && *ptr != '\"') {
4641                 if (*ptr == '\\') {
4642                     if (!ptr[1])
4643                         break;
4644                     if (dest && dest < dest_end)
4645                         *dest++ = ptr[1];
4646                     ptr += 2;
4647                 } else {
4648                     if (dest && dest < dest_end)
4649                         *dest++ = *ptr;
4650                     ptr++;
4651                 }
4652             }
4653             if (*ptr == '\"')
4654                 ptr++;
4655         } else {
4656             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4657                 if (dest && dest < dest_end)
4658                     *dest++ = *ptr;
4659         }
4660         if (dest)
4661             *dest = 0;
4662     }
4663 }
4664
4665 int ff_find_stream_index(AVFormatContext *s, int id)
4666 {
4667     int i;
4668     for (i = 0; i < s->nb_streams; i++)
4669         if (s->streams[i]->id == id)
4670             return i;
4671     return -1;
4672 }
4673
4674 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4675                          int std_compliance)
4676 {
4677     if (ofmt) {
4678         unsigned int codec_tag;
4679         if (ofmt->query_codec)
4680             return ofmt->query_codec(codec_id, std_compliance);
4681         else if (ofmt->codec_tag)
4682             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4683         else if (codec_id == ofmt->video_codec ||
4684                  codec_id == ofmt->audio_codec ||
4685                  codec_id == ofmt->subtitle_codec ||
4686                  codec_id == ofmt->data_codec)
4687             return 1;
4688     }
4689     return AVERROR_PATCHWELCOME;
4690 }
4691
4692 int avformat_network_init(void)
4693 {
4694 #if CONFIG_NETWORK
4695     int ret;
4696     ff_network_inited_globally = 1;
4697     if ((ret = ff_network_init()) < 0)
4698         return ret;
4699     if ((ret = ff_tls_init()) < 0)
4700         return ret;
4701 #endif
4702     return 0;
4703 }
4704
4705 int avformat_network_deinit(void)
4706 {
4707 #if CONFIG_NETWORK
4708     ff_network_close();
4709     ff_tls_deinit();
4710     ff_network_inited_globally = 0;
4711 #endif
4712     return 0;
4713 }
4714
4715 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4716                         uint64_t channel_layout, int32_t sample_rate,
4717                         int32_t width, int32_t height)
4718 {
4719     uint32_t flags = 0;
4720     int size = 4;
4721     uint8_t *data;
4722     if (!pkt)
4723         return AVERROR(EINVAL);
4724     if (channels) {
4725         size  += 4;
4726         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4727     }
4728     if (channel_layout) {
4729         size  += 8;
4730         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4731     }
4732     if (sample_rate) {
4733         size  += 4;
4734         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4735     }
4736     if (width || height) {
4737         size  += 8;
4738         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4739     }
4740     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4741     if (!data)
4742         return AVERROR(ENOMEM);
4743     bytestream_put_le32(&data, flags);
4744     if (channels)
4745         bytestream_put_le32(&data, channels);
4746     if (channel_layout)
4747         bytestream_put_le64(&data, channel_layout);
4748     if (sample_rate)
4749         bytestream_put_le32(&data, sample_rate);
4750     if (width || height) {
4751         bytestream_put_le32(&data, width);
4752         bytestream_put_le32(&data, height);
4753     }
4754     return 0;
4755 }
4756
4757 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4758 {
4759     AVRational undef = {0, 1};
4760     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4761     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4762     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4763
4764     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4765                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4766     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4767         stream_sample_aspect_ratio = undef;
4768
4769     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4770                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4771     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4772         frame_sample_aspect_ratio = undef;
4773
4774     if (stream_sample_aspect_ratio.num)
4775         return stream_sample_aspect_ratio;
4776     else
4777         return frame_sample_aspect_ratio;
4778 }
4779
4780 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4781 {
4782     AVRational fr = st->r_frame_rate;
4783     AVRational codec_fr = st->internal->avctx->framerate;
4784     AVRational   avg_fr = st->avg_frame_rate;
4785
4786     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4787         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4788         fr = avg_fr;
4789     }
4790
4791
4792     if (st->internal->avctx->ticks_per_frame > 1) {
4793         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4794             (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))
4795             fr = codec_fr;
4796     }
4797
4798     return fr;
4799 }
4800
4801 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4802                                     const char *spec)
4803 {
4804     if (*spec <= '9' && *spec >= '0') /* opt:index */
4805         return strtol(spec, NULL, 0) == st->index;
4806     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4807              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4808         enum AVMediaType type;
4809         int nopic = 0;
4810
4811         switch (*spec++) {
4812         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4813         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4814         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4815         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4816         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4817         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4818         default:  av_assert0(0);
4819         }
4820 #if FF_API_LAVF_AVCTX
4821 FF_DISABLE_DEPRECATION_WARNINGS
4822         if (type != st->codecpar->codec_type
4823            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4824             return 0;
4825 FF_ENABLE_DEPRECATION_WARNINGS
4826 #else
4827         if (type != st->codecpar->codec_type)
4828             return 0;
4829 #endif
4830         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4831             return 0;
4832         if (*spec++ == ':') { /* possibly followed by :index */
4833             int i, index = strtol(spec, NULL, 0);
4834             for (i = 0; i < s->nb_streams; i++) {
4835 #if FF_API_LAVF_AVCTX
4836 FF_DISABLE_DEPRECATION_WARNINGS
4837                 if ((s->streams[i]->codecpar->codec_type == type
4838                       || s->streams[i]->codec->codec_type == type
4839                     ) &&
4840                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4841                     index-- == 0)
4842                     return i == st->index;
4843 FF_ENABLE_DEPRECATION_WARNINGS
4844 #else
4845                 if ((s->streams[i]->codecpar->codec_type == type) &&
4846                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4847                     index-- == 0)
4848                     return i == st->index;
4849 #endif
4850             }
4851             return 0;
4852         }
4853         return 1;
4854     } else if (*spec == 'p' && *(spec + 1) == ':') {
4855         int prog_id, i, j;
4856         char *endptr;
4857         spec += 2;
4858         prog_id = strtol(spec, &endptr, 0);
4859         for (i = 0; i < s->nb_programs; i++) {
4860             if (s->programs[i]->id != prog_id)
4861                 continue;
4862
4863             if (*endptr++ == ':') {
4864                 int stream_idx = strtol(endptr, NULL, 0);
4865                 return stream_idx >= 0 &&
4866                     stream_idx < s->programs[i]->nb_stream_indexes &&
4867                     st->index == s->programs[i]->stream_index[stream_idx];
4868             }
4869
4870             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4871                 if (st->index == s->programs[i]->stream_index[j])
4872                     return 1;
4873         }
4874         return 0;
4875     } else if (*spec == '#' ||
4876                (*spec == 'i' && *(spec + 1) == ':')) {
4877         int stream_id;
4878         char *endptr;
4879         spec += 1 + (*spec == 'i');
4880         stream_id = strtol(spec, &endptr, 0);
4881         if (!*endptr)
4882             return stream_id == st->id;
4883     } else if (*spec == 'm' && *(spec + 1) == ':') {
4884         AVDictionaryEntry *tag;
4885         char *key, *val;
4886         int ret;
4887
4888         spec += 2;
4889         val = strchr(spec, ':');
4890
4891         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4892         if (!key)
4893             return AVERROR(ENOMEM);
4894
4895         tag = av_dict_get(st->metadata, key, NULL, 0);
4896         if (tag) {
4897             if (!val || !strcmp(tag->value, val + 1))
4898                 ret = 1;
4899             else
4900                 ret = 0;
4901         } else
4902             ret = 0;
4903
4904         av_freep(&key);
4905         return ret;
4906     } else if (*spec == 'u') {
4907         AVCodecParameters *par = st->codecpar;
4908 #if FF_API_LAVF_AVCTX
4909 FF_DISABLE_DEPRECATION_WARNINGS
4910         AVCodecContext *codec = st->codec;
4911 FF_ENABLE_DEPRECATION_WARNINGS
4912 #endif
4913         int val;
4914         switch (par->codec_type) {
4915         case AVMEDIA_TYPE_AUDIO:
4916             val = par->sample_rate && par->channels;
4917 #if FF_API_LAVF_AVCTX
4918             val = val || (codec->sample_rate && codec->channels);
4919 #endif
4920             if (par->format == AV_SAMPLE_FMT_NONE
4921 #if FF_API_LAVF_AVCTX
4922                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
4923 #endif
4924                 )
4925                 return 0;
4926             break;
4927         case AVMEDIA_TYPE_VIDEO:
4928             val = par->width && par->height;
4929 #if FF_API_LAVF_AVCTX
4930             val = val || (codec->width && codec->height);
4931 #endif
4932             if (par->format == AV_PIX_FMT_NONE
4933 #if FF_API_LAVF_AVCTX
4934                 && codec->pix_fmt == AV_PIX_FMT_NONE
4935 #endif
4936                 )
4937                 return 0;
4938             break;
4939         case AVMEDIA_TYPE_UNKNOWN:
4940             val = 0;
4941             break;
4942         default:
4943             val = 1;
4944             break;
4945         }
4946 #if FF_API_LAVF_AVCTX
4947         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
4948 #else
4949         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
4950 #endif
4951     } else if (!*spec) /* empty specifier, matches everything */
4952         return 1;
4953
4954     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4955     return AVERROR(EINVAL);
4956 }
4957
4958 int ff_generate_avci_extradata(AVStream *st)
4959 {
4960     static const uint8_t avci100_1080p_extradata[] = {
4961         // SPS
4962         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4963         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4964         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4965         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4966         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4967         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4968         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4969         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4970         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4971         // PPS
4972         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4973         0xd0
4974     };
4975     static const uint8_t avci100_1080i_extradata[] = {
4976         // SPS
4977         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4978         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4979         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4980         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4981         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4982         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4983         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4984         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4985         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4986         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4987         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4988         // PPS
4989         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4990         0xd0
4991     };
4992     static const uint8_t avci50_1080p_extradata[] = {
4993         // SPS
4994         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4995         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4996         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4997         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4998         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4999         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5000         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5001         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5002         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5003         // PPS
5004         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5005         0x11
5006     };
5007     static const uint8_t avci50_1080i_extradata[] = {
5008         // SPS
5009         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5010         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5011         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5012         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5013         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5014         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5015         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5016         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5017         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5018         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5019         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5020         // PPS
5021         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5022         0x11
5023     };
5024     static const uint8_t avci100_720p_extradata[] = {
5025         // SPS
5026         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5027         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5028         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5029         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5030         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5031         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5032         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5033         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5034         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5035         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5036         // PPS
5037         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5038         0x11
5039     };
5040     static const uint8_t avci50_720p_extradata[] = {
5041         // SPS
5042         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5043         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5044         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5045         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5046         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5047         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5048         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5049         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5050         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5051         // PPS
5052         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5053         0x11
5054     };
5055
5056     const uint8_t *data = NULL;
5057     int size            = 0;
5058
5059     if (st->codecpar->width == 1920) {
5060         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5061             data = avci100_1080p_extradata;
5062             size = sizeof(avci100_1080p_extradata);
5063         } else {
5064             data = avci100_1080i_extradata;
5065             size = sizeof(avci100_1080i_extradata);
5066         }
5067     } else if (st->codecpar->width == 1440) {
5068         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5069             data = avci50_1080p_extradata;
5070             size = sizeof(avci50_1080p_extradata);
5071         } else {
5072             data = avci50_1080i_extradata;
5073             size = sizeof(avci50_1080i_extradata);
5074         }
5075     } else if (st->codecpar->width == 1280) {
5076         data = avci100_720p_extradata;
5077         size = sizeof(avci100_720p_extradata);
5078     } else if (st->codecpar->width == 960) {
5079         data = avci50_720p_extradata;
5080         size = sizeof(avci50_720p_extradata);
5081     }
5082
5083     if (!size)
5084         return 0;
5085
5086     av_freep(&st->codecpar->extradata);
5087     if (ff_alloc_extradata(st->codecpar, size))
5088         return AVERROR(ENOMEM);
5089     memcpy(st->codecpar->extradata, data, size);
5090
5091     return 0;
5092 }
5093
5094 #if FF_API_NOCONST_GET_SIDE_DATA
5095 uint8_t *av_stream_get_side_data(AVStream *st,
5096                                  enum AVPacketSideDataType type, int *size)
5097 #else
5098 uint8_t *av_stream_get_side_data(const AVStream *st,
5099                                  enum AVPacketSideDataType type, int *size)
5100 #endif
5101 {
5102     int i;
5103
5104     for (i = 0; i < st->nb_side_data; i++) {
5105         if (st->side_data[i].type == type) {
5106             if (size)
5107                 *size = st->side_data[i].size;
5108             return st->side_data[i].data;
5109         }
5110     }
5111     return NULL;
5112 }
5113
5114 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5115                             uint8_t *data, size_t size)
5116 {
5117     AVPacketSideData *sd, *tmp;
5118     int i;
5119
5120     for (i = 0; i < st->nb_side_data; i++) {
5121         sd = &st->side_data[i];
5122
5123         if (sd->type == type) {
5124             av_freep(&sd->data);
5125             sd->data = data;
5126             sd->size = size;
5127             return 0;
5128         }
5129     }
5130
5131     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5132         return AVERROR(ERANGE);
5133
5134     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5135     if (!tmp) {
5136         return AVERROR(ENOMEM);
5137     }
5138
5139     st->side_data = tmp;
5140     st->nb_side_data++;
5141
5142     sd = &st->side_data[st->nb_side_data - 1];
5143     sd->type = type;
5144     sd->data = data;
5145     sd->size = size;
5146
5147     return 0;
5148 }
5149
5150 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5151                                  int size)
5152 {
5153     int ret;
5154     uint8_t *data = av_malloc(size);
5155
5156     if (!data)
5157         return NULL;
5158
5159     ret = av_stream_add_side_data(st, type, data, size);
5160     if (ret < 0) {
5161         av_freep(&data);
5162         return NULL;
5163     }
5164
5165     return data;
5166 }
5167
5168 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5169 {
5170     int ret;
5171     const AVBitStreamFilter *bsf;
5172     AVBSFContext *bsfc;
5173     AVCodecParameters *in_par;
5174
5175     if (!(bsf = av_bsf_get_by_name(name))) {
5176         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5177         return AVERROR_BSF_NOT_FOUND;
5178     }
5179
5180     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5181         return ret;
5182
5183     if (st->internal->nb_bsfcs) {
5184         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5185         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5186     } else {
5187         in_par = st->codecpar;
5188         bsfc->time_base_in = st->time_base;
5189     }
5190
5191     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5192         av_bsf_free(&bsfc);
5193         return ret;
5194     }
5195
5196     if (args && bsfc->filter->priv_class) {
5197         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5198         const char * shorthand[2] = {NULL};
5199
5200         if (opt)
5201             shorthand[0] = opt->name;
5202
5203         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5204             av_bsf_free(&bsfc);
5205             return ret;
5206         }
5207     }
5208
5209     if ((ret = av_bsf_init(bsfc)) < 0) {
5210         av_bsf_free(&bsfc);
5211         return ret;
5212     }
5213
5214     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5215         av_bsf_free(&bsfc);
5216         return ret;
5217     }
5218
5219     av_log(NULL, AV_LOG_VERBOSE,
5220            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5221            name, args ? args : "");
5222     return 1;
5223 }
5224
5225 #if FF_API_OLD_BSF
5226 FF_DISABLE_DEPRECATION_WARNINGS
5227 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5228                                AVBitStreamFilterContext *bsfc)
5229 {
5230     int ret = 0;
5231     while (bsfc) {
5232         AVPacket new_pkt = *pkt;
5233         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5234                                            &new_pkt.data, &new_pkt.size,
5235                                            pkt->data, pkt->size,
5236                                            pkt->flags & AV_PKT_FLAG_KEY);
5237         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5238             av_packet_unref(pkt);
5239             memset(pkt, 0, sizeof(*pkt));
5240             return 0;
5241         }
5242         if(a == 0 && new_pkt.data != pkt->data) {
5243             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
5244             if (t) {
5245                 memcpy(t, new_pkt.data, new_pkt.size);
5246                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5247                 new_pkt.data = t;
5248                 new_pkt.buf = NULL;
5249                 a = 1;
5250             } else {
5251                 a = AVERROR(ENOMEM);
5252             }
5253         }
5254         if (a > 0) {
5255             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5256                                            av_buffer_default_free, NULL, 0);
5257             if (new_pkt.buf) {
5258                 pkt->side_data = NULL;
5259                 pkt->side_data_elems = 0;
5260                 av_packet_unref(pkt);
5261             } else {
5262                 av_freep(&new_pkt.data);
5263                 a = AVERROR(ENOMEM);
5264             }
5265         }
5266         if (a < 0) {
5267             av_log(codec, AV_LOG_ERROR,
5268                    "Failed to open bitstream filter %s for stream %d with codec %s",
5269                    bsfc->filter->name, pkt->stream_index,
5270                    codec->codec ? codec->codec->name : "copy");
5271             ret = a;
5272             break;
5273         }
5274         *pkt = new_pkt;
5275
5276         bsfc = bsfc->next;
5277     }
5278     return ret;
5279 }
5280 FF_ENABLE_DEPRECATION_WARNINGS
5281 #endif
5282
5283 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5284 {
5285     if (!s->oformat)
5286         return AVERROR(EINVAL);
5287
5288     if (!(s->oformat->flags & AVFMT_NOFILE))
5289         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5290     return 0;
5291 }
5292
5293 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5294 {
5295     if (*pb)
5296         s->io_close(s, *pb);
5297     *pb = NULL;
5298 }
5299
5300 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5301 {
5302     AVDictionaryEntry *entry;
5303     int64_t parsed_timestamp;
5304     int ret;
5305     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5306         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5307             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5308             return 1;
5309         } else {
5310             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5311             return ret;
5312         }
5313     }
5314     return 0;
5315 }
5316
5317 int ff_standardize_creation_time(AVFormatContext *s)
5318 {
5319     int64_t timestamp;
5320     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5321     if (ret == 1)
5322         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5323     return ret;
5324 }
5325
5326 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5327 {
5328     uint8_t *side_data;
5329     int size;
5330
5331     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5332     if (side_data) {
5333         if (size != AVPALETTE_SIZE) {
5334             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5335             return AVERROR_INVALIDDATA;
5336         }
5337         memcpy(palette, side_data, AVPALETTE_SIZE);
5338         return 1;
5339     }
5340
5341     if (ret == CONTAINS_PAL) {
5342         int i;
5343         for (i = 0; i < AVPALETTE_COUNT; i++)
5344             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5345         return 1;
5346     }
5347
5348     return 0;
5349 }
5350
5351 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5352 {
5353     int ret;
5354     char *str;
5355
5356     ret = av_bprint_finalize(buf, &str);
5357     if (ret < 0)
5358         return ret;
5359     if (!av_bprint_is_complete(buf)) {
5360         av_free(str);
5361         return AVERROR(ENOMEM);
5362     }
5363
5364     par->extradata = str;
5365     /* Note: the string is NUL terminated (so extradata can be read as a
5366      * string), but the ending character is not accounted in the size (in
5367      * binary formats you are likely not supposed to mux that character). When
5368      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5369      * zeros. */
5370     par->extradata_size = buf->len;
5371     return 0;
5372 }
5373
5374 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5375                                                   AVStream *ost, const AVStream *ist,
5376                                                   enum AVTimebaseSource copy_tb)
5377 {
5378     //TODO: use [io]st->internal->avctx
5379     const AVCodecContext *dec_ctx = ist->codec;
5380     AVCodecContext       *enc_ctx = ost->codec;
5381
5382     enc_ctx->time_base = ist->time_base;
5383     /*
5384      * Avi is a special case here because it supports variable fps but
5385      * having the fps and timebase differe significantly adds quite some
5386      * overhead
5387      */
5388     if (!strcmp(ofmt->name, "avi")) {
5389 #if FF_API_R_FRAME_RATE
5390         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5391             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5392             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5393             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5394             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5395             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5396             enc_ctx->time_base.num = ist->r_frame_rate.den;
5397             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5398             enc_ctx->ticks_per_frame = 2;
5399         } else
5400 #endif
5401             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5402                    && av_q2d(ist->time_base) < 1.0/500
5403                    || copy_tb == AVFMT_TBCF_DECODER) {
5404             enc_ctx->time_base = dec_ctx->time_base;
5405             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5406             enc_ctx->time_base.den *= 2;
5407             enc_ctx->ticks_per_frame = 2;
5408         }
5409     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5410                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5411         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5412             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5413             && av_q2d(ist->time_base) < 1.0/500
5414             || copy_tb == AVFMT_TBCF_DECODER) {
5415             enc_ctx->time_base = dec_ctx->time_base;
5416             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5417         }
5418     }
5419
5420     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5421         && dec_ctx->time_base.num < dec_ctx->time_base.den
5422         && dec_ctx->time_base.num > 0
5423         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5424         enc_ctx->time_base = dec_ctx->time_base;
5425     }
5426
5427     if (ost->avg_frame_rate.num)
5428         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5429
5430     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5431               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5432
5433     return 0;
5434 }
5435
5436 AVRational av_stream_get_codec_timebase(const AVStream *st)
5437 {
5438     // See avformat_transfer_internal_stream_timing_info() TODO.
5439 #if FF_API_LAVF_AVCTX
5440 FF_DISABLE_DEPRECATION_WARNINGS
5441     return st->codec->time_base;
5442 FF_ENABLE_DEPRECATION_WARNINGS
5443 #else
5444     return st->internal->avctx->time_base;
5445 #endif
5446 }