git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

   1 /*
   2  * various utility functions for use within FFmpeg
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #undef NDEBUG
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <stdint.h>
  26
  27 #include "config.h"
  28
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/avstring.h"
  31 #include "libavutil/dict.h"
  32 #include "libavutil/internal.h"
  33 #include "libavutil/mathematics.h"
  34 #include "libavutil/opt.h"
  35 #include "libavutil/parseutils.h"
  36 #include "libavutil/pixdesc.h"
  37 #include "libavutil/time.h"
  38 #include "libavutil/timestamp.h"
  39
  40 #include "libavcodec/bytestream.h"
  41 #include "libavcodec/internal.h"
  42 #include "libavcodec/raw.h"
  43
  44 #include "audiointerleave.h"
  45 #include "avformat.h"
  46 #include "avio_internal.h"
  47 #include "id3v2.h"
  48 #include "internal.h"
  49 #include "metadata.h"
  50 #if CONFIG_NETWORK
  51 #include "network.h"
  52 #endif
  53 #include "riff.h"
  54 #include "url.h"
  55
  56 /**
  57  * @file
  58  * various utility functions for use within FFmpeg
  59  */
  60
  61 unsigned avformat_version(void)
  62 {
  63     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
  64     return LIBAVFORMAT_VERSION_INT;
  65 }
  66
  67 const char *avformat_configuration(void)
  68 {
  69     return FFMPEG_CONFIGURATION;
  70 }
  71
  72 const char *avformat_license(void)
  73 {
  74 #define LICENSE_PREFIX "libavformat license: "
  75     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  76 }
  77
  78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
  79
  80 static int is_relative(int64_t ts) {
  81     return ts > (RELATIVE_TS_BASE - (1LL<<48));
  82 }
  83
  84 /**
  85  * Wrap a given time stamp, if there is an indication for an overflow
  86  *
  87  * @param st stream
  88  * @param timestamp the time stamp to wrap
  89  * @return resulting time stamp
  90  */
  91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
  92 {
  93     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
  94         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
  95         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
  96             timestamp < st->pts_wrap_reference)
  97             return timestamp + (1ULL << st->pts_wrap_bits);
  98         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
  99             timestamp >= st->pts_wrap_reference)
 100             return timestamp - (1ULL << st->pts_wrap_bits);
 101     }
 102     return timestamp;
 103 }
 104
 105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
 106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
 107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
 108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
 109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
 110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
 111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
 112
 113 int64_t av_stream_get_end_pts(const AVStream *st)
 114 {
 115     return st->pts.val;
 116 }
 117
 118 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
 119 {
 120     return st->parser;
 121 }
 122
 123 void av_format_inject_global_side_data(AVFormatContext *s)
 124 {
 125     int i;
 126     s->internal->inject_global_side_data = 1;
 127     for (i = 0; i < s->nb_streams; i++) {
 128         AVStream *st = s->streams[i];
 129         st->inject_global_side_data = 1;
 130     }
 131 }
 132
 133 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 i;
