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