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 (st->discard != AVDISCARD_ALL)
1601             score += 200;
1602
1603         if (score > best_score) {
1604             best_score = score;
1605             best_stream = i;
1606         }
1607     }
1608     return best_stream;
1609 }
1610
1611 /** Flush the frame reader. */
1612 void ff_read_frame_flush(AVFormatContext *s)
1613 {
1614     AVStream *st;
1615     int i, j;
1616
1617     flush_packet_queue(s);
1618
1619     /* Reset read state for each stream. */
1620     for (i = 0; i < s->nb_streams; i++) {
1621         st = s->streams[i];
1622
1623         if (st->parser) {
1624             av_parser_close(st->parser);
1625             st->parser = NULL;
1626         }
1627         st->last_IP_pts = AV_NOPTS_VALUE;
1628         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1629         if (st->first_dts == AV_NOPTS_VALUE)
1630             st->cur_dts = RELATIVE_TS_BASE;
1631         else
1632             /* We set the current DTS to an unspecified origin. */
1633             st->cur_dts = AV_NOPTS_VALUE;
1634
1635         st->probe_packets = MAX_PROBE_PACKETS;
1636
1637         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1638             st->pts_buffer[j] = AV_NOPTS_VALUE;
1639
1640         if (s->internal->inject_global_side_data)
1641             st->inject_global_side_data = 1;
1642     }
1643 }
1644
1645 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1646 {
1647     int i;
1648
1649     for (i = 0; i < s->nb_streams; i++) {
1650         AVStream *st = s->streams[i];
1651
1652         st->cur_dts =
1653             av_rescale(timestamp,
1654                        st->time_base.den * (int64_t) ref_st->time_base.num,
1655                        st->time_base.num * (int64_t) ref_st->time_base.den);
1656     }
1657 }
1658
1659 void ff_reduce_index(AVFormatContext *s, int stream_index)
1660 {
1661     AVStream *st             = s->streams[stream_index];
1662     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1663
1664     if ((unsigned) st->nb_index_entries >= max_entries) {
1665         int i;
1666         for (i = 0; 2 * i < st->nb_index_entries; i++)
1667             st->index_entries[i] = st->index_entries[2 * i];
1668         st->nb_index_entries = i;
1669     }
1670 }
1671
1672 int ff_add_index_entry(AVIndexEntry **index_entries,
1673                        int *nb_index_entries,
1674                        unsigned int *index_entries_allocated_size,
1675                        int64_t pos, int64_t timestamp,
1676                        int size, int distance, int flags)
1677 {
1678     AVIndexEntry *entries, *ie;
1679     int index;
1680
1681     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1682         return -1;
1683
1684     if (timestamp == AV_NOPTS_VALUE)
1685         return AVERROR(EINVAL);
1686
1687     if (size < 0 || size > 0x3FFFFFFF)
1688         return AVERROR(EINVAL);
1689
1690     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1691         timestamp -= RELATIVE_TS_BASE;
1692
1693     entries = av_fast_realloc(*index_entries,
1694                               index_entries_allocated_size,
1695                               (*nb_index_entries + 1) *
1696                               sizeof(AVIndexEntry));
1697     if (!entries)
1698         return -1;
1699
1700     *index_entries = entries;
1701
1702     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1703                                       timestamp, AVSEEK_FLAG_ANY);
1704
1705     if (index < 0) {
1706         index = (*nb_index_entries)++;
1707         ie    = &entries[index];
1708         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1709     } else {
1710         ie = &entries[index];
1711         if (ie->timestamp != timestamp) {
1712             if (ie->timestamp <= timestamp)
1713                 return -1;
1714             memmove(entries + index + 1, entries + index,
1715                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1716             (*nb_index_entries)++;
1717         } else if (ie->pos == pos && distance < ie->min_distance)
1718             // do not reduce the distance
1719             distance = ie->min_distance;
1720     }
1721
1722     ie->pos          = pos;
1723     ie->timestamp    = timestamp;
1724     ie->min_distance = distance;
1725     ie->size         = size;
1726     ie->flags        = flags;
1727
1728     return index;
1729 }
1730
1731 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1732                        int size, int distance, int flags)
1733 {
1734     timestamp = wrap_timestamp(st, timestamp);
1735     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1736                               &st->index_entries_allocated_size, pos,
1737                               timestamp, size, distance, flags);
1738 }
1739
1740 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1741                               int64_t wanted_timestamp, int flags)
1742 {
1743     int a, b, m;
1744     int64_t timestamp;
1745
1746     a = -1;
1747     b = nb_entries;
1748
1749     // Optimize appending index entries at the end.
1750     if (b && entries[b - 1].timestamp < wanted_timestamp)
1751         a = b - 1;
1752
1753     while (b - a > 1) {
1754         m         = (a + b) >> 1;
1755         timestamp = entries[m].timestamp;
1756         if (timestamp >= wanted_timestamp)
1757             b = m;
1758         if (timestamp <= wanted_timestamp)
1759             a = m;
1760     }
1761     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1762
1763     if (!(flags & AVSEEK_FLAG_ANY))
1764         while (m >= 0 && m < nb_entries &&
1765                !(entries[m].flags & AVINDEX_KEYFRAME))
1766             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1767
1768     if (m == nb_entries)
1769         return -1;
1770     return m;
1771 }
1772
1773 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1774 {
1775     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1776                                      wanted_timestamp, flags);
1777 }
1778
1779 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1780                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1781 {
1782     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1783     if (stream_index >= 0)
1784         ts = wrap_timestamp(s->streams[stream_index], ts);
1785     return ts;
1786 }
1787
1788 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1789                          int64_t target_ts, int flags)
1790 {
1791     AVInputFormat *avif = s->iformat;
1792     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1793     int64_t ts_min, ts_max, ts;
1794     int index;
1795     int64_t ret;
1796     AVStream *st;
1797
1798     if (stream_index < 0)
1799         return -1;
1800
1801     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1802
1803     ts_max =
1804     ts_min = AV_NOPTS_VALUE;
1805     pos_limit = -1; // GCC falsely says it may be uninitialized.
1806
1807     st = s->streams[stream_index];
1808     if (st->index_entries) {
1809         AVIndexEntry *e;
1810
1811         /* FIXME: Whole function must be checked for non-keyframe entries in
1812          * index case, especially read_timestamp(). */
1813         index = av_index_search_timestamp(st, target_ts,
1814                                           flags | AVSEEK_FLAG_BACKWARD);
1815         index = FFMAX(index, 0);
1816         e     = &st->index_entries[index];
1817
1818         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1819             pos_min = e->pos;
1820             ts_min  = e->timestamp;
1821             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1822                     pos_min, av_ts2str(ts_min));
1823         } else {
1824             av_assert1(index == 0);
1825         }
1826
1827         index = av_index_search_timestamp(st, target_ts,
1828                                           flags & ~AVSEEK_FLAG_BACKWARD);
1829         av_assert0(index < st->nb_index_entries);
1830         if (index >= 0) {
1831             e = &st->index_entries[index];
1832             av_assert1(e->timestamp >= target_ts);
1833             pos_max   = e->pos;
1834             ts_max    = e->timestamp;
1835             pos_limit = pos_max - e->min_distance;
1836             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1837                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1838         }
1839     }
1840
1841     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1842                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
1843     if (pos < 0)
1844         return -1;
1845
1846     /* do the seek */
1847     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1848         return ret;
1849
1850     ff_read_frame_flush(s);
1851     ff_update_cur_dts(s, st, ts);
1852
1853     return 0;
1854 }
1855
1856 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1857                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1858 {
1859     int64_t step = 1024;
1860     int64_t limit, ts_max;
1861     int64_t filesize = avio_size(s->pb);
1862     int64_t pos_max  = filesize - 1;
1863     do {
1864         limit = pos_max;
1865         pos_max = FFMAX(0, (pos_max) - step);
1866         ts_max  = ff_read_timestamp(s, stream_index,
1867                                     &pos_max, limit, read_timestamp);
1868         step   += step;
1869     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1870     if (ts_max == AV_NOPTS_VALUE)
1871         return -1;
1872
1873     for (;;) {
1874         int64_t tmp_pos = pos_max + 1;
1875         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
1876                                             &tmp_pos, INT64_MAX, read_timestamp);
1877         if (tmp_ts == AV_NOPTS_VALUE)
1878             break;
1879         av_assert0(tmp_pos > pos_max);
1880         ts_max  = tmp_ts;
1881         pos_max = tmp_pos;
1882         if (tmp_pos >= filesize)
1883             break;
1884     }
1885
1886     if (ts)
1887         *ts = ts_max;
1888     if (pos)
1889         *pos = pos_max;
1890
1891     return 0;
1892 }
1893
1894 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1895                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1896                       int64_t ts_min, int64_t ts_max,
1897                       int flags, int64_t *ts_ret,
1898                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
1899                                                 int64_t *, int64_t))
1900 {
1901     int64_t pos, ts;
1902     int64_t start_pos;
1903     int no_change;
1904     int ret;
1905
1906     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1907
1908     if (ts_min == AV_NOPTS_VALUE) {
1909         pos_min = s->internal->data_offset;
1910         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1911         if (ts_min == AV_NOPTS_VALUE)
1912             return -1;
1913     }
1914
1915     if (ts_min >= target_ts) {
1916         *ts_ret = ts_min;
1917         return pos_min;
1918     }
1919
1920     if (ts_max == AV_NOPTS_VALUE) {
1921         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1922             return ret;
1923         pos_limit = pos_max;
1924     }
1925
1926     if (ts_max <= target_ts) {
1927         *ts_ret = ts_max;
1928         return pos_max;
1929     }
1930
1931     av_assert0(ts_min < ts_max);
1932
1933     no_change = 0;
1934     while (pos_min < pos_limit) {
1935         av_dlog(s,
1936                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1937                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1938         av_assert0(pos_limit <= pos_max);
1939
1940         if (no_change == 0) {
1941             int64_t approximate_keyframe_distance = pos_max - pos_limit;
1942             // interpolate position (better than dichotomy)
1943             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1944                              ts_max - ts_min) +
1945                   pos_min - approximate_keyframe_distance;
1946         } else if (no_change == 1) {
1947             // bisection if interpolation did not change min / max pos last time
1948             pos = (pos_min + pos_limit) >> 1;
1949         } else {
1950             /* linear search if bisection failed, can only happen if there
1951              * are very few or no keyframes between min/max */
1952             pos = pos_min;
1953         }
1954         if (pos <= pos_min)
1955             pos = pos_min + 1;
1956         else if (pos > pos_limit)
1957             pos = pos_limit;
1958         start_pos = pos;
1959
1960         // May pass pos_limit instead of -1.
1961         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1962         if (pos == pos_max)
1963             no_change++;
1964         else
1965             no_change = 0;
1966         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1967                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1968                 pos_min, pos, pos_max,
1969                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1970                 pos_limit, start_pos, no_change);
1971         if (ts == AV_NOPTS_VALUE) {
1972             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1973             return -1;
1974         }
1975         if (target_ts <= ts) {
1976             pos_limit = start_pos - 1;
1977             pos_max   = pos;
1978             ts_max    = ts;
1979         }
1980         if (target_ts >= ts) {
1981             pos_min = pos;
1982             ts_min  = ts;
1983         }
1984     }
1985
1986     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1987     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
1988 #if 0
1989     pos_min = pos;
1990     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1991     pos_min++;
1992     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1993     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1994             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1995 #endif
1996     *ts_ret = ts;
1997     return pos;
1998 }
1999
2000 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2001                            int64_t pos, int flags)
2002 {
2003     int64_t pos_min, pos_max;
2004
2005     pos_min = s->internal->data_offset;
2006     pos_max = avio_size(s->pb) - 1;
2007
2008     if (pos < pos_min)
2009         pos = pos_min;
2010     else if (pos > pos_max)
2011         pos = pos_max;
2012
2013     avio_seek(s->pb, pos, SEEK_SET);
2014
2015     s->io_repositioned = 1;
2016
2017     return 0;
2018 }
2019
2020 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2021                               int64_t timestamp, int flags)
2022 {
2023     int index;
2024     int64_t ret;
2025     AVStream *st;
2026     AVIndexEntry *ie;
2027
2028     st = s->streams[stream_index];
2029
2030     index = av_index_search_timestamp(st, timestamp, flags);
2031
2032     if (index < 0 && st->nb_index_entries &&
2033         timestamp < st->index_entries[0].timestamp)
2034         return -1;
2035
2036     if (index < 0 || index == st->nb_index_entries - 1) {
2037         AVPacket pkt;
2038         int nonkey = 0;
2039
2040         if (st->nb_index_entries) {
2041             av_assert0(st->index_entries);
2042             ie = &st->index_entries[st->nb_index_entries - 1];
2043             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2044                 return ret;
2045             ff_update_cur_dts(s, st, ie->timestamp);
2046         } else {
2047             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2048                 return ret;
2049         }
2050         for (;;) {
2051             int read_status;
2052             do {
2053                 read_status = av_read_frame(s, &pkt);
2054             } while (read_status == AVERROR(EAGAIN));
2055             if (read_status < 0)
2056                 break;
2057             av_free_packet(&pkt);
2058             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2059                 if (pkt.flags & AV_PKT_FLAG_KEY)
2060                     break;
2061                 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2062                     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);
2063                     break;
2064                 }
2065             }
2066         }
2067         index = av_index_search_timestamp(st, timestamp, flags);
2068     }
2069     if (index < 0)
2070         return -1;
2071
2072     ff_read_frame_flush(s);
2073     if (s->iformat->read_seek)
2074         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2075             return 0;
2076     ie = &st->index_entries[index];
2077     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2078         return ret;
2079     ff_update_cur_dts(s, st, ie->timestamp);
2080
2081     return 0;
2082 }
2083
2084 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2085                                int64_t timestamp, int flags)
2086 {
2087     int ret;
2088     AVStream *st;
2089
2090     if (flags & AVSEEK_FLAG_BYTE) {
2091         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2092             return -1;
2093         ff_read_frame_flush(s);
2094         return seek_frame_byte(s, stream_index, timestamp, flags);
2095     }
2096
2097     if (stream_index < 0) {
2098         stream_index = av_find_default_stream_index(s);
2099         if (stream_index < 0)
2100             return -1;
2101
2102         st = s->streams[stream_index];
2103         /* timestamp for default must be expressed in AV_TIME_BASE units */
2104         timestamp = av_rescale(timestamp, st->time_base.den,
2105                                AV_TIME_BASE * (int64_t) st->time_base.num);
2106     }
2107
2108     /* first, we try the format specific seek */
2109     if (s->iformat->read_seek) {
2110         ff_read_frame_flush(s);
2111         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2112     } else
2113         ret = -1;
2114     if (ret >= 0)
2115         return 0;
2116
2117     if (s->iformat->read_timestamp &&
2118         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2119         ff_read_frame_flush(s);
2120         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2121     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2122         ff_read_frame_flush(s);
2123         return seek_frame_generic(s, stream_index, timestamp, flags);
2124     } else
2125         return -1;
2126 }
2127
2128 int av_seek_frame(AVFormatContext *s, int stream_index,
2129                   int64_t timestamp, int flags)
2130 {
2131     int ret;
2132
2133     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2134         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2135         if ((flags & AVSEEK_FLAG_BACKWARD))
2136             max_ts = timestamp;
2137         else
2138             min_ts = timestamp;
2139         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2140                                   flags & ~AVSEEK_FLAG_BACKWARD);
2141     }
2142
2143     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2144
2145     if (ret >= 0)
2146         ret = avformat_queue_attached_pictures(s);
2147
2148     return ret;
2149 }
2150
2151 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2152                        int64_t ts, int64_t max_ts, int flags)
2153 {
2154     if (min_ts > ts || max_ts < ts)
2155         return -1;
2156     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2157         return AVERROR(EINVAL);
2158
2159     if (s->seek2any>0)
2160         flags |= AVSEEK_FLAG_ANY;
2161     flags &= ~AVSEEK_FLAG_BACKWARD;
2162
2163     if (s->iformat->read_seek2) {
2164         int ret;
2165         ff_read_frame_flush(s);
2166
2167         if (stream_index == -1 && s->nb_streams == 1) {
2168             AVRational time_base = s->streams[0]->time_base;
2169             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2170             min_ts = av_rescale_rnd(min_ts, time_base.den,
2171                                     time_base.num * (int64_t)AV_TIME_BASE,
2172                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2173             max_ts = av_rescale_rnd(max_ts, time_base.den,
2174                                     time_base.num * (int64_t)AV_TIME_BASE,
2175                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2176         }
2177
2178         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2179                                      ts, max_ts, flags);
2180
2181         if (ret >= 0)
2182             ret = avformat_queue_attached_pictures(s);
2183         return ret;
2184     }
2185
2186     if (s->iformat->read_timestamp) {
2187         // try to seek via read_timestamp()
2188     }
2189
2190     // Fall back on old API if new is not implemented but old is.
2191     // Note the old API has somewhat different semantics.
2192     if (s->iformat->read_seek || 1) {
2193         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2194         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2195         if (ret<0 && ts != min_ts && max_ts != ts) {
2196             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2197             if (ret >= 0)
2198                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2199         }
2200         return ret;
2201     }
2202
2203     // try some generic seek like seek_frame_generic() but with new ts semantics
2204     return -1; //unreachable
2205 }
2206
2207 int avformat_flush(AVFormatContext *s)
2208 {
2209     ff_read_frame_flush(s);
2210     return 0;
2211 }
2212
2213 /*******************************************************/
2214
2215 /**
2216  * Return TRUE if the stream has accurate duration in any stream.
2217  *
2218  * @return TRUE if the stream has accurate duration for at least one component.
2219  */
2220 static int has_duration(AVFormatContext *ic)
2221 {
2222     int i;
2223     AVStream *st;
2224
2225     for (i = 0; i < ic->nb_streams; i++) {
2226         st = ic->streams[i];
2227         if (st->duration != AV_NOPTS_VALUE)
2228             return 1;
2229     }
2230     if (ic->duration != AV_NOPTS_VALUE)
2231         return 1;
2232     return 0;
2233 }
2234
2235 /**
2236  * Estimate the stream timings from the one of each components.
2237  *
2238  * Also computes the global bitrate if possible.
2239  */
2240 static void update_stream_timings(AVFormatContext *ic)
2241 {
2242     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2243     int64_t duration, duration1, filesize;
2244     int i;
2245     AVStream *st;
2246     AVProgram *p;
2247
2248     start_time = INT64_MAX;
2249     start_time_text = INT64_MAX;
2250     end_time   = INT64_MIN;
2251     duration   = INT64_MIN;
2252     for (i = 0; i < ic->nb_streams; i++) {
2253         st = ic->streams[i];
2254         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2255             start_time1 = av_rescale_q(st->start_time, st->time_base,
2256                                        AV_TIME_BASE_Q);
2257             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2258                 if (start_time1 < start_time_text)
2259                     start_time_text = start_time1;
2260             } else
2261                 start_time = FFMIN(start_time, start_time1);
2262             end_time1   = AV_NOPTS_VALUE;
2263             if (st->duration != AV_NOPTS_VALUE) {
2264                 end_time1 = start_time1 +
2265                             av_rescale_q(st->duration, st->time_base,
2266                                          AV_TIME_BASE_Q);
2267                 end_time = FFMAX(end_time, end_time1);
2268             }
2269             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2270                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2271                     p->start_time = start_time1;
2272                 if (p->end_time < end_time1)
2273                     p->end_time = end_time1;
2274             }
2275         }
2276         if (st->duration != AV_NOPTS_VALUE) {
2277             duration1 = av_rescale_q(st->duration, st->time_base,
2278                                      AV_TIME_BASE_Q);
2279             duration  = FFMAX(duration, duration1);
2280         }
2281     }
2282     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2283         start_time = start_time_text;
2284     else if (start_time > start_time_text)
2285         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2286
2287     if (start_time != INT64_MAX) {
2288         ic->start_time = start_time;
2289         if (end_time != INT64_MIN) {
2290             if (ic->nb_programs) {
2291                 for (i = 0; i < ic->nb_programs; i++) {
2292                     p = ic->programs[i];
2293                     if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2294                         duration = FFMAX(duration, p->end_time - p->start_time);
2295                 }
2296             } else
2297                 duration = FFMAX(duration, end_time - start_time);
2298         }
2299     }
2300     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2301         ic->duration = duration;
2302     }
2303     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2304         /* compute the bitrate */
2305         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2306                          (double) ic->duration;
2307         if (bitrate >= 0 && bitrate <= INT_MAX)
2308             ic->bit_rate = bitrate;
2309     }
2310 }
2311
2312 static void fill_all_stream_timings(AVFormatContext *ic)
2313 {
2314     int i;
2315     AVStream *st;
2316
2317     update_stream_timings(ic);
2318     for (i = 0; i < ic->nb_streams; i++) {
2319         st = ic->streams[i];
2320         if (st->start_time == AV_NOPTS_VALUE) {
2321             if (ic->start_time != AV_NOPTS_VALUE)
2322                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2323                                               st->time_base);
2324             if (ic->duration != AV_NOPTS_VALUE)
2325                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2326                                             st->time_base);
2327         }
2328     }
2329 }
2330
2331 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2332 {
2333     int64_t filesize, duration;
2334     int i, show_warning = 0;
2335     AVStream *st;
2336
2337     /* if bit_rate is already set, we believe it */
2338     if (ic->bit_rate <= 0) {
2339         int bit_rate = 0;
2340         for (i = 0; i < ic->nb_streams; i++) {
2341             st = ic->streams[i];
2342             if (st->codec->bit_rate > 0) {
2343                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2344                     bit_rate = 0;
2345                     break;
2346                 }
2347                 bit_rate += st->codec->bit_rate;
2348             } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2349                 // If we have a videostream with packets but without a bitrate
2350                 // then consider the sum not known
2351                 bit_rate = 0;
2352                 break;
2353             }
2354         }
2355         ic->bit_rate = bit_rate;
2356     }
2357
2358     /* if duration is already set, we believe it */
2359     if (ic->duration == AV_NOPTS_VALUE &&
2360         ic->bit_rate != 0) {
2361         filesize = ic->pb ? avio_size(ic->pb) : 0;
2362         if (filesize > ic->internal->data_offset) {
2363             filesize -= ic->internal->data_offset;
2364             for (i = 0; i < ic->nb_streams; i++) {
2365                 st      = ic->streams[i];
2366                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2367                     && st->duration == AV_NOPTS_VALUE) {
2368                     duration = av_rescale(8 * filesize, st->time_base.den,
2369                                           ic->bit_rate *
2370                                           (int64_t) st->time_base.num);
2371                     st->duration = duration;
2372                     show_warning = 1;
2373                 }
2374             }
2375         }
2376     }
2377     if (show_warning)
2378         av_log(ic, AV_LOG_WARNING,
2379                "Estimating duration from bitrate, this may be inaccurate\n");
2380 }
2381
2382 #define DURATION_MAX_READ_SIZE 250000LL
2383 #define DURATION_MAX_RETRY 4
2384
2385 /* only usable for MPEG-PS streams */
2386 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2387 {
2388     AVPacket pkt1, *pkt = &pkt1;
2389     AVStream *st;
2390     int num, den, read_size, i, ret;
2391     int found_duration = 0;
2392     int is_end;
2393     int64_t filesize, offset, duration;
2394     int retry = 0;
2395
2396     /* flush packet queue */
2397     flush_packet_queue(ic);
2398
2399     for (i = 0; i < ic->nb_streams; i++) {
2400         st = ic->streams[i];
2401         if (st->start_time == AV_NOPTS_VALUE &&
2402             st->first_dts == AV_NOPTS_VALUE &&
2403             st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2404             av_log(st->codec, AV_LOG_WARNING,
2405                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2406
2407         if (st->parser) {
2408             av_parser_close(st->parser);
2409             st->parser = NULL;
2410         }
2411     }
2412
2413     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2414     /* estimate the end time (duration) */
2415     /* XXX: may need to support wrapping */
2416     filesize = ic->pb ? avio_size(ic->pb) : 0;
2417     do {
2418         is_end = found_duration;
2419         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2420         if (offset < 0)
2421             offset = 0;
2422
2423         avio_seek(ic->pb, offset, SEEK_SET);
2424         read_size = 0;
2425         for (;;) {
2426             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2427                 break;
2428
2429             do {
2430                 ret = ff_read_packet(ic, pkt);
2431             } while (ret == AVERROR(EAGAIN));
2432             if (ret != 0)
2433                 break;
2434             read_size += pkt->size;
2435             st         = ic->streams[pkt->stream_index];
2436             if (pkt->pts != AV_NOPTS_VALUE &&
2437                 (st->start_time != AV_NOPTS_VALUE ||
2438                  st->first_dts  != AV_NOPTS_VALUE)) {
2439                 if (pkt->duration == 0) {
2440                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2441                     if (den && num) {
2442                         pkt->duration = av_rescale_rnd(1,
2443                                            num * (int64_t) st->time_base.den,
2444                                            den * (int64_t) st->time_base.num,
2445                                            AV_ROUND_DOWN);
2446                     }
2447                 }
2448                 duration = pkt->pts + pkt->duration;
2449                 found_duration = 1;
2450                 if (st->start_time != AV_NOPTS_VALUE)
2451                     duration -= st->start_time;
2452                 else
2453                     duration -= st->first_dts;
2454                 if (duration > 0) {
2455                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2456                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2457                         st->duration = duration;
2458                     st->info->last_duration = duration;
2459                 }
2460             }
2461             av_free_packet(pkt);
2462         }
2463
2464         /* check if all audio/video streams have valid duration */
2465         if (!is_end) {
2466             is_end = 1;
2467             for (i = 0; i < ic->nb_streams; i++) {
2468                 st = ic->streams[i];
2469                 switch (st->codec->codec_type) {
2470                     case AVMEDIA_TYPE_VIDEO:
2471                     case AVMEDIA_TYPE_AUDIO:
2472                         if (st->duration == AV_NOPTS_VALUE)
2473                             is_end = 0;
2474                 }
2475             }
2476         }
2477     } while (!is_end &&
2478              offset &&
2479              ++retry <= DURATION_MAX_RETRY);
2480
2481     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2482
2483     /* warn about audio/video streams which duration could not be estimated */
2484     for (i = 0; i < ic->nb_streams; i++) {
2485         st = ic->streams[i];
2486         if (st->duration == AV_NOPTS_VALUE) {
2487             switch (st->codec->codec_type) {
2488             case AVMEDIA_TYPE_VIDEO:
2489             case AVMEDIA_TYPE_AUDIO:
2490                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2491                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2492                 } else
2493                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2494             }
2495         }
2496     }
2497     fill_all_stream_timings(ic);
2498
2499     avio_seek(ic->pb, old_offset, SEEK_SET);
2500     for (i = 0; i < ic->nb_streams; i++) {
2501         int j;
2502
2503         st              = ic->streams[i];
2504         st->cur_dts     = st->first_dts;
2505         st->last_IP_pts = AV_NOPTS_VALUE;
2506         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2507         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2508             st->pts_buffer[j] = AV_NOPTS_VALUE;
2509     }
2510 }
2511
2512 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2513 {
2514     int64_t file_size;
2515
2516     /* get the file size, if possible */
2517     if (ic->iformat->flags & AVFMT_NOFILE) {
2518         file_size = 0;
2519     } else {
2520         file_size = avio_size(ic->pb);
2521         file_size = FFMAX(0, file_size);
2522     }
2523
2524     if ((!strcmp(ic->iformat->name, "mpeg") ||
2525          !strcmp(ic->iformat->name, "mpegts")) &&
2526         file_size && ic->pb->seekable) {
2527         /* get accurate estimate from the PTSes */
2528         estimate_timings_from_pts(ic, old_offset);
2529         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2530     } else if (has_duration(ic)) {
2531         /* at least one component has timings - we use them for all
2532          * the components */
2533         fill_all_stream_timings(ic);
2534         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2535     } else {
2536         /* less precise: use bitrate info */
2537         estimate_timings_from_bit_rate(ic);
2538         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2539     }
2540     update_stream_timings(ic);
2541
2542     {
2543         int i;
2544         AVStream av_unused *st;
2545         for (i = 0; i < ic->nb_streams; i++) {
2546             st = ic->streams[i];
2547             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2548                     (double) st->start_time / AV_TIME_BASE,
2549                     (double) st->duration   / AV_TIME_BASE);
2550         }
2551         av_dlog(ic,
2552                 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2553                 (double) ic->start_time / AV_TIME_BASE,
2554                 (double) ic->duration   / AV_TIME_BASE,
2555                 ic->bit_rate / 1000);
2556     }
2557 }
2558
2559 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2560 {
2561     AVCodecContext *avctx = st->codec;
2562
2563 #define FAIL(errmsg) do {                                         \
2564         if (errmsg_ptr)                                           \
2565             *errmsg_ptr = errmsg;                                 \
2566         return 0;                                                 \
2567     } while (0)
2568
2569     if (   avctx->codec_id == AV_CODEC_ID_NONE
2570         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2571         FAIL("unknown codec");
2572     switch (avctx->codec_type) {
2573     case AVMEDIA_TYPE_AUDIO:
2574         if (!avctx->frame_size && determinable_frame_size(avctx))
2575             FAIL("unspecified frame size");
2576         if (st->info->found_decoder >= 0 &&
2577             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2578             FAIL("unspecified sample format");
2579         if (!avctx->sample_rate)
2580             FAIL("unspecified sample rate");
2581         if (!avctx->channels)
2582             FAIL("unspecified number of channels");
2583         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2584             FAIL("no decodable DTS frames");
2585         break;
2586     case AVMEDIA_TYPE_VIDEO:
2587         if (!avctx->width)
2588             FAIL("unspecified size");
2589         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2590             FAIL("unspecified pixel format");
2591         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2592             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2593                 FAIL("no frame in rv30/40 and no sar");
2594         break;
2595     case AVMEDIA_TYPE_SUBTITLE:
2596         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2597             FAIL("unspecified size");
2598         break;
2599     case AVMEDIA_TYPE_DATA:
2600         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2601     }
2602
2603     return 1;
2604 }
2605
2606 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2607 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2608                             AVDictionary **options)
2609 {
2610     const AVCodec *codec;
2611     int got_picture = 1, ret = 0;
2612     AVFrame *frame = av_frame_alloc();
2613     AVSubtitle subtitle;
2614     AVPacket pkt = *avpkt;
2615
2616     if (!frame)
2617         return AVERROR(ENOMEM);
2618
2619     if (!avcodec_is_open(st->codec) &&
2620         st->info->found_decoder <= 0 &&
2621         (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2622         AVDictionary *thread_opt = NULL;
2623
2624         codec = find_decoder(s, st, st->codec->codec_id);
2625
2626         if (!codec) {
2627             st->info->found_decoder = -st->codec->codec_id;
2628             ret                     = -1;
2629             goto fail;
2630         }
2631
2632         /* Force thread count to 1 since the H.264 decoder will not extract
2633          * SPS and PPS to extradata during multi-threaded decoding. */
2634         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2635         if (s->codec_whitelist)
2636             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2637         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2638         if (!options)
2639             av_dict_free(&thread_opt);
2640         if (ret < 0) {
2641             st->info->found_decoder = -st->codec->codec_id;
2642             goto fail;
2643         }
2644         st->info->found_decoder = 1;
2645     } else if (!st->info->found_decoder)
2646         st->info->found_decoder = 1;
2647
2648     if (st->info->found_decoder < 0) {
2649         ret = -1;
2650         goto fail;
2651     }
2652
2653     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2654            ret >= 0 &&
2655            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2656             (!st->codec_info_nb_frames &&
2657              st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2658         got_picture = 0;
2659         switch (st->codec->codec_type) {
2660         case AVMEDIA_TYPE_VIDEO:
2661             ret = avcodec_decode_video2(st->codec, frame,
2662                                         &got_picture, &pkt);
2663             break;
2664         case AVMEDIA_TYPE_AUDIO:
2665             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2666             break;
2667         case AVMEDIA_TYPE_SUBTITLE:
2668             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2669                                            &got_picture, &pkt);
2670             ret = pkt.size;
2671             break;
2672         default:
2673             break;
2674         }
2675         if (ret >= 0) {
2676             if (got_picture)
2677                 st->nb_decoded_frames++;
2678             pkt.data += ret;
2679             pkt.size -= ret;
2680             ret       = got_picture;
2681         }
2682     }
2683
2684     if (!pkt.data && !got_picture)
2685         ret = -1;
2686
2687 fail:
2688     av_frame_free(&frame);
2689     return ret;
2690 }
2691
2692 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2693 {
2694     while (tags->id != AV_CODEC_ID_NONE) {
2695         if (tags->id == id)
2696             return tags->tag;
2697         tags++;
2698     }
2699     return 0;
2700 }
2701
2702 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2703 {
2704     int i;
2705     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2706         if (tag == tags[i].tag)
2707             return tags[i].id;
2708     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2709         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2710             return tags[i].id;
2711     return AV_CODEC_ID_NONE;
2712 }
2713
2714 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2715 {
2716     if (flt) {
2717         switch (bps) {
2718         case 32:
2719             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2720         case 64:
2721             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2722         default:
2723             return AV_CODEC_ID_NONE;
2724         }
2725     } else {
2726         bps  += 7;
2727         bps >>= 3;
2728         if (sflags & (1 << (bps - 1))) {
2729             switch (bps) {
2730             case 1:
2731                 return AV_CODEC_ID_PCM_S8;
2732             case 2:
2733                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2734             case 3:
2735                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2736             case 4:
2737                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2738             default:
2739                 return AV_CODEC_ID_NONE;
2740             }
2741         } else {
2742             switch (bps) {
2743             case 1:
2744                 return AV_CODEC_ID_PCM_U8;
2745             case 2:
2746                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2747             case 3:
2748                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2749             case 4:
2750                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2751             default:
2752                 return AV_CODEC_ID_NONE;
2753             }
2754         }
2755     }
2756 }
2757
2758 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2759 {
2760     unsigned int tag;
2761     if (!av_codec_get_tag2(tags, id, &tag))
2762         return 0;
2763     return tag;
2764 }
2765
2766 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2767                       unsigned int *tag)
2768 {
2769     int i;
2770     for (i = 0; tags && tags[i]; i++) {
2771         const AVCodecTag *codec_tags = tags[i];
2772         while (codec_tags->id != AV_CODEC_ID_NONE) {
2773             if (codec_tags->id == id) {
2774                 *tag = codec_tags->tag;
2775                 return 1;
2776             }
2777             codec_tags++;
2778         }
2779     }
2780     return 0;
2781 }
2782
2783 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2784 {
2785     int i;
2786     for (i = 0; tags && tags[i]; i++) {
2787         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2788         if (id != AV_CODEC_ID_NONE)
2789             return id;
2790     }
2791     return AV_CODEC_ID_NONE;
2792 }
2793
2794 static void compute_chapters_end(AVFormatContext *s)
2795 {
2796     unsigned int i, j;
2797     int64_t max_time = s->duration +
2798                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2799
2800     for (i = 0; i < s->nb_chapters; i++)
2801         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2802             AVChapter *ch = s->chapters[i];
2803             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2804                                                   ch->time_base)
2805                                    : INT64_MAX;
2806
2807             for (j = 0; j < s->nb_chapters; j++) {
2808                 AVChapter *ch1     = s->chapters[j];
2809                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2810                                                   ch->time_base);
2811                 if (j != i && next_start > ch->start && next_start < end)
2812                     end = next_start;
2813             }
2814             ch->end = (end == INT64_MAX) ? ch->start : end;
2815         }
2816 }
2817
2818 static int get_std_framerate(int i)
2819 {
2820     if (i < 30*12)
2821         return (i + 1) * 1001;
2822     i -= 30*12;
2823
2824     if (i < 7)
2825         return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2826
2827     i -= 7;
2828
2829     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2830 }
2831
2832 /* Is the time base unreliable?
2833  * This is a heuristic to balance between quick acceptance of the values in
2834  * the headers vs. some extra checks.
2835  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2836  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2837  * And there are "variable" fps files this needs to detect as well. */
2838 static int tb_unreliable(AVCodecContext *c)
2839 {
2840     if (c->time_base.den >= 101LL * c->time_base.num ||
2841         c->time_base.den <    5LL * c->time_base.num ||
2842         // c->codec_tag == AV_RL32("DIVX") ||
2843         // c->codec_tag == AV_RL32("XVID") ||
2844         c->codec_tag == AV_RL32("mp4v") ||
2845         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2846         c->codec_id == AV_CODEC_ID_GIF ||
2847         c->codec_id == AV_CODEC_ID_H264)
2848         return 1;
2849     return 0;
2850 }
2851
2852 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2853 {
2854     int ret;
2855
2856     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2857         avctx->extradata = NULL;
2858         avctx->extradata_size = 0;
2859         return AVERROR(EINVAL);
2860     }
2861     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2862     if (avctx->extradata) {
2863         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2864         avctx->extradata_size = size;
2865         ret = 0;
2866     } else {
2867         avctx->extradata_size = 0;
2868         ret = AVERROR(ENOMEM);
2869     }
2870     return ret;
2871 }
2872
2873 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2874 {
2875     int ret = ff_alloc_extradata(avctx, size);
2876     if (ret < 0)
2877         return ret;
2878     ret = avio_read(pb, avctx->extradata, size);
2879     if (ret != size) {
2880         av_freep(&avctx->extradata);
2881         avctx->extradata_size = 0;
2882         av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2883         return ret < 0 ? ret : AVERROR_INVALIDDATA;
2884     }
2885
2886     return ret;
2887 }
2888
2889 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2890 {
2891     int i, j;
2892     int64_t last = st->info->last_dts;
2893
2894     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2895        && ts - (uint64_t)last < INT64_MAX) {
2896         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2897         int64_t duration = ts - last;
2898
2899         if (!st->info->duration_error)
2900             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2901         if (!st->info->duration_error)
2902             return AVERROR(ENOMEM);
2903
2904 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2905 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2906         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2907             if (st->info->duration_error[0][1][i] < 1e10) {
2908                 int framerate = get_std_framerate(i);
2909                 double sdts = dts*framerate/(1001*12);
2910                 for (j= 0; j<2; j++) {
2911                     int64_t ticks = llrint(sdts+j*0.5);
2912                     double error= sdts - ticks + j*0.5;
2913                     st->info->duration_error[j][0][i] += error;
2914                     st->info->duration_error[j][1][i] += error*error;
2915                 }
2916             }
2917         }
2918         st->info->duration_count++;
2919         st->info->rfps_duration_sum += duration;
2920
2921         if (st->info->duration_count % 10 == 0) {
2922             int n = st->info->duration_count;
2923             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2924                 if (st->info->duration_error[0][1][i] < 1e10) {
2925                     double a0     = st->info->duration_error[0][0][i] / n;
2926                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2927                     double a1     = st->info->duration_error[1][0][i] / n;
2928                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2929                     if (error0 > 0.04 && error1 > 0.04) {
2930                         st->info->duration_error[0][1][i] = 2e10;
2931                         st->info->duration_error[1][1][i] = 2e10;
2932                     }
2933                 }
2934             }
2935         }
2936
2937         // ignore the first 4 values, they might have some random jitter
2938         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2939             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2940     }
2941     if (ts != AV_NOPTS_VALUE)
2942         st->info->last_dts = ts;
2943
2944     return 0;
2945 }
2946
2947 void ff_rfps_calculate(AVFormatContext *ic)
2948 {
2949     int i, j;
2950
2951     for (i = 0; i < ic->nb_streams; i++) {
2952         AVStream *st = ic->streams[i];
2953
2954         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2955             continue;
2956         // the check for tb_unreliable() is not completely correct, since this is not about handling
2957         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2958         // ipmovie.c produces.
2959         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)
2960             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);
2961         if (st->info->duration_count>1 && !st->r_frame_rate.num
2962             && tb_unreliable(st->codec)) {
2963             int num = 0;
2964             double best_error= 0.01;
2965             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2966
2967             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2968                 int k;
2969
2970                 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2971                     continue;
2972                 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2973                     continue;
2974
2975                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2976                     continue;
2977
2978                 for (k= 0; k<2; k++) {
2979                     int n = st->info->duration_count;
2980                     double a= st->info->duration_error[k][0][j] / n;
2981                     double error= st->info->duration_error[k][1][j]/n - a*a;
2982
2983                     if (error < best_error && best_error> 0.000000001) {
2984                         best_error= error;
2985                         num = get_std_framerate(j);
2986                     }
2987                     if (error < 0.02)
2988                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2989                 }
2990             }
2991             // do not increase frame rate by more than 1 % in order to match a standard rate.
2992             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2993                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2994         }
2995         if (   !st->avg_frame_rate.num
2996             && st->r_frame_rate.num && st->info->rfps_duration_sum
2997             && st->info->codec_info_duration <= 0
2998             && st->info->duration_count > 2
2999             && 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
3000             ) {
3001             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3002             st->avg_frame_rate = st->r_frame_rate;
3003         }
3004
3005         av_freep(&st->info->duration_error);
3006         st->info->last_dts = AV_NOPTS_VALUE;
3007         st->info->duration_count = 0;
3008         st->info->rfps_duration_sum = 0;
3009     }
3010 }
3011
3012 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3013 {
3014     int i, count, ret = 0, j;
3015     int64_t read_size;
3016     AVStream *st;
3017     AVPacket pkt1, *pkt;
3018     int64_t old_offset  = avio_tell(ic->pb);
3019     // new streams might appear, no options for those
3020     int orig_nb_streams = ic->nb_streams;
3021     int flush_codecs;
3022     int64_t max_analyze_duration = ic->max_analyze_duration2;
3023     int64_t max_stream_analyze_duration;
3024     int64_t probesize = ic->probesize2;
3025
3026     if (!max_analyze_duration)
3027         max_analyze_duration = ic->max_analyze_duration;
3028     if (ic->probesize)
3029         probesize = ic->probesize;
3030     flush_codecs = probesize > 0;
3031
3032     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3033
3034     max_stream_analyze_duration = max_analyze_duration;
3035     if (!max_analyze_duration) {
3036         max_stream_analyze_duration =
3037         max_analyze_duration        = 5*AV_TIME_BASE;
3038         if (!strcmp(ic->iformat->name, "flv"))
3039             max_stream_analyze_duration = 30*AV_TIME_BASE;
3040     }
3041
3042     if (ic->pb)
3043         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3044                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3045
3046     for (i = 0; i < ic->nb_streams; i++) {
3047         const AVCodec *codec;
3048         AVDictionary *thread_opt = NULL;
3049         st = ic->streams[i];
3050
3051         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3052             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3053 /*            if (!st->time_base.num)
3054                 st->time_base = */
3055             if (!st->codec->time_base.num)
3056                 st->codec->time_base = st->time_base;
3057         }
3058         // only for the split stuff
3059         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3060             st->parser = av_parser_init(st->codec->codec_id);
3061             if (st->parser) {
3062                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3063                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3064                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3065                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3066                 }
3067             } else if (st->need_parsing) {
3068                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3069                        "%s, packets or times may be invalid.\n",
3070                        avcodec_get_name(st->codec->codec_id));
3071             }
3072         }
3073         codec = find_decoder(ic, st, st->codec->codec_id);
3074
3075         /* Force thread count to 1 since the H.264 decoder will not extract
3076          * SPS and PPS to extradata during multi-threaded decoding. */
3077         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3078
3079         if (ic->codec_whitelist)
3080             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3081
3082         /* Ensure that subtitle_header is properly set. */
3083         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3084             && codec && !st->codec->codec) {
3085             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3086                 av_log(ic, AV_LOG_WARNING,
3087                        "Failed to open codec in av_find_stream_info\n");
3088         }
3089
3090         // Try to just open decoders, in case this is enough to get parameters.
3091         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3092             if (codec && !st->codec->codec)
3093                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3094                     av_log(ic, AV_LOG_WARNING,
3095                            "Failed to open codec in av_find_stream_info\n");
3096         }
3097         if (!options)
3098             av_dict_free(&thread_opt);
3099     }
3100
3101     for (i = 0; i < ic->nb_streams; i++) {
3102 #if FF_API_R_FRAME_RATE
3103         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3104 #endif
3105         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3106         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3107     }
3108
3109     count     = 0;
3110     read_size = 0;
3111     for (;;) {
3112         int analyzed_all_streams;
3113         if (ff_check_interrupt(&ic->interrupt_callback)) {
3114             ret = AVERROR_EXIT;
3115             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3116             break;
3117         }
3118
3119         /* check if one codec still needs to be handled */
3120         for (i = 0; i < ic->nb_streams; i++) {
3121             int fps_analyze_framecount = 20;
3122
3123             st = ic->streams[i];
3124             if (!has_codec_parameters(st, NULL))
3125                 break;
3126             /* If the timebase is coarse (like the usual millisecond precision
3127              * of mkv), we need to analyze more frames to reliably arrive at
3128              * the correct fps. */
3129             if (av_q2d(st->time_base) > 0.0005)
3130                 fps_analyze_framecount *= 2;
3131             if (!tb_unreliable(st->codec))
3132                 fps_analyze_framecount = 0;
3133             if (ic->fps_probe_size >= 0)
3134                 fps_analyze_framecount = ic->fps_probe_size;
3135             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3136                 fps_analyze_framecount = 0;
3137             /* variable fps and no guess at the real fps */
3138             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3139                 st->info->duration_count < fps_analyze_framecount &&
3140                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3141                 break;
3142             if (st->parser && st->parser->parser->split &&
3143                 !st->codec->extradata)
3144                 break;
3145             if (st->first_dts == AV_NOPTS_VALUE &&
3146                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3147                 st->codec_info_nb_frames < ic->max_ts_probe &&
3148                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3149                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3150                 break;
3151         }
3152         analyzed_all_streams = 0;
3153         if (i == ic->nb_streams) {
3154             analyzed_all_streams = 1;
3155             /* NOTE: If the format has no header, then we need to read some
3156              * packets to get most of the streams, so we cannot stop here. */
3157             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3158                 /* If we found the info for all the codecs, we can stop. */
3159                 ret = count;
3160                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3161                 flush_codecs = 0;
3162                 break;
3163             }
3164         }
3165         /* We did not get all the codec info, but we read too much data. */
3166         if (read_size >= probesize) {
3167             ret = count;
3168             av_log(ic, AV_LOG_DEBUG,
3169                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3170             for (i = 0; i < ic->nb_streams; i++)
3171                 if (!ic->streams[i]->r_frame_rate.num &&
3172                     ic->streams[i]->info->duration_count <= 1 &&
3173                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3174                     strcmp(ic->iformat->name, "image2"))
3175                     av_log(ic, AV_LOG_WARNING,
3176                            "Stream #%d: not enough frames to estimate rate; "
3177                            "consider increasing probesize\n", i);
3178             break;
3179         }
3180
3181         /* NOTE: A new stream can be added there if no header in file
3182          * (AVFMTCTX_NOHEADER). */
3183         ret = read_frame_internal(ic, &pkt1);
3184         if (ret == AVERROR(EAGAIN))
3185             continue;
3186
3187         if (ret < 0) {
3188             /* EOF or error*/
3189             break;
3190         }
3191
3192         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3193             free_packet_buffer(&ic->internal->packet_buffer,
3194                                &ic->internal->packet_buffer_end);
3195         {
3196             pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3197                                 &ic->internal->packet_buffer_end);
3198             if (!pkt) {
3199                 ret = AVERROR(ENOMEM);
3200                 goto find_stream_info_err;
3201             }
3202             if ((ret = av_dup_packet(pkt)) < 0)
3203                 goto find_stream_info_err;
3204         }
3205
3206         st = ic->streams[pkt->stream_index];
3207         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3208             read_size += pkt->size;
3209
3210         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3211             /* check for non-increasing dts */
3212             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3213                 st->info->fps_last_dts >= pkt->dts) {
3214                 av_log(ic, AV_LOG_DEBUG,
3215                        "Non-increasing DTS in stream %d: packet %d with DTS "
3216                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3217                        st->index, st->info->fps_last_dts_idx,
3218                        st->info->fps_last_dts, st->codec_info_nb_frames,
3219                        pkt->dts);
3220                 st->info->fps_first_dts =
3221                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3222             }
3223             /* Check for a discontinuity in dts. If the difference in dts
3224              * is more than 1000 times the average packet duration in the
3225              * sequence, we treat it as a discontinuity. */
3226             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3227                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3228                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3229                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3230                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3231                 av_log(ic, AV_LOG_WARNING,
3232                        "DTS discontinuity in stream %d: packet %d with DTS "
3233                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3234                        st->index, st->info->fps_last_dts_idx,
3235                        st->info->fps_last_dts, st->codec_info_nb_frames,
3236                        pkt->dts);
3237                 st->info->fps_first_dts =
3238                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3239             }
3240
3241             /* update stored dts values */
3242             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3243                 st->info->fps_first_dts     = pkt->dts;
3244                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3245             }
3246             st->info->fps_last_dts     = pkt->dts;
3247             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3248         }
3249         if (st->codec_info_nb_frames>1) {
3250             int64_t t = 0;
3251
3252             if (st->time_base.den > 0)
3253                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3254             if (st->avg_frame_rate.num > 0)
3255                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3256
3257             if (   t == 0
3258                 && st->codec_info_nb_frames>30
3259                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3260                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3261                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3262
3263             if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3264                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3265                        max_analyze_duration,
3266                        t);
3267                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3268                     av_packet_unref(pkt);
3269                 break;
3270             }
3271             if (pkt->duration) {
3272                 st->info->codec_info_duration        += pkt->duration;
3273                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3274             }
3275         }
3276 #if FF_API_R_FRAME_RATE
3277         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3278             ff_rfps_add_frame(ic, st, pkt->dts);
3279 #endif
3280         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3281             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3282             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3283                 if (ff_alloc_extradata(st->codec, i))
3284                     return AVERROR(ENOMEM);
3285                 memcpy(st->codec->extradata, pkt->data,
3286                        st->codec->extradata_size);
3287             }
3288         }
3289
3290         /* If still no information, we try to open the codec and to
3291          * decompress the frame. We try to avoid that in most cases as
3292          * it takes longer and uses more memory. For MPEG-4, we need to
3293          * decompress for QuickTime.
3294          *
3295          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3296          * least one frame of codec data, this makes sure the codec initializes
3297          * the channel configuration and does not only trust the values from
3298          * the container. */
3299         try_decode_frame(ic, st, pkt,
3300                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3301
3302         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3303             av_packet_unref(pkt);
3304
3305         st->codec_info_nb_frames++;
3306         count++;
3307     }
3308
3309     if (flush_codecs) {
3310         AVPacket empty_pkt = { 0 };
3311         int err = 0;
3312         av_init_packet(&empty_pkt);
3313
3314         for (i = 0; i < ic->nb_streams; i++) {
3315
3316             st = ic->streams[i];
3317
3318             /* flush the decoders */
3319             if (st->info->found_decoder == 1) {
3320                 do {
3321                     err = try_decode_frame(ic, st, &empty_pkt,
3322                                             (options && i < orig_nb_streams)
3323                                             ? &options[i] : NULL);
3324                 } while (err > 0 && !has_codec_parameters(st, NULL));
3325
3326                 if (err < 0) {
3327                     av_log(ic, AV_LOG_INFO,
3328                         "decoding for stream %d failed\n", st->index);
3329                 }
3330             }
3331         }
3332     }
3333
3334     // close codecs which were opened in try_decode_frame()
3335     for (i = 0; i < ic->nb_streams; i++) {
3336         st = ic->streams[i];
3337         avcodec_close(st->codec);
3338     }
3339
3340     ff_rfps_calculate(ic);
3341
3342     for (i = 0; i < ic->nb_streams; i++) {
3343         st = ic->streams[i];
3344         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3345             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3346                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3347                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3348                     st->codec->codec_tag= tag;
3349             }
3350
3351             /* estimate average framerate if not set by demuxer */
3352             if (st->info->codec_info_duration_fields &&
3353                 !st->avg_frame_rate.num &&
3354                 st->info->codec_info_duration) {
3355                 int best_fps      = 0;
3356                 double best_error = 0.01;
3357
3358                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3359                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3360                     st->info->codec_info_duration        < 0)
3361                     continue;
3362                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3363                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3364                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3365
3366                 /* Round guessed framerate to a "standard" framerate if it's
3367                  * within 1% of the original estimate. */
3368                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3369                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3370                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3371                                               av_q2d(std_fps) - 1);
3372
3373                     if (error < best_error) {
3374                         best_error = error;
3375                         best_fps   = std_fps.num;
3376                     }
3377                 }
3378                 if (best_fps)
3379                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3380                               best_fps, 12 * 1001, INT_MAX);
3381             }
3382
3383             if (!st->r_frame_rate.num) {
3384                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3385                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3386                     st->r_frame_rate.num = st->codec->time_base.den;
3387                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3388                 } else {
3389                     st->r_frame_rate.num = st->time_base.den;
3390                     st->r_frame_rate.den = st->time_base.num;
3391                 }
3392             }
3393             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3394                 AVRational hw_ratio = { st->codec->height, st->codec->width };
3395                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3396                                                    hw_ratio);
3397             }
3398         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3399             if (!st->codec->bits_per_coded_sample)
3400                 st->codec->bits_per_coded_sample =
3401                     av_get_bits_per_sample(st->codec->codec_id);
3402             // set stream disposition based on audio service type
3403             switch (st->codec->audio_service_type) {
3404             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3405                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3406                 break;
3407             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3408                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3409                 break;
3410             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3411                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3412                 break;
3413             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3414                 st->disposition = AV_DISPOSITION_COMMENT;
3415                 break;
3416             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3417                 st->disposition = AV_DISPOSITION_KARAOKE;
3418                 break;
3419             }
3420         }
3421     }
3422
3423     if (probesize)
3424     estimate_timings(ic, old_offset);
3425
3426     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3427
3428     if (ret >= 0 && ic->nb_streams)
3429         /* We could not have all the codec parameters before EOF. */
3430         ret = -1;
3431     for (i = 0; i < ic->nb_streams; i++) {
3432         const char *errmsg;
3433         st = ic->streams[i];
3434         if (!has_codec_parameters(st, &errmsg)) {
3435             char buf[256];
3436             avcodec_string(buf, sizeof(buf), st->codec, 0);
3437             av_log(ic, AV_LOG_WARNING,
3438                    "Could not find codec parameters for stream %d (%s): %s\n"
3439                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3440                    i, buf, errmsg);
3441         } else {
3442             ret = 0;
3443         }
3444     }
3445
3446     compute_chapters_end(ic);
3447
3448 find_stream_info_err:
3449     for (i = 0; i < ic->nb_streams; i++) {
3450         st = ic->streams[i];
3451         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3452             ic->streams[i]->codec->thread_count = 0;
3453         if (st->info)
3454             av_freep(&st->info->duration_error);
3455         av_freep(&ic->streams[i]->info);
3456     }
3457     if (ic->pb)
3458         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3459                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3460     return ret;
3461 }
3462
3463 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3464 {
3465     int i, j;
3466
3467     for (i = 0; i < ic->nb_programs; i++) {
3468         if (ic->programs[i] == last) {
3469             last = NULL;
3470         } else {
3471             if (!last)
3472                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3473                     if (ic->programs[i]->stream_index[j] == s)
3474                         return ic->programs[i];
3475         }
3476     }
3477     return NULL;
3478 }
3479
3480 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3481                         int wanted_stream_nb, int related_stream,
3482                         AVCodec **decoder_ret, int flags)
3483 {
3484     int i, nb_streams = ic->nb_streams;
3485     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3486     unsigned *program = NULL;
3487     const AVCodec *decoder = NULL, *best_decoder = NULL;
3488
3489     if (related_stream >= 0 && wanted_stream_nb < 0) {
3490         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3491         if (p) {
3492             program    = p->stream_index;
3493             nb_streams = p->nb_stream_indexes;
3494         }
3495     }
3496     for (i = 0; i < nb_streams; i++) {
3497         int real_stream_index = program ? program[i] : i;
3498         AVStream *st          = ic->streams[real_stream_index];
3499         AVCodecContext *avctx = st->codec;
3500         if (avctx->codec_type != type)
3501             continue;
3502         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3503             continue;
3504         if (wanted_stream_nb != real_stream_index &&
3505             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3506                                AV_DISPOSITION_VISUAL_IMPAIRED))
3507             continue;
3508         if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3509             continue;
3510         if (decoder_ret) {
3511             decoder = find_decoder(ic, st, st->codec->codec_id);
3512             if (!decoder) {
3513                 if (ret < 0)
3514                     ret = AVERROR_DECODER_NOT_FOUND;
3515                 continue;
3516             }
3517         }
3518         count = st->codec_info_nb_frames;
3519         bitrate = avctx->bit_rate;
3520         if (!bitrate)
3521             bitrate = avctx->rc_max_rate;
3522         multiframe = FFMIN(5, count);
3523         if ((best_multiframe >  multiframe) ||
3524             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3525             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3526             continue;
3527         best_count   = count;
3528         best_bitrate = bitrate;
3529         best_multiframe = multiframe;
3530         ret          = real_stream_index;
3531         best_decoder = decoder;
3532         if (program && i == nb_streams - 1 && ret < 0) {
3533             program    = NULL;
3534             nb_streams = ic->nb_streams;
3535             /* no related stream found, try again with everything */
3536             i = 0;
3537         }
3538     }
3539     if (decoder_ret)
3540         *decoder_ret = (AVCodec*)best_decoder;
3541     return ret;
3542 }
3543
3544 /*******************************************************/
3545
3546 int av_read_play(AVFormatContext *s)
3547 {
3548     if (s->iformat->read_play)
3549         return s->iformat->read_play(s);
3550     if (s->pb)
3551         return avio_pause(s->pb, 0);
3552     return AVERROR(ENOSYS);
3553 }
3554
3555 int av_read_pause(AVFormatContext *s)
3556 {
3557     if (s->iformat->read_pause)
3558         return s->iformat->read_pause(s);
3559     if (s->pb)
3560         return avio_pause(s->pb, 1);
3561     return AVERROR(ENOSYS);
3562 }
3563
3564 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3565     int j;
3566     av_assert0(s->nb_streams>0);
3567     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3568
3569     for (j = 0; j < st->nb_side_data; j++)
3570         av_freep(&st->side_data[j].data);
3571     av_freep(&st->side_data);
3572     st->nb_side_data = 0;
3573
3574     if (st->parser) {
3575         av_parser_close(st->parser);
3576     }
3577     if (st->attached_pic.data)
3578         av_free_packet(&st->attached_pic);
3579     av_dict_free(&st->metadata);
3580     av_freep(&st->probe_data.buf);
3581     av_freep(&st->index_entries);
3582     av_freep(&st->codec->extradata);
3583     av_freep(&st->codec->subtitle_header);
3584     av_freep(&st->codec);
3585     av_freep(&st->priv_data);
3586     if (st->info)
3587         av_freep(&st->info->duration_error);
3588     av_freep(&st->info);
3589     av_freep(&st->recommended_encoder_configuration);
3590     av_freep(&s->streams[ --s->nb_streams ]);
3591 }
3592
3593 void avformat_free_context(AVFormatContext *s)
3594 {
3595     int i;
3596
3597     if (!s)
3598         return;
3599
3600     av_opt_free(s);
3601     if (s->iformat && s->iformat->priv_class && s->priv_data)
3602         av_opt_free(s->priv_data);
3603     if (s->oformat && s->oformat->priv_class && s->priv_data)
3604         av_opt_free(s->priv_data);
3605
3606     for (i = s->nb_streams - 1; i >= 0; i--) {
3607         ff_free_stream(s, s->streams[i]);
3608     }
3609     for (i = s->nb_programs - 1; i >= 0; i--) {
3610         av_dict_free(&s->programs[i]->metadata);
3611         av_freep(&s->programs[i]->stream_index);
3612         av_freep(&s->programs[i]);
3613     }
3614     av_freep(&s->programs);
3615     av_freep(&s->priv_data);
3616     while (s->nb_chapters--) {
3617         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3618         av_freep(&s->chapters[s->nb_chapters]);
3619     }
3620     av_freep(&s->chapters);
3621     av_dict_free(&s->metadata);
3622     av_freep(&s->streams);
3623     av_freep(&s->internal);
3624     flush_packet_queue(s);
3625     av_free(s);
3626 }
3627
3628 void avformat_close_input(AVFormatContext **ps)
3629 {
3630     AVFormatContext *s;
3631     AVIOContext *pb;
3632
3633     if (!ps || !*ps)
3634         return;
3635
3636     s  = *ps;
3637     pb = s->pb;
3638
3639     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3640         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3641         pb = NULL;
3642
3643     flush_packet_queue(s);
3644
3645     if (s->iformat)
3646         if (s->iformat->read_close)
3647             s->iformat->read_close(s);
3648
3649     avformat_free_context(s);
3650
3651     *ps = NULL;
3652
3653     avio_close(pb);
3654 }
3655
3656 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3657 {
3658     AVStream *st;
3659     int i;
3660     AVStream **streams;
3661
3662     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3663         return NULL;
3664     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3665     if (!streams)
3666         return NULL;
3667     s->streams = streams;
3668
3669     st = av_mallocz(sizeof(AVStream));
3670     if (!st)
3671         return NULL;
3672     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3673         av_free(st);
3674         return NULL;
3675     }
3676     st->info->last_dts = AV_NOPTS_VALUE;
3677
3678     st->codec = avcodec_alloc_context3(c);
3679     if (!st->codec) {
3680         av_free(st->info);
3681         av_free(st);
3682         return NULL;
3683     }
3684     if (s->iformat) {
3685         /* no default bitrate if decoding */
3686         st->codec->bit_rate = 0;
3687
3688         /* default pts setting is MPEG-like */
3689         avpriv_set_pts_info(st, 33, 1, 90000);
3690     }
3691
3692     st->index      = s->nb_streams;
3693     st->start_time = AV_NOPTS_VALUE;
3694     st->duration   = AV_NOPTS_VALUE;
3695     /* we set the current DTS to 0 so that formats without any timestamps
3696      * but durations get some timestamps, formats with some unknown
3697      * timestamps have their first few packets buffered and the
3698      * timestamps corrected before they are returned to the user */
3699     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3700     st->first_dts     = AV_NOPTS_VALUE;
3701     st->probe_packets = MAX_PROBE_PACKETS;
3702     st->pts_wrap_reference = AV_NOPTS_VALUE;
3703     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3704
3705     st->last_IP_pts = AV_NOPTS_VALUE;
3706     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3707     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3708         st->pts_buffer[i] = AV_NOPTS_VALUE;
3709
3710     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3711
3712 #if FF_API_R_FRAME_RATE
3713     st->info->last_dts      = AV_NOPTS_VALUE;
3714 #endif
3715     st->info->fps_first_dts = AV_NOPTS_VALUE;
3716     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3717
3718     st->inject_global_side_data = s->internal->inject_global_side_data;
3719
3720     s->streams[s->nb_streams++] = st;
3721     return st;
3722 }
3723
3724 AVProgram *av_new_program(AVFormatContext *ac, int id)
3725 {
3726     AVProgram *program = NULL;
3727     int i;
3728
3729     av_dlog(ac, "new_program: id=0x%04x\n", id);
3730
3731     for (i = 0; i < ac->nb_programs; i++)
3732         if (ac->programs[i]->id == id)
3733             program = ac->programs[i];
3734
3735     if (!program) {
3736         program = av_mallocz(sizeof(AVProgram));
3737         if (!program)
3738             return NULL;
3739         dynarray_add(&ac->programs, &ac->nb_programs, program);
3740         program->discard = AVDISCARD_NONE;
3741     }
3742     program->id = id;
3743     program->pts_wrap_reference = AV_NOPTS_VALUE;
3744     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3745
3746     program->start_time =
3747     program->end_time   = AV_NOPTS_VALUE;
3748
3749     return program;
3750 }
3751
3752 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3753                               int64_t start, int64_t end, const char *title)
3754 {
3755     AVChapter *chapter = NULL;
3756     int i;
3757
3758     if (end != AV_NOPTS_VALUE && start > end) {
3759         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3760         return NULL;
3761     }
3762
3763     for (i = 0; i < s->nb_chapters; i++)
3764         if (s->chapters[i]->id == id)
3765             chapter = s->chapters[i];
3766
3767     if (!chapter) {
3768         chapter = av_mallocz(sizeof(AVChapter));
3769         if (!chapter)
3770             return NULL;
3771         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3772     }
3773     av_dict_set(&chapter->metadata, "title", title, 0);
3774     chapter->id        = id;
3775     chapter->time_base = time_base;
3776     chapter->start     = start;
3777     chapter->end       = end;
3778
3779     return chapter;
3780 }
3781
3782 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3783 {
3784     int i, j;
3785     AVProgram *program = NULL;
3786     void *tmp;
3787
3788     if (idx >= ac->nb_streams) {
3789         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3790         return;
3791     }
3792
3793     for (i = 0; i < ac->nb_programs; i++) {
3794         if (ac->programs[i]->id != progid)
3795             continue;
3796         program = ac->programs[i];
3797         for (j = 0; j < program->nb_stream_indexes; j++)
3798             if (program->stream_index[j] == idx)
3799                 return;
3800
3801         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3802         if (!tmp)
3803             return;
3804         program->stream_index = tmp;
3805         program->stream_index[program->nb_stream_indexes++] = idx;
3806         return;
3807     }
3808 }
3809
3810 uint64_t ff_ntp_time(void)
3811 {
3812     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3813 }
3814
3815 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3816 {
3817     const char *p;
3818     char *q, buf1[20], c;
3819     int nd, len, percentd_found;
3820
3821     q = buf;
3822     p = path;
3823     percentd_found = 0;
3824     for (;;) {
3825         c = *p++;
3826         if (c == '\0')
3827             break;
3828         if (c == '%') {
3829             do {
3830                 nd = 0;
3831                 while (av_isdigit(*p))
3832                     nd = nd * 10 + *p++ - '0';
3833                 c = *p++;
3834             } while (av_isdigit(c));
3835
3836             switch (c) {
3837             case '%':
3838                 goto addchar;
3839             case 'd':
3840                 if (percentd_found)
3841                     goto fail;
3842                 percentd_found = 1;
3843                 if (number < 0)
3844                     nd += 1;
3845                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3846                 len = strlen(buf1);
3847                 if ((q - buf + len) > buf_size - 1)
3848                     goto fail;
3849                 memcpy(q, buf1, len);
3850                 q += len;
3851                 break;
3852             default:
3853                 goto fail;
3854             }
3855         } else {
3856 addchar:
3857             if ((q - buf) < buf_size - 1)
3858                 *q++ = c;
3859         }
3860     }
3861     if (!percentd_found)
3862         goto fail;
3863     *q = '\0';
3864     return 0;
3865 fail:
3866     *q = '\0';
3867     return -1;
3868 }
3869
3870 void av_url_split(char *proto, int proto_size,
3871                   char *authorization, int authorization_size,
3872                   char *hostname, int hostname_size,
3873                   int *port_ptr, char *path, int path_size, const char *url)
3874 {
3875     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3876
3877     if (port_ptr)
3878         *port_ptr = -1;
3879     if (proto_size > 0)
3880         proto[0] = 0;
3881     if (authorization_size > 0)
3882         authorization[0] = 0;
3883     if (hostname_size > 0)
3884         hostname[0] = 0;
3885     if (path_size > 0)
3886         path[0] = 0;
3887
3888     /* parse protocol */
3889     if ((p = strchr(url, ':'))) {
3890         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3891         p++; /* skip ':' */
3892         if (*p == '/')
3893             p++;
3894         if (*p == '/')
3895             p++;
3896     } else {
3897         /* no protocol means plain filename */
3898         av_strlcpy(path, url, path_size);
3899         return;
3900     }
3901
3902     /* separate path from hostname */
3903     ls = strchr(p, '/');
3904     ls2 = strchr(p, '?');
3905     if (!ls)
3906         ls = ls2;
3907     else if (ls && ls2)
3908         ls = FFMIN(ls, ls2);
3909     if (ls)
3910         av_strlcpy(path, ls, path_size);
3911     else
3912         ls = &p[strlen(p)];  // XXX
3913
3914     /* the rest is hostname, use that to parse auth/port */
3915     if (ls != p) {
3916         /* authorization (user[:pass]@hostname) */
3917         at2 = p;
3918         while ((at = strchr(p, '@')) && at < ls) {
3919             av_strlcpy(authorization, at2,
3920                        FFMIN(authorization_size, at + 1 - at2));
3921             p = at + 1; /* skip '@' */
3922         }
3923
3924         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3925             /* [host]:port */
3926             av_strlcpy(hostname, p + 1,
3927                        FFMIN(hostname_size, brk - p));
3928             if (brk[1] == ':' && port_ptr)
3929                 *port_ptr = atoi(brk + 2);
3930         } else if ((col = strchr(p, ':')) && col < ls) {
3931             av_strlcpy(hostname, p,
3932                        FFMIN(col + 1 - p, hostname_size));
3933             if (port_ptr)
3934                 *port_ptr = atoi(col + 1);
3935         } else
3936             av_strlcpy(hostname, p,
3937                        FFMIN(ls + 1 - p, hostname_size));
3938     }
3939 }
3940
3941 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3942 {
3943     int i;
3944     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3945                                            '4', '5', '6', '7',
3946                                            '8', '9', 'A', 'B',
3947                                            'C', 'D', 'E', 'F' };
3948     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3949                                            '4', '5', '6', '7',
3950                                            '8', '9', 'a', 'b',
3951                                            'c', 'd', 'e', 'f' };
3952     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3953
3954     for (i = 0; i < s; i++) {
3955         buff[i * 2]     = hex_table[src[i] >> 4];
3956         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3957     }
3958
3959     return buff;
3960 }
3961
3962 int ff_hex_to_data(uint8_t *data, const char *p)
3963 {
3964     int c, len, v;
3965
3966     len = 0;
3967     v   = 1;
3968     for (;;) {
3969         p += strspn(p, SPACE_CHARS);
3970         if (*p == '\0')
3971             break;
3972         c = av_toupper((unsigned char) *p++);
3973         if (c >= '0' && c <= '9')
3974             c = c - '0';
3975         else if (c >= 'A' && c <= 'F')
3976             c = c - 'A' + 10;
3977         else
3978             break;
3979         v = (v << 4) | c;
3980         if (v & 0x100) {
3981             if (data)
3982                 data[len] = v;
3983             len++;
3984             v = 1;
3985         }
3986     }
3987     return len;
3988 }
3989
3990 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3991                          unsigned int pts_num, unsigned int pts_den)
3992 {
3993     AVRational new_tb;
3994     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3995         if (new_tb.num != pts_num)
3996             av_log(NULL, AV_LOG_DEBUG,
3997                    "st:%d removing common factor %d from timebase\n",
3998                    s->index, pts_num / new_tb.num);
3999     } else
4000         av_log(NULL, AV_LOG_WARNING,
4001                "st:%d has too large timebase, reducing\n", s->index);
4002
4003     if (new_tb.num <= 0 || new_tb.den <= 0) {
4004         av_log(NULL, AV_LOG_ERROR,
4005                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4006                new_tb.num, new_tb.den,
4007                s->index);
4008         return;
4009     }
4010     s->time_base     = new_tb;
4011     av_codec_set_pkt_timebase(s->codec, new_tb);
4012     s->pts_wrap_bits = pts_wrap_bits;
4013 }
4014
4015 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4016                         void *context)
4017 {
4018     const char *ptr = str;
4019
4020     /* Parse key=value pairs. */
4021     for (;;) {
4022         const char *key;
4023         char *dest = NULL, *dest_end;
4024         int key_len, dest_len = 0;
4025
4026         /* Skip whitespace and potential commas. */
4027         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4028             ptr++;
4029         if (!*ptr)
4030             break;
4031
4032         key = ptr;
4033
4034         if (!(ptr = strchr(key, '=')))
4035             break;
4036         ptr++;
4037         key_len = ptr - key;
4038
4039         callback_get_buf(context, key, key_len, &dest, &dest_len);
4040         dest_end = dest + dest_len - 1;
4041
4042         if (*ptr == '\"') {
4043             ptr++;
4044             while (*ptr && *ptr != '\"') {
4045                 if (*ptr == '\\') {
4046                     if (!ptr[1])
4047                         break;
4048                     if (dest && dest < dest_end)
4049                         *dest++ = ptr[1];
4050                     ptr += 2;
4051                 } else {
4052                     if (dest && dest < dest_end)
4053                         *dest++ = *ptr;
4054                     ptr++;
4055                 }
4056             }
4057             if (*ptr == '\"')
4058                 ptr++;
4059         } else {
4060             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4061                 if (dest && dest < dest_end)
4062                     *dest++ = *ptr;
4063         }
4064         if (dest)
4065             *dest = 0;
4066     }
4067 }
4068
4069 int ff_find_stream_index(AVFormatContext *s, int id)
4070 {
4071     int i;
4072     for (i = 0; i < s->nb_streams; i++)
4073         if (s->streams[i]->id == id)
4074             return i;
4075     return -1;
4076 }
4077
4078 int64_t ff_iso8601_to_unix_time(const char *datestr)
4079 {
4080     struct tm time1 = { 0 }, time2 = { 0 };
4081     char *ret1, *ret2;
4082     ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4083     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4084     if (ret2 && !ret1)
4085         return av_timegm(&time2);
4086     else
4087         return av_timegm(&time1);
4088 }
4089
4090 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4091                          int std_compliance)
4092 {
4093     if (ofmt) {
4094         if (ofmt->query_codec)
4095             return ofmt->query_codec(codec_id, std_compliance);
4096         else if (ofmt->codec_tag)
4097             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4098         else if (codec_id == ofmt->video_codec ||
4099                  codec_id == ofmt->audio_codec ||
4100                  codec_id == ofmt->subtitle_codec)
4101             return 1;
4102     }
4103     return AVERROR_PATCHWELCOME;
4104 }
4105
4106 int avformat_network_init(void)
4107 {
4108 #if CONFIG_NETWORK
4109     int ret;
4110     ff_network_inited_globally = 1;
4111     if ((ret = ff_network_init()) < 0)
4112         return ret;
4113     if ((ret = ff_tls_init()) < 0)
4114         return ret;
4115 #endif
4116     return 0;
4117 }
4118
4119 int avformat_network_deinit(void)
4120 {
4121 #if CONFIG_NETWORK
4122     ff_network_close();
4123     ff_tls_deinit();
4124 #endif
4125     return 0;
4126 }
4127
4128 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4129                         uint64_t channel_layout, int32_t sample_rate,
4130                         int32_t width, int32_t height)
4131 {
4132     uint32_t flags = 0;
4133     int size = 4;
4134     uint8_t *data;
4135     if (!pkt)
4136         return AVERROR(EINVAL);
4137     if (channels) {
4138         size  += 4;
4139         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4140     }
4141     if (channel_layout) {
4142         size  += 8;
4143         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4144     }
4145     if (sample_rate) {
4146         size  += 4;
4147         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4148     }
4149     if (width || height) {
4150         size  += 8;
4151         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4152     }
4153     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4154     if (!data)
4155         return AVERROR(ENOMEM);
4156     bytestream_put_le32(&data, flags);
4157     if (channels)
4158         bytestream_put_le32(&data, channels);
4159     if (channel_layout)
4160         bytestream_put_le64(&data, channel_layout);
4161     if (sample_rate)
4162         bytestream_put_le32(&data, sample_rate);
4163     if (width || height) {
4164         bytestream_put_le32(&data, width);
4165         bytestream_put_le32(&data, height);
4166     }
4167     return 0;
4168 }
4169
4170 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4171 {
4172     AVRational undef = {0, 1};
4173     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4174     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4175     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4176
4177     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4178                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4179     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4180         stream_sample_aspect_ratio = undef;
4181
4182     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4183                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4184     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4185         frame_sample_aspect_ratio = undef;
4186
4187     if (stream_sample_aspect_ratio.num)
4188         return stream_sample_aspect_ratio;
4189     else
4190         return frame_sample_aspect_ratio;
4191 }
4192
4193 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4194 {
4195     AVRational fr = st->r_frame_rate;
4196     AVRational codec_fr = st->codec->framerate;
4197     AVRational   avg_fr = st->avg_frame_rate;
4198
4199     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4200         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4201         fr = avg_fr;
4202     }
4203
4204
4205     if (st->codec->ticks_per_frame > 1) {
4206         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4207             (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))
4208             fr = codec_fr;
4209     }
4210
4211     return fr;
4212 }
4213
4214 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4215                                     const char *spec)
4216 {
4217     if (*spec <= '9' && *spec >= '0') /* opt:index */
4218         return strtol(spec, NULL, 0) == st->index;
4219     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4220              *spec == 't') { /* opt:[vasdt] */
4221         enum AVMediaType type;
4222
4223         switch (*spec++) {
4224         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4225         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4226         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4227         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4228         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4229         default:  av_assert0(0);
4230         }
4231         if (type != st->codec->codec_type)
4232             return 0;
4233         if (*spec++ == ':') { /* possibly followed by :index */
4234             int i, index = strtol(spec, NULL, 0);
4235             for (i = 0; i < s->nb_streams; i++)
4236                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4237                    return i == st->index;
4238             return 0;
4239         }
4240         return 1;
4241     } else if (*spec == 'p' && *(spec + 1) == ':') {
4242         int prog_id, i, j;
4243         char *endptr;
4244         spec += 2;
4245         prog_id = strtol(spec, &endptr, 0);
4246         for (i = 0; i < s->nb_programs; i++) {
4247             if (s->programs[i]->id != prog_id)
4248                 continue;
4249
4250             if (*endptr++ == ':') {
4251                 int stream_idx = strtol(endptr, NULL, 0);
4252                 return stream_idx >= 0 &&
4253                     stream_idx < s->programs[i]->nb_stream_indexes &&
4254                     st->index == s->programs[i]->stream_index[stream_idx];
4255             }
4256
4257             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4258                 if (st->index == s->programs[i]->stream_index[j])
4259                     return 1;
4260         }
4261         return 0;
4262     } else if (*spec == '#' ||
4263                (*spec == 'i' && *(spec + 1) == ':')) {
4264         int stream_id;
4265         char *endptr;
4266         spec += 1 + (*spec == 'i');
4267         stream_id = strtol(spec, &endptr, 0);
4268         if (!*endptr)
4269             return stream_id == st->id;
4270     } else if (*spec == 'm' && *(spec + 1) == ':') {
4271         AVDictionaryEntry *tag;
4272         char *key, *val;
4273         int ret;
4274
4275         spec += 2;
4276         val = strchr(spec, ':');
4277
4278         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4279         if (!key)
4280             return AVERROR(ENOMEM);
4281
4282         tag = av_dict_get(st->metadata, key, NULL, 0);
4283         if (tag) {
4284             if (!val || !strcmp(tag->value, val + 1))
4285                 ret = 1;
4286             else
4287                 ret = 0;
4288         } else
4289             ret = 0;
4290
4291         av_freep(&key);
4292         return ret;
4293     } else if (*spec == 'u') {
4294         AVCodecContext *avctx = st->codec;
4295         int val;
4296         switch (avctx->codec_type) {
4297         case AVMEDIA_TYPE_AUDIO:
4298             val = avctx->sample_rate && avctx->channels;
4299             if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4300                 return 0;
4301             break;
4302         case AVMEDIA_TYPE_VIDEO:
4303             val = avctx->width && avctx->height;
4304             if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4305                 return 0;
4306             break;
4307         case AVMEDIA_TYPE_UNKNOWN:
4308             val = 0;
4309             break;
4310         default:
4311             val = 1;
4312             break;
4313         }
4314         return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4315     } else if (!*spec) /* empty specifier, matches everything */
4316         return 1;
4317
4318     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4319     return AVERROR(EINVAL);
4320 }
4321
4322 int ff_generate_avci_extradata(AVStream *st)
4323 {
4324     static const uint8_t avci100_1080p_extradata[] = {
4325         // SPS
4326         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4327         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4328         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4329         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4330         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4331         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4332         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4333         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4334         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4335         // PPS
4336         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4337         0xd0
4338     };
4339     static const uint8_t avci100_1080i_extradata[] = {
4340         // SPS
4341         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4342         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4343         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4344         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4345         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4346         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4347         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4348         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4349         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4350         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4351         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4352         // PPS
4353         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4354         0xd0
4355     };
4356     static const uint8_t avci50_1080p_extradata[] = {
4357         // SPS
4358         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4359         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4360         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4361         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4362         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4363         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4364         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4365         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4366         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4367         // PPS
4368         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4369         0x11
4370     };
4371     static const uint8_t avci50_1080i_extradata[] = {
4372         // SPS
4373         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4374         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4375         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4376         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4377         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4378         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4379         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4380         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4381         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4382         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4383         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4384         // PPS
4385         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4386         0x11
4387     };
4388     static const uint8_t avci100_720p_extradata[] = {
4389         // SPS
4390         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4391         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4392         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4393         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4394         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4395         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4396         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4397         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4398         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4399         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4400         // PPS
4401         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4402         0x11
4403     };
4404     static const uint8_t avci50_720p_extradata[] = {
4405         // SPS
4406         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4407         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4408         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4409         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4410         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4411         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4412         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4413         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4414         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4415         // PPS
4416         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4417         0x11
4418     };
4419
4420     const uint8_t *data = NULL;
4421     int size            = 0;
4422
4423     if (st->codec->width == 1920) {
4424         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4425             data = avci100_1080p_extradata;
4426             size = sizeof(avci100_1080p_extradata);
4427         } else {
4428             data = avci100_1080i_extradata;
4429             size = sizeof(avci100_1080i_extradata);
4430         }
4431     } else if (st->codec->width == 1440) {
4432         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4433             data = avci50_1080p_extradata;
4434             size = sizeof(avci50_1080p_extradata);
4435         } else {
4436             data = avci50_1080i_extradata;
4437             size = sizeof(avci50_1080i_extradata);
4438         }
4439     } else if (st->codec->width == 1280) {
4440         data = avci100_720p_extradata;
4441         size = sizeof(avci100_720p_extradata);
4442     } else if (st->codec->width == 960) {
4443         data = avci50_720p_extradata;
4444         size = sizeof(avci50_720p_extradata);
4445     }
4446
4447     if (!size)
4448         return 0;
4449
4450     av_freep(&st->codec->extradata);
4451     if (ff_alloc_extradata(st->codec, size))
4452         return AVERROR(ENOMEM);
4453     memcpy(st->codec->extradata, data, size);
4454
4455     return 0;
4456 }
4457
4458 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4459                                  int *size)
4460 {
4461     int i;
4462
4463     for (i = 0; i < st->nb_side_data; i++) {
4464         if (st->side_data[i].type == type) {
4465             if (size)
4466                 *size = st->side_data[i].size;
4467             return st->side_data[i].data;
4468         }
4469     }
4470     return NULL;
4471 }
4472
4473 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4474                                  int size)
4475 {
4476     AVPacketSideData *sd, *tmp;
4477     int i;
4478     uint8_t *data = av_malloc(size);
4479
4480     if (!data)
4481         return NULL;
4482
4483     for (i = 0; i < st->nb_side_data; i++) {
4484         sd = &st->side_data[i];
4485
4486         if (sd->type == type) {
4487             av_freep(&sd->data);
4488             sd->data = data;
4489             sd->size = size;
4490             return sd->data;
4491         }
4492     }
4493
4494     tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4495     if (!tmp) {
4496         av_freep(&data);
4497         return NULL;
4498     }
4499
4500     st->side_data = tmp;
4501     st->nb_side_data++;
4502
4503     sd = &st->side_data[st->nb_side_data - 1];
4504     sd->type = type;
4505     sd->data = data;
4506     sd->size = size;
4507     return data;
4508 }