git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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