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

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