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