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