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_close(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_size = 0;
2847         return AVERROR(EINVAL);
2848     }
2849     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2850     if (avctx->extradata) {
2851         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2852         avctx->extradata_size = size;
2853         ret = 0;
2854     } else {
2855         avctx->extradata_size = 0;
2856         ret = AVERROR(ENOMEM);
2857     }
2858     return ret;
2859 }
2860
2861 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2862 {
2863     int ret = ff_alloc_extradata(avctx, size);
2864     if (ret < 0)
2865         return ret;
2866     ret = avio_read(pb, avctx->extradata, size);
2867     if (ret != size) {
2868         av_freep(&avctx->extradata);
2869         avctx->extradata_size = 0;
2870         av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2871         return ret < 0 ? ret : AVERROR_INVALIDDATA;
2872     }
2873
2874     return ret;
2875 }
2876
2877 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2878 {
2879     int i, j;
2880     int64_t last = st->info->last_dts;
2881
2882     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2883        && ts - (uint64_t)last < INT64_MAX) {
2884         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2885         int64_t duration = ts - last;
2886
2887         if (!st->info->duration_error)
2888             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2889         if (!st->info->duration_error)
2890             return AVERROR(ENOMEM);
2891
2892 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2893 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2894         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2895             if (st->info->duration_error[0][1][i] < 1e10) {
2896                 int framerate = get_std_framerate(i);
2897                 double sdts = dts*framerate/(1001*12);
2898                 for (j= 0; j<2; j++) {
2899                     int64_t ticks = llrint(sdts+j*0.5);
2900                     double error= sdts - ticks + j*0.5;
2901                     st->info->duration_error[j][0][i] += error;
2902                     st->info->duration_error[j][1][i] += error*error;
2903                 }
2904             }
2905         }
2906         st->info->duration_count++;
2907         st->info->rfps_duration_sum += duration;
2908
2909         if (st->info->duration_count % 10 == 0) {
2910             int n = st->info->duration_count;
2911             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2912                 if (st->info->duration_error[0][1][i] < 1e10) {
2913                     double a0     = st->info->duration_error[0][0][i] / n;
2914                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2915                     double a1     = st->info->duration_error[1][0][i] / n;
2916                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2917                     if (error0 > 0.04 && error1 > 0.04) {
2918                         st->info->duration_error[0][1][i] = 2e10;
2919                         st->info->duration_error[1][1][i] = 2e10;
2920                     }
2921                 }
2922             }
2923         }
2924
2925         // ignore the first 4 values, they might have some random jitter
2926         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2927             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2928     }
2929     if (ts != AV_NOPTS_VALUE)
2930         st->info->last_dts = ts;
2931
2932     return 0;
2933 }
2934
2935 void ff_rfps_calculate(AVFormatContext *ic)
2936 {
2937     int i, j;
2938
2939     for (i = 0; i < ic->nb_streams; i++) {
2940         AVStream *st = ic->streams[i];
2941
2942         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2943             continue;
2944         // the check for tb_unreliable() is not completely correct, since this is not about handling
2945         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2946         // ipmovie.c produces.
2947         if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2948             av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2949         if (st->info->duration_count>1 && !st->r_frame_rate.num
2950             && tb_unreliable(st->codec)) {
2951             int num = 0;
2952             double best_error= 0.01;
2953             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2954
2955             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2956                 int k;
2957
2958                 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2959                     continue;
2960                 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2961                     continue;
2962
2963                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2964                     continue;
2965
2966                 for (k= 0; k<2; k++) {
2967                     int n = st->info->duration_count;
2968                     double a= st->info->duration_error[k][0][j] / n;
2969                     double error= st->info->duration_error[k][1][j]/n - a*a;
2970
2971                     if (error < best_error && best_error> 0.000000001) {
2972                         best_error= error;
2973                         num = get_std_framerate(j);
2974                     }
2975                     if (error < 0.02)
2976                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2977                 }
2978             }
2979             // do not increase frame rate by more than 1 % in order to match a standard rate.
2980             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2981                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2982         }
2983         if (   !st->avg_frame_rate.num
2984             && st->r_frame_rate.num && st->info->rfps_duration_sum
2985             && st->info->codec_info_duration <= 0
2986             && st->info->duration_count > 2
2987             && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
2988             ) {
2989             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2990             st->avg_frame_rate = st->r_frame_rate;
2991         }
2992
2993         av_freep(&st->info->duration_error);
2994         st->info->last_dts = AV_NOPTS_VALUE;
2995         st->info->duration_count = 0;
2996         st->info->rfps_duration_sum = 0;
2997     }
2998 }
2999
3000 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3001 {
3002     int i, count, ret = 0, j;
3003     int64_t read_size;
3004     AVStream *st;
3005     AVPacket pkt1, *pkt;
3006     int64_t old_offset  = avio_tell(ic->pb);
3007     // new streams might appear, no options for those
3008     int orig_nb_streams = ic->nb_streams;
3009     int flush_codecs;
3010     int64_t max_analyze_duration = ic->max_analyze_duration2;
3011     int64_t max_stream_analyze_duration;
3012     int64_t probesize = ic->probesize2;
3013
3014     if (!max_analyze_duration)
3015         max_analyze_duration = ic->max_analyze_duration;
3016     if (ic->probesize)
3017         probesize = ic->probesize;
3018     flush_codecs = probesize > 0;
3019
3020     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3021
3022     max_stream_analyze_duration = max_analyze_duration;
3023     if (!max_analyze_duration) {
3024         max_stream_analyze_duration =
3025         max_analyze_duration        = 5*AV_TIME_BASE;
3026         if (!strcmp(ic->iformat->name, "flv"))
3027             max_stream_analyze_duration = 30*AV_TIME_BASE;
3028     }
3029
3030     if (ic->pb)
3031         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3032                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3033
3034     for (i = 0; i < ic->nb_streams; i++) {
3035         const AVCodec *codec;
3036         AVDictionary *thread_opt = NULL;
3037         st = ic->streams[i];
3038
3039         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3040             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3041 /*            if (!st->time_base.num)
3042                 st->time_base = */
3043             if (!st->codec->time_base.num)
3044                 st->codec->time_base = st->time_base;
3045         }
3046         // only for the split stuff
3047         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3048             st->parser = av_parser_init(st->codec->codec_id);
3049             if (st->parser) {
3050                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3051                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3052                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3053                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3054                 }
3055             } else if (st->need_parsing) {
3056                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3057                        "%s, packets or times may be invalid.\n",
3058                        avcodec_get_name(st->codec->codec_id));
3059             }
3060         }
3061         codec = find_decoder(ic, st, st->codec->codec_id);
3062
3063         /* Force thread count to 1 since the H.264 decoder will not extract
3064          * SPS and PPS to extradata during multi-threaded decoding. */
3065         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3066
3067         if (ic->codec_whitelist)
3068             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3069
3070         /* Ensure that subtitle_header is properly set. */
3071         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3072             && codec && !st->codec->codec) {
3073             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3074                 av_log(ic, AV_LOG_WARNING,
3075                        "Failed to open codec in av_find_stream_info\n");
3076         }
3077
3078         // Try to just open decoders, in case this is enough to get parameters.
3079         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3080             if (codec && !st->codec->codec)
3081                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3082                     av_log(ic, AV_LOG_WARNING,
3083                            "Failed to open codec in av_find_stream_info\n");
3084         }
3085         if (!options)
3086             av_dict_free(&thread_opt);
3087     }
3088
3089     for (i = 0; i < ic->nb_streams; i++) {
3090 #if FF_API_R_FRAME_RATE
3091         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3092 #endif
3093         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3094         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3095     }
3096
3097     count     = 0;
3098     read_size = 0;
3099     for (;;) {
3100         int analyzed_all_streams;
3101         if (ff_check_interrupt(&ic->interrupt_callback)) {
3102             ret = AVERROR_EXIT;
3103             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3104             break;
3105         }
3106
3107         /* check if one codec still needs to be handled */
3108         for (i = 0; i < ic->nb_streams; i++) {
3109             int fps_analyze_framecount = 20;
3110
3111             st = ic->streams[i];
3112             if (!has_codec_parameters(st, NULL))
3113                 break;
3114             /* If the timebase is coarse (like the usual millisecond precision
3115              * of mkv), we need to analyze more frames to reliably arrive at
3116              * the correct fps. */
3117             if (av_q2d(st->time_base) > 0.0005)
3118                 fps_analyze_framecount *= 2;
3119             if (!tb_unreliable(st->codec))
3120                 fps_analyze_framecount = 0;
3121             if (ic->fps_probe_size >= 0)
3122                 fps_analyze_framecount = ic->fps_probe_size;
3123             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3124                 fps_analyze_framecount = 0;
3125             /* variable fps and no guess at the real fps */
3126             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3127                 st->info->duration_count < fps_analyze_framecount &&
3128                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3129                 break;
3130             if (st->parser && st->parser->parser->split &&
3131                 !st->codec->extradata)
3132                 break;
3133             if (st->first_dts == AV_NOPTS_VALUE &&
3134                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3135                 st->codec_info_nb_frames < ic->max_ts_probe &&
3136                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3137                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3138                 break;
3139         }
3140         analyzed_all_streams = 0;
3141         if (i == ic->nb_streams) {
3142             analyzed_all_streams = 1;
3143             /* NOTE: If the format has no header, then we need to read some
3144              * packets to get most of the streams, so we cannot stop here. */
3145             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3146                 /* If we found the info for all the codecs, we can stop. */
3147                 ret = count;
3148                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3149                 flush_codecs = 0;
3150                 break;
3151             }
3152         }
3153         /* We did not get all the codec info, but we read too much data. */
3154         if (read_size >= probesize) {
3155             ret = count;
3156             av_log(ic, AV_LOG_DEBUG,
3157                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3158             for (i = 0; i < ic->nb_streams; i++)
3159                 if (!ic->streams[i]->r_frame_rate.num &&
3160                     ic->streams[i]->info->duration_count <= 1 &&
3161                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3162                     strcmp(ic->iformat->name, "image2"))
3163                     av_log(ic, AV_LOG_WARNING,
3164                            "Stream #%d: not enough frames to estimate rate; "
3165                            "consider increasing probesize\n", i);
3166             break;
3167         }
3168
3169         /* NOTE: A new stream can be added there if no header in file
3170          * (AVFMTCTX_NOHEADER). */
3171         ret = read_frame_internal(ic, &pkt1);
3172         if (ret == AVERROR(EAGAIN))
3173             continue;
3174
3175         if (ret < 0) {
3176             /* EOF or error*/
3177             break;
3178         }
3179
3180         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3181             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3182         {
3183             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3184                                 &ic->packet_buffer_end);
3185             if (!pkt) {
3186                 ret = AVERROR(ENOMEM);
3187                 goto find_stream_info_err;
3188             }
3189             if ((ret = av_dup_packet(pkt)) < 0)
3190                 goto find_stream_info_err;
3191         }
3192
3193         st = ic->streams[pkt->stream_index];
3194         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3195             read_size += pkt->size;
3196
3197         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3198             /* check for non-increasing dts */
3199             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3200                 st->info->fps_last_dts >= pkt->dts) {
3201                 av_log(ic, AV_LOG_DEBUG,
3202                        "Non-increasing DTS in stream %d: packet %d with DTS "
3203                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3204                        st->index, st->info->fps_last_dts_idx,
3205                        st->info->fps_last_dts, st->codec_info_nb_frames,
3206                        pkt->dts);
3207                 st->info->fps_first_dts =
3208                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3209             }
3210             /* Check for a discontinuity in dts. If the difference in dts
3211              * is more than 1000 times the average packet duration in the
3212              * sequence, we treat it as a discontinuity. */
3213             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3214                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3215                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3216                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3217                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3218                 av_log(ic, AV_LOG_WARNING,
3219                        "DTS discontinuity in stream %d: packet %d with DTS "
3220                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3221                        st->index, st->info->fps_last_dts_idx,
3222                        st->info->fps_last_dts, st->codec_info_nb_frames,
3223                        pkt->dts);
3224                 st->info->fps_first_dts =
3225                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3226             }
3227
3228             /* update stored dts values */
3229             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3230                 st->info->fps_first_dts     = pkt->dts;
3231                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3232             }
3233             st->info->fps_last_dts     = pkt->dts;
3234             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3235         }
3236         if (st->codec_info_nb_frames>1) {
3237             int64_t t = 0;
3238
3239             if (st->time_base.den > 0)
3240                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3241             if (st->avg_frame_rate.num > 0)
3242                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3243
3244             if (   t == 0
3245                 && st->codec_info_nb_frames>30
3246                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3247                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3248                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3249
3250             if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3251                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3252                        max_analyze_duration,
3253                        t);
3254                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3255                     av_packet_unref(pkt);
3256                 break;
3257             }
3258             if (pkt->duration) {
3259                 st->info->codec_info_duration        += pkt->duration;
3260                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3261             }
3262         }
3263 #if FF_API_R_FRAME_RATE
3264         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3265             ff_rfps_add_frame(ic, st, pkt->dts);
3266 #endif
3267         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3268             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3269             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3270                 if (ff_alloc_extradata(st->codec, i))
3271                     return AVERROR(ENOMEM);
3272                 memcpy(st->codec->extradata, pkt->data,
3273                        st->codec->extradata_size);
3274             }
3275         }
3276
3277         /* If still no information, we try to open the codec and to
3278          * decompress the frame. We try to avoid that in most cases as
3279          * it takes longer and uses more memory. For MPEG-4, we need to
3280          * decompress for QuickTime.
3281          *
3282          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3283          * least one frame of codec data, this makes sure the codec initializes
3284          * the channel configuration and does not only trust the values from
3285          * the container. */
3286         try_decode_frame(ic, st, pkt,
3287                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3288
3289         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3290             av_packet_unref(pkt);
3291
3292         st->codec_info_nb_frames++;
3293         count++;
3294     }
3295
3296     if (flush_codecs) {
3297         AVPacket empty_pkt = { 0 };
3298         int err = 0;
3299         av_init_packet(&empty_pkt);
3300
3301         for (i = 0; i < ic->nb_streams; i++) {
3302
3303             st = ic->streams[i];
3304
3305             /* flush the decoders */
3306             if (st->info->found_decoder == 1) {
3307                 do {
3308                     err = try_decode_frame(ic, st, &empty_pkt,
3309                                             (options && i < orig_nb_streams)
3310                                             ? &options[i] : NULL);
3311                 } while (err > 0 && !has_codec_parameters(st, NULL));
3312
3313                 if (err < 0) {
3314                     av_log(ic, AV_LOG_INFO,
3315                         "decoding for stream %d failed\n", st->index);
3316                 }
3317             }
3318         }
3319     }
3320
3321     // close codecs which were opened in try_decode_frame()
3322     for (i = 0; i < ic->nb_streams; i++) {
3323         st = ic->streams[i];
3324         avcodec_close(st->codec);
3325     }
3326
3327     ff_rfps_calculate(ic);
3328
3329     for (i = 0; i < ic->nb_streams; i++) {
3330         st = ic->streams[i];
3331         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3332             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3333                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3334                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3335                     st->codec->codec_tag= tag;
3336             }
3337
3338             /* estimate average framerate if not set by demuxer */
3339             if (st->info->codec_info_duration_fields &&
3340                 !st->avg_frame_rate.num &&
3341                 st->info->codec_info_duration) {
3342                 int best_fps      = 0;
3343                 double best_error = 0.01;
3344
3345                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3346                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3347                     st->info->codec_info_duration        < 0)
3348                     continue;
3349                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3350                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3351                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3352
3353                 /* Round guessed framerate to a "standard" framerate if it's
3354                  * within 1% of the original estimate. */
3355                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3356                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3357                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3358                                               av_q2d(std_fps) - 1);
3359
3360                     if (error < best_error) {
3361                         best_error = error;
3362                         best_fps   = std_fps.num;
3363                     }
3364                 }
3365                 if (best_fps)
3366                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3367                               best_fps, 12 * 1001, INT_MAX);
3368             }
3369
3370             if (!st->r_frame_rate.num) {
3371                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3372                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3373                     st->r_frame_rate.num = st->codec->time_base.den;
3374                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3375                 } else {
3376                     st->r_frame_rate.num = st->time_base.den;
3377                     st->r_frame_rate.den = st->time_base.num;
3378                 }
3379             }
3380             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3381                 AVRational hw_ratio = { st->codec->height, st->codec->width };
3382                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3383                                                    hw_ratio);
3384             }
3385         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3386             if (!st->codec->bits_per_coded_sample)
3387                 st->codec->bits_per_coded_sample =
3388                     av_get_bits_per_sample(st->codec->codec_id);
3389             // set stream disposition based on audio service type
3390             switch (st->codec->audio_service_type) {
3391             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3392                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3393                 break;
3394             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3395                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3396                 break;
3397             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3398                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3399                 break;
3400             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3401                 st->disposition = AV_DISPOSITION_COMMENT;
3402                 break;
3403             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3404                 st->disposition = AV_DISPOSITION_KARAOKE;
3405                 break;
3406             }
3407         }
3408     }
3409
3410     if (probesize)
3411     estimate_timings(ic, old_offset);
3412
3413     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3414
3415     if (ret >= 0 && ic->nb_streams)
3416         /* We could not have all the codec parameters before EOF. */
3417         ret = -1;
3418     for (i = 0; i < ic->nb_streams; i++) {
3419         const char *errmsg;
3420         st = ic->streams[i];
3421         if (!has_codec_parameters(st, &errmsg)) {
3422             char buf[256];
3423             avcodec_string(buf, sizeof(buf), st->codec, 0);
3424             av_log(ic, AV_LOG_WARNING,
3425                    "Could not find codec parameters for stream %d (%s): %s\n"
3426                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3427                    i, buf, errmsg);
3428         } else {
3429             ret = 0;
3430         }
3431     }
3432
3433     compute_chapters_end(ic);
3434
3435 find_stream_info_err:
3436     for (i = 0; i < ic->nb_streams; i++) {
3437         st = ic->streams[i];
3438         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3439             ic->streams[i]->codec->thread_count = 0;
3440         if (st->info)
3441             av_freep(&st->info->duration_error);
3442         av_freep(&ic->streams[i]->info);
3443     }
3444     if (ic->pb)
3445         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3446                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3447     return ret;
3448 }
3449
3450 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3451 {
3452     int i, j;
3453
3454     for (i = 0; i < ic->nb_programs; i++) {
3455         if (ic->programs[i] == last) {
3456             last = NULL;
3457         } else {
3458             if (!last)
3459                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3460                     if (ic->programs[i]->stream_index[j] == s)
3461                         return ic->programs[i];
3462         }
3463     }
3464     return NULL;
3465 }
3466
3467 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3468                         int wanted_stream_nb, int related_stream,
3469                         AVCodec **decoder_ret, int flags)
3470 {
3471     int i, nb_streams = ic->nb_streams;
3472     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3473     unsigned *program = NULL;
3474     const AVCodec *decoder = NULL, *best_decoder = NULL;
3475
3476     if (related_stream >= 0 && wanted_stream_nb < 0) {
3477         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3478         if (p) {
3479             program    = p->stream_index;
3480             nb_streams = p->nb_stream_indexes;
3481         }
3482     }
3483     for (i = 0; i < nb_streams; i++) {
3484         int real_stream_index = program ? program[i] : i;
3485         AVStream *st          = ic->streams[real_stream_index];
3486         AVCodecContext *avctx = st->codec;
3487         if (avctx->codec_type != type)
3488             continue;
3489         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3490             continue;
3491         if (wanted_stream_nb != real_stream_index &&
3492             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3493                                AV_DISPOSITION_VISUAL_IMPAIRED))
3494             continue;
3495         if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3496             continue;
3497         if (decoder_ret) {
3498             decoder = find_decoder(ic, st, st->codec->codec_id);
3499             if (!decoder) {
3500                 if (ret < 0)
3501                     ret = AVERROR_DECODER_NOT_FOUND;
3502                 continue;
3503             }
3504         }
3505         count = st->codec_info_nb_frames;
3506         bitrate = avctx->bit_rate;
3507         if (!bitrate)
3508             bitrate = avctx->rc_max_rate;
3509         multiframe = FFMIN(5, count);
3510         if ((best_multiframe >  multiframe) ||
3511             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3512             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3513             continue;
3514         best_count   = count;
3515         best_bitrate = bitrate;
3516         best_multiframe = multiframe;
3517         ret          = real_stream_index;
3518         best_decoder = decoder;
3519         if (program && i == nb_streams - 1 && ret < 0) {
3520             program    = NULL;
3521             nb_streams = ic->nb_streams;
3522             /* no related stream found, try again with everything */
3523             i = 0;
3524         }
3525     }
3526     if (decoder_ret)
3527         *decoder_ret = (AVCodec*)best_decoder;
3528     return ret;
3529 }
3530
3531 /*******************************************************/
3532
3533 int av_read_play(AVFormatContext *s)
3534 {
3535     if (s->iformat->read_play)
3536         return s->iformat->read_play(s);
3537     if (s->pb)
3538         return avio_pause(s->pb, 0);
3539     return AVERROR(ENOSYS);
3540 }
3541
3542 int av_read_pause(AVFormatContext *s)
3543 {
3544     if (s->iformat->read_pause)
3545         return s->iformat->read_pause(s);
3546     if (s->pb)
3547         return avio_pause(s->pb, 1);
3548     return AVERROR(ENOSYS);
3549 }
3550
3551 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3552     int j;
3553     av_assert0(s->nb_streams>0);
3554     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3555
3556     for (j = 0; j < st->nb_side_data; j++)
3557         av_freep(&st->side_data[j].data);
3558     av_freep(&st->side_data);
3559     st->nb_side_data = 0;
3560
3561     if (st->parser) {
3562         av_parser_close(st->parser);
3563     }
3564     if (st->attached_pic.data)
3565         av_free_packet(&st->attached_pic);
3566     av_dict_free(&st->metadata);
3567     av_freep(&st->probe_data.buf);
3568     av_freep(&st->index_entries);
3569     av_freep(&st->codec->extradata);
3570     av_freep(&st->codec->subtitle_header);
3571     av_freep(&st->codec);
3572     av_freep(&st->priv_data);
3573     if (st->info)
3574         av_freep(&st->info->duration_error);
3575     av_freep(&st->info);
3576     av_freep(&st->recommended_encoder_configuration);
3577     av_freep(&s->streams[ --s->nb_streams ]);
3578 }
3579
3580 void avformat_free_context(AVFormatContext *s)
3581 {
3582     int i;
3583
3584     if (!s)
3585         return;
3586
3587     av_opt_free(s);
3588     if (s->iformat && s->iformat->priv_class && s->priv_data)
3589         av_opt_free(s->priv_data);
3590     if (s->oformat && s->oformat->priv_class && s->priv_data)
3591         av_opt_free(s->priv_data);
3592
3593     for (i = s->nb_streams - 1; i >= 0; i--) {
3594         ff_free_stream(s, s->streams[i]);
3595     }
3596     for (i = s->nb_programs - 1; i >= 0; i--) {
3597         av_dict_free(&s->programs[i]->metadata);
3598         av_freep(&s->programs[i]->stream_index);
3599         av_freep(&s->programs[i]);
3600     }
3601     av_freep(&s->programs);
3602     av_freep(&s->priv_data);
3603     while (s->nb_chapters--) {
3604         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3605         av_freep(&s->chapters[s->nb_chapters]);
3606     }
3607     av_freep(&s->chapters);
3608     av_dict_free(&s->metadata);
3609     av_freep(&s->streams);
3610     av_freep(&s->internal);
3611     flush_packet_queue(s);
3612     av_free(s);
3613 }
3614
3615 void avformat_close_input(AVFormatContext **ps)
3616 {
3617     AVFormatContext *s;
3618     AVIOContext *pb;
3619
3620     if (!ps || !*ps)
3621         return;
3622
3623     s  = *ps;
3624     pb = s->pb;
3625
3626     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3627         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3628         pb = NULL;
3629
3630     flush_packet_queue(s);
3631
3632     if (s->iformat)
3633         if (s->iformat->read_close)
3634             s->iformat->read_close(s);
3635
3636     avformat_free_context(s);
3637
3638     *ps = NULL;
3639
3640     avio_close(pb);
3641 }
3642
3643 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3644 {
3645     AVStream *st;
3646     int i;
3647     AVStream **streams;
3648
3649     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3650         return NULL;
3651     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3652     if (!streams)
3653         return NULL;
3654     s->streams = streams;
3655
3656     st = av_mallocz(sizeof(AVStream));
3657     if (!st)
3658         return NULL;
3659     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3660         av_free(st);
3661         return NULL;
3662     }
3663     st->info->last_dts = AV_NOPTS_VALUE;
3664
3665     st->codec = avcodec_alloc_context3(c);
3666     if (!st->codec) {
3667         av_free(st->info);
3668         av_free(st);
3669         return NULL;
3670     }
3671     if (s->iformat) {
3672         /* no default bitrate if decoding */
3673         st->codec->bit_rate = 0;
3674
3675         /* default pts setting is MPEG-like */
3676         avpriv_set_pts_info(st, 33, 1, 90000);
3677     }
3678
3679     st->index      = s->nb_streams;
3680     st->start_time = AV_NOPTS_VALUE;
3681     st->duration   = AV_NOPTS_VALUE;
3682     /* we set the current DTS to 0 so that formats without any timestamps
3683      * but durations get some timestamps, formats with some unknown
3684      * timestamps have their first few packets buffered and the
3685      * timestamps corrected before they are returned to the user */
3686     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3687     st->first_dts     = AV_NOPTS_VALUE;
3688     st->probe_packets = MAX_PROBE_PACKETS;
3689     st->pts_wrap_reference = AV_NOPTS_VALUE;
3690     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3691
3692     st->last_IP_pts = AV_NOPTS_VALUE;
3693     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3694     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3695         st->pts_buffer[i] = AV_NOPTS_VALUE;
3696
3697     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3698
3699 #if FF_API_R_FRAME_RATE
3700     st->info->last_dts      = AV_NOPTS_VALUE;
3701 #endif
3702     st->info->fps_first_dts = AV_NOPTS_VALUE;
3703     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3704
3705     st->inject_global_side_data = s->internal->inject_global_side_data;
3706
3707     s->streams[s->nb_streams++] = st;
3708     return st;
3709 }
3710
3711 AVProgram *av_new_program(AVFormatContext *ac, int id)
3712 {
3713     AVProgram *program = NULL;
3714     int i;
3715
3716     av_dlog(ac, "new_program: id=0x%04x\n", id);
3717
3718     for (i = 0; i < ac->nb_programs; i++)
3719         if (ac->programs[i]->id == id)
3720             program = ac->programs[i];
3721
3722     if (!program) {
3723         program = av_mallocz(sizeof(AVProgram));
3724         if (!program)
3725             return NULL;
3726         dynarray_add(&ac->programs, &ac->nb_programs, program);
3727         program->discard = AVDISCARD_NONE;
3728     }
3729     program->id = id;
3730     program->pts_wrap_reference = AV_NOPTS_VALUE;
3731     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3732
3733     program->start_time =
3734     program->end_time   = AV_NOPTS_VALUE;
3735
3736     return program;
3737 }
3738
3739 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3740                               int64_t start, int64_t end, const char *title)
3741 {
3742     AVChapter *chapter = NULL;
3743     int i;
3744
3745     if (end != AV_NOPTS_VALUE && start > end) {
3746         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3747         return NULL;
3748     }
3749
3750     for (i = 0; i < s->nb_chapters; i++)
3751         if (s->chapters[i]->id == id)
3752             chapter = s->chapters[i];
3753
3754     if (!chapter) {
3755         chapter = av_mallocz(sizeof(AVChapter));
3756         if (!chapter)
3757             return NULL;
3758         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3759     }
3760     av_dict_set(&chapter->metadata, "title", title, 0);
3761     chapter->id        = id;
3762     chapter->time_base = time_base;
3763     chapter->start     = start;
3764     chapter->end       = end;
3765
3766     return chapter;
3767 }
3768
3769 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3770 {
3771     int i, j;
3772     AVProgram *program = NULL;
3773     void *tmp;
3774
3775     if (idx >= ac->nb_streams) {
3776         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3777         return;
3778     }
3779
3780     for (i = 0; i < ac->nb_programs; i++) {
3781         if (ac->programs[i]->id != progid)
3782             continue;
3783         program = ac->programs[i];
3784         for (j = 0; j < program->nb_stream_indexes; j++)
3785             if (program->stream_index[j] == idx)
3786                 return;
3787
3788         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3789         if (!tmp)
3790             return;
3791         program->stream_index = tmp;
3792         program->stream_index[program->nb_stream_indexes++] = idx;
3793         return;
3794     }
3795 }
3796
3797 uint64_t ff_ntp_time(void)
3798 {
3799     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3800 }
3801
3802 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3803 {
3804     const char *p;
3805     char *q, buf1[20], c;
3806     int nd, len, percentd_found;
3807
3808     q = buf;
3809     p = path;
3810     percentd_found = 0;
3811     for (;;) {
3812         c = *p++;
3813         if (c == '\0')
3814             break;
3815         if (c == '%') {
3816             do {
3817                 nd = 0;
3818                 while (av_isdigit(*p))
3819                     nd = nd * 10 + *p++ - '0';
3820                 c = *p++;
3821             } while (av_isdigit(c));
3822
3823             switch (c) {
3824             case '%':
3825                 goto addchar;
3826             case 'd':
3827                 if (percentd_found)
3828                     goto fail;
3829                 percentd_found = 1;
3830                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3831                 len = strlen(buf1);
3832                 if ((q - buf + len) > buf_size - 1)
3833                     goto fail;
3834                 memcpy(q, buf1, len);
3835                 q += len;
3836                 break;
3837             default:
3838                 goto fail;
3839             }
3840         } else {
3841 addchar:
3842             if ((q - buf) < buf_size - 1)
3843                 *q++ = c;
3844         }
3845     }
3846     if (!percentd_found)
3847         goto fail;
3848     *q = '\0';
3849     return 0;
3850 fail:
3851     *q = '\0';
3852     return -1;
3853 }
3854
3855 void av_url_split(char *proto, int proto_size,
3856                   char *authorization, int authorization_size,
3857                   char *hostname, int hostname_size,
3858                   int *port_ptr, char *path, int path_size, const char *url)
3859 {
3860     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3861
3862     if (port_ptr)
3863         *port_ptr = -1;
3864     if (proto_size > 0)
3865         proto[0] = 0;
3866     if (authorization_size > 0)
3867         authorization[0] = 0;
3868     if (hostname_size > 0)
3869         hostname[0] = 0;
3870     if (path_size > 0)
3871         path[0] = 0;
3872
3873     /* parse protocol */
3874     if ((p = strchr(url, ':'))) {
3875         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3876         p++; /* skip ':' */
3877         if (*p == '/')
3878             p++;
3879         if (*p == '/')
3880             p++;
3881     } else {
3882         /* no protocol means plain filename */
3883         av_strlcpy(path, url, path_size);
3884         return;
3885     }
3886
3887     /* separate path from hostname */
3888     ls = strchr(p, '/');
3889     ls2 = strchr(p, '?');
3890     if (!ls)
3891         ls = ls2;
3892     else if (ls && ls2)
3893         ls = FFMIN(ls, ls2);
3894     if (ls)
3895         av_strlcpy(path, ls, path_size);
3896     else
3897         ls = &p[strlen(p)];  // XXX
3898
3899     /* the rest is hostname, use that to parse auth/port */
3900     if (ls != p) {
3901         /* authorization (user[:pass]@hostname) */
3902         at2 = p;
3903         while ((at = strchr(p, '@')) && at < ls) {
3904             av_strlcpy(authorization, at2,
3905                        FFMIN(authorization_size, at + 1 - at2));
3906             p = at + 1; /* skip '@' */
3907         }
3908
3909         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3910             /* [host]:port */
3911             av_strlcpy(hostname, p + 1,
3912                        FFMIN(hostname_size, brk - p));
3913             if (brk[1] == ':' && port_ptr)
3914                 *port_ptr = atoi(brk + 2);
3915         } else if ((col = strchr(p, ':')) && col < ls) {
3916             av_strlcpy(hostname, p,
3917                        FFMIN(col + 1 - p, hostname_size));
3918             if (port_ptr)
3919                 *port_ptr = atoi(col + 1);
3920         } else
3921             av_strlcpy(hostname, p,
3922                        FFMIN(ls + 1 - p, hostname_size));
3923     }
3924 }
3925
3926 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3927 {
3928     int i;
3929     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3930                                            '4', '5', '6', '7',
3931                                            '8', '9', 'A', 'B',
3932                                            'C', 'D', 'E', 'F' };
3933     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3934                                            '4', '5', '6', '7',
3935                                            '8', '9', 'a', 'b',
3936                                            'c', 'd', 'e', 'f' };
3937     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3938
3939     for (i = 0; i < s; i++) {
3940         buff[i * 2]     = hex_table[src[i] >> 4];
3941         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3942     }
3943
3944     return buff;
3945 }
3946
3947 int ff_hex_to_data(uint8_t *data, const char *p)
3948 {
3949     int c, len, v;
3950
3951     len = 0;
3952     v   = 1;
3953     for (;;) {
3954         p += strspn(p, SPACE_CHARS);
3955         if (*p == '\0')
3956             break;
3957         c = av_toupper((unsigned char) *p++);
3958         if (c >= '0' && c <= '9')
3959             c = c - '0';
3960         else if (c >= 'A' && c <= 'F')
3961             c = c - 'A' + 10;
3962         else
3963             break;
3964         v = (v << 4) | c;
3965         if (v & 0x100) {
3966             if (data)
3967                 data[len] = v;
3968             len++;
3969             v = 1;
3970         }
3971     }
3972     return len;
3973 }
3974
3975 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3976                          unsigned int pts_num, unsigned int pts_den)
3977 {
3978     AVRational new_tb;
3979     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3980         if (new_tb.num != pts_num)
3981             av_log(NULL, AV_LOG_DEBUG,
3982                    "st:%d removing common factor %d from timebase\n",
3983                    s->index, pts_num / new_tb.num);
3984     } else
3985         av_log(NULL, AV_LOG_WARNING,
3986                "st:%d has too large timebase, reducing\n", s->index);
3987
3988     if (new_tb.num <= 0 || new_tb.den <= 0) {
3989         av_log(NULL, AV_LOG_ERROR,
3990                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3991                new_tb.num, new_tb.den,
3992                s->index);
3993         return;
3994     }
3995     s->time_base     = new_tb;
3996     av_codec_set_pkt_timebase(s->codec, new_tb);
3997     s->pts_wrap_bits = pts_wrap_bits;
3998 }
3999
4000 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4001                         void *context)
4002 {
4003     const char *ptr = str;
4004
4005     /* Parse key=value pairs. */
4006     for (;;) {
4007         const char *key;
4008         char *dest = NULL, *dest_end;
4009         int key_len, dest_len = 0;
4010
4011         /* Skip whitespace and potential commas. */
4012         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4013             ptr++;
4014         if (!*ptr)
4015             break;
4016
4017         key = ptr;
4018
4019         if (!(ptr = strchr(key, '=')))
4020             break;
4021         ptr++;
4022         key_len = ptr - key;
4023
4024         callback_get_buf(context, key, key_len, &dest, &dest_len);
4025         dest_end = dest + dest_len - 1;
4026
4027         if (*ptr == '\"') {
4028             ptr++;
4029             while (*ptr && *ptr != '\"') {
4030                 if (*ptr == '\\') {
4031                     if (!ptr[1])
4032                         break;
4033                     if (dest && dest < dest_end)
4034                         *dest++ = ptr[1];
4035                     ptr += 2;
4036                 } else {
4037                     if (dest && dest < dest_end)
4038                         *dest++ = *ptr;
4039                     ptr++;
4040                 }
4041             }
4042             if (*ptr == '\"')
4043                 ptr++;
4044         } else {
4045             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4046                 if (dest && dest < dest_end)
4047                     *dest++ = *ptr;
4048         }
4049         if (dest)
4050             *dest = 0;
4051     }
4052 }
4053
4054 int ff_find_stream_index(AVFormatContext *s, int id)
4055 {
4056     int i;
4057     for (i = 0; i < s->nb_streams; i++)
4058         if (s->streams[i]->id == id)
4059             return i;
4060     return -1;
4061 }
4062
4063 int64_t ff_iso8601_to_unix_time(const char *datestr)
4064 {
4065     struct tm time1 = { 0 }, time2 = { 0 };
4066     char *ret1, *ret2;
4067     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4068     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4069     if (ret2 && !ret1)
4070         return av_timegm(&time2);
4071     else
4072         return av_timegm(&time1);
4073 }
4074
4075 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4076                          int std_compliance)
4077 {
4078     if (ofmt) {
4079         if (ofmt->query_codec)
4080             return ofmt->query_codec(codec_id, std_compliance);
4081         else if (ofmt->codec_tag)
4082             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4083         else if (codec_id == ofmt->video_codec ||
4084                  codec_id == ofmt->audio_codec ||
4085                  codec_id == ofmt->subtitle_codec)
4086             return 1;
4087     }
4088     return AVERROR_PATCHWELCOME;
4089 }
4090
4091 int avformat_network_init(void)
4092 {
4093 #if CONFIG_NETWORK
4094     int ret;
4095     ff_network_inited_globally = 1;
4096     if ((ret = ff_network_init()) < 0)
4097         return ret;
4098     ff_tls_init();
4099 #endif
4100     return 0;
4101 }
4102
4103 int avformat_network_deinit(void)
4104 {
4105 #if CONFIG_NETWORK
4106     ff_network_close();
4107     ff_tls_deinit();
4108 #endif
4109     return 0;
4110 }
4111
4112 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4113                         uint64_t channel_layout, int32_t sample_rate,
4114                         int32_t width, int32_t height)
4115 {
4116     uint32_t flags = 0;
4117     int size = 4;
4118     uint8_t *data;
4119     if (!pkt)
4120         return AVERROR(EINVAL);
4121     if (channels) {
4122         size  += 4;
4123         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4124     }
4125     if (channel_layout) {
4126         size  += 8;
4127         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4128     }
4129     if (sample_rate) {
4130         size  += 4;
4131         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4132     }
4133     if (width || height) {
4134         size  += 8;
4135         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4136     }
4137     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4138     if (!data)
4139         return AVERROR(ENOMEM);
4140     bytestream_put_le32(&data, flags);
4141     if (channels)
4142         bytestream_put_le32(&data, channels);
4143     if (channel_layout)
4144         bytestream_put_le64(&data, channel_layout);
4145     if (sample_rate)
4146         bytestream_put_le32(&data, sample_rate);
4147     if (width || height) {
4148         bytestream_put_le32(&data, width);
4149         bytestream_put_le32(&data, height);
4150     }
4151     return 0;
4152 }
4153
4154 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4155 {
4156     AVRational undef = {0, 1};
4157     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4158     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4159     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4160
4161     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4162                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4163     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4164         stream_sample_aspect_ratio = undef;
4165
4166     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4167                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4168     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4169         frame_sample_aspect_ratio = undef;
4170
4171     if (stream_sample_aspect_ratio.num)
4172         return stream_sample_aspect_ratio;
4173     else
4174         return frame_sample_aspect_ratio;
4175 }
4176
4177 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4178 {
4179     AVRational fr = st->r_frame_rate;
4180     AVRational codec_fr = st->codec->framerate;
4181     AVRational   avg_fr = st->avg_frame_rate;
4182
4183     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4184         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4185         fr = avg_fr;
4186     }
4187
4188
4189     if (st->codec->ticks_per_frame > 1) {
4190         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4191             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4192             fr = codec_fr;
4193     }
4194
4195     return fr;
4196 }
4197
4198 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4199                                     const char *spec)
4200 {
4201     if (*spec <= '9' && *spec >= '0') /* opt:index */
4202         return strtol(spec, NULL, 0) == st->index;
4203     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4204              *spec == 't') { /* opt:[vasdt] */
4205         enum AVMediaType type;
4206
4207         switch (*spec++) {
4208         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4209         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4210         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4211         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4212         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4213         default:  av_assert0(0);
4214         }
4215         if (type != st->codec->codec_type)
4216             return 0;
4217         if (*spec++ == ':') { /* possibly followed by :index */
4218             int i, index = strtol(spec, NULL, 0);
4219             for (i = 0; i < s->nb_streams; i++)
4220                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4221                    return i == st->index;
4222             return 0;
4223         }
4224         return 1;
4225     } else if (*spec == 'p' && *(spec + 1) == ':') {
4226         int prog_id, i, j;
4227         char *endptr;
4228         spec += 2;
4229         prog_id = strtol(spec, &endptr, 0);
4230         for (i = 0; i < s->nb_programs; i++) {
4231             if (s->programs[i]->id != prog_id)
4232                 continue;
4233
4234             if (*endptr++ == ':') {
4235                 int stream_idx = strtol(endptr, NULL, 0);
4236                 return stream_idx >= 0 &&
4237                     stream_idx < s->programs[i]->nb_stream_indexes &&
4238                     st->index == s->programs[i]->stream_index[stream_idx];
4239             }
4240
4241             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4242                 if (st->index == s->programs[i]->stream_index[j])
4243                     return 1;
4244         }
4245         return 0;
4246     } else if (*spec == '#' ||
4247                (*spec == 'i' && *(spec + 1) == ':')) {
4248         int stream_id;
4249         char *endptr;
4250         spec += 1 + (*spec == 'i');
4251         stream_id = strtol(spec, &endptr, 0);
4252         if (!*endptr)
4253             return stream_id == st->id;
4254     } else if (*spec == 'm' && *(spec + 1) == ':') {
4255         AVDictionaryEntry *tag;
4256         char *key, *val;
4257         int ret;
4258
4259         spec += 2;
4260         val = strchr(spec, ':');
4261
4262         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4263         if (!key)
4264             return AVERROR(ENOMEM);
4265
4266         tag = av_dict_get(st->metadata, key, NULL, 0);
4267         if (tag) {
4268             if (!val || !strcmp(tag->value, val + 1))
4269                 ret = 1;
4270             else
4271                 ret = 0;
4272         } else
4273             ret = 0;
4274
4275         av_freep(&key);
4276         return ret;
4277     } else if (!*spec) /* empty specifier, matches everything */
4278         return 1;
4279
4280     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4281     return AVERROR(EINVAL);
4282 }
4283
4284 int ff_generate_avci_extradata(AVStream *st)
4285 {
4286     static const uint8_t avci100_1080p_extradata[] = {
4287         // SPS
4288         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4289         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4290         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4291         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4292         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4293         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4294         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4295         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4296         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4297         // PPS
4298         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4299         0xd0
4300     };
4301     static const uint8_t avci100_1080i_extradata[] = {
4302         // SPS
4303         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4304         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4305         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4306         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4307         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4308         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4309         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4310         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4311         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4312         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4313         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4314         // PPS
4315         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4316         0xd0
4317     };
4318     static const uint8_t avci50_1080p_extradata[] = {
4319         // SPS
4320         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4321         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4322         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4323         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4324         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4325         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4326         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4327         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4328         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4329         // PPS
4330         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4331         0x11
4332     };
4333     static const uint8_t avci50_1080i_extradata[] = {
4334         // SPS
4335         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4336         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4337         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4338         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4339         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4340         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4341         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4342         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4343         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4344         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4345         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4346         // PPS
4347         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4348         0x11
4349     };
4350     static const uint8_t avci100_720p_extradata[] = {
4351         // SPS
4352         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4353         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4354         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4355         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4356         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4357         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4358         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4359         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4360         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4361         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4362         // PPS
4363         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4364         0x11
4365     };
4366     static const uint8_t avci50_720p_extradata[] = {
4367         // SPS
4368         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4369         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4370         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4371         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4372         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4373         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4374         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4375         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4376         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4377         // PPS
4378         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4379         0x11
4380     };
4381
4382     const uint8_t *data = NULL;
4383     int size            = 0;
4384
4385     if (st->codec->width == 1920) {
4386         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4387             data = avci100_1080p_extradata;
4388             size = sizeof(avci100_1080p_extradata);
4389         } else {
4390             data = avci100_1080i_extradata;
4391             size = sizeof(avci100_1080i_extradata);
4392         }
4393     } else if (st->codec->width == 1440) {
4394         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4395             data = avci50_1080p_extradata;
4396             size = sizeof(avci50_1080p_extradata);
4397         } else {
4398             data = avci50_1080i_extradata;
4399             size = sizeof(avci50_1080i_extradata);
4400         }
4401     } else if (st->codec->width == 1280) {
4402         data = avci100_720p_extradata;
4403         size = sizeof(avci100_720p_extradata);
4404     } else if (st->codec->width == 960) {
4405         data = avci50_720p_extradata;
4406         size = sizeof(avci50_720p_extradata);
4407     }
4408
4409     if (!size)
4410         return 0;
4411
4412     av_freep(&st->codec->extradata);
4413     if (ff_alloc_extradata(st->codec, size))
4414         return AVERROR(ENOMEM);
4415     memcpy(st->codec->extradata, data, size);
4416
4417     return 0;
4418 }
4419
4420 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4421                                  int *size)
4422 {
4423     int i;
4424
4425     for (i = 0; i < st->nb_side_data; i++) {
4426         if (st->side_data[i].type == type) {
4427             if (size)
4428                 *size = st->side_data[i].size;
4429             return st->side_data[i].data;
4430         }
4431     }
4432     return NULL;
4433 }