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_log(NULL, AV_LOG_TRACE,
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_log(NULL, AV_LOG_TRACE, "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 = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? 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 / discard %d\n", st->skip_samples, discard_padding);
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 (st->discard != AVDISCARD_ALL)
1601             score += 200;
1602
1603         if (score > best_score) {
1604             best_score = score;
1605             best_stream = i;
1606         }
1607     }
1608     return best_stream;
1609 }
1610
1611 /** Flush the frame reader. */
1612 void ff_read_frame_flush(AVFormatContext *s)
1613 {
1614     AVStream *st;
1615     int i, j;
1616
1617     flush_packet_queue(s);
1618
1619     /* Reset read state for each stream. */
1620     for (i = 0; i < s->nb_streams; i++) {
1621         st = s->streams[i];
1622
1623         if (st->parser) {
1624             av_parser_close(st->parser);
1625             st->parser = NULL;
1626         }
1627         st->last_IP_pts = AV_NOPTS_VALUE;
1628         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1629         if (st->first_dts == AV_NOPTS_VALUE)
1630             st->cur_dts = RELATIVE_TS_BASE;
1631         else
1632             /* We set the current DTS to an unspecified origin. */
1633             st->cur_dts = AV_NOPTS_VALUE;
1634
1635         st->probe_packets = MAX_PROBE_PACKETS;
1636
1637         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1638             st->pts_buffer[j] = AV_NOPTS_VALUE;
1639
1640         if (s->internal->inject_global_side_data)
1641             st->inject_global_side_data = 1;
1642     }
1643 }
1644
1645 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1646 {
1647     int i;
1648
1649     for (i = 0; i < s->nb_streams; i++) {
1650         AVStream *st = s->streams[i];
1651
1652         st->cur_dts =
1653             av_rescale(timestamp,
1654                        st->time_base.den * (int64_t) ref_st->time_base.num,
1655                        st->time_base.num * (int64_t) ref_st->time_base.den);
1656     }
1657 }
1658
1659 void ff_reduce_index(AVFormatContext *s, int stream_index)
1660 {
1661     AVStream *st             = s->streams[stream_index];
1662     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1663
1664     if ((unsigned) st->nb_index_entries >= max_entries) {
1665         int i;
1666         for (i = 0; 2 * i < st->nb_index_entries; i++)
1667             st->index_entries[i] = st->index_entries[2 * i];
1668         st->nb_index_entries = i;
1669     }
1670 }
1671
1672 int ff_add_index_entry(AVIndexEntry **index_entries,
1673                        int *nb_index_entries,
1674                        unsigned int *index_entries_allocated_size,
1675                        int64_t pos, int64_t timestamp,
1676                        int size, int distance, int flags)
1677 {
1678     AVIndexEntry *entries, *ie;
1679     int index;
1680
1681     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1682         return -1;
1683
1684     if (timestamp == AV_NOPTS_VALUE)
1685         return AVERROR(EINVAL);
1686
1687     if (size < 0 || size > 0x3FFFFFFF)
1688         return AVERROR(EINVAL);
1689
1690     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1691         timestamp -= RELATIVE_TS_BASE;
1692
1693     entries = av_fast_realloc(*index_entries,
1694                               index_entries_allocated_size,
1695                               (*nb_index_entries + 1) *
1696                               sizeof(AVIndexEntry));
1697     if (!entries)
1698         return -1;
1699
1700     *index_entries = entries;
1701
1702     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1703                                       timestamp, AVSEEK_FLAG_ANY);
1704
1705     if (index < 0) {
1706         index = (*nb_index_entries)++;
1707         ie    = &entries[index];
1708         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1709     } else {
1710         ie = &entries[index];
1711         if (ie->timestamp != timestamp) {
1712             if (ie->timestamp <= timestamp)
1713                 return -1;
1714             memmove(entries + index + 1, entries + index,
1715                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1716             (*nb_index_entries)++;
1717         } else if (ie->pos == pos && distance < ie->min_distance)
1718             // do not reduce the distance
1719             distance = ie->min_distance;
1720     }
1721
1722     ie->pos          = pos;
1723     ie->timestamp    = timestamp;
1724     ie->min_distance = distance;
1725     ie->size         = size;
1726     ie->flags        = flags;
1727
1728     return index;
1729 }
1730
1731 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1732                        int size, int distance, int flags)
1733 {
1734     timestamp = wrap_timestamp(st, timestamp);
1735     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1736                               &st->index_entries_allocated_size, pos,
1737                               timestamp, size, distance, flags);
1738 }
1739
1740 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1741                               int64_t wanted_timestamp, int flags)
1742 {
1743     int a, b, m;
1744     int64_t timestamp;
1745
1746     a = -1;
1747     b = nb_entries;
1748
1749     // Optimize appending index entries at the end.
1750     if (b && entries[b - 1].timestamp < wanted_timestamp)
1751         a = b - 1;
1752
1753     while (b - a > 1) {
1754         m         = (a + b) >> 1;
1755         timestamp = entries[m].timestamp;
1756         if (timestamp >= wanted_timestamp)
1757             b = m;
1758         if (timestamp <= wanted_timestamp)
1759             a = m;
1760     }
1761     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1762
1763     if (!(flags & AVSEEK_FLAG_ANY))
1764         while (m >= 0 && m < nb_entries &&
1765                !(entries[m].flags & AVINDEX_KEYFRAME))
1766             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1767
1768     if (m == nb_entries)
1769         return -1;
1770     return m;
1771 }
1772
1773 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1774 {
1775     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1776                                      wanted_timestamp, flags);
1777 }
1778
1779 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1780                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1781 {
1782     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1783     if (stream_index >= 0)
1784         ts = wrap_timestamp(s->streams[stream_index], ts);
1785     return ts;
1786 }
1787
1788 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1789                          int64_t target_ts, int flags)
1790 {
1791     AVInputFormat *avif = s->iformat;
1792     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1793     int64_t ts_min, ts_max, ts;
1794     int index;
1795     int64_t ret;
1796     AVStream *st;
1797
1798     if (stream_index < 0)
1799         return -1;
1800
1801     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1802
1803     ts_max =
1804     ts_min = AV_NOPTS_VALUE;
1805     pos_limit = -1; // GCC falsely says it may be uninitialized.
1806
1807     st = s->streams[stream_index];
1808     if (st->index_entries) {
1809         AVIndexEntry *e;
1810
1811         /* FIXME: Whole function must be checked for non-keyframe entries in
1812          * index case, especially read_timestamp(). */
1813         index = av_index_search_timestamp(st, target_ts,
1814                                           flags | AVSEEK_FLAG_BACKWARD);
1815         index = FFMAX(index, 0);
1816         e     = &st->index_entries[index];
1817
1818         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1819             pos_min = e->pos;
1820             ts_min  = e->timestamp;
1821             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1822                     pos_min, av_ts2str(ts_min));
1823         } else {
1824             av_assert1(index == 0);
1825         }
1826
1827         index = av_index_search_timestamp(st, target_ts,
1828                                           flags & ~AVSEEK_FLAG_BACKWARD);
1829         av_assert0(index < st->nb_index_entries);
1830         if (index >= 0) {
1831             e = &st->index_entries[index];
1832             av_assert1(e->timestamp >= target_ts);
1833             pos_max   = e->pos;
1834             ts_max    = e->timestamp;
1835             pos_limit = pos_max - e->min_distance;
1836             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1837                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1838         }
1839     }
1840
1841     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1842                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
1843     if (pos < 0)
1844         return -1;
1845
1846     /* do the seek */
1847     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1848         return ret;
1849
1850     ff_read_frame_flush(s);
1851     ff_update_cur_dts(s, st, ts);
1852
1853     return 0;
1854 }
1855
1856 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1857                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1858 {
1859     int64_t step = 1024;
1860     int64_t limit, ts_max;
1861     int64_t filesize = avio_size(s->pb);
1862     int64_t pos_max  = filesize - 1;
1863     do {
1864         limit = pos_max;
1865         pos_max = FFMAX(0, (pos_max) - step);
1866         ts_max  = ff_read_timestamp(s, stream_index,
1867                                     &pos_max, limit, read_timestamp);
1868         step   += step;
1869     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1870     if (ts_max == AV_NOPTS_VALUE)
1871         return -1;
1872
1873     for (;;) {
1874         int64_t tmp_pos = pos_max + 1;
1875         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
1876                                             &tmp_pos, INT64_MAX, read_timestamp);
1877         if (tmp_ts == AV_NOPTS_VALUE)
1878             break;
1879         av_assert0(tmp_pos > pos_max);
1880         ts_max  = tmp_ts;
1881         pos_max = tmp_pos;
1882         if (tmp_pos >= filesize)
1883             break;
1884     }
1885
1886     if (ts)
1887         *ts = ts_max;
1888     if (pos)
1889         *pos = pos_max;
1890
1891     return 0;
1892 }
1893
1894 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1895                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1896                       int64_t ts_min, int64_t ts_max,
1897                       int flags, int64_t *ts_ret,
1898                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
1899                                                 int64_t *, int64_t))
1900 {
1901     int64_t pos, ts;
1902     int64_t start_pos;
1903     int no_change;
1904     int ret;
1905
1906     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1907
1908     if (ts_min == AV_NOPTS_VALUE) {
1909         pos_min = s->internal->data_offset;
1910         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1911         if (ts_min == AV_NOPTS_VALUE)
1912             return -1;
1913     }
1914
1915     if (ts_min >= target_ts) {
1916         *ts_ret = ts_min;
1917         return pos_min;
1918     }
1919
1920     if (ts_max == AV_NOPTS_VALUE) {
1921         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1922             return ret;
1923         pos_limit = pos_max;
1924     }
1925
1926     if (ts_max <= target_ts) {
1927         *ts_ret = ts_max;
1928         return pos_max;
1929     }
1930
1931     av_assert0(ts_min < ts_max);
1932
1933     no_change = 0;
1934     while (pos_min < pos_limit) {
1935         av_log(s, AV_LOG_TRACE,
1936                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1937                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1938         av_assert0(pos_limit <= pos_max);
1939
1940         if (no_change == 0) {
1941             int64_t approximate_keyframe_distance = pos_max - pos_limit;
1942             // interpolate position (better than dichotomy)
1943             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1944                              ts_max - ts_min) +
1945                   pos_min - approximate_keyframe_distance;
1946         } else if (no_change == 1) {
1947             // bisection if interpolation did not change min / max pos last time
1948             pos = (pos_min + pos_limit) >> 1;
1949         } else {
1950             /* linear search if bisection failed, can only happen if there
1951              * are very few or no keyframes between min/max */
1952             pos = pos_min;
1953         }
1954         if (pos <= pos_min)
1955             pos = pos_min + 1;
1956         else if (pos > pos_limit)
1957             pos = pos_limit;
1958         start_pos = pos;
1959
1960         // May pass pos_limit instead of -1.
1961         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1962         if (pos == pos_max)
1963             no_change++;
1964         else
1965             no_change = 0;
1966         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1967                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1968                 pos_min, pos, pos_max,
1969                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1970                 pos_limit, start_pos, no_change);
1971         if (ts == AV_NOPTS_VALUE) {
1972             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1973             return -1;
1974         }
1975         if (target_ts <= ts) {
1976             pos_limit = start_pos - 1;
1977             pos_max   = pos;
1978             ts_max    = ts;
1979         }
1980         if (target_ts >= ts) {
1981             pos_min = pos;
1982             ts_min  = ts;
1983         }
1984     }
1985
1986     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1987     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
1988 #if 0
1989     pos_min = pos;
1990     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1991     pos_min++;
1992     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1993     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1994             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1995 #endif
1996     *ts_ret = ts;
1997     return pos;
1998 }
1999
2000 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2001                            int64_t pos, int flags)
2002 {
2003     int64_t pos_min, pos_max;
2004
2005     pos_min = s->internal->data_offset;
2006     pos_max = avio_size(s->pb) - 1;
2007
2008     if (pos < pos_min)
2009         pos = pos_min;
2010     else if (pos > pos_max)
2011         pos = pos_max;
2012
2013     avio_seek(s->pb, pos, SEEK_SET);
2014
2015     s->io_repositioned = 1;
2016
2017     return 0;
2018 }
2019
2020 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2021                               int64_t timestamp, int flags)
2022 {
2023     int index;
2024     int64_t ret;
2025     AVStream *st;
2026     AVIndexEntry *ie;
2027
2028     st = s->streams[stream_index];
2029
2030     index = av_index_search_timestamp(st, timestamp, flags);
2031
2032     if (index < 0 && st->nb_index_entries &&
2033         timestamp < st->index_entries[0].timestamp)
2034         return -1;
2035
2036     if (index < 0 || index == st->nb_index_entries - 1) {
2037         AVPacket pkt;
2038         int nonkey = 0;
2039
2040         if (st->nb_index_entries) {
2041             av_assert0(st->index_entries);
2042             ie = &st->index_entries[st->nb_index_entries - 1];
2043             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2044                 return ret;
2045             ff_update_cur_dts(s, st, ie->timestamp);
2046         } else {
2047             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2048                 return ret;
2049         }
2050         for (;;) {
2051             int read_status;
2052             do {
2053                 read_status = av_read_frame(s, &pkt);
2054             } while (read_status == AVERROR(EAGAIN));
2055             if (read_status < 0)
2056                 break;
2057             av_free_packet(&pkt);
2058             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2059                 if (pkt.flags & AV_PKT_FLAG_KEY)
2060                     break;
2061                 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2062                     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);
2063                     break;
2064                 }
2065             }
2066         }
2067         index = av_index_search_timestamp(st, timestamp, flags);
2068     }
2069     if (index < 0)
2070         return -1;
2071
2072     ff_read_frame_flush(s);
2073     if (s->iformat->read_seek)
2074         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2075             return 0;
2076     ie = &st->index_entries[index];
2077     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2078         return ret;
2079     ff_update_cur_dts(s, st, ie->timestamp);
2080
2081     return 0;
2082 }
2083
2084 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2085                                int64_t timestamp, int flags)
2086 {
2087     int ret;
2088     AVStream *st;
2089
2090     if (flags & AVSEEK_FLAG_BYTE) {
2091         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2092             return -1;
2093         ff_read_frame_flush(s);
2094         return seek_frame_byte(s, stream_index, timestamp, flags);
2095     }
2096
2097     if (stream_index < 0) {
2098         stream_index = av_find_default_stream_index(s);
2099         if (stream_index < 0)
2100             return -1;
2101
2102         st = s->streams[stream_index];
2103         /* timestamp for default must be expressed in AV_TIME_BASE units */
2104         timestamp = av_rescale(timestamp, st->time_base.den,
2105                                AV_TIME_BASE * (int64_t) st->time_base.num);
2106     }
2107
2108     /* first, we try the format specific seek */
2109     if (s->iformat->read_seek) {
2110         ff_read_frame_flush(s);
2111         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2112     } else
2113         ret = -1;
2114     if (ret >= 0)
2115         return 0;
2116
2117     if (s->iformat->read_timestamp &&
2118         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2119         ff_read_frame_flush(s);
2120         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2121     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2122         ff_read_frame_flush(s);
2123         return seek_frame_generic(s, stream_index, timestamp, flags);
2124     } else
2125         return -1;
2126 }
2127
2128 int av_seek_frame(AVFormatContext *s, int stream_index,
2129                   int64_t timestamp, int flags)
2130 {
2131     int ret;
2132
2133     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2134         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2135         if ((flags & AVSEEK_FLAG_BACKWARD))
2136             max_ts = timestamp;
2137         else
2138             min_ts = timestamp;
2139         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2140                                   flags & ~AVSEEK_FLAG_BACKWARD);
2141     }
2142
2143     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2144
2145     if (ret >= 0)
2146         ret = avformat_queue_attached_pictures(s);
2147
2148     return ret;
2149 }
2150
2151 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2152                        int64_t ts, int64_t max_ts, int flags)
2153 {
2154     if (min_ts > ts || max_ts < ts)
2155         return -1;
2156     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2157         return AVERROR(EINVAL);
2158
2159     if (s->seek2any>0)
2160         flags |= AVSEEK_FLAG_ANY;
2161     flags &= ~AVSEEK_FLAG_BACKWARD;
2162
2163     if (s->iformat->read_seek2) {
2164         int ret;
2165         ff_read_frame_flush(s);
2166
2167         if (stream_index == -1 && s->nb_streams == 1) {
2168             AVRational time_base = s->streams[0]->time_base;
2169             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2170             min_ts = av_rescale_rnd(min_ts, time_base.den,
2171                                     time_base.num * (int64_t)AV_TIME_BASE,
2172                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2173             max_ts = av_rescale_rnd(max_ts, time_base.den,
2174                                     time_base.num * (int64_t)AV_TIME_BASE,
2175                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2176         }
2177
2178         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2179                                      ts, max_ts, flags);
2180
2181         if (ret >= 0)
2182             ret = avformat_queue_attached_pictures(s);
2183         return ret;
2184     }
2185
2186     if (s->iformat->read_timestamp) {
2187         // try to seek via read_timestamp()
2188     }
2189
2190     // Fall back on old API if new is not implemented but old is.
2191     // Note the old API has somewhat different semantics.
2192     if (s->iformat->read_seek || 1) {
2193         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2194         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2195         if (ret<0 && ts != min_ts && max_ts != ts) {
2196             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2197             if (ret >= 0)
2198                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2199         }
2200         return ret;
2201     }
2202
2203     // try some generic seek like seek_frame_generic() but with new ts semantics
2204     return -1; //unreachable
2205 }
2206
2207 int avformat_flush(AVFormatContext *s)
2208 {
2209     ff_read_frame_flush(s);
2210     return 0;
2211 }
2212
2213 /*******************************************************/
2214
2215 /**
2216  * Return TRUE if the stream has accurate duration in any stream.
2217  *
2218  * @return TRUE if the stream has accurate duration for at least one component.
2219  */
2220 static int has_duration(AVFormatContext *ic)
2221 {
2222     int i;
2223     AVStream *st;
2224
2225     for (i = 0; i < ic->nb_streams; i++) {
2226         st = ic->streams[i];
2227         if (st->duration != AV_NOPTS_VALUE)
2228             return 1;
2229     }
2230     if (ic->duration != AV_NOPTS_VALUE)
2231         return 1;
2232     return 0;
2233 }
2234
2235 /**
2236  * Estimate the stream timings from the one of each components.
2237  *
2238  * Also computes the global bitrate if possible.
2239  */
2240 static void update_stream_timings(AVFormatContext *ic)
2241 {
2242     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2243     int64_t duration, duration1, filesize;
2244     int i;
2245     AVStream *st;
2246     AVProgram *p;
2247
2248     start_time = INT64_MAX;
2249     start_time_text = INT64_MAX;
2250     end_time   = INT64_MIN;
2251     duration   = INT64_MIN;
2252     for (i = 0; i < ic->nb_streams; i++) {
2253         st = ic->streams[i];
2254         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2255             start_time1 = av_rescale_q(st->start_time, st->time_base,
2256                                        AV_TIME_BASE_Q);
2257             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2258                 if (start_time1 < start_time_text)
2259                     start_time_text = start_time1;
2260             } else
2261                 start_time = FFMIN(start_time, start_time1);
2262             end_time1   = AV_NOPTS_VALUE;
2263             if (st->duration != AV_NOPTS_VALUE) {
2264                 end_time1 = start_time1 +
2265                             av_rescale_q(st->duration, st->time_base,
2266                                          AV_TIME_BASE_Q);
2267                 end_time = FFMAX(end_time, end_time1);
2268             }
2269             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2270                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2271                     p->start_time = start_time1;
2272                 if (p->end_time < end_time1)
2273                     p->end_time = end_time1;
2274             }
2275         }
2276         if (st->duration != AV_NOPTS_VALUE) {
2277             duration1 = av_rescale_q(st->duration, st->time_base,
2278                                      AV_TIME_BASE_Q);
2279             duration  = FFMAX(duration, duration1);
2280         }
2281     }
2282     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2283         start_time = start_time_text;
2284     else if (start_time > start_time_text)
2285         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2286
2287     if (start_time != INT64_MAX) {
2288         ic->start_time = start_time;
2289         if (end_time != INT64_MIN) {
2290             if (ic->nb_programs) {
2291                 for (i = 0; i < ic->nb_programs; i++) {
2292                     p = ic->programs[i];
2293                     if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2294                         duration = FFMAX(duration, p->end_time - p->start_time);
2295                 }
2296             } else
2297                 duration = FFMAX(duration, end_time - start_time);
2298         }
2299     }
2300     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2301         ic->duration = duration;
2302     }
2303     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2304         /* compute the bitrate */
2305         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2306                          (double) ic->duration;
2307         if (bitrate >= 0 && bitrate <= INT_MAX)
2308             ic->bit_rate = bitrate;
2309     }
2310 }
2311
2312 static void fill_all_stream_timings(AVFormatContext *ic)
2313 {
2314     int i;
2315     AVStream *st;
2316
2317     update_stream_timings(ic);
2318     for (i = 0; i < ic->nb_streams; i++) {
2319         st = ic->streams[i];
2320         if (st->start_time == AV_NOPTS_VALUE) {
2321             if (ic->start_time != AV_NOPTS_VALUE)
2322                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2323                                               st->time_base);
2324             if (ic->duration != AV_NOPTS_VALUE)
2325                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2326                                             st->time_base);
2327         }
2328     }
2329 }
2330
2331 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2332 {
2333     int64_t filesize, duration;
2334     int i, show_warning = 0;
2335     AVStream *st;
2336
2337     /* if bit_rate is already set, we believe it */
2338     if (ic->bit_rate <= 0) {
2339         int bit_rate = 0;
2340         for (i = 0; i < ic->nb_streams; i++) {
2341             st = ic->streams[i];
2342             if (st->codec->bit_rate > 0) {
2343                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2344                     bit_rate = 0;
2345                     break;
2346                 }
2347                 bit_rate += st->codec->bit_rate;
2348             } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2349                 // If we have a videostream with packets but without a bitrate
2350                 // then consider the sum not known
2351                 bit_rate = 0;
2352                 break;
2353             }
2354         }
2355         ic->bit_rate = bit_rate;
2356     }
2357
2358     /* if duration is already set, we believe it */
2359     if (ic->duration == AV_NOPTS_VALUE &&
2360         ic->bit_rate != 0) {
2361         filesize = ic->pb ? avio_size(ic->pb) : 0;
2362         if (filesize > ic->internal->data_offset) {
2363             filesize -= ic->internal->data_offset;
2364             for (i = 0; i < ic->nb_streams; i++) {
2365                 st      = ic->streams[i];
2366                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2367                     && st->duration == AV_NOPTS_VALUE) {
2368                     duration = av_rescale(8 * filesize, st->time_base.den,
2369                                           ic->bit_rate *
2370                                           (int64_t) st->time_base.num);
2371                     st->duration = duration;
2372                     show_warning = 1;
2373                 }
2374             }
2375         }
2376     }
2377     if (show_warning)
2378         av_log(ic, AV_LOG_WARNING,
2379                "Estimating duration from bitrate, this may be inaccurate\n");
2380 }
2381
2382 #define DURATION_MAX_READ_SIZE 250000LL
2383 #define DURATION_MAX_RETRY 4
2384
2385 /* only usable for MPEG-PS streams */
2386 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2387 {
2388     AVPacket pkt1, *pkt = &pkt1;
2389     AVStream *st;
2390     int num, den, read_size, i, ret;
2391     int found_duration = 0;
2392     int is_end;
2393     int64_t filesize, offset, duration;
2394     int retry = 0;
2395
2396     /* flush packet queue */
2397     flush_packet_queue(ic);
2398
2399     for (i = 0; i < ic->nb_streams; i++) {
2400         st = ic->streams[i];
2401         if (st->start_time == AV_NOPTS_VALUE &&
2402             st->first_dts == AV_NOPTS_VALUE &&
2403             st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2404             av_log(st->codec, AV_LOG_WARNING,
2405                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2406
2407         if (st->parser) {
2408             av_parser_close(st->parser);
2409             st->parser = NULL;
2410         }
2411     }
2412
2413     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2414     /* estimate the end time (duration) */
2415     /* XXX: may need to support wrapping */
2416     filesize = ic->pb ? avio_size(ic->pb) : 0;
2417     do {
2418         is_end = found_duration;
2419         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2420         if (offset < 0)
2421             offset = 0;
2422
2423         avio_seek(ic->pb, offset, SEEK_SET);
2424         read_size = 0;
2425         for (;;) {
2426             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2427                 break;
2428
2429             do {
2430                 ret = ff_read_packet(ic, pkt);
2431             } while (ret == AVERROR(EAGAIN));
2432             if (ret != 0)
2433                 break;
2434             read_size += pkt->size;
2435             st         = ic->streams[pkt->stream_index];
2436             if (pkt->pts != AV_NOPTS_VALUE &&
2437                 (st->start_time != AV_NOPTS_VALUE ||
2438                  st->first_dts  != AV_NOPTS_VALUE)) {
2439                 if (pkt->duration == 0) {
2440                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2441                     if (den && num) {
2442                         pkt->duration = av_rescale_rnd(1,
2443                                            num * (int64_t) st->time_base.den,
2444                                            den * (int64_t) st->time_base.num,
2445                                            AV_ROUND_DOWN);
2446                     }
2447                 }
2448                 duration = pkt->pts + pkt->duration;
2449                 found_duration = 1;
2450                 if (st->start_time != AV_NOPTS_VALUE)
2451                     duration -= st->start_time;
2452                 else
2453                     duration -= st->first_dts;
2454                 if (duration > 0) {
2455                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2456                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2457                         st->duration = duration;
2458                     st->info->last_duration = duration;
2459                 }
2460             }
2461             av_free_packet(pkt);
2462         }
2463
2464         /* check if all audio/video streams have valid duration */
2465         if (!is_end) {
2466             is_end = 1;
2467             for (i = 0; i < ic->nb_streams; i++) {
2468                 st = ic->streams[i];
2469                 switch (st->codec->codec_type) {
2470                     case AVMEDIA_TYPE_VIDEO:
2471                     case AVMEDIA_TYPE_AUDIO:
2472                         if (st->duration == AV_NOPTS_VALUE)
2473                             is_end = 0;
2474                 }
2475             }
2476         }
2477     } while (!is_end &&
2478              offset &&
2479              ++retry <= DURATION_MAX_RETRY);
2480
2481     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2482
2483     /* warn about audio/video streams which duration could not be estimated */
2484     for (i = 0; i < ic->nb_streams; i++) {
2485         st = ic->streams[i];
2486         if (st->duration == AV_NOPTS_VALUE) {
2487             switch (st->codec->codec_type) {
2488             case AVMEDIA_TYPE_VIDEO:
2489             case AVMEDIA_TYPE_AUDIO:
2490                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2491                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2492                 } else
2493                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2494             }
2495         }
2496     }
2497     fill_all_stream_timings(ic);
2498
2499     avio_seek(ic->pb, old_offset, SEEK_SET);
2500     for (i = 0; i < ic->nb_streams; i++) {
2501         int j;
2502
2503         st              = ic->streams[i];
2504         st->cur_dts     = st->first_dts;
2505         st->last_IP_pts = AV_NOPTS_VALUE;
2506         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2507         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2508             st->pts_buffer[j] = AV_NOPTS_VALUE;
2509     }
2510 }
2511
2512 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2513 {
2514     int64_t file_size;
2515
2516     /* get the file size, if possible */
2517     if (ic->iformat->flags & AVFMT_NOFILE) {
2518         file_size = 0;
2519     } else {
2520         file_size = avio_size(ic->pb);
2521         file_size = FFMAX(0, file_size);
2522     }
2523
2524     if ((!strcmp(ic->iformat->name, "mpeg") ||
2525          !strcmp(ic->iformat->name, "mpegts")) &&
2526         file_size && ic->pb->seekable) {
2527         /* get accurate estimate from the PTSes */
2528         estimate_timings_from_pts(ic, old_offset);
2529         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2530     } else if (has_duration(ic)) {
2531         /* at least one component has timings - we use them for all
2532          * the components */
2533         fill_all_stream_timings(ic);
2534         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2535     } else {
2536         /* less precise: use bitrate info */
2537         estimate_timings_from_bit_rate(ic);
2538         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2539     }
2540     update_stream_timings(ic);
2541
2542     {
2543         int i;
2544         AVStream av_unused *st;
2545         for (i = 0; i < ic->nb_streams; i++) {
2546             st = ic->streams[i];
2547             av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2548                     (double) st->start_time / AV_TIME_BASE,
2549                     (double) st->duration   / AV_TIME_BASE);
2550         }
2551         av_log(ic, AV_LOG_TRACE,
2552                 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2553                 (double) ic->start_time / AV_TIME_BASE,
2554                 (double) ic->duration   / AV_TIME_BASE,
2555                 ic->bit_rate / 1000);
2556     }
2557 }
2558
2559 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2560 {
2561     AVCodecContext *avctx = st->codec;
2562
2563 #define FAIL(errmsg) do {                                         \
2564         if (errmsg_ptr)                                           \
2565             *errmsg_ptr = errmsg;                                 \
2566         return 0;                                                 \
2567     } while (0)
2568
2569     if (   avctx->codec_id == AV_CODEC_ID_NONE
2570         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2571         FAIL("unknown codec");
2572     switch (avctx->codec_type) {
2573     case AVMEDIA_TYPE_AUDIO:
2574         if (!avctx->frame_size && determinable_frame_size(avctx))
2575             FAIL("unspecified frame size");
2576         if (st->info->found_decoder >= 0 &&
2577             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2578             FAIL("unspecified sample format");
2579         if (!avctx->sample_rate)
2580             FAIL("unspecified sample rate");
2581         if (!avctx->channels)
2582             FAIL("unspecified number of channels");
2583         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2584             FAIL("no decodable DTS frames");
2585         break;
2586     case AVMEDIA_TYPE_VIDEO:
2587         if (!avctx->width)
2588             FAIL("unspecified size");
2589         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2590             FAIL("unspecified pixel format");
2591         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2592             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2593                 FAIL("no frame in rv30/40 and no sar");
2594         break;
2595     case AVMEDIA_TYPE_SUBTITLE:
2596         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2597             FAIL("unspecified size");
2598         break;
2599     case AVMEDIA_TYPE_DATA:
2600         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2601     }
2602
2603     return 1;
2604 }
2605
2606 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2607 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2608                             AVDictionary **options)
2609 {
2610     const AVCodec *codec;
2611     int got_picture = 1, ret = 0;
2612     AVFrame *frame = av_frame_alloc();
2613     AVSubtitle subtitle;
2614     AVPacket pkt = *avpkt;
2615
2616     if (!frame)
2617         return AVERROR(ENOMEM);
2618
2619     if (!avcodec_is_open(st->codec) &&
2620         st->info->found_decoder <= 0 &&
2621         (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2622         AVDictionary *thread_opt = NULL;
2623
2624         codec = find_decoder(s, st, st->codec->codec_id);
2625
2626         if (!codec) {
2627             st->info->found_decoder = -st->codec->codec_id;
2628             ret                     = -1;
2629             goto fail;
2630         }
2631
2632         /* Force thread count to 1 since the H.264 decoder will not extract
2633          * SPS and PPS to extradata during multi-threaded decoding. */
2634         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2635         if (s->codec_whitelist)
2636             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2637         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2638         if (!options)
2639             av_dict_free(&thread_opt);
2640         if (ret < 0) {
2641             st->info->found_decoder = -st->codec->codec_id;
2642             goto fail;
2643         }
2644         st->info->found_decoder = 1;
2645     } else if (!st->info->found_decoder)
2646         st->info->found_decoder = 1;
2647
2648     if (st->info->found_decoder < 0) {
2649         ret = -1;
2650         goto fail;
2651     }
2652
2653     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2654            ret >= 0 &&
2655            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2656             (!st->codec_info_nb_frames &&
2657              st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2658         got_picture = 0;
2659         switch (st->codec->codec_type) {
2660         case AVMEDIA_TYPE_VIDEO:
2661             ret = avcodec_decode_video2(st->codec, frame,
2662                                         &got_picture, &pkt);
2663             break;
2664         case AVMEDIA_TYPE_AUDIO:
2665             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2666             break;
2667         case AVMEDIA_TYPE_SUBTITLE:
2668             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2669                                            &got_picture, &pkt);
2670             ret = pkt.size;
2671             break;
2672         default:
2673             break;
2674         }
2675         if (ret >= 0) {
2676             if (got_picture)
2677                 st->nb_decoded_frames++;
2678             pkt.data += ret;
2679             pkt.size -= ret;
2680             ret       = got_picture;
2681         }
2682     }
2683
2684     if (!pkt.data && !got_picture)
2685         ret = -1;
2686
2687 fail:
2688     av_frame_free(&frame);
2689     return ret;
2690 }
2691
2692 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2693 {
2694     while (tags->id != AV_CODEC_ID_NONE) {
2695         if (tags->id == id)
2696             return tags->tag;
2697         tags++;
2698     }
2699     return 0;
2700 }
2701
2702 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2703 {
2704     int i;
2705     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2706         if (tag == tags[i].tag)
2707             return tags[i].id;
2708     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2709         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2710             return tags[i].id;
2711     return AV_CODEC_ID_NONE;
2712 }
2713
2714 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2715 {
2716     if (flt) {
2717         switch (bps) {
2718         case 32:
2719             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2720         case 64:
2721             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2722         default:
2723             return AV_CODEC_ID_NONE;
2724         }
2725     } else {
2726         bps  += 7;
2727         bps >>= 3;
2728         if (sflags & (1 << (bps - 1))) {
2729             switch (bps) {
2730             case 1:
2731                 return AV_CODEC_ID_PCM_S8;
2732             case 2:
2733                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2734             case 3:
2735                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2736             case 4:
2737                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2738             default:
2739                 return AV_CODEC_ID_NONE;
2740             }
2741         } else {
2742             switch (bps) {
2743             case 1:
2744                 return AV_CODEC_ID_PCM_U8;
2745             case 2:
2746                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2747             case 3:
2748                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2749             case 4:
2750                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2751             default:
2752                 return AV_CODEC_ID_NONE;
2753             }
2754         }
2755     }
2756 }
2757
2758 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2759 {
2760     unsigned int tag;
2761     if (!av_codec_get_tag2(tags, id, &tag))
2762         return 0;
2763     return tag;
2764 }
2765
2766 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2767                       unsigned int *tag)
2768 {
2769     int i;
2770     for (i = 0; tags && tags[i]; i++) {
2771         const AVCodecTag *codec_tags = tags[i];
2772         while (codec_tags->id != AV_CODEC_ID_NONE) {
2773             if (codec_tags->id == id) {
2774                 *tag = codec_tags->tag;
2775                 return 1;
2776             }
2777             codec_tags++;
2778         }
2779     }
2780     return 0;
2781 }
2782
2783 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2784 {
2785     int i;
2786     for (i = 0; tags && tags[i]; i++) {
2787         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2788         if (id != AV_CODEC_ID_NONE)
2789             return id;
2790     }
2791     return AV_CODEC_ID_NONE;
2792 }
2793
2794 static void compute_chapters_end(AVFormatContext *s)
2795 {
2796     unsigned int i, j;
2797     int64_t max_time = s->duration +
2798                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2799
2800     for (i = 0; i < s->nb_chapters; i++)
2801         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2802             AVChapter *ch = s->chapters[i];
2803             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2804                                                   ch->time_base)
2805                                    : INT64_MAX;
2806
2807             for (j = 0; j < s->nb_chapters; j++) {
2808                 AVChapter *ch1     = s->chapters[j];
2809                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2810                                                   ch->time_base);
2811                 if (j != i && next_start > ch->start && next_start < end)
2812                     end = next_start;
2813             }
2814             ch->end = (end == INT64_MAX) ? ch->start : end;
2815         }
2816 }
2817
2818 static int get_std_framerate(int i)
2819 {
2820     if (i < 30*12)
2821         return (i + 1) * 1001;
2822     i -= 30*12;
2823
2824     if (i < 7)
2825         return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2826
2827     i -= 7;
2828
2829     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2830 }
2831
2832 /* Is the time base unreliable?
2833  * This is a heuristic to balance between quick acceptance of the values in
2834  * the headers vs. some extra checks.
2835  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2836  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2837  * And there are "variable" fps files this needs to detect as well. */
2838 static int tb_unreliable(AVCodecContext *c)
2839 {
2840     if (c->time_base.den >= 101LL * c->time_base.num ||
2841         c->time_base.den <    5LL * c->time_base.num ||
2842         // c->codec_tag == AV_RL32("DIVX") ||
2843         // c->codec_tag == AV_RL32("XVID") ||
2844         c->codec_tag == AV_RL32("mp4v") ||
2845         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2846         c->codec_id == AV_CODEC_ID_GIF ||
2847         c->codec_id == AV_CODEC_ID_HEVC ||
2848         c->codec_id == AV_CODEC_ID_H264)
2849         return 1;
2850     return 0;
2851 }
2852
2853 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2854 {
2855     int ret;
2856
2857     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2858         avctx->extradata = NULL;
2859         avctx->extradata_size = 0;
2860         return AVERROR(EINVAL);
2861     }
2862     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2863     if (avctx->extradata) {
2864         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2865         avctx->extradata_size = size;
2866         ret = 0;
2867     } else {
2868         avctx->extradata_size = 0;
2869         ret = AVERROR(ENOMEM);
2870     }
2871     return ret;
2872 }
2873
2874 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2875 {
2876     int ret = ff_alloc_extradata(avctx, size);
2877     if (ret < 0)
2878         return ret;
2879     ret = avio_read(pb, avctx->extradata, size);
2880     if (ret != size) {
2881         av_freep(&avctx->extradata);
2882         avctx->extradata_size = 0;
2883         av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2884         return ret < 0 ? ret : AVERROR_INVALIDDATA;
2885     }
2886
2887     return ret;
2888 }
2889
2890 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2891 {
2892     int i, j;
2893     int64_t last = st->info->last_dts;
2894
2895     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2896        && ts - (uint64_t)last < INT64_MAX) {
2897         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2898         int64_t duration = ts - last;
2899
2900         if (!st->info->duration_error)
2901             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2902         if (!st->info->duration_error)
2903             return AVERROR(ENOMEM);
2904
2905 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2906 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2907         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2908             if (st->info->duration_error[0][1][i] < 1e10) {
2909                 int framerate = get_std_framerate(i);
2910                 double sdts = dts*framerate/(1001*12);
2911                 for (j= 0; j<2; j++) {
2912                     int64_t ticks = llrint(sdts+j*0.5);
2913                     double error= sdts - ticks + j*0.5;
2914                     st->info->duration_error[j][0][i] += error;
2915                     st->info->duration_error[j][1][i] += error*error;
2916                 }
2917             }
2918         }
2919         st->info->duration_count++;
2920         st->info->rfps_duration_sum += duration;
2921
2922         if (st->info->duration_count % 10 == 0) {
2923             int n = st->info->duration_count;
2924             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2925                 if (st->info->duration_error[0][1][i] < 1e10) {
2926                     double a0     = st->info->duration_error[0][0][i] / n;
2927                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2928                     double a1     = st->info->duration_error[1][0][i] / n;
2929                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2930                     if (error0 > 0.04 && error1 > 0.04) {
2931                         st->info->duration_error[0][1][i] = 2e10;
2932                         st->info->duration_error[1][1][i] = 2e10;
2933                     }
2934                 }
2935             }
2936         }
2937
2938         // ignore the first 4 values, they might have some random jitter
2939         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2940             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2941     }
2942     if (ts != AV_NOPTS_VALUE)
2943         st->info->last_dts = ts;
2944
2945     return 0;
2946 }
2947
2948 void ff_rfps_calculate(AVFormatContext *ic)
2949 {
2950     int i, j;
2951
2952     for (i = 0; i < ic->nb_streams; i++) {
2953         AVStream *st = ic->streams[i];
2954
2955         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2956             continue;
2957         // the check for tb_unreliable() is not completely correct, since this is not about handling
2958         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2959         // ipmovie.c produces.
2960         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)
2961             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);
2962         if (st->info->duration_count>1 && !st->r_frame_rate.num
2963             && tb_unreliable(st->codec)) {
2964             int num = 0;
2965             double best_error= 0.01;
2966             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2967
2968             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2969                 int k;
2970
2971                 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2972                     continue;
2973                 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2974                     continue;
2975
2976                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2977                     continue;
2978
2979                 for (k= 0; k<2; k++) {
2980                     int n = st->info->duration_count;
2981                     double a= st->info->duration_error[k][0][j] / n;
2982                     double error= st->info->duration_error[k][1][j]/n - a*a;
2983
2984                     if (error < best_error && best_error> 0.000000001) {
2985                         best_error= error;
2986                         num = get_std_framerate(j);
2987                     }
2988                     if (error < 0.02)
2989                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2990                 }
2991             }
2992             // do not increase frame rate by more than 1 % in order to match a standard rate.
2993             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2994                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2995         }
2996         if (   !st->avg_frame_rate.num
2997             && st->r_frame_rate.num && st->info->rfps_duration_sum
2998             && st->info->codec_info_duration <= 0
2999             && st->info->duration_count > 2
3000             && 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
3001             ) {
3002             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3003             st->avg_frame_rate = st->r_frame_rate;
3004         }
3005
3006         av_freep(&st->info->duration_error);
3007         st->info->last_dts = AV_NOPTS_VALUE;
3008         st->info->duration_count = 0;
3009         st->info->rfps_duration_sum = 0;
3010     }
3011 }
3012
3013 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3014 {
3015     int i, count, ret = 0, j;
3016     int64_t read_size;
3017     AVStream *st;
3018     AVPacket pkt1, *pkt;
3019     int64_t old_offset  = avio_tell(ic->pb);
3020     // new streams might appear, no options for those
3021     int orig_nb_streams = ic->nb_streams;
3022     int flush_codecs;
3023     int64_t max_analyze_duration = ic->max_analyze_duration2;
3024     int64_t max_stream_analyze_duration;
3025     int64_t probesize = ic->probesize2;
3026
3027     if (!max_analyze_duration)
3028         max_analyze_duration = ic->max_analyze_duration;
3029     if (ic->probesize)
3030         probesize = ic->probesize;
3031     flush_codecs = probesize > 0;
3032
3033     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3034
3035     max_stream_analyze_duration = max_analyze_duration;
3036     if (!max_analyze_duration) {
3037         max_stream_analyze_duration =
3038         max_analyze_duration        = 5*AV_TIME_BASE;
3039         if (!strcmp(ic->iformat->name, "flv"))
3040             max_stream_analyze_duration = 30*AV_TIME_BASE;
3041     }
3042
3043     if (ic->pb)
3044         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3045                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3046
3047     for (i = 0; i < ic->nb_streams; i++) {
3048         const AVCodec *codec;
3049         AVDictionary *thread_opt = NULL;
3050         st = ic->streams[i];
3051
3052         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3053             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3054 /*            if (!st->time_base.num)
3055                 st->time_base = */
3056             if (!st->codec->time_base.num)
3057                 st->codec->time_base = st->time_base;
3058         }
3059         // only for the split stuff
3060         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3061             st->parser = av_parser_init(st->codec->codec_id);
3062             if (st->parser) {
3063                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3064                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3065                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3066                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3067                 }
3068             } else if (st->need_parsing) {
3069                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3070                        "%s, packets or times may be invalid.\n",
3071                        avcodec_get_name(st->codec->codec_id));
3072             }
3073         }
3074         codec = find_decoder(ic, st, st->codec->codec_id);
3075
3076         /* Force thread count to 1 since the H.264 decoder will not extract
3077          * SPS and PPS to extradata during multi-threaded decoding. */
3078         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3079
3080         if (ic->codec_whitelist)
3081             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3082
3083         /* Ensure that subtitle_header is properly set. */
3084         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3085             && codec && !st->codec->codec) {
3086             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3087                 av_log(ic, AV_LOG_WARNING,
3088                        "Failed to open codec in av_find_stream_info\n");
3089         }
3090
3091         // Try to just open decoders, in case this is enough to get parameters.
3092         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3093             if (codec && !st->codec->codec)
3094                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3095                     av_log(ic, AV_LOG_WARNING,
3096                            "Failed to open codec in av_find_stream_info\n");
3097         }
3098         if (!options)
3099             av_dict_free(&thread_opt);
3100     }
3101
3102     for (i = 0; i < ic->nb_streams; i++) {
3103 #if FF_API_R_FRAME_RATE
3104         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3105 #endif
3106         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3107         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3108     }
3109
3110     count     = 0;
3111     read_size = 0;
3112     for (;;) {
3113         int analyzed_all_streams;
3114         if (ff_check_interrupt(&ic->interrupt_callback)) {
3115             ret = AVERROR_EXIT;
3116             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3117             break;
3118         }
3119
3120         /* check if one codec still needs to be handled */
3121         for (i = 0; i < ic->nb_streams; i++) {
3122             int fps_analyze_framecount = 20;
3123
3124             st = ic->streams[i];
3125             if (!has_codec_parameters(st, NULL))
3126                 break;
3127             /* If the timebase is coarse (like the usual millisecond precision
3128              * of mkv), we need to analyze more frames to reliably arrive at
3129              * the correct fps. */
3130             if (av_q2d(st->time_base) > 0.0005)
3131                 fps_analyze_framecount *= 2;
3132             if (!tb_unreliable(st->codec))
3133                 fps_analyze_framecount = 0;
3134             if (ic->fps_probe_size >= 0)
3135                 fps_analyze_framecount = ic->fps_probe_size;
3136             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3137                 fps_analyze_framecount = 0;
3138             /* variable fps and no guess at the real fps */
3139             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3140                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3141                 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3142                     st->info->codec_info_duration_fields/2 :
3143                     st->info->duration_count;
3144                 if (count < fps_analyze_framecount)
3145                     break;
3146             }
3147             if (st->parser && st->parser->parser->split &&
3148                 !st->codec->extradata)
3149                 break;
3150             if (st->first_dts == AV_NOPTS_VALUE &&
3151                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3152                 st->codec_info_nb_frames < ic->max_ts_probe &&
3153                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3154                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3155                 break;
3156         }
3157         analyzed_all_streams = 0;
3158         if (i == ic->nb_streams) {
3159             analyzed_all_streams = 1;
3160             /* NOTE: If the format has no header, then we need to read some
3161              * packets to get most of the streams, so we cannot stop here. */
3162             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3163                 /* If we found the info for all the codecs, we can stop. */
3164                 ret = count;
3165                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3166                 flush_codecs = 0;
3167                 break;
3168             }
3169         }
3170         /* We did not get all the codec info, but we read too much data. */
3171         if (read_size >= probesize) {
3172             ret = count;
3173             av_log(ic, AV_LOG_DEBUG,
3174                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3175             for (i = 0; i < ic->nb_streams; i++)
3176                 if (!ic->streams[i]->r_frame_rate.num &&
3177                     ic->streams[i]->info->duration_count <= 1 &&
3178                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3179                     strcmp(ic->iformat->name, "image2"))
3180                     av_log(ic, AV_LOG_WARNING,
3181                            "Stream #%d: not enough frames to estimate rate; "
3182                            "consider increasing probesize\n", i);
3183             break;
3184         }
3185
3186         /* NOTE: A new stream can be added there if no header in file
3187          * (AVFMTCTX_NOHEADER). */
3188         ret = read_frame_internal(ic, &pkt1);
3189         if (ret == AVERROR(EAGAIN))
3190             continue;
3191
3192         if (ret < 0) {
3193             /* EOF or error*/
3194             break;
3195         }
3196
3197         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3198             free_packet_buffer(&ic->internal->packet_buffer,
3199                                &ic->internal->packet_buffer_end);
3200         {
3201             pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3202                                 &ic->internal->packet_buffer_end);
3203             if (!pkt) {
3204                 ret = AVERROR(ENOMEM);
3205                 goto find_stream_info_err;
3206             }
3207             if ((ret = av_dup_packet(pkt)) < 0)
3208                 goto find_stream_info_err;
3209         }
3210
3211         st = ic->streams[pkt->stream_index];
3212         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3213             read_size += pkt->size;
3214
3215         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3216             /* check for non-increasing dts */
3217             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3218                 st->info->fps_last_dts >= pkt->dts) {
3219                 av_log(ic, AV_LOG_DEBUG,
3220                        "Non-increasing DTS in stream %d: packet %d with DTS "
3221                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3222                        st->index, st->info->fps_last_dts_idx,
3223                        st->info->fps_last_dts, st->codec_info_nb_frames,
3224                        pkt->dts);
3225                 st->info->fps_first_dts =
3226                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3227             }
3228             /* Check for a discontinuity in dts. If the difference in dts
3229              * is more than 1000 times the average packet duration in the
3230              * sequence, we treat it as a discontinuity. */
3231             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3232                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3233                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3234                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3235                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3236                 av_log(ic, AV_LOG_WARNING,
3237                        "DTS discontinuity in stream %d: packet %d with DTS "
3238                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3239                        st->index, st->info->fps_last_dts_idx,
3240                        st->info->fps_last_dts, st->codec_info_nb_frames,
3241                        pkt->dts);
3242                 st->info->fps_first_dts =
3243                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3244             }
3245
3246             /* update stored dts values */
3247             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3248                 st->info->fps_first_dts     = pkt->dts;
3249                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3250             }
3251             st->info->fps_last_dts     = pkt->dts;
3252             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3253         }
3254         if (st->codec_info_nb_frames>1) {
3255             int64_t t = 0;
3256
3257             if (st->time_base.den > 0)
3258                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3259             if (st->avg_frame_rate.num > 0)
3260                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3261
3262             if (   t == 0
3263                 && st->codec_info_nb_frames>30
3264                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3265                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3266                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3267
3268             if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3269                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3270                        max_analyze_duration,
3271                        t);
3272                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3273                     av_packet_unref(pkt);
3274                 break;
3275             }
3276             if (pkt->duration) {
3277                 st->info->codec_info_duration        += pkt->duration;
3278                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3279             }
3280         }
3281 #if FF_API_R_FRAME_RATE
3282         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3283             ff_rfps_add_frame(ic, st, pkt->dts);
3284 #endif
3285         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3286             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3287             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3288                 if (ff_alloc_extradata(st->codec, i))
3289                     return AVERROR(ENOMEM);
3290                 memcpy(st->codec->extradata, pkt->data,
3291                        st->codec->extradata_size);
3292             }
3293         }
3294
3295         /* If still no information, we try to open the codec and to
3296          * decompress the frame. We try to avoid that in most cases as
3297          * it takes longer and uses more memory. For MPEG-4, we need to
3298          * decompress for QuickTime.
3299          *
3300          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3301          * least one frame of codec data, this makes sure the codec initializes
3302          * the channel configuration and does not only trust the values from
3303          * the container. */
3304         try_decode_frame(ic, st, pkt,
3305                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3306
3307         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3308             av_packet_unref(pkt);
3309
3310         st->codec_info_nb_frames++;
3311         count++;
3312     }
3313
3314     if (flush_codecs) {
3315         AVPacket empty_pkt = { 0 };
3316         int err = 0;
3317         av_init_packet(&empty_pkt);
3318
3319         for (i = 0; i < ic->nb_streams; i++) {
3320
3321             st = ic->streams[i];
3322
3323             /* flush the decoders */
3324             if (st->info->found_decoder == 1) {
3325                 do {
3326                     err = try_decode_frame(ic, st, &empty_pkt,
3327                                             (options && i < orig_nb_streams)
3328                                             ? &options[i] : NULL);
3329                 } while (err > 0 && !has_codec_parameters(st, NULL));
3330
3331                 if (err < 0) {
3332                     av_log(ic, AV_LOG_INFO,
3333                         "decoding for stream %d failed\n", st->index);
3334                 }
3335             }
3336         }
3337     }
3338
3339     // close codecs which were opened in try_decode_frame()
3340     for (i = 0; i < ic->nb_streams; i++) {
3341         st = ic->streams[i];
3342         avcodec_close(st->codec);
3343     }
3344
3345     ff_rfps_calculate(ic);
3346
3347     for (i = 0; i < ic->nb_streams; i++) {
3348         st = ic->streams[i];
3349         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3350             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3351                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3352                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3353                     st->codec->codec_tag= tag;
3354             }
3355
3356             /* estimate average framerate if not set by demuxer */
3357             if (st->info->codec_info_duration_fields &&
3358                 !st->avg_frame_rate.num &&
3359                 st->info->codec_info_duration) {
3360                 int best_fps      = 0;
3361                 double best_error = 0.01;
3362
3363                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3364                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3365                     st->info->codec_info_duration        < 0)
3366                     continue;
3367                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3368                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3369                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3370
3371                 /* Round guessed framerate to a "standard" framerate if it's
3372                  * within 1% of the original estimate. */
3373                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3374                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3375                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3376                                               av_q2d(std_fps) - 1);
3377
3378                     if (error < best_error) {
3379                         best_error = error;
3380                         best_fps   = std_fps.num;
3381                     }
3382                 }
3383                 if (best_fps)
3384                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3385                               best_fps, 12 * 1001, INT_MAX);
3386             }
3387
3388             if (!st->r_frame_rate.num) {
3389                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3390                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3391                     st->r_frame_rate.num = st->codec->time_base.den;
3392                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3393                 } else {
3394                     st->r_frame_rate.num = st->time_base.den;
3395                     st->r_frame_rate.den = st->time_base.num;
3396                 }
3397             }
3398             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3399                 AVRational hw_ratio = { st->codec->height, st->codec->width };
3400                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3401                                                    hw_ratio);
3402             }
3403         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3404             if (!st->codec->bits_per_coded_sample)
3405                 st->codec->bits_per_coded_sample =
3406                     av_get_bits_per_sample(st->codec->codec_id);
3407             // set stream disposition based on audio service type
3408             switch (st->codec->audio_service_type) {
3409             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3410                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3411                 break;
3412             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3413                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3414                 break;
3415             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3416                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3417                 break;
3418             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3419                 st->disposition = AV_DISPOSITION_COMMENT;
3420                 break;
3421             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3422                 st->disposition = AV_DISPOSITION_KARAOKE;
3423                 break;
3424             }
3425         }
3426     }
3427
3428     if (probesize)
3429     estimate_timings(ic, old_offset);
3430
3431     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3432
3433     if (ret >= 0 && ic->nb_streams)
3434         /* We could not have all the codec parameters before EOF. */
3435         ret = -1;
3436     for (i = 0; i < ic->nb_streams; i++) {
3437         const char *errmsg;
3438         st = ic->streams[i];
3439         if (!has_codec_parameters(st, &errmsg)) {
3440             char buf[256];
3441             avcodec_string(buf, sizeof(buf), st->codec, 0);
3442             av_log(ic, AV_LOG_WARNING,
3443                    "Could not find codec parameters for stream %d (%s): %s\n"
3444                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3445                    i, buf, errmsg);
3446         } else {
3447             ret = 0;
3448         }
3449     }
3450
3451     compute_chapters_end(ic);
3452
3453 find_stream_info_err:
3454     for (i = 0; i < ic->nb_streams; i++) {
3455         st = ic->streams[i];
3456         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3457             ic->streams[i]->codec->thread_count = 0;
3458         if (st->info)
3459             av_freep(&st->info->duration_error);
3460         av_freep(&ic->streams[i]->info);
3461     }
3462     if (ic->pb)
3463         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3464                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3465     return ret;
3466 }
3467
3468 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3469 {
3470     int i, j;
3471
3472     for (i = 0; i < ic->nb_programs; i++) {
3473         if (ic->programs[i] == last) {
3474             last = NULL;
3475         } else {
3476             if (!last)
3477                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3478                     if (ic->programs[i]->stream_index[j] == s)
3479                         return ic->programs[i];
3480         }
3481     }
3482     return NULL;
3483 }
3484
3485 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3486                         int wanted_stream_nb, int related_stream,
3487                         AVCodec **decoder_ret, int flags)
3488 {
3489     int i, nb_streams = ic->nb_streams;
3490     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3491     unsigned *program = NULL;
3492     const AVCodec *decoder = NULL, *best_decoder = NULL;
3493
3494     if (related_stream >= 0 && wanted_stream_nb < 0) {
3495         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3496         if (p) {
3497             program    = p->stream_index;
3498             nb_streams = p->nb_stream_indexes;
3499         }
3500     }
3501     for (i = 0; i < nb_streams; i++) {
3502         int real_stream_index = program ? program[i] : i;
3503         AVStream *st          = ic->streams[real_stream_index];
3504         AVCodecContext *avctx = st->codec;
3505         if (avctx->codec_type != type)
3506             continue;
3507         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3508             continue;
3509         if (wanted_stream_nb != real_stream_index &&
3510             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3511                                AV_DISPOSITION_VISUAL_IMPAIRED))
3512             continue;
3513         if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3514             continue;
3515         if (decoder_ret) {
3516             decoder = find_decoder(ic, st, st->codec->codec_id);
3517             if (!decoder) {
3518                 if (ret < 0)
3519                     ret = AVERROR_DECODER_NOT_FOUND;
3520                 continue;
3521             }
3522         }
3523         count = st->codec_info_nb_frames;
3524         bitrate = avctx->bit_rate;
3525         if (!bitrate)
3526             bitrate = avctx->rc_max_rate;
3527         multiframe = FFMIN(5, count);
3528         if ((best_multiframe >  multiframe) ||
3529             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3530             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3531             continue;
3532         best_count   = count;
3533         best_bitrate = bitrate;
3534         best_multiframe = multiframe;
3535         ret          = real_stream_index;
3536         best_decoder = decoder;
3537         if (program && i == nb_streams - 1 && ret < 0) {
3538             program    = NULL;
3539             nb_streams = ic->nb_streams;
3540             /* no related stream found, try again with everything */
3541             i = 0;
3542         }
3543     }
3544     if (decoder_ret)
3545         *decoder_ret = (AVCodec*)best_decoder;
3546     return ret;
3547 }
3548
3549 /*******************************************************/
3550
3551 int av_read_play(AVFormatContext *s)
3552 {
3553     if (s->iformat->read_play)
3554         return s->iformat->read_play(s);
3555     if (s->pb)
3556         return avio_pause(s->pb, 0);
3557     return AVERROR(ENOSYS);
3558 }
3559
3560 int av_read_pause(AVFormatContext *s)
3561 {
3562     if (s->iformat->read_pause)
3563         return s->iformat->read_pause(s);
3564     if (s->pb)
3565         return avio_pause(s->pb, 1);
3566     return AVERROR(ENOSYS);
3567 }
3568
3569 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3570     int j;
3571     av_assert0(s->nb_streams>0);
3572     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3573
3574     for (j = 0; j < st->nb_side_data; j++)
3575         av_freep(&st->side_data[j].data);
3576     av_freep(&st->side_data);
3577     st->nb_side_data = 0;
3578
3579     if (st->parser) {
3580         av_parser_close(st->parser);
3581     }
3582     if (st->attached_pic.data)
3583         av_free_packet(&st->attached_pic);
3584     av_dict_free(&st->metadata);
3585     av_freep(&st->probe_data.buf);
3586     av_freep(&st->index_entries);
3587     av_freep(&st->codec->extradata);
3588     av_freep(&st->codec->subtitle_header);
3589     av_freep(&st->codec);
3590     av_freep(&st->priv_data);
3591     if (st->info)
3592         av_freep(&st->info->duration_error);
3593     av_freep(&st->info);
3594     av_freep(&st->recommended_encoder_configuration);
3595     av_freep(&s->streams[ --s->nb_streams ]);
3596 }
3597
3598 void avformat_free_context(AVFormatContext *s)
3599 {
3600     int i;
3601
3602     if (!s)
3603         return;
3604
3605     av_opt_free(s);
3606     if (s->iformat && s->iformat->priv_class && s->priv_data)
3607         av_opt_free(s->priv_data);
3608     if (s->oformat && s->oformat->priv_class && s->priv_data)
3609         av_opt_free(s->priv_data);
3610
3611     for (i = s->nb_streams - 1; i >= 0; i--) {
3612         ff_free_stream(s, s->streams[i]);
3613     }
3614     for (i = s->nb_programs - 1; i >= 0; i--) {
3615         av_dict_free(&s->programs[i]->metadata);
3616         av_freep(&s->programs[i]->stream_index);
3617         av_freep(&s->programs[i]);
3618     }
3619     av_freep(&s->programs);
3620     av_freep(&s->priv_data);
3621     while (s->nb_chapters--) {
3622         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3623         av_freep(&s->chapters[s->nb_chapters]);
3624     }
3625     av_freep(&s->chapters);
3626     av_dict_free(&s->metadata);
3627     av_freep(&s->streams);
3628     av_freep(&s->internal);
3629     flush_packet_queue(s);
3630     av_free(s);
3631 }
3632
3633 void avformat_close_input(AVFormatContext **ps)
3634 {
3635     AVFormatContext *s;
3636     AVIOContext *pb;
3637
3638     if (!ps || !*ps)
3639         return;
3640
3641     s  = *ps;
3642     pb = s->pb;
3643
3644     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3645         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3646         pb = NULL;
3647
3648     flush_packet_queue(s);
3649
3650     if (s->iformat)
3651         if (s->iformat->read_close)
3652             s->iformat->read_close(s);
3653
3654     avformat_free_context(s);
3655
3656     *ps = NULL;
3657
3658     avio_close(pb);
3659 }
3660
3661 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3662 {
3663     AVStream *st;
3664     int i;
3665     AVStream **streams;
3666
3667     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3668         return NULL;
3669     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3670     if (!streams)
3671         return NULL;
3672     s->streams = streams;
3673
3674     st = av_mallocz(sizeof(AVStream));
3675     if (!st)
3676         return NULL;
3677     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3678         av_free(st);
3679         return NULL;
3680     }
3681     st->info->last_dts = AV_NOPTS_VALUE;
3682
3683     st->codec = avcodec_alloc_context3(c);
3684     if (!st->codec) {
3685         av_free(st->info);
3686         av_free(st);
3687         return NULL;
3688     }
3689     if (s->iformat) {
3690         /* no default bitrate if decoding */
3691         st->codec->bit_rate = 0;
3692
3693         /* default pts setting is MPEG-like */
3694         avpriv_set_pts_info(st, 33, 1, 90000);
3695     }
3696
3697     st->index      = s->nb_streams;
3698     st->start_time = AV_NOPTS_VALUE;
3699     st->duration   = AV_NOPTS_VALUE;
3700     /* we set the current DTS to 0 so that formats without any timestamps
3701      * but durations get some timestamps, formats with some unknown
3702      * timestamps have their first few packets buffered and the
3703      * timestamps corrected before they are returned to the user */
3704     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3705     st->first_dts     = AV_NOPTS_VALUE;
3706     st->probe_packets = MAX_PROBE_PACKETS;
3707     st->pts_wrap_reference = AV_NOPTS_VALUE;
3708     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3709
3710     st->last_IP_pts = AV_NOPTS_VALUE;
3711     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3712     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3713         st->pts_buffer[i] = AV_NOPTS_VALUE;
3714
3715     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3716
3717 #if FF_API_R_FRAME_RATE
3718     st->info->last_dts      = AV_NOPTS_VALUE;
3719 #endif
3720     st->info->fps_first_dts = AV_NOPTS_VALUE;
3721     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3722
3723     st->inject_global_side_data = s->internal->inject_global_side_data;
3724
3725     s->streams[s->nb_streams++] = st;
3726     return st;
3727 }
3728
3729 AVProgram *av_new_program(AVFormatContext *ac, int id)
3730 {
3731     AVProgram *program = NULL;
3732     int i;
3733
3734     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3735
3736     for (i = 0; i < ac->nb_programs; i++)
3737         if (ac->programs[i]->id == id)
3738             program = ac->programs[i];
3739
3740     if (!program) {
3741         program = av_mallocz(sizeof(AVProgram));
3742         if (!program)
3743             return NULL;
3744         dynarray_add(&ac->programs, &ac->nb_programs, program);
3745         program->discard = AVDISCARD_NONE;
3746     }
3747     program->id = id;
3748     program->pts_wrap_reference = AV_NOPTS_VALUE;
3749     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3750
3751     program->start_time =
3752     program->end_time   = AV_NOPTS_VALUE;
3753
3754     return program;
3755 }
3756
3757 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3758                               int64_t start, int64_t end, const char *title)
3759 {
3760     AVChapter *chapter = NULL;
3761     int i;
3762
3763     if (end != AV_NOPTS_VALUE && start > end) {
3764         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3765         return NULL;
3766     }
3767
3768     for (i = 0; i < s->nb_chapters; i++)
3769         if (s->chapters[i]->id == id)
3770             chapter = s->chapters[i];
3771
3772     if (!chapter) {
3773         chapter = av_mallocz(sizeof(AVChapter));
3774         if (!chapter)
3775             return NULL;
3776         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3777     }
3778     av_dict_set(&chapter->metadata, "title", title, 0);
3779     chapter->id        = id;
3780     chapter->time_base = time_base;
3781     chapter->start     = start;
3782     chapter->end       = end;
3783
3784     return chapter;
3785 }
3786
3787 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3788 {
3789     int i, j;
3790     AVProgram *program = NULL;
3791     void *tmp;
3792
3793     if (idx >= ac->nb_streams) {
3794         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3795         return;
3796     }
3797
3798     for (i = 0; i < ac->nb_programs; i++) {
3799         if (ac->programs[i]->id != progid)
3800             continue;
3801         program = ac->programs[i];
3802         for (j = 0; j < program->nb_stream_indexes; j++)
3803             if (program->stream_index[j] == idx)
3804                 return;
3805
3806         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3807         if (!tmp)
3808             return;
3809         program->stream_index = tmp;
3810         program->stream_index[program->nb_stream_indexes++] = idx;
3811         return;
3812     }
3813 }
3814
3815 uint64_t ff_ntp_time(void)
3816 {
3817     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3818 }
3819
3820 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3821 {
3822     const char *p;
3823     char *q, buf1[20], c;
3824     int nd, len, percentd_found;
3825
3826     q = buf;
3827     p = path;
3828     percentd_found = 0;
3829     for (;;) {
3830         c = *p++;
3831         if (c == '\0')
3832             break;
3833         if (c == '%') {
3834             do {
3835                 nd = 0;
3836                 while (av_isdigit(*p))
3837                     nd = nd * 10 + *p++ - '0';
3838                 c = *p++;
3839             } while (av_isdigit(c));
3840
3841             switch (c) {
3842             case '%':
3843                 goto addchar;
3844             case 'd':
3845                 if (percentd_found)
3846                     goto fail;
3847                 percentd_found = 1;
3848                 if (number < 0)
3849                     nd += 1;
3850                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3851                 len = strlen(buf1);
3852                 if ((q - buf + len) > buf_size - 1)
3853                     goto fail;
3854                 memcpy(q, buf1, len);
3855                 q += len;
3856                 break;
3857             default:
3858                 goto fail;
3859             }
3860         } else {
3861 addchar:
3862             if ((q - buf) < buf_size - 1)
3863                 *q++ = c;
3864         }
3865     }
3866     if (!percentd_found)
3867         goto fail;
3868     *q = '\0';
3869     return 0;
3870 fail:
3871     *q = '\0';
3872     return -1;
3873 }
3874
3875 void av_url_split(char *proto, int proto_size,
3876                   char *authorization, int authorization_size,
3877                   char *hostname, int hostname_size,
3878                   int *port_ptr, char *path, int path_size, const char *url)
3879 {
3880     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3881
3882     if (port_ptr)
3883         *port_ptr = -1;
3884     if (proto_size > 0)
3885         proto[0] = 0;
3886     if (authorization_size > 0)
3887         authorization[0] = 0;
3888     if (hostname_size > 0)
3889         hostname[0] = 0;
3890     if (path_size > 0)
3891         path[0] = 0;
3892
3893     /* parse protocol */
3894     if ((p = strchr(url, ':'))) {
3895         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3896         p++; /* skip ':' */
3897         if (*p == '/')
3898             p++;
3899         if (*p == '/')
3900             p++;
3901     } else {
3902         /* no protocol means plain filename */
3903         av_strlcpy(path, url, path_size);
3904         return;
3905     }
3906
3907     /* separate path from hostname */
3908     ls = strchr(p, '/');
3909     ls2 = strchr(p, '?');
3910     if (!ls)
3911         ls = ls2;
3912     else if (ls && ls2)
3913         ls = FFMIN(ls, ls2);
3914     if (ls)
3915         av_strlcpy(path, ls, path_size);
3916     else
3917         ls = &p[strlen(p)];  // XXX
3918
3919     /* the rest is hostname, use that to parse auth/port */
3920     if (ls != p) {
3921         /* authorization (user[:pass]@hostname) */
3922         at2 = p;
3923         while ((at = strchr(p, '@')) && at < ls) {
3924             av_strlcpy(authorization, at2,
3925                        FFMIN(authorization_size, at + 1 - at2));
3926             p = at + 1; /* skip '@' */
3927         }
3928
3929         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3930             /* [host]:port */
3931             av_strlcpy(hostname, p + 1,
3932                        FFMIN(hostname_size, brk - p));
3933             if (brk[1] == ':' && port_ptr)
3934                 *port_ptr = atoi(brk + 2);
3935         } else if ((col = strchr(p, ':')) && col < ls) {
3936             av_strlcpy(hostname, p,
3937                        FFMIN(col + 1 - p, hostname_size));
3938             if (port_ptr)
3939                 *port_ptr = atoi(col + 1);
3940         } else
3941             av_strlcpy(hostname, p,
3942                        FFMIN(ls + 1 - p, hostname_size));
3943     }
3944 }
3945
3946 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3947 {
3948     int i;
3949     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3950                                            '4', '5', '6', '7',
3951                                            '8', '9', 'A', 'B',
3952                                            'C', 'D', 'E', 'F' };
3953     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3954                                            '4', '5', '6', '7',
3955                                            '8', '9', 'a', 'b',
3956                                            'c', 'd', 'e', 'f' };
3957     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3958
3959     for (i = 0; i < s; i++) {
3960         buff[i * 2]     = hex_table[src[i] >> 4];
3961         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3962     }
3963
3964     return buff;
3965 }
3966
3967 int ff_hex_to_data(uint8_t *data, const char *p)
3968 {
3969     int c, len, v;
3970
3971     len = 0;
3972     v   = 1;
3973     for (;;) {
3974         p += strspn(p, SPACE_CHARS);
3975         if (*p == '\0')
3976             break;
3977         c = av_toupper((unsigned char) *p++);
3978         if (c >= '0' && c <= '9')
3979             c = c - '0';
3980         else if (c >= 'A' && c <= 'F')
3981             c = c - 'A' + 10;
3982         else
3983             break;
3984         v = (v << 4) | c;
3985         if (v & 0x100) {
3986             if (data)
3987                 data[len] = v;
3988             len++;
3989             v = 1;
3990         }
3991     }
3992     return len;
3993 }
3994
3995 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3996                          unsigned int pts_num, unsigned int pts_den)
3997 {
3998     AVRational new_tb;
3999     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4000         if (new_tb.num != pts_num)
4001             av_log(NULL, AV_LOG_DEBUG,
4002                    "st:%d removing common factor %d from timebase\n",
4003                    s->index, pts_num / new_tb.num);
4004     } else
4005         av_log(NULL, AV_LOG_WARNING,
4006                "st:%d has too large timebase, reducing\n", s->index);
4007
4008     if (new_tb.num <= 0 || new_tb.den <= 0) {
4009         av_log(NULL, AV_LOG_ERROR,
4010                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4011                new_tb.num, new_tb.den,
4012                s->index);
4013         return;
4014     }
4015     s->time_base     = new_tb;
4016     av_codec_set_pkt_timebase(s->codec, new_tb);
4017     s->pts_wrap_bits = pts_wrap_bits;
4018 }
4019
4020 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4021                         void *context)
4022 {
4023     const char *ptr = str;
4024
4025     /* Parse key=value pairs. */
4026     for (;;) {
4027         const char *key;
4028         char *dest = NULL, *dest_end;
4029         int key_len, dest_len = 0;
4030
4031         /* Skip whitespace and potential commas. */
4032         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4033             ptr++;
4034         if (!*ptr)
4035             break;
4036
4037         key = ptr;
4038
4039         if (!(ptr = strchr(key, '=')))
4040             break;
4041         ptr++;
4042         key_len = ptr - key;
4043
4044         callback_get_buf(context, key, key_len, &dest, &dest_len);
4045         dest_end = dest + dest_len - 1;
4046
4047         if (*ptr == '\"') {
4048             ptr++;
4049             while (*ptr && *ptr != '\"') {
4050                 if (*ptr == '\\') {
4051                     if (!ptr[1])
4052                         break;
4053                     if (dest && dest < dest_end)
4054                         *dest++ = ptr[1];
4055                     ptr += 2;
4056                 } else {
4057                     if (dest && dest < dest_end)
4058                         *dest++ = *ptr;
4059                     ptr++;
4060                 }
4061             }
4062             if (*ptr == '\"')
4063                 ptr++;
4064         } else {
4065             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4066                 if (dest && dest < dest_end)
4067                     *dest++ = *ptr;
4068         }
4069         if (dest)
4070             *dest = 0;
4071     }
4072 }
4073
4074 int ff_find_stream_index(AVFormatContext *s, int id)
4075 {
4076     int i;
4077     for (i = 0; i < s->nb_streams; i++)
4078         if (s->streams[i]->id == id)
4079             return i;
4080     return -1;
4081 }
4082
4083 int64_t ff_iso8601_to_unix_time(const char *datestr)
4084 {
4085     struct tm time1 = { 0 }, time2 = { 0 };
4086     char *ret1, *ret2;
4087     ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4088     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4089     if (ret2 && !ret1)
4090         return av_timegm(&time2);
4091     else
4092         return av_timegm(&time1);
4093 }
4094
4095 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4096                          int std_compliance)
4097 {
4098     if (ofmt) {
4099         if (ofmt->query_codec)
4100             return ofmt->query_codec(codec_id, std_compliance);
4101         else if (ofmt->codec_tag)
4102             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4103         else if (codec_id == ofmt->video_codec ||
4104                  codec_id == ofmt->audio_codec ||
4105                  codec_id == ofmt->subtitle_codec)
4106             return 1;
4107     }
4108     return AVERROR_PATCHWELCOME;
4109 }
4110
4111 int avformat_network_init(void)
4112 {
4113 #if CONFIG_NETWORK
4114     int ret;
4115     ff_network_inited_globally = 1;
4116     if ((ret = ff_network_init()) < 0)
4117         return ret;
4118     if ((ret = ff_tls_init()) < 0)
4119         return ret;
4120 #endif
4121     return 0;
4122 }
4123
4124 int avformat_network_deinit(void)
4125 {
4126 #if CONFIG_NETWORK
4127     ff_network_close();
4128     ff_tls_deinit();
4129 #endif
4130     return 0;
4131 }
4132
4133 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4134                         uint64_t channel_layout, int32_t sample_rate,
4135                         int32_t width, int32_t height)
4136 {
4137     uint32_t flags = 0;
4138     int size = 4;
4139     uint8_t *data;
4140     if (!pkt)
4141         return AVERROR(EINVAL);
4142     if (channels) {
4143         size  += 4;
4144         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4145     }
4146     if (channel_layout) {
4147         size  += 8;
4148         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4149     }
4150     if (sample_rate) {
4151         size  += 4;
4152         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4153     }
4154     if (width || height) {
4155         size  += 8;
4156         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4157     }
4158     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4159     if (!data)
4160         return AVERROR(ENOMEM);
4161     bytestream_put_le32(&data, flags);
4162     if (channels)
4163         bytestream_put_le32(&data, channels);
4164     if (channel_layout)
4165         bytestream_put_le64(&data, channel_layout);
4166     if (sample_rate)
4167         bytestream_put_le32(&data, sample_rate);
4168     if (width || height) {
4169         bytestream_put_le32(&data, width);
4170         bytestream_put_le32(&data, height);
4171     }
4172     return 0;
4173 }
4174
4175 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4176 {
4177     AVRational undef = {0, 1};
4178     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4179     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4180     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4181
4182     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4183                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4184     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4185         stream_sample_aspect_ratio = undef;
4186
4187     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4188                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4189     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4190         frame_sample_aspect_ratio = undef;
4191
4192     if (stream_sample_aspect_ratio.num)
4193         return stream_sample_aspect_ratio;
4194     else
4195         return frame_sample_aspect_ratio;
4196 }
4197
4198 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4199 {
4200     AVRational fr = st->r_frame_rate;
4201     AVRational codec_fr = st->codec->framerate;
4202     AVRational   avg_fr = st->avg_frame_rate;
4203
4204     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4205         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4206         fr = avg_fr;
4207     }
4208
4209
4210     if (st->codec->ticks_per_frame > 1) {
4211         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4212             (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))
4213             fr = codec_fr;
4214     }
4215
4216     return fr;
4217 }
4218
4219 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4220                                     const char *spec)
4221 {
4222     if (*spec <= '9' && *spec >= '0') /* opt:index */
4223         return strtol(spec, NULL, 0) == st->index;
4224     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4225              *spec == 't') { /* opt:[vasdt] */
4226         enum AVMediaType type;
4227
4228         switch (*spec++) {
4229         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4230         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4231         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4232         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4233         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4234         default:  av_assert0(0);
4235         }
4236         if (type != st->codec->codec_type)
4237             return 0;
4238         if (*spec++ == ':') { /* possibly followed by :index */
4239             int i, index = strtol(spec, NULL, 0);
4240             for (i = 0; i < s->nb_streams; i++)
4241                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4242                    return i == st->index;
4243             return 0;
4244         }
4245         return 1;
4246     } else if (*spec == 'p' && *(spec + 1) == ':') {
4247         int prog_id, i, j;
4248         char *endptr;
4249         spec += 2;
4250         prog_id = strtol(spec, &endptr, 0);
4251         for (i = 0; i < s->nb_programs; i++) {
4252             if (s->programs[i]->id != prog_id)
4253                 continue;
4254
4255             if (*endptr++ == ':') {
4256                 int stream_idx = strtol(endptr, NULL, 0);
4257                 return stream_idx >= 0 &&
4258                     stream_idx < s->programs[i]->nb_stream_indexes &&
4259                     st->index == s->programs[i]->stream_index[stream_idx];
4260             }
4261
4262             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4263                 if (st->index == s->programs[i]->stream_index[j])
4264                     return 1;
4265         }
4266         return 0;
4267     } else if (*spec == '#' ||
4268                (*spec == 'i' && *(spec + 1) == ':')) {
4269         int stream_id;
4270         char *endptr;
4271         spec += 1 + (*spec == 'i');
4272         stream_id = strtol(spec, &endptr, 0);
4273         if (!*endptr)
4274             return stream_id == st->id;
4275     } else if (*spec == 'm' && *(spec + 1) == ':') {
4276         AVDictionaryEntry *tag;
4277         char *key, *val;
4278         int ret;
4279
4280         spec += 2;
4281         val = strchr(spec, ':');
4282
4283         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4284         if (!key)
4285             return AVERROR(ENOMEM);
4286
4287         tag = av_dict_get(st->metadata, key, NULL, 0);
4288         if (tag) {
4289             if (!val || !strcmp(tag->value, val + 1))
4290                 ret = 1;
4291             else
4292                 ret = 0;
4293         } else
4294             ret = 0;
4295
4296         av_freep(&key);
4297         return ret;
4298     } else if (*spec == 'u') {
4299         AVCodecContext *avctx = st->codec;
4300         int val;
4301         switch (avctx->codec_type) {
4302         case AVMEDIA_TYPE_AUDIO:
4303             val = avctx->sample_rate && avctx->channels;
4304             if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4305                 return 0;
4306             break;
4307         case AVMEDIA_TYPE_VIDEO:
4308             val = avctx->width && avctx->height;
4309             if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4310                 return 0;
4311             break;
4312         case AVMEDIA_TYPE_UNKNOWN:
4313             val = 0;
4314             break;
4315         default:
4316             val = 1;
4317             break;
4318         }
4319         return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4320     } else if (!*spec) /* empty specifier, matches everything */
4321         return 1;
4322
4323     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4324     return AVERROR(EINVAL);
4325 }
4326
4327 int ff_generate_avci_extradata(AVStream *st)
4328 {
4329     static const uint8_t avci100_1080p_extradata[] = {
4330         // SPS
4331         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4332         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4333         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4334         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4335         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4336         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4337         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4338         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4339         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4340         // PPS
4341         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4342         0xd0
4343     };
4344     static const uint8_t avci100_1080i_extradata[] = {
4345         // SPS
4346         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4347         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4348         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4349         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4350         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4351         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4352         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4353         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4354         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4355         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4356         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4357         // PPS
4358         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4359         0xd0
4360     };
4361     static const uint8_t avci50_1080p_extradata[] = {
4362         // SPS
4363         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4364         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4365         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4366         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4367         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4368         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4369         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4370         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4371         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4372         // PPS
4373         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4374         0x11
4375     };
4376     static const uint8_t avci50_1080i_extradata[] = {
4377         // SPS
4378         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4379         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4380         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4381         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4382         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4383         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4384         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4385         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4386         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4387         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4388         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4389         // PPS
4390         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4391         0x11
4392     };
4393     static const uint8_t avci100_720p_extradata[] = {
4394         // SPS
4395         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4396         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4397         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4398         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4399         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4400         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4401         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4402         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4403         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4404         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4405         // PPS
4406         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4407         0x11
4408     };
4409     static const uint8_t avci50_720p_extradata[] = {
4410         // SPS
4411         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4412         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4413         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4414         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4415         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4416         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4417         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4418         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4419         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4420         // PPS
4421         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4422         0x11
4423     };
4424
4425     const uint8_t *data = NULL;
4426     int size            = 0;
4427
4428     if (st->codec->width == 1920) {
4429         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4430             data = avci100_1080p_extradata;
4431             size = sizeof(avci100_1080p_extradata);
4432         } else {
4433             data = avci100_1080i_extradata;
4434             size = sizeof(avci100_1080i_extradata);
4435         }
4436     } else if (st->codec->width == 1440) {
4437         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4438             data = avci50_1080p_extradata;
4439             size = sizeof(avci50_1080p_extradata);
4440         } else {
4441             data = avci50_1080i_extradata;
4442             size = sizeof(avci50_1080i_extradata);
4443         }
4444     } else if (st->codec->width == 1280) {
4445         data = avci100_720p_extradata;
4446         size = sizeof(avci100_720p_extradata);
4447     } else if (st->codec->width == 960) {
4448         data = avci50_720p_extradata;
4449         size = sizeof(avci50_720p_extradata);
4450     }
4451
4452     if (!size)
4453         return 0;
4454
4455     av_freep(&st->codec->extradata);
4456     if (ff_alloc_extradata(st->codec, size))
4457         return AVERROR(ENOMEM);
4458     memcpy(st->codec->extradata, data, size);
4459
4460     return 0;
4461 }
4462
4463 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4464                                  int *size)
4465 {
4466     int i;
4467
4468     for (i = 0; i < st->nb_side_data; i++) {
4469         if (st->side_data[i].type == type) {
4470             if (size)
4471                 *size = st->side_data[i].size;
4472             return st->side_data[i].data;
4473         }
4474     }
4475     return NULL;
4476 }
4477
4478 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4479                                  int size)
4480 {
4481     AVPacketSideData *sd, *tmp;
4482     int i;
4483     uint8_t *data = av_malloc(size);
4484
4485     if (!data)
4486         return NULL;
4487
4488     for (i = 0; i < st->nb_side_data; i++) {
4489         sd = &st->side_data[i];
4490
4491         if (sd->type == type) {
4492             av_freep(&sd->data);
4493             sd->data = data;
4494             sd->size = size;
4495             return sd->data;
4496         }
4497     }
4498
4499     tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4500     if (!tmp) {
4501         av_freep(&data);
4502         return NULL;
4503     }
4504
4505     st->side_data = tmp;
4506     st->nb_side_data++;
4507
4508     sd = &st->side_data[st->nb_side_data - 1];
4509     sd->type = type;
4510     sd->data = data;
4511     sd->size = size;
4512     return data;
4513 }