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 < 60 * 12)
2791         return (i + 1) * 1001;
2792     else
2793         return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2794 }
2795
2796 /* Is the time base unreliable?
2797  * This is a heuristic to balance between quick acceptance of the values in
2798  * the headers vs. some extra checks.
2799  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2800  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2801  * And there are "variable" fps files this needs to detect as well. */
2802 static int tb_unreliable(AVCodecContext *c)
2803 {
2804     if (c->time_base.den >= 101L * c->time_base.num ||
2805         c->time_base.den <    5L * c->time_base.num ||
2806         // c->codec_tag == AV_RL32("DIVX") ||
2807         // c->codec_tag == AV_RL32("XVID") ||
2808         c->codec_tag == AV_RL32("mp4v") ||
2809         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2810         c->codec_id == AV_CODEC_ID_GIF ||
2811         c->codec_id == AV_CODEC_ID_H264)
2812         return 1;
2813     return 0;
2814 }
2815
2816 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2817 {
2818     int ret;
2819
2820     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2821         avctx->extradata_size = 0;
2822         return AVERROR(EINVAL);
2823     }
2824     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2825     if (avctx->extradata) {
2826         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2827         avctx->extradata_size = size;
2828         ret = 0;
2829     } else {
2830         avctx->extradata_size = 0;
2831         ret = AVERROR(ENOMEM);
2832     }
2833     return ret;
2834 }
2835
2836 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2837 {
2838     int ret = ff_alloc_extradata(avctx, size);
2839     if (ret < 0)
2840         return ret;
2841     ret = avio_read(pb, avctx->extradata, size);
2842     if (ret != size) {
2843         av_freep(&avctx->extradata);
2844         avctx->extradata_size = 0;
2845         av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2846         return ret < 0 ? ret : AVERROR_INVALIDDATA;
2847     }
2848
2849     return ret;
2850 }
2851
2852 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2853 {
2854     int i, j;
2855     int64_t last = st->info->last_dts;
2856
2857     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2858        && ts - (uint64_t)last < INT64_MAX) {
2859         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2860         int64_t duration = ts - last;
2861
2862         if (!st->info->duration_error)
2863             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2864         if (!st->info->duration_error)
2865             return AVERROR(ENOMEM);
2866
2867 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2868 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2869         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2870             if (st->info->duration_error[0][1][i] < 1e10) {
2871                 int framerate = get_std_framerate(i);
2872                 double sdts = dts*framerate/(1001*12);
2873                 for (j= 0; j<2; j++) {
2874                     int64_t ticks = llrint(sdts+j*0.5);
2875                     double error= sdts - ticks + j*0.5;
2876                     st->info->duration_error[j][0][i] += error;
2877                     st->info->duration_error[j][1][i] += error*error;
2878                 }
2879             }
2880         }
2881         st->info->duration_count++;
2882         st->info->rfps_duration_sum += duration;
2883
2884         if (st->info->duration_count % 10 == 0) {
2885             int n = st->info->duration_count;
2886             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2887                 if (st->info->duration_error[0][1][i] < 1e10) {
2888                     double a0     = st->info->duration_error[0][0][i] / n;
2889                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2890                     double a1     = st->info->duration_error[1][0][i] / n;
2891                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2892                     if (error0 > 0.04 && error1 > 0.04) {
2893                         st->info->duration_error[0][1][i] = 2e10;
2894                         st->info->duration_error[1][1][i] = 2e10;
2895                     }
2896                 }
2897             }
2898         }
2899
2900         // ignore the first 4 values, they might have some random jitter
2901         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2902             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2903     }
2904     if (ts != AV_NOPTS_VALUE)
2905         st->info->last_dts = ts;
2906
2907     return 0;
2908 }
2909
2910 void ff_rfps_calculate(AVFormatContext *ic)
2911 {
2912     int i, j;
2913
2914     for (i = 0; i < ic->nb_streams; i++) {
2915         AVStream *st = ic->streams[i];
2916
2917         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2918             continue;
2919         // the check for tb_unreliable() is not completely correct, since this is not about handling
2920         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2921         // ipmovie.c produces.
2922         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)
2923             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);
2924         if (st->info->duration_count>1 && !st->r_frame_rate.num
2925             && tb_unreliable(st->codec)) {
2926             int num = 0;
2927             double best_error= 0.01;
2928             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2929
2930             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2931                 int k;
2932
2933                 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2934                     continue;
2935                 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2936                     continue;
2937
2938                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2939                     continue;
2940
2941                 for (k= 0; k<2; k++) {
2942                     int n = st->info->duration_count;
2943                     double a= st->info->duration_error[k][0][j] / n;
2944                     double error= st->info->duration_error[k][1][j]/n - a*a;
2945
2946                     if (error < best_error && best_error> 0.000000001) {
2947                         best_error= error;
2948                         num = get_std_framerate(j);
2949                     }
2950                     if (error < 0.02)
2951                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2952                 }
2953             }
2954             // do not increase frame rate by more than 1 % in order to match a standard rate.
2955             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2956                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2957         }
2958         if (   !st->avg_frame_rate.num
2959             && st->r_frame_rate.num && st->info->rfps_duration_sum
2960             && st->info->codec_info_duration <= 0
2961             && st->info->duration_count > 2
2962             && 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
2963             ) {
2964             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2965             st->avg_frame_rate = st->r_frame_rate;
2966         }
2967
2968         av_freep(&st->info->duration_error);
2969         st->info->last_dts = AV_NOPTS_VALUE;
2970         st->info->duration_count = 0;
2971         st->info->rfps_duration_sum = 0;
2972     }
2973 }
2974
2975 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2976 {
2977     int i, count, ret = 0, j;
2978     int64_t read_size;
2979     AVStream *st;
2980     AVPacket pkt1, *pkt;
2981     int64_t old_offset  = avio_tell(ic->pb);
2982     // new streams might appear, no options for those
2983     int orig_nb_streams = ic->nb_streams;
2984     int flush_codecs;
2985     int64_t max_analyze_duration = ic->max_analyze_duration2;
2986     int64_t probesize = ic->probesize2;
2987
2988     if (!max_analyze_duration)
2989         max_analyze_duration = ic->max_analyze_duration;
2990     if (ic->probesize)
2991         probesize = ic->probesize;
2992     flush_codecs = probesize > 0;
2993
2994     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2995
2996     if (!max_analyze_duration) {
2997         if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2998             max_analyze_duration = 10*AV_TIME_BASE;
2999         } else
3000             max_analyze_duration = 5*AV_TIME_BASE;
3001     }
3002
3003     if (ic->pb)
3004         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3005                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3006
3007     for (i = 0; i < ic->nb_streams; i++) {
3008         const AVCodec *codec;
3009         AVDictionary *thread_opt = NULL;
3010         st = ic->streams[i];
3011
3012         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3013             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3014 /*            if (!st->time_base.num)
3015                 st->time_base = */
3016             if (!st->codec->time_base.num)
3017                 st->codec->time_base = st->time_base;
3018         }
3019         // only for the split stuff
3020         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3021             st->parser = av_parser_init(st->codec->codec_id);
3022             if (st->parser) {
3023                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3024                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3025                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3026                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3027                 }
3028             } else if (st->need_parsing) {
3029                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3030                        "%s, packets or times may be invalid.\n",
3031                        avcodec_get_name(st->codec->codec_id));
3032             }
3033         }
3034         codec = find_decoder(ic, st, st->codec->codec_id);
3035
3036         /* Force thread count to 1 since the H.264 decoder will not extract
3037          * SPS and PPS to extradata during multi-threaded decoding. */
3038         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3039
3040         if (ic->codec_whitelist)
3041             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3042
3043         /* Ensure that subtitle_header is properly set. */
3044         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3045             && codec && !st->codec->codec) {
3046             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3047                 av_log(ic, AV_LOG_WARNING,
3048                        "Failed to open codec in av_find_stream_info\n");
3049         }
3050
3051         // Try to just open decoders, in case this is enough to get parameters.
3052         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3053             if (codec && !st->codec->codec)
3054                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3055                     av_log(ic, AV_LOG_WARNING,
3056                            "Failed to open codec in av_find_stream_info\n");
3057         }
3058         if (!options)
3059             av_dict_free(&thread_opt);
3060     }
3061
3062     for (i = 0; i < ic->nb_streams; i++) {
3063 #if FF_API_R_FRAME_RATE
3064         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3065 #endif
3066         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3067         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3068     }
3069
3070     count     = 0;
3071     read_size = 0;
3072     for (;;) {
3073         if (ff_check_interrupt(&ic->interrupt_callback)) {
3074             ret = AVERROR_EXIT;
3075             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3076             break;
3077         }
3078
3079         /* check if one codec still needs to be handled */
3080         for (i = 0; i < ic->nb_streams; i++) {
3081             int fps_analyze_framecount = 20;
3082
3083             st = ic->streams[i];
3084             if (!has_codec_parameters(st, NULL))
3085                 break;
3086             /* If the timebase is coarse (like the usual millisecond precision
3087              * of mkv), we need to analyze more frames to reliably arrive at
3088              * the correct fps. */
3089             if (av_q2d(st->time_base) > 0.0005)
3090                 fps_analyze_framecount *= 2;
3091             if (!tb_unreliable(st->codec))
3092                 fps_analyze_framecount = 0;
3093             if (ic->fps_probe_size >= 0)
3094                 fps_analyze_framecount = ic->fps_probe_size;
3095             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3096                 fps_analyze_framecount = 0;
3097             /* variable fps and no guess at the real fps */
3098             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3099                 st->info->duration_count < fps_analyze_framecount &&
3100                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3101                 break;
3102             if (st->parser && st->parser->parser->split &&
3103                 !st->codec->extradata)
3104                 break;
3105             if (st->first_dts == AV_NOPTS_VALUE &&
3106                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3107                 st->codec_info_nb_frames < ic->max_ts_probe &&
3108                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3109                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3110                 break;
3111         }
3112         if (i == ic->nb_streams) {
3113             /* NOTE: If the format has no header, then we need to read some
3114              * packets to get most of the streams, so we cannot stop here. */
3115             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3116                 /* If we found the info for all the codecs, we can stop. */
3117                 ret = count;
3118                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3119                 flush_codecs = 0;
3120                 break;
3121             }
3122         }
3123         /* We did not get all the codec info, but we read too much data. */
3124         if (read_size >= probesize) {
3125             ret = count;
3126             av_log(ic, AV_LOG_DEBUG,
3127                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3128             for (i = 0; i < ic->nb_streams; i++)
3129                 if (!ic->streams[i]->r_frame_rate.num &&
3130                     ic->streams[i]->info->duration_count <= 1 &&
3131                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3132                     strcmp(ic->iformat->name, "image2"))
3133                     av_log(ic, AV_LOG_WARNING,
3134                            "Stream #%d: not enough frames to estimate rate; "
3135                            "consider increasing probesize\n", i);
3136             break;
3137         }
3138
3139         /* NOTE: A new stream can be added there if no header in file
3140          * (AVFMTCTX_NOHEADER). */
3141         ret = read_frame_internal(ic, &pkt1);
3142         if (ret == AVERROR(EAGAIN))
3143             continue;
3144
3145         if (ret < 0) {
3146             /* EOF or error*/
3147             break;
3148         }
3149
3150         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3151             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3152         {
3153             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3154                                 &ic->packet_buffer_end);
3155             if (!pkt) {
3156                 ret = AVERROR(ENOMEM);
3157                 goto find_stream_info_err;
3158             }
3159             if ((ret = av_dup_packet(pkt)) < 0)
3160                 goto find_stream_info_err;
3161         }
3162
3163         st = ic->streams[pkt->stream_index];
3164         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3165             read_size += pkt->size;
3166
3167         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3168             /* check for non-increasing dts */
3169             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3170                 st->info->fps_last_dts >= pkt->dts) {
3171                 av_log(ic, AV_LOG_DEBUG,
3172                        "Non-increasing DTS in stream %d: packet %d with DTS "
3173                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3174                        st->index, st->info->fps_last_dts_idx,
3175                        st->info->fps_last_dts, st->codec_info_nb_frames,
3176                        pkt->dts);
3177                 st->info->fps_first_dts =
3178                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3179             }
3180             /* Check for a discontinuity in dts. If the difference in dts
3181              * is more than 1000 times the average packet duration in the
3182              * sequence, we treat it as a discontinuity. */
3183             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3184                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3185                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3186                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3187                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3188                 av_log(ic, AV_LOG_WARNING,
3189                        "DTS discontinuity in stream %d: packet %d with DTS "
3190                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3191                        st->index, st->info->fps_last_dts_idx,
3192                        st->info->fps_last_dts, st->codec_info_nb_frames,
3193                        pkt->dts);
3194                 st->info->fps_first_dts =
3195                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3196             }
3197
3198             /* update stored dts values */
3199             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3200                 st->info->fps_first_dts     = pkt->dts;
3201                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3202             }
3203             st->info->fps_last_dts     = pkt->dts;
3204             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3205         }
3206         if (st->codec_info_nb_frames>1) {
3207             int64_t t = 0;
3208
3209             if (st->time_base.den > 0)
3210                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3211             if (st->avg_frame_rate.num > 0)
3212                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3213
3214             if (   t == 0
3215                 && st->codec_info_nb_frames>30
3216                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3217                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3218                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3219
3220             if (t >= max_analyze_duration) {
3221                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3222                        max_analyze_duration,
3223                        t);
3224                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3225                     av_packet_unref(pkt);
3226                 break;
3227             }
3228             if (pkt->duration) {
3229                 st->info->codec_info_duration        += pkt->duration;
3230                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3231             }
3232         }
3233 #if FF_API_R_FRAME_RATE
3234         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3235             ff_rfps_add_frame(ic, st, pkt->dts);
3236 #endif
3237         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3238             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3239             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3240                 if (ff_alloc_extradata(st->codec, i))
3241                     return AVERROR(ENOMEM);
3242                 memcpy(st->codec->extradata, pkt->data,
3243                        st->codec->extradata_size);
3244             }
3245         }
3246
3247         /* If still no information, we try to open the codec and to
3248          * decompress the frame. We try to avoid that in most cases as
3249          * it takes longer and uses more memory. For MPEG-4, we need to
3250          * decompress for QuickTime.
3251          *
3252          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3253          * least one frame of codec data, this makes sure the codec initializes
3254          * the channel configuration and does not only trust the values from
3255          * the container. */
3256         try_decode_frame(ic, st, pkt,
3257                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3258
3259         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3260             av_packet_unref(pkt);
3261
3262         st->codec_info_nb_frames++;
3263         count++;
3264     }
3265
3266     if (flush_codecs) {
3267         AVPacket empty_pkt = { 0 };
3268         int err = 0;
3269         av_init_packet(&empty_pkt);
3270
3271         for (i = 0; i < ic->nb_streams; i++) {
3272
3273             st = ic->streams[i];
3274
3275             /* flush the decoders */
3276             if (st->info->found_decoder == 1) {
3277                 do {
3278                     err = try_decode_frame(ic, st, &empty_pkt,
3279                                             (options && i < orig_nb_streams)
3280                                             ? &options[i] : NULL);
3281                 } while (err > 0 && !has_codec_parameters(st, NULL));
3282
3283                 if (err < 0) {
3284                     av_log(ic, AV_LOG_INFO,
3285                         "decoding for stream %d failed\n", st->index);
3286                 }
3287             }
3288         }
3289     }
3290
3291     // close codecs which were opened in try_decode_frame()
3292     for (i = 0; i < ic->nb_streams; i++) {
3293         st = ic->streams[i];
3294         avcodec_close(st->codec);
3295     }
3296
3297     ff_rfps_calculate(ic);
3298
3299     for (i = 0; i < ic->nb_streams; i++) {
3300         st = ic->streams[i];
3301         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3302             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3303                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3304                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3305                     st->codec->codec_tag= tag;
3306             }
3307
3308             /* estimate average framerate if not set by demuxer */
3309             if (st->info->codec_info_duration_fields &&
3310                 !st->avg_frame_rate.num &&
3311                 st->info->codec_info_duration) {
3312                 int best_fps      = 0;
3313                 double best_error = 0.01;
3314
3315                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3316                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3317                     st->info->codec_info_duration        < 0)
3318                     continue;
3319                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3320                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3321                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3322
3323                 /* Round guessed framerate to a "standard" framerate if it's
3324                  * within 1% of the original estimate. */
3325                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3326                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3327                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3328                                               av_q2d(std_fps) - 1);
3329
3330                     if (error < best_error) {
3331                         best_error = error;
3332                         best_fps   = std_fps.num;
3333                     }
3334                 }
3335                 if (best_fps)
3336                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3337                               best_fps, 12 * 1001, INT_MAX);
3338             }
3339
3340             if (!st->r_frame_rate.num) {
3341                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3342                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3343                     st->r_frame_rate.num = st->codec->time_base.den;
3344                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3345                 } else {
3346                     st->r_frame_rate.num = st->time_base.den;
3347                     st->r_frame_rate.den = st->time_base.num;
3348                 }
3349             }
3350         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3351             if (!st->codec->bits_per_coded_sample)
3352                 st->codec->bits_per_coded_sample =
3353                     av_get_bits_per_sample(st->codec->codec_id);
3354             // set stream disposition based on audio service type
3355             switch (st->codec->audio_service_type) {
3356             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3357                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3358                 break;
3359             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3360                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3361                 break;
3362             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3363                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3364                 break;
3365             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3366                 st->disposition = AV_DISPOSITION_COMMENT;
3367                 break;
3368             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3369                 st->disposition = AV_DISPOSITION_KARAOKE;
3370                 break;
3371             }
3372         }
3373     }
3374
3375     if (probesize)
3376     estimate_timings(ic, old_offset);
3377
3378     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3379
3380     if (ret >= 0 && ic->nb_streams)
3381         /* We could not have all the codec parameters before EOF. */
3382         ret = -1;
3383     for (i = 0; i < ic->nb_streams; i++) {
3384         const char *errmsg;
3385         st = ic->streams[i];
3386         if (!has_codec_parameters(st, &errmsg)) {
3387             char buf[256];
3388             avcodec_string(buf, sizeof(buf), st->codec, 0);
3389             av_log(ic, AV_LOG_WARNING,
3390                    "Could not find codec parameters for stream %d (%s): %s\n"
3391                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3392                    i, buf, errmsg);
3393         } else {
3394             ret = 0;
3395         }
3396     }
3397
3398     compute_chapters_end(ic);
3399
3400 find_stream_info_err:
3401     for (i = 0; i < ic->nb_streams; i++) {
3402         st = ic->streams[i];
3403         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3404             ic->streams[i]->codec->thread_count = 0;
3405         if (st->info)
3406             av_freep(&st->info->duration_error);
3407         av_freep(&ic->streams[i]->info);
3408     }
3409     if (ic->pb)
3410         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3411                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3412     return ret;
3413 }
3414
3415 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3416 {
3417     int i, j;
3418
3419     for (i = 0; i < ic->nb_programs; i++) {
3420         if (ic->programs[i] == last) {
3421             last = NULL;
3422         } else {
3423             if (!last)
3424                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3425                     if (ic->programs[i]->stream_index[j] == s)
3426                         return ic->programs[i];
3427         }
3428     }
3429     return NULL;
3430 }
3431
3432 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3433                         int wanted_stream_nb, int related_stream,
3434                         AVCodec **decoder_ret, int flags)
3435 {
3436     int i, nb_streams = ic->nb_streams;
3437     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3438     unsigned *program = NULL;
3439     const AVCodec *decoder = NULL, *best_decoder = NULL;
3440
3441     if (related_stream >= 0 && wanted_stream_nb < 0) {
3442         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3443         if (p) {
3444             program    = p->stream_index;
3445             nb_streams = p->nb_stream_indexes;
3446         }
3447     }
3448     for (i = 0; i < nb_streams; i++) {
3449         int real_stream_index = program ? program[i] : i;
3450         AVStream *st          = ic->streams[real_stream_index];
3451         AVCodecContext *avctx = st->codec;
3452         if (avctx->codec_type != type)
3453             continue;
3454         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3455             continue;
3456         if (wanted_stream_nb != real_stream_index &&
3457             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3458                                AV_DISPOSITION_VISUAL_IMPAIRED))
3459             continue;
3460         if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3461             continue;
3462         if (decoder_ret) {
3463             decoder = find_decoder(ic, st, st->codec->codec_id);
3464             if (!decoder) {
3465                 if (ret < 0)
3466                     ret = AVERROR_DECODER_NOT_FOUND;
3467                 continue;
3468             }
3469         }
3470         count = st->codec_info_nb_frames;
3471         bitrate = avctx->bit_rate;
3472         if (!bitrate)
3473             bitrate = avctx->rc_max_rate;
3474         multiframe = FFMIN(5, count);
3475         if ((best_multiframe >  multiframe) ||
3476             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3477             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3478             continue;
3479         best_count   = count;
3480         best_bitrate = bitrate;
3481         best_multiframe = multiframe;
3482         ret          = real_stream_index;
3483         best_decoder = decoder;
3484         if (program && i == nb_streams - 1 && ret < 0) {
3485             program    = NULL;
3486             nb_streams = ic->nb_streams;
3487             /* no related stream found, try again with everything */
3488             i = 0;
3489         }
3490     }
3491     if (decoder_ret)
3492         *decoder_ret = (AVCodec*)best_decoder;
3493     return ret;
3494 }
3495
3496 /*******************************************************/
3497
3498 int av_read_play(AVFormatContext *s)
3499 {
3500     if (s->iformat->read_play)
3501         return s->iformat->read_play(s);
3502     if (s->pb)
3503         return avio_pause(s->pb, 0);
3504     return AVERROR(ENOSYS);
3505 }
3506
3507 int av_read_pause(AVFormatContext *s)
3508 {
3509     if (s->iformat->read_pause)
3510         return s->iformat->read_pause(s);
3511     if (s->pb)
3512         return avio_pause(s->pb, 1);
3513     return AVERROR(ENOSYS);
3514 }
3515
3516 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3517     int j;
3518     av_assert0(s->nb_streams>0);
3519     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3520
3521     for (j = 0; j < st->nb_side_data; j++)
3522         av_freep(&st->side_data[j].data);
3523     av_freep(&st->side_data);
3524     st->nb_side_data = 0;
3525
3526     if (st->parser) {
3527         av_parser_close(st->parser);
3528     }
3529     if (st->attached_pic.data)
3530         av_free_packet(&st->attached_pic);
3531     av_dict_free(&st->metadata);
3532     av_freep(&st->probe_data.buf);
3533     av_freep(&st->index_entries);
3534     av_freep(&st->codec->extradata);
3535     av_freep(&st->codec->subtitle_header);
3536     av_freep(&st->codec);
3537     av_freep(&st->priv_data);
3538     if (st->info)
3539         av_freep(&st->info->duration_error);
3540     av_freep(&st->info);
3541     av_freep(&st->recommended_encoder_configuration);
3542     av_freep(&s->streams[ --s->nb_streams ]);
3543 }
3544
3545 void avformat_free_context(AVFormatContext *s)
3546 {
3547     int i;
3548
3549     if (!s)
3550         return;
3551
3552     av_opt_free(s);
3553     if (s->iformat && s->iformat->priv_class && s->priv_data)
3554         av_opt_free(s->priv_data);
3555     if (s->oformat && s->oformat->priv_class && s->priv_data)
3556         av_opt_free(s->priv_data);
3557
3558     for (i = s->nb_streams - 1; i >= 0; i--) {
3559         ff_free_stream(s, s->streams[i]);
3560     }
3561     for (i = s->nb_programs - 1; i >= 0; i--) {
3562         av_dict_free(&s->programs[i]->metadata);
3563         av_freep(&s->programs[i]->stream_index);
3564         av_freep(&s->programs[i]);
3565     }
3566     av_freep(&s->programs);
3567     av_freep(&s->priv_data);
3568     while (s->nb_chapters--) {
3569         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3570         av_freep(&s->chapters[s->nb_chapters]);
3571     }
3572     av_freep(&s->chapters);
3573     av_dict_free(&s->metadata);
3574     av_freep(&s->streams);
3575     av_freep(&s->internal);
3576     flush_packet_queue(s);
3577     av_free(s);
3578 }
3579
3580 void avformat_close_input(AVFormatContext **ps)
3581 {
3582     AVFormatContext *s;
3583     AVIOContext *pb;
3584
3585     if (!ps || !*ps)
3586         return;
3587
3588     s  = *ps;
3589     pb = s->pb;
3590
3591     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3592         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3593         pb = NULL;
3594
3595     flush_packet_queue(s);
3596
3597     if (s->iformat)
3598         if (s->iformat->read_close)
3599             s->iformat->read_close(s);
3600
3601     avformat_free_context(s);
3602
3603     *ps = NULL;
3604
3605     avio_close(pb);
3606 }
3607
3608 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3609 {
3610     AVStream *st;
3611     int i;
3612     AVStream **streams;
3613
3614     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3615         return NULL;
3616     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3617     if (!streams)
3618         return NULL;
3619     s->streams = streams;
3620
3621     st = av_mallocz(sizeof(AVStream));
3622     if (!st)
3623         return NULL;
3624     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3625         av_free(st);
3626         return NULL;
3627     }
3628     st->info->last_dts = AV_NOPTS_VALUE;
3629
3630     st->codec = avcodec_alloc_context3(c);
3631     if (s->iformat) {
3632         /* no default bitrate if decoding */
3633         st->codec->bit_rate = 0;
3634
3635         /* default pts setting is MPEG-like */
3636         avpriv_set_pts_info(st, 33, 1, 90000);
3637     }
3638
3639     st->index      = s->nb_streams;
3640     st->start_time = AV_NOPTS_VALUE;
3641     st->duration   = AV_NOPTS_VALUE;
3642     /* we set the current DTS to 0 so that formats without any timestamps
3643      * but durations get some timestamps, formats with some unknown
3644      * timestamps have their first few packets buffered and the
3645      * timestamps corrected before they are returned to the user */
3646     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3647     st->first_dts     = AV_NOPTS_VALUE;
3648     st->probe_packets = MAX_PROBE_PACKETS;
3649     st->pts_wrap_reference = AV_NOPTS_VALUE;
3650     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3651
3652     st->last_IP_pts = AV_NOPTS_VALUE;
3653     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3654     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3655         st->pts_buffer[i] = AV_NOPTS_VALUE;
3656
3657     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3658
3659 #if FF_API_R_FRAME_RATE
3660     st->info->last_dts      = AV_NOPTS_VALUE;
3661 #endif
3662     st->info->fps_first_dts = AV_NOPTS_VALUE;
3663     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3664
3665     st->inject_global_side_data = s->internal->inject_global_side_data;
3666
3667     s->streams[s->nb_streams++] = st;
3668     return st;
3669 }
3670
3671 AVProgram *av_new_program(AVFormatContext *ac, int id)
3672 {
3673     AVProgram *program = NULL;
3674     int i;
3675
3676     av_dlog(ac, "new_program: id=0x%04x\n", id);
3677
3678     for (i = 0; i < ac->nb_programs; i++)
3679         if (ac->programs[i]->id == id)
3680             program = ac->programs[i];
3681
3682     if (!program) {
3683         program = av_mallocz(sizeof(AVProgram));
3684         if (!program)
3685             return NULL;
3686         dynarray_add(&ac->programs, &ac->nb_programs, program);
3687         program->discard = AVDISCARD_NONE;
3688     }
3689     program->id = id;
3690     program->pts_wrap_reference = AV_NOPTS_VALUE;
3691     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3692
3693     program->start_time =
3694     program->end_time   = AV_NOPTS_VALUE;
3695
3696     return program;
3697 }
3698
3699 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3700                               int64_t start, int64_t end, const char *title)
3701 {
3702     AVChapter *chapter = NULL;
3703     int i;
3704
3705     if (end != AV_NOPTS_VALUE && start > end) {
3706         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3707         return NULL;
3708     }
3709
3710     for (i = 0; i < s->nb_chapters; i++)
3711         if (s->chapters[i]->id == id)
3712             chapter = s->chapters[i];
3713
3714     if (!chapter) {
3715         chapter = av_mallocz(sizeof(AVChapter));
3716         if (!chapter)
3717             return NULL;
3718         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3719     }
3720     av_dict_set(&chapter->metadata, "title", title, 0);
3721     chapter->id        = id;
3722     chapter->time_base = time_base;
3723     chapter->start     = start;
3724     chapter->end       = end;
3725
3726     return chapter;
3727 }
3728
3729 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3730 {
3731     int i, j;
3732     AVProgram *program = NULL;
3733     void *tmp;
3734
3735     if (idx >= ac->nb_streams) {
3736         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3737         return;
3738     }
3739
3740     for (i = 0; i < ac->nb_programs; i++) {
3741         if (ac->programs[i]->id != progid)
3742             continue;
3743         program = ac->programs[i];
3744         for (j = 0; j < program->nb_stream_indexes; j++)
3745             if (program->stream_index[j] == idx)
3746                 return;
3747
3748         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3749         if (!tmp)
3750             return;
3751         program->stream_index = tmp;
3752         program->stream_index[program->nb_stream_indexes++] = idx;
3753         return;
3754     }
3755 }
3756
3757 uint64_t ff_ntp_time(void)
3758 {
3759     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3760 }
3761
3762 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3763 {
3764     const char *p;
3765     char *q, buf1[20], c;
3766     int nd, len, percentd_found;
3767
3768     q = buf;
3769     p = path;
3770     percentd_found = 0;
3771     for (;;) {
3772         c = *p++;
3773         if (c == '\0')
3774             break;
3775         if (c == '%') {
3776             do {
3777                 nd = 0;
3778                 while (av_isdigit(*p))
3779                     nd = nd * 10 + *p++ - '0';
3780                 c = *p++;
3781             } while (av_isdigit(c));
3782
3783             switch (c) {
3784             case '%':
3785                 goto addchar;
3786             case 'd':
3787                 if (percentd_found)
3788                     goto fail;
3789                 percentd_found = 1;
3790                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3791                 len = strlen(buf1);
3792                 if ((q - buf + len) > buf_size - 1)
3793                     goto fail;
3794                 memcpy(q, buf1, len);
3795                 q += len;
3796                 break;
3797             default:
3798                 goto fail;
3799             }
3800         } else {
3801 addchar:
3802             if ((q - buf) < buf_size - 1)
3803                 *q++ = c;
3804         }
3805     }
3806     if (!percentd_found)
3807         goto fail;
3808     *q = '\0';
3809     return 0;
3810 fail:
3811     *q = '\0';
3812     return -1;
3813 }
3814
3815 void av_url_split(char *proto, int proto_size,
3816                   char *authorization, int authorization_size,
3817                   char *hostname, int hostname_size,
3818                   int *port_ptr, char *path, int path_size, const char *url)
3819 {
3820     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3821
3822     if (port_ptr)
3823         *port_ptr = -1;
3824     if (proto_size > 0)
3825         proto[0] = 0;
3826     if (authorization_size > 0)
3827         authorization[0] = 0;
3828     if (hostname_size > 0)
3829         hostname[0] = 0;
3830     if (path_size > 0)
3831         path[0] = 0;
3832
3833     /* parse protocol */
3834     if ((p = strchr(url, ':'))) {
3835         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3836         p++; /* skip ':' */
3837         if (*p == '/')
3838             p++;
3839         if (*p == '/')
3840             p++;
3841     } else {
3842         /* no protocol means plain filename */
3843         av_strlcpy(path, url, path_size);
3844         return;
3845     }
3846
3847     /* separate path from hostname */
3848     ls = strchr(p, '/');
3849     ls2 = strchr(p, '?');
3850     if (!ls)
3851         ls = ls2;
3852     else if (ls && ls2)
3853         ls = FFMIN(ls, ls2);
3854     if (ls)
3855         av_strlcpy(path, ls, path_size);
3856     else
3857         ls = &p[strlen(p)];  // XXX
3858
3859     /* the rest is hostname, use that to parse auth/port */
3860     if (ls != p) {
3861         /* authorization (user[:pass]@hostname) */
3862         at2 = p;
3863         while ((at = strchr(p, '@')) && at < ls) {
3864             av_strlcpy(authorization, at2,
3865                        FFMIN(authorization_size, at + 1 - at2));
3866             p = at + 1; /* skip '@' */
3867         }
3868
3869         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3870             /* [host]:port */
3871             av_strlcpy(hostname, p + 1,
3872                        FFMIN(hostname_size, brk - p));
3873             if (brk[1] == ':' && port_ptr)
3874                 *port_ptr = atoi(brk + 2);
3875         } else if ((col = strchr(p, ':')) && col < ls) {
3876             av_strlcpy(hostname, p,
3877                        FFMIN(col + 1 - p, hostname_size));
3878             if (port_ptr)
3879                 *port_ptr = atoi(col + 1);
3880         } else
3881             av_strlcpy(hostname, p,
3882                        FFMIN(ls + 1 - p, hostname_size));
3883     }
3884 }
3885
3886 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3887 {
3888     int i;
3889     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3890                                            '4', '5', '6', '7',
3891                                            '8', '9', 'A', 'B',
3892                                            'C', 'D', 'E', 'F' };
3893     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3894                                            '4', '5', '6', '7',
3895                                            '8', '9', 'a', 'b',
3896                                            'c', 'd', 'e', 'f' };
3897     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3898
3899     for (i = 0; i < s; i++) {
3900         buff[i * 2]     = hex_table[src[i] >> 4];
3901         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3902     }
3903
3904     return buff;
3905 }
3906
3907 int ff_hex_to_data(uint8_t *data, const char *p)
3908 {
3909     int c, len, v;
3910
3911     len = 0;
3912     v   = 1;
3913     for (;;) {
3914         p += strspn(p, SPACE_CHARS);
3915         if (*p == '\0')
3916             break;
3917         c = av_toupper((unsigned char) *p++);
3918         if (c >= '0' && c <= '9')
3919             c = c - '0';
3920         else if (c >= 'A' && c <= 'F')
3921             c = c - 'A' + 10;
3922         else
3923             break;
3924         v = (v << 4) | c;
3925         if (v & 0x100) {
3926             if (data)
3927                 data[len] = v;
3928             len++;
3929             v = 1;
3930         }
3931     }
3932     return len;
3933 }
3934
3935 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3936                          unsigned int pts_num, unsigned int pts_den)
3937 {
3938     AVRational new_tb;
3939     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3940         if (new_tb.num != pts_num)
3941             av_log(NULL, AV_LOG_DEBUG,
3942                    "st:%d removing common factor %d from timebase\n",
3943                    s->index, pts_num / new_tb.num);
3944     } else
3945         av_log(NULL, AV_LOG_WARNING,
3946                "st:%d has too large timebase, reducing\n", s->index);
3947
3948     if (new_tb.num <= 0 || new_tb.den <= 0) {
3949         av_log(NULL, AV_LOG_ERROR,
3950                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3951                new_tb.num, new_tb.den,
3952                s->index);
3953         return;
3954     }
3955     s->time_base     = new_tb;
3956     av_codec_set_pkt_timebase(s->codec, new_tb);
3957     s->pts_wrap_bits = pts_wrap_bits;
3958 }
3959
3960 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3961                         void *context)
3962 {
3963     const char *ptr = str;
3964
3965     /* Parse key=value pairs. */
3966     for (;;) {
3967         const char *key;
3968         char *dest = NULL, *dest_end;
3969         int key_len, dest_len = 0;
3970
3971         /* Skip whitespace and potential commas. */
3972         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3973             ptr++;
3974         if (!*ptr)
3975             break;
3976
3977         key = ptr;
3978
3979         if (!(ptr = strchr(key, '=')))
3980             break;
3981         ptr++;
3982         key_len = ptr - key;
3983
3984         callback_get_buf(context, key, key_len, &dest, &dest_len);
3985         dest_end = dest + dest_len - 1;
3986
3987         if (*ptr == '\"') {
3988             ptr++;
3989             while (*ptr && *ptr != '\"') {
3990                 if (*ptr == '\\') {
3991                     if (!ptr[1])
3992                         break;
3993                     if (dest && dest < dest_end)
3994                         *dest++ = ptr[1];
3995                     ptr += 2;
3996                 } else {
3997                     if (dest && dest < dest_end)
3998                         *dest++ = *ptr;
3999                     ptr++;
4000                 }
4001             }
4002             if (*ptr == '\"')
4003                 ptr++;
4004         } else {
4005             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4006                 if (dest && dest < dest_end)
4007                     *dest++ = *ptr;
4008         }
4009         if (dest)
4010             *dest = 0;
4011     }
4012 }
4013
4014 int ff_find_stream_index(AVFormatContext *s, int id)
4015 {
4016     int i;
4017     for (i = 0; i < s->nb_streams; i++)
4018         if (s->streams[i]->id == id)
4019             return i;
4020     return -1;
4021 }
4022
4023 int64_t ff_iso8601_to_unix_time(const char *datestr)
4024 {
4025     struct tm time1 = { 0 }, time2 = { 0 };
4026     char *ret1, *ret2;
4027     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4028     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4029     if (ret2 && !ret1)
4030         return av_timegm(&time2);
4031     else
4032         return av_timegm(&time1);
4033 }
4034
4035 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4036                          int std_compliance)
4037 {
4038     if (ofmt) {
4039         if (ofmt->query_codec)
4040             return ofmt->query_codec(codec_id, std_compliance);
4041         else if (ofmt->codec_tag)
4042             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4043         else if (codec_id == ofmt->video_codec ||
4044                  codec_id == ofmt->audio_codec ||
4045                  codec_id == ofmt->subtitle_codec)
4046             return 1;
4047     }
4048     return AVERROR_PATCHWELCOME;
4049 }
4050
4051 int avformat_network_init(void)
4052 {
4053 #if CONFIG_NETWORK
4054     int ret;
4055     ff_network_inited_globally = 1;
4056     if ((ret = ff_network_init()) < 0)
4057         return ret;
4058     ff_tls_init();
4059 #endif
4060     return 0;
4061 }
4062
4063 int avformat_network_deinit(void)
4064 {
4065 #if CONFIG_NETWORK
4066     ff_network_close();
4067     ff_tls_deinit();
4068 #endif
4069     return 0;
4070 }
4071
4072 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4073                         uint64_t channel_layout, int32_t sample_rate,
4074                         int32_t width, int32_t height)
4075 {
4076     uint32_t flags = 0;
4077     int size = 4;
4078     uint8_t *data;
4079     if (!pkt)
4080         return AVERROR(EINVAL);
4081     if (channels) {
4082         size  += 4;
4083         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4084     }
4085     if (channel_layout) {
4086         size  += 8;
4087         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4088     }
4089     if (sample_rate) {
4090         size  += 4;
4091         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4092     }
4093     if (width || height) {
4094         size  += 8;
4095         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4096     }
4097     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4098     if (!data)
4099         return AVERROR(ENOMEM);
4100     bytestream_put_le32(&data, flags);
4101     if (channels)
4102         bytestream_put_le32(&data, channels);
4103     if (channel_layout)
4104         bytestream_put_le64(&data, channel_layout);
4105     if (sample_rate)
4106         bytestream_put_le32(&data, sample_rate);
4107     if (width || height) {
4108         bytestream_put_le32(&data, width);
4109         bytestream_put_le32(&data, height);
4110     }
4111     return 0;
4112 }
4113
4114 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4115 {
4116     AVRational undef = {0, 1};
4117     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4118     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4119     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4120
4121     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4122                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4123     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4124         stream_sample_aspect_ratio = undef;
4125
4126     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4127                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4128     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4129         frame_sample_aspect_ratio = undef;
4130
4131     if (stream_sample_aspect_ratio.num)
4132         return stream_sample_aspect_ratio;
4133     else
4134         return frame_sample_aspect_ratio;
4135 }
4136
4137 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4138 {
4139     AVRational fr = st->r_frame_rate;
4140     AVRational codec_fr = st->codec->framerate;
4141     AVRational   avg_fr = st->avg_frame_rate;
4142
4143     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4144         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4145         fr = avg_fr;
4146     }
4147
4148
4149     if (st->codec->ticks_per_frame > 1) {
4150         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4151             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4152             fr = codec_fr;
4153     }
4154
4155     return fr;
4156 }
4157
4158 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4159                                     const char *spec)
4160 {
4161     if (*spec <= '9' && *spec >= '0') /* opt:index */
4162         return strtol(spec, NULL, 0) == st->index;
4163     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4164              *spec == 't') { /* opt:[vasdt] */
4165         enum AVMediaType type;
4166
4167         switch (*spec++) {
4168         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4169         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4170         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4171         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4172         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4173         default:  av_assert0(0);
4174         }
4175         if (type != st->codec->codec_type)
4176             return 0;
4177         if (*spec++ == ':') { /* possibly followed by :index */
4178             int i, index = strtol(spec, NULL, 0);
4179             for (i = 0; i < s->nb_streams; i++)
4180                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4181                    return i == st->index;
4182             return 0;
4183         }
4184         return 1;
4185     } else if (*spec == 'p' && *(spec + 1) == ':') {
4186         int prog_id, i, j;
4187         char *endptr;
4188         spec += 2;
4189         prog_id = strtol(spec, &endptr, 0);
4190         for (i = 0; i < s->nb_programs; i++) {
4191             if (s->programs[i]->id != prog_id)
4192                 continue;
4193
4194             if (*endptr++ == ':') {
4195                 int stream_idx = strtol(endptr, NULL, 0);
4196                 return stream_idx >= 0 &&
4197                     stream_idx < s->programs[i]->nb_stream_indexes &&
4198                     st->index == s->programs[i]->stream_index[stream_idx];
4199             }
4200
4201             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4202                 if (st->index == s->programs[i]->stream_index[j])
4203                     return 1;
4204         }
4205         return 0;
4206     } else if (*spec == '#' ||
4207                (*spec == 'i' && *(spec + 1) == ':')) {
4208         int stream_id;
4209         char *endptr;
4210         spec += 1 + (*spec == 'i');
4211         stream_id = strtol(spec, &endptr, 0);
4212         if (!*endptr)
4213             return stream_id == st->id;
4214     } else if (*spec == 'm' && *(spec + 1) == ':') {
4215         AVDictionaryEntry *tag;
4216         char *key, *val;
4217         int ret;
4218
4219         spec += 2;
4220         val = strchr(spec, ':');
4221
4222         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4223         if (!key)
4224             return AVERROR(ENOMEM);
4225
4226         tag = av_dict_get(st->metadata, key, NULL, 0);
4227         if (tag) {
4228             if (!val || !strcmp(tag->value, val + 1))
4229                 ret = 1;
4230             else
4231                 ret = 0;
4232         } else
4233             ret = 0;
4234
4235         av_freep(&key);
4236         return ret;
4237     } else if (!*spec) /* empty specifier, matches everything */
4238         return 1;
4239
4240     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4241     return AVERROR(EINVAL);
4242 }
4243
4244 int ff_generate_avci_extradata(AVStream *st)
4245 {
4246     static const uint8_t avci100_1080p_extradata[] = {
4247         // SPS
4248         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4249         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4250         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4251         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4252         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4253         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4254         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4255         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4256         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4257         // PPS
4258         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4259         0xd0
4260     };
4261     static const uint8_t avci100_1080i_extradata[] = {
4262         // SPS
4263         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4264         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4265         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4266         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4267         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4268         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4269         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4270         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4271         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4272         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4273         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4274         // PPS
4275         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4276         0xd0
4277     };
4278     static const uint8_t avci50_1080p_extradata[] = {
4279         // SPS
4280         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4281         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4282         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4283         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4284         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4285         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4286         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4287         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4288         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4289         // PPS
4290         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4291         0x11
4292     };
4293     static const uint8_t avci50_1080i_extradata[] = {
4294         // SPS
4295         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4296         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4297         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4298         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4299         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4300         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4301         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4302         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4303         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4304         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4305         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4306         // PPS
4307         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4308         0x11
4309     };
4310     static const uint8_t avci100_720p_extradata[] = {
4311         // SPS
4312         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4313         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4314         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4315         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4316         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4317         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4318         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4319         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4320         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4321         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4322         // PPS
4323         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4324         0x11
4325     };
4326     static const uint8_t avci50_720p_extradata[] = {
4327         // SPS
4328         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4329         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4330         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4331         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4332         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4333         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4334         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4335         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4336         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4337         // PPS
4338         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4339         0x11
4340     };
4341
4342     const uint8_t *data = NULL;
4343     int size            = 0;
4344
4345     if (st->codec->width == 1920) {
4346         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4347             data = avci100_1080p_extradata;
4348             size = sizeof(avci100_1080p_extradata);
4349         } else {
4350             data = avci100_1080i_extradata;
4351             size = sizeof(avci100_1080i_extradata);
4352         }
4353     } else if (st->codec->width == 1440) {
4354         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4355             data = avci50_1080p_extradata;
4356             size = sizeof(avci50_1080p_extradata);
4357         } else {
4358             data = avci50_1080i_extradata;
4359             size = sizeof(avci50_1080i_extradata);
4360         }
4361     } else if (st->codec->width == 1280) {
4362         data = avci100_720p_extradata;
4363         size = sizeof(avci100_720p_extradata);
4364     } else if (st->codec->width == 960) {
4365         data = avci50_720p_extradata;
4366         size = sizeof(avci50_720p_extradata);
4367     }
4368
4369     if (!size)
4370         return 0;
4371
4372     av_freep(&st->codec->extradata);
4373     if (ff_alloc_extradata(st->codec, size))
4374         return AVERROR(ENOMEM);
4375     memcpy(st->codec->extradata, data, size);
4376
4377     return 0;
4378 }
4379
4380 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4381                                  int *size)
4382 {
4383     int i;
4384
4385     for (i = 0; i < st->nb_side_data; i++) {
4386         if (st->side_data[i].type == type) {
4387             if (size)
4388                 *size = st->side_data[i].size;
4389             return st->side_data[i].data;
4390         }
4391     }
4392     return NULL;
4393 }