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