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