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