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

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