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