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