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