1535     AVStream *st;
1536     int best_stream = 0;
1537     int best_score = -1;
1538
1539     if (s->nb_streams <= 0)
1540         return -1;
1541     for (i = 0; i < s->nb_streams; i++) {
1542         int score = 0;
1543         st = s->streams[i];
1544         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1545             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1546             if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1547                 score += 25;
1548             else
1549                 score += 100;
1550         }
1551         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1552             if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1553                 score += 12;
1554             else
1555                 score += 50;
1556         }
1557
1558         if (score > best_score) {
1559             best_score = score;
1560             best_stream = i;
1561         }
1562     }
1563     return best_stream;
1564 }
1565
1566 /** Flush the frame reader. */
1567 void ff_read_frame_flush(AVFormatContext *s)
1568 {
1569     AVStream *st;
1570     int i, j;
1571
1572     flush_packet_queue(s);
1573
1574     /* Reset read state for each stream. */
1575     for (i = 0; i < s->nb_streams; i++) {
1576         st = s->streams[i];
1577
1578         if (st->parser) {
1579             av_parser_close(st->parser);
1580             st->parser = NULL;
1581         }
1582         st->last_IP_pts = AV_NOPTS_VALUE;
1583         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1584         if (st->first_dts == AV_NOPTS_VALUE)
1585             st->cur_dts = RELATIVE_TS_BASE;
1586         else
1587             /* We set the current DTS to an unspecified origin. */
1588             st->cur_dts = AV_NOPTS_VALUE;
1589
1590         st->probe_packets = MAX_PROBE_PACKETS;
1591
1592         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1593             st->pts_buffer[j] = AV_NOPTS_VALUE;
1594
1595         if (s->internal->inject_global_side_data)
1596             st->inject_global_side_data = 1;
1597     }
1598 }
1599
1600 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1601 {
1602     int i;
1603
1604     for (i = 0; i < s->nb_streams; i++) {
1605         AVStream *st = s->streams[i];
1606
1607         st->cur_dts =
1608             av_rescale(timestamp,
1609                        st->time_base.den * (int64_t) ref_st->time_base.num,
1610                        st->time_base.num * (int64_t) ref_st->time_base.den);
1611     }
1612 }
1613
1614 void ff_reduce_index(AVFormatContext *s, int stream_index)
1615 {
1616     AVStream *st             = s->streams[stream_index];
1617     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1618
1619     if ((unsigned) st->nb_index_entries >= max_entries) {
1620         int i;
1621         for (i = 0; 2 * i < st->nb_index_entries; i++)
1622             st->index_entries[i] = st->index_entries[2 * i];
1623         st->nb_index_entries = i;
1624     }
1625 }
1626
1627 int ff_add_index_entry(AVIndexEntry **index_entries,
1628                        int *nb_index_entries,
1629                        unsigned int *index_entries_allocated_size,
1630                        int64_t pos, int64_t timestamp,
1631                        int size, int distance, int flags)
1632 {
1633     AVIndexEntry *entries, *ie;
1634     int index;
1635
1636     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1637         return -1;
1638
1639     if (timestamp == AV_NOPTS_VALUE)
1640         return AVERROR(EINVAL);
1641
1642     if (size < 0 || size > 0x3FFFFFFF)
1643         return AVERROR(EINVAL);
1644
1645     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1646         timestamp -= RELATIVE_TS_BASE;
1647
1648     entries = av_fast_realloc(*index_entries,
1649                               index_entries_allocated_size,
1650                               (*nb_index_entries + 1) *
1651                               sizeof(AVIndexEntry));
1652     if (!entries)
1653         return -1;
1654
1655     *index_entries = entries;
1656
1657     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1658                                       timestamp, AVSEEK_FLAG_ANY);
1659
1660     if (index < 0) {
1661         index = (*nb_index_entries)++;
1662         ie    = &entries[index];
1663         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1664     } else {
1665         ie = &entries[index];
1666         if (ie->timestamp != timestamp) {
1667             if (ie->timestamp <= timestamp)
1668                 return -1;
1669             memmove(entries + index + 1, entries + index,
1670                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1671             (*nb_index_entries)++;
1672         } else if (ie->pos == pos && distance < ie->min_distance)
1673             // do not reduce the distance
1674             distance = ie->min_distance;
1675     }
1676
1677     ie->pos          = pos;
1678     ie->timestamp    = timestamp;
1679     ie->min_distance = distance;
1680     ie->size         = size;
1681     ie->flags        = flags;
1682
1683     return index;
1684 }
1685
1686 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1687                        int size, int distance, int flags)
1688 {
1689     timestamp = wrap_timestamp(st, timestamp);
1690     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1691                               &st->index_entries_allocated_size, pos,
1692                               timestamp, size, distance, flags);
1693 }
1694
1695 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1696                               int64_t wanted_timestamp, int flags)
1697 {
1698     int a, b, m;
1699     int64_t timestamp;
1700
1701     a = -1;
1702     b = nb_entries;
1703
1704     // Optimize appending index entries at the end.
1705     if (b && entries[b - 1].timestamp < wanted_timestamp)
1706         a = b - 1;
1707
1708     while (b - a > 1) {
1709         m         = (a + b) >> 1;
1710         timestamp = entries[m].timestamp;
1711         if (timestamp >= wanted_timestamp)
1712             b = m;
1713         if (timestamp <= wanted_timestamp)
1714             a = m;
1715     }
1716     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1717
1718     if (!(flags & AVSEEK_FLAG_ANY))
1719         while (m >= 0 && m < nb_entries &&
1720                !(entries[m].flags & AVINDEX_KEYFRAME))
1721             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1722
1723     if (m == nb_entries)
1724         return -1;
1725     return m;
1726 }
1727
1728 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1729 {
1730     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1731                                      wanted_timestamp, flags);
1732 }
1733
1734 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1735                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1736 {
1737     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1738     if (stream_index >= 0)
1739         ts = wrap_timestamp(s->streams[stream_index], ts);
1740     return ts;
1741 }
1742
1743 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1744                          int64_t target_ts, int flags)
1745 {
1746     AVInputFormat *avif = s->iformat;
1747     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1748     int64_t ts_min, ts_max, ts;
1749     int index;
1750     int64_t ret;
1751     AVStream *st;
1752
1753     if (stream_index < 0)
1754         return -1;
1755
1756     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1757
1758     ts_max =
1759     ts_min = AV_NOPTS_VALUE;
1760     pos_limit = -1; // GCC falsely says it may be uninitialized.
1761
1762     st = s->streams[stream_index];
1763     if (st->index_entries) {
1764         AVIndexEntry *e;
1765
1766         /* FIXME: Whole function must be checked for non-keyframe entries in
1767          * index case, especially read_timestamp(). */
1768         index = av_index_search_timestamp(st, target_ts,
1769                                           flags | AVSEEK_FLAG_BACKWARD);
1770         index = FFMAX(index, 0);
1771         e     = &st->index_entries[index];
1772
1773         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1774             pos_min = e->pos;
1775             ts_min  = e->timestamp;
1776             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1777                     pos_min, av_ts2str(ts_min));
1778         } else {
1779             av_assert1(index == 0);
1780         }
1781
1782         index = av_index_search_timestamp(st, target_ts,
1783                                           flags & ~AVSEEK_FLAG_BACKWARD);
1784         av_assert0(index < st->nb_index_entries);
1785         if (index >= 0) {
1786             e = &st->index_entries[index];
1787             av_assert1(e->timestamp >= target_ts);
1788             pos_max   = e->pos;
1789             ts_max    = e->timestamp;
1790             pos_limit = pos_max - e->min_distance;
1791             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1792                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1793         }
1794     }
1795
1796     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1797                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
1798     if (pos < 0)
1799         return -1;
1800
1801     /* do the seek */
1802     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1803         return ret;
1804
1805     ff_read_frame_flush(s);
1806     ff_update_cur_dts(s, st, ts);
1807
1808     return 0;
1809 }
1810
1811 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1812                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1813 {
1814     int64_t step = 1024;
1815     int64_t limit, ts_max;
1816     int64_t filesize = avio_size(s->pb);
1817     int64_t pos_max  = filesize - 1;
1818     do {
1819         limit = pos_max;
1820         pos_max = FFMAX(0, (pos_max) - step);
1821         ts_max  = ff_read_timestamp(s, stream_index,
1822                                     &pos_max, limit, read_timestamp);
1823         step   += step;
1824     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1825     if (ts_max == AV_NOPTS_VALUE)
1826         return -1;
1827
1828     for (;;) {
1829         int64_t tmp_pos = pos_max + 1;
1830         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
1831                                             &tmp_pos, INT64_MAX, read_timestamp);
1832         if (tmp_ts == AV_NOPTS_VALUE)
1833             break;
1834         av_assert0(tmp_pos > pos_max);
1835         ts_max  = tmp_ts;
1836         pos_max = tmp_pos;
1837         if (tmp_pos >= filesize)
1838             break;
1839     }
1840
1841     if (ts)
1842         *ts = ts_max;
1843     if (pos)
1844         *pos = pos_max;
1845
1846     return 0;
1847 }
1848
1849 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1850                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1851                       int64_t ts_min, int64_t ts_max,
1852                       int flags, int64_t *ts_ret,
1853                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
1854                                                 int64_t *, int64_t))
1855 {
1856     int64_t pos, ts;
1857     int64_t start_pos;
1858     int no_change;
1859     int ret;
1860
1861     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1862
1863     if (ts_min == AV_NOPTS_VALUE) {
1864         pos_min = s->data_offset;
1865         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1866         if (ts_min == AV_NOPTS_VALUE)
1867             return -1;
1868     }
1869
1870     if (ts_min >= target_ts) {
1871         *ts_ret = ts_min;
1872         return pos_min;
1873     }
1874
1875     if (ts_max == AV_NOPTS_VALUE) {
1876         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1877             return ret;
1878         pos_limit = pos_max;
1879     }
1880
1881     if (ts_max <= target_ts) {
1882         *ts_ret = ts_max;
1883         return pos_max;
1884     }
1885
1886     if (ts_min > ts_max)
1887         return -1;
1888     else if (ts_min == ts_max)
1889         pos_limit = pos_min;
1890
1891     no_change = 0;
1892     while (pos_min < pos_limit) {
1893         av_dlog(s,
1894                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1895                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1896         assert(pos_limit <= pos_max);
1897
1898         if (no_change == 0) {
1899             int64_t approximate_keyframe_distance = pos_max - pos_limit;
1900             // interpolate position (better than dichotomy)
1901             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1902                              ts_max - ts_min) +
1903                   pos_min - approximate_keyframe_distance;
1904         } else if (no_change == 1) {
1905             // bisection if interpolation did not change min / max pos last time
1906             pos = (pos_min + pos_limit) >> 1;
1907         } else {
1908             /* linear search if bisection failed, can only happen if there
1909              * are very few or no keyframes between min/max */
1910             pos = pos_min;
1911         }
1912         if (pos <= pos_min)
1913             pos = pos_min + 1;
1914         else if (pos > pos_limit)
1915             pos = pos_limit;
1916         start_pos = pos;
1917
1918         // May pass pos_limit instead of -1.
1919         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1920         if (pos == pos_max)
1921             no_change++;
1922         else
1923             no_change = 0;
1924         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1925                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1926                 pos_min, pos, pos_max,
1927                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1928                 pos_limit, start_pos, no_change);
1929         if (ts == AV_NOPTS_VALUE) {
1930             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1931             return -1;
1932         }
1933         assert(ts != AV_NOPTS_VALUE);
1934         if (target_ts <= ts) {
1935             pos_limit = start_pos - 1;
1936             pos_max   = pos;
1937             ts_max    = ts;
1938         }
1939         if (target_ts >= ts) {
1940             pos_min = pos;
1941             ts_min  = ts;
1942         }
1943     }
1944
1945     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1946     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
1947 #if 0
1948     pos_min = pos;
1949     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1950     pos_min++;
1951     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1952     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1953             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1954 #endif
1955     *ts_ret = ts;
1956     return pos;
1957 }
1958
1959 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1960                            int64_t pos, int flags)
1961 {
1962     int64_t pos_min, pos_max;
1963
1964     pos_min = s->data_offset;
1965     pos_max = avio_size(s->pb) - 1;
1966
1967     if (pos < pos_min)
1968         pos = pos_min;
1969     else if (pos > pos_max)
1970         pos = pos_max;
1971
1972     avio_seek(s->pb, pos, SEEK_SET);
1973
1974     s->io_repositioned = 1;
1975
1976     return 0;
1977 }
1978
1979 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1980                               int64_t timestamp, int flags)
1981 {
1982     int index;
1983     int64_t ret;
1984     AVStream *st;
1985     AVIndexEntry *ie;
1986
1987     st = s->streams[stream_index];
1988
1989     index = av_index_search_timestamp(st, timestamp, flags);
1990
1991     if (index < 0 && st->nb_index_entries &&
1992         timestamp < st->index_entries[0].timestamp)
1993         return -1;
1994
1995     if (index < 0 || index == st->nb_index_entries - 1) {
1996         AVPacket pkt;
1997         int nonkey = 0;
1998
1999         if (st->nb_index_entries) {
2000             av_assert0(st->index_entries);
2001             ie = &st->index_entries[st->nb_index_entries - 1];
2002             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2003                 return ret;
2004             ff_update_cur_dts(s, st, ie->timestamp);
2005         } else {
2006             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2007                 return ret;
2008         }
2009         for (;;) {
2010             int read_status;
2011             do {
2012                 read_status = av_read_frame(s, &pkt);
2013             } while (read_status == AVERROR(EAGAIN));
2014             if (read_status < 0)
2015                 break;
2016             av_free_packet(&pkt);
2017             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2018                 if (pkt.flags & AV_PKT_FLAG_KEY)
2019                     break;
2020                 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2021                     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);
2022                     break;
2023                 }
2024             }
2025         }
2026         index = av_index_search_timestamp(st, timestamp, flags);
2027     }
2028     if (index < 0)
2029         return -1;
2030
2031     ff_read_frame_flush(s);
2032     if (s->iformat->read_seek)
2033         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2034             return 0;
2035     ie = &st->index_entries[index];
2036     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2037         return ret;
2038     ff_update_cur_dts(s, st, ie->timestamp);
2039
2040     return 0;
2041 }
2042
2043 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2044                                int64_t timestamp, int flags)
2045 {
2046     int ret;
2047     AVStream *st;
2048
2049     if (flags & AVSEEK_FLAG_BYTE) {
2050         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2051             return -1;
2052         ff_read_frame_flush(s);
2053         return seek_frame_byte(s, stream_index, timestamp, flags);
2054     }
2055
2056     if (stream_index < 0) {
2057         stream_index = av_find_default_stream_index(s);
2058         if (stream_index < 0)
2059             return -1;
2060
2061         st = s->streams[stream_index];
2062         /* timestamp for default must be expressed in AV_TIME_BASE units */
2063         timestamp = av_rescale(timestamp, st->time_base.den,
2064                                AV_TIME_BASE * (int64_t) st->time_base.num);
2065     }
2066
2067     /* first, we try the format specific seek */
2068     if (s->iformat->read_seek) {
2069         ff_read_frame_flush(s);
2070         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2071     } else
2072         ret = -1;
2073     if (ret >= 0)
2074         return 0;
2075
2076     if (s->iformat->read_timestamp &&
2077         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2078         ff_read_frame_flush(s);
2079         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2080     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2081         ff_read_frame_flush(s);
2082         return seek_frame_generic(s, stream_index, timestamp, flags);
2083     } else
2084         return -1;
2085 }
2086
2087 int av_seek_frame(AVFormatContext *s, int stream_index,
2088                   int64_t timestamp, int flags)
2089 {
2090     int ret;
2091
2092     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2093         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2094         if ((flags & AVSEEK_FLAG_BACKWARD))
2095             max_ts = timestamp;
2096         else
2097             min_ts = timestamp;
2098         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2099                                   flags & ~AVSEEK_FLAG_BACKWARD);
2100     }
2101
2102     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2103
2104     if (ret >= 0)
2105         ret = avformat_queue_attached_pictures(s);
2106
2107     return ret;
2108 }
2109
2110 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2111                        int64_t ts, int64_t max_ts, int flags)
2112 {
2113     if (min_ts > ts || max_ts < ts)
2114         return -1;
2115     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2116         return AVERROR(EINVAL);
2117
2118     if (s->seek2any>0)
2119         flags |= AVSEEK_FLAG_ANY;
2120     flags &= ~AVSEEK_FLAG_BACKWARD;
2121
2122     if (s->iformat->read_seek2) {
2123         int ret;
2124         ff_read_frame_flush(s);
2125
2126         if (stream_index == -1 && s->nb_streams == 1) {
2127             AVRational time_base = s->streams[0]->time_base;
2128             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2129             min_ts = av_rescale_rnd(min_ts, time_base.den,
2130                                     time_base.num * (int64_t)AV_TIME_BASE,
2131                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2132             max_ts = av_rescale_rnd(max_ts, time_base.den,
2133                                     time_base.num * (int64_t)AV_TIME_BASE,
2134                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2135         }
2136
2137         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2138                                      ts, max_ts, flags);
2139
2140         if (ret >= 0)
2141             ret = avformat_queue_attached_pictures(s);
2142         return ret;
2143     }
2144
2145     if (s->iformat->read_timestamp) {
2146         // try to seek via read_timestamp()
2147     }
2148
2149     // Fall back on old API if new is not implemented but old is.
2150     // Note the old API has somewhat different semantics.
2151     if (s->iformat->read_seek || 1) {
2152         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2153         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2154         if (ret<0 && ts != min_ts && max_ts != ts) {
2155             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2156             if (ret >= 0)
2157                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2158         }
2159         return ret;
2160     }
2161
2162     // try some generic seek like seek_frame_generic() but with new ts semantics
2163     return -1; //unreachable
2164 }
2165
2166 /*******************************************************/
2167
2168 /**
2169  * Return TRUE if the stream has accurate duration in any stream.
2170  *
2171  * @return TRUE if the stream has accurate duration for at least one component.
2172  */
2173 static int has_duration(AVFormatContext *ic)
2174 {
2175     int i;
2176     AVStream *st;
2177
2178     for (i = 0; i < ic->nb_streams; i++) {
2179         st = ic->streams[i];
2180         if (st->duration != AV_NOPTS_VALUE)
2181             return 1;
2182     }
2183     if (ic->duration != AV_NOPTS_VALUE)
2184         return 1;
2185     return 0;
2186 }
2187
2188 /**
2189  * Estimate the stream timings from the one of each components.
2190  *
2191  * Also computes the global bitrate if possible.
2192  */
2193 static void update_stream_timings(AVFormatContext *ic)
2194 {
2195     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2196     int64_t duration, duration1, filesize;
2197     int i;
2198     AVStream *st;
2199     AVProgram *p;
2200
2201     start_time = INT64_MAX;
2202     start_time_text = INT64_MAX;
2203     end_time   = INT64_MIN;
2204     duration   = INT64_MIN;
2205     for (i = 0; i < ic->nb_streams; i++) {
2206         st = ic->streams[i];
2207         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2208             start_time1 = av_rescale_q(st->start_time, st->time_base,
2209                                        AV_TIME_BASE_Q);
2210             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2211                 if (start_time1 < start_time_text)
2212                     start_time_text = start_time1;
2213             } else
2214                 start_time = FFMIN(start_time, start_time1);
2215             end_time1   = AV_NOPTS_VALUE;
2216             if (st->duration != AV_NOPTS_VALUE) {
2217                 end_time1 = start_time1 +
2218                             av_rescale_q(st->duration, st->time_base,
2219                                          AV_TIME_BASE_Q);
2220                 end_time = FFMAX(end_time, end_time1);
2221             }
2222             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2223                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2224                     p->start_time = start_time1;
2225                 if (p->end_time < end_time1)
2226                     p->end_time = end_time1;
2227             }
2228         }
2229         if (st->duration != AV_NOPTS_VALUE) {
2230             duration1 = av_rescale_q(st->duration, st->time_base,
2231                                      AV_TIME_BASE_Q);
2232             duration  = FFMAX(duration, duration1);
2233         }
2234     }
2235     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2236         start_time = start_time_text;
2237     else if (start_time > start_time_text)
2238         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2239
2240     if (start_time != INT64_MAX) {
2241         ic->start_time = start_time;
2242         if (end_time != INT64_MIN) {
2243             if (ic->nb_programs) {
2244                 for (i = 0; i < ic->nb_programs; i++) {
2245                     p = ic->programs[i];
2246                     if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2247                         duration = FFMAX(duration, p->end_time - p->start_time);
2248                 }
2249             } else
2250                 duration = FFMAX(duration, end_time - start_time);
2251         }
2252     }
2253     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2254         ic->duration = duration;
2255     }
2256     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2257         /* compute the bitrate */
2258         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2259                          (double) ic->duration;
2260         if (bitrate >= 0 && bitrate <= INT_MAX)
2261             ic->bit_rate = bitrate;
2262     }
2263 }
2264
2265 static void fill_all_stream_timings(AVFormatContext *ic)
2266 {
2267     int i;
2268     AVStream *st;
2269
2270     update_stream_timings(ic);
2271     for (i = 0; i < ic->nb_streams; i++) {
2272         st = ic->streams[i];
2273         if (st->start_time == AV_NOPTS_VALUE) {
2274             if (ic->start_time != AV_NOPTS_VALUE)
2275                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2276                                               st->time_base);
2277             if (ic->duration != AV_NOPTS_VALUE)
2278                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2279                                             st->time_base);
2280         }
2281     }
2282 }
2283
2284 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2285 {
2286     int64_t filesize, duration;
2287     int i, show_warning = 0;
2288     AVStream *st;
2289
2290     /* if bit_rate is already set, we believe it */
2291     if (ic->bit_rate <= 0) {
2292         int bit_rate = 0;
2293         for (i = 0; i < ic->nb_streams; i++) {
2294             st = ic->streams[i];
2295             if (st->codec->bit_rate > 0) {
2296                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2297                     bit_rate = 0;
2298                     break;
2299                 }
2300                 bit_rate += st->codec->bit_rate;
2301             }
2302         }
2303         ic->bit_rate = bit_rate;
2304     }
2305
2306     /* if duration is already set, we believe it */
2307     if (ic->duration == AV_NOPTS_VALUE &&
2308         ic->bit_rate != 0) {
2309         filesize = ic->pb ? avio_size(ic->pb) : 0;
2310         if (filesize > 0) {
2311             for (i = 0; i < ic->nb_streams; i++) {
2312                 st      = ic->streams[i];
2313                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2314                     && st->duration == AV_NOPTS_VALUE) {
2315                     duration = av_rescale(8 * filesize, st->time_base.den,
2316                                           ic->bit_rate *
2317                                           (int64_t) st->time_base.num);
2318                     st->duration = duration;
2319                     show_warning = 1;
2320                 }
2321             }
2322         }
2323     }
2324     if (show_warning)
2325         av_log(ic, AV_LOG_WARNING,
2326                "Estimating duration from bitrate, this may be inaccurate\n");
2327 }
2328
2329 #define DURATION_MAX_READ_SIZE 250000LL
2330 #define DURATION_MAX_RETRY 4
2331
2332 /* only usable for MPEG-PS streams */
2333 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2334 {
2335     AVPacket pkt1, *pkt = &pkt1;
2336     AVStream *st;
2337     int num, den, read_size, i, ret;
2338     int found_duration = 0;
2339     int is_end;
2340     int64_t filesize, offset, duration;
2341     int retry = 0;
2342
2343     /* flush packet queue */
2344     flush_packet_queue(ic);
2345
2346     for (i = 0; i < ic->nb_streams; i++) {
2347         st = ic->streams[i];
2348         if (st->start_time == AV_NOPTS_VALUE &&
2349             st->first_dts == AV_NOPTS_VALUE &&
2350             st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2351             av_log(st->codec, AV_LOG_WARNING,
2352                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2353
2354         if (st->parser) {
2355             av_parser_close(st->parser);
2356             st->parser = NULL;
2357         }
2358     }
2359
2360     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2361     /* estimate the end time (duration) */
2362     /* XXX: may need to support wrapping */
2363     filesize = ic->pb ? avio_size(ic->pb) : 0;
2364     do {
2365         is_end = found_duration;
2366         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2367         if (offset < 0)
2368             offset = 0;
2369
2370         avio_seek(ic->pb, offset, SEEK_SET);
2371         read_size = 0;
2372         for (;;) {
2373             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2374                 break;
2375
2376             do {
2377                 ret = ff_read_packet(ic, pkt);
2378             } while (ret == AVERROR(EAGAIN));
2379             if (ret != 0)
2380                 break;
2381             read_size += pkt->size;
2382             st         = ic->streams[pkt->stream_index];
2383             if (pkt->pts != AV_NOPTS_VALUE &&
2384                 (st->start_time != AV_NOPTS_VALUE ||
2385                  st->first_dts  != AV_NOPTS_VALUE)) {
2386                 if (pkt->duration == 0) {
2387                     ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2388                     if (den && num) {
2389                         pkt->duration = av_rescale_rnd(1,
2390                                            num * (int64_t) st->time_base.den,
2391                                            den * (int64_t) st->time_base.num,
2392                                            AV_ROUND_DOWN);
2393                     }
2394                 }
2395                 duration = pkt->pts + pkt->duration;
2396                 found_duration = 1;
2397                 if (st->start_time != AV_NOPTS_VALUE)
2398                     duration -= st->start_time;
2399                 else
2400                     duration -= st->first_dts;
2401                 if (duration > 0) {
2402                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2403                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2404                         st->duration = duration;
2405                     st->info->last_duration = duration;
2406                 }
2407             }
2408             av_free_packet(pkt);
2409         }
2410
2411         /* check if all audio/video streams have valid duration */
2412         if (!is_end) {
2413             is_end = 1;
2414             for (i = 0; i < ic->nb_streams; i++) {
2415                 st = ic->streams[i];
2416                 switch (st->codec->codec_type) {
2417                     case AVMEDIA_TYPE_VIDEO:
2418                     case AVMEDIA_TYPE_AUDIO:
2419                         if (st->duration == AV_NOPTS_VALUE)
2420                             is_end = 0;
2421                 }
2422             }
2423         }
2424     } while (!is_end &&
2425              offset &&
2426              ++retry <= DURATION_MAX_RETRY);
2427
2428     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2429
2430     /* warn about audio/video streams which duration could not be estimated */
2431     for (i = 0; i < ic->nb_streams; i++) {
2432         st = ic->streams[i];
2433         if (st->duration == AV_NOPTS_VALUE) {
2434             switch (st->codec->codec_type) {
2435             case AVMEDIA_TYPE_VIDEO:
2436             case AVMEDIA_TYPE_AUDIO:
2437                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2438                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2439                 } else
2440                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2441             }
2442         }
2443     }
2444     fill_all_stream_timings(ic);
2445
2446     avio_seek(ic->pb, old_offset, SEEK_SET);
2447     for (i = 0; i < ic->nb_streams; i++) {
2448         int j;
2449
2450         st              = ic->streams[i];
2451         st->cur_dts     = st->first_dts;
2452         st->last_IP_pts = AV_NOPTS_VALUE;
2453         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2454         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2455             st->pts_buffer[j] = AV_NOPTS_VALUE;
2456     }
2457 }
2458
2459 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2460 {
2461     int64_t file_size;
2462
2463     /* get the file size, if possible */
2464     if (ic->iformat->flags & AVFMT_NOFILE) {
2465         file_size = 0;
2466     } else {
2467         file_size = avio_size(ic->pb);
2468         file_size = FFMAX(0, file_size);
2469     }
2470
2471     if ((!strcmp(ic->iformat->name, "mpeg") ||
2472          !strcmp(ic->iformat->name, "mpegts")) &&
2473         file_size && ic->pb->seekable) {
2474         /* get accurate estimate from the PTSes */
2475         estimate_timings_from_pts(ic, old_offset);
2476         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2477     } else if (has_duration(ic)) {
2478         /* at least one component has timings - we use them for all
2479          * the components */
2480         fill_all_stream_timings(ic);
2481         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2482     } else {
2483         /* less precise: use bitrate info */
2484         estimate_timings_from_bit_rate(ic);
2485         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2486     }
2487     update_stream_timings(ic);
2488
2489     {
2490         int i;
2491         AVStream av_unused *st;
2492         for (i = 0; i < ic->nb_streams; i++) {
2493             st = ic->streams[i];
2494             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2495                     (double) st->start_time / AV_TIME_BASE,
2496                     (double) st->duration   / AV_TIME_BASE);
2497         }
2498         av_dlog(ic,
2499                 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2500                 (double) ic->start_time / AV_TIME_BASE,
2501                 (double) ic->duration   / AV_TIME_BASE,
2502                 ic->bit_rate / 1000);
2503     }
2504 }
2505
2506 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2507 {
2508     AVCodecContext *avctx = st->codec;
2509
2510 #define FAIL(errmsg) do {                                         \
2511         if (errmsg_ptr)                                           \
2512             *errmsg_ptr = errmsg;                                 \
2513         return 0;                                                 \
2514     } while (0)
2515
2516     if (   avctx->codec_id == AV_CODEC_ID_NONE
2517         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2518         FAIL("unknown codec");
2519     switch (avctx->codec_type) {
2520     case AVMEDIA_TYPE_AUDIO:
2521         if (!avctx->frame_size && determinable_frame_size(avctx))
2522             FAIL("unspecified frame size");
2523         if (st->info->found_decoder >= 0 &&
2524             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2525             FAIL("unspecified sample format");
2526         if (!avctx->sample_rate)
2527             FAIL("unspecified sample rate");
2528         if (!avctx->channels)
2529             FAIL("unspecified number of channels");
2530         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2531             FAIL("no decodable DTS frames");
2532         break;
2533     case AVMEDIA_TYPE_VIDEO:
2534         if (!avctx->width)
2535             FAIL("unspecified size");
2536         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2537             FAIL("unspecified pixel format");
2538         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2539             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2540                 FAIL("no frame in rv30/40 and no sar");
2541         break;
2542     case AVMEDIA_TYPE_SUBTITLE:
2543         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2544             FAIL("unspecified size");
2545         break;
2546     case AVMEDIA_TYPE_DATA:
2547         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2548     }
2549
2550     return 1;
2551 }
2552
2553 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2554 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2555                             AVDictionary **options)
2556 {
2557     const AVCodec *codec;
2558     int got_picture = 1, ret = 0;
2559     AVFrame *frame = av_frame_alloc();
2560     AVSubtitle subtitle;
2561     AVPacket pkt = *avpkt;
2562
2563     if (!frame)
2564         return AVERROR(ENOMEM);
2565
2566     if (!avcodec_is_open(st->codec) &&
2567         st->info->found_decoder <= 0 &&
2568         (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2569         AVDictionary *thread_opt = NULL;
2570
2571         codec = find_decoder(s, st, st->codec->codec_id);
2572
2573         if (!codec) {
2574             st->info->found_decoder = -st->codec->codec_id;
2575             ret                     = -1;
2576             goto fail;
2577         }
2578
2579         /* Force thread count to 1 since the H.264 decoder will not extract
2580          * SPS and PPS to extradata during multi-threaded decoding. */
2581         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2582         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2583         if (!options)
2584             av_dict_free(&thread_opt);
2585         if (ret < 0) {
2586             st->info->found_decoder = -st->codec->codec_id;
2587             goto fail;
2588         }
2589         st->info->found_decoder = 1;
2590     } else if (!st->info->found_decoder)
2591         st->info->found_decoder = 1;
2592
2593     if (st->info->found_decoder < 0) {
2594         ret = -1;
2595         goto fail;
2596     }
2597
2598     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2599            ret >= 0 &&
2600            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2601             (!st->codec_info_nb_frames &&
2602              st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2603         got_picture = 0;
2604         switch (st->codec->codec_type) {
2605         case AVMEDIA_TYPE_VIDEO:
2606             ret = avcodec_decode_video2(st->codec, frame,
2607                                         &got_picture, &pkt);
2608             break;
2609         case AVMEDIA_TYPE_AUDIO:
2610             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2611             break;
2612         case AVMEDIA_TYPE_SUBTITLE:
2613             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2614                                            &got_picture, &pkt);
2615             ret = pkt.size;
2616             break;
2617         default:
2618             break;
2619         }
2620         if (ret >= 0) {
2621             if (got_picture)
2622                 st->nb_decoded_frames++;
2623             pkt.data += ret;
2624             pkt.size -= ret;
2625             ret       = got_picture;
2626         }
2627     }
2628
2629     if (!pkt.data && !got_picture)
2630         ret = -1;
2631
2632 fail:
2633     av_frame_free(&frame);
2634     return ret;
2635 }
2636
2637 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2638 {
2639     while (tags->id != AV_CODEC_ID_NONE) {
2640         if (tags->id == id)
2641             return tags->tag;
2642         tags++;
2643     }
2644     return 0;
2645 }
2646
2647 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2648 {
2649     int i;
2650     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2651         if (tag == tags[i].tag)
2652             return tags[i].id;
2653     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2654         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2655             return tags[i].id;
2656     return AV_CODEC_ID_NONE;
2657 }
2658
2659 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2660 {
2661     if (flt) {
2662         switch (bps) {
2663         case 32:
2664             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2665         case 64:
2666             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2667         default:
2668             return AV_CODEC_ID_NONE;
2669         }
2670     } else {
2671         bps  += 7;
2672         bps >>= 3;
2673         if (sflags & (1 << (bps - 1))) {
2674             switch (bps) {
2675             case 1:
2676                 return AV_CODEC_ID_PCM_S8;
2677             case 2:
2678                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2679             case 3:
2680                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2681             case 4:
2682                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2683             default:
2684                 return AV_CODEC_ID_NONE;
2685             }
2686         } else {
2687             switch (bps) {
2688             case 1:
2689                 return AV_CODEC_ID_PCM_U8;
2690             case 2:
2691                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2692             case 3:
2693                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2694             case 4:
2695                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2696             default:
2697                 return AV_CODEC_ID_NONE;
2698             }
2699         }
2700     }
2701 }
2702
2703 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2704 {
2705     unsigned int tag;
2706     if (!av_codec_get_tag2(tags, id, &tag))
2707         return 0;
2708     return tag;
2709 }
2710
2711 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2712                       unsigned int *tag)
2713 {
2714     int i;
2715     for (i = 0; tags && tags[i]; i++) {
2716         const AVCodecTag *codec_tags = tags[i];
2717         while (codec_tags->id != AV_CODEC_ID_NONE) {
2718             if (codec_tags->id == id) {
2719                 *tag = codec_tags->tag;
2720                 return 1;
2721             }
2722             codec_tags++;
2723         }
2724     }
2725     return 0;
2726 }
2727
2728 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2729 {
2730     int i;
2731     for (i = 0; tags && tags[i]; i++) {
2732         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2733         if (id != AV_CODEC_ID_NONE)
2734             return id;
2735     }
2736     return AV_CODEC_ID_NONE;
2737 }
2738
2739 static void compute_chapters_end(AVFormatContext *s)
2740 {
2741     unsigned int i, j;
2742     int64_t max_time = s->duration +
2743                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2744
2745     for (i = 0; i < s->nb_chapters; i++)
2746         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2747             AVChapter *ch = s->chapters[i];
2748             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2749                                                   ch->time_base)
2750                                    : INT64_MAX;
2751
2752             for (j = 0; j < s->nb_chapters; j++) {
2753                 AVChapter *ch1     = s->chapters[j];
2754                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2755                                                   ch->time_base);
2756                 if (j != i && next_start > ch->start && next_start < end)
2757                     end = next_start;
2758             }
2759             ch->end = (end == INT64_MAX) ? ch->start : end;
2760         }
2761 }
2762
2763 static int get_std_framerate(int i)
2764 {
2765     if (i < 60 * 12)
2766         return (i + 1) * 1001;
2767     else
2768         return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2769 }
2770
2771 /* Is the time base unreliable?
2772  * This is a heuristic to balance between quick acceptance of the values in
2773  * the headers vs. some extra checks.
2774  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2775  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2776  * And there are "variable" fps files this needs to detect as well. */
2777 static int tb_unreliable(AVCodecContext *c)
2778 {
2779     if (c->time_base.den >= 101L * c->time_base.num ||
2780         c->time_base.den <    5L * c->time_base.num ||
2781         // c->codec_tag == AV_RL32("DIVX") ||
2782         // c->codec_tag == AV_RL32("XVID") ||
2783         c->codec_tag == AV_RL32("mp4v") ||
2784         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2785         c->codec_id == AV_CODEC_ID_GIF ||
2786         c->codec_id == AV_CODEC_ID_H264)
2787         return 1;
2788     return 0;
2789 }
2790
2791 #if FF_API_FORMAT_PARAMETERS
2792 int av_find_stream_info(AVFormatContext *ic)
2793 {
2794     return avformat_find_stream_info(ic, NULL);
2795 }
2796 #endif
2797
2798 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2799 {
2800     int ret;
2801
2802     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2803         avctx->extradata_size = 0;
2804         return AVERROR(EINVAL);
2805     }
2806     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2807     if (avctx->extradata) {
2808         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2809         avctx->extradata_size = size;
2810         ret = 0;
2811     } else {
2812         avctx->extradata_size = 0;
2813         ret = AVERROR(ENOMEM);
2814     }
2815     return ret;
2816 }
2817
2818 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2819 {
2820     int ret = ff_alloc_extradata(avctx, size);
2821     if (ret < 0)
2822         return ret;
2823     ret = avio_read(pb, avctx->extradata, size);
2824     if (ret != size) {
2825         av_freep(&avctx->extradata);
2826         avctx->extradata_size = 0;
2827         av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2828         return ret < 0 ? ret : AVERROR_INVALIDDATA;
2829     }
2830
2831     return ret;
2832 }
2833
2834 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2835 {
2836     int i, j;
2837     int64_t last = st->info->last_dts;
2838
2839     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2840        && ts - (uint64_t)last < INT64_MAX) {
2841         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2842         int64_t duration = ts - last;
2843
2844         if (!st->info->duration_error)
2845             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2846         if (!st->info->duration_error)
2847             return AVERROR(ENOMEM);
2848
2849 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2850 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2851         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2852             if (st->info->duration_error[0][1][i] < 1e10) {
2853                 int framerate = get_std_framerate(i);
2854                 double sdts = dts*framerate/(1001*12);
2855                 for (j= 0; j<2; j++) {
2856                     int64_t ticks = llrint(sdts+j*0.5);
2857                     double error= sdts - ticks + j*0.5;
2858                     st->info->duration_error[j][0][i] += error;
2859                     st->info->duration_error[j][1][i] += error*error;
2860                 }
2861             }
2862         }
2863         st->info->duration_count++;
2864         st->info->rfps_duration_sum += duration;
2865
2866         if (st->info->duration_count % 10 == 0) {
2867             int n = st->info->duration_count;
2868             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2869                 if (st->info->duration_error[0][1][i] < 1e10) {
2870                     double a0     = st->info->duration_error[0][0][i] / n;
2871                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2872                     double a1     = st->info->duration_error[1][0][i] / n;
2873                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2874                     if (error0 > 0.04 && error1 > 0.04) {
2875                         st->info->duration_error[0][1][i] = 2e10;
2876                         st->info->duration_error[1][1][i] = 2e10;
2877                     }
2878                 }
2879             }
2880         }
2881
2882         // ignore the first 4 values, they might have some random jitter
2883         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2884             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2885     }
2886     if (ts != AV_NOPTS_VALUE)
2887         st->info->last_dts = ts;
2888
2889     return 0;
2890 }
2891
2892 void ff_rfps_calculate(AVFormatContext *ic)
2893 {
2894     int i, j;
2895
2896     for (i = 0; i < ic->nb_streams; i++) {
2897         AVStream *st = ic->streams[i];
2898
2899         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2900             continue;
2901         // the check for tb_unreliable() is not completely correct, since this is not about handling
2902         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2903         // ipmovie.c produces.
2904         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)
2905             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);
2906         if (st->info->duration_count>1 && !st->r_frame_rate.num
2907             && tb_unreliable(st->codec)) {
2908             int num = 0;
2909             double best_error= 0.01;
2910             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2911
2912             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2913                 int k;
2914
2915                 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2916                     continue;
2917                 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2918                     continue;
2919
2920                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2921                     continue;
2922
2923                 for (k= 0; k<2; k++) {
2924                     int n = st->info->duration_count;
2925                     double a= st->info->duration_error[k][0][j] / n;
2926                     double error= st->info->duration_error[k][1][j]/n - a*a;
2927
2928                     if (error < best_error && best_error> 0.000000001) {
2929                         best_error= error;
2930                         num = get_std_framerate(j);
2931                     }
2932                     if (error < 0.02)
2933                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2934                 }
2935             }
2936             // do not increase frame rate by more than 1 % in order to match a standard rate.
2937             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2938                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2939         }
2940         if (   !st->avg_frame_rate.num
2941             && st->r_frame_rate.num && st->info->rfps_duration_sum
2942             && st->info->codec_info_duration <= 0
2943             && st->info->duration_count > 2
2944             && 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
2945             ) {
2946             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2947             st->avg_frame_rate = st->r_frame_rate;
2948         }
2949
2950         av_freep(&st->info->duration_error);
2951         st->info->last_dts = AV_NOPTS_VALUE;
2952         st->info->duration_count = 0;
2953         st->info->rfps_duration_sum = 0;
2954     }
2955 }
2956
2957 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2958 {
2959     int i, count, ret = 0, j;
2960     int64_t read_size;
2961     AVStream *st;
2962     AVPacket pkt1, *pkt;
2963     int64_t old_offset  = avio_tell(ic->pb);
2964     // new streams might appear, no options for those
2965     int orig_nb_streams = ic->nb_streams;
2966     int flush_codecs;
2967     int64_t max_analyze_duration = ic->max_analyze_duration2;
2968     int64_t probesize = ic->probesize2;
2969
2970     if (!max_analyze_duration)
2971         max_analyze_duration = ic->max_analyze_duration;
2972     if (ic->probesize)
2973         probesize = ic->probesize;
2974     flush_codecs = probesize > 0;
2975
2976     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2977
2978     if (!max_analyze_duration) {
2979         if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2980             max_analyze_duration = 10*AV_TIME_BASE;
2981         } else
2982             max_analyze_duration = 5*AV_TIME_BASE;
2983     }
2984
2985     if (ic->pb)
2986         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2987                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2988
2989     for (i = 0; i < ic->nb_streams; i++) {
2990         const AVCodec *codec;
2991         AVDictionary *thread_opt = NULL;
2992         st = ic->streams[i];
2993
2994         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2995             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2996 /*            if (!st->time_base.num)
2997                 st->time_base = */
2998             if (!st->codec->time_base.num)
2999                 st->codec->time_base = st->time_base;
3000         }
3001         // only for the split stuff
3002         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3003             st->parser = av_parser_init(st->codec->codec_id);
3004             if (st->parser) {
3005                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3006                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3007                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3008                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3009                 }
3010             } else if (st->need_parsing) {
3011                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3012                        "%s, packets or times may be invalid.\n",
3013                        avcodec_get_name(st->codec->codec_id));
3014             }
3015         }
3016         codec = find_decoder(ic, st, st->codec->codec_id);
3017
3018         /* Force thread count to 1 since the H.264 decoder will not extract
3019          * SPS and PPS to extradata during multi-threaded decoding. */
3020         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3021
3022         /* Ensure that subtitle_header is properly set. */
3023         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3024             && codec && !st->codec->codec) {
3025             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3026                 av_log(ic, AV_LOG_WARNING,
3027                        "Failed to open codec in av_find_stream_info\n");
3028         }
3029
3030         // Try to just open decoders, in case this is enough to get parameters.
3031         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3032             if (codec && !st->codec->codec)
3033                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3034                     av_log(ic, AV_LOG_WARNING,
3035                            "Failed to open codec in av_find_stream_info\n");
3036         }
3037         if (!options)
3038             av_dict_free(&thread_opt);
3039     }
3040
3041     for (i = 0; i < ic->nb_streams; i++) {
3042 #if FF_API_R_FRAME_RATE
3043         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3044 #endif
3045         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3046         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3047     }
3048
3049     count     = 0;
3050     read_size = 0;
3051     for (;;) {
3052         if (ff_check_interrupt(&ic->interrupt_callback)) {
3053             ret = AVERROR_EXIT;
3054             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3055             break;
3056         }
3057
3058         /* check if one codec still needs to be handled */
3059         for (i = 0; i < ic->nb_streams; i++) {
3060             int fps_analyze_framecount = 20;
3061
3062             st = ic->streams[i];
3063             if (!has_codec_parameters(st, NULL))
3064                 break;
3065             /* If the timebase is coarse (like the usual millisecond precision
3066              * of mkv), we need to analyze more frames to reliably arrive at
3067              * the correct fps. */
3068             if (av_q2d(st->time_base) > 0.0005)
3069                 fps_analyze_framecount *= 2;
3070             if (!tb_unreliable(st->codec))
3071                 fps_analyze_framecount = 0;
3072             if (ic->fps_probe_size >= 0)
3073                 fps_analyze_framecount = ic->fps_probe_size;
3074             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3075                 fps_analyze_framecount = 0;
3076             /* variable fps and no guess at the real fps */
3077             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3078                 st->info->duration_count < fps_analyze_framecount &&
3079                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3080                 break;
3081             if (st->parser && st->parser->parser->split &&
3082                 !st->codec->extradata)
3083                 break;
3084             if (st->first_dts == AV_NOPTS_VALUE &&
3085                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3086                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3087                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3088                 break;
3089         }
3090         if (i == ic->nb_streams) {
3091             /* NOTE: If the format has no header, then we need to read some
3092              * packets to get most of the streams, so we cannot stop here. */
3093             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3094                 /* If we found the info for all the codecs, we can stop. */
3095                 ret = count;
3096                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3097                 flush_codecs = 0;
3098                 break;
3099             }
3100         }
3101         /* We did not get all the codec info, but we read too much data. */
3102         if (read_size >= probesize) {
3103             ret = count;
3104             av_log(ic, AV_LOG_DEBUG,
3105                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3106             for (i = 0; i < ic->nb_streams; i++)
3107                 if (!ic->streams[i]->r_frame_rate.num &&
3108                     ic->streams[i]->info->duration_count <= 1 &&
3109                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3110                     strcmp(ic->iformat->name, "image2"))
3111                     av_log(ic, AV_LOG_WARNING,
3112                            "Stream #%d: not enough frames to estimate rate; "
3113                            "consider increasing probesize\n", i);
3114             break;
3115         }
3116
3117         /* NOTE: A new stream can be added there if no header in file
3118          * (AVFMTCTX_NOHEADER). */
3119         ret = read_frame_internal(ic, &pkt1);
3120         if (ret == AVERROR(EAGAIN))
3121             continue;
3122
3123         if (ret < 0) {
3124             /* EOF or error*/
3125             break;
3126         }
3127
3128         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3129             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3130         {
3131             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3132                                 &ic->packet_buffer_end);
3133             if (!pkt) {
3134                 ret = AVERROR(ENOMEM);
3135                 goto find_stream_info_err;
3136             }
3137             if ((ret = av_dup_packet(pkt)) < 0)
3138                 goto find_stream_info_err;
3139         }
3140
3141         st = ic->streams[pkt->stream_index];
3142         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3143             read_size += pkt->size;
3144
3145         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3146             /* check for non-increasing dts */
3147             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3148                 st->info->fps_last_dts >= pkt->dts) {
3149                 av_log(ic, AV_LOG_DEBUG,
3150                        "Non-increasing DTS in stream %d: packet %d with DTS "
3151                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3152                        st->index, st->info->fps_last_dts_idx,
3153                        st->info->fps_last_dts, st->codec_info_nb_frames,
3154                        pkt->dts);
3155                 st->info->fps_first_dts =
3156                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3157             }
3158             /* Check for a discontinuity in dts. If the difference in dts
3159              * is more than 1000 times the average packet duration in the
3160              * sequence, we treat it as a discontinuity. */
3161             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3162                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3163                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3164                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3165                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3166                 av_log(ic, AV_LOG_WARNING,
3167                        "DTS discontinuity in stream %d: packet %d with DTS "
3168                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3169                        st->index, st->info->fps_last_dts_idx,
3170                        st->info->fps_last_dts, st->codec_info_nb_frames,
3171                        pkt->dts);
3172                 st->info->fps_first_dts =
3173                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3174             }
3175
3176             /* update stored dts values */
3177             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3178                 st->info->fps_first_dts     = pkt->dts;
3179                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3180             }
3181             st->info->fps_last_dts     = pkt->dts;
3182             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3183         }
3184         if (st->codec_info_nb_frames>1) {
3185             int64_t t = 0;
3186
3187             if (st->time_base.den > 0)
3188                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3189             if (st->avg_frame_rate.num > 0)
3190                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3191
3192             if (   t == 0
3193                 && st->codec_info_nb_frames>30
3194                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3195                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3196                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3197
3198             if (t >= max_analyze_duration) {
3199                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3200                        max_analyze_duration,
3201                        t);
3202                 break;
3203             }
3204             if (pkt->duration) {
3205                 st->info->codec_info_duration        += pkt->duration;
3206                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3207             }
3208         }
3209 #if FF_API_R_FRAME_RATE
3210         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3211             ff_rfps_add_frame(ic, st, pkt->dts);
3212 #endif
3213         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3214             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3215             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3216                 if (ff_alloc_extradata(st->codec, i))
3217                     return AVERROR(ENOMEM);
3218                 memcpy(st->codec->extradata, pkt->data,
3219                        st->codec->extradata_size);
3220             }
3221         }
3222
3223         /* If still no information, we try to open the codec and to
3224          * decompress the frame. We try to avoid that in most cases as
3225          * it takes longer and uses more memory. For MPEG-4, we need to
3226          * decompress for QuickTime.
3227          *
3228          * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3229          * least one frame of codec data, this makes sure the codec initializes
3230          * the channel configuration and does not only trust the values from
3231          * the container. */
3232         try_decode_frame(ic, st, pkt,
3233                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3234
3235         st->codec_info_nb_frames++;
3236         count++;
3237     }
3238
3239     if (flush_codecs) {
3240         AVPacket empty_pkt = { 0 };
3241         int err = 0;
3242         av_init_packet(&empty_pkt);
3243
3244         for (i = 0; i < ic->nb_streams; i++) {
3245
3246             st = ic->streams[i];
3247
3248             /* flush the decoders */
3249             if (st->info->found_decoder == 1) {
3250                 do {
3251                     err = try_decode_frame(ic, st, &empty_pkt,
3252                                             (options && i < orig_nb_streams)
3253                                             ? &options[i] : NULL);
3254                 } while (err > 0 && !has_codec_parameters(st, NULL));
3255
3256                 if (err < 0) {
3257                     av_log(ic, AV_LOG_INFO,
3258                         "decoding for stream %d failed\n", st->index);
3259                 }
3260             }
3261         }
3262     }
3263     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3264
3265     // close codecs which were opened in try_decode_frame()
3266     for (i = 0; i < ic->nb_streams; i++) {
3267         st = ic->streams[i];
3268         avcodec_close(st->codec);
3269     }
3270
3271     ff_rfps_calculate(ic);
3272
3273     for (i = 0; i < ic->nb_streams; i++) {
3274         st = ic->streams[i];
3275         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3276             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3277                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3278                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3279                     st->codec->codec_tag= tag;
3280             }
3281
3282             /* estimate average framerate if not set by demuxer */
3283             if (st->info->codec_info_duration_fields &&
3284                 !st->avg_frame_rate.num &&
3285                 st->info->codec_info_duration) {
3286                 int best_fps      = 0;
3287                 double best_error = 0.01;
3288
3289                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3290                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3291                     st->info->codec_info_duration        < 0)
3292                     continue;
3293                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3294                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3295                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3296
3297                 /* Round guessed framerate to a "standard" framerate if it's
3298                  * within 1% of the original estimate. */
3299                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3300                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3301                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3302                                               av_q2d(std_fps) - 1);
3303
3304                     if (error < best_error) {
3305                         best_error = error;
3306                         best_fps   = std_fps.num;
3307                     }
3308                 }
3309                 if (best_fps)
3310                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3311                               best_fps, 12 * 1001, INT_MAX);
3312             }
3313
3314             if (!st->r_frame_rate.num) {
3315                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3316                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3317                     st->r_frame_rate.num = st->codec->time_base.den;
3318                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3319                 } else {
3320                     st->r_frame_rate.num = st->time_base.den;
3321                     st->r_frame_rate.den = st->time_base.num;
3322                 }
3323             }
3324         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3325             if (!st->codec->bits_per_coded_sample)
3326                 st->codec->bits_per_coded_sample =
3327                     av_get_bits_per_sample(st->codec->codec_id);
3328             // set stream disposition based on audio service type
3329             switch (st->codec->audio_service_type) {
3330             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3331                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3332                 break;
3333             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3334                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3335                 break;
3336             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3337                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3338                 break;
3339             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3340                 st->disposition = AV_DISPOSITION_COMMENT;
3341                 break;
3342             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3343                 st->disposition = AV_DISPOSITION_KARAOKE;
3344                 break;
3345             }
3346         }
3347     }
3348
3349     if (probesize)
3350     estimate_timings(ic, old_offset);
3351
3352     if (ret >= 0 && ic->nb_streams)
3353         /* We could not have all the codec parameters before EOF. */
3354         ret = -1;
3355     for (i = 0; i < ic->nb_streams; i++) {
3356         const char *errmsg;
3357         st = ic->streams[i];
3358         if (!has_codec_parameters(st, &errmsg)) {
3359             char buf[256];
3360             avcodec_string(buf, sizeof(buf), st->codec, 0);
3361             av_log(ic, AV_LOG_WARNING,
3362                    "Could not find codec parameters for stream %d (%s): %s\n"
3363                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3364                    i, buf, errmsg);
3365         } else {
3366             ret = 0;
3367         }
3368     }
3369
3370     compute_chapters_end(ic);
3371
3372 find_stream_info_err:
3373     for (i = 0; i < ic->nb_streams; i++) {
3374         st = ic->streams[i];
3375         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3376             ic->streams[i]->codec->thread_count = 0;
3377         if (st->info)
3378             av_freep(&st->info->duration_error);
3379         av_freep(&ic->streams[i]->info);
3380     }
3381     if (ic->pb)
3382         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3383                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3384     return ret;
3385 }
3386
3387 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3388 {
3389     int i, j;
3390
3391     for (i = 0; i < ic->nb_programs; i++) {
3392         if (ic->programs[i] == last) {
3393             last = NULL;
3394         } else {
3395             if (!last)
3396                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3397                     if (ic->programs[i]->stream_index[j] == s)
3398                         return ic->programs[i];
3399         }
3400     }
3401     return NULL;
3402 }
3403
3404 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3405                         int wanted_stream_nb, int related_stream,
3406                         AVCodec **decoder_ret, int flags)
3407 {
3408     int i, nb_streams = ic->nb_streams;
3409     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3410     unsigned *program = NULL;
3411     const AVCodec *decoder = NULL, *best_decoder = NULL;
3412
3413     if (related_stream >= 0 && wanted_stream_nb < 0) {
3414         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3415         if (p) {
3416             program    = p->stream_index;
3417             nb_streams = p->nb_stream_indexes;
3418         }
3419     }
3420     for (i = 0; i < nb_streams; i++) {
3421         int real_stream_index = program ? program[i] : i;
3422         AVStream *st          = ic->streams[real_stream_index];
3423         AVCodecContext *avctx = st->codec;
3424         if (avctx->codec_type != type)
3425             continue;
3426         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3427             continue;
3428         if (wanted_stream_nb != real_stream_index &&
3429             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3430                                AV_DISPOSITION_VISUAL_IMPAIRED))
3431             continue;
3432         if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3433             continue;
3434         if (decoder_ret) {
3435             decoder = find_decoder(ic, st, st->codec->codec_id);
3436             if (!decoder) {
3437                 if (ret < 0)
3438                     ret = AVERROR_DECODER_NOT_FOUND;
3439                 continue;
3440             }
3441         }
3442         count = st->codec_info_nb_frames;
3443         bitrate = avctx->bit_rate;
3444         if (!bitrate)
3445             bitrate = avctx->rc_max_rate;
3446         multiframe = FFMIN(5, count);
3447         if ((best_multiframe >  multiframe) ||
3448             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3449             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3450             continue;
3451         best_count   = count;
3452         best_bitrate = bitrate;
3453         best_multiframe = multiframe;
3454         ret          = real_stream_index;
3455         best_decoder = decoder;
3456         if (program && i == nb_streams - 1 && ret < 0) {
3457             program    = NULL;
3458             nb_streams = ic->nb_streams;
3459             /* no related stream found, try again with everything */
3460             i = 0;
3461         }
3462     }
3463     if (decoder_ret)
3464         *decoder_ret = (AVCodec*)best_decoder;
3465     return ret;
3466 }
3467
3468 /*******************************************************/
3469
3470 int av_read_play(AVFormatContext *s)
3471 {
3472     if (s->iformat->read_play)
3473         return s->iformat->read_play(s);
3474     if (s->pb)
3475         return avio_pause(s->pb, 0);
3476     return AVERROR(ENOSYS);
3477 }
3478
3479 int av_read_pause(AVFormatContext *s)
3480 {
3481     if (s->iformat->read_pause)
3482         return s->iformat->read_pause(s);
3483     if (s->pb)
3484         return avio_pause(s->pb, 1);
3485     return AVERROR(ENOSYS);
3486 }
3487
3488 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3489     int j;
3490     av_assert0(s->nb_streams>0);
3491     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3492
3493     for (j = 0; j < st->nb_side_data; j++)
3494         av_freep(&st->side_data[j].data);
3495     av_freep(&st->side_data);
3496     st->nb_side_data = 0;
3497
3498     if (st->parser) {
3499         av_parser_close(st->parser);
3500     }
3501     if (st->attached_pic.data)
3502         av_free_packet(&st->attached_pic);
3503     av_dict_free(&st->metadata);
3504     av_freep(&st->probe_data.buf);
3505     av_freep(&st->index_entries);
3506     av_freep(&st->codec->extradata);
3507     av_freep(&st->codec->subtitle_header);
3508     av_freep(&st->codec);
3509     av_freep(&st->priv_data);
3510     if (st->info)
3511         av_freep(&st->info->duration_error);
3512     av_freep(&st->info);
3513     av_freep(&s->streams[ --s->nb_streams ]);
3514 }
3515
3516 void avformat_free_context(AVFormatContext *s)
3517 {
3518     int i;
3519
3520     if (!s)
3521         return;
3522
3523     av_opt_free(s);
3524     if (s->iformat && s->iformat->priv_class && s->priv_data)
3525         av_opt_free(s->priv_data);
3526     if (s->oformat && s->oformat->priv_class && s->priv_data)
3527         av_opt_free(s->priv_data);
3528
3529     for (i = s->nb_streams - 1; i >= 0; i--) {
3530         ff_free_stream(s, s->streams[i]);
3531     }
3532     for (i = s->nb_programs - 1; i >= 0; i--) {
3533         av_dict_free(&s->programs[i]->metadata);
3534         av_freep(&s->programs[i]->stream_index);
3535         av_freep(&s->programs[i]);
3536     }
3537     av_freep(&s->programs);
3538     av_freep(&s->priv_data);
3539     while (s->nb_chapters--) {
3540         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3541         av_freep(&s->chapters[s->nb_chapters]);
3542     }
3543     av_freep(&s->chapters);
3544     av_dict_free(&s->metadata);
3545     av_freep(&s->streams);
3546     av_freep(&s->internal);
3547     av_free(s);
3548 }
3549
3550 #if FF_API_CLOSE_INPUT_FILE
3551 void av_close_input_file(AVFormatContext *s)
3552 {
3553     avformat_close_input(&s);
3554 }
3555 #endif
3556
3557 void avformat_close_input(AVFormatContext **ps)
3558 {
3559     AVFormatContext *s;
3560     AVIOContext *pb;
3561
3562     if (!ps || !*ps)
3563         return;
3564
3565     s  = *ps;
3566     pb = s->pb;
3567
3568     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3569         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3570         pb = NULL;
3571
3572     flush_packet_queue(s);
3573
3574     if (s->iformat)
3575         if (s->iformat->read_close)
3576             s->iformat->read_close(s);
3577
3578     avformat_free_context(s);
3579
3580     *ps = NULL;
3581
3582     avio_close(pb);
3583 }
3584
3585 #if FF_API_NEW_STREAM
3586 AVStream *av_new_stream(AVFormatContext *s, int id)
3587 {
3588     AVStream *st = avformat_new_stream(s, NULL);
3589     if (st)
3590         st->id = id;
3591     return st;
3592 }
3593 #endif
3594
3595 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3596 {
3597     AVStream *st;
3598     int i;
3599     AVStream **streams;
3600
3601     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3602         return NULL;
3603     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3604     if (!streams)
3605         return NULL;
3606     s->streams = streams;
3607
3608     st = av_mallocz(sizeof(AVStream));
3609     if (!st)
3610         return NULL;
3611     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3612         av_free(st);
3613         return NULL;
3614     }
3615     st->info->last_dts = AV_NOPTS_VALUE;
3616
3617     st->codec = avcodec_alloc_context3(c);
3618     if (s->iformat) {
3619         /* no default bitrate if decoding */
3620         st->codec->bit_rate = 0;
3621
3622         /* default pts setting is MPEG-like */
3623         avpriv_set_pts_info(st, 33, 1, 90000);
3624     }
3625
3626     st->index      = s->nb_streams;
3627     st->start_time = AV_NOPTS_VALUE;
3628     st->duration   = AV_NOPTS_VALUE;
3629     /* we set the current DTS to 0 so that formats without any timestamps
3630      * but durations get some timestamps, formats with some unknown
3631      * timestamps have their first few packets buffered and the
3632      * timestamps corrected before they are returned to the user */
3633     st->cur_dts       = s->iformat ? RELATIVE_TS_BASE : 0;
3634     st->first_dts     = AV_NOPTS_VALUE;
3635     st->probe_packets = MAX_PROBE_PACKETS;
3636     st->pts_wrap_reference = AV_NOPTS_VALUE;
3637     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3638
3639     st->last_IP_pts = AV_NOPTS_VALUE;
3640     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3641     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3642         st->pts_buffer[i] = AV_NOPTS_VALUE;
3643
3644     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3645
3646 #if FF_API_R_FRAME_RATE
3647     st->info->last_dts      = AV_NOPTS_VALUE;
3648 #endif
3649     st->info->fps_first_dts = AV_NOPTS_VALUE;
3650     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3651
3652     st->inject_global_side_data = s->internal->inject_global_side_data;
3653
3654     s->streams[s->nb_streams++] = st;
3655     return st;
3656 }
3657
3658 AVProgram *av_new_program(AVFormatContext *ac, int id)
3659 {
3660     AVProgram *program = NULL;
3661     int i;
3662
3663     av_dlog(ac, "new_program: id=0x%04x\n", id);
3664
3665     for (i = 0; i < ac->nb_programs; i++)
3666         if (ac->programs[i]->id == id)
3667             program = ac->programs[i];
3668
3669     if (!program) {
3670         program = av_mallocz(sizeof(AVProgram));
3671         if (!program)
3672             return NULL;
3673         dynarray_add(&ac->programs, &ac->nb_programs, program);
3674         program->discard = AVDISCARD_NONE;
3675     }
3676     program->id = id;
3677     program->pts_wrap_reference = AV_NOPTS_VALUE;
3678     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3679
3680     program->start_time =
3681     program->end_time   = AV_NOPTS_VALUE;
3682
3683     return program;
3684 }
3685
3686 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3687                               int64_t start, int64_t end, const char *title)
3688 {
3689     AVChapter *chapter = NULL;
3690     int i;
3691
3692     if (end != AV_NOPTS_VALUE && start > end) {
3693         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3694         return NULL;
3695     }
3696
3697     for (i = 0; i < s->nb_chapters; i++)
3698         if (s->chapters[i]->id == id)
3699             chapter = s->chapters[i];
3700
3701     if (!chapter) {
3702         chapter = av_mallocz(sizeof(AVChapter));
3703         if (!chapter)
3704             return NULL;
3705         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3706     }
3707     av_dict_set(&chapter->metadata, "title", title, 0);
3708     chapter->id        = id;
3709     chapter->time_base = time_base;
3710     chapter->start     = start;
3711     chapter->end       = end;
3712
3713     return chapter;
3714 }
3715
3716 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3717 {
3718     int i, j;
3719     AVProgram *program = NULL;
3720     void *tmp;
3721
3722     if (idx >= ac->nb_streams) {
3723         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3724         return;
3725     }
3726
3727     for (i = 0; i < ac->nb_programs; i++) {
3728         if (ac->programs[i]->id != progid)
3729             continue;
3730         program = ac->programs[i];
3731         for (j = 0; j < program->nb_stream_indexes; j++)
3732             if (program->stream_index[j] == idx)
3733                 return;
3734
3735         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3736         if (!tmp)
3737             return;
3738         program->stream_index = tmp;
3739         program->stream_index[program->nb_stream_indexes++] = idx;
3740         return;
3741     }
3742 }
3743
3744 uint64_t ff_ntp_time(void)
3745 {
3746     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3747 }
3748
3749 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3750 {
3751     const char *p;
3752     char *q, buf1[20], c;
3753     int nd, len, percentd_found;
3754
3755     q = buf;
3756     p = path;
3757     percentd_found = 0;
3758     for (;;) {
3759         c = *p++;
3760         if (c == '\0')
3761             break;
3762         if (c == '%') {
3763             do {
3764                 nd = 0;
3765                 while (av_isdigit(*p))
3766                     nd = nd * 10 + *p++ - '0';
3767                 c = *p++;
3768             } while (av_isdigit(c));
3769
3770             switch (c) {
3771             case '%':
3772                 goto addchar;
3773             case 'd':
3774                 if (percentd_found)
3775                     goto fail;
3776                 percentd_found = 1;
3777                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3778                 len = strlen(buf1);
3779                 if ((q - buf + len) > buf_size - 1)
3780                     goto fail;
3781                 memcpy(q, buf1, len);
3782                 q += len;
3783                 break;
3784             default:
3785                 goto fail;
3786             }
3787         } else {
3788 addchar:
3789             if ((q - buf) < buf_size - 1)
3790                 *q++ = c;
3791         }
3792     }
3793     if (!percentd_found)
3794         goto fail;
3795     *q = '\0';
3796     return 0;
3797 fail:
3798     *q = '\0';
3799     return -1;
3800 }
3801
3802 void av_url_split(char *proto, int proto_size,
3803                   char *authorization, int authorization_size,
3804                   char *hostname, int hostname_size,
3805                   int *port_ptr, char *path, int path_size, const char *url)
3806 {
3807     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3808
3809     if (port_ptr)
3810         *port_ptr = -1;
3811     if (proto_size > 0)
3812         proto[0] = 0;
3813     if (authorization_size > 0)
3814         authorization[0] = 0;
3815     if (hostname_size > 0)
3816         hostname[0] = 0;
3817     if (path_size > 0)
3818         path[0] = 0;
3819
3820     /* parse protocol */
3821     if ((p = strchr(url, ':'))) {
3822         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3823         p++; /* skip ':' */
3824         if (*p == '/')
3825             p++;
3826         if (*p == '/')
3827             p++;
3828     } else {
3829         /* no protocol means plain filename */
3830         av_strlcpy(path, url, path_size);
3831         return;
3832     }
3833
3834     /* separate path from hostname */
3835     ls = strchr(p, '/');
3836     ls2 = strchr(p, '?');
3837     if (!ls)
3838         ls = ls2;
3839     else if (ls && ls2)
3840         ls = FFMIN(ls, ls2);
3841     if (ls)
3842         av_strlcpy(path, ls, path_size);
3843     else
3844         ls = &p[strlen(p)];  // XXX
3845
3846     /* the rest is hostname, use that to parse auth/port */
3847     if (ls != p) {
3848         /* authorization (user[:pass]@hostname) */
3849         at2 = p;
3850         while ((at = strchr(p, '@')) && at < ls) {
3851             av_strlcpy(authorization, at2,
3852                        FFMIN(authorization_size, at + 1 - at2));
3853             p = at + 1; /* skip '@' */
3854         }
3855
3856         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3857             /* [host]:port */
3858             av_strlcpy(hostname, p + 1,
3859                        FFMIN(hostname_size, brk - p));
3860             if (brk[1] == ':' && port_ptr)
3861                 *port_ptr = atoi(brk + 2);
3862         } else if ((col = strchr(p, ':')) && col < ls) {
3863             av_strlcpy(hostname, p,
3864                        FFMIN(col + 1 - p, hostname_size));
3865             if (port_ptr)
3866                 *port_ptr = atoi(col + 1);
3867         } else
3868             av_strlcpy(hostname, p,
3869                        FFMIN(ls + 1 - p, hostname_size));
3870     }
3871 }
3872
3873 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3874 {
3875     int i;
3876     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3877                                            '4', '5', '6', '7',
3878                                            '8', '9', 'A', 'B',
3879                                            'C', 'D', 'E', 'F' };
3880     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3881                                            '4', '5', '6', '7',
3882                                            '8', '9', 'a', 'b',
3883                                            'c', 'd', 'e', 'f' };
3884     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3885
3886     for (i = 0; i < s; i++) {
3887         buff[i * 2]     = hex_table[src[i] >> 4];
3888         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3889     }
3890
3891     return buff;
3892 }
3893
3894 int ff_hex_to_data(uint8_t *data, const char *p)
3895 {
3896     int c, len, v;
3897
3898     len = 0;
3899     v   = 1;
3900     for (;;) {
3901         p += strspn(p, SPACE_CHARS);
3902         if (*p == '\0')
3903             break;
3904         c = av_toupper((unsigned char) *p++);
3905         if (c >= '0' && c <= '9')
3906             c = c - '0';
3907         else if (c >= 'A' && c <= 'F')
3908             c = c - 'A' + 10;
3909         else
3910             break;
3911         v = (v << 4) | c;
3912         if (v & 0x100) {
3913             if (data)
3914                 data[len] = v;
3915             len++;
3916             v = 1;
3917         }
3918     }
3919     return len;
3920 }
3921
3922 #if FF_API_SET_PTS_INFO
3923 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3924                      unsigned int pts_num, unsigned int pts_den)
3925 {
3926     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3927 }
3928 #endif
3929
3930 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3931                          unsigned int pts_num, unsigned int pts_den)
3932 {
3933     AVRational new_tb;
3934     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3935         if (new_tb.num != pts_num)
3936             av_log(NULL, AV_LOG_DEBUG,
3937                    "st:%d removing common factor %d from timebase\n",
3938                    s->index, pts_num / new_tb.num);
3939     } else
3940         av_log(NULL, AV_LOG_WARNING,
3941                "st:%d has too large timebase, reducing\n", s->index);
3942
3943     if (new_tb.num <= 0 || new_tb.den <= 0) {
3944         av_log(NULL, AV_LOG_ERROR,
3945                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3946                new_tb.num, new_tb.den,
3947                s->index);
3948         return;
3949     }
3950     s->time_base     = new_tb;
3951     av_codec_set_pkt_timebase(s->codec, new_tb);
3952     s->pts_wrap_bits = pts_wrap_bits;
3953 }
3954
3955 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3956                         void *context)
3957 {
3958     const char *ptr = str;
3959
3960     /* Parse key=value pairs. */
3961     for (;;) {
3962         const char *key;
3963         char *dest = NULL, *dest_end;
3964         int key_len, dest_len = 0;
3965
3966         /* Skip whitespace and potential commas. */
3967         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3968             ptr++;
3969         if (!*ptr)
3970             break;
3971
3972         key = ptr;
3973
3974         if (!(ptr = strchr(key, '=')))
3975             break;
3976         ptr++;
3977         key_len = ptr - key;
3978
3979         callback_get_buf(context, key, key_len, &dest, &dest_len);
3980         dest_end = dest + dest_len - 1;
3981
3982         if (*ptr == '\"') {
3983             ptr++;
3984             while (*ptr && *ptr != '\"') {
3985                 if (*ptr == '\\') {
3986                     if (!ptr[1])
3987                         break;
3988                     if (dest && dest < dest_end)
3989                         *dest++ = ptr[1];
3990                     ptr += 2;
3991                 } else {
3992                     if (dest && dest < dest_end)
3993                         *dest++ = *ptr;
3994                     ptr++;
3995                 }
3996             }
3997             if (*ptr == '\"')
3998                 ptr++;
3999         } else {
4000             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4001                 if (dest && dest < dest_end)
4002                     *dest++ = *ptr;
4003         }
4004         if (dest)
4005             *dest = 0;
4006     }
4007 }
4008
4009 int ff_find_stream_index(AVFormatContext *s, int id)
4010 {
4011     int i;
4012     for (i = 0; i < s->nb_streams; i++)
4013         if (s->streams[i]->id == id)
4014             return i;
4015     return -1;
4016 }
4017
4018 int64_t ff_iso8601_to_unix_time(const char *datestr)
4019 {
4020     struct tm time1 = { 0 }, time2 = { 0 };
4021     char *ret1, *ret2;
4022     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4023     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4024     if (ret2 && !ret1)
4025         return av_timegm(&time2);
4026     else
4027         return av_timegm(&time1);
4028 }
4029
4030 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4031                          int std_compliance)
4032 {
4033     if (ofmt) {
4034         if (ofmt->query_codec)
4035             return ofmt->query_codec(codec_id, std_compliance);
4036         else if (ofmt->codec_tag)
4037             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4038         else if (codec_id == ofmt->video_codec ||
4039                  codec_id == ofmt->audio_codec ||
4040                  codec_id == ofmt->subtitle_codec)
4041             return 1;
4042     }
4043     return AVERROR_PATCHWELCOME;
4044 }
4045
4046 int avformat_network_init(void)
4047 {
4048 #if CONFIG_NETWORK
4049     int ret;
4050     ff_network_inited_globally = 1;
4051     if ((ret = ff_network_init()) < 0)
4052         return ret;
4053     ff_tls_init();
4054 #endif
4055     return 0;
4056 }
4057
4058 int avformat_network_deinit(void)
4059 {
4060 #if CONFIG_NETWORK
4061     ff_network_close();
4062     ff_tls_deinit();
4063 #endif
4064     return 0;
4065 }
4066
4067 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4068                         uint64_t channel_layout, int32_t sample_rate,
4069                         int32_t width, int32_t height)
4070 {
4071     uint32_t flags = 0;
4072     int size = 4;
4073     uint8_t *data;
4074     if (!pkt)
4075         return AVERROR(EINVAL);
4076     if (channels) {
4077         size  += 4;
4078         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4079     }
4080     if (channel_layout) {
4081         size  += 8;
4082         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4083     }
4084     if (sample_rate) {
4085         size  += 4;
4086         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4087     }
4088     if (width || height) {
4089         size  += 8;
4090         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4091     }
4092     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4093     if (!data)
4094         return AVERROR(ENOMEM);
4095     bytestream_put_le32(&data, flags);
4096     if (channels)
4097         bytestream_put_le32(&data, channels);
4098     if (channel_layout)
4099         bytestream_put_le64(&data, channel_layout);
4100     if (sample_rate)
4101         bytestream_put_le32(&data, sample_rate);
4102     if (width || height) {
4103         bytestream_put_le32(&data, width);
4104         bytestream_put_le32(&data, height);
4105     }
4106     return 0;
4107 }
4108
4109 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4110 {
4111     AVRational undef = {0, 1};
4112     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4113     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4114     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4115
4116     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4117                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4118     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4119         stream_sample_aspect_ratio = undef;
4120
4121     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4122                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4123     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4124         frame_sample_aspect_ratio = undef;
4125
4126     if (stream_sample_aspect_ratio.num)
4127         return stream_sample_aspect_ratio;
4128     else
4129         return frame_sample_aspect_ratio;
4130 }
4131
4132 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4133 {
4134     AVRational fr = st->r_frame_rate;
4135     AVRational codec_fr = av_inv_q(st->codec->time_base);
4136     AVRational   avg_fr = st->avg_frame_rate;
4137
4138     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4139         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4140         fr = avg_fr;
4141     }
4142
4143
4144     if (st->codec->ticks_per_frame > 1) {
4145         codec_fr.den *= st->codec->ticks_per_frame;
4146         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4147             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4148             fr = codec_fr;
4149     }
4150
4151     return fr;
4152 }
4153
4154 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4155                                     const char *spec)
4156 {
4157     if (*spec <= '9' && *spec >= '0') /* opt:index */
4158         return strtol(spec, NULL, 0) == st->index;
4159     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4160              *spec == 't') { /* opt:[vasdt] */
4161         enum AVMediaType type;
4162
4163         switch (*spec++) {
4164         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4165         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4166         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4167         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4168         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4169         default:  av_assert0(0);
4170         }
4171         if (type != st->codec->codec_type)
4172             return 0;
4173         if (*spec++ == ':') { /* possibly followed by :index */
4174             int i, index = strtol(spec, NULL, 0);
4175             for (i = 0; i < s->nb_streams; i++)
4176                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4177                    return i == st->index;
4178             return 0;
4179         }
4180         return 1;
4181     } else if (*spec == 'p' && *(spec + 1) == ':') {
4182         int prog_id, i, j;
4183         char *endptr;
4184         spec += 2;
4185         prog_id = strtol(spec, &endptr, 0);
4186         for (i = 0; i < s->nb_programs; i++) {
4187             if (s->programs[i]->id != prog_id)
4188                 continue;
4189
4190             if (*endptr++ == ':') {
4191                 int stream_idx = strtol(endptr, NULL, 0);
4192                 return stream_idx >= 0 &&
4193                     stream_idx < s->programs[i]->nb_stream_indexes &&
4194                     st->index == s->programs[i]->stream_index[stream_idx];
4195             }
4196
4197             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4198                 if (st->index == s->programs[i]->stream_index[j])
4199                     return 1;
4200         }
4201         return 0;
4202     } else if (*spec == '#' ||
4203                (*spec == 'i' && *(spec + 1) == ':')) {
4204         int stream_id;
4205         char *endptr;
4206         spec += 1 + (*spec == 'i');
4207         stream_id = strtol(spec, &endptr, 0);
4208         if (!*endptr)
4209             return stream_id == st->id;
4210     } else if (!*spec) /* empty specifier, matches everything */
4211         return 1;
4212
4213     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4214     return AVERROR(EINVAL);
4215 }
4216
4217 int ff_generate_avci_extradata(AVStream *st)
4218 {
4219     static const uint8_t avci100_1080p_extradata[] = {
4220         // SPS
4221         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4222         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4223         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4224         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4225         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4226         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4227         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4228         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4229         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4230         // PPS
4231         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4232         0xd0
4233     };
4234     static const uint8_t avci100_1080i_extradata[] = {
4235         // SPS
4236         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4237         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4238         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4239         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4240         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4241         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4242         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4243         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4244         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4245         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4246         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4247         // PPS
4248         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4249         0xd0
4250     };
4251     static const uint8_t avci50_1080i_extradata[] = {
4252         // SPS
4253         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4254         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4255         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4256         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4257         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4258         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4259         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4260         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4261         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4262         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4263         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4264         // PPS
4265         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4266         0x11
4267     };
4268     static const uint8_t avci100_720p_extradata[] = {
4269         // SPS
4270         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4271         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4272         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4273         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4274         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4275         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4276         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4277         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4278         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4279         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4280         // PPS
4281         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4282         0x11
4283     };
4284
4285     const uint8_t *data = NULL;
4286     int size            = 0;
4287
4288     if (st->codec->width == 1920) {
4289         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4290             data = avci100_1080p_extradata;
4291             size = sizeof(avci100_1080p_extradata);
4292         } else {
4293             data = avci100_1080i_extradata;
4294             size = sizeof(avci100_1080i_extradata);
4295         }
4296     } else if (st->codec->width == 1440) {
4297         data = avci50_1080i_extradata;
4298         size = sizeof(avci50_1080i_extradata);
4299     } else if (st->codec->width == 1280) {
4300         data = avci100_720p_extradata;
4301         size = sizeof(avci100_720p_extradata);
4302     }
4303
4304     if (!size)
4305         return 0;
4306
4307     av_freep(&st->codec->extradata);
4308     if (ff_alloc_extradata(st->codec, size))
4309         return AVERROR(ENOMEM);
4310     memcpy(st->codec->extradata, data, size);
4311
4312     return 0;
4313 }
4314
4315 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4316                                  int *size)
4317 {
4318     int i;
4319
4320     for (i = 0; i < st->nb_side_data; i++) {
4321         if (st->side_data[i].type == type) {
4322             if (size)
4323                 *size = st->side_data[i].size;
4324             return st->side_data[i].data;
4325         }
4326     }
4327     return NULL;
4328 }