git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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