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