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