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