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