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