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