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