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