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