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

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