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