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