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