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