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