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

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