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