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