git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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