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