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 & 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 - FF_INPUT_BUFFER_PADDING_SIZE) {
2926         avctx->extradata = NULL;
2927         avctx->extradata_size = 0;
2928         return AVERROR(EINVAL);
2929     }
2930     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2931     if (avctx->extradata) {
2932         memset(avctx->extradata + size, 0, FF_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 probesize = ic->probesize2;
3094
3095     if (!max_analyze_duration)
3096         max_analyze_duration = ic->max_analyze_duration;
3097     if (ic->probesize)
3098         probesize = ic->probesize;
3099     flush_codecs = probesize > 0;
3100
3101     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3102
3103     max_stream_analyze_duration = max_analyze_duration;
3104     if (!max_analyze_duration) {
3105         max_stream_analyze_duration =
3106         max_analyze_duration        = 5*AV_TIME_BASE;
3107         if (!strcmp(ic->iformat->name, "flv"))
3108             max_stream_analyze_duration = 30*AV_TIME_BASE;
3109     }
3110
3111     if (ic->pb)
3112         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3113                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3114
3115     for (i = 0; i < ic->nb_streams; i++) {
3116         const AVCodec *codec;
3117         AVDictionary *thread_opt = NULL;
3118         st = ic->streams[i];
3119
3120         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3121             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3122 /*            if (!st->time_base.num)
3123                 st->time_base = */
3124             if (!st->codec->time_base.num)
3125                 st->codec->time_base = st->time_base;
3126         }
3127         // only for the split stuff
3128         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3129             st->parser = av_parser_init(st->codec->codec_id);
3130             if (st->parser) {
3131                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3132                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3133                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3134                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3135                 }
3136             } else if (st->need_parsing) {
3137                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3138                        "%s, packets or times may be invalid.\n",
3139                        avcodec_get_name(st->codec->codec_id));
3140             }
3141         }
3142         codec = find_decoder(ic, st, st->codec->codec_id);
3143
3144         /* Force thread count to 1 since the H.264 decoder will not extract
3145          * SPS and PPS to extradata during multi-threaded decoding. */
3146         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3147
3148         if (ic->codec_whitelist)
3149             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3150
3151         /* Ensure that subtitle_header is properly set. */
3152         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3153             && codec && !st->codec->codec) {
3154             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3155                 av_log(ic, AV_LOG_WARNING,
3156                        "Failed to open codec in av_find_stream_info\n");
3157         }
3158
3159         // Try to just open decoders, in case this is enough to get parameters.
3160         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3161             if (codec && !st->codec->codec)
3162                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3163                     av_log(ic, AV_LOG_WARNING,
3164                            "Failed to open codec in av_find_stream_info\n");
3165         }
3166         if (!options)
3167             av_dict_free(&thread_opt);
3168     }
3169
3170     for (i = 0; i < ic->nb_streams; i++) {
3171 #if FF_API_R_FRAME_RATE
3172         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3173 #endif
3174         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3175         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3176     }
3177
3178     count     = 0;
3179     read_size = 0;
3180     for (;;) {
3181         int analyzed_all_streams;
3182         if (ff_check_interrupt(&ic->interrupt_callback)) {
3183             ret = AVERROR_EXIT;
3184             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3185             break;
3186         }
3187
3188         /* check if one codec still needs to be handled */
3189         for (i = 0; i < ic->nb_streams; i++) {
3190             int fps_analyze_framecount = 20;
3191
3192             st = ic->streams[i];
3193             if (!has_codec_parameters(st, NULL))
3194                 break;
3195             /* If the timebase is coarse (like the usual millisecond precision
3196              * of mkv), we need to analyze more frames to reliably arrive at
3197              * the correct fps. */
3198             if (av_q2d(st->time_base) > 0.0005)
3199                 fps_analyze_framecount *= 2;
3200             if (!tb_unreliable(st->codec))
3201                 fps_analyze_framecount = 0;
3202             if (ic->fps_probe_size >= 0)
3203                 fps_analyze_framecount = ic->fps_probe_size;
3204             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3205                 fps_analyze_framecount = 0;
3206             /* variable fps and no guess at the real fps */
3207             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3208                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3209                 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3210                     st->info->codec_info_duration_fields/2 :
3211                     st->info->duration_count;
3212                 if (count < fps_analyze_framecount)
3213                     break;
3214             }
3215             if (st->parser && st->parser->parser->split &&
3216                 !st->codec->extradata)
3217                 break;
3218             if (st->first_dts == AV_NOPTS_VALUE &&
3219                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3220                 st->codec_info_nb_frames < ic->max_ts_probe &&
3221                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3222                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3223                 break;
3224         }
3225         analyzed_all_streams = 0;
3226         if (i == ic->nb_streams) {
3227             analyzed_all_streams = 1;
3228             /* NOTE: If the format has no header, then we need to read some
3229              * packets to get most of the streams, so we cannot stop here. */
3230             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3231                 /* If we found the info for all the codecs, we can stop. */
3232                 ret = count;
3233                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3234                 flush_codecs = 0;
3235                 break;
3236             }
3237         }
3238         /* We did not get all the codec info, but we read too much data. */
3239         if (read_size >= probesize) {
3240             ret = count;
3241             av_log(ic, AV_LOG_DEBUG,
3242                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3243             for (i = 0; i < ic->nb_streams; i++)
3244                 if (!ic->streams[i]->r_frame_rate.num &&
3245                     ic->streams[i]->info->duration_count <= 1 &&
3246                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3247                     strcmp(ic->iformat->name, "image2"))
3248                     av_log(ic, AV_LOG_WARNING,
3249                            "Stream #%d: not enough frames to estimate rate; "
3250                            "consider increasing probesize\n", i);
3251             break;
3252         }
3253
3254         /* NOTE: A new stream can be added there if no header in file
3255          * (AVFMTCTX_NOHEADER). */
3256         ret = read_frame_internal(ic, &pkt1);
3257         if (ret == AVERROR(EAGAIN))
3258             continue;
3259
3260         if (ret < 0) {
3261             /* EOF or error*/
3262             break;
3263         }
3264
3265         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3266             free_packet_buffer(&ic->internal->packet_buffer,
3267                                &ic->internal->packet_buffer_end);
3268         {
3269             pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3270                                 &ic->internal->packet_buffer_end);
3271             if (!pkt) {
3272                 ret = AVERROR(ENOMEM);
3273                 goto find_stream_info_err;
3274             }
3275             if ((ret = av_dup_packet(pkt)) < 0)
3276                 goto find_stream_info_err;
3277         }
3278
3279         st = ic->streams[pkt->stream_index];
3280         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3281             read_size += pkt->size;
3282
3283         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3284             /* check for non-increasing dts */
3285             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3286                 st->info->fps_last_dts >= pkt->dts) {
3287                 av_log(ic, AV_LOG_DEBUG,
3288                        "Non-increasing DTS in stream %d: packet %d with DTS "
3289                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3290                        st->index, st->info->fps_last_dts_idx,
3291                        st->info->fps_last_dts, st->codec_info_nb_frames,
3292                        pkt->dts);
3293                 st->info->fps_first_dts =
3294                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3295             }
3296             /* Check for a discontinuity in dts. If the difference in dts
3297              * is more than 1000 times the average packet duration in the
3298              * sequence, we treat it as a discontinuity. */
3299             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3300                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3301                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3302                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3303                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3304                 av_log(ic, AV_LOG_WARNING,
3305                        "DTS discontinuity in stream %d: packet %d with DTS "
3306                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3307                        st->index, st->info->fps_last_dts_idx,
3308                        st->info->fps_last_dts, st->codec_info_nb_frames,
3309                        pkt->dts);
3310                 st->info->fps_first_dts =
3311                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3312             }
3313
3314             /* update stored dts values */
3315             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3316                 st->info->fps_first_dts     = pkt->dts;
3317                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3318             }
3319             st->info->fps_last_dts     = pkt->dts;
3320             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3321         }
3322         if (st->codec_info_nb_frames>1) {
3323             int64_t t = 0;
3324
3325             if (st->time_base.den > 0)
3326                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3327             if (st->avg_frame_rate.num > 0)
3328                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3329
3330             if (   t == 0
3331                 && st->codec_info_nb_frames>30
3332                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3333                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3334                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3335
3336             if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3337                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3338                        max_analyze_duration,
3339                        t);
3340                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3341                     av_packet_unref(pkt);
3342                 break;
3343             }
3344             if (pkt->duration) {
3345                 st->info->codec_info_duration        += pkt->duration;
3346                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3347             }
3348         }
3349 #if FF_API_R_FRAME_RATE
3350         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3351             ff_rfps_add_frame(ic, st, pkt->dts);
3352 #endif
3353         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3354             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3355             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3356                 if (ff_alloc_extradata(st->codec, i))
3357                     return AVERROR(ENOMEM);
3358                 memcpy(st->codec->extradata, pkt->data,
3359                        st->codec->extradata_size);
3360             }
3361         }
3362
3363         /* If still no information, we try to open the codec and to
3364          * decompress the frame. We try to avoid that in most cases as
3365          * it takes longer and uses more memory. For MPEG-4, we need to
3366          * decompress for QuickTime.
3367          *
3368          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3369          * least one frame of codec data, this makes sure the codec initializes
3370          * the channel configuration and does not only trust the values from
3371          * the container. */
3372         try_decode_frame(ic, st, pkt,
3373                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3374
3375         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3376             av_packet_unref(pkt);
3377
3378         st->codec_info_nb_frames++;
3379         count++;
3380     }
3381
3382     if (flush_codecs) {
3383         AVPacket empty_pkt = { 0 };
3384         int err = 0;
3385         av_init_packet(&empty_pkt);
3386
3387         for (i = 0; i < ic->nb_streams; i++) {
3388
3389             st = ic->streams[i];
3390
3391             /* flush the decoders */
3392             if (st->info->found_decoder == 1) {
3393                 do {
3394                     err = try_decode_frame(ic, st, &empty_pkt,
3395                                             (options && i < orig_nb_streams)
3396                                             ? &options[i] : NULL);
3397                 } while (err > 0 && !has_codec_parameters(st, NULL));
3398
3399                 if (err < 0) {
3400                     av_log(ic, AV_LOG_INFO,
3401                         "decoding for stream %d failed\n", st->index);
3402                 }
3403             }
3404         }
3405     }
3406
3407     // close codecs which were opened in try_decode_frame()
3408     for (i = 0; i < ic->nb_streams; i++) {
3409         st = ic->streams[i];
3410         avcodec_close(st->codec);
3411     }
3412
3413     ff_rfps_calculate(ic);
3414
3415     for (i = 0; i < ic->nb_streams; i++) {
3416         st = ic->streams[i];
3417         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3418             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3419                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3420                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3421                     st->codec->codec_tag= tag;
3422             }
3423
3424             /* estimate average framerate if not set by demuxer */
3425             if (st->info->codec_info_duration_fields &&
3426                 !st->avg_frame_rate.num &&
3427                 st->info->codec_info_duration) {
3428                 int best_fps      = 0;
3429                 double best_error = 0.01;
3430
3431                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3432                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3433                     st->info->codec_info_duration        < 0)
3434                     continue;
3435                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3436                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3437                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3438
3439                 /* Round guessed framerate to a "standard" framerate if it's
3440                  * within 1% of the original estimate. */
3441                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3442                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3443                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3444                                               av_q2d(std_fps) - 1);
3445
3446                     if (error < best_error) {
3447                         best_error = error;
3448                         best_fps   = std_fps.num;
3449                     }
3450                 }
3451                 if (best_fps)
3452                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3453                               best_fps, 12 * 1001, INT_MAX);
3454             }
3455
3456             if (!st->r_frame_rate.num) {
3457                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3458                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3459                     st->r_frame_rate.num = st->codec->time_base.den;
3460                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3461                 } else {
3462                     st->r_frame_rate.num = st->time_base.den;
3463                     st->r_frame_rate.den = st->time_base.num;
3464                 }
3465             }
3466             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3467                 AVRational hw_ratio = { st->codec->height, st->codec->width };
3468                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3469                                                    hw_ratio);
3470             }
3471         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3472             if (!st->codec->bits_per_coded_sample)
3473                 st->codec->bits_per_coded_sample =
3474                     av_get_bits_per_sample(st->codec->codec_id);
3475             // set stream disposition based on audio service type
3476             switch (st->codec->audio_service_type) {
3477             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3478                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3479                 break;
3480             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3481                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3482                 break;
3483             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3484                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3485                 break;
3486             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3487                 st->disposition = AV_DISPOSITION_COMMENT;
3488                 break;
3489             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3490                 st->disposition = AV_DISPOSITION_KARAOKE;
3491                 break;
3492             }
3493         }
3494     }
3495
3496     if (probesize)
3497     estimate_timings(ic, old_offset);
3498
3499     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3500
3501     if (ret >= 0 && ic->nb_streams)
3502         /* We could not have all the codec parameters before EOF. */
3503         ret = -1;
3504     for (i = 0; i < ic->nb_streams; i++) {
3505         const char *errmsg;
3506         st = ic->streams[i];
3507         if (!has_codec_parameters(st, &errmsg)) {
3508             char buf[256];
3509             avcodec_string(buf, sizeof(buf), st->codec, 0);
3510             av_log(ic, AV_LOG_WARNING,
3511                    "Could not find codec parameters for stream %d (%s): %s\n"
3512                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3513                    i, buf, errmsg);
3514         } else {
3515             ret = 0;
3516         }
3517     }
3518
3519     compute_chapters_end(ic);
3520
3521 find_stream_info_err:
3522     for (i = 0; i < ic->nb_streams; i++) {
3523         st = ic->streams[i];
3524         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3525             ic->streams[i]->codec->thread_count = 0;
3526         if (st->info)
3527             av_freep(&st->info->duration_error);
3528         av_freep(&ic->streams[i]->info);
3529     }
3530     if (ic->pb)
3531         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3532                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3533     return ret;
3534 }
3535
3536 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3537 {
3538     int i, j;
3539
3540     for (i = 0; i < ic->nb_programs; i++) {
3541         if (ic->programs[i] == last) {
3542             last = NULL;
3543         } else {
3544             if (!last)
3545                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3546                     if (ic->programs[i]->stream_index[j] == s)
3547                         return ic->programs[i];
3548         }
3549     }
3550     return NULL;
3551 }
3552
3553 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3554                         int wanted_stream_nb, int related_stream,
3555                         AVCodec **decoder_ret, int flags)
3556 {
3557     int i, nb_streams = ic->nb_streams;
3558     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3559     unsigned *program = NULL;
3560     const AVCodec *decoder = NULL, *best_decoder = NULL;
3561
3562     if (related_stream >= 0 && wanted_stream_nb < 0) {
3563         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3564         if (p) {
3565             program    = p->stream_index;
3566             nb_streams = p->nb_stream_indexes;
3567         }
3568     }
3569     for (i = 0; i < nb_streams; i++) {
3570         int real_stream_index = program ? program[i] : i;
3571         AVStream *st          = ic->streams[real_stream_index];
3572         AVCodecContext *avctx = st->codec;
3573         if (avctx->codec_type != type)
3574             continue;
3575         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3576             continue;
3577         if (wanted_stream_nb != real_stream_index &&
3578             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3579                                AV_DISPOSITION_VISUAL_IMPAIRED))
3580             continue;
3581         if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3582             continue;
3583         if (decoder_ret) {
3584             decoder = find_decoder(ic, st, st->codec->codec_id);
3585             if (!decoder) {
3586                 if (ret < 0)
3587                     ret = AVERROR_DECODER_NOT_FOUND;
3588                 continue;
3589             }
3590         }
3591         count = st->codec_info_nb_frames;
3592         bitrate = avctx->bit_rate;
3593         if (!bitrate)
3594             bitrate = avctx->rc_max_rate;
3595         multiframe = FFMIN(5, count);
3596         if ((best_multiframe >  multiframe) ||
3597             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3598             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3599             continue;
3600         best_count   = count;
3601         best_bitrate = bitrate;
3602         best_multiframe = multiframe;
3603         ret          = real_stream_index;
3604         best_decoder = decoder;
3605         if (program && i == nb_streams - 1 && ret < 0) {
3606             program    = NULL;
3607             nb_streams = ic->nb_streams;
3608             /* no related stream found, try again with everything */
3609             i = 0;
3610         }
3611     }
3612     if (decoder_ret)
3613         *decoder_ret = (AVCodec*)best_decoder;
3614     return ret;
3615 }
3616
3617 /*******************************************************/
3618
3619 int av_read_play(AVFormatContext *s)
3620 {
3621     if (s->iformat->read_play)
3622         return s->iformat->read_play(s);
3623     if (s->pb)
3624         return avio_pause(s->pb, 0);
3625     return AVERROR(ENOSYS);
3626 }
3627
3628 int av_read_pause(AVFormatContext *s)
3629 {
3630     if (s->iformat->read_pause)
3631         return s->iformat->read_pause(s);
3632     if (s->pb)
3633         return avio_pause(s->pb, 1);
3634     return AVERROR(ENOSYS);
3635 }
3636
3637 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3638     int j;
3639     av_assert0(s->nb_streams>0);
3640     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3641
3642     for (j = 0; j < st->nb_side_data; j++)
3643         av_freep(&st->side_data[j].data);
3644     av_freep(&st->side_data);
3645     st->nb_side_data = 0;
3646
3647     if (st->parser) {
3648         av_parser_close(st->parser);
3649     }
3650     if (st->attached_pic.data)
3651         av_free_packet(&st->attached_pic);
3652     av_dict_free(&st->metadata);
3653     av_freep(&st->probe_data.buf);
3654     av_freep(&st->index_entries);
3655     av_freep(&st->codec->extradata);
3656     av_freep(&st->codec->subtitle_header);
3657     av_freep(&st->codec);
3658     av_freep(&st->priv_data);
3659     if (st->info)
3660         av_freep(&st->info->duration_error);
3661     av_freep(&st->info);
3662     av_freep(&st->recommended_encoder_configuration);
3663     av_freep(&s->streams[ --s->nb_streams ]);
3664 }
3665
3666 void avformat_free_context(AVFormatContext *s)
3667 {
3668     int i;
3669
3670     if (!s)
3671         return;
3672
3673     av_opt_free(s);
3674     if (s->iformat && s->iformat->priv_class && s->priv_data)
3675         av_opt_free(s->priv_data);
3676     if (s->oformat && s->oformat->priv_class && s->priv_data)
3677         av_opt_free(s->priv_data);
3678
3679     for (i = s->nb_streams - 1; i >= 0; i--) {
3680         ff_free_stream(s, s->streams[i]);
3681     }
3682     for (i = s->nb_programs - 1; i >= 0; i--) {
3683         av_dict_free(&s->programs[i]->metadata);
3684         av_freep(&s->programs[i]->stream_index);
3685         av_freep(&s->programs[i]);
3686     }
3687     av_freep(&s->programs);
3688     av_freep(&s->priv_data);
3689     while (s->nb_chapters--) {
3690         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3691         av_freep(&s->chapters[s->nb_chapters]);
3692     }
3693     av_freep(&s->chapters);
3694     av_dict_free(&s->metadata);
3695     av_freep(&s->streams);
3696     av_freep(&s->internal);
3697     flush_packet_queue(s);
3698     av_free(s);
3699 }
3700
3701 void avformat_close_input(AVFormatContext **ps)
3702 {
3703     AVFormatContext *s;
3704     AVIOContext *pb;
3705
3706     if (!ps || !*ps)
3707         return;
3708
3709     s  = *ps;
3710     pb = s->pb;
3711
3712     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3713         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3714         pb = NULL;
3715
3716     flush_packet_queue(s);
3717
3718     if (s->iformat)
3719         if (s->iformat->read_close)
3720             s->iformat->read_close(s);
3721
3722     avformat_free_context(s);
3723
3724     *ps = NULL;
3725
3726     avio_close(pb);
3727 }
3728
3729 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3730 {
3731     AVStream *st;
3732     int i;
3733     AVStream **streams;
3734
3735     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3736         return NULL;
3737     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3738     if (!streams)
3739         return NULL;
3740     s->streams = streams;
3741
3742     st = av_mallocz(sizeof(AVStream));
3743     if (!st)
3744         return NULL;
3745     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3746         av_free(st);
3747         return NULL;
3748     }
3749     st->info->last_dts = AV_NOPTS_VALUE;
3750
3751     st->codec = avcodec_alloc_context3(c);
3752     if (!st->codec) {
3753         av_free(st->info);
3754         av_free(st);
3755         return NULL;
3756     }
3757     if (s->iformat) {
3758         /* no default bitrate if decoding */
3759         st->codec->bit_rate = 0;
3760
3761         /* default pts setting is MPEG-like */
3762         avpriv_set_pts_info(st, 33, 1, 90000);
3763     }
3764
3765     st->index      = s->nb_streams;
3766     st->start_time = AV_NOPTS_VALUE;
3767     st->duration   = AV_NOPTS_VALUE;
3768     /* we set the current DTS to 0 so that formats without any timestamps
3769      * but durations get some timestamps, formats with some unknown
3770      * timestamps have their first few packets buffered and the
3771      * timestamps corrected before they are returned to the user */
3772     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3773     st->first_dts     = AV_NOPTS_VALUE;
3774     st->probe_packets = MAX_PROBE_PACKETS;
3775     st->pts_wrap_reference = AV_NOPTS_VALUE;
3776     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3777
3778     st->last_IP_pts = AV_NOPTS_VALUE;
3779     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3780     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3781         st->pts_buffer[i] = AV_NOPTS_VALUE;
3782
3783     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3784
3785 #if FF_API_R_FRAME_RATE
3786     st->info->last_dts      = AV_NOPTS_VALUE;
3787 #endif
3788     st->info->fps_first_dts = AV_NOPTS_VALUE;
3789     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3790
3791     st->inject_global_side_data = s->internal->inject_global_side_data;
3792
3793     s->streams[s->nb_streams++] = st;
3794     return st;
3795 }
3796
3797 AVProgram *av_new_program(AVFormatContext *ac, int id)
3798 {
3799     AVProgram *program = NULL;
3800     int i;
3801
3802     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3803
3804     for (i = 0; i < ac->nb_programs; i++)
3805         if (ac->programs[i]->id == id)
3806             program = ac->programs[i];
3807
3808     if (!program) {
3809         program = av_mallocz(sizeof(AVProgram));
3810         if (!program)
3811             return NULL;
3812         dynarray_add(&ac->programs, &ac->nb_programs, program);
3813         program->discard = AVDISCARD_NONE;
3814     }
3815     program->id = id;
3816     program->pts_wrap_reference = AV_NOPTS_VALUE;
3817     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3818
3819     program->start_time =
3820     program->end_time   = AV_NOPTS_VALUE;
3821
3822     return program;
3823 }
3824
3825 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3826                               int64_t start, int64_t end, const char *title)
3827 {
3828     AVChapter *chapter = NULL;
3829     int i;
3830
3831     if (end != AV_NOPTS_VALUE && start > end) {
3832         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3833         return NULL;
3834     }
3835
3836     for (i = 0; i < s->nb_chapters; i++)
3837         if (s->chapters[i]->id == id)
3838             chapter = s->chapters[i];
3839
3840     if (!chapter) {
3841         chapter = av_mallocz(sizeof(AVChapter));
3842         if (!chapter)
3843             return NULL;
3844         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3845     }
3846     av_dict_set(&chapter->metadata, "title", title, 0);
3847     chapter->id        = id;
3848     chapter->time_base = time_base;
3849     chapter->start     = start;
3850     chapter->end       = end;
3851
3852     return chapter;
3853 }
3854
3855 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3856 {
3857     int i, j;
3858     AVProgram *program = NULL;
3859     void *tmp;
3860
3861     if (idx >= ac->nb_streams) {
3862         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3863         return;
3864     }
3865
3866     for (i = 0; i < ac->nb_programs; i++) {
3867         if (ac->programs[i]->id != progid)
3868             continue;
3869         program = ac->programs[i];
3870         for (j = 0; j < program->nb_stream_indexes; j++)
3871             if (program->stream_index[j] == idx)
3872                 return;
3873
3874         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3875         if (!tmp)
3876             return;
3877         program->stream_index = tmp;
3878         program->stream_index[program->nb_stream_indexes++] = idx;
3879         return;
3880     }
3881 }
3882
3883 uint64_t ff_ntp_time(void)
3884 {
3885     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3886 }
3887
3888 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3889 {
3890     const char *p;
3891     char *q, buf1[20], c;
3892     int nd, len, percentd_found;
3893
3894     q = buf;
3895     p = path;
3896     percentd_found = 0;
3897     for (;;) {
3898         c = *p++;
3899         if (c == '\0')
3900             break;
3901         if (c == '%') {
3902             do {
3903                 nd = 0;
3904                 while (av_isdigit(*p))
3905                     nd = nd * 10 + *p++ - '0';
3906                 c = *p++;
3907             } while (av_isdigit(c));
3908
3909             switch (c) {
3910             case '%':
3911                 goto addchar;
3912             case 'd':
3913                 if (percentd_found)
3914                     goto fail;
3915                 percentd_found = 1;
3916                 if (number < 0)
3917                     nd += 1;
3918                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3919                 len = strlen(buf1);
3920                 if ((q - buf + len) > buf_size - 1)
3921                     goto fail;
3922                 memcpy(q, buf1, len);
3923                 q += len;
3924                 break;
3925             default:
3926                 goto fail;
3927             }
3928         } else {
3929 addchar:
3930             if ((q - buf) < buf_size - 1)
3931                 *q++ = c;
3932         }
3933     }
3934     if (!percentd_found)
3935         goto fail;
3936     *q = '\0';
3937     return 0;
3938 fail:
3939     *q = '\0';
3940     return -1;
3941 }
3942
3943 void av_url_split(char *proto, int proto_size,
3944                   char *authorization, int authorization_size,
3945                   char *hostname, int hostname_size,
3946                   int *port_ptr, char *path, int path_size, const char *url)
3947 {
3948     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3949
3950     if (port_ptr)
3951         *port_ptr = -1;
3952     if (proto_size > 0)
3953         proto[0] = 0;
3954     if (authorization_size > 0)
3955         authorization[0] = 0;
3956     if (hostname_size > 0)
3957         hostname[0] = 0;
3958     if (path_size > 0)
3959         path[0] = 0;
3960
3961     /* parse protocol */
3962     if ((p = strchr(url, ':'))) {
3963         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3964         p++; /* skip ':' */
3965         if (*p == '/')
3966             p++;
3967         if (*p == '/')
3968             p++;
3969     } else {
3970         /* no protocol means plain filename */
3971         av_strlcpy(path, url, path_size);
3972         return;
3973     }
3974
3975     /* separate path from hostname */
3976     ls = strchr(p, '/');
3977     ls2 = strchr(p, '?');
3978     if (!ls)
3979         ls = ls2;
3980     else if (ls && ls2)
3981         ls = FFMIN(ls, ls2);
3982     if (ls)
3983         av_strlcpy(path, ls, path_size);
3984     else
3985         ls = &p[strlen(p)];  // XXX
3986
3987     /* the rest is hostname, use that to parse auth/port */
3988     if (ls != p) {
3989         /* authorization (user[:pass]@hostname) */
3990         at2 = p;
3991         while ((at = strchr(p, '@')) && at < ls) {
3992             av_strlcpy(authorization, at2,
3993                        FFMIN(authorization_size, at + 1 - at2));
3994             p = at + 1; /* skip '@' */
3995         }
3996
3997         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3998             /* [host]:port */
3999             av_strlcpy(hostname, p + 1,
4000                        FFMIN(hostname_size, brk - p));
4001             if (brk[1] == ':' && port_ptr)
4002                 *port_ptr = atoi(brk + 2);
4003         } else if ((col = strchr(p, ':')) && col < ls) {
4004             av_strlcpy(hostname, p,
4005                        FFMIN(col + 1 - p, hostname_size));
4006             if (port_ptr)
4007                 *port_ptr = atoi(col + 1);
4008         } else
4009             av_strlcpy(hostname, p,
4010                        FFMIN(ls + 1 - p, hostname_size));
4011     }
4012 }
4013
4014 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4015 {
4016     int i;
4017     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4018                                            '4', '5', '6', '7',
4019                                            '8', '9', 'A', 'B',
4020                                            'C', 'D', 'E', 'F' };
4021     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4022                                            '4', '5', '6', '7',
4023                                            '8', '9', 'a', 'b',
4024                                            'c', 'd', 'e', 'f' };
4025     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4026
4027     for (i = 0; i < s; i++) {
4028         buff[i * 2]     = hex_table[src[i] >> 4];
4029         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4030     }
4031
4032     return buff;
4033 }
4034
4035 int ff_hex_to_data(uint8_t *data, const char *p)
4036 {
4037     int c, len, v;
4038
4039     len = 0;
4040     v   = 1;
4041     for (;;) {
4042         p += strspn(p, SPACE_CHARS);
4043         if (*p == '\0')
4044             break;
4045         c = av_toupper((unsigned char) *p++);
4046         if (c >= '0' && c <= '9')
4047             c = c - '0';
4048         else if (c >= 'A' && c <= 'F')
4049             c = c - 'A' + 10;
4050         else
4051             break;
4052         v = (v << 4) | c;
4053         if (v & 0x100) {
4054             if (data)
4055                 data[len] = v;
4056             len++;
4057             v = 1;
4058         }
4059     }
4060     return len;
4061 }
4062
4063 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4064                          unsigned int pts_num, unsigned int pts_den)
4065 {
4066     AVRational new_tb;
4067     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4068         if (new_tb.num != pts_num)
4069             av_log(NULL, AV_LOG_DEBUG,
4070                    "st:%d removing common factor %d from timebase\n",
4071                    s->index, pts_num / new_tb.num);
4072     } else
4073         av_log(NULL, AV_LOG_WARNING,
4074                "st:%d has too large timebase, reducing\n", s->index);
4075
4076     if (new_tb.num <= 0 || new_tb.den <= 0) {
4077         av_log(NULL, AV_LOG_ERROR,
4078                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4079                new_tb.num, new_tb.den,
4080                s->index);
4081         return;
4082     }
4083     s->time_base     = new_tb;
4084     av_codec_set_pkt_timebase(s->codec, new_tb);
4085     s->pts_wrap_bits = pts_wrap_bits;
4086 }
4087
4088 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4089                         void *context)
4090 {
4091     const char *ptr = str;
4092
4093     /* Parse key=value pairs. */
4094     for (;;) {
4095         const char *key;
4096         char *dest = NULL, *dest_end;
4097         int key_len, dest_len = 0;
4098
4099         /* Skip whitespace and potential commas. */
4100         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4101             ptr++;
4102         if (!*ptr)
4103             break;
4104
4105         key = ptr;
4106
4107         if (!(ptr = strchr(key, '=')))
4108             break;
4109         ptr++;
4110         key_len = ptr - key;
4111
4112         callback_get_buf(context, key, key_len, &dest, &dest_len);
4113         dest_end = dest + dest_len - 1;
4114
4115         if (*ptr == '\"') {
4116             ptr++;
4117             while (*ptr && *ptr != '\"') {
4118                 if (*ptr == '\\') {
4119                     if (!ptr[1])
4120                         break;
4121                     if (dest && dest < dest_end)
4122                         *dest++ = ptr[1];
4123                     ptr += 2;
4124                 } else {
4125                     if (dest && dest < dest_end)
4126                         *dest++ = *ptr;
4127                     ptr++;
4128                 }
4129             }
4130             if (*ptr == '\"')
4131                 ptr++;
4132         } else {
4133             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4134                 if (dest && dest < dest_end)
4135                     *dest++ = *ptr;
4136         }
4137         if (dest)
4138             *dest = 0;
4139     }
4140 }
4141
4142 int ff_find_stream_index(AVFormatContext *s, int id)
4143 {
4144     int i;
4145     for (i = 0; i < s->nb_streams; i++)
4146         if (s->streams[i]->id == id)
4147             return i;
4148     return -1;
4149 }
4150
4151 int64_t ff_iso8601_to_unix_time(const char *datestr)
4152 {
4153     struct tm time1 = { 0 }, time2 = { 0 };
4154     const char *ret1, *ret2;
4155     ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4156     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4157     if (ret2 && !ret1)
4158         return av_timegm(&time2);
4159     else
4160         return av_timegm(&time1);
4161 }
4162
4163 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4164                          int std_compliance)
4165 {
4166     if (ofmt) {
4167         unsigned int codec_tag;
4168         if (ofmt->query_codec)
4169             return ofmt->query_codec(codec_id, std_compliance);
4170         else if (ofmt->codec_tag)
4171             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4172         else if (codec_id == ofmt->video_codec ||
4173                  codec_id == ofmt->audio_codec ||
4174                  codec_id == ofmt->subtitle_codec)
4175             return 1;
4176     }
4177     return AVERROR_PATCHWELCOME;
4178 }
4179
4180 int avformat_network_init(void)
4181 {
4182 #if CONFIG_NETWORK
4183     int ret;
4184     ff_network_inited_globally = 1;
4185     if ((ret = ff_network_init()) < 0)
4186         return ret;
4187     if ((ret = ff_tls_init()) < 0)
4188         return ret;
4189 #endif
4190     return 0;
4191 }
4192
4193 int avformat_network_deinit(void)
4194 {
4195 #if CONFIG_NETWORK
4196     ff_network_close();
4197     ff_tls_deinit();
4198     ff_network_inited_globally = 0;
4199 #endif
4200     return 0;
4201 }
4202
4203 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4204                         uint64_t channel_layout, int32_t sample_rate,
4205                         int32_t width, int32_t height)
4206 {
4207     uint32_t flags = 0;
4208     int size = 4;
4209     uint8_t *data;
4210     if (!pkt)
4211         return AVERROR(EINVAL);
4212     if (channels) {
4213         size  += 4;
4214         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4215     }
4216     if (channel_layout) {
4217         size  += 8;
4218         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4219     }
4220     if (sample_rate) {
4221         size  += 4;
4222         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4223     }
4224     if (width || height) {
4225         size  += 8;
4226         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4227     }
4228     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4229     if (!data)
4230         return AVERROR(ENOMEM);
4231     bytestream_put_le32(&data, flags);
4232     if (channels)
4233         bytestream_put_le32(&data, channels);
4234     if (channel_layout)
4235         bytestream_put_le64(&data, channel_layout);
4236     if (sample_rate)
4237         bytestream_put_le32(&data, sample_rate);
4238     if (width || height) {
4239         bytestream_put_le32(&data, width);
4240         bytestream_put_le32(&data, height);
4241     }
4242     return 0;
4243 }
4244
4245 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4246 {
4247     AVRational undef = {0, 1};
4248     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4249     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4250     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4251
4252     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4253                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4254     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4255         stream_sample_aspect_ratio = undef;
4256
4257     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4258                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4259     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4260         frame_sample_aspect_ratio = undef;
4261
4262     if (stream_sample_aspect_ratio.num)
4263         return stream_sample_aspect_ratio;
4264     else
4265         return frame_sample_aspect_ratio;
4266 }
4267
4268 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4269 {
4270     AVRational fr = st->r_frame_rate;
4271     AVRational codec_fr = st->codec->framerate;
4272     AVRational   avg_fr = st->avg_frame_rate;
4273
4274     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4275         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4276         fr = avg_fr;
4277     }
4278
4279
4280     if (st->codec->ticks_per_frame > 1) {
4281         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4282             (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))
4283             fr = codec_fr;
4284     }
4285
4286     return fr;
4287 }
4288
4289 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4290                                     const char *spec)
4291 {
4292     if (*spec <= '9' && *spec >= '0') /* opt:index */
4293         return strtol(spec, NULL, 0) == st->index;
4294     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4295              *spec == 't') { /* opt:[vasdt] */
4296         enum AVMediaType type;
4297
4298         switch (*spec++) {
4299         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4300         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4301         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4302         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4303         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4304         default:  av_assert0(0);
4305         }
4306         if (type != st->codec->codec_type)
4307             return 0;
4308         if (*spec++ == ':') { /* possibly followed by :index */
4309             int i, index = strtol(spec, NULL, 0);
4310             for (i = 0; i < s->nb_streams; i++)
4311                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4312                    return i == st->index;
4313             return 0;
4314         }
4315         return 1;
4316     } else if (*spec == 'p' && *(spec + 1) == ':') {
4317         int prog_id, i, j;
4318         char *endptr;
4319         spec += 2;
4320         prog_id = strtol(spec, &endptr, 0);
4321         for (i = 0; i < s->nb_programs; i++) {
4322             if (s->programs[i]->id != prog_id)
4323                 continue;
4324
4325             if (*endptr++ == ':') {
4326                 int stream_idx = strtol(endptr, NULL, 0);
4327                 return stream_idx >= 0 &&
4328                     stream_idx < s->programs[i]->nb_stream_indexes &&
4329                     st->index == s->programs[i]->stream_index[stream_idx];
4330             }
4331
4332             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4333                 if (st->index == s->programs[i]->stream_index[j])
4334                     return 1;
4335         }
4336         return 0;
4337     } else if (*spec == '#' ||
4338                (*spec == 'i' && *(spec + 1) == ':')) {
4339         int stream_id;
4340         char *endptr;
4341         spec += 1 + (*spec == 'i');
4342         stream_id = strtol(spec, &endptr, 0);
4343         if (!*endptr)
4344             return stream_id == st->id;
4345     } else if (*spec == 'm' && *(spec + 1) == ':') {
4346         AVDictionaryEntry *tag;
4347         char *key, *val;
4348         int ret;
4349
4350         spec += 2;
4351         val = strchr(spec, ':');
4352
4353         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4354         if (!key)
4355             return AVERROR(ENOMEM);
4356
4357         tag = av_dict_get(st->metadata, key, NULL, 0);
4358         if (tag) {
4359             if (!val || !strcmp(tag->value, val + 1))
4360                 ret = 1;
4361             else
4362                 ret = 0;
4363         } else
4364             ret = 0;
4365
4366         av_freep(&key);
4367         return ret;
4368     } else if (*spec == 'u') {
4369         AVCodecContext *avctx = st->codec;
4370         int val;
4371         switch (avctx->codec_type) {
4372         case AVMEDIA_TYPE_AUDIO:
4373             val = avctx->sample_rate && avctx->channels;
4374             if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4375                 return 0;
4376             break;
4377         case AVMEDIA_TYPE_VIDEO:
4378             val = avctx->width && avctx->height;
4379             if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4380                 return 0;
4381             break;
4382         case AVMEDIA_TYPE_UNKNOWN:
4383             val = 0;
4384             break;
4385         default:
4386             val = 1;
4387             break;
4388         }
4389         return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4390     } else if (!*spec) /* empty specifier, matches everything */
4391         return 1;
4392
4393     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4394     return AVERROR(EINVAL);
4395 }
4396
4397 int ff_generate_avci_extradata(AVStream *st)
4398 {
4399     static const uint8_t avci100_1080p_extradata[] = {
4400         // SPS
4401         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4402         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4403         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4404         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4405         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4406         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4407         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4408         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4409         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4410         // PPS
4411         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4412         0xd0
4413     };
4414     static const uint8_t avci100_1080i_extradata[] = {
4415         // SPS
4416         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4417         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4418         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4419         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4420         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4421         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4422         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4423         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4424         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4425         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4426         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4427         // PPS
4428         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4429         0xd0
4430     };
4431     static const uint8_t avci50_1080p_extradata[] = {
4432         // SPS
4433         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4434         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4435         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4436         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4437         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4438         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4439         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4440         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4441         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4442         // PPS
4443         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4444         0x11
4445     };
4446     static const uint8_t avci50_1080i_extradata[] = {
4447         // SPS
4448         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4449         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4450         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4451         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4452         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4453         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4454         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4455         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4456         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4457         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4458         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4459         // PPS
4460         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4461         0x11
4462     };
4463     static const uint8_t avci100_720p_extradata[] = {
4464         // SPS
4465         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4466         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4467         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4468         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4469         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4470         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4471         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4472         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4473         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4474         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4475         // PPS
4476         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4477         0x11
4478     };
4479     static const uint8_t avci50_720p_extradata[] = {
4480         // SPS
4481         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4482         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4483         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4484         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4485         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4486         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4487         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4488         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4489         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4490         // PPS
4491         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4492         0x11
4493     };
4494
4495     const uint8_t *data = NULL;
4496     int size            = 0;
4497
4498     if (st->codec->width == 1920) {
4499         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4500             data = avci100_1080p_extradata;
4501             size = sizeof(avci100_1080p_extradata);
4502         } else {
4503             data = avci100_1080i_extradata;
4504             size = sizeof(avci100_1080i_extradata);
4505         }
4506     } else if (st->codec->width == 1440) {
4507         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4508             data = avci50_1080p_extradata;
4509             size = sizeof(avci50_1080p_extradata);
4510         } else {
4511             data = avci50_1080i_extradata;
4512             size = sizeof(avci50_1080i_extradata);
4513         }
4514     } else if (st->codec->width == 1280) {
4515         data = avci100_720p_extradata;
4516         size = sizeof(avci100_720p_extradata);
4517     } else if (st->codec->width == 960) {
4518         data = avci50_720p_extradata;
4519         size = sizeof(avci50_720p_extradata);
4520     }
4521
4522     if (!size)
4523         return 0;
4524
4525     av_freep(&st->codec->extradata);
4526     if (ff_alloc_extradata(st->codec, size))
4527         return AVERROR(ENOMEM);
4528     memcpy(st->codec->extradata, data, size);
4529
4530     return 0;
4531 }
4532
4533 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4534                                  int *size)
4535 {
4536     int i;
4537
4538     for (i = 0; i < st->nb_side_data; i++) {
4539         if (st->side_data[i].type == type) {
4540             if (size)
4541                 *size = st->side_data[i].size;
4542             return st->side_data[i].data;
4543         }
4544     }
4545     return NULL;
4546 }
4547
4548 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4549                                  int size)
4550 {
4551     AVPacketSideData *sd, *tmp;
4552     int i;
4553     uint8_t *data = av_malloc(size);
4554
4555     if (!data)
4556         return NULL;
4557
4558     for (i = 0; i < st->nb_side_data; i++) {
4559         sd = &st->side_data[i];
4560
4561         if (sd->type == type) {
4562             av_freep(&sd->data);
4563             sd->data = data;
4564             sd->size = size;
4565             return sd->data;
4566         }
4567     }
4568
4569     tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4570     if (!tmp) {
4571         av_freep(&data);
4572         return NULL;
4573     }
4574
4575     st->side_data = tmp;
4576     st->nb_side_data++;
4577
4578     sd = &st->side_data[st->nb_side_data - 1];
4579     sd->type = type;
4580     sd->data = data;
4581     sd->size = size;
4582     return data;
4583 }