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 #include <stdarg.h>
  23 #include <stdint.h>
  24
  25 #include "config.h"
  26
  27 #include "libavutil/avassert.h"
  28 #include "libavutil/avstring.h"
  29 #include "libavutil/dict.h"
  30 #include "libavutil/internal.h"
  31 #include "libavutil/mathematics.h"
  32 #include "libavutil/opt.h"
  33 #include "libavutil/parseutils.h"
  34 #include "libavutil/pixdesc.h"
  35 #include "libavutil/thread.h"
  36 #include "libavutil/time.h"
  37 #include "libavutil/time_internal.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 #include "libavutil/ffversion.h"
  57 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
  58
  59 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
  60
  61 /**
  62  * @file
  63  * various utility functions for use within FFmpeg
  64  */
  65
  66 unsigned avformat_version(void)
  67 {
  68     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
  69     return LIBAVFORMAT_VERSION_INT;
  70 }
  71
  72 const char *avformat_configuration(void)
  73 {
  74     return FFMPEG_CONFIGURATION;
  75 }
  76
  77 const char *avformat_license(void)
  78 {
  79 #define LICENSE_PREFIX "libavformat license: "
  80     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  81 }
  82
  83 int ff_lock_avformat(void)
  84 {
  85     return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
  86 }
  87
  88 int ff_unlock_avformat(void)
  89 {
  90     return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
  91 }
  92
  93 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
  94
  95 static int is_relative(int64_t ts) {
  96     return ts > (RELATIVE_TS_BASE - (1LL<<48));
  97 }
  98
  99 /**
 100  * Wrap a given time stamp, if there is an indication for an overflow
 101  *
 102  * @param st stream
 103  * @param timestamp the time stamp to wrap
 104  * @return resulting time stamp
 105  */
 106 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
 107 {
 108     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
 109         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
 110         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
 111             timestamp < st->pts_wrap_reference)
 112             return timestamp + (1ULL << st->pts_wrap_bits);
 113         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
 114             timestamp >= st->pts_wrap_reference)
 115             return timestamp - (1ULL << st->pts_wrap_bits);
 116     }
 117     return timestamp;
 118 }
 119
 120 #if FF_API_FORMAT_GET_SET
 121 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
 122 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
 123 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
 124 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
 125 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
 126 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
 127 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
 128 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
 129 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
 130 #if FF_API_OLD_OPEN_CALLBACKS
 131 FF_DISABLE_DEPRECATION_WARNINGS
 132 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
 133 FF_ENABLE_DEPRECATION_WARNINGS
 134 #endif
 135 #endif
 136
 137 int64_t av_stream_get_end_pts(const AVStream *st)
 138 {
 139     if (st->internal->priv_pts) {
 140         return st->internal->priv_pts->val;
 141     } else
 142         return AV_NOPTS_VALUE;
 143 }
 144
 145 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
 146 {
 147     return st->parser;
 148 }
 149
 150 void av_format_inject_global_side_data(AVFormatContext *s)
 151 {
 152     int i;
 153     s->internal->inject_global_side_data = 1;
 154     for (i = 0; i < s->nb_streams; i++) {
 155         AVStream *st = s->streams[i];
 156         st->inject_global_side_data = 1;
 157     }
 158 }
 159
 160 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
 161 {
 162     av_assert0(!dst->codec_whitelist &&
 163                !dst->format_whitelist &&
 164                !dst->protocol_whitelist &&
 165                !dst->protocol_blacklist);
 166     dst-> codec_whitelist = av_strdup(src->codec_whitelist);
 167     dst->format_whitelist = av_strdup(src->format_whitelist);
 168     dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
 169     dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
 170     if (   (src-> codec_whitelist && !dst-> codec_whitelist)
 171         || (src->  format_whitelist && !dst->  format_whitelist)
 172         || (src->protocol_whitelist && !dst->protocol_whitelist)
 173         || (src->protocol_blacklist && !dst->protocol_blacklist)) {
 174         av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
 175         return AVERROR(ENOMEM);
 176     }
 177     return 0;
 178 }
 179
 180 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
 181 {
 182 #if FF_API_LAVF_AVCTX
 183 FF_DISABLE_DEPRECATION_WARNINGS
 184     if (st->codec->codec)
 185         return st->codec->codec;
 186 FF_ENABLE_DEPRECATION_WARNINGS
 187 #endif
 188
 189     switch (st->codecpar->codec_type) {
 190     case AVMEDIA_TYPE_VIDEO:
 191         if (s->video_codec)    return s->video_codec;
 192         break;
 193     case AVMEDIA_TYPE_AUDIO:
 194         if (s->audio_codec)    return s->audio_codec;
 195         break;
 196     case AVMEDIA_TYPE_SUBTITLE:
 197         if (s->subtitle_codec) return s->subtitle_codec;
 198         break;
 199     }
 200
 201     return avcodec_find_decoder(codec_id);
 202 }
 203
 204 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
 205 {
 206     const AVCodec *codec;
 207
 208 #if CONFIG_H264_DECODER
 209     /* Other parts of the code assume this decoder to be used for h264,
 210      * so force it if possible. */
 211     if (codec_id == AV_CODEC_ID_H264)
 212         return avcodec_find_decoder_by_name("h264");
 213 #endif
 214
 215     codec = find_decoder(s, st, codec_id);
 216     if (!codec)
 217         return NULL;
 218
 219     if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
 220         const AVCodec *probe_codec = NULL;
 221         while (probe_codec = av_codec_next(probe_codec)) {
 222             if (probe_codec->id == codec_id &&
 223                     av_codec_is_decoder(probe_codec) &&
 224                     !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
 225                 return probe_codec;
 226             }
 227         }
 228     }
 229
 230     return codec;
 231 }
 232
 233 #if FF_API_FORMAT_GET_SET
 234 int av_format_get_probe_score(const AVFormatContext *s)
 235 {
 236     return s->probe_score;
 237 }
 238 #endif
 239
 240 /* an arbitrarily chosen "sane" max packet size -- 50M */
 241 #define SANE_CHUNK_SIZE (50000000)
 242
 243 int ffio_limit(AVIOContext *s, int size)
 244 {
 245     if (s->maxsize>= 0) {
 246         int64_t remaining= s->maxsize - avio_tell(s);
 247         if (remaining < size) {
 248             int64_t newsize = avio_size(s);
 249             if (!s->maxsize || s->maxsize<newsize)
 250                 s->maxsize = newsize - !newsize;
 251             remaining= s->maxsize - avio_tell(s);
 252             remaining= FFMAX(remaining, 0);
 253         }
 254
 255         if (s->maxsize>= 0 && remaining+1 < size) {
 256             av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
 257             size = remaining+1;
 258         }
 259     }
 260     return size;
 261 }
 262
 263 /* Read the data in sane-sized chunks and append to pkt.
 264  * Return the number of bytes read or an error. */
 265 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
 266 {
 267     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
 268     int orig_size      = pkt->size;
 269     int ret;
 270
 271     do {
 272         int prev_size = pkt->size;
 273         int read_size;
 274
 275         /* When the caller requests a lot of data, limit it to the amount
 276          * left in file or SANE_CHUNK_SIZE when it is not known. */
 277         read_size = size;
 278         if (read_size > SANE_CHUNK_SIZE/10) {
 279             read_size = ffio_limit(s, read_size);
 280             // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
 281             if (s->maxsize < 0)
 282                 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
 283         }
 284
 285         ret = av_grow_packet(pkt, read_size);
 286         if (ret < 0)
 287             break;
 288
 289         ret = avio_read(s, pkt->data + prev_size, read_size);
 290         if (ret != read_size) {
 291             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
 292             break;
 293         }
 294
 295         size -= read_size;
 296     } while (size > 0);
 297     if (size > 0)
 298         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 299
 300     pkt->pos = orig_pos;
 301     if (!pkt->size)
 302         av_packet_unref(pkt);
 303     return pkt->size > orig_size ? pkt->size - orig_size : ret;
 304 }
 305
 306 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 307 {
 308     av_init_packet(pkt);
 309     pkt->data = NULL;
 310     pkt->size = 0;
 311     pkt->pos  = avio_tell(s);
 312
 313     return append_packet_chunked(s, pkt, size);
 314 }
 315
 316 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 317 {
 318     if (!pkt->size)
 319         return av_get_packet(s, pkt, size);
 320     return append_packet_chunked(s, pkt, size);
 321 }
 322
 323 int av_filename_number_test(const char *filename)
 324 {
 325     char buf[1024];
 326     return filename &&
 327            (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
 328 }
 329
 330 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
 331                                      AVProbeData *pd)
 332 {
 333     static const struct {
 334         const char *name;
 335         enum AVCodecID id;
 336         enum AVMediaType type;
 337     } fmt_id_type[] = {
 338         { "aac",       AV_CODEC_ID_AAC,        AVMEDIA_TYPE_AUDIO },
 339         { "ac3",       AV_CODEC_ID_AC3,        AVMEDIA_TYPE_AUDIO },
 340         { "aptx",      AV_CODEC_ID_APTX,       AVMEDIA_TYPE_AUDIO },
 341         { "dts",       AV_CODEC_ID_DTS,        AVMEDIA_TYPE_AUDIO },
 342         { "dvbsub",    AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
 343         { "dvbtxt",    AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
 344         { "eac3",      AV_CODEC_ID_EAC3,       AVMEDIA_TYPE_AUDIO },
 345         { "h264",      AV_CODEC_ID_H264,       AVMEDIA_TYPE_VIDEO },
 346         { "hevc",      AV_CODEC_ID_HEVC,       AVMEDIA_TYPE_VIDEO },
 347         { "loas",      AV_CODEC_ID_AAC_LATM,   AVMEDIA_TYPE_AUDIO },
 348         { "m4v",       AV_CODEC_ID_MPEG4,      AVMEDIA_TYPE_VIDEO },
 349         { "mjpeg_2000",AV_CODEC_ID_JPEG2000,   AVMEDIA_TYPE_VIDEO },
 350         { "mp3",       AV_CODEC_ID_MP3,        AVMEDIA_TYPE_AUDIO },
 351         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 352         { "truehd",    AV_CODEC_ID_TRUEHD,     AVMEDIA_TYPE_AUDIO },
 353         { 0 }
 354     };
 355     int score;
 356     AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
 357
 358     if (fmt) {
 359         int i;
 360         av_log(s, AV_LOG_DEBUG,
 361                "Probe with size=%d, packets=%d detected %s with score=%d\n",
 362                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
 363                fmt->name, score);
 364         for (i = 0; fmt_id_type[i].name; i++) {
 365             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 366                 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
 367                     st->codecpar->sample_rate)
 368                     continue;
 369                 if (st->request_probe > score &&
 370                     st->codecpar->codec_id != fmt_id_type[i].id)
 371                     continue;
 372                 st->codecpar->codec_id   = fmt_id_type[i].id;
 373                 st->codecpar->codec_type = fmt_id_type[i].type;
 374                 st->internal->need_context_update = 1;
 375 #if FF_API_LAVF_AVCTX
 376 FF_DISABLE_DEPRECATION_WARNINGS
 377                 st->codec->codec_type = st->codecpar->codec_type;
 378                 st->codec->codec_id   = st->codecpar->codec_id;
 379 FF_ENABLE_DEPRECATION_WARNINGS
 380 #endif
 381                 return score;
 382             }
 383         }
 384     }
 385     return 0;
 386 }
 387
 388 /************************************************************/
 389 /* input media file */
 390
 391 int av_demuxer_open(AVFormatContext *ic) {
 392     int err;
 393
 394     if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
 395         av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
 396         return AVERROR(EINVAL);
 397     }
 398
 399     if (ic->iformat->read_header) {
 400         err = ic->iformat->read_header(ic);
 401         if (err < 0)
 402             return err;
 403     }
 404
 405     if (ic->pb && !ic->internal->data_offset)
 406         ic->internal->data_offset = avio_tell(ic->pb);
 407
 408     return 0;
 409 }
 410
 411 /* Open input file and probe the format if necessary. */
 412 static int init_input(AVFormatContext *s, const char *filename,
 413                       AVDictionary **options)
 414 {
 415     int ret;
 416     AVProbeData pd = { filename, NULL, 0 };
 417     int score = AVPROBE_SCORE_RETRY;
 418
 419     if (s->pb) {
 420         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 421         if (!s->iformat)
 422             return av_probe_input_buffer2(s->pb, &s->iformat, filename,
 423                                          s, 0, s->format_probesize);
 424         else if (s->iformat->flags & AVFMT_NOFILE)
 425             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 426                                       "will be ignored with AVFMT_NOFILE format.\n");
 427         return 0;
 428     }
 429
 430     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
 431         (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
 432         return score;
 433
 434     if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
 435         return ret;
 436
 437     if (s->iformat)
 438         return 0;
 439     return av_probe_input_buffer2(s->pb, &s->iformat, filename,
 440                                  s, 0, s->format_probesize);
 441 }
 442
 443 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 444                          AVPacketList **plast_pktl, int ref)
 445 {
 446     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 447     int ret;
 448
 449     if (!pktl)
 450         return AVERROR(ENOMEM);
 451
 452     if (ref) {
 453         if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
 454             av_free(pktl);
 455             return ret;
 456         }
 457     } else {
 458         pktl->pkt = *pkt;
 459     }
 460
 461     if (*packet_buffer)
 462         (*plast_pktl)->next = pktl;
 463     else
 464         *packet_buffer = pktl;
 465
 466     /* Add the packet in the buffered packet list. */
 467     *plast_pktl = pktl;
 468     return 0;
 469 }
 470
 471 int avformat_queue_attached_pictures(AVFormatContext *s)
 472 {
 473     int i, ret;
 474     for (i = 0; i < s->nb_streams; i++)
 475         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
 476             s->streams[i]->discard < AVDISCARD_ALL) {
 477             if (s->streams[i]->attached_pic.size <= 0) {
 478                 av_log(s, AV_LOG_WARNING,
 479                     "Attached picture on stream %d has invalid size, "
 480                     "ignoring\n", i);
 481                 continue;
 482             }
 483
 484             ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
 485                                 &s->streams[i]->attached_pic,
 486                                 &s->internal->raw_packet_buffer_end, 1);
 487             if (ret < 0)
 488                 return ret;
 489         }
 490     return 0;
 491 }
 492
 493 static int update_stream_avctx(AVFormatContext *s)
 494 {
 495     int i, ret;
 496     for (i = 0; i < s->nb_streams; i++) {
 497         AVStream *st = s->streams[i];
 498
 499         if (!st->internal->need_context_update)
 500             continue;
 501
 502         /* close parser, because it depends on the codec */
 503         if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
 504             av_parser_close(st->parser);
 505             st->parser = NULL;
 506         }
 507
 508         /* update internal codec context, for the parser */
 509         ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
 510         if (ret < 0)
 511             return ret;
 512
 513 #if FF_API_LAVF_AVCTX
 514 FF_DISABLE_DEPRECATION_WARNINGS
 515         /* update deprecated public codec context */
 516         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
 517         if (ret < 0)
 518             return ret;
 519 FF_ENABLE_DEPRECATION_WARNINGS
 520 #endif
 521
 522         st->internal->need_context_update = 0;
 523     }
 524     return 0;
 525 }
 526
 527
 528 int avformat_open_input(AVFormatContext **ps, const char *filename,
 529                         AVInputFormat *fmt, AVDictionary **options)
 530 {
 531     AVFormatContext *s = *ps;
 532     int i, ret = 0;
 533     AVDictionary *tmp = NULL;
 534     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
 535
 536     if (!s && !(s = avformat_alloc_context()))
 537         return AVERROR(ENOMEM);
 538     if (!s->av_class) {
 539         av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
 540         return AVERROR(EINVAL);
 541     }
 542     if (fmt)
 543         s->iformat = fmt;
 544
 545     if (options)
 546         av_dict_copy(&tmp, *options, 0);
 547
 548     if (s->pb) // must be before any goto fail
 549         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 550
 551     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
 552         goto fail;
 553
 554     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
 555     if ((ret = init_input(s, filename, &tmp)) < 0)
 556         goto fail;
 557     s->probe_score = ret;
 558
 559     if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
 560         s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
 561         if (!s->protocol_whitelist) {
 562             ret = AVERROR(ENOMEM);
 563             goto fail;
 564         }
 565     }
 566
 567     if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
 568         s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
 569         if (!s->protocol_blacklist) {
 570             ret = AVERROR(ENOMEM);
 571             goto fail;
 572         }
 573     }
 574
 575     if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
 576         av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
 577         ret = AVERROR(EINVAL);
 578         goto fail;
 579     }
 580
 581     avio_skip(s->pb, s->skip_initial_bytes);
 582
 583     /* Check filename in case an image number is expected. */
 584     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
 585         if (!av_filename_number_test(filename)) {
 586             ret = AVERROR(EINVAL);
 587             goto fail;
 588         }
 589     }
 590
 591     s->duration = s->start_time = AV_NOPTS_VALUE;
 592
 593     /* Allocate private data. */
 594     if (s->iformat->priv_data_size > 0) {
 595         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
 596             ret = AVERROR(ENOMEM);
 597             goto fail;
 598         }
 599         if (s->iformat->priv_class) {
 600             *(const AVClass **) s->priv_data = s->iformat->priv_class;
 601             av_opt_set_defaults(s->priv_data);
 602             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 603                 goto fail;
 604         }
 605     }
 606
 607     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
 608     if (s->pb)
 609         ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
 610
 611
 612     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
 613         if ((ret = s->iformat->read_header(s)) < 0)
 614             goto fail;
 615
 616     if (!s->metadata) {
 617         s->metadata = s->internal->id3v2_meta;
 618         s->internal->id3v2_meta = NULL;
 619     } else if (s->internal->id3v2_meta) {
 620         int level = AV_LOG_WARNING;
 621         if (s->error_recognition & AV_EF_COMPLIANT)
 622             level = AV_LOG_ERROR;
 623         av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
 624         av_dict_free(&s->internal->id3v2_meta);
 625         if (s->error_recognition & AV_EF_EXPLODE)
 626             return AVERROR_INVALIDDATA;
 627     }
 628
 629     if (id3v2_extra_meta) {
 630         if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
 631             !strcmp(s->iformat->name, "tta")) {
 632             if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
 633                 goto fail;
 634             if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
 635                 goto fail;
 636         } else
 637             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
 638     }
 639     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 640
 641     if ((ret = avformat_queue_attached_pictures(s)) < 0)
 642         goto fail;
 643
 644     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
 645         s->internal->data_offset = avio_tell(s->pb);
 646
 647     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 648
 649     update_stream_avctx(s);
 650
 651     for (i = 0; i < s->nb_streams; i++)
 652         s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
 653
 654     if (options) {
 655         av_dict_free(options);
 656         *options = tmp;
 657     }
 658     *ps = s;
 659     return 0;
 660
 661 fail:
 662     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 663     av_dict_free(&tmp);
 664     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
 665         avio_closep(&s->pb);
 666     avformat_free_context(s);
 667     *ps = NULL;
 668     return ret;
 669 }
 670
 671 /*******************************************************/
 672
 673 static void force_codec_ids(AVFormatContext *s, AVStream *st)
 674 {
 675     switch (st->codecpar->codec_type) {
 676     case AVMEDIA_TYPE_VIDEO:
 677         if (s->video_codec_id)
 678             st->codecpar->codec_id = s->video_codec_id;
 679         break;
 680     case AVMEDIA_TYPE_AUDIO:
 681         if (s->audio_codec_id)
 682             st->codecpar->codec_id = s->audio_codec_id;
 683         break;
 684     case AVMEDIA_TYPE_SUBTITLE:
 685         if (s->subtitle_codec_id)
 686             st->codecpar->codec_id = s->subtitle_codec_id;
 687         break;
 688     case AVMEDIA_TYPE_DATA:
 689         if (s->data_codec_id)
 690             st->codecpar->codec_id = s->data_codec_id;
 691         break;
 692     }
 693 }
 694
 695 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
 696 {
 697     if (st->request_probe>0) {
 698         AVProbeData *pd = &st->probe_data;
 699         int end;
 700         av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
 701         --st->probe_packets;
 702
 703         if (pkt) {
 704             uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 705             if (!new_buf) {
 706                 av_log(s, AV_LOG_WARNING,
 707                        "Failed to reallocate probe buffer for stream %d\n",
 708                        st->index);
 709                 goto no_packet;
 710             }
 711             pd->buf = new_buf;
 712             memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
 713             pd->buf_size += pkt->size;
 714             memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 715         } else {
 716 no_packet:
 717             st->probe_packets = 0;
 718             if (!pd->buf_size) {
 719                 av_log(s, AV_LOG_WARNING,
 720                        "nothing to probe for stream %d\n", st->index);
 721             }
 722         }
 723
 724         end=    s->internal->raw_packet_buffer_remaining_size <= 0
 725                 || st->probe_packets<= 0;
 726
 727         if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
 728             int score = set_codec_from_probe_data(s, st, pd);
 729             if (    (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
 730                 || end) {
 731                 pd->buf_size = 0;
 732                 av_freep(&pd->buf);
 733                 st->request_probe = -1;
 734                 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
 735                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 736                 } else
 737                     av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
 738             }
 739             force_codec_ids(s, st);
 740         }
 741     }
 742     return 0;
 743 }
 744
 745 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
 746 {
 747     int64_t ref = pkt->dts;
 748     int i, pts_wrap_behavior;
 749     int64_t pts_wrap_reference;
 750     AVProgram *first_program;
 751
 752     if (ref == AV_NOPTS_VALUE)
 753         ref = pkt->pts;
 754     if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
 755         return 0;
 756     ref &= (1LL << st->pts_wrap_bits)-1;
 757
 758     // reference time stamp should be 60 s before first time stamp
 759     pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
 760     // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
 761     pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
 762         (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
 763         AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
 764
 765     first_program = av_find_program_from_stream(s, NULL, stream_index);
 766
 767     if (!first_program) {
 768         int default_stream_index = av_find_default_stream_index(s);
 769         if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
 770             for (i = 0; i < s->nb_streams; i++) {
 771                 if (av_find_program_from_stream(s, NULL, i))
 772                     continue;
 773                 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
 774                 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
 775             }
 776         }
 777         else {
 778             st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
 779             st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
 780         }
 781     }
 782     else {
 783         AVProgram *program = first_program;
 784         while (program) {
 785             if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
 786                 pts_wrap_reference = program->pts_wrap_reference;
 787                 pts_wrap_behavior = program->pts_wrap_behavior;
 788                 break;
 789             }
 790             program = av_find_program_from_stream(s, program, stream_index);
 791         }
 792
 793         // update every program with differing pts_wrap_reference
 794         program = first_program;
 795         while (program) {
 796             if (program->pts_wrap_reference != pts_wrap_reference) {
 797                 for (i = 0; i<program->nb_stream_indexes; i++) {
 798                     s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
 799                     s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
 800                 }
 801
 802                 program->pts_wrap_reference = pts_wrap_reference;
 803                 program->pts_wrap_behavior = pts_wrap_behavior;
 804             }
 805             program = av_find_program_from_stream(s, program, stream_index);
 806         }
 807     }
 808     return 1;
 809 }
 810
 811 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
 812 {
 813     int ret, i, err;
 814     AVStream *st;
 815
 816     for (;;) {
 817         AVPacketList *pktl = s->internal->raw_packet_buffer;
 818
 819         if (pktl) {
 820             *pkt = pktl->pkt;
 821             st   = s->streams[pkt->stream_index];
 822             if (s->internal->raw_packet_buffer_remaining_size <= 0)
 823                 if ((err = probe_codec(s, st, NULL)) < 0)
 824                     return err;
 825             if (st->request_probe <= 0) {
 826                 s->internal->raw_packet_buffer                 = pktl->next;
 827                 s->internal->raw_packet_buffer_remaining_size += pkt->size;
 828                 av_free(pktl);
 829                 return 0;
 830             }
 831         }
 832
 833         pkt->data = NULL;
 834         pkt->size = 0;
 835         av_init_packet(pkt);
 836         ret = s->iformat->read_packet(s, pkt);
 837         if (ret < 0) {
 838             /* Some demuxers return FFERROR_REDO when they consume
 839                data and discard it (ignored streams, junk, extradata).
 840                We must re-call the demuxer to get the real packet. */
 841             if (ret == FFERROR_REDO)
 842                 continue;
 843             if (!pktl || ret == AVERROR(EAGAIN))
 844                 return ret;
 845             for (i = 0; i < s->nb_streams; i++) {
 846                 st = s->streams[i];
 847                 if (st->probe_packets || st->request_probe > 0)
 848                     if ((err = probe_codec(s, st, NULL)) < 0)
 849                         return err;
 850                 av_assert0(st->request_probe <= 0);
 851             }
 852             continue;
 853         }
 854
 855         if (!pkt->buf) {
 856             AVPacket tmp = { 0 };
 857             ret = av_packet_ref(&tmp, pkt);
 858             if (ret < 0)
 859                 return ret;
 860             *pkt = tmp;
 861         }
 862
 863         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
 864             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
 865             av_log(s, AV_LOG_WARNING,
 866                    "Dropped corrupted packet (stream = %d)\n",
 867                    pkt->stream_index);
 868             av_packet_unref(pkt);
 869             continue;
 870         }
 871
 872         if (pkt->stream_index >= (unsigned)s->nb_streams) {
 873             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
 874             continue;
 875         }
 876
 877         st = s->streams[pkt->stream_index];
 878
 879         if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
 880             // correct first time stamps to negative values
 881             if (!is_relative(st->first_dts))
 882                 st->first_dts = wrap_timestamp(st, st->first_dts);
 883             if (!is_relative(st->start_time))
 884                 st->start_time = wrap_timestamp(st, st->start_time);
 885             if (!is_relative(st->cur_dts))
 886                 st->cur_dts = wrap_timestamp(st, st->cur_dts);
 887         }
 888
 889         pkt->dts = wrap_timestamp(st, pkt->dts);
 890         pkt->pts = wrap_timestamp(st, pkt->pts);
 891
 892         force_codec_ids(s, st);
 893
 894         /* TODO: audio: time filter; video: frame reordering (pts != dts) */
 895         if (s->use_wallclock_as_timestamps)
 896             pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
 897
 898         if (!pktl && st->request_probe <= 0)
 899             return ret;
 900
 901         err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
 902                             &s->internal->raw_packet_buffer_end, 0);
 903         if (err)
 904             return err;
 905         s->internal->raw_packet_buffer_remaining_size -= pkt->size;
 906
 907         if ((err = probe_codec(s, st, pkt)) < 0)
 908             return err;
 909     }
 910 }
 911
 912
 913 /**********************************************************/
 914
 915 static int determinable_frame_size(AVCodecContext *avctx)
 916 {
 917     switch(avctx->codec_id) {
 918     case AV_CODEC_ID_MP1:
 919     case AV_CODEC_ID_MP2:
 920     case AV_CODEC_ID_MP3:
 921         return 1;
 922     }
 923
 924     return 0;
 925 }
 926
 927 /**
 928  * Return the frame duration in seconds. Return 0 if not available.
 929  */
 930 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
 931                                AVCodecParserContext *pc, AVPacket *pkt)
 932 {
 933     AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
 934                                               av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
 935     int frame_size, sample_rate;
 936
 937 #if FF_API_LAVF_AVCTX
 938 FF_DISABLE_DEPRECATION_WARNINGS
 939     if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
 940         codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
 941 FF_ENABLE_DEPRECATION_WARNINGS
 942 #endif
 943
 944     *pnum = 0;
 945     *pden = 0;
 946     switch (st->codecpar->codec_type) {
 947     case AVMEDIA_TYPE_VIDEO:
 948         if (st->r_frame_rate.num && !pc && s->iformat) {
 949             *pnum = st->r_frame_rate.den;
 950             *pden = st->r_frame_rate.num;
 951         } else if (st->time_base.num * 1000LL > st->time_base.den) {
 952             *pnum = st->time_base.num;
 953             *pden = st->time_base.den;
 954         } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
 955             av_assert0(st->internal->avctx->ticks_per_frame);
 956             av_reduce(pnum, pden,
 957                       codec_framerate.den,
 958                       codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
 959                       INT_MAX);
 960
 961             if (pc && pc->repeat_pict) {
 962                 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
 963                 av_reduce(pnum, pden,
 964                           (*pnum) * (1LL + pc->repeat_pict),
 965                           (*pden),
 966                           INT_MAX);
 967             }
 968             /* If this codec can be interlaced or progressive then we need
 969              * a parser to compute duration of a packet. Thus if we have
 970              * no parser in such case leave duration undefined. */
 971             if (st->internal->avctx->ticks_per_frame > 1 && !pc)
 972                 *pnum = *pden = 0;
 973         }
 974         break;
 975     case AVMEDIA_TYPE_AUDIO:
 976         if (st->internal->avctx_inited) {
 977             frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
 978             sample_rate = st->internal->avctx->sample_rate;
 979         } else {
 980             frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
 981             sample_rate = st->codecpar->sample_rate;
 982         }
 983         if (frame_size <= 0 || sample_rate <= 0)
 984             break;
 985         *pnum = frame_size;
 986         *pden = sample_rate;
 987         break;
 988     default:
 989         break;
 990     }
 991 }
 992
 993 static int is_intra_only(enum AVCodecID id)
 994 {
 995     const AVCodecDescriptor *d = avcodec_descriptor_get(id);
 996     if (!d)
 997         return 0;
 998     if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
 999         return 0;
1000     return 1;
1001 }
1002
1003 static int has_decode_delay_been_guessed(AVStream *st)
1004 {
1005     if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1006     if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1007         return 1;
1008 #if CONFIG_H264_DECODER
1009     if (st->internal->avctx->has_b_frames &&
1010        avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1011         return 1;
1012 #endif
1013     if (st->internal->avctx->has_b_frames<3)
1014         return st->nb_decoded_frames >= 7;
1015     else if (st->internal->avctx->has_b_frames<4)
1016         return st->nb_decoded_frames >= 18;
1017     else
1018         return st->nb_decoded_frames >= 20;
1019 }
1020
1021 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1022 {
1023     if (pktl->next)
1024         return pktl->next;
1025     if (pktl == s->internal->packet_buffer_end)
1026         return s->internal->parse_queue;
1027     return NULL;
1028 }
1029
1030 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1031     int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1032                        st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1033
1034     if(!onein_oneout) {
1035         int delay = st->internal->avctx->has_b_frames;
1036         int i;
1037
1038         if (dts == AV_NOPTS_VALUE) {
1039             int64_t best_score = INT64_MAX;
1040             for (i = 0; i<delay; i++) {
1041                 if (st->pts_reorder_error_count[i]) {
1042                     int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1043                     if (score < best_score) {
1044                         best_score = score;
1045                         dts = pts_buffer[i];
1046                     }
1047                 }
1048             }
1049         } else {
1050             for (i = 0; i<delay; i++) {
1051                 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1052                     int64_t diff =  FFABS(pts_buffer[i] - dts)
1053                                     + (uint64_t)st->pts_reorder_error[i];
1054                     diff = FFMAX(diff, st->pts_reorder_error[i]);
1055                     st->pts_reorder_error[i] = diff;
1056                     st->pts_reorder_error_count[i]++;
1057                     if (st->pts_reorder_error_count[i] > 250) {
1058                         st->pts_reorder_error[i] >>= 1;
1059                         st->pts_reorder_error_count[i] >>= 1;
1060                     }
1061                 }
1062             }
1063         }
1064     }
1065
1066     if (dts == AV_NOPTS_VALUE)
1067         dts = pts_buffer[0];
1068
1069     return dts;
1070 }
1071
1072 /**
1073  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1074  * of the packets in a window.
1075  */
1076 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1077                                 AVPacketList *pkt_buffer)
1078 {
1079     AVStream *st       = s->streams[stream_index];
1080     int delay          = st->internal->avctx->has_b_frames;
1081     int i;
1082
1083     int64_t pts_buffer[MAX_REORDER_DELAY+1];
1084
1085     for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1086         pts_buffer[i] = AV_NOPTS_VALUE;
1087
1088     for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1089         if (pkt_buffer->pkt.stream_index != stream_index)
1090             continue;
1091
1092         if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1093             pts_buffer[0] = pkt_buffer->pkt.pts;
1094             for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1095                 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1096
1097             pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1098         }
1099     }
1100 }
1101
1102 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1103                                       int64_t dts, int64_t pts, AVPacket *pkt)
1104 {
1105     AVStream *st       = s->streams[stream_index];
1106     AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1107     AVPacketList *pktl_it;
1108
1109     uint64_t shift;
1110
1111     if (st->first_dts != AV_NOPTS_VALUE ||
1112         dts           == AV_NOPTS_VALUE ||
1113         st->cur_dts   == AV_NOPTS_VALUE ||
1114         is_relative(dts))
1115         return;
1116
1117     st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1118     st->cur_dts   = dts;
1119     shift         = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1120
1121     if (is_relative(pts))
1122         pts += shift;
1123
1124     for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1125         if (pktl_it->pkt.stream_index != stream_index)
1126             continue;
1127         if (is_relative(pktl_it->pkt.pts))
1128             pktl_it->pkt.pts += shift;
1129
1130         if (is_relative(pktl_it->pkt.dts))
1131             pktl_it->pkt.dts += shift;
1132
1133         if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1134             st->start_time = pktl_it->pkt.pts;
1135             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1136                 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1137         }
1138     }
1139
1140     if (has_decode_delay_been_guessed(st)) {
1141         update_dts_from_pts(s, stream_index, pktl);
1142     }
1143
1144     if (st->start_time == AV_NOPTS_VALUE) {
1145         st->start_time = pts;
1146         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1147             st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1148     }
1149 }
1150
1151 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1152                                      int stream_index, int duration)
1153 {
1154     AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1155     int64_t cur_dts    = RELATIVE_TS_BASE;
1156
1157     if (st->first_dts != AV_NOPTS_VALUE) {
1158         if (st->update_initial_durations_done)
1159             return;
1160         st->update_initial_durations_done = 1;
1161         cur_dts = st->first_dts;
1162         for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1163             if (pktl->pkt.stream_index == stream_index) {
1164                 if (pktl->pkt.pts != pktl->pkt.dts  ||
1165                     pktl->pkt.dts != AV_NOPTS_VALUE ||
1166                     pktl->pkt.duration)
1167                     break;
1168                 cur_dts -= duration;
1169             }
1170         }
1171         if (pktl && pktl->pkt.dts != st->first_dts) {
1172             av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1173                    av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1174             return;
1175         }
1176         if (!pktl) {
1177             av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1178             return;
1179         }
1180         pktl          = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1181         st->first_dts = cur_dts;
1182     } else if (st->cur_dts != RELATIVE_TS_BASE)
1183         return;
1184
1185     for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1186         if (pktl->pkt.stream_index != stream_index)
1187             continue;
1188         if ((pktl->pkt.pts == pktl->pkt.dts ||
1189              pktl->pkt.pts == AV_NOPTS_VALUE) &&
1190             (pktl->pkt.dts == AV_NOPTS_VALUE ||
1191              pktl->pkt.dts == st->first_dts ||
1192              pktl->pkt.dts == RELATIVE_TS_BASE) &&
1193             !pktl->pkt.duration) {
1194             pktl->pkt.dts = cur_dts;
1195             if (!st->internal->avctx->has_b_frames)
1196                 pktl->pkt.pts = cur_dts;
1197 //            if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1198                 pktl->pkt.duration = duration;
1199         } else
1200             break;
1201         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1202     }
1203     if (!pktl)
1204         st->cur_dts = cur_dts;
1205 }
1206
1207 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1208                                AVCodecParserContext *pc, AVPacket *pkt,
1209                                int64_t next_dts, int64_t next_pts)
1210 {
1211     int num, den, presentation_delayed, delay, i;
1212     int64_t offset;
1213     AVRational duration;
1214     int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1215                        st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1216
1217     if (s->flags & AVFMT_FLAG_NOFILLIN)
1218         return;
1219
1220     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1221         if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1222             if (st->last_dts_for_order_check <= pkt->dts) {
1223                 st->dts_ordered++;
1224             } else {
1225                 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1226                        "DTS %"PRIi64" < %"PRIi64" out of order\n",
1227                        pkt->dts,
1228                        st->last_dts_for_order_check);
1229                 st->dts_misordered++;
1230             }
1231             if (st->dts_ordered + st->dts_misordered > 250) {
1232                 st->dts_ordered    >>= 1;
1233                 st->dts_misordered >>= 1;
1234             }
1235         }
1236
1237         st->last_dts_for_order_check = pkt->dts;
1238         if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1239             pkt->dts = AV_NOPTS_VALUE;
1240     }
1241
1242     if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1243         pkt->dts = AV_NOPTS_VALUE;
1244
1245     if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1246         && !st->internal->avctx->has_b_frames)
1247         //FIXME Set low_delay = 0 when has_b_frames = 1
1248         st->internal->avctx->has_b_frames = 1;
1249
1250     /* do we have a video B-frame ? */
1251     delay = st->internal->avctx->has_b_frames;
1252     presentation_delayed = 0;
1253
1254     /* XXX: need has_b_frame, but cannot get it if the codec is
1255      *  not initialized */
1256     if (delay &&
1257         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1258         presentation_delayed = 1;
1259
1260     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1261         st->pts_wrap_bits < 63 &&
1262         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1263         if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1264             pkt->dts -= 1LL << st->pts_wrap_bits;
1265         } else
1266             pkt->pts += 1LL << st->pts_wrap_bits;
1267     }
1268
1269     /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1270      * We take the conservative approach and discard both.
1271      * Note: If this is misbehaving for an H.264 file, then possibly
1272      * presentation_delayed is not set correctly. */
1273     if (delay == 1 && pkt->dts == pkt->pts &&
1274         pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1275         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1276         if (    strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1277              && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1278             pkt->dts = AV_NOPTS_VALUE;
1279     }
1280
1281     duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1282     if (pkt->duration == 0) {
1283         ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1284         if (den && num) {
1285             duration = (AVRational) {num, den};
1286             pkt->duration = av_rescale_rnd(1,
1287                                            num * (int64_t) st->time_base.den,
1288                                            den * (int64_t) st->time_base.num,
1289                                            AV_ROUND_DOWN);
1290         }
1291     }
1292
1293     if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1294         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1295
1296     /* Correct timestamps with byte offset if demuxers only have timestamps
1297      * on packet boundaries */
1298     if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1299         /* this will estimate bitrate based on this frame's duration and size */
1300         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1301         if (pkt->pts != AV_NOPTS_VALUE)
1302             pkt->pts += offset;
1303         if (pkt->dts != AV_NOPTS_VALUE)
1304             pkt->dts += offset;
1305     }
1306
1307     /* This may be redundant, but it should not hurt. */
1308     if (pkt->dts != AV_NOPTS_VALUE &&
1309         pkt->pts != AV_NOPTS_VALUE &&
1310         pkt->pts > pkt->dts)
1311         presentation_delayed = 1;
1312
1313     if (s->debug & FF_FDEBUG_TS)
1314         av_log(s, AV_LOG_TRACE,
1315             "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1316             presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1317             pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1318
1319     /* Interpolate PTS and DTS if they are not present. We skip H264
1320      * currently because delay and has_b_frames are not reliably set. */
1321     if ((delay == 0 || (delay == 1 && pc)) &&
1322         onein_oneout) {
1323         if (presentation_delayed) {
1324             /* DTS = decompression timestamp */
1325             /* PTS = presentation timestamp */
1326             if (pkt->dts == AV_NOPTS_VALUE)
1327                 pkt->dts = st->last_IP_pts;
1328             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1329             if (pkt->dts == AV_NOPTS_VALUE)
1330                 pkt->dts = st->cur_dts;
1331
1332             /* This is tricky: the dts must be incremented by the duration
1333              * of the frame we are displaying, i.e. the last I- or P-frame. */
1334             if (st->last_IP_duration == 0)
1335                 st->last_IP_duration = pkt->duration;
1336             if (pkt->dts != AV_NOPTS_VALUE)
1337                 st->cur_dts = pkt->dts + st->last_IP_duration;
1338             if (pkt->dts != AV_NOPTS_VALUE &&
1339                 pkt->pts == AV_NOPTS_VALUE &&
1340                 st->last_IP_duration > 0 &&
1341                 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1342                 next_dts != next_pts &&
1343                 next_pts != AV_NOPTS_VALUE)
1344                 pkt->pts = next_dts;
1345
1346             st->last_IP_duration = pkt->duration;
1347             st->last_IP_pts      = pkt->pts;
1348             /* Cannot compute PTS if not present (we can compute it only
1349              * by knowing the future. */
1350         } else if (pkt->pts != AV_NOPTS_VALUE ||
1351                    pkt->dts != AV_NOPTS_VALUE ||
1352                    pkt->duration                ) {
1353
1354             /* presentation is not delayed : PTS and DTS are the same */
1355             if (pkt->pts == AV_NOPTS_VALUE)
1356                 pkt->pts = pkt->dts;
1357             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1358                                       pkt->pts, pkt);
1359             if (pkt->pts == AV_NOPTS_VALUE)
1360                 pkt->pts = st->cur_dts;
1361             pkt->dts = pkt->pts;
1362             if (pkt->pts != AV_NOPTS_VALUE)
1363                 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1364         }
1365     }
1366
1367     if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1368         st->pts_buffer[0] = pkt->pts;
1369         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1370             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1371
1372         if(has_decode_delay_been_guessed(st))
1373             pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1374     }
1375     // We skipped it above so we try here.
1376     if (!onein_oneout)
1377         // This should happen on the first packet
1378         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1379     if (pkt->dts > st->cur_dts)
1380         st->cur_dts = pkt->dts;
1381
1382     if (s->debug & FF_FDEBUG_TS)
1383         av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1384             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1385
1386     /* update flags */
1387     if (is_intra_only(st->codecpar->codec_id))
1388         pkt->flags |= AV_PKT_FLAG_KEY;
1389 #if FF_API_CONVERGENCE_DURATION
1390 FF_DISABLE_DEPRECATION_WARNINGS
1391     if (pc)
1392         pkt->convergence_duration = pc->convergence_duration;
1393 FF_ENABLE_DEPRECATION_WARNINGS
1394 #endif
1395 }
1396
1397 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1398 {
1399     while (*pkt_buf) {
1400         AVPacketList *pktl = *pkt_buf;
1401         *pkt_buf = pktl->next;
1402         av_packet_unref(&pktl->pkt);
1403         av_freep(&pktl);
1404     }
1405     *pkt_buf_end = NULL;
1406 }
1407
1408 /**
1409  * Parse a packet, add all split parts to parse_queue.
1410  *
1411  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1412  */
1413 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1414 {
1415     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1416     AVStream *st = s->streams[stream_index];
1417     uint8_t *data = pkt ? pkt->data : NULL;
1418     int size      = pkt ? pkt->size : 0;
1419     int ret = 0, got_output = 0;
1420
1421     if (!pkt) {
1422         av_init_packet(&flush_pkt);
1423         pkt        = &flush_pkt;
1424         got_output = 1;
1425     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1426         // preserve 0-size sync packets
1427         compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1428     }
1429
1430     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1431         int len;
1432         int64_t next_pts = pkt->pts;
1433         int64_t next_dts = pkt->dts;
1434
1435         av_init_packet(&out_pkt);
1436         len = av_parser_parse2(st->parser, st->internal->avctx,
1437                                &out_pkt.data, &out_pkt.size, data, size,
1438                                pkt->pts, pkt->dts, pkt->pos);
1439
1440         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1441         pkt->pos = -1;
1442         /* increment read pointer */
1443         data += len;
1444         size -= len;
1445
1446         got_output = !!out_pkt.size;
1447
1448         if (!out_pkt.size)
1449             continue;
1450
1451         if (pkt->side_data) {
1452             out_pkt.side_data       = pkt->side_data;
1453             out_pkt.side_data_elems = pkt->side_data_elems;
1454             pkt->side_data          = NULL;
1455             pkt->side_data_elems    = 0;
1456         }
1457
1458         /* set the duration */
1459         out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1460         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1461             if (st->internal->avctx->sample_rate > 0) {
1462                 out_pkt.duration =
1463                     av_rescale_q_rnd(st->parser->duration,
1464                                      (AVRational) { 1, st->internal->avctx->sample_rate },
1465                                      st->time_base,
1466                                      AV_ROUND_DOWN);
1467             }
1468         }
1469
1470         out_pkt.stream_index = st->index;
1471         out_pkt.pts          = st->parser->pts;
1472         out_pkt.dts          = st->parser->dts;
1473         out_pkt.pos          = st->parser->pos;
1474         out_pkt.flags       |= pkt->flags & AV_PKT_FLAG_DISCARD;
1475
1476         if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1477             out_pkt.pos = st->parser->frame_offset;
1478
1479         if (st->parser->key_frame == 1 ||
1480             (st->parser->key_frame == -1 &&
1481              st->parser->pict_type == AV_PICTURE_TYPE_I))
1482             out_pkt.flags |= AV_PKT_FLAG_KEY;
1483
1484         if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1485             out_pkt.flags |= AV_PKT_FLAG_KEY;
1486
1487         compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1488
1489         ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1490                             &s->internal->parse_queue_end, 1);
1491         av_packet_unref(&out_pkt);
1492         if (ret < 0)
1493             goto fail;
1494     }
1495
1496     /* end of the stream => close and free the parser */
1497     if (pkt == &flush_pkt) {
1498         av_parser_close(st->parser);
1499         st->parser = NULL;
1500     }
1501
1502 fail:
1503     av_packet_unref(pkt);
1504     return ret;
1505 }
1506
1507 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1508                                    AVPacketList **pkt_buffer_end,
1509                                    AVPacket      *pkt)
1510 {
1511     AVPacketList *pktl;
1512     av_assert0(*pkt_buffer);
1513     pktl        = *pkt_buffer;
1514     *pkt        = pktl->pkt;
1515     *pkt_buffer = pktl->next;
1516     if (!pktl->next)
1517         *pkt_buffer_end = NULL;
1518     av_freep(&pktl);
1519     return 0;
1520 }
1521
1522 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1523 {
1524     return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1525 }
1526
1527 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1528 {
1529     int ret = 0, i, got_packet = 0;
1530     AVDictionary *metadata = NULL;
1531
1532     av_init_packet(pkt);
1533
1534     while (!got_packet && !s->internal->parse_queue) {
1535         AVStream *st;
1536         AVPacket cur_pkt;
1537
1538         /* read next packet */
1539         ret = ff_read_packet(s, &cur_pkt);
1540         if (ret < 0) {
1541             if (ret == AVERROR(EAGAIN))
1542                 return ret;
1543             /* flush the parsers */
1544             for (i = 0; i < s->nb_streams; i++) {
1545                 st = s->streams[i];
1546                 if (st->parser && st->need_parsing)
1547                     parse_packet(s, NULL, st->index);
1548             }
1549             /* all remaining packets are now in parse_queue =>
1550              * really terminate parsing */
1551             break;
1552         }
1553         ret = 0;
1554         st  = s->streams[cur_pkt.stream_index];
1555
1556         /* update context if required */
1557         if (st->internal->need_context_update) {
1558             if (avcodec_is_open(st->internal->avctx)) {
1559                 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1560                 avcodec_close(st->internal->avctx);
1561                 st->info->found_decoder = 0;
1562             }
1563
1564             /* close parser, because it depends on the codec */
1565             if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1566                 av_parser_close(st->parser);
1567                 st->parser = NULL;
1568             }
1569
1570             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1571             if (ret < 0)
1572                 return ret;
1573
1574 #if FF_API_LAVF_AVCTX
1575 FF_DISABLE_DEPRECATION_WARNINGS
1576             /* update deprecated public codec context */
1577             ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1578             if (ret < 0)
1579                 return ret;
1580 FF_ENABLE_DEPRECATION_WARNINGS
1581 #endif
1582
1583             st->internal->need_context_update = 0;
1584         }
1585
1586         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1587             cur_pkt.dts != AV_NOPTS_VALUE &&
1588             cur_pkt.pts < cur_pkt.dts) {
1589             av_log(s, AV_LOG_WARNING,
1590                    "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1591                    cur_pkt.stream_index,
1592                    av_ts2str(cur_pkt.pts),
1593                    av_ts2str(cur_pkt.dts),
1594                    cur_pkt.size);
1595         }
1596         if (s->debug & FF_FDEBUG_TS)
1597             av_log(s, AV_LOG_DEBUG,
1598                    "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1599                    cur_pkt.stream_index,
1600                    av_ts2str(cur_pkt.pts),
1601                    av_ts2str(cur_pkt.dts),
1602                    cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1603
1604         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1605             st->parser = av_parser_init(st->codecpar->codec_id);
1606             if (!st->parser) {
1607                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1608                        "%s, packets or times may be invalid.\n",
1609                        avcodec_get_name(st->codecpar->codec_id));
1610                 /* no parser available: just output the raw packets */
1611                 st->need_parsing = AVSTREAM_PARSE_NONE;
1612             } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1613                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1614             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1615                 st->parser->flags |= PARSER_FLAG_ONCE;
1616             else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1617                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1618         }
1619
1620         if (!st->need_parsing || !st->parser) {
1621             /* no parsing needed: we just output the packet as is */
1622             *pkt = cur_pkt;
1623             compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1624             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1625                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1626                 ff_reduce_index(s, st->index);
1627                 av_add_index_entry(st, pkt->pos, pkt->dts,
1628                                    0, 0, AVINDEX_KEYFRAME);
1629             }
1630             got_packet = 1;
1631         } else if (st->discard < AVDISCARD_ALL) {
1632             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1633                 return ret;
1634             st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1635             st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1636             st->codecpar->channels = st->internal->avctx->channels;
1637             st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1638             st->codecpar->codec_id = st->internal->avctx->codec_id;
1639         } else {
1640             /* free packet */
1641             av_packet_unref(&cur_pkt);
1642         }
1643         if (pkt->flags & AV_PKT_FLAG_KEY)
1644             st->skip_to_keyframe = 0;
1645         if (st->skip_to_keyframe) {
1646             av_packet_unref(&cur_pkt);
1647             if (got_packet) {
1648                 *pkt = cur_pkt;
1649             }
1650             got_packet = 0;
1651         }
1652     }
1653
1654     if (!got_packet && s->internal->parse_queue)
1655         ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1656
1657     if (ret >= 0) {
1658         AVStream *st = s->streams[pkt->stream_index];
1659         int discard_padding = 0;
1660         if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1661             int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1662             int64_t sample = ts_to_samples(st, pts);
1663             int duration = ts_to_samples(st, pkt->duration);
1664             int64_t end_sample = sample + duration;
1665             if (duration > 0 && end_sample >= st->first_discard_sample &&
1666                 sample < st->last_discard_sample)
1667                 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1668         }
1669         if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1670             st->skip_samples = st->start_skip_samples;
1671         if (st->skip_samples || discard_padding) {
1672             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1673             if (p) {
1674                 AV_WL32(p, st->skip_samples);
1675                 AV_WL32(p + 4, discard_padding);
1676                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1677             }
1678             st->skip_samples = 0;
1679         }
1680
1681         if (st->inject_global_side_data) {
1682             for (i = 0; i < st->nb_side_data; i++) {
1683                 AVPacketSideData *src_sd = &st->side_data[i];
1684                 uint8_t *dst_data;
1685
1686                 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1687                     continue;
1688
1689                 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1690                 if (!dst_data) {
1691                     av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1692                     continue;
1693                 }
1694
1695                 memcpy(dst_data, src_sd->data, src_sd->size);
1696             }
1697             st->inject_global_side_data = 0;
1698         }
1699     }
1700
1701     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1702     if (metadata) {
1703         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1704         av_dict_copy(&s->metadata, metadata, 0);
1705         av_dict_free(&metadata);
1706         av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1707     }
1708
1709 #if FF_API_LAVF_AVCTX
1710     update_stream_avctx(s);
1711 #endif
1712
1713     if (s->debug & FF_FDEBUG_TS)
1714         av_log(s, AV_LOG_DEBUG,
1715                "read_frame_internal stream=%d, pts=%s, dts=%s, "
1716                "size=%d, duration=%"PRId64", flags=%d\n",
1717                pkt->stream_index,
1718                av_ts2str(pkt->pts),
1719                av_ts2str(pkt->dts),
1720                pkt->size, pkt->duration, pkt->flags);
1721
1722     return ret;
1723 }
1724
1725 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1726 {
1727     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1728     int eof = 0;
1729     int ret;
1730     AVStream *st;
1731
1732     if (!genpts) {
1733         ret = s->internal->packet_buffer
1734               ? read_from_packet_buffer(&s->internal->packet_buffer,
1735                                         &s->internal->packet_buffer_end, pkt)
1736               : read_frame_internal(s, pkt);
1737         if (ret < 0)
1738             return ret;
1739         goto return_packet;
1740     }
1741
1742     for (;;) {
1743         AVPacketList *pktl = s->internal->packet_buffer;
1744
1745         if (pktl) {
1746             AVPacket *next_pkt = &pktl->pkt;
1747
1748             if (next_pkt->dts != AV_NOPTS_VALUE) {
1749                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1750                 // last dts seen for this stream. if any of packets following
1751                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1752                 int64_t last_dts = next_pkt->dts;
1753                 av_assert2(wrap_bits <= 64);
1754                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1755                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1756                         av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1757                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1758                             // not B-frame
1759                             next_pkt->pts = pktl->pkt.dts;
1760                         }
1761                         if (last_dts != AV_NOPTS_VALUE) {
1762                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1763                             last_dts = pktl->pkt.dts;
1764                         }
1765                     }
1766                     pktl = pktl->next;
1767                 }
1768                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1769                     // Fixing the last reference frame had none pts issue (For MXF etc).
1770                     // We only do this when
1771                     // 1. eof.
1772                     // 2. we are not able to resolve a pts value for current packet.
1773                     // 3. the packets for this stream at the end of the files had valid dts.
1774                     next_pkt->pts = last_dts + next_pkt->duration;
1775                 }
1776                 pktl = s->internal->packet_buffer;
1777             }
1778
1779             /* read packet from packet buffer, if there is data */
1780             st = s->streams[next_pkt->stream_index];
1781             if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1782                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1783                 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1784                                                &s->internal->packet_buffer_end, pkt);
1785                 goto return_packet;
1786             }
1787         }
1788
1789         ret = read_frame_internal(s, pkt);
1790         if (ret < 0) {
1791             if (pktl && ret != AVERROR(EAGAIN)) {
1792                 eof = 1;
1793                 continue;
1794             } else
1795                 return ret;
1796         }
1797
1798         ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1799                             &s->internal->packet_buffer_end, 1);
1800         av_packet_unref(pkt);
1801         if (ret < 0)
1802             return ret;
1803     }
1804
1805 return_packet:
1806
1807     st = s->streams[pkt->stream_index];
1808     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1809         ff_reduce_index(s, st->index);
1810         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1811     }
1812
1813     if (is_relative(pkt->dts))
1814         pkt->dts -= RELATIVE_TS_BASE;
1815     if (is_relative(pkt->pts))
1816         pkt->pts -= RELATIVE_TS_BASE;
1817
1818     return ret;
1819 }
1820
1821 /* XXX: suppress the packet queue */
1822 static void flush_packet_queue(AVFormatContext *s)
1823 {
1824     if (!s->internal)
1825         return;
1826     free_packet_buffer(&s->internal->parse_queue,       &s->internal->parse_queue_end);
1827     free_packet_buffer(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
1828     free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1829
1830     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1831 }
1832
1833 /*******************************************************/
1834 /* seek support */
1835
1836 int av_find_default_stream_index(AVFormatContext *s)
1837 {
1838     int i;
1839     AVStream *st;
1840     int best_stream = 0;
1841     int best_score = INT_MIN;
1842
1843     if (s->nb_streams <= 0)
1844         return -1;
1845     for (i = 0; i < s->nb_streams; i++) {
1846         int score = 0;
1847         st = s->streams[i];
1848         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1849             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1850                 score -= 400;
1851             if (st->codecpar->width && st->codecpar->height)
1852                 score += 50;
1853             score+= 25;
1854         }
1855         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1856             if (st->codecpar->sample_rate)
1857                 score += 50;
1858         }
1859         if (st->codec_info_nb_frames)
1860             score += 12;
1861
1862         if (st->discard != AVDISCARD_ALL)
1863             score += 200;
1864
1865         if (score > best_score) {
1866             best_score = score;
1867             best_stream = i;
1868         }
1869     }
1870     return best_stream;
1871 }
1872
1873 /** Flush the frame reader. */
1874 void ff_read_frame_flush(AVFormatContext *s)
1875 {
1876     AVStream *st;
1877     int i, j;
1878
1879     flush_packet_queue(s);
1880
1881     /* Reset read state for each stream. */
1882     for (i = 0; i < s->nb_streams; i++) {
1883         st = s->streams[i];
1884
1885         if (st->parser) {
1886             av_parser_close(st->parser);
1887             st->parser = NULL;
1888         }
1889         st->last_IP_pts = AV_NOPTS_VALUE;
1890         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1891         if (st->first_dts == AV_NOPTS_VALUE)
1892             st->cur_dts = RELATIVE_TS_BASE;
1893         else
1894             /* We set the current DTS to an unspecified origin. */
1895             st->cur_dts = AV_NOPTS_VALUE;
1896
1897         st->probe_packets = MAX_PROBE_PACKETS;
1898
1899         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1900             st->pts_buffer[j] = AV_NOPTS_VALUE;
1901
1902         if (s->internal->inject_global_side_data)
1903             st->inject_global_side_data = 1;
1904
1905         st->skip_samples = 0;
1906     }
1907 }
1908
1909 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1910 {
1911     int i;
1912
1913     for (i = 0; i < s->nb_streams; i++) {
1914         AVStream *st = s->streams[i];
1915
1916         st->cur_dts =
1917             av_rescale(timestamp,
1918                        st->time_base.den * (int64_t) ref_st->time_base.num,
1919                        st->time_base.num * (int64_t) ref_st->time_base.den);
1920     }
1921 }
1922
1923 void ff_reduce_index(AVFormatContext *s, int stream_index)
1924 {
1925     AVStream *st             = s->streams[stream_index];
1926     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1927
1928     if ((unsigned) st->nb_index_entries >= max_entries) {
1929         int i;
1930         for (i = 0; 2 * i < st->nb_index_entries; i++)
1931             st->index_entries[i] = st->index_entries[2 * i];
1932         st->nb_index_entries = i;
1933     }
1934 }
1935
1936 int ff_add_index_entry(AVIndexEntry **index_entries,
1937                        int *nb_index_entries,
1938                        unsigned int *index_entries_allocated_size,
1939                        int64_t pos, int64_t timestamp,
1940                        int size, int distance, int flags)
1941 {
1942     AVIndexEntry *entries, *ie;
1943     int index;
1944
1945     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1946         return -1;
1947
1948     if (timestamp == AV_NOPTS_VALUE)
1949         return AVERROR(EINVAL);
1950
1951     if (size < 0 || size > 0x3FFFFFFF)
1952         return AVERROR(EINVAL);
1953
1954     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1955         timestamp -= RELATIVE_TS_BASE;
1956
1957     entries = av_fast_realloc(*index_entries,
1958                               index_entries_allocated_size,
1959                               (*nb_index_entries + 1) *
1960                               sizeof(AVIndexEntry));
1961     if (!entries)
1962         return -1;
1963
1964     *index_entries = entries;
1965
1966     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1967                                       timestamp, AVSEEK_FLAG_ANY);
1968
1969     if (index < 0) {
1970         index = (*nb_index_entries)++;
1971         ie    = &entries[index];
1972         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1973     } else {
1974         ie = &entries[index];
1975         if (ie->timestamp != timestamp) {
1976             if (ie->timestamp <= timestamp)
1977                 return -1;
1978             memmove(entries + index + 1, entries + index,
1979                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1980             (*nb_index_entries)++;
1981         } else if (ie->pos == pos && distance < ie->min_distance)
1982             // do not reduce the distance
1983             distance = ie->min_distance;
1984     }
1985
1986     ie->pos          = pos;
1987     ie->timestamp    = timestamp;
1988     ie->min_distance = distance;
1989     ie->size         = size;
1990     ie->flags        = flags;
1991
1992     return index;
1993 }
1994
1995 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1996                        int size, int distance, int flags)
1997 {
1998     timestamp = wrap_timestamp(st, timestamp);
1999     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2000                               &st->index_entries_allocated_size, pos,
2001                               timestamp, size, distance, flags);
2002 }
2003
2004 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2005                               int64_t wanted_timestamp, int flags)
2006 {
2007     int a, b, m;
2008     int64_t timestamp;
2009
2010     a = -1;
2011     b = nb_entries;
2012
2013     // Optimize appending index entries at the end.
2014     if (b && entries[b - 1].timestamp < wanted_timestamp)
2015         a = b - 1;
2016
2017     while (b - a > 1) {
2018         m         = (a + b) >> 1;
2019
2020         // Search for the next non-discarded packet.
2021         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2022             m++;
2023             if (m == b && entries[m].timestamp >= wanted_timestamp) {
2024                 m = b - 1;
2025                 break;
2026             }
2027         }
2028
2029         timestamp = entries[m].timestamp;
2030         if (timestamp >= wanted_timestamp)
2031             b = m;
2032         if (timestamp <= wanted_timestamp)
2033             a = m;
2034     }
2035     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2036
2037     if (!(flags & AVSEEK_FLAG_ANY))
2038         while (m >= 0 && m < nb_entries &&
2039                !(entries[m].flags & AVINDEX_KEYFRAME))
2040             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2041
2042     if (m == nb_entries)
2043         return -1;
2044     return m;
2045 }
2046
2047 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2048 {
2049     int ist1, ist2;
2050     int64_t pos_delta = 0;
2051     int64_t skip = 0;
2052     //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2053     const char *proto = avio_find_protocol_name(s->filename);
2054
2055     if (!proto) {
2056         av_log(s, AV_LOG_INFO,
2057                "Protocol name not provided, cannot determine if input is local or "
2058                "a network protocol, buffers and access patterns cannot be configured "
2059                "optimally without knowing the protocol\n");
2060     }
2061
2062     if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2063         return;
2064
2065     for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2066         AVStream *st1 = s->streams[ist1];
2067         for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2068             AVStream *st2 = s->streams[ist2];
2069             int i1, i2;
2070
2071             if (ist1 == ist2)
2072                 continue;
2073
2074             for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2075                 AVIndexEntry *e1 = &st1->index_entries[i1];
2076                 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2077
2078                 skip = FFMAX(skip, e1->size);
2079                 for (; i2 < st2->nb_index_entries; i2++) {
2080                     AVIndexEntry *e2 = &st2->index_entries[i2];
2081                     int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2082                     if (e2_pts - e1_pts < time_tolerance)
2083                         continue;
2084                     pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2085                     break;
2086                 }
2087             }
2088         }
2089     }
2090
2091     pos_delta *= 2;
2092     /* XXX This could be adjusted depending on protocol*/
2093     if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2094         av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2095         ffio_set_buf_size(s->pb, pos_delta);
2096         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2097     }
2098
2099     if (skip < (1<<23)) {
2100         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2101     }
2102 }
2103
2104 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2105 {
2106     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2107                                      wanted_timestamp, flags);
2108 }
2109
2110 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2111                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2112 {
2113     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2114     if (stream_index >= 0)
2115         ts = wrap_timestamp(s->streams[stream_index], ts);
2116     return ts;
2117 }
2118
2119 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2120                          int64_t target_ts, int flags)
2121 {
2122     AVInputFormat *avif = s->iformat;
2123     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2124     int64_t ts_min, ts_max, ts;
2125     int index;
2126     int64_t ret;
2127     AVStream *st;
2128
2129     if (stream_index < 0)
2130         return -1;
2131
2132     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2133
2134     ts_max =
2135     ts_min = AV_NOPTS_VALUE;
2136     pos_limit = -1; // GCC falsely says it may be uninitialized.
2137
2138     st = s->streams[stream_index];
2139     if (st->index_entries) {
2140         AVIndexEntry *e;
2141
2142         /* FIXME: Whole function must be checked for non-keyframe entries in
2143          * index case, especially read_timestamp(). */
2144         index = av_index_search_timestamp(st, target_ts,
2145                                           flags | AVSEEK_FLAG_BACKWARD);
2146         index = FFMAX(index, 0);
2147         e     = &st->index_entries[index];
2148
2149         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2150             pos_min = e->pos;
2151             ts_min  = e->timestamp;
2152             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2153                     pos_min, av_ts2str(ts_min));
2154         } else {
2155             av_assert1(index == 0);
2156         }
2157
2158         index = av_index_search_timestamp(st, target_ts,
2159                                           flags & ~AVSEEK_FLAG_BACKWARD);
2160         av_assert0(index < st->nb_index_entries);
2161         if (index >= 0) {
2162             e = &st->index_entries[index];
2163             av_assert1(e->timestamp >= target_ts);
2164             pos_max   = e->pos;
2165             ts_max    = e->timestamp;
2166             pos_limit = pos_max - e->min_distance;
2167             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2168                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2169         }
2170     }
2171
2172     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2173                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
2174     if (pos < 0)
2175         return -1;
2176
2177     /* do the seek */
2178     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2179         return ret;
2180
2181     ff_read_frame_flush(s);
2182     ff_update_cur_dts(s, st, ts);
2183
2184     return 0;
2185 }
2186
2187 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2188                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2189 {
2190     int64_t step = 1024;
2191     int64_t limit, ts_max;
2192     int64_t filesize = avio_size(s->pb);
2193     int64_t pos_max  = filesize - 1;
2194     do {
2195         limit = pos_max;
2196         pos_max = FFMAX(0, (pos_max) - step);
2197         ts_max  = ff_read_timestamp(s, stream_index,
2198                                     &pos_max, limit, read_timestamp);
2199         step   += step;
2200     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2201     if (ts_max == AV_NOPTS_VALUE)
2202         return -1;
2203
2204     for (;;) {
2205         int64_t tmp_pos = pos_max + 1;
2206         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
2207                                             &tmp_pos, INT64_MAX, read_timestamp);
2208         if (tmp_ts == AV_NOPTS_VALUE)
2209             break;
2210         av_assert0(tmp_pos > pos_max);
2211         ts_max  = tmp_ts;
2212         pos_max = tmp_pos;
2213         if (tmp_pos >= filesize)
2214             break;
2215     }
2216
2217     if (ts)
2218         *ts = ts_max;
2219     if (pos)
2220         *pos = pos_max;
2221
2222     return 0;
2223 }
2224
2225 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2226                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2227                       int64_t ts_min, int64_t ts_max,
2228                       int flags, int64_t *ts_ret,
2229                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
2230                                                 int64_t *, int64_t))
2231 {
2232     int64_t pos, ts;
2233     int64_t start_pos;
2234     int no_change;
2235     int ret;
2236
2237     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2238
2239     if (ts_min == AV_NOPTS_VALUE) {
2240         pos_min = s->internal->data_offset;
2241         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2242         if (ts_min == AV_NOPTS_VALUE)
2243             return -1;
2244     }
2245
2246     if (ts_min >= target_ts) {
2247         *ts_ret = ts_min;
2248         return pos_min;
2249     }
2250
2251     if (ts_max == AV_NOPTS_VALUE) {
2252         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2253             return ret;
2254         pos_limit = pos_max;
2255     }
2256
2257     if (ts_max <= target_ts) {
2258         *ts_ret = ts_max;
2259         return pos_max;
2260     }
2261
2262     av_assert0(ts_min < ts_max);
2263
2264     no_change = 0;
2265     while (pos_min < pos_limit) {
2266         av_log(s, AV_LOG_TRACE,
2267                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2268                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2269         av_assert0(pos_limit <= pos_max);
2270
2271         if (no_change == 0) {
2272             int64_t approximate_keyframe_distance = pos_max - pos_limit;
2273             // interpolate position (better than dichotomy)
2274             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2275                              ts_max - ts_min) +
2276                   pos_min - approximate_keyframe_distance;
2277         } else if (no_change == 1) {
2278             // bisection if interpolation did not change min / max pos last time
2279             pos = (pos_min + pos_limit) >> 1;
2280         } else {
2281             /* linear search if bisection failed, can only happen if there
2282              * are very few or no keyframes between min/max */
2283             pos = pos_min;
2284         }
2285         if (pos <= pos_min)
2286             pos = pos_min + 1;
2287         else if (pos > pos_limit)
2288             pos = pos_limit;
2289         start_pos = pos;
2290
2291         // May pass pos_limit instead of -1.
2292         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2293         if (pos == pos_max)
2294             no_change++;
2295         else
2296             no_change = 0;
2297         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2298                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2299                 pos_min, pos, pos_max,
2300                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2301                 pos_limit, start_pos, no_change);
2302         if (ts == AV_NOPTS_VALUE) {
2303             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2304             return -1;
2305         }
2306         if (target_ts <= ts) {
2307             pos_limit = start_pos - 1;
2308             pos_max   = pos;
2309             ts_max    = ts;
2310         }
2311         if (target_ts >= ts) {
2312             pos_min = pos;
2313             ts_min  = ts;
2314         }
2315     }
2316
2317     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2318     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
2319 #if 0
2320     pos_min = pos;
2321     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2322     pos_min++;
2323     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2324     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2325             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2326 #endif
2327     *ts_ret = ts;
2328     return pos;
2329 }
2330
2331 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2332                            int64_t pos, int flags)
2333 {
2334     int64_t pos_min, pos_max;
2335
2336     pos_min = s->internal->data_offset;
2337     pos_max = avio_size(s->pb) - 1;
2338
2339     if (pos < pos_min)
2340         pos = pos_min;
2341     else if (pos > pos_max)
2342         pos = pos_max;
2343
2344     avio_seek(s->pb, pos, SEEK_SET);
2345
2346     s->io_repositioned = 1;
2347
2348     return 0;
2349 }
2350
2351 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2352                               int64_t timestamp, int flags)
2353 {
2354     int index;
2355     int64_t ret;
2356     AVStream *st;
2357     AVIndexEntry *ie;
2358
2359     st = s->streams[stream_index];
2360
2361     index = av_index_search_timestamp(st, timestamp, flags);
2362
2363     if (index < 0 && st->nb_index_entries &&
2364         timestamp < st->index_entries[0].timestamp)
2365         return -1;
2366
2367     if (index < 0 || index == st->nb_index_entries - 1) {
2368         AVPacket pkt;
2369         int nonkey = 0;
2370
2371         if (st->nb_index_entries) {
2372             av_assert0(st->index_entries);
2373             ie = &st->index_entries[st->nb_index_entries - 1];
2374             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2375                 return ret;
2376             ff_update_cur_dts(s, st, ie->timestamp);
2377         } else {
2378             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2379                 return ret;
2380         }
2381         for (;;) {
2382             int read_status;
2383             do {
2384                 read_status = av_read_frame(s, &pkt);
2385             } while (read_status == AVERROR(EAGAIN));
2386             if (read_status < 0)
2387                 break;
2388             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2389                 if (pkt.flags & AV_PKT_FLAG_KEY) {
2390                     av_packet_unref(&pkt);
2391                     break;
2392                 }
2393                 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2394                     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);
2395                     av_packet_unref(&pkt);
2396                     break;
2397                 }
2398             }
2399             av_packet_unref(&pkt);
2400         }
2401         index = av_index_search_timestamp(st, timestamp, flags);
2402     }
2403     if (index < 0)
2404         return -1;
2405
2406     ff_read_frame_flush(s);
2407     if (s->iformat->read_seek)
2408         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2409             return 0;
2410     ie = &st->index_entries[index];
2411     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2412         return ret;
2413     ff_update_cur_dts(s, st, ie->timestamp);
2414
2415     return 0;
2416 }
2417
2418 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2419                                int64_t timestamp, int flags)
2420 {
2421     int ret;
2422     AVStream *st;
2423
2424     if (flags & AVSEEK_FLAG_BYTE) {
2425         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2426             return -1;
2427         ff_read_frame_flush(s);
2428         return seek_frame_byte(s, stream_index, timestamp, flags);
2429     }
2430
2431     if (stream_index < 0) {
2432         stream_index = av_find_default_stream_index(s);
2433         if (stream_index < 0)
2434             return -1;
2435
2436         st = s->streams[stream_index];
2437         /* timestamp for default must be expressed in AV_TIME_BASE units */
2438         timestamp = av_rescale(timestamp, st->time_base.den,
2439                                AV_TIME_BASE * (int64_t) st->time_base.num);
2440     }
2441
2442     /* first, we try the format specific seek */
2443     if (s->iformat->read_seek) {
2444         ff_read_frame_flush(s);
2445         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2446     } else
2447         ret = -1;
2448     if (ret >= 0)
2449         return 0;
2450
2451     if (s->iformat->read_timestamp &&
2452         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2453         ff_read_frame_flush(s);
2454         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2455     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2456         ff_read_frame_flush(s);
2457         return seek_frame_generic(s, stream_index, timestamp, flags);
2458     } else
2459         return -1;
2460 }
2461
2462 int av_seek_frame(AVFormatContext *s, int stream_index,
2463                   int64_t timestamp, int flags)
2464 {
2465     int ret;
2466
2467     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2468         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2469         if ((flags & AVSEEK_FLAG_BACKWARD))
2470             max_ts = timestamp;
2471         else
2472             min_ts = timestamp;
2473         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2474                                   flags & ~AVSEEK_FLAG_BACKWARD);
2475     }
2476
2477     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2478
2479     if (ret >= 0)
2480         ret = avformat_queue_attached_pictures(s);
2481
2482     return ret;
2483 }
2484
2485 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2486                        int64_t ts, int64_t max_ts, int flags)
2487 {
2488     if (min_ts > ts || max_ts < ts)
2489         return -1;
2490     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2491         return AVERROR(EINVAL);
2492
2493     if (s->seek2any>0)
2494         flags |= AVSEEK_FLAG_ANY;
2495     flags &= ~AVSEEK_FLAG_BACKWARD;
2496
2497     if (s->iformat->read_seek2) {
2498         int ret;
2499         ff_read_frame_flush(s);
2500
2501         if (stream_index == -1 && s->nb_streams == 1) {
2502             AVRational time_base = s->streams[0]->time_base;
2503             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2504             min_ts = av_rescale_rnd(min_ts, time_base.den,
2505                                     time_base.num * (int64_t)AV_TIME_BASE,
2506                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2507             max_ts = av_rescale_rnd(max_ts, time_base.den,
2508                                     time_base.num * (int64_t)AV_TIME_BASE,
2509                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2510             stream_index = 0;
2511         }
2512
2513         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2514                                      ts, max_ts, flags);
2515
2516         if (ret >= 0)
2517             ret = avformat_queue_attached_pictures(s);
2518         return ret;
2519     }
2520
2521     if (s->iformat->read_timestamp) {
2522         // try to seek via read_timestamp()
2523     }
2524
2525     // Fall back on old API if new is not implemented but old is.
2526     // Note the old API has somewhat different semantics.
2527     if (s->iformat->read_seek || 1) {
2528         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2529         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2530         if (ret<0 && ts != min_ts && max_ts != ts) {
2531             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2532             if (ret >= 0)
2533                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2534         }
2535         return ret;
2536     }
2537
2538     // try some generic seek like seek_frame_generic() but with new ts semantics
2539     return -1; //unreachable
2540 }
2541
2542 int avformat_flush(AVFormatContext *s)
2543 {
2544     ff_read_frame_flush(s);
2545     return 0;
2546 }
2547
2548 /*******************************************************/
2549
2550 /**
2551  * Return TRUE if the stream has accurate duration in any stream.
2552  *
2553  * @return TRUE if the stream has accurate duration for at least one component.
2554  */
2555 static int has_duration(AVFormatContext *ic)
2556 {
2557     int i;
2558     AVStream *st;
2559
2560     for (i = 0; i < ic->nb_streams; i++) {
2561         st = ic->streams[i];
2562         if (st->duration != AV_NOPTS_VALUE)
2563             return 1;
2564     }
2565     if (ic->duration != AV_NOPTS_VALUE)
2566         return 1;
2567     return 0;
2568 }
2569
2570 /**
2571  * Estimate the stream timings from the one of each components.
2572  *
2573  * Also computes the global bitrate if possible.
2574  */
2575 static void update_stream_timings(AVFormatContext *ic)
2576 {
2577     int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2578     int64_t duration, duration1, filesize;
2579     int i;
2580     AVStream *st;
2581     AVProgram *p;
2582
2583     start_time = INT64_MAX;
2584     start_time_text = INT64_MAX;
2585     end_time   = INT64_MIN;
2586     end_time_text   = INT64_MIN;
2587     duration   = INT64_MIN;
2588     for (i = 0; i < ic->nb_streams; i++) {
2589         st = ic->streams[i];
2590         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2591             start_time1 = av_rescale_q(st->start_time, st->time_base,
2592                                        AV_TIME_BASE_Q);
2593             if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2594                 if (start_time1 < start_time_text)
2595                     start_time_text = start_time1;
2596             } else
2597                 start_time = FFMIN(start_time, start_time1);
2598             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2599                                          AV_TIME_BASE_Q,
2600                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2601             if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2602                 end_time1 += start_time1;
2603                 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2604                     end_time_text = FFMAX(end_time_text, end_time1);
2605                 else
2606                     end_time = FFMAX(end_time, end_time1);
2607             }
2608             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2609                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2610                     p->start_time = start_time1;
2611                 if (p->end_time < end_time1)
2612                     p->end_time = end_time1;
2613             }
2614         }
2615         if (st->duration != AV_NOPTS_VALUE) {
2616             duration1 = av_rescale_q(st->duration, st->time_base,
2617                                      AV_TIME_BASE_Q);
2618             duration  = FFMAX(duration, duration1);
2619         }
2620     }
2621     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2622         start_time = start_time_text;
2623     else if (start_time > start_time_text)
2624         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2625
2626     if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2627         end_time = end_time_text;
2628     } else if (end_time < end_time_text) {
2629         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2630     }
2631
2632     if (start_time != INT64_MAX) {
2633         ic->start_time = start_time;
2634         if (end_time != INT64_MIN) {
2635             if (ic->nb_programs > 1) {
2636                 for (i = 0; i < ic->nb_programs; i++) {
2637                     p = ic->programs[i];
2638                     if (p->start_time != AV_NOPTS_VALUE &&
2639                         p->end_time > p->start_time &&
2640                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2641                         duration = FFMAX(duration, p->end_time - p->start_time);
2642                 }
2643             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2644                 duration = FFMAX(duration, end_time - start_time);
2645             }
2646         }
2647     }
2648     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2649         ic->duration = duration;
2650     }
2651     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2652         /* compute the bitrate */
2653         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2654                          (double) ic->duration;
2655         if (bitrate >= 0 && bitrate <= INT64_MAX)
2656             ic->bit_rate = bitrate;
2657     }
2658 }
2659
2660 static void fill_all_stream_timings(AVFormatContext *ic)
2661 {
2662     int i;
2663     AVStream *st;
2664
2665     update_stream_timings(ic);
2666     for (i = 0; i < ic->nb_streams; i++) {
2667         st = ic->streams[i];
2668         if (st->start_time == AV_NOPTS_VALUE) {
2669             if (ic->start_time != AV_NOPTS_VALUE)
2670                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2671                                               st->time_base);
2672             if (ic->duration != AV_NOPTS_VALUE)
2673                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2674                                             st->time_base);
2675         }
2676     }
2677 }
2678
2679 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2680 {
2681     int64_t filesize, duration;
2682     int i, show_warning = 0;
2683     AVStream *st;
2684
2685     /* if bit_rate is already set, we believe it */
2686     if (ic->bit_rate <= 0) {
2687         int64_t bit_rate = 0;
2688         for (i = 0; i < ic->nb_streams; i++) {
2689             st = ic->streams[i];
2690             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2691                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2692             if (st->codecpar->bit_rate > 0) {
2693                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2694                     bit_rate = 0;
2695                     break;
2696                 }
2697                 bit_rate += st->codecpar->bit_rate;
2698             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2699                 // If we have a videostream with packets but without a bitrate
2700                 // then consider the sum not known
2701                 bit_rate = 0;
2702                 break;
2703             }
2704         }
2705         ic->bit_rate = bit_rate;
2706     }
2707
2708     /* if duration is already set, we believe it */
2709     if (ic->duration == AV_NOPTS_VALUE &&
2710         ic->bit_rate != 0) {
2711         filesize = ic->pb ? avio_size(ic->pb) : 0;
2712         if (filesize > ic->internal->data_offset) {
2713             filesize -= ic->internal->data_offset;
2714             for (i = 0; i < ic->nb_streams; i++) {
2715                 st      = ic->streams[i];
2716                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2717                     && st->duration == AV_NOPTS_VALUE) {
2718                     duration = av_rescale(8 * filesize, st->time_base.den,
2719                                           ic->bit_rate *
2720                                           (int64_t) st->time_base.num);
2721                     st->duration = duration;
2722                     show_warning = 1;
2723                 }
2724             }
2725         }
2726     }
2727     if (show_warning)
2728         av_log(ic, AV_LOG_WARNING,
2729                "Estimating duration from bitrate, this may be inaccurate\n");
2730 }
2731
2732 #define DURATION_MAX_READ_SIZE 250000LL
2733 #define DURATION_MAX_RETRY 6
2734
2735 /* only usable for MPEG-PS streams */
2736 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2737 {
2738     AVPacket pkt1, *pkt = &pkt1;
2739     AVStream *st;
2740     int num, den, read_size, i, ret;
2741     int found_duration = 0;
2742     int is_end;
2743     int64_t filesize, offset, duration;
2744     int retry = 0;
2745
2746     /* flush packet queue */
2747     flush_packet_queue(ic);
2748
2749     for (i = 0; i < ic->nb_streams; i++) {
2750         st = ic->streams[i];
2751         if (st->start_time == AV_NOPTS_VALUE &&
2752             st->first_dts == AV_NOPTS_VALUE &&
2753             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2754             av_log(ic, AV_LOG_WARNING,
2755                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2756
2757         if (st->parser) {
2758             av_parser_close(st->parser);
2759             st->parser = NULL;
2760         }
2761     }
2762
2763     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2764     /* estimate the end time (duration) */
2765     /* XXX: may need to support wrapping */
2766     filesize = ic->pb ? avio_size(ic->pb) : 0;
2767     do {
2768         is_end = found_duration;
2769         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2770         if (offset < 0)
2771             offset = 0;
2772
2773         avio_seek(ic->pb, offset, SEEK_SET);
2774         read_size = 0;
2775         for (;;) {
2776             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2777                 break;
2778
2779             do {
2780                 ret = ff_read_packet(ic, pkt);
2781             } while (ret == AVERROR(EAGAIN));
2782             if (ret != 0)
2783                 break;
2784             read_size += pkt->size;
2785             st         = ic->streams[pkt->stream_index];
2786             if (pkt->pts != AV_NOPTS_VALUE &&
2787                 (st->start_time != AV_NOPTS_VALUE ||
2788                  st->first_dts  != AV_NOPTS_VALUE)) {
2789                 if (pkt->duration == 0) {
2790                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2791                     if (den && num) {
2792                         pkt->duration = av_rescale_rnd(1,
2793                                            num * (int64_t) st->time_base.den,
2794                                            den * (int64_t) st->time_base.num,
2795                                            AV_ROUND_DOWN);
2796                     }
2797                 }
2798                 duration = pkt->pts + pkt->duration;
2799                 found_duration = 1;
2800                 if (st->start_time != AV_NOPTS_VALUE)
2801                     duration -= st->start_time;
2802                 else
2803                     duration -= st->first_dts;
2804                 if (duration > 0) {
2805                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2806                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2807                         st->duration = duration;
2808                     st->info->last_duration = duration;
2809                 }
2810             }
2811             av_packet_unref(pkt);
2812         }
2813
2814         /* check if all audio/video streams have valid duration */
2815         if (!is_end) {
2816             is_end = 1;
2817             for (i = 0; i < ic->nb_streams; i++) {
2818                 st = ic->streams[i];
2819                 switch (st->codecpar->codec_type) {
2820                     case AVMEDIA_TYPE_VIDEO:
2821                     case AVMEDIA_TYPE_AUDIO:
2822                         if (st->duration == AV_NOPTS_VALUE)
2823                             is_end = 0;
2824                 }
2825             }
2826         }
2827     } while (!is_end &&
2828              offset &&
2829              ++retry <= DURATION_MAX_RETRY);
2830
2831     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2832
2833     /* warn about audio/video streams which duration could not be estimated */
2834     for (i = 0; i < ic->nb_streams; i++) {
2835         st = ic->streams[i];
2836         if (st->duration == AV_NOPTS_VALUE) {
2837             switch (st->codecpar->codec_type) {
2838             case AVMEDIA_TYPE_VIDEO:
2839             case AVMEDIA_TYPE_AUDIO:
2840                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2841                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2842                 } else
2843                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2844             }
2845         }
2846     }
2847     fill_all_stream_timings(ic);
2848
2849     avio_seek(ic->pb, old_offset, SEEK_SET);
2850     for (i = 0; i < ic->nb_streams; i++) {
2851         int j;
2852
2853         st              = ic->streams[i];
2854         st->cur_dts     = st->first_dts;
2855         st->last_IP_pts = AV_NOPTS_VALUE;
2856         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2857         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2858             st->pts_buffer[j] = AV_NOPTS_VALUE;
2859     }
2860 }
2861
2862 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2863 {
2864     int64_t file_size;
2865
2866     /* get the file size, if possible */
2867     if (ic->iformat->flags & AVFMT_NOFILE) {
2868         file_size = 0;
2869     } else {
2870         file_size = avio_size(ic->pb);
2871         file_size = FFMAX(0, file_size);
2872     }
2873
2874     if ((!strcmp(ic->iformat->name, "mpeg") ||
2875          !strcmp(ic->iformat->name, "mpegts")) &&
2876         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2877         /* get accurate estimate from the PTSes */
2878         estimate_timings_from_pts(ic, old_offset);
2879         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2880     } else if (has_duration(ic)) {
2881         /* at least one component has timings - we use them for all
2882          * the components */
2883         fill_all_stream_timings(ic);
2884         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2885     } else {
2886         /* less precise: use bitrate info */
2887         estimate_timings_from_bit_rate(ic);
2888         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2889     }
2890     update_stream_timings(ic);
2891
2892     {
2893         int i;
2894         AVStream av_unused *st;
2895         for (i = 0; i < ic->nb_streams; i++) {
2896             st = ic->streams[i];
2897             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2898                    (double) st->start_time * av_q2d(st->time_base),
2899                    (double) st->duration   * av_q2d(st->time_base));
2900         }
2901         av_log(ic, AV_LOG_TRACE,
2902                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2903                 (double) ic->start_time / AV_TIME_BASE,
2904                 (double) ic->duration   / AV_TIME_BASE,
2905                 (int64_t)ic->bit_rate / 1000);
2906     }
2907 }
2908
2909 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2910 {
2911     AVCodecContext *avctx = st->internal->avctx;
2912
2913 #define FAIL(errmsg) do {                                         \
2914         if (errmsg_ptr)                                           \
2915             *errmsg_ptr = errmsg;                                 \
2916         return 0;                                                 \
2917     } while (0)
2918
2919     if (   avctx->codec_id == AV_CODEC_ID_NONE
2920         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2921         FAIL("unknown codec");
2922     switch (avctx->codec_type) {
2923     case AVMEDIA_TYPE_AUDIO:
2924         if (!avctx->frame_size && determinable_frame_size(avctx))
2925             FAIL("unspecified frame size");
2926         if (st->info->found_decoder >= 0 &&
2927             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2928             FAIL("unspecified sample format");
2929         if (!avctx->sample_rate)
2930             FAIL("unspecified sample rate");
2931         if (!avctx->channels)
2932             FAIL("unspecified number of channels");
2933         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2934             FAIL("no decodable DTS frames");
2935         break;
2936     case AVMEDIA_TYPE_VIDEO:
2937         if (!avctx->width)
2938             FAIL("unspecified size");
2939         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2940             FAIL("unspecified pixel format");
2941         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2942             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2943                 FAIL("no frame in rv30/40 and no sar");
2944         break;
2945     case AVMEDIA_TYPE_SUBTITLE:
2946         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2947             FAIL("unspecified size");
2948         break;
2949     case AVMEDIA_TYPE_DATA:
2950         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2951     }
2952
2953     return 1;
2954 }
2955
2956 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2957 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2958                             AVDictionary **options)
2959 {
2960     AVCodecContext *avctx = st->internal->avctx;
2961     const AVCodec *codec;
2962     int got_picture = 1, ret = 0;
2963     AVFrame *frame = av_frame_alloc();
2964     AVSubtitle subtitle;
2965     AVPacket pkt = *avpkt;
2966     int do_skip_frame = 0;
2967     enum AVDiscard skip_frame;
2968
2969     if (!frame)
2970         return AVERROR(ENOMEM);
2971
2972     if (!avcodec_is_open(avctx) &&
2973         st->info->found_decoder <= 0 &&
2974         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2975         AVDictionary *thread_opt = NULL;
2976
2977         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2978
2979         if (!codec) {
2980             st->info->found_decoder = -st->codecpar->codec_id;
2981             ret                     = -1;
2982             goto fail;
2983         }
2984
2985         /* Force thread count to 1 since the H.264 decoder will not extract
2986          * SPS and PPS to extradata during multi-threaded decoding. */
2987         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2988         if (s->codec_whitelist)
2989             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2990         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2991         if (!options)
2992             av_dict_free(&thread_opt);
2993         if (ret < 0) {
2994             st->info->found_decoder = -avctx->codec_id;
2995             goto fail;
2996         }
2997         st->info->found_decoder = 1;
2998     } else if (!st->info->found_decoder)
2999         st->info->found_decoder = 1;
3000
3001     if (st->info->found_decoder < 0) {
3002         ret = -1;
3003         goto fail;
3004     }
3005
3006     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3007         do_skip_frame = 1;
3008         skip_frame = avctx->skip_frame;
3009         avctx->skip_frame = AVDISCARD_ALL;
3010     }
3011
3012     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3013            ret >= 0 &&
3014            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3015             (!st->codec_info_nb_frames &&
3016              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3017         got_picture = 0;
3018         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3019             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3020             ret = avcodec_send_packet(avctx, &pkt);
3021             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3022                 break;
3023             if (ret >= 0)
3024                 pkt.size = 0;
3025             ret = avcodec_receive_frame(avctx, frame);
3026             if (ret >= 0)
3027                 got_picture = 1;
3028             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3029                 ret = 0;
3030         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3031             ret = avcodec_decode_subtitle2(avctx, &subtitle,
3032                                            &got_picture, &pkt);
3033             if (ret >= 0)
3034                 pkt.size = 0;
3035         }
3036         if (ret >= 0) {
3037             if (got_picture)
3038                 st->nb_decoded_frames++;
3039             ret       = got_picture;
3040         }
3041     }
3042
3043     if (!pkt.data && !got_picture)
3044         ret = -1;
3045
3046 fail:
3047     if (do_skip_frame) {
3048         avctx->skip_frame = skip_frame;
3049     }
3050
3051     av_frame_free(&frame);
3052     return ret;
3053 }
3054
3055 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3056 {
3057     while (tags->id != AV_CODEC_ID_NONE) {
3058         if (tags->id == id)
3059             return tags->tag;
3060         tags++;
3061     }
3062     return 0;
3063 }
3064
3065 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3066 {
3067     int i;
3068     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3069         if (tag == tags[i].tag)
3070             return tags[i].id;
3071     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3072         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3073             return tags[i].id;
3074     return AV_CODEC_ID_NONE;
3075 }
3076
3077 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3078 {
3079     if (bps <= 0 || bps > 64)
3080         return AV_CODEC_ID_NONE;
3081
3082     if (flt) {
3083         switch (bps) {
3084         case 32:
3085             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3086         case 64:
3087             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3088         default:
3089             return AV_CODEC_ID_NONE;
3090         }
3091     } else {
3092         bps  += 7;
3093         bps >>= 3;
3094         if (sflags & (1 << (bps - 1))) {
3095             switch (bps) {
3096             case 1:
3097                 return AV_CODEC_ID_PCM_S8;
3098             case 2:
3099                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3100             case 3:
3101                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3102             case 4:
3103                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3104             case 8:
3105                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3106             default:
3107                 return AV_CODEC_ID_NONE;
3108             }
3109         } else {
3110             switch (bps) {
3111             case 1:
3112                 return AV_CODEC_ID_PCM_U8;
3113             case 2:
3114                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3115             case 3:
3116                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3117             case 4:
3118                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3119             default:
3120                 return AV_CODEC_ID_NONE;
3121             }
3122         }
3123     }
3124 }
3125
3126 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3127 {
3128     unsigned int tag;
3129     if (!av_codec_get_tag2(tags, id, &tag))
3130         return 0;
3131     return tag;
3132 }
3133
3134 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3135                       unsigned int *tag)
3136 {
3137     int i;
3138     for (i = 0; tags && tags[i]; i++) {
3139         const AVCodecTag *codec_tags = tags[i];
3140         while (codec_tags->id != AV_CODEC_ID_NONE) {
3141             if (codec_tags->id == id) {
3142                 *tag = codec_tags->tag;
3143                 return 1;
3144             }
3145             codec_tags++;
3146         }
3147     }
3148     return 0;
3149 }
3150
3151 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3152 {
3153     int i;
3154     for (i = 0; tags && tags[i]; i++) {
3155         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3156         if (id != AV_CODEC_ID_NONE)
3157             return id;
3158     }
3159     return AV_CODEC_ID_NONE;
3160 }
3161
3162 static void compute_chapters_end(AVFormatContext *s)
3163 {
3164     unsigned int i, j;
3165     int64_t max_time = 0;
3166
3167     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3168         max_time = s->duration +
3169                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3170
3171     for (i = 0; i < s->nb_chapters; i++)
3172         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3173             AVChapter *ch = s->chapters[i];
3174             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3175                                                   ch->time_base)
3176                                    : INT64_MAX;
3177
3178             for (j = 0; j < s->nb_chapters; j++) {
3179                 AVChapter *ch1     = s->chapters[j];
3180                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3181                                                   ch->time_base);
3182                 if (j != i && next_start > ch->start && next_start < end)
3183                     end = next_start;
3184             }
3185             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3186         }
3187 }
3188
3189 static int get_std_framerate(int i)
3190 {
3191     if (i < 30*12)
3192         return (i + 1) * 1001;
3193     i -= 30*12;
3194
3195     if (i < 30)
3196         return (i + 31) * 1001 * 12;
3197     i -= 30;
3198
3199     if (i < 3)
3200         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3201
3202     i -= 3;
3203
3204     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3205 }
3206
3207 /* Is the time base unreliable?
3208  * This is a heuristic to balance between quick acceptance of the values in
3209  * the headers vs. some extra checks.
3210  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3211  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3212  * And there are "variable" fps files this needs to detect as well. */
3213 static int tb_unreliable(AVCodecContext *c)
3214 {
3215     if (c->time_base.den >= 101LL * c->time_base.num ||
3216         c->time_base.den <    5LL * c->time_base.num ||
3217         // c->codec_tag == AV_RL32("DIVX") ||
3218         // c->codec_tag == AV_RL32("XVID") ||
3219         c->codec_tag == AV_RL32("mp4v") ||
3220         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3221         c->codec_id == AV_CODEC_ID_GIF ||
3222         c->codec_id == AV_CODEC_ID_HEVC ||
3223         c->codec_id == AV_CODEC_ID_H264)
3224         return 1;
3225     return 0;
3226 }
3227
3228 int ff_alloc_extradata(AVCodecParameters *par, int size)
3229 {
3230     int ret;
3231
3232     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3233         par->extradata = NULL;
3234         par->extradata_size = 0;
3235         return AVERROR(EINVAL);
3236     }
3237     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3238     if (par->extradata) {
3239         memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3240         par->extradata_size = size;
3241         ret = 0;
3242     } else {
3243         par->extradata_size = 0;
3244         ret = AVERROR(ENOMEM);
3245     }
3246     return ret;
3247 }
3248
3249 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3250 {
3251     int ret = ff_alloc_extradata(par, size);
3252     if (ret < 0)
3253         return ret;
3254     ret = avio_read(pb, par->extradata, size);
3255     if (ret != size) {
3256         av_freep(&par->extradata);
3257         par->extradata_size = 0;
3258         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3259         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3260     }
3261
3262     return ret;
3263 }
3264
3265 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3266 {
3267     int i, j;
3268     int64_t last = st->info->last_dts;
3269
3270     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3271        && ts - (uint64_t)last < INT64_MAX) {
3272         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3273         int64_t duration = ts - last;
3274
3275         if (!st->info->duration_error)
3276             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3277         if (!st->info->duration_error)
3278             return AVERROR(ENOMEM);
3279
3280 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3281 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3282         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3283             if (st->info->duration_error[0][1][i] < 1e10) {
3284                 int framerate = get_std_framerate(i);
3285                 double sdts = dts*framerate/(1001*12);
3286                 for (j= 0; j<2; j++) {
3287                     int64_t ticks = llrint(sdts+j*0.5);
3288                     double error= sdts - ticks + j*0.5;
3289                     st->info->duration_error[j][0][i] += error;
3290                     st->info->duration_error[j][1][i] += error*error;
3291                 }
3292             }
3293         }
3294         st->info->duration_count++;
3295         st->info->rfps_duration_sum += duration;
3296
3297         if (st->info->duration_count % 10 == 0) {
3298             int n = st->info->duration_count;
3299             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3300                 if (st->info->duration_error[0][1][i] < 1e10) {
3301                     double a0     = st->info->duration_error[0][0][i] / n;
3302                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3303                     double a1     = st->info->duration_error[1][0][i] / n;
3304                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3305                     if (error0 > 0.04 && error1 > 0.04) {
3306                         st->info->duration_error[0][1][i] = 2e10;
3307                         st->info->duration_error[1][1][i] = 2e10;
3308                     }
3309                 }
3310             }
3311         }
3312
3313         // ignore the first 4 values, they might have some random jitter
3314         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3315             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3316     }
3317     if (ts != AV_NOPTS_VALUE)
3318         st->info->last_dts = ts;
3319
3320     return 0;
3321 }
3322
3323 void ff_rfps_calculate(AVFormatContext *ic)
3324 {
3325     int i, j;
3326
3327     for (i = 0; i < ic->nb_streams; i++) {
3328         AVStream *st = ic->streams[i];
3329
3330         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3331             continue;
3332         // the check for tb_unreliable() is not completely correct, since this is not about handling
3333         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3334         // ipmovie.c produces.
3335         if (tb_unreliable(st->internal->avctx) && 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)
3336             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);
3337         if (st->info->duration_count>1 && !st->r_frame_rate.num
3338             && tb_unreliable(st->internal->avctx)) {
3339             int num = 0;
3340             double best_error= 0.01;
3341             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3342
3343             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3344                 int k;
3345
3346                 if (st->info->codec_info_duration &&
3347                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3348                     continue;
3349                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3350                     continue;
3351
3352                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3353                     continue;
3354
3355                 for (k= 0; k<2; k++) {
3356                     int n = st->info->duration_count;
3357                     double a= st->info->duration_error[k][0][j] / n;
3358                     double error= st->info->duration_error[k][1][j]/n - a*a;
3359
3360                     if (error < best_error && best_error> 0.000000001) {
3361                         best_error= error;
3362                         num = get_std_framerate(j);
3363                     }
3364                     if (error < 0.02)
3365                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3366                 }
3367             }
3368             // do not increase frame rate by more than 1 % in order to match a standard rate.
3369             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3370                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3371         }
3372         if (   !st->avg_frame_rate.num
3373             && st->r_frame_rate.num && st->info->rfps_duration_sum
3374             && st->info->codec_info_duration <= 0
3375             && st->info->duration_count > 2
3376             && 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
3377             ) {
3378             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3379             st->avg_frame_rate = st->r_frame_rate;
3380         }
3381
3382         av_freep(&st->info->duration_error);
3383         st->info->last_dts = AV_NOPTS_VALUE;
3384         st->info->duration_count = 0;
3385         st->info->rfps_duration_sum = 0;
3386     }
3387 }
3388
3389 static int extract_extradata_check(AVStream *st)
3390 {
3391     const AVBitStreamFilter *f;
3392
3393     f = av_bsf_get_by_name("extract_extradata");
3394     if (!f)
3395         return 0;
3396
3397     if (f->codec_ids) {
3398         const enum AVCodecID *ids;
3399         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3400             if (*ids == st->codecpar->codec_id)
3401                 return 1;
3402     }
3403
3404     return 0;
3405 }
3406
3407 static int extract_extradata_init(AVStream *st)
3408 {
3409     AVStreamInternal *i = st->internal;
3410     const AVBitStreamFilter *f;
3411     int ret;
3412
3413     f = av_bsf_get_by_name("extract_extradata");
3414     if (!f)
3415         goto finish;
3416
3417     /* check that the codec id is supported */
3418     ret = extract_extradata_check(st);
3419     if (!ret)
3420         goto finish;
3421
3422     i->extract_extradata.pkt = av_packet_alloc();
3423     if (!i->extract_extradata.pkt)
3424         return AVERROR(ENOMEM);
3425
3426     ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3427     if (ret < 0)
3428         goto fail;
3429
3430     ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3431                                   st->codecpar);
3432     if (ret < 0)
3433         goto fail;
3434
3435     i->extract_extradata.bsf->time_base_in = st->time_base;
3436
3437     /* if init fails here, we assume extracting extradata is just not
3438      * supported for this codec, so we return success */
3439     ret = av_bsf_init(i->extract_extradata.bsf);
3440     if (ret < 0) {
3441         av_bsf_free(&i->extract_extradata.bsf);
3442         ret = 0;
3443     }
3444
3445 finish:
3446     i->extract_extradata.inited = 1;
3447
3448     return 0;
3449 fail:
3450     av_bsf_free(&i->extract_extradata.bsf);
3451     av_packet_free(&i->extract_extradata.pkt);
3452     return ret;
3453 }
3454
3455 static int extract_extradata(AVStream *st, AVPacket *pkt)
3456 {
3457     AVStreamInternal *i = st->internal;
3458     AVPacket *pkt_ref;
3459     int ret;
3460
3461     if (!i->extract_extradata.inited) {
3462         ret = extract_extradata_init(st);
3463         if (ret < 0)
3464             return ret;
3465     }
3466
3467     if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3468         return 0;
3469
3470     pkt_ref = i->extract_extradata.pkt;
3471     ret = av_packet_ref(pkt_ref, pkt);
3472     if (ret < 0)
3473         return ret;
3474
3475     ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3476     if (ret < 0) {
3477         av_packet_unref(pkt_ref);
3478         return ret;
3479     }
3480
3481     while (ret >= 0 && !i->avctx->extradata) {
3482         int extradata_size;
3483         uint8_t *extradata;
3484
3485         ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3486         if (ret < 0) {
3487             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3488                 return ret;
3489             continue;
3490         }
3491
3492         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3493                                             &extradata_size);
3494
3495         if (extradata) {
3496             i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3497             if (!i->avctx->extradata) {
3498                 av_packet_unref(pkt_ref);
3499                 return AVERROR(ENOMEM);
3500             }
3501             memcpy(i->avctx->extradata, extradata, extradata_size);
3502             i->avctx->extradata_size = extradata_size;
3503         }
3504         av_packet_unref(pkt_ref);
3505     }
3506
3507     return 0;
3508 }
3509
3510 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3511 {
3512     int i, count = 0, ret = 0, j;
3513     int64_t read_size;
3514     AVStream *st;
3515     AVCodecContext *avctx;
3516     AVPacket pkt1, *pkt;
3517     int64_t old_offset  = avio_tell(ic->pb);
3518     // new streams might appear, no options for those
3519     int orig_nb_streams = ic->nb_streams;
3520     int flush_codecs;
3521     int64_t max_analyze_duration = ic->max_analyze_duration;
3522     int64_t max_stream_analyze_duration;
3523     int64_t max_subtitle_analyze_duration;
3524     int64_t probesize = ic->probesize;
3525     int eof_reached = 0;
3526     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3527
3528     flush_codecs = probesize > 0;
3529
3530     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3531
3532     max_stream_analyze_duration = max_analyze_duration;
3533     max_subtitle_analyze_duration = max_analyze_duration;
3534     if (!max_analyze_duration) {
3535         max_stream_analyze_duration =
3536         max_analyze_duration        = 5*AV_TIME_BASE;
3537         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3538         if (!strcmp(ic->iformat->name, "flv"))
3539             max_stream_analyze_duration = 90*AV_TIME_BASE;
3540         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3541             max_stream_analyze_duration = 7*AV_TIME_BASE;
3542     }
3543
3544     if (ic->pb)
3545         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3546                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3547
3548     for (i = 0; i < ic->nb_streams; i++) {
3549         const AVCodec *codec;
3550         AVDictionary *thread_opt = NULL;
3551         st = ic->streams[i];
3552         avctx = st->internal->avctx;
3553
3554         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3555             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3556 /*            if (!st->time_base.num)
3557                 st->time_base = */
3558             if (!avctx->time_base.num)
3559                 avctx->time_base = st->time_base;
3560         }
3561
3562         /* check if the caller has overridden the codec id */
3563 #if FF_API_LAVF_AVCTX
3564 FF_DISABLE_DEPRECATION_WARNINGS
3565         if (st->codec->codec_id != st->internal->orig_codec_id) {
3566             st->codecpar->codec_id   = st->codec->codec_id;
3567             st->codecpar->codec_type = st->codec->codec_type;
3568             st->internal->orig_codec_id = st->codec->codec_id;
3569         }
3570 FF_ENABLE_DEPRECATION_WARNINGS
3571 #endif
3572         // only for the split stuff
3573         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3574             st->parser = av_parser_init(st->codecpar->codec_id);
3575             if (st->parser) {
3576                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3577                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3578                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3579                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3580                 }
3581             } else if (st->need_parsing) {
3582                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3583                        "%s, packets or times may be invalid.\n",
3584                        avcodec_get_name(st->codecpar->codec_id));
3585             }
3586         }
3587
3588         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3589             st->internal->orig_codec_id = st->codecpar->codec_id;
3590
3591         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3592         if (ret < 0)
3593             goto find_stream_info_err;
3594         if (st->request_probe <= 0)
3595             st->internal->avctx_inited = 1;
3596
3597         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3598
3599         /* Force thread count to 1 since the H.264 decoder will not extract
3600          * SPS and PPS to extradata during multi-threaded decoding. */
3601         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3602
3603         if (ic->codec_whitelist)
3604             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3605
3606         /* Ensure that subtitle_header is properly set. */
3607         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3608             && codec && !avctx->codec) {
3609             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3610                 av_log(ic, AV_LOG_WARNING,
3611                        "Failed to open codec in %s\n",__FUNCTION__);
3612         }
3613
3614         // Try to just open decoders, in case this is enough to get parameters.
3615         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3616             if (codec && !avctx->codec)
3617                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3618                     av_log(ic, AV_LOG_WARNING,
3619                            "Failed to open codec in %s\n",__FUNCTION__);
3620         }
3621         if (!options)
3622             av_dict_free(&thread_opt);
3623     }
3624
3625     for (i = 0; i < ic->nb_streams; i++) {
3626 #if FF_API_R_FRAME_RATE
3627         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3628 #endif
3629         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3630         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3631     }
3632
3633     read_size = 0;
3634     for (;;) {
3635         int analyzed_all_streams;
3636         if (ff_check_interrupt(&ic->interrupt_callback)) {
3637             ret = AVERROR_EXIT;
3638             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3639             break;
3640         }
3641
3642         /* check if one codec still needs to be handled */
3643         for (i = 0; i < ic->nb_streams; i++) {
3644             int fps_analyze_framecount = 20;
3645             int count;
3646
3647             st = ic->streams[i];
3648             if (!has_codec_parameters(st, NULL))
3649                 break;
3650             /* If the timebase is coarse (like the usual millisecond precision
3651              * of mkv), we need to analyze more frames to reliably arrive at
3652              * the correct fps. */
3653             if (av_q2d(st->time_base) > 0.0005)
3654                 fps_analyze_framecount *= 2;
3655             if (!tb_unreliable(st->internal->avctx))
3656                 fps_analyze_framecount = 0;
3657             if (ic->fps_probe_size >= 0)
3658                 fps_analyze_framecount = ic->fps_probe_size;
3659             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3660                 fps_analyze_framecount = 0;
3661             /* variable fps and no guess at the real fps */
3662             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3663                        st->info->codec_info_duration_fields/2 :
3664                        st->info->duration_count;
3665             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3666                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3667                 if (count < fps_analyze_framecount)
3668                     break;
3669             }
3670             // Look at the first 3 frames if there is evidence of frame delay
3671             // but the decoder delay is not set.
3672             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3673                 break;
3674             if (!st->internal->avctx->extradata &&
3675                 (!st->internal->extract_extradata.inited ||
3676                  st->internal->extract_extradata.bsf) &&
3677                 extract_extradata_check(st))
3678                 break;
3679             if (st->first_dts == AV_NOPTS_VALUE &&
3680                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3681                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3682                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3683                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3684                 break;
3685         }
3686         analyzed_all_streams = 0;
3687         if (!missing_streams || !*missing_streams)
3688         if (i == ic->nb_streams) {
3689             analyzed_all_streams = 1;
3690             /* NOTE: If the format has no header, then we need to read some
3691              * packets to get most of the streams, so we cannot stop here. */
3692             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3693                 /* If we found the info for all the codecs, we can stop. */
3694                 ret = count;
3695                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3696                 flush_codecs = 0;
3697                 break;
3698             }
3699         }
3700         /* We did not get all the codec info, but we read too much data. */
3701         if (read_size >= probesize) {
3702             ret = count;
3703             av_log(ic, AV_LOG_DEBUG,
3704                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3705             for (i = 0; i < ic->nb_streams; i++)
3706                 if (!ic->streams[i]->r_frame_rate.num &&
3707                     ic->streams[i]->info->duration_count <= 1 &&
3708                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3709                     strcmp(ic->iformat->name, "image2"))
3710                     av_log(ic, AV_LOG_WARNING,
3711                            "Stream #%d: not enough frames to estimate rate; "
3712                            "consider increasing probesize\n", i);
3713             break;
3714         }
3715
3716         /* NOTE: A new stream can be added there if no header in file
3717          * (AVFMTCTX_NOHEADER). */
3718         ret = read_frame_internal(ic, &pkt1);
3719         if (ret == AVERROR(EAGAIN))
3720             continue;
3721
3722         if (ret < 0) {
3723             /* EOF or error*/
3724             eof_reached = 1;
3725             break;
3726         }
3727
3728         pkt = &pkt1;
3729
3730         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3731             ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3732                                 &ic->internal->packet_buffer_end, 0);
3733             if (ret < 0)
3734                 goto find_stream_info_err;
3735         }
3736
3737         st = ic->streams[pkt->stream_index];
3738         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3739             read_size += pkt->size;
3740
3741         avctx = st->internal->avctx;
3742         if (!st->internal->avctx_inited) {
3743             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3744             if (ret < 0)
3745                 goto find_stream_info_err;
3746             st->internal->avctx_inited = 1;
3747         }
3748
3749         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3750             /* check for non-increasing dts */
3751             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3752                 st->info->fps_last_dts >= pkt->dts) {
3753                 av_log(ic, AV_LOG_DEBUG,
3754                        "Non-increasing DTS in stream %d: packet %d with DTS "
3755                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3756                        st->index, st->info->fps_last_dts_idx,
3757                        st->info->fps_last_dts, st->codec_info_nb_frames,
3758                        pkt->dts);
3759                 st->info->fps_first_dts =
3760                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3761             }
3762             /* Check for a discontinuity in dts. If the difference in dts
3763              * is more than 1000 times the average packet duration in the
3764              * sequence, we treat it as a discontinuity. */
3765             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3766                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3767                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3768                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3769                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3770                 av_log(ic, AV_LOG_WARNING,
3771                        "DTS discontinuity in stream %d: packet %d with DTS "
3772                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3773                        st->index, st->info->fps_last_dts_idx,
3774                        st->info->fps_last_dts, st->codec_info_nb_frames,
3775                        pkt->dts);
3776                 st->info->fps_first_dts =
3777                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3778             }
3779
3780             /* update stored dts values */
3781             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3782                 st->info->fps_first_dts     = pkt->dts;
3783                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3784             }
3785             st->info->fps_last_dts     = pkt->dts;
3786             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3787         }
3788         if (st->codec_info_nb_frames>1) {
3789             int64_t t = 0;
3790             int64_t limit;
3791
3792             if (st->time_base.den > 0)
3793                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3794             if (st->avg_frame_rate.num > 0)
3795                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3796
3797             if (   t == 0
3798                 && st->codec_info_nb_frames>30
3799                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3800                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3801                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3802
3803             if (analyzed_all_streams)                                limit = max_analyze_duration;
3804             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3805             else                                                     limit = max_stream_analyze_duration;
3806
3807             if (t >= limit) {
3808                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3809                        limit,
3810                        t, pkt->stream_index);
3811                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3812                     av_packet_unref(pkt);
3813                 break;
3814             }
3815             if (pkt->duration) {
3816                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3817                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3818                 } else
3819                     st->info->codec_info_duration += pkt->duration;
3820                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3821             }
3822         }
3823         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3824 #if FF_API_R_FRAME_RATE
3825             ff_rfps_add_frame(ic, st, pkt->dts);
3826 #endif
3827             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3828                 st->info->frame_delay_evidence = 1;
3829         }
3830         if (!st->internal->avctx->extradata) {
3831             ret = extract_extradata(st, pkt);
3832             if (ret < 0)
3833                 goto find_stream_info_err;
3834         }
3835
3836         /* If still no information, we try to open the codec and to
3837          * decompress the frame. We try to avoid that in most cases as
3838          * it takes longer and uses more memory. For MPEG-4, we need to
3839          * decompress for QuickTime.
3840          *
3841          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3842          * least one frame of codec data, this makes sure the codec initializes
3843          * the channel configuration and does not only trust the values from
3844          * the container. */
3845         try_decode_frame(ic, st, pkt,
3846                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3847
3848         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3849             av_packet_unref(pkt);
3850
3851         st->codec_info_nb_frames++;
3852         count++;
3853     }
3854
3855     if (eof_reached) {
3856         int stream_index;
3857         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3858             st = ic->streams[stream_index];
3859             avctx = st->internal->avctx;
3860             if (!has_codec_parameters(st, NULL)) {
3861                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3862                 if (codec && !avctx->codec) {
3863                     AVDictionary *opts = NULL;
3864                     if (ic->codec_whitelist)
3865                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3866                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3867                         av_log(ic, AV_LOG_WARNING,
3868                                "Failed to open codec in %s\n",__FUNCTION__);
3869                     av_dict_free(&opts);
3870                 }
3871             }
3872
3873             // EOF already reached while reading the stream above.
3874             // So continue with reoordering DTS with whatever delay we have.
3875             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3876                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3877             }
3878         }
3879     }
3880
3881     if (flush_codecs) {
3882         AVPacket empty_pkt = { 0 };
3883         int err = 0;
3884         av_init_packet(&empty_pkt);
3885
3886         for (i = 0; i < ic->nb_streams; i++) {
3887
3888             st = ic->streams[i];
3889
3890             /* flush the decoders */
3891             if (st->info->found_decoder == 1) {
3892                 do {
3893                     err = try_decode_frame(ic, st, &empty_pkt,
3894                                             (options && i < orig_nb_streams)
3895                                             ? &options[i] : NULL);
3896                 } while (err > 0 && !has_codec_parameters(st, NULL));
3897
3898                 if (err < 0) {
3899                     av_log(ic, AV_LOG_INFO,
3900                         "decoding for stream %d failed\n", st->index);
3901                 }
3902             }
3903         }
3904     }
3905
3906     ff_rfps_calculate(ic);
3907
3908     for (i = 0; i < ic->nb_streams; i++) {
3909         st = ic->streams[i];
3910         avctx = st->internal->avctx;
3911         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3912             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3913                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3914                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3915                     avctx->codec_tag= tag;
3916             }
3917
3918             /* estimate average framerate if not set by demuxer */
3919             if (st->info->codec_info_duration_fields &&
3920                 !st->avg_frame_rate.num &&
3921                 st->info->codec_info_duration) {
3922                 int best_fps      = 0;
3923                 double best_error = 0.01;
3924                 AVRational codec_frame_rate = avctx->framerate;
3925
3926                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3927                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3928                     st->info->codec_info_duration        < 0)
3929                     continue;
3930                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3931                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3932                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3933
3934                 /* Round guessed framerate to a "standard" framerate if it's
3935                  * within 1% of the original estimate. */
3936                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3937                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3938                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3939                                               av_q2d(std_fps) - 1);
3940
3941                     if (error < best_error) {
3942                         best_error = error;
3943                         best_fps   = std_fps.num;
3944                     }
3945
3946                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3947                         error       = fabs(av_q2d(codec_frame_rate) /
3948                                            av_q2d(std_fps) - 1);
3949                         if (error < best_error) {
3950                             best_error = error;
3951                             best_fps   = std_fps.num;
3952                         }
3953                     }
3954                 }
3955                 if (best_fps)
3956                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3957                               best_fps, 12 * 1001, INT_MAX);
3958             }
3959
3960             if (!st->r_frame_rate.num) {
3961                 if (    avctx->time_base.den * (int64_t) st->time_base.num
3962                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3963                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3964                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3965                 } else {
3966                     st->r_frame_rate.num = st->time_base.den;
3967                     st->r_frame_rate.den = st->time_base.num;
3968                 }
3969             }
3970             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3971                 AVRational hw_ratio = { avctx->height, avctx->width };
3972                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3973                                                    hw_ratio);
3974             }
3975         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3976             if (!avctx->bits_per_coded_sample)
3977                 avctx->bits_per_coded_sample =
3978                     av_get_bits_per_sample(avctx->codec_id);
3979             // set stream disposition based on audio service type
3980             switch (avctx->audio_service_type) {
3981             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3982                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3983                 break;
3984             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3985                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3986                 break;
3987             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3988                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3989                 break;
3990             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3991                 st->disposition = AV_DISPOSITION_COMMENT;
3992                 break;
3993             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3994                 st->disposition = AV_DISPOSITION_KARAOKE;
3995                 break;
3996             }
3997         }
3998     }
3999
4000     if (probesize)
4001         estimate_timings(ic, old_offset);
4002
4003     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4004
4005     if (ret >= 0 && ic->nb_streams)
4006         /* We could not have all the codec parameters before EOF. */
4007         ret = -1;
4008     for (i = 0; i < ic->nb_streams; i++) {
4009         const char *errmsg;
4010         st = ic->streams[i];
4011
4012         /* if no packet was ever seen, update context now for has_codec_parameters */
4013         if (!st->internal->avctx_inited) {
4014             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4015                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4016                 st->codecpar->format = st->internal->avctx->sample_fmt;
4017             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4018             if (ret < 0)
4019                 goto find_stream_info_err;
4020         }
4021         if (!has_codec_parameters(st, &errmsg)) {
4022             char buf[256];
4023             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4024             av_log(ic, AV_LOG_WARNING,
4025                    "Could not find codec parameters for stream %d (%s): %s\n"
4026                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4027                    i, buf, errmsg);
4028         } else {
4029             ret = 0;
4030         }
4031     }
4032
4033     compute_chapters_end(ic);
4034
4035     /* update the stream parameters from the internal codec contexts */
4036     for (i = 0; i < ic->nb_streams; i++) {
4037         st = ic->streams[i];
4038
4039         if (st->internal->avctx_inited) {
4040             int orig_w = st->codecpar->width;
4041             int orig_h = st->codecpar->height;
4042             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4043             if (ret < 0)
4044                 goto find_stream_info_err;
4045 #if FF_API_LOWRES
4046             // The decoder might reduce the video size by the lowres factor.
4047             if (st->internal->avctx->lowres && orig_w) {
4048                 st->codecpar->width = orig_w;
4049                 st->codecpar->height = orig_h;
4050             }
4051 #endif
4052         }
4053
4054 #if FF_API_LAVF_AVCTX
4055 FF_DISABLE_DEPRECATION_WARNINGS
4056         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4057         if (ret < 0)
4058             goto find_stream_info_err;
4059
4060 #if FF_API_LOWRES
4061         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4062         // by the lowres factor.
4063         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4064             st->codec->lowres = st->internal->avctx->lowres;
4065             st->codec->width = st->internal->avctx->width;
4066             st->codec->height = st->internal->avctx->height;
4067         }
4068 #endif
4069
4070         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4071             st->codec->time_base = st->internal->avctx->time_base;
4072             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4073         }
4074         st->codec->framerate = st->avg_frame_rate;
4075
4076         if (st->internal->avctx->subtitle_header) {
4077             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4078             if (!st->codec->subtitle_header)
4079                 goto find_stream_info_err;
4080             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4081             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4082                    st->codec->subtitle_header_size);
4083         }
4084
4085         // Fields unavailable in AVCodecParameters
4086         st->codec->coded_width = st->internal->avctx->coded_width;
4087         st->codec->coded_height = st->internal->avctx->coded_height;
4088         st->codec->properties = st->internal->avctx->properties;
4089 FF_ENABLE_DEPRECATION_WARNINGS
4090 #endif
4091
4092         st->internal->avctx_inited = 0;
4093     }
4094
4095 find_stream_info_err:
4096     for (i = 0; i < ic->nb_streams; i++) {
4097         st = ic->streams[i];
4098         if (st->info)
4099             av_freep(&st->info->duration_error);
4100         avcodec_close(ic->streams[i]->internal->avctx);
4101         av_freep(&ic->streams[i]->info);
4102         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4103         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4104     }
4105     if (ic->pb)
4106         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4107                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4108     return ret;
4109 }
4110
4111 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4112 {
4113     int i, j;
4114
4115     for (i = 0; i < ic->nb_programs; i++) {
4116         if (ic->programs[i] == last) {
4117             last = NULL;
4118         } else {
4119             if (!last)
4120                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4121                     if (ic->programs[i]->stream_index[j] == s)
4122                         return ic->programs[i];
4123         }
4124     }
4125     return NULL;
4126 }
4127
4128 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4129                         int wanted_stream_nb, int related_stream,
4130                         AVCodec **decoder_ret, int flags)
4131 {
4132     int i, nb_streams = ic->nb_streams;
4133     int ret = AVERROR_STREAM_NOT_FOUND;
4134     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4135     int count, multiframe, disposition;
4136     int64_t best_bitrate = -1;
4137     int64_t bitrate;
4138     unsigned *program = NULL;
4139     const AVCodec *decoder = NULL, *best_decoder = NULL;
4140
4141     if (related_stream >= 0 && wanted_stream_nb < 0) {
4142         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4143         if (p) {
4144             program    = p->stream_index;
4145             nb_streams = p->nb_stream_indexes;
4146         }
4147     }
4148     for (i = 0; i < nb_streams; i++) {
4149         int real_stream_index = program ? program[i] : i;
4150         AVStream *st          = ic->streams[real_stream_index];
4151         AVCodecParameters *par = st->codecpar;
4152         if (par->codec_type != type)
4153             continue;
4154         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4155             continue;
4156         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4157             continue;
4158         if (decoder_ret) {
4159             decoder = find_decoder(ic, st, par->codec_id);
4160             if (!decoder) {
4161                 if (ret < 0)
4162                     ret = AVERROR_DECODER_NOT_FOUND;
4163                 continue;
4164             }
4165         }
4166         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4167         count = st->codec_info_nb_frames;
4168         bitrate = par->bit_rate;
4169         multiframe = FFMIN(5, count);
4170         if ((best_disposition >  disposition) ||
4171             (best_disposition == disposition && best_multiframe >  multiframe) ||
4172             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4173             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4174             continue;
4175         best_disposition = disposition;
4176         best_count   = count;
4177         best_bitrate = bitrate;
4178         best_multiframe = multiframe;
4179         ret          = real_stream_index;
4180         best_decoder = decoder;
4181         if (program && i == nb_streams - 1 && ret < 0) {
4182             program    = NULL;
4183             nb_streams = ic->nb_streams;
4184             /* no related stream found, try again with everything */
4185             i = 0;
4186         }
4187     }
4188     if (decoder_ret)
4189         *decoder_ret = (AVCodec*)best_decoder;
4190     return ret;
4191 }
4192
4193 /*******************************************************/
4194
4195 int av_read_play(AVFormatContext *s)
4196 {
4197     if (s->iformat->read_play)
4198         return s->iformat->read_play(s);
4199     if (s->pb)
4200         return avio_pause(s->pb, 0);
4201     return AVERROR(ENOSYS);
4202 }
4203
4204 int av_read_pause(AVFormatContext *s)
4205 {
4206     if (s->iformat->read_pause)
4207         return s->iformat->read_pause(s);
4208     if (s->pb)
4209         return avio_pause(s->pb, 1);
4210     return AVERROR(ENOSYS);
4211 }
4212
4213 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4214 {
4215     int ret, i;
4216
4217     dst->id                  = src->id;
4218     dst->time_base           = src->time_base;
4219     dst->nb_frames           = src->nb_frames;
4220     dst->disposition         = src->disposition;
4221     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4222     dst->avg_frame_rate      = src->avg_frame_rate;
4223     dst->r_frame_rate        = src->r_frame_rate;
4224
4225     av_dict_free(&dst->metadata);
4226     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4227     if (ret < 0)
4228         return ret;
4229
4230     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4231     if (ret < 0)
4232         return ret;
4233
4234     /* Free existing side data*/
4235     for (i = 0; i < dst->nb_side_data; i++)
4236         av_free(dst->side_data[i].data);
4237     av_freep(&dst->side_data);
4238     dst->nb_side_data = 0;
4239
4240     /* Copy side data if present */
4241     if (src->nb_side_data) {
4242         dst->side_data = av_mallocz_array(src->nb_side_data,
4243                                           sizeof(AVPacketSideData));
4244         if (!dst->side_data)
4245             return AVERROR(ENOMEM);
4246         dst->nb_side_data = src->nb_side_data;
4247
4248         for (i = 0; i < src->nb_side_data; i++) {
4249             uint8_t *data = av_memdup(src->side_data[i].data,
4250                                       src->side_data[i].size);
4251             if (!data)
4252                 return AVERROR(ENOMEM);
4253             dst->side_data[i].type = src->side_data[i].type;
4254             dst->side_data[i].size = src->side_data[i].size;
4255             dst->side_data[i].data = data;
4256         }
4257     }
4258
4259     av_freep(&dst->recommended_encoder_configuration);
4260     if (src->recommended_encoder_configuration) {
4261         const char *conf_str = src->recommended_encoder_configuration;
4262         dst->recommended_encoder_configuration = av_strdup(conf_str);
4263         if (!dst->recommended_encoder_configuration)
4264             return AVERROR(ENOMEM);
4265     }
4266
4267     return 0;
4268 }
4269
4270 static void free_stream(AVStream **pst)
4271 {
4272     AVStream *st = *pst;
4273     int i;
4274
4275     if (!st)
4276         return;
4277
4278     for (i = 0; i < st->nb_side_data; i++)
4279         av_freep(&st->side_data[i].data);
4280     av_freep(&st->side_data);
4281
4282     if (st->parser)
4283         av_parser_close(st->parser);
4284
4285     if (st->attached_pic.data)
4286         av_packet_unref(&st->attached_pic);
4287
4288     if (st->internal) {
4289         avcodec_free_context(&st->internal->avctx);
4290         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4291             av_bsf_free(&st->internal->bsfcs[i]);
4292             av_freep(&st->internal->bsfcs);
4293         }
4294         av_freep(&st->internal->priv_pts);
4295         av_bsf_free(&st->internal->extract_extradata.bsf);
4296         av_packet_free(&st->internal->extract_extradata.pkt);
4297     }
4298     av_freep(&st->internal);
4299
4300     av_dict_free(&st->metadata);
4301     avcodec_parameters_free(&st->codecpar);
4302     av_freep(&st->probe_data.buf);
4303     av_freep(&st->index_entries);
4304 #if FF_API_LAVF_AVCTX
4305 FF_DISABLE_DEPRECATION_WARNINGS
4306     avcodec_free_context(&st->codec);
4307 FF_ENABLE_DEPRECATION_WARNINGS
4308 #endif
4309     av_freep(&st->priv_data);
4310     if (st->info)
4311         av_freep(&st->info->duration_error);
4312     av_freep(&st->info);
4313     av_freep(&st->recommended_encoder_configuration);
4314
4315     av_freep(pst);
4316 }
4317
4318 void ff_free_stream(AVFormatContext *s, AVStream *st)
4319 {
4320     av_assert0(s->nb_streams>0);
4321     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4322
4323     free_stream(&s->streams[ --s->nb_streams ]);
4324 }
4325
4326 void avformat_free_context(AVFormatContext *s)
4327 {
4328     int i;
4329
4330     if (!s)
4331         return;
4332
4333     av_opt_free(s);
4334     if (s->iformat && s->iformat->priv_class && s->priv_data)
4335         av_opt_free(s->priv_data);
4336     if (s->oformat && s->oformat->priv_class && s->priv_data)
4337         av_opt_free(s->priv_data);
4338
4339     for (i = s->nb_streams - 1; i >= 0; i--)
4340         ff_free_stream(s, s->streams[i]);
4341
4342
4343     for (i = s->nb_programs - 1; i >= 0; i--) {
4344         av_dict_free(&s->programs[i]->metadata);
4345         av_freep(&s->programs[i]->stream_index);
4346         av_freep(&s->programs[i]);
4347     }
4348     av_freep(&s->programs);
4349     av_freep(&s->priv_data);
4350     while (s->nb_chapters--) {
4351         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4352         av_freep(&s->chapters[s->nb_chapters]);
4353     }
4354     av_freep(&s->chapters);
4355     av_dict_free(&s->metadata);
4356     av_dict_free(&s->internal->id3v2_meta);
4357     av_freep(&s->streams);
4358     flush_packet_queue(s);
4359     av_freep(&s->internal);
4360     av_free(s);
4361 }
4362
4363 void avformat_close_input(AVFormatContext **ps)
4364 {
4365     AVFormatContext *s;
4366     AVIOContext *pb;
4367
4368     if (!ps || !*ps)
4369         return;
4370
4371     s  = *ps;
4372     pb = s->pb;
4373
4374     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4375         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4376         pb = NULL;
4377
4378     flush_packet_queue(s);
4379
4380     if (s->iformat)
4381         if (s->iformat->read_close)
4382             s->iformat->read_close(s);
4383
4384     avformat_free_context(s);
4385
4386     *ps = NULL;
4387
4388     avio_close(pb);
4389 }
4390
4391 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4392 {
4393     AVStream *st;
4394     int i;
4395     AVStream **streams;
4396
4397     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4398         if (s->max_streams < INT_MAX/sizeof(*streams))
4399             av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4400         return NULL;
4401     }
4402     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4403     if (!streams)
4404         return NULL;
4405     s->streams = streams;
4406
4407     st = av_mallocz(sizeof(AVStream));
4408     if (!st)
4409         return NULL;
4410     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4411         av_free(st);
4412         return NULL;
4413     }
4414     st->info->last_dts = AV_NOPTS_VALUE;
4415
4416 #if FF_API_LAVF_AVCTX
4417 FF_DISABLE_DEPRECATION_WARNINGS
4418     st->codec = avcodec_alloc_context3(c);
4419     if (!st->codec) {
4420         av_free(st->info);
4421         av_free(st);
4422         return NULL;
4423     }
4424 FF_ENABLE_DEPRECATION_WARNINGS
4425 #endif
4426
4427     st->internal = av_mallocz(sizeof(*st->internal));
4428     if (!st->internal)
4429         goto fail;
4430
4431     st->codecpar = avcodec_parameters_alloc();
4432     if (!st->codecpar)
4433         goto fail;
4434
4435     st->internal->avctx = avcodec_alloc_context3(NULL);
4436     if (!st->internal->avctx)
4437         goto fail;
4438
4439     if (s->iformat) {
4440 #if FF_API_LAVF_AVCTX
4441 FF_DISABLE_DEPRECATION_WARNINGS
4442         /* no default bitrate if decoding */
4443         st->codec->bit_rate = 0;
4444 FF_ENABLE_DEPRECATION_WARNINGS
4445 #endif
4446
4447         /* default pts setting is MPEG-like */
4448         avpriv_set_pts_info(st, 33, 1, 90000);
4449         /* we set the current DTS to 0 so that formats without any timestamps
4450          * but durations get some timestamps, formats with some unknown
4451          * timestamps have their first few packets buffered and the
4452          * timestamps corrected before they are returned to the user */
4453         st->cur_dts = RELATIVE_TS_BASE;
4454     } else {
4455         st->cur_dts = AV_NOPTS_VALUE;
4456     }
4457
4458     st->index      = s->nb_streams;
4459     st->start_time = AV_NOPTS_VALUE;
4460     st->duration   = AV_NOPTS_VALUE;
4461     st->first_dts     = AV_NOPTS_VALUE;
4462     st->probe_packets = MAX_PROBE_PACKETS;
4463     st->pts_wrap_reference = AV_NOPTS_VALUE;
4464     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4465
4466     st->last_IP_pts = AV_NOPTS_VALUE;
4467     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4468     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4469         st->pts_buffer[i] = AV_NOPTS_VALUE;
4470
4471     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4472
4473 #if FF_API_R_FRAME_RATE
4474     st->info->last_dts      = AV_NOPTS_VALUE;
4475 #endif
4476     st->info->fps_first_dts = AV_NOPTS_VALUE;
4477     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4478
4479     st->inject_global_side_data = s->internal->inject_global_side_data;
4480
4481     st->internal->need_context_update = 1;
4482
4483     s->streams[s->nb_streams++] = st;
4484     return st;
4485 fail:
4486     free_stream(&st);
4487     return NULL;
4488 }
4489
4490 AVProgram *av_new_program(AVFormatContext *ac, int id)
4491 {
4492     AVProgram *program = NULL;
4493     int i;
4494
4495     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4496
4497     for (i = 0; i < ac->nb_programs; i++)
4498         if (ac->programs[i]->id == id)
4499             program = ac->programs[i];
4500
4501     if (!program) {
4502         program = av_mallocz(sizeof(AVProgram));
4503         if (!program)
4504             return NULL;
4505         dynarray_add(&ac->programs, &ac->nb_programs, program);
4506         program->discard = AVDISCARD_NONE;
4507     }
4508     program->id = id;
4509     program->pts_wrap_reference = AV_NOPTS_VALUE;
4510     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4511
4512     program->start_time =
4513     program->end_time   = AV_NOPTS_VALUE;
4514
4515     return program;
4516 }
4517
4518 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4519                               int64_t start, int64_t end, const char *title)
4520 {
4521     AVChapter *chapter = NULL;
4522     int i;
4523
4524     if (end != AV_NOPTS_VALUE && start > end) {
4525         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4526         return NULL;
4527     }
4528
4529     for (i = 0; i < s->nb_chapters; i++)
4530         if (s->chapters[i]->id == id)
4531             chapter = s->chapters[i];
4532
4533     if (!chapter) {
4534         chapter = av_mallocz(sizeof(AVChapter));
4535         if (!chapter)
4536             return NULL;
4537         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4538     }
4539     av_dict_set(&chapter->metadata, "title", title, 0);
4540     chapter->id        = id;
4541     chapter->time_base = time_base;
4542     chapter->start     = start;
4543     chapter->end       = end;
4544
4545     return chapter;
4546 }
4547
4548 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4549 {
4550     int i, j;
4551     AVProgram *program = NULL;
4552     void *tmp;
4553
4554     if (idx >= ac->nb_streams) {
4555         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4556         return;
4557     }
4558
4559     for (i = 0; i < ac->nb_programs; i++) {
4560         if (ac->programs[i]->id != progid)
4561             continue;
4562         program = ac->programs[i];
4563         for (j = 0; j < program->nb_stream_indexes; j++)
4564             if (program->stream_index[j] == idx)
4565                 return;
4566
4567         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4568         if (!tmp)
4569             return;
4570         program->stream_index = tmp;
4571         program->stream_index[program->nb_stream_indexes++] = idx;
4572         return;
4573     }
4574 }
4575
4576 uint64_t ff_ntp_time(void)
4577 {
4578     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4579 }
4580
4581 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4582 {
4583     const char *p;
4584     char *q, buf1[20], c;
4585     int nd, len, percentd_found;
4586
4587     q = buf;
4588     p = path;
4589     percentd_found = 0;
4590     for (;;) {
4591         c = *p++;
4592         if (c == '\0')
4593             break;
4594         if (c == '%') {
4595             do {
4596                 nd = 0;
4597                 while (av_isdigit(*p))
4598                     nd = nd * 10 + *p++ - '0';
4599                 c = *p++;
4600             } while (av_isdigit(c));
4601
4602             switch (c) {
4603             case '%':
4604                 goto addchar;
4605             case 'd':
4606                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4607                     goto fail;
4608                 percentd_found = 1;
4609                 if (number < 0)
4610                     nd += 1;
4611                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4612                 len = strlen(buf1);
4613                 if ((q - buf + len) > buf_size - 1)
4614                     goto fail;
4615                 memcpy(q, buf1, len);
4616                 q += len;
4617                 break;
4618             default:
4619                 goto fail;
4620             }
4621         } else {
4622 addchar:
4623             if ((q - buf) < buf_size - 1)
4624                 *q++ = c;
4625         }
4626     }
4627     if (!percentd_found)
4628         goto fail;
4629     *q = '\0';
4630     return 0;
4631 fail:
4632     *q = '\0';
4633     return -1;
4634 }
4635
4636 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4637 {
4638     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4639 }
4640
4641 void av_url_split(char *proto, int proto_size,
4642                   char *authorization, int authorization_size,
4643                   char *hostname, int hostname_size,
4644                   int *port_ptr, char *path, int path_size, const char *url)
4645 {
4646     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4647
4648     if (port_ptr)
4649         *port_ptr = -1;
4650     if (proto_size > 0)
4651         proto[0] = 0;
4652     if (authorization_size > 0)
4653         authorization[0] = 0;
4654     if (hostname_size > 0)
4655         hostname[0] = 0;
4656     if (path_size > 0)
4657         path[0] = 0;
4658
4659     /* parse protocol */
4660     if ((p = strchr(url, ':'))) {
4661         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4662         p++; /* skip ':' */
4663         if (*p == '/')
4664             p++;
4665         if (*p == '/')
4666             p++;
4667     } else {
4668         /* no protocol means plain filename */
4669         av_strlcpy(path, url, path_size);
4670         return;
4671     }
4672
4673     /* separate path from hostname */
4674     ls = strchr(p, '/');
4675     ls2 = strchr(p, '?');
4676     if (!ls)
4677         ls = ls2;
4678     else if (ls && ls2)
4679         ls = FFMIN(ls, ls2);
4680     if (ls)
4681         av_strlcpy(path, ls, path_size);
4682     else
4683         ls = &p[strlen(p)];  // XXX
4684
4685     /* the rest is hostname, use that to parse auth/port */
4686     if (ls != p) {
4687         /* authorization (user[:pass]@hostname) */
4688         at2 = p;
4689         while ((at = strchr(p, '@')) && at < ls) {
4690             av_strlcpy(authorization, at2,
4691                        FFMIN(authorization_size, at + 1 - at2));
4692             p = at + 1; /* skip '@' */
4693         }
4694
4695         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4696             /* [host]:port */
4697             av_strlcpy(hostname, p + 1,
4698                        FFMIN(hostname_size, brk - p));
4699             if (brk[1] == ':' && port_ptr)
4700                 *port_ptr = atoi(brk + 2);
4701         } else if ((col = strchr(p, ':')) && col < ls) {
4702             av_strlcpy(hostname, p,
4703                        FFMIN(col + 1 - p, hostname_size));
4704             if (port_ptr)
4705                 *port_ptr = atoi(col + 1);
4706         } else
4707             av_strlcpy(hostname, p,
4708                        FFMIN(ls + 1 - p, hostname_size));
4709     }
4710 }
4711
4712 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4713 {
4714     int i;
4715     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4716                                            '4', '5', '6', '7',
4717                                            '8', '9', 'A', 'B',
4718                                            'C', 'D', 'E', 'F' };
4719     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4720                                            '4', '5', '6', '7',
4721                                            '8', '9', 'a', 'b',
4722                                            'c', 'd', 'e', 'f' };
4723     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4724
4725     for (i = 0; i < s; i++) {
4726         buff[i * 2]     = hex_table[src[i] >> 4];
4727         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4728     }
4729
4730     return buff;
4731 }
4732
4733 int ff_hex_to_data(uint8_t *data, const char *p)
4734 {
4735     int c, len, v;
4736
4737     len = 0;
4738     v   = 1;
4739     for (;;) {
4740         p += strspn(p, SPACE_CHARS);
4741         if (*p == '\0')
4742             break;
4743         c = av_toupper((unsigned char) *p++);
4744         if (c >= '0' && c <= '9')
4745             c = c - '0';
4746         else if (c >= 'A' && c <= 'F')
4747             c = c - 'A' + 10;
4748         else
4749             break;
4750         v = (v << 4) | c;
4751         if (v & 0x100) {
4752             if (data)
4753                 data[len] = v;
4754             len++;
4755             v = 1;
4756         }
4757     }
4758     return len;
4759 }
4760
4761 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4762                          unsigned int pts_num, unsigned int pts_den)
4763 {
4764     AVRational new_tb;
4765     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4766         if (new_tb.num != pts_num)
4767             av_log(NULL, AV_LOG_DEBUG,
4768                    "st:%d removing common factor %d from timebase\n",
4769                    s->index, pts_num / new_tb.num);
4770     } else
4771         av_log(NULL, AV_LOG_WARNING,
4772                "st:%d has too large timebase, reducing\n", s->index);
4773
4774     if (new_tb.num <= 0 || new_tb.den <= 0) {
4775         av_log(NULL, AV_LOG_ERROR,
4776                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4777                new_tb.num, new_tb.den,
4778                s->index);
4779         return;
4780     }
4781     s->time_base     = new_tb;
4782 #if FF_API_LAVF_AVCTX
4783 FF_DISABLE_DEPRECATION_WARNINGS
4784     s->codec->pkt_timebase = new_tb;
4785 FF_ENABLE_DEPRECATION_WARNINGS
4786 #endif
4787     s->internal->avctx->pkt_timebase = new_tb;
4788     s->pts_wrap_bits = pts_wrap_bits;
4789 }
4790
4791 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4792                         void *context)
4793 {
4794     const char *ptr = str;
4795
4796     /* Parse key=value pairs. */
4797     for (;;) {
4798         const char *key;
4799         char *dest = NULL, *dest_end;
4800         int key_len, dest_len = 0;
4801
4802         /* Skip whitespace and potential commas. */
4803         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4804             ptr++;
4805         if (!*ptr)
4806             break;
4807
4808         key = ptr;
4809
4810         if (!(ptr = strchr(key, '=')))
4811             break;
4812         ptr++;
4813         key_len = ptr - key;
4814
4815         callback_get_buf(context, key, key_len, &dest, &dest_len);
4816         dest_end = dest + dest_len - 1;
4817
4818         if (*ptr == '\"') {
4819             ptr++;
4820             while (*ptr && *ptr != '\"') {
4821                 if (*ptr == '\\') {
4822                     if (!ptr[1])
4823                         break;
4824                     if (dest && dest < dest_end)
4825                         *dest++ = ptr[1];
4826                     ptr += 2;
4827                 } else {
4828                     if (dest && dest < dest_end)
4829                         *dest++ = *ptr;
4830                     ptr++;
4831                 }
4832             }
4833             if (*ptr == '\"')
4834                 ptr++;
4835         } else {
4836             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4837                 if (dest && dest < dest_end)
4838                     *dest++ = *ptr;
4839         }
4840         if (dest)
4841             *dest = 0;
4842     }
4843 }
4844
4845 int ff_find_stream_index(AVFormatContext *s, int id)
4846 {
4847     int i;
4848     for (i = 0; i < s->nb_streams; i++)
4849         if (s->streams[i]->id == id)
4850             return i;
4851     return -1;
4852 }
4853
4854 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4855                          int std_compliance)
4856 {
4857     if (ofmt) {
4858         unsigned int codec_tag;
4859         if (ofmt->query_codec)
4860             return ofmt->query_codec(codec_id, std_compliance);
4861         else if (ofmt->codec_tag)
4862             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4863         else if (codec_id == ofmt->video_codec ||
4864                  codec_id == ofmt->audio_codec ||
4865                  codec_id == ofmt->subtitle_codec ||
4866                  codec_id == ofmt->data_codec)
4867             return 1;
4868     }
4869     return AVERROR_PATCHWELCOME;
4870 }
4871
4872 int avformat_network_init(void)
4873 {
4874 #if CONFIG_NETWORK
4875     int ret;
4876     ff_network_inited_globally = 1;
4877     if ((ret = ff_network_init()) < 0)
4878         return ret;
4879     if ((ret = ff_tls_init()) < 0)
4880         return ret;
4881 #endif
4882     return 0;
4883 }
4884
4885 int avformat_network_deinit(void)
4886 {
4887 #if CONFIG_NETWORK
4888     ff_network_close();
4889     ff_tls_deinit();
4890     ff_network_inited_globally = 0;
4891 #endif
4892     return 0;
4893 }
4894
4895 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4896                         uint64_t channel_layout, int32_t sample_rate,
4897                         int32_t width, int32_t height)
4898 {
4899     uint32_t flags = 0;
4900     int size = 4;
4901     uint8_t *data;
4902     if (!pkt)
4903         return AVERROR(EINVAL);
4904     if (channels) {
4905         size  += 4;
4906         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4907     }
4908     if (channel_layout) {
4909         size  += 8;
4910         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4911     }
4912     if (sample_rate) {
4913         size  += 4;
4914         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4915     }
4916     if (width || height) {
4917         size  += 8;
4918         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4919     }
4920     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4921     if (!data)
4922         return AVERROR(ENOMEM);
4923     bytestream_put_le32(&data, flags);
4924     if (channels)
4925         bytestream_put_le32(&data, channels);
4926     if (channel_layout)
4927         bytestream_put_le64(&data, channel_layout);
4928     if (sample_rate)
4929         bytestream_put_le32(&data, sample_rate);
4930     if (width || height) {
4931         bytestream_put_le32(&data, width);
4932         bytestream_put_le32(&data, height);
4933     }
4934     return 0;
4935 }
4936
4937 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4938 {
4939     AVRational undef = {0, 1};
4940     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4941     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4942     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4943
4944     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4945                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4946     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4947         stream_sample_aspect_ratio = undef;
4948
4949     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4950                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4951     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4952         frame_sample_aspect_ratio = undef;
4953
4954     if (stream_sample_aspect_ratio.num)
4955         return stream_sample_aspect_ratio;
4956     else
4957         return frame_sample_aspect_ratio;
4958 }
4959
4960 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4961 {
4962     AVRational fr = st->r_frame_rate;
4963     AVRational codec_fr = st->internal->avctx->framerate;
4964     AVRational   avg_fr = st->avg_frame_rate;
4965
4966     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4967         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4968         fr = avg_fr;
4969     }
4970
4971
4972     if (st->internal->avctx->ticks_per_frame > 1) {
4973         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4974             (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
4975             fr = codec_fr;
4976     }
4977
4978     return fr;
4979 }
4980
4981 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4982                                     const char *spec)
4983 {
4984     if (*spec <= '9' && *spec >= '0') /* opt:index */
4985         return strtol(spec, NULL, 0) == st->index;
4986     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4987              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4988         enum AVMediaType type;
4989         int nopic = 0;
4990
4991         switch (*spec++) {
4992         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4993         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4994         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4995         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4996         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4997         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4998         default:  av_assert0(0);
4999         }
5000 #if FF_API_LAVF_AVCTX
5001 FF_DISABLE_DEPRECATION_WARNINGS
5002         if (type != st->codecpar->codec_type
5003            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5004             return 0;
5005 FF_ENABLE_DEPRECATION_WARNINGS
5006 #else
5007         if (type != st->codecpar->codec_type)
5008             return 0;
5009 #endif
5010         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5011             return 0;
5012         if (*spec++ == ':') { /* possibly followed by :index */
5013             int i, index = strtol(spec, NULL, 0);
5014             for (i = 0; i < s->nb_streams; i++) {
5015 #if FF_API_LAVF_AVCTX
5016 FF_DISABLE_DEPRECATION_WARNINGS
5017                 if ((s->streams[i]->codecpar->codec_type == type
5018                       || s->streams[i]->codec->codec_type == type
5019                     ) &&
5020                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5021                     index-- == 0)
5022                     return i == st->index;
5023 FF_ENABLE_DEPRECATION_WARNINGS
5024 #else
5025                 if ((s->streams[i]->codecpar->codec_type == type) &&
5026                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5027                     index-- == 0)
5028                     return i == st->index;
5029 #endif
5030             }
5031             return 0;
5032         }
5033         return 1;
5034     } else if (*spec == 'p' && *(spec + 1) == ':') {
5035         int prog_id, i, j;
5036         char *endptr;
5037         spec += 2;
5038         prog_id = strtol(spec, &endptr, 0);
5039         for (i = 0; i < s->nb_programs; i++) {
5040             if (s->programs[i]->id != prog_id)
5041                 continue;
5042
5043             if (*endptr++ == ':') {
5044                 int stream_idx = strtol(endptr, NULL, 0);
5045                 return stream_idx >= 0 &&
5046                     stream_idx < s->programs[i]->nb_stream_indexes &&
5047                     st->index == s->programs[i]->stream_index[stream_idx];
5048             }
5049
5050             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5051                 if (st->index == s->programs[i]->stream_index[j])
5052                     return 1;
5053         }
5054         return 0;
5055     } else if (*spec == '#' ||
5056                (*spec == 'i' && *(spec + 1) == ':')) {
5057         int stream_id;
5058         char *endptr;
5059         spec += 1 + (*spec == 'i');
5060         stream_id = strtol(spec, &endptr, 0);
5061         if (!*endptr)
5062             return stream_id == st->id;
5063     } else if (*spec == 'm' && *(spec + 1) == ':') {
5064         AVDictionaryEntry *tag;
5065         char *key, *val;
5066         int ret;
5067
5068         spec += 2;
5069         val = strchr(spec, ':');
5070
5071         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5072         if (!key)
5073             return AVERROR(ENOMEM);
5074
5075         tag = av_dict_get(st->metadata, key, NULL, 0);
5076         if (tag) {
5077             if (!val || !strcmp(tag->value, val + 1))
5078                 ret = 1;
5079             else
5080                 ret = 0;
5081         } else
5082             ret = 0;
5083
5084         av_freep(&key);
5085         return ret;
5086     } else if (*spec == 'u') {
5087         AVCodecParameters *par = st->codecpar;
5088 #if FF_API_LAVF_AVCTX
5089 FF_DISABLE_DEPRECATION_WARNINGS
5090         AVCodecContext *codec = st->codec;
5091 FF_ENABLE_DEPRECATION_WARNINGS
5092 #endif
5093         int val;
5094         switch (par->codec_type) {
5095         case AVMEDIA_TYPE_AUDIO:
5096             val = par->sample_rate && par->channels;
5097 #if FF_API_LAVF_AVCTX
5098             val = val || (codec->sample_rate && codec->channels);
5099 #endif
5100             if (par->format == AV_SAMPLE_FMT_NONE
5101 #if FF_API_LAVF_AVCTX
5102                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5103 #endif
5104                 )
5105                 return 0;
5106             break;
5107         case AVMEDIA_TYPE_VIDEO:
5108             val = par->width && par->height;
5109 #if FF_API_LAVF_AVCTX
5110             val = val || (codec->width && codec->height);
5111 #endif
5112             if (par->format == AV_PIX_FMT_NONE
5113 #if FF_API_LAVF_AVCTX
5114                 && codec->pix_fmt == AV_PIX_FMT_NONE
5115 #endif
5116                 )
5117                 return 0;
5118             break;
5119         case AVMEDIA_TYPE_UNKNOWN:
5120             val = 0;
5121             break;
5122         default:
5123             val = 1;
5124             break;
5125         }
5126 #if FF_API_LAVF_AVCTX
5127         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5128 #else
5129         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5130 #endif
5131     } else if (!*spec) /* empty specifier, matches everything */
5132         return 1;
5133
5134     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5135     return AVERROR(EINVAL);
5136 }
5137
5138 int ff_generate_avci_extradata(AVStream *st)
5139 {
5140     static const uint8_t avci100_1080p_extradata[] = {
5141         // SPS
5142         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5143         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5144         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5145         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5146         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5147         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5148         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5149         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5150         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5151         // PPS
5152         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5153         0xd0
5154     };
5155     static const uint8_t avci100_1080i_extradata[] = {
5156         // SPS
5157         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5158         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5159         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5160         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5161         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5162         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5163         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5164         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5165         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5166         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5167         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5168         // PPS
5169         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5170         0xd0
5171     };
5172     static const uint8_t avci50_1080p_extradata[] = {
5173         // SPS
5174         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5175         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5176         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5177         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5178         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5179         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5180         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5181         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5182         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5183         // PPS
5184         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5185         0x11
5186     };
5187     static const uint8_t avci50_1080i_extradata[] = {
5188         // SPS
5189         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5190         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5191         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5192         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5193         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5194         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5195         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5196         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5197         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5198         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5199         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5200         // PPS
5201         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5202         0x11
5203     };
5204     static const uint8_t avci100_720p_extradata[] = {
5205         // SPS
5206         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5207         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5208         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5209         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5210         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5211         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5212         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5213         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5214         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5215         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5216         // PPS
5217         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5218         0x11
5219     };
5220     static const uint8_t avci50_720p_extradata[] = {
5221         // SPS
5222         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5223         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5224         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5225         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5226         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5227         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5228         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5229         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5230         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5231         // PPS
5232         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5233         0x11
5234     };
5235
5236     const uint8_t *data = NULL;
5237     int size            = 0;
5238
5239     if (st->codecpar->width == 1920) {
5240         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5241             data = avci100_1080p_extradata;
5242             size = sizeof(avci100_1080p_extradata);
5243         } else {
5244             data = avci100_1080i_extradata;
5245             size = sizeof(avci100_1080i_extradata);
5246         }
5247     } else if (st->codecpar->width == 1440) {
5248         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5249             data = avci50_1080p_extradata;
5250             size = sizeof(avci50_1080p_extradata);
5251         } else {
5252             data = avci50_1080i_extradata;
5253             size = sizeof(avci50_1080i_extradata);
5254         }
5255     } else if (st->codecpar->width == 1280) {
5256         data = avci100_720p_extradata;
5257         size = sizeof(avci100_720p_extradata);
5258     } else if (st->codecpar->width == 960) {
5259         data = avci50_720p_extradata;
5260         size = sizeof(avci50_720p_extradata);
5261     }
5262
5263     if (!size)
5264         return 0;
5265
5266     av_freep(&st->codecpar->extradata);
5267     if (ff_alloc_extradata(st->codecpar, size))
5268         return AVERROR(ENOMEM);
5269     memcpy(st->codecpar->extradata, data, size);
5270
5271     return 0;
5272 }
5273
5274 uint8_t *av_stream_get_side_data(const AVStream *st,
5275                                  enum AVPacketSideDataType type, int *size)
5276 {
5277     int i;
5278
5279     for (i = 0; i < st->nb_side_data; i++) {
5280         if (st->side_data[i].type == type) {
5281             if (size)
5282                 *size = st->side_data[i].size;
5283             return st->side_data[i].data;
5284         }
5285     }
5286     return NULL;
5287 }
5288
5289 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5290                             uint8_t *data, size_t size)
5291 {
5292     AVPacketSideData *sd, *tmp;
5293     int i;
5294
5295     for (i = 0; i < st->nb_side_data; i++) {
5296         sd = &st->side_data[i];
5297
5298         if (sd->type == type) {
5299             av_freep(&sd->data);
5300             sd->data = data;
5301             sd->size = size;
5302             return 0;
5303         }
5304     }
5305
5306     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5307         return AVERROR(ERANGE);
5308
5309     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5310     if (!tmp) {
5311         return AVERROR(ENOMEM);
5312     }
5313
5314     st->side_data = tmp;
5315     st->nb_side_data++;
5316
5317     sd = &st->side_data[st->nb_side_data - 1];
5318     sd->type = type;
5319     sd->data = data;
5320     sd->size = size;
5321
5322     return 0;
5323 }
5324
5325 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5326                                  int size)
5327 {
5328     int ret;
5329     uint8_t *data = av_malloc(size);
5330
5331     if (!data)
5332         return NULL;
5333
5334     ret = av_stream_add_side_data(st, type, data, size);
5335     if (ret < 0) {
5336         av_freep(&data);
5337         return NULL;
5338     }
5339
5340     return data;
5341 }
5342
5343 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5344 {
5345     int ret;
5346     const AVBitStreamFilter *bsf;
5347     AVBSFContext *bsfc;
5348     AVCodecParameters *in_par;
5349
5350     if (!(bsf = av_bsf_get_by_name(name))) {
5351         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5352         return AVERROR_BSF_NOT_FOUND;
5353     }
5354
5355     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5356         return ret;
5357
5358     if (st->internal->nb_bsfcs) {
5359         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5360         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5361     } else {
5362         in_par = st->codecpar;
5363         bsfc->time_base_in = st->time_base;
5364     }
5365
5366     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5367         av_bsf_free(&bsfc);
5368         return ret;
5369     }
5370
5371     if (args && bsfc->filter->priv_class) {
5372         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5373         const char * shorthand[2] = {NULL};
5374
5375         if (opt)
5376             shorthand[0] = opt->name;
5377
5378         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5379             av_bsf_free(&bsfc);
5380             return ret;
5381         }
5382     }
5383
5384     if ((ret = av_bsf_init(bsfc)) < 0) {
5385         av_bsf_free(&bsfc);
5386         return ret;
5387     }
5388
5389     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5390         av_bsf_free(&bsfc);
5391         return ret;
5392     }
5393
5394     av_log(NULL, AV_LOG_VERBOSE,
5395            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5396            name, args ? args : "");
5397     return 1;
5398 }
5399
5400 #if FF_API_OLD_BSF
5401 FF_DISABLE_DEPRECATION_WARNINGS
5402 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5403                                AVBitStreamFilterContext *bsfc)
5404 {
5405     int ret = 0;
5406     while (bsfc) {
5407         AVPacket new_pkt = *pkt;
5408         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5409                                            &new_pkt.data, &new_pkt.size,
5410                                            pkt->data, pkt->size,
5411                                            pkt->flags & AV_PKT_FLAG_KEY);
5412         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5413             av_packet_unref(pkt);
5414             memset(pkt, 0, sizeof(*pkt));
5415             return 0;
5416         }
5417         if(a == 0 && new_pkt.data != pkt->data) {
5418             uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5419             if (t) {
5420                 memcpy(t, new_pkt.data, new_pkt.size);
5421                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5422                 new_pkt.data = t;
5423                 new_pkt.buf = NULL;
5424                 a = 1;
5425             } else {
5426                 a = AVERROR(ENOMEM);
5427             }
5428         }
5429         if (a > 0) {
5430             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5431                                            av_buffer_default_free, NULL, 0);
5432             if (new_pkt.buf) {
5433                 pkt->side_data = NULL;
5434                 pkt->side_data_elems = 0;
5435                 av_packet_unref(pkt);
5436             } else {
5437                 av_freep(&new_pkt.data);
5438                 a = AVERROR(ENOMEM);
5439             }
5440         }
5441         if (a < 0) {
5442             av_log(codec, AV_LOG_ERROR,
5443                    "Failed to open bitstream filter %s for stream %d with codec %s",
5444                    bsfc->filter->name, pkt->stream_index,
5445                    codec->codec ? codec->codec->name : "copy");
5446             ret = a;
5447             break;
5448         }
5449         *pkt = new_pkt;
5450
5451         bsfc = bsfc->next;
5452     }
5453     return ret;
5454 }
5455 FF_ENABLE_DEPRECATION_WARNINGS
5456 #endif
5457
5458 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5459 {
5460     if (!s->oformat)
5461         return AVERROR(EINVAL);
5462
5463     if (!(s->oformat->flags & AVFMT_NOFILE))
5464         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5465     return 0;
5466 }
5467
5468 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5469 {
5470     if (*pb)
5471         s->io_close(s, *pb);
5472     *pb = NULL;
5473 }
5474
5475 int ff_is_http_proto(char *filename) {
5476     const char *proto = avio_find_protocol_name(filename);
5477     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5478 }
5479
5480 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5481 {
5482     AVDictionaryEntry *entry;
5483     int64_t parsed_timestamp;
5484     int ret;
5485     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5486         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5487             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5488             return 1;
5489         } else {
5490             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5491             return ret;
5492         }
5493     }
5494     return 0;
5495 }
5496
5497 int ff_standardize_creation_time(AVFormatContext *s)
5498 {
5499     int64_t timestamp;
5500     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5501     if (ret == 1)
5502         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5503     return ret;
5504 }
5505
5506 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5507 {
5508     uint8_t *side_data;
5509     int size;
5510
5511     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5512     if (side_data) {
5513         if (size != AVPALETTE_SIZE) {
5514             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5515             return AVERROR_INVALIDDATA;
5516         }
5517         memcpy(palette, side_data, AVPALETTE_SIZE);
5518         return 1;
5519     }
5520
5521     if (ret == CONTAINS_PAL) {
5522         int i;
5523         for (i = 0; i < AVPALETTE_COUNT; i++)
5524             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5525         return 1;
5526     }
5527
5528     return 0;
5529 }
5530
5531 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5532 {
5533     int ret;
5534     char *str;
5535
5536     ret = av_bprint_finalize(buf, &str);
5537     if (ret < 0)
5538         return ret;
5539     if (!av_bprint_is_complete(buf)) {
5540         av_free(str);
5541         return AVERROR(ENOMEM);
5542     }
5543
5544     par->extradata = str;
5545     /* Note: the string is NUL terminated (so extradata can be read as a
5546      * string), but the ending character is not accounted in the size (in
5547      * binary formats you are likely not supposed to mux that character). When
5548      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5549      * zeros. */
5550     par->extradata_size = buf->len;
5551     return 0;
5552 }
5553
5554 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5555                                                   AVStream *ost, const AVStream *ist,
5556                                                   enum AVTimebaseSource copy_tb)
5557 {
5558     //TODO: use [io]st->internal->avctx
5559     const AVCodecContext *dec_ctx = ist->codec;
5560     AVCodecContext       *enc_ctx = ost->codec;
5561
5562     enc_ctx->time_base = ist->time_base;
5563     /*
5564      * Avi is a special case here because it supports variable fps but
5565      * having the fps and timebase differe significantly adds quite some
5566      * overhead
5567      */
5568     if (!strcmp(ofmt->name, "avi")) {
5569 #if FF_API_R_FRAME_RATE
5570         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5571             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5572             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5573             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5574             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5575             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5576             enc_ctx->time_base.num = ist->r_frame_rate.den;
5577             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5578             enc_ctx->ticks_per_frame = 2;
5579         } else
5580 #endif
5581             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5582                    && av_q2d(ist->time_base) < 1.0/500
5583                    || copy_tb == AVFMT_TBCF_DECODER) {
5584             enc_ctx->time_base = dec_ctx->time_base;
5585             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5586             enc_ctx->time_base.den *= 2;
5587             enc_ctx->ticks_per_frame = 2;
5588         }
5589     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5590                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5591         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5592             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5593             && av_q2d(ist->time_base) < 1.0/500
5594             || copy_tb == AVFMT_TBCF_DECODER) {
5595             enc_ctx->time_base = dec_ctx->time_base;
5596             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5597         }
5598     }
5599
5600     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5601         && dec_ctx->time_base.num < dec_ctx->time_base.den
5602         && dec_ctx->time_base.num > 0
5603         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5604         enc_ctx->time_base = dec_ctx->time_base;
5605     }
5606
5607     if (ost->avg_frame_rate.num)
5608         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5609
5610     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5611               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5612
5613     return 0;
5614 }
5615
5616 AVRational av_stream_get_codec_timebase(const AVStream *st)
5617 {
5618     // See avformat_transfer_internal_stream_timing_info() TODO.
5619 #if FF_API_LAVF_AVCTX
5620 FF_DISABLE_DEPRECATION_WARNINGS
5621     return st->codec->time_base;
5622 FF_ENABLE_DEPRECATION_WARNINGS
5623 #else
5624     return st->internal->avctx->time_base;
5625 #endif
5626 }