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 (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3377                                AV_DISPOSITION_VISUAL_IMPAIRED))
3378             continue;
3379         if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3380             continue;
3381         if (decoder_ret) {
3382             decoder = find_decoder(ic, st, st->codec->codec_id);
3383             if (!decoder) {
3384                 if (ret < 0)
3385                     ret = AVERROR_DECODER_NOT_FOUND;
3386                 continue;
3387             }
3388         }
3389         count = st->codec_info_nb_frames;
3390         bitrate = avctx->bit_rate;
3391         multiframe = FFMIN(5, count);
3392         if ((best_multiframe >  multiframe) ||
3393             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3394             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3395             continue;
3396         best_count   = count;
3397         best_bitrate = bitrate;
3398         best_multiframe = multiframe;
3399         ret          = real_stream_index;
3400         best_decoder = decoder;
3401         if (program && i == nb_streams - 1 && ret < 0) {
3402             program    = NULL;
3403             nb_streams = ic->nb_streams;
3404             /* no related stream found, try again with everything */
3405             i = 0;
3406         }
3407     }
3408     if (decoder_ret)
3409         *decoder_ret = best_decoder;
3410     return ret;
3411 }
3412
3413 /*******************************************************/
3414
3415 int av_read_play(AVFormatContext *s)
3416 {
3417     if (s->iformat->read_play)
3418         return s->iformat->read_play(s);
3419     if (s->pb)
3420         return avio_pause(s->pb, 0);
3421     return AVERROR(ENOSYS);
3422 }
3423
3424 int av_read_pause(AVFormatContext *s)
3425 {
3426     if (s->iformat->read_pause)
3427         return s->iformat->read_pause(s);
3428     if (s->pb)
3429         return avio_pause(s->pb, 1);
3430     return AVERROR(ENOSYS);
3431 }
3432
3433 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3434     av_assert0(s->nb_streams>0);
3435     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3436
3437     if (st->parser) {
3438         av_parser_close(st->parser);
3439     }
3440     if (st->attached_pic.data)
3441         av_free_packet(&st->attached_pic);
3442     av_dict_free(&st->metadata);
3443     av_freep(&st->probe_data.buf);
3444     av_freep(&st->index_entries);
3445     av_freep(&st->codec->extradata);
3446     av_freep(&st->codec->subtitle_header);
3447     av_freep(&st->codec);
3448     av_freep(&st->priv_data);
3449     if (st->info)
3450         av_freep(&st->info->duration_error);
3451     av_freep(&st->info);
3452     av_freep(&s->streams[ --s->nb_streams ]);
3453 }
3454
3455 void avformat_free_context(AVFormatContext *s)
3456 {
3457     int i;
3458
3459     if (!s)
3460         return;
3461
3462     av_opt_free(s);
3463     if (s->iformat && s->iformat->priv_class && s->priv_data)
3464         av_opt_free(s->priv_data);
3465
3466     for (i = s->nb_streams - 1; i >= 0; i--) {
3467         ff_free_stream(s, s->streams[i]);
3468     }
3469     for (i = s->nb_programs - 1; i >= 0; i--) {
3470         av_dict_free(&s->programs[i]->metadata);
3471         av_freep(&s->programs[i]->stream_index);
3472         av_freep(&s->programs[i]);
3473     }
3474     av_freep(&s->programs);
3475     av_freep(&s->priv_data);
3476     while (s->nb_chapters--) {
3477         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3478         av_freep(&s->chapters[s->nb_chapters]);
3479     }
3480     av_freep(&s->chapters);
3481     av_dict_free(&s->metadata);
3482     av_freep(&s->streams);
3483     av_freep(&s->internal);
3484     av_free(s);
3485 }
3486
3487 #if FF_API_CLOSE_INPUT_FILE
3488 void av_close_input_file(AVFormatContext *s)
3489 {
3490     avformat_close_input(&s);
3491 }
3492 #endif
3493
3494 void avformat_close_input(AVFormatContext **ps)
3495 {
3496     AVFormatContext *s;
3497     AVIOContext *pb;
3498
3499     if (!ps || !*ps)
3500         return;
3501
3502     s  = *ps;
3503     pb = s->pb;
3504
3505     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3506         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3507         pb = NULL;
3508
3509     flush_packet_queue(s);
3510
3511     if (s->iformat)
3512         if (s->iformat->read_close)
3513             s->iformat->read_close(s);
3514
3515     avformat_free_context(s);
3516
3517     *ps = NULL;
3518
3519     avio_close(pb);
3520 }
3521
3522 #if FF_API_NEW_STREAM
3523 AVStream *av_new_stream(AVFormatContext *s, int id)
3524 {
3525     AVStream *st = avformat_new_stream(s, NULL);
3526     if (st)
3527         st->id = id;
3528     return st;
3529 }
3530 #endif
3531
3532 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3533 {
3534     AVStream *st;
3535     int i;
3536     AVStream **streams;
3537
3538     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3539         return NULL;
3540     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3541     if (!streams)
3542         return NULL;
3543     s->streams = streams;
3544
3545     st = av_mallocz(sizeof(AVStream));
3546     if (!st)
3547         return NULL;
3548     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3549         av_free(st);
3550         return NULL;
3551     }
3552     st->info->last_dts = AV_NOPTS_VALUE;
3553
3554     st->codec = avcodec_alloc_context3(c);
3555     if (s->iformat)
3556         /* no default bitrate if decoding */
3557         st->codec->bit_rate = 0;
3558     st->index      = s->nb_streams;
3559     st->start_time = AV_NOPTS_VALUE;
3560     st->duration   = AV_NOPTS_VALUE;
3561     /* we set the current DTS to 0 so that formats without any timestamps
3562      * but durations get some timestamps, formats with some unknown
3563      * timestamps have their first few packets buffered and the
3564      * timestamps corrected before they are returned to the user */
3565     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3566     st->first_dts     = AV_NOPTS_VALUE;
3567     st->probe_packets = MAX_PROBE_PACKETS;
3568     st->pts_wrap_reference = AV_NOPTS_VALUE;
3569     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3570
3571     /* default pts setting is MPEG-like */
3572     avpriv_set_pts_info(st, 33, 1, 90000);
3573     st->last_IP_pts = AV_NOPTS_VALUE;
3574     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3575         st->pts_buffer[i] = AV_NOPTS_VALUE;
3576
3577     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3578
3579 #if FF_API_R_FRAME_RATE
3580     st->info->last_dts      = AV_NOPTS_VALUE;
3581 #endif
3582     st->info->fps_first_dts = AV_NOPTS_VALUE;
3583     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3584
3585     s->streams[s->nb_streams++] = st;
3586     return st;
3587 }
3588
3589 AVProgram *av_new_program(AVFormatContext *ac, int id)
3590 {
3591     AVProgram *program = NULL;
3592     int i;
3593
3594     av_dlog(ac, "new_program: id=0x%04x\n", id);
3595
3596     for (i = 0; i < ac->nb_programs; i++)
3597         if (ac->programs[i]->id == id)
3598             program = ac->programs[i];
3599
3600     if (!program) {
3601         program = av_mallocz(sizeof(AVProgram));
3602         if (!program)
3603             return NULL;
3604         dynarray_add(&ac->programs, &ac->nb_programs, program);
3605         program->discard = AVDISCARD_NONE;
3606     }
3607     program->id = id;
3608     program->pts_wrap_reference = AV_NOPTS_VALUE;
3609     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3610
3611     program->start_time =
3612     program->end_time   = AV_NOPTS_VALUE;
3613
3614     return program;
3615 }
3616
3617 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3618                               int64_t start, int64_t end, const char *title)
3619 {
3620     AVChapter *chapter = NULL;
3621     int i;
3622
3623     for (i = 0; i < s->nb_chapters; i++)
3624         if (s->chapters[i]->id == id)
3625             chapter = s->chapters[i];
3626
3627     if (!chapter) {
3628         chapter = av_mallocz(sizeof(AVChapter));
3629         if (!chapter)
3630             return NULL;
3631         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3632     }
3633     av_dict_set(&chapter->metadata, "title", title, 0);
3634     chapter->id        = id;
3635     chapter->time_base = time_base;
3636     chapter->start     = start;
3637     chapter->end       = end;
3638
3639     return chapter;
3640 }
3641
3642 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3643 {
3644     int i, j;
3645     AVProgram *program = NULL;
3646     void *tmp;
3647
3648     if (idx >= ac->nb_streams) {
3649         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3650         return;
3651     }
3652
3653     for (i = 0; i < ac->nb_programs; i++) {
3654         if (ac->programs[i]->id != progid)
3655             continue;
3656         program = ac->programs[i];
3657         for (j = 0; j < program->nb_stream_indexes; j++)
3658             if (program->stream_index[j] == idx)
3659                 return;
3660
3661         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3662         if (!tmp)
3663             return;
3664         program->stream_index = tmp;
3665         program->stream_index[program->nb_stream_indexes++] = idx;
3666         return;
3667     }
3668 }
3669
3670 static void print_fps(double d, const char *postfix)
3671 {
3672     uint64_t v = lrintf(d * 100);
3673     if (v % 100)
3674         av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3675     else if (v % (100 * 1000))
3676         av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3677     else
3678         av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d / 1000, postfix);
3679 }
3680
3681 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3682 {
3683     if (m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))) {
3684         AVDictionaryEntry *tag = NULL;
3685
3686         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3687         while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX)))
3688             if (strcmp("language", tag->key)) {
3689                 const char *p = tag->value;
3690                 av_log(ctx, AV_LOG_INFO,
3691                        "%s  %-16s: ", indent, tag->key);
3692                 while (*p) {
3693                     char tmp[256];
3694                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3695                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3696                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3697                     p += len;
3698                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3699                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3700                     if (*p) p++;
3701                 }
3702                 av_log(ctx, AV_LOG_INFO, "\n");
3703             }
3704     }
3705 }
3706
3707 /* "user interface" functions */
3708 static void dump_stream_format(AVFormatContext *ic, int i,
3709                                int index, int is_output)
3710 {
3711     char buf[256];
3712     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3713     AVStream *st = ic->streams[i];
3714     int g = av_gcd(st->time_base.num, st->time_base.den);
3715     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3716     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3717     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3718     /* the pid is an important information, so we display it */
3719     /* XXX: add a generic system */
3720     if (flags & AVFMT_SHOW_IDS)
3721         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3722     if (lang)
3723         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3724     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames,
3725            st->time_base.num / g, st->time_base.den / g);
3726     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3727     if (st->sample_aspect_ratio.num && // default
3728         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3729         AVRational display_aspect_ratio;
3730         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3731                   st->codec->width  * st->sample_aspect_ratio.num,
3732                   st->codec->height * st->sample_aspect_ratio.den,
3733                   1024 * 1024);
3734         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3735                st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3736                display_aspect_ratio.num, display_aspect_ratio.den);
3737     }
3738     if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3739         if (st->avg_frame_rate.den && st->avg_frame_rate.num)
3740             print_fps(av_q2d(st->avg_frame_rate), "fps");
3741 #if FF_API_R_FRAME_RATE
3742         if (st->r_frame_rate.den && st->r_frame_rate.num)
3743             print_fps(av_q2d(st->r_frame_rate), "tbr");
3744 #endif
3745         if (st->time_base.den && st->time_base.num)
3746             print_fps(1 / av_q2d(st->time_base), "tbn");
3747         if (st->codec->time_base.den && st->codec->time_base.num)
3748             print_fps(1 / av_q2d(st->codec->time_base), "tbc");
3749     }
3750     if (st->disposition & AV_DISPOSITION_DEFAULT)
3751         av_log(NULL, AV_LOG_INFO, " (default)");
3752     if (st->disposition & AV_DISPOSITION_DUB)
3753         av_log(NULL, AV_LOG_INFO, " (dub)");
3754     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3755         av_log(NULL, AV_LOG_INFO, " (original)");
3756     if (st->disposition & AV_DISPOSITION_COMMENT)
3757         av_log(NULL, AV_LOG_INFO, " (comment)");
3758     if (st->disposition & AV_DISPOSITION_LYRICS)
3759         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3760     if (st->disposition & AV_DISPOSITION_KARAOKE)
3761         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3762     if (st->disposition & AV_DISPOSITION_FORCED)
3763         av_log(NULL, AV_LOG_INFO, " (forced)");
3764     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3765         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3766     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3767         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3768     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3769         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3770     av_log(NULL, AV_LOG_INFO, "\n");
3771     dump_metadata(NULL, st->metadata, "    ");
3772 }
3773
3774 void av_dump_format(AVFormatContext *ic, int index,
3775                     const char *url, int is_output)
3776 {
3777     int i;
3778     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3779     if (ic->nb_streams && !printed)
3780         return;
3781
3782     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3783            is_output ? "Output" : "Input",
3784            index,
3785            is_output ? ic->oformat->name : ic->iformat->name,
3786            is_output ? "to" : "from", url);
3787     dump_metadata(NULL, ic->metadata, "  ");
3788     if (!is_output) {
3789         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3790         if (ic->duration != AV_NOPTS_VALUE) {
3791             int hours, mins, secs, us;
3792             int64_t duration = ic->duration + 5000;
3793             secs  = duration / AV_TIME_BASE;
3794             us    = duration % AV_TIME_BASE;
3795             mins  = secs / 60;
3796             secs %= 60;
3797             hours = mins / 60;
3798             mins %= 60;
3799             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3800                    (100 * us) / AV_TIME_BASE);
3801         } else {
3802             av_log(NULL, AV_LOG_INFO, "N/A");
3803         }
3804         if (ic->start_time != AV_NOPTS_VALUE) {
3805             int secs, us;
3806             av_log(NULL, AV_LOG_INFO, ", start: ");
3807             secs = ic->start_time / AV_TIME_BASE;
3808             us   = abs(ic->start_time % AV_TIME_BASE);
3809             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3810                    secs, (int) av_rescale(us, 1000000, AV_TIME_BASE));
3811         }
3812         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3813         if (ic->bit_rate)
3814             av_log(NULL, AV_LOG_INFO, "%d kb/s", ic->bit_rate / 1000);
3815         else
3816             av_log(NULL, AV_LOG_INFO, "N/A");
3817         av_log(NULL, AV_LOG_INFO, "\n");
3818     }
3819     for (i = 0; i < ic->nb_chapters; i++) {
3820         AVChapter *ch = ic->chapters[i];
3821         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3822         av_log(NULL, AV_LOG_INFO,
3823                "start %f, ", ch->start * av_q2d(ch->time_base));
3824         av_log(NULL, AV_LOG_INFO,
3825                "end %f\n", ch->end * av_q2d(ch->time_base));
3826
3827         dump_metadata(NULL, ch->metadata, "    ");
3828     }
3829     if (ic->nb_programs) {
3830         int j, k, total = 0;
3831         for (j = 0; j < ic->nb_programs; j++) {
3832             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3833                                                   "name", NULL, 0);
3834             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3835                    name ? name->value : "");
3836             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3837             for (k = 0; k < ic->programs[j]->nb_stream_indexes; k++) {
3838                 dump_stream_format(ic, ic->programs[j]->stream_index[k],
3839                                    index, is_output);
3840                 printed[ic->programs[j]->stream_index[k]] = 1;
3841             }
3842             total += ic->programs[j]->nb_stream_indexes;
3843         }
3844         if (total < ic->nb_streams)
3845             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3846     }
3847     for (i = 0; i < ic->nb_streams; i++)
3848         if (!printed[i])
3849             dump_stream_format(ic, i, index, is_output);
3850
3851     av_free(printed);
3852 }
3853
3854 uint64_t ff_ntp_time(void)
3855 {
3856     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3857 }
3858
3859 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3860 {
3861     const char *p;
3862     char *q, buf1[20], c;
3863     int nd, len, percentd_found;
3864
3865     q = buf;
3866     p = path;
3867     percentd_found = 0;
3868     for (;;) {
3869         c = *p++;
3870         if (c == '\0')
3871             break;
3872         if (c == '%') {
3873             do {
3874                 nd = 0;
3875                 while (av_isdigit(*p))
3876                     nd = nd * 10 + *p++ - '0';
3877                 c = *p++;
3878             } while (av_isdigit(c));
3879
3880             switch (c) {
3881             case '%':
3882                 goto addchar;
3883             case 'd':
3884                 if (percentd_found)
3885                     goto fail;
3886                 percentd_found = 1;
3887                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3888                 len = strlen(buf1);
3889                 if ((q - buf + len) > buf_size - 1)
3890                     goto fail;
3891                 memcpy(q, buf1, len);
3892                 q += len;
3893                 break;
3894             default:
3895                 goto fail;
3896             }
3897         } else {
3898 addchar:
3899             if ((q - buf) < buf_size - 1)
3900                 *q++ = c;
3901         }
3902     }
3903     if (!percentd_found)
3904         goto fail;
3905     *q = '\0';
3906     return 0;
3907 fail:
3908     *q = '\0';
3909     return -1;
3910 }
3911
3912 #define HEXDUMP_PRINT(...)                      \
3913     do {                                        \
3914         if (!f)                                 \
3915             av_log(avcl, level, __VA_ARGS__);   \
3916         else                                    \
3917             fprintf(f, __VA_ARGS__);            \
3918     } while (0)
3919
3920 static void hex_dump_internal(void *avcl, FILE *f, int level,
3921                               const uint8_t *buf, int size)
3922 {
3923     int len, i, j, c;
3924
3925     for (i = 0; i < size; i += 16) {
3926         len = size - i;
3927         if (len > 16)
3928             len = 16;
3929         HEXDUMP_PRINT("%08x ", i);
3930         for (j = 0; j < 16; j++) {
3931             if (j < len)
3932                 HEXDUMP_PRINT(" %02x", buf[i + j]);
3933             else
3934                 HEXDUMP_PRINT("   ");
3935         }
3936         HEXDUMP_PRINT(" ");
3937         for (j = 0; j < len; j++) {
3938             c = buf[i + j];
3939             if (c < ' ' || c > '~')
3940                 c = '.';
3941             HEXDUMP_PRINT("%c", c);
3942         }
3943         HEXDUMP_PRINT("\n");
3944     }
3945 }
3946
3947 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3948 {
3949     hex_dump_internal(NULL, f, 0, buf, size);
3950 }
3951
3952 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3953 {
3954     hex_dump_internal(avcl, NULL, level, buf, size);
3955 }
3956
3957 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt,
3958                               int dump_payload, AVRational time_base)
3959 {
3960     HEXDUMP_PRINT("stream #%d:\n", pkt->stream_index);
3961     HEXDUMP_PRINT("  keyframe=%d\n", (pkt->flags & AV_PKT_FLAG_KEY) != 0);
3962     HEXDUMP_PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3963     /* DTS is _always_ valid after av_read_frame() */
3964     HEXDUMP_PRINT("  dts=");
3965     if (pkt->dts == AV_NOPTS_VALUE)
3966         HEXDUMP_PRINT("N/A");
3967     else
3968         HEXDUMP_PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3969     /* PTS may not be known if B-frames are present. */
3970     HEXDUMP_PRINT("  pts=");
3971     if (pkt->pts == AV_NOPTS_VALUE)
3972         HEXDUMP_PRINT("N/A");
3973     else
3974         HEXDUMP_PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3975     HEXDUMP_PRINT("\n");
3976     HEXDUMP_PRINT("  size=%d\n", pkt->size);
3977     if (dump_payload)
3978         av_hex_dump(f, pkt->data, pkt->size);
3979 }
3980
3981 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3982 {
3983     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3984 }
3985
3986 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3987                       AVStream *st)
3988 {
3989     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3990 }
3991
3992 void av_url_split(char *proto, int proto_size,
3993                   char *authorization, int authorization_size,
3994                   char *hostname, int hostname_size,
3995                   int *port_ptr, char *path, int path_size, const char *url)
3996 {
3997     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3998
3999     if (port_ptr)
4000         *port_ptr = -1;
4001     if (proto_size > 0)
4002         proto[0] = 0;
4003     if (authorization_size > 0)
4004         authorization[0] = 0;
4005     if (hostname_size > 0)
4006         hostname[0] = 0;
4007     if (path_size > 0)
4008         path[0] = 0;
4009
4010     /* parse protocol */
4011     if ((p = strchr(url, ':'))) {
4012         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4013         p++; /* skip ':' */
4014         if (*p == '/')
4015             p++;
4016         if (*p == '/')
4017             p++;
4018     } else {
4019         /* no protocol means plain filename */
4020         av_strlcpy(path, url, path_size);
4021         return;
4022     }
4023
4024     /* separate path from hostname */
4025     ls = strchr(p, '/');
4026     ls2 = strchr(p, '?');
4027     if (!ls)
4028         ls = ls2;
4029     else if (ls && ls2)
4030         ls = FFMIN(ls, ls2);
4031     if (ls)
4032         av_strlcpy(path, ls, path_size);
4033     else
4034         ls = &p[strlen(p)];  // XXX
4035
4036     /* the rest is hostname, use that to parse auth/port */
4037     if (ls != p) {
4038         /* authorization (user[:pass]@hostname) */
4039         at2 = p;
4040         while ((at = strchr(p, '@')) && at < ls) {
4041             av_strlcpy(authorization, at2,
4042                        FFMIN(authorization_size, at + 1 - at2));
4043             p = at + 1; /* skip '@' */
4044         }
4045
4046         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4047             /* [host]:port */
4048             av_strlcpy(hostname, p + 1,
4049                        FFMIN(hostname_size, brk - p));
4050             if (brk[1] == ':' && port_ptr)
4051                 *port_ptr = atoi(brk + 2);
4052         } else if ((col = strchr(p, ':')) && col < ls) {
4053             av_strlcpy(hostname, p,
4054                        FFMIN(col + 1 - p, hostname_size));
4055             if (port_ptr)
4056                 *port_ptr = atoi(col + 1);
4057         } else
4058             av_strlcpy(hostname, p,
4059                        FFMIN(ls + 1 - p, hostname_size));
4060     }
4061 }
4062
4063 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4064 {
4065     int i;
4066     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4067                                            '4', '5', '6', '7',
4068                                            '8', '9', 'A', 'B',
4069                                            'C', 'D', 'E', 'F' };
4070     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4071                                            '4', '5', '6', '7',
4072                                            '8', '9', 'a', 'b',
4073                                            'c', 'd', 'e', 'f' };
4074     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4075
4076     for (i = 0; i < s; i++) {
4077         buff[i * 2]     = hex_table[src[i] >> 4];
4078         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4079     }
4080
4081     return buff;
4082 }
4083
4084 int ff_hex_to_data(uint8_t *data, const char *p)
4085 {
4086     int c, len, v;
4087
4088     len = 0;
4089     v   = 1;
4090     for (;;) {
4091         p += strspn(p, SPACE_CHARS);
4092         if (*p == '\0')
4093             break;
4094         c = av_toupper((unsigned char) *p++);
4095         if (c >= '0' && c <= '9')
4096             c = c - '0';
4097         else if (c >= 'A' && c <= 'F')
4098             c = c - 'A' + 10;
4099         else
4100             break;
4101         v = (v << 4) | c;
4102         if (v & 0x100) {
4103             if (data)
4104                 data[len] = v;
4105             len++;
4106             v = 1;
4107         }
4108     }
4109     return len;
4110 }
4111
4112 #if FF_API_SET_PTS_INFO
4113 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4114                      unsigned int pts_num, unsigned int pts_den)
4115 {
4116     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4117 }
4118 #endif
4119
4120 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4121                          unsigned int pts_num, unsigned int pts_den)
4122 {
4123     AVRational new_tb;
4124     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4125         if (new_tb.num != pts_num)
4126             av_log(NULL, AV_LOG_DEBUG,
4127                    "st:%d removing common factor %d from timebase\n",
4128                    s->index, pts_num / new_tb.num);
4129     } else
4130         av_log(NULL, AV_LOG_WARNING,
4131                "st:%d has too large timebase, reducing\n", s->index);
4132
4133     if (new_tb.num <= 0 || new_tb.den <= 0) {
4134         av_log(NULL, AV_LOG_ERROR,
4135                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4136                new_tb.num, new_tb.den,
4137                s->index);
4138         return;
4139     }
4140     s->time_base     = new_tb;
4141     av_codec_set_pkt_timebase(s->codec, new_tb);
4142     s->pts_wrap_bits = pts_wrap_bits;
4143 }
4144
4145 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4146                         void *context)
4147 {
4148     const char *ptr = str;
4149
4150     /* Parse key=value pairs. */
4151     for (;;) {
4152         const char *key;
4153         char *dest = NULL, *dest_end;
4154         int key_len, dest_len = 0;
4155
4156         /* Skip whitespace and potential commas. */
4157         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4158             ptr++;
4159         if (!*ptr)
4160             break;
4161
4162         key = ptr;
4163
4164         if (!(ptr = strchr(key, '=')))
4165             break;
4166         ptr++;
4167         key_len = ptr - key;
4168
4169         callback_get_buf(context, key, key_len, &dest, &dest_len);
4170         dest_end = dest + dest_len - 1;
4171
4172         if (*ptr == '\"') {
4173             ptr++;
4174             while (*ptr && *ptr != '\"') {
4175                 if (*ptr == '\\') {
4176                     if (!ptr[1])
4177                         break;
4178                     if (dest && dest < dest_end)
4179                         *dest++ = ptr[1];
4180                     ptr += 2;
4181                 } else {
4182                     if (dest && dest < dest_end)
4183                         *dest++ = *ptr;
4184                     ptr++;
4185                 }
4186             }
4187             if (*ptr == '\"')
4188                 ptr++;
4189         } else {
4190             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4191                 if (dest && dest < dest_end)
4192                     *dest++ = *ptr;
4193         }
4194         if (dest)
4195             *dest = 0;
4196     }
4197 }
4198
4199 int ff_find_stream_index(AVFormatContext *s, int id)
4200 {
4201     int i;
4202     for (i = 0; i < s->nb_streams; i++)
4203         if (s->streams[i]->id == id)
4204             return i;
4205     return -1;
4206 }
4207
4208 int64_t ff_iso8601_to_unix_time(const char *datestr)
4209 {
4210     struct tm time1 = { 0 }, time2 = { 0 };
4211     char *ret1, *ret2;
4212     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4213     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4214     if (ret2 && !ret1)
4215         return av_timegm(&time2);
4216     else
4217         return av_timegm(&time1);
4218 }
4219
4220 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4221                          int std_compliance)
4222 {
4223     if (ofmt) {
4224         if (ofmt->query_codec)
4225             return ofmt->query_codec(codec_id, std_compliance);
4226         else if (ofmt->codec_tag)
4227             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4228         else if (codec_id == ofmt->video_codec ||
4229                  codec_id == ofmt->audio_codec ||
4230                  codec_id == ofmt->subtitle_codec)
4231             return 1;
4232     }
4233     return AVERROR_PATCHWELCOME;
4234 }
4235
4236 int avformat_network_init(void)
4237 {
4238 #if CONFIG_NETWORK
4239     int ret;
4240     ff_network_inited_globally = 1;
4241     if ((ret = ff_network_init()) < 0)
4242         return ret;
4243     ff_tls_init();
4244 #endif
4245     return 0;
4246 }
4247
4248 int avformat_network_deinit(void)
4249 {
4250 #if CONFIG_NETWORK
4251     ff_network_close();
4252     ff_tls_deinit();
4253 #endif
4254     return 0;
4255 }
4256
4257 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4258                         uint64_t channel_layout, int32_t sample_rate,
4259                         int32_t width, int32_t height)
4260 {
4261     uint32_t flags = 0;
4262     int size = 4;
4263     uint8_t *data;
4264     if (!pkt)
4265         return AVERROR(EINVAL);
4266     if (channels) {
4267         size  += 4;
4268         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4269     }
4270     if (channel_layout) {
4271         size  += 8;
4272         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4273     }
4274     if (sample_rate) {
4275         size  += 4;
4276         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4277     }
4278     if (width || height) {
4279         size  += 8;
4280         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4281     }
4282     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4283     if (!data)
4284         return AVERROR(ENOMEM);
4285     bytestream_put_le32(&data, flags);
4286     if (channels)
4287         bytestream_put_le32(&data, channels);
4288     if (channel_layout)
4289         bytestream_put_le64(&data, channel_layout);
4290     if (sample_rate)
4291         bytestream_put_le32(&data, sample_rate);
4292     if (width || height) {
4293         bytestream_put_le32(&data, width);
4294         bytestream_put_le32(&data, height);
4295     }
4296     return 0;
4297 }
4298
4299 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4300 {
4301     AVRational undef = {0, 1};
4302     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4303     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4304     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4305
4306     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4307                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4308     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4309         stream_sample_aspect_ratio = undef;
4310
4311     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4312                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4313     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4314         frame_sample_aspect_ratio = undef;
4315
4316     if (stream_sample_aspect_ratio.num)
4317         return stream_sample_aspect_ratio;
4318     else
4319         return frame_sample_aspect_ratio;
4320 }
4321
4322 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4323 {
4324     AVRational fr = st->r_frame_rate;
4325
4326     if (st->codec->ticks_per_frame > 1) {
4327         AVRational codec_fr = av_inv_q(st->codec->time_base);
4328         AVRational   avg_fr = st->avg_frame_rate;
4329         codec_fr.den *= st->codec->ticks_per_frame;
4330         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4331             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4332             fr = codec_fr;
4333     }
4334
4335     return fr;
4336 }
4337
4338 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4339                                     const char *spec)
4340 {
4341     if (*spec <= '9' && *spec >= '0') /* opt:index */
4342         return strtol(spec, NULL, 0) == st->index;
4343     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4344              *spec == 't') { /* opt:[vasdt] */
4345         enum AVMediaType type;
4346
4347         switch (*spec++) {
4348         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4349         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4350         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4351         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4352         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4353         default:  av_assert0(0);
4354         }
4355         if (type != st->codec->codec_type)
4356             return 0;
4357         if (*spec++ == ':') { /* possibly followed by :index */
4358             int i, index = strtol(spec, NULL, 0);
4359             for (i = 0; i < s->nb_streams; i++)
4360                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4361                    return i == st->index;
4362             return 0;
4363         }
4364         return 1;
4365     } else if (*spec == 'p' && *(spec + 1) == ':') {
4366         int prog_id, i, j;
4367         char *endptr;
4368         spec += 2;
4369         prog_id = strtol(spec, &endptr, 0);
4370         for (i = 0; i < s->nb_programs; i++) {
4371             if (s->programs[i]->id != prog_id)
4372                 continue;
4373
4374             if (*endptr++ == ':') {
4375                 int stream_idx = strtol(endptr, NULL, 0);
4376                 return stream_idx >= 0 &&
4377                     stream_idx < s->programs[i]->nb_stream_indexes &&
4378                     st->index == s->programs[i]->stream_index[stream_idx];
4379             }
4380
4381             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4382                 if (st->index == s->programs[i]->stream_index[j])
4383                     return 1;
4384         }
4385         return 0;
4386     } else if (*spec == '#') {
4387         int sid;
4388         char *endptr;
4389         sid = strtol(spec + 1, &endptr, 0);
4390         if (!*endptr)
4391             return st->id == sid;
4392     } else if (!*spec) /* empty specifier, matches everything */
4393         return 1;
4394
4395     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4396     return AVERROR(EINVAL);
4397 }
4398
4399 int ff_generate_avci_extradata(AVStream *st)
4400 {
4401     static const uint8_t avci100_1080p_extradata[] = {
4402         // SPS
4403         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4404         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4405         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4406         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4407         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4408         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4409         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4410         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4411         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4412         // PPS
4413         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4414         0xd0
4415     };
4416     static const uint8_t avci100_1080i_extradata[] = {
4417         // SPS
4418         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4419         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4420         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4421         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4422         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4423         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4424         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4425         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4426         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4427         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4428         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4429         // PPS
4430         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4431         0xd0
4432     };
4433     static const uint8_t avci50_1080i_extradata[] = {
4434         // SPS
4435         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4436         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4437         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4438         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4439         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4440         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4441         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4442         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4443         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4444         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4445         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4446         // PPS
4447         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4448         0x11
4449     };
4450     static const uint8_t avci100_720p_extradata[] = {
4451         // SPS
4452         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4453         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4454         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4455         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4456         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4457         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4458         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4459         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4460         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4461         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4462         // PPS
4463         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4464         0x11
4465     };
4466
4467     const uint8_t *data = NULL;
4468     int size            = 0;
4469
4470     if (st->codec->width == 1920) {
4471         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4472             data = avci100_1080p_extradata;
4473             size = sizeof(avci100_1080p_extradata);
4474         } else {
4475             data = avci100_1080i_extradata;
4476             size = sizeof(avci100_1080i_extradata);
4477         }
4478     } else if (st->codec->width == 1440) {
4479         data = avci50_1080i_extradata;
4480         size = sizeof(avci50_1080i_extradata);
4481     } else if (st->codec->width == 1280) {
4482         data = avci100_720p_extradata;
4483         size = sizeof(avci100_720p_extradata);
4484     }
4485
4486     if (!size)
4487         return 0;
4488
4489     av_freep(&st->codec->extradata);
4490     if (ff_alloc_extradata(st->codec, size))
4491         return AVERROR(ENOMEM);
4492     memcpy(st->codec->extradata, data, size);
4493
4494     return 0;
4495 }