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