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