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