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