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->internal->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->internal->request_probe>0) {
 679         AVProbeData *pd = &st->internal->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->internal->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->internal->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->internal->request_probe > 0)
 832                     if ((err = probe_codec(s, st, NULL)) < 0)
 833                         return err;
 834                 av_assert0(st->internal->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->internal->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->internal->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->internal->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->internal->pts_buffer[0] = pkt->pts;
1361         for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1362             FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1363
1364         if(has_decode_delay_been_guessed(st))
1365             pkt->dts = select_from_pts_buffer(st, st->internal->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->internal->skip_to_keyframe = 0;
1630         if (st->internal->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->internal->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->internal->first_discard_sample &&
1648                 sample < st->internal->last_discard_sample)
1649                 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1650         }
1651         if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1652             st->internal->skip_samples = st->internal->start_skip_samples;
1653         if (st->internal->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->internal->skip_samples);
1657                 AV_WL32(p + 4, discard_padding);
1658                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1659             }
1660             st->internal->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->internal->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->internal->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->internal->nb_index_entries >= max_entries) {
1918         int i;
1919         for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1920             st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1921         st->internal->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->internal->index_entries, &st->internal->nb_index_entries,
1989                               &st->internal->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->internal->nb_index_entries; i1++) {
2066                 AVIndexEntry *e1 = &st1->internal->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->internal->nb_index_entries; i2++) {
2071                     AVIndexEntry *e2 = &st2->internal->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->internal->index_entries, st->internal->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->internal->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->internal->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->internal->nb_index_entries);
2158         if (index >= 0) {
2159             e = &st->internal->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->internal->nb_index_entries &&
2361         timestamp < st->internal->index_entries[0].timestamp)
2362         return -1;
2363
2364     if (index < 0 || index == st->internal->nb_index_entries - 1) {
2365         AVPacket pkt;
2366         int nonkey = 0;
2367
2368         if (st->internal->nb_index_entries) {
2369             av_assert0(st->internal->index_entries);
2370             ie = &st->internal->index_entries[st->internal->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->internal->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->internal->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->internal->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->internal->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->internal->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_freep(&st->internal->index_entries);
4346         av_freep(&st->internal->probe_data.buf);
4347
4348         av_bsf_free(&st->internal->extract_extradata.bsf);
4349         av_packet_free(&st->internal->extract_extradata.pkt);
4350
4351         if (st->internal->info)
4352             av_freep(&st->internal->info->duration_error);
4353         av_freep(&st->internal->info);
4354     }
4355     av_freep(&st->internal);
4356
4357     av_dict_free(&st->metadata);
4358     avcodec_parameters_free(&st->codecpar);
4359 #if FF_API_LAVF_AVCTX
4360 FF_DISABLE_DEPRECATION_WARNINGS
4361     avcodec_free_context(&st->codec);
4362 FF_ENABLE_DEPRECATION_WARNINGS
4363 #endif
4364     av_freep(&st->priv_data);
4365 #if FF_API_LAVF_FFSERVER
4366 FF_DISABLE_DEPRECATION_WARNINGS
4367     av_freep(&st->recommended_encoder_configuration);
4368 FF_ENABLE_DEPRECATION_WARNINGS
4369 #endif
4370
4371     av_freep(pst);
4372 }
4373
4374 void ff_free_stream(AVFormatContext *s, AVStream *st)
4375 {
4376     av_assert0(s->nb_streams>0);
4377     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4378
4379     free_stream(&s->streams[ --s->nb_streams ]);
4380 }
4381
4382 void avformat_free_context(AVFormatContext *s)
4383 {
4384     int i;
4385
4386     if (!s)
4387         return;
4388
4389     if (s->oformat && s->oformat->deinit && s->internal->initialized)
4390         s->oformat->deinit(s);
4391
4392     av_opt_free(s);
4393     if (s->iformat && s->iformat->priv_class && s->priv_data)
4394         av_opt_free(s->priv_data);
4395     if (s->oformat && s->oformat->priv_class && s->priv_data)
4396         av_opt_free(s->priv_data);
4397
4398     for (i = 0; i < s->nb_streams; i++)
4399         free_stream(&s->streams[i]);
4400     s->nb_streams = 0;
4401
4402     for (i = 0; i < s->nb_programs; i++) {
4403         av_dict_free(&s->programs[i]->metadata);
4404         av_freep(&s->programs[i]->stream_index);
4405         av_freep(&s->programs[i]);
4406     }
4407     s->nb_programs = 0;
4408
4409     av_freep(&s->programs);
4410     av_freep(&s->priv_data);
4411     while (s->nb_chapters--) {
4412         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4413         av_freep(&s->chapters[s->nb_chapters]);
4414     }
4415     av_freep(&s->chapters);
4416     av_dict_free(&s->metadata);
4417     av_dict_free(&s->internal->id3v2_meta);
4418     av_freep(&s->streams);
4419     flush_packet_queue(s);
4420     av_freep(&s->internal);
4421     av_freep(&s->url);
4422     av_free(s);
4423 }
4424
4425 void avformat_close_input(AVFormatContext **ps)
4426 {
4427     AVFormatContext *s;
4428     AVIOContext *pb;
4429
4430     if (!ps || !*ps)
4431         return;
4432
4433     s  = *ps;
4434     pb = s->pb;
4435
4436     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4437         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4438         pb = NULL;
4439
4440     flush_packet_queue(s);
4441
4442     if (s->iformat)
4443         if (s->iformat->read_close)
4444             s->iformat->read_close(s);
4445
4446     avformat_free_context(s);
4447
4448     *ps = NULL;
4449
4450     avio_close(pb);
4451 }
4452
4453 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4454 {
4455     AVStream *st;
4456     int i;
4457     AVStream **streams;
4458
4459     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4460         if (s->max_streams < INT_MAX/sizeof(*streams))
4461             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);
4462         return NULL;
4463     }
4464     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4465     if (!streams)
4466         return NULL;
4467     s->streams = streams;
4468
4469     st = av_mallocz(sizeof(AVStream));
4470     if (!st)
4471         return NULL;
4472
4473 #if FF_API_LAVF_AVCTX
4474 FF_DISABLE_DEPRECATION_WARNINGS
4475     st->codec = avcodec_alloc_context3(c);
4476     if (!st->codec) {
4477         av_free(st);
4478         return NULL;
4479     }
4480 FF_ENABLE_DEPRECATION_WARNINGS
4481 #endif
4482
4483     st->internal = av_mallocz(sizeof(*st->internal));
4484     if (!st->internal)
4485         goto fail;
4486
4487     st->internal->info = av_mallocz(sizeof(*st->internal->info));
4488     if (!st->internal->info)
4489         goto fail;
4490     st->internal->info->last_dts = AV_NOPTS_VALUE;
4491
4492     st->codecpar = avcodec_parameters_alloc();
4493     if (!st->codecpar)
4494         goto fail;
4495
4496     st->internal->avctx = avcodec_alloc_context3(NULL);
4497     if (!st->internal->avctx)
4498         goto fail;
4499
4500     if (s->iformat) {
4501 #if FF_API_LAVF_AVCTX
4502 FF_DISABLE_DEPRECATION_WARNINGS
4503         /* no default bitrate if decoding */
4504         st->codec->bit_rate = 0;
4505 FF_ENABLE_DEPRECATION_WARNINGS
4506 #endif
4507
4508         /* default pts setting is MPEG-like */
4509         avpriv_set_pts_info(st, 33, 1, 90000);
4510         /* we set the current DTS to 0 so that formats without any timestamps
4511          * but durations get some timestamps, formats with some unknown
4512          * timestamps have their first few packets buffered and the
4513          * timestamps corrected before they are returned to the user */
4514         st->cur_dts = RELATIVE_TS_BASE;
4515     } else {
4516         st->cur_dts = AV_NOPTS_VALUE;
4517     }
4518
4519     st->index      = s->nb_streams;
4520     st->start_time = AV_NOPTS_VALUE;
4521     st->duration   = AV_NOPTS_VALUE;
4522     st->first_dts     = AV_NOPTS_VALUE;
4523     st->probe_packets = s->max_probe_packets;
4524     st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4525     st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4526
4527     st->last_IP_pts = AV_NOPTS_VALUE;
4528     st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4529     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4530         st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4531
4532     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4533
4534 #if FF_API_R_FRAME_RATE
4535     st->internal->info->last_dts      = AV_NOPTS_VALUE;
4536 #endif
4537     st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4538     st->internal->info->fps_last_dts  = AV_NOPTS_VALUE;
4539
4540     st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4541
4542     st->internal->need_context_update = 1;
4543
4544     s->streams[s->nb_streams++] = st;
4545     return st;
4546 fail:
4547     free_stream(&st);
4548     return NULL;
4549 }
4550
4551 AVProgram *av_new_program(AVFormatContext *ac, int id)
4552 {
4553     AVProgram *program = NULL;
4554     int i;
4555
4556     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4557
4558     for (i = 0; i < ac->nb_programs; i++)
4559         if (ac->programs[i]->id == id)
4560             program = ac->programs[i];
4561
4562     if (!program) {
4563         program = av_mallocz(sizeof(AVProgram));
4564         if (!program)
4565             return NULL;
4566         dynarray_add(&ac->programs, &ac->nb_programs, program);
4567         program->discard = AVDISCARD_NONE;
4568         program->pmt_version = -1;
4569     }
4570     program->id = id;
4571     program->pts_wrap_reference = AV_NOPTS_VALUE;
4572     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4573
4574     program->start_time =
4575     program->end_time   = AV_NOPTS_VALUE;
4576
4577     return program;
4578 }
4579
4580 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4581                               int64_t start, int64_t end, const char *title)
4582 {
4583     AVChapter *chapter = NULL;
4584     int i;
4585
4586     if (end != AV_NOPTS_VALUE && start > end) {
4587         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4588         return NULL;
4589     }
4590
4591     for (i = 0; i < s->nb_chapters; i++)
4592         if (s->chapters[i]->id == id)
4593             chapter = s->chapters[i];
4594
4595     if (!chapter) {
4596         chapter = av_mallocz(sizeof(AVChapter));
4597         if (!chapter)
4598             return NULL;
4599         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4600     }
4601     av_dict_set(&chapter->metadata, "title", title, 0);
4602     chapter->id        = id;
4603     chapter->time_base = time_base;
4604     chapter->start     = start;
4605     chapter->end       = end;
4606
4607     return chapter;
4608 }
4609
4610 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4611 {
4612     int i, j;
4613     AVProgram *program = NULL;
4614     void *tmp;
4615
4616     if (idx >= ac->nb_streams) {
4617         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4618         return;
4619     }
4620
4621     for (i = 0; i < ac->nb_programs; i++) {
4622         if (ac->programs[i]->id != progid)
4623             continue;
4624         program = ac->programs[i];
4625         for (j = 0; j < program->nb_stream_indexes; j++)
4626             if (program->stream_index[j] == idx)
4627                 return;
4628
4629         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4630         if (!tmp)
4631             return;
4632         program->stream_index = tmp;
4633         program->stream_index[program->nb_stream_indexes++] = idx;
4634         return;
4635     }
4636 }
4637
4638 uint64_t ff_ntp_time(void)
4639 {
4640     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4641 }
4642
4643 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4644 {
4645     uint64_t ntp_ts, frac_part, sec;
4646     uint32_t usec;
4647
4648     //current ntp time in seconds and micro seconds
4649     sec = ntp_time_us / 1000000;
4650     usec = ntp_time_us % 1000000;
4651
4652     //encoding in ntp timestamp format
4653     frac_part = usec * 0xFFFFFFFFULL;
4654     frac_part /= 1000000;
4655
4656     if (sec > 0xFFFFFFFFULL)
4657         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4658
4659     ntp_ts = sec << 32;
4660     ntp_ts |= frac_part;
4661
4662     return ntp_ts;
4663 }
4664
4665 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4666 {
4667     const char *p;
4668     char *q, buf1[20], c;
4669     int nd, len, percentd_found;
4670
4671     q = buf;
4672     p = path;
4673     percentd_found = 0;
4674     for (;;) {
4675         c = *p++;
4676         if (c == '\0')
4677             break;
4678         if (c == '%') {
4679             do {
4680                 nd = 0;
4681                 while (av_isdigit(*p))
4682                     nd = nd * 10 + *p++ - '0';
4683                 c = *p++;
4684             } while (av_isdigit(c));
4685
4686             switch (c) {
4687             case '%':
4688                 goto addchar;
4689             case 'd':
4690                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4691                     goto fail;
4692                 percentd_found = 1;
4693                 if (number < 0)
4694                     nd += 1;
4695                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4696                 len = strlen(buf1);
4697                 if ((q - buf + len) > buf_size - 1)
4698                     goto fail;
4699                 memcpy(q, buf1, len);
4700                 q += len;
4701                 break;
4702             default:
4703                 goto fail;
4704             }
4705         } else {
4706 addchar:
4707             if ((q - buf) < buf_size - 1)
4708                 *q++ = c;
4709         }
4710     }
4711     if (!percentd_found)
4712         goto fail;
4713     *q = '\0';
4714     return 0;
4715 fail:
4716     *q = '\0';
4717     return -1;
4718 }
4719
4720 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4721 {
4722     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4723 }
4724
4725 void av_url_split(char *proto, int proto_size,
4726                   char *authorization, int authorization_size,
4727                   char *hostname, int hostname_size,
4728                   int *port_ptr, char *path, int path_size, const char *url)
4729 {
4730     const char *p, *ls, *at, *at2, *col, *brk;
4731
4732     if (port_ptr)
4733         *port_ptr = -1;
4734     if (proto_size > 0)
4735         proto[0] = 0;
4736     if (authorization_size > 0)
4737         authorization[0] = 0;
4738     if (hostname_size > 0)
4739         hostname[0] = 0;
4740     if (path_size > 0)
4741         path[0] = 0;
4742
4743     /* parse protocol */
4744     if ((p = strchr(url, ':'))) {
4745         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4746         p++; /* skip ':' */
4747         if (*p == '/')
4748             p++;
4749         if (*p == '/')
4750             p++;
4751     } else {
4752         /* no protocol means plain filename */
4753         av_strlcpy(path, url, path_size);
4754         return;
4755     }
4756
4757     /* separate path from hostname */
4758     ls = p + strcspn(p, "/?#");
4759     av_strlcpy(path, ls, path_size);
4760
4761     /* the rest is hostname, use that to parse auth/port */
4762     if (ls != p) {
4763         /* authorization (user[:pass]@hostname) */
4764         at2 = p;
4765         while ((at = strchr(p, '@')) && at < ls) {
4766             av_strlcpy(authorization, at2,
4767                        FFMIN(authorization_size, at + 1 - at2));
4768             p = at + 1; /* skip '@' */
4769         }
4770
4771         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4772             /* [host]:port */
4773             av_strlcpy(hostname, p + 1,
4774                        FFMIN(hostname_size, brk - p));
4775             if (brk[1] == ':' && port_ptr)
4776                 *port_ptr = atoi(brk + 2);
4777         } else if ((col = strchr(p, ':')) && col < ls) {
4778             av_strlcpy(hostname, p,
4779                        FFMIN(col + 1 - p, hostname_size));
4780             if (port_ptr)
4781                 *port_ptr = atoi(col + 1);
4782         } else
4783             av_strlcpy(hostname, p,
4784                        FFMIN(ls + 1 - p, hostname_size));
4785     }
4786 }
4787
4788 int ff_mkdir_p(const char *path)
4789 {
4790     int ret = 0;
4791     char *temp = av_strdup(path);
4792     char *pos = temp;
4793     char tmp_ch = '\0';
4794
4795     if (!path || !temp) {
4796         return -1;
4797     }
4798
4799     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4800         pos++;
4801     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4802         pos += 2;
4803     }
4804
4805     for ( ; *pos != '\0'; ++pos) {
4806         if (*pos == '/' || *pos == '\\') {
4807             tmp_ch = *pos;
4808             *pos = '\0';
4809             ret = mkdir(temp, 0755);
4810             *pos = tmp_ch;
4811         }
4812     }
4813
4814     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4815         ret = mkdir(temp, 0755);
4816     }
4817
4818     av_free(temp);
4819     return ret;
4820 }
4821
4822 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4823 {
4824     int i;
4825     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4826                                            '4', '5', '6', '7',
4827                                            '8', '9', 'A', 'B',
4828                                            'C', 'D', 'E', 'F' };
4829     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4830                                            '4', '5', '6', '7',
4831                                            '8', '9', 'a', 'b',
4832                                            'c', 'd', 'e', 'f' };
4833     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4834
4835     for (i = 0; i < s; i++) {
4836         buff[i * 2]     = hex_table[src[i] >> 4];
4837         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4838     }
4839
4840     return buff;
4841 }
4842
4843 int ff_hex_to_data(uint8_t *data, const char *p)
4844 {
4845     int c, len, v;
4846
4847     len = 0;
4848     v   = 1;
4849     for (;;) {
4850         p += strspn(p, SPACE_CHARS);
4851         if (*p == '\0')
4852             break;
4853         c = av_toupper((unsigned char) *p++);
4854         if (c >= '0' && c <= '9')
4855             c = c - '0';
4856         else if (c >= 'A' && c <= 'F')
4857             c = c - 'A' + 10;
4858         else
4859             break;
4860         v = (v << 4) | c;
4861         if (v & 0x100) {
4862             if (data)
4863                 data[len] = v;
4864             len++;
4865             v = 1;
4866         }
4867     }
4868     return len;
4869 }
4870
4871 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4872                          unsigned int pts_num, unsigned int pts_den)
4873 {
4874     AVRational new_tb;
4875     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4876         if (new_tb.num != pts_num)
4877             av_log(NULL, AV_LOG_DEBUG,
4878                    "st:%d removing common factor %d from timebase\n",
4879                    s->index, pts_num / new_tb.num);
4880     } else
4881         av_log(NULL, AV_LOG_WARNING,
4882                "st:%d has too large timebase, reducing\n", s->index);
4883
4884     if (new_tb.num <= 0 || new_tb.den <= 0) {
4885         av_log(NULL, AV_LOG_ERROR,
4886                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4887                new_tb.num, new_tb.den,
4888                s->index);
4889         return;
4890     }
4891     s->time_base     = new_tb;
4892 #if FF_API_LAVF_AVCTX
4893 FF_DISABLE_DEPRECATION_WARNINGS
4894     s->codec->pkt_timebase = new_tb;
4895 FF_ENABLE_DEPRECATION_WARNINGS
4896 #endif
4897     s->internal->avctx->pkt_timebase = new_tb;
4898     s->pts_wrap_bits = pts_wrap_bits;
4899 }
4900
4901 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4902                         void *context)
4903 {
4904     const char *ptr = str;
4905
4906     /* Parse key=value pairs. */
4907     for (;;) {
4908         const char *key;
4909         char *dest = NULL, *dest_end;
4910         int key_len, dest_len = 0;
4911
4912         /* Skip whitespace and potential commas. */
4913         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4914             ptr++;
4915         if (!*ptr)
4916             break;
4917
4918         key = ptr;
4919
4920         if (!(ptr = strchr(key, '=')))
4921             break;
4922         ptr++;
4923         key_len = ptr - key;
4924
4925         callback_get_buf(context, key, key_len, &dest, &dest_len);
4926         dest_end = dest + dest_len - 1;
4927
4928         if (*ptr == '\"') {
4929             ptr++;
4930             while (*ptr && *ptr != '\"') {
4931                 if (*ptr == '\\') {
4932                     if (!ptr[1])
4933                         break;
4934                     if (dest && dest < dest_end)
4935                         *dest++ = ptr[1];
4936                     ptr += 2;
4937                 } else {
4938                     if (dest && dest < dest_end)
4939                         *dest++ = *ptr;
4940                     ptr++;
4941                 }
4942             }
4943             if (*ptr == '\"')
4944                 ptr++;
4945         } else {
4946             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4947                 if (dest && dest < dest_end)
4948                     *dest++ = *ptr;
4949         }
4950         if (dest)
4951             *dest = 0;
4952     }
4953 }
4954
4955 int ff_find_stream_index(AVFormatContext *s, int id)
4956 {
4957     int i;
4958     for (i = 0; i < s->nb_streams; i++)
4959         if (s->streams[i]->id == id)
4960             return i;
4961     return -1;
4962 }
4963
4964 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4965                          int std_compliance)
4966 {
4967     if (ofmt) {
4968         unsigned int codec_tag;
4969         if (ofmt->query_codec)
4970             return ofmt->query_codec(codec_id, std_compliance);
4971         else if (ofmt->codec_tag)
4972             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4973         else if (codec_id == ofmt->video_codec ||
4974                  codec_id == ofmt->audio_codec ||
4975                  codec_id == ofmt->subtitle_codec ||
4976                  codec_id == ofmt->data_codec)
4977             return 1;
4978     }
4979     return AVERROR_PATCHWELCOME;
4980 }
4981
4982 int avformat_network_init(void)
4983 {
4984 #if CONFIG_NETWORK
4985     int ret;
4986     if ((ret = ff_network_init()) < 0)
4987         return ret;
4988     if ((ret = ff_tls_init()) < 0)
4989         return ret;
4990 #endif
4991     return 0;
4992 }
4993
4994 int avformat_network_deinit(void)
4995 {
4996 #if CONFIG_NETWORK
4997     ff_network_close();
4998     ff_tls_deinit();
4999 #endif
5000     return 0;
5001 }
5002
5003 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5004                         uint64_t channel_layout, int32_t sample_rate,
5005                         int32_t width, int32_t height)
5006 {
5007     uint32_t flags = 0;
5008     int size = 4;
5009     uint8_t *data;
5010     if (!pkt)
5011         return AVERROR(EINVAL);
5012     if (channels) {
5013         size  += 4;
5014         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5015     }
5016     if (channel_layout) {
5017         size  += 8;
5018         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5019     }
5020     if (sample_rate) {
5021         size  += 4;
5022         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5023     }
5024     if (width || height) {
5025         size  += 8;
5026         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5027     }
5028     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5029     if (!data)
5030         return AVERROR(ENOMEM);
5031     bytestream_put_le32(&data, flags);
5032     if (channels)
5033         bytestream_put_le32(&data, channels);
5034     if (channel_layout)
5035         bytestream_put_le64(&data, channel_layout);
5036     if (sample_rate)
5037         bytestream_put_le32(&data, sample_rate);
5038     if (width || height) {
5039         bytestream_put_le32(&data, width);
5040         bytestream_put_le32(&data, height);
5041     }
5042     return 0;
5043 }
5044
5045 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5046 {
5047     AVRational undef = {0, 1};
5048     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5049     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5050     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5051
5052     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5053                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5054     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5055         stream_sample_aspect_ratio = undef;
5056
5057     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5058                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5059     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5060         frame_sample_aspect_ratio = undef;
5061
5062     if (stream_sample_aspect_ratio.num)
5063         return stream_sample_aspect_ratio;
5064     else
5065         return frame_sample_aspect_ratio;
5066 }
5067
5068 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5069 {
5070     AVRational fr = st->r_frame_rate;
5071     AVRational codec_fr = st->internal->avctx->framerate;
5072     AVRational   avg_fr = st->avg_frame_rate;
5073
5074     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5075         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5076         fr = avg_fr;
5077     }
5078
5079
5080     if (st->internal->avctx->ticks_per_frame > 1) {
5081         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5082             (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))
5083             fr = codec_fr;
5084     }
5085
5086     return fr;
5087 }
5088
5089 /**
5090  * Matches a stream specifier (but ignores requested index).
5091  *
5092  * @param indexptr set to point to the requested stream index if there is one
5093  *
5094  * @return <0 on error
5095  *         0  if st is NOT a matching stream
5096  *         >0 if st is a matching stream
5097  */
5098 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5099                                   const char *spec, const char **indexptr, AVProgram **p)
5100 {
5101     int match = 1;                      /* Stores if the specifier matches so far. */
5102     while (*spec) {
5103         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5104             if (indexptr)
5105                 *indexptr = spec;
5106             return match;
5107         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5108                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5109             enum AVMediaType type;
5110             int nopic = 0;
5111
5112             switch (*spec++) {
5113             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5114             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5115             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5116             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5117             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5118             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5119             default:  av_assert0(0);
5120             }
5121             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5122                 return AVERROR(EINVAL);
5123
5124 #if FF_API_LAVF_AVCTX
5125 FF_DISABLE_DEPRECATION_WARNINGS
5126             if (type != st->codecpar->codec_type
5127                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5128                 match = 0;
5129     FF_ENABLE_DEPRECATION_WARNINGS
5130 #else
5131             if (type != st->codecpar->codec_type)
5132                 match = 0;
5133 #endif
5134             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5135                 match = 0;
5136         } else if (*spec == 'p' && *(spec + 1) == ':') {
5137             int prog_id, i, j;
5138             int found = 0;
5139             char *endptr;
5140             spec += 2;
5141             prog_id = strtol(spec, &endptr, 0);
5142             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5143             if (spec == endptr || (*endptr && *endptr++ != ':'))
5144                 return AVERROR(EINVAL);
5145             spec = endptr;
5146             if (match) {
5147                 for (i = 0; i < s->nb_programs; i++) {
5148                     if (s->programs[i]->id != prog_id)
5149                         continue;
5150
5151                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5152                         if (st->index == s->programs[i]->stream_index[j]) {
5153                             found = 1;
5154                             if (p)
5155                                 *p = s->programs[i];
5156                             i = s->nb_programs;
5157                             break;
5158                         }
5159                     }
5160                 }
5161             }
5162             if (!found)
5163                 match = 0;
5164         } else if (*spec == '#' ||
5165                    (*spec == 'i' && *(spec + 1) == ':')) {
5166             int stream_id;
5167             char *endptr;
5168             spec += 1 + (*spec == 'i');
5169             stream_id = strtol(spec, &endptr, 0);
5170             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5171                 return AVERROR(EINVAL);
5172             return match && (stream_id == st->id);
5173         } else if (*spec == 'm' && *(spec + 1) == ':') {
5174             AVDictionaryEntry *tag;
5175             char *key, *val;
5176             int ret;
5177
5178             if (match) {
5179                spec += 2;
5180                val = strchr(spec, ':');
5181
5182                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5183                if (!key)
5184                    return AVERROR(ENOMEM);
5185
5186                tag = av_dict_get(st->metadata, key, NULL, 0);
5187                if (tag) {
5188                    if (!val || !strcmp(tag->value, val + 1))
5189                        ret = 1;
5190                    else
5191                        ret = 0;
5192                } else
5193                    ret = 0;
5194
5195                av_freep(&key);
5196             }
5197             return match && ret;
5198         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5199             AVCodecParameters *par = st->codecpar;
5200 #if FF_API_LAVF_AVCTX
5201 FF_DISABLE_DEPRECATION_WARNINGS
5202             AVCodecContext *codec = st->codec;
5203 FF_ENABLE_DEPRECATION_WARNINGS
5204 #endif
5205             int val;
5206             switch (par->codec_type) {
5207             case AVMEDIA_TYPE_AUDIO:
5208                 val = par->sample_rate && par->channels;
5209 #if FF_API_LAVF_AVCTX
5210                 val = val || (codec->sample_rate && codec->channels);
5211 #endif
5212                 if (par->format == AV_SAMPLE_FMT_NONE
5213 #if FF_API_LAVF_AVCTX
5214                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5215 #endif
5216                     )
5217                     return 0;
5218                 break;
5219             case AVMEDIA_TYPE_VIDEO:
5220                 val = par->width && par->height;
5221 #if FF_API_LAVF_AVCTX
5222                 val = val || (codec->width && codec->height);
5223 #endif
5224                 if (par->format == AV_PIX_FMT_NONE
5225 #if FF_API_LAVF_AVCTX
5226                     && codec->pix_fmt == AV_PIX_FMT_NONE
5227 #endif
5228                     )
5229                     return 0;
5230                 break;
5231             case AVMEDIA_TYPE_UNKNOWN:
5232                 val = 0;
5233                 break;
5234             default:
5235                 val = 1;
5236                 break;
5237             }
5238 #if FF_API_LAVF_AVCTX
5239             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5240 #else
5241             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5242 #endif
5243         } else {
5244             return AVERROR(EINVAL);
5245         }
5246     }
5247
5248     return match;
5249 }
5250
5251
5252 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5253                                     const char *spec)
5254 {
5255     int ret, index;
5256     char *endptr;
5257     const char *indexptr = NULL;
5258     AVProgram *p = NULL;
5259     int nb_streams;
5260
5261     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5262     if (ret < 0)
5263         goto error;
5264
5265     if (!indexptr)
5266         return ret;
5267
5268     index = strtol(indexptr, &endptr, 0);
5269     if (*endptr) {                  /* We can't have anything after the requested index. */
5270         ret = AVERROR(EINVAL);
5271         goto error;
5272     }
5273
5274     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5275     if (spec == indexptr)
5276         return (index == st->index);
5277
5278     /* If we requested a matching stream index, we have to ensure st is that. */
5279     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5280     for (int i = 0; i < nb_streams && index >= 0; i++) {
5281         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5282         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5283         if (ret < 0)
5284             goto error;
5285         if (ret > 0 && index-- == 0 && st == candidate)
5286             return 1;
5287     }
5288     return 0;
5289
5290 error:
5291     if (ret == AVERROR(EINVAL))
5292         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5293     return ret;
5294 }
5295
5296 int ff_generate_avci_extradata(AVStream *st)
5297 {
5298     static const uint8_t avci100_1080p_extradata[] = {
5299         // SPS
5300         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5301         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5302         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5303         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5304         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5305         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5306         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5307         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5308         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5309         // PPS
5310         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5311         0xd0
5312     };
5313     static const uint8_t avci100_1080i_extradata[] = {
5314         // SPS
5315         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5316         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5317         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5318         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5319         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5320         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5321         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5322         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5323         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5324         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5325         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5326         // PPS
5327         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5328         0xd0
5329     };
5330     static const uint8_t avci50_1080p_extradata[] = {
5331         // SPS
5332         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5333         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5334         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5335         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5336         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5337         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5338         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5339         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5340         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5341         // PPS
5342         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5343         0x11
5344     };
5345     static const uint8_t avci50_1080i_extradata[] = {
5346         // SPS
5347         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5348         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5349         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5350         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5351         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5352         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5353         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5354         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5355         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5356         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5357         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5358         // PPS
5359         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5360         0x11
5361     };
5362     static const uint8_t avci100_720p_extradata[] = {
5363         // SPS
5364         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5365         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5366         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5367         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5368         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5369         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5370         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5371         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5372         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5373         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5374         // PPS
5375         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5376         0x11
5377     };
5378     static const uint8_t avci50_720p_extradata[] = {
5379         // SPS
5380         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5381         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5382         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5383         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5384         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5385         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5386         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5387         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5388         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5389         // PPS
5390         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5391         0x11
5392     };
5393
5394     const uint8_t *data = NULL;
5395     int ret, size       = 0;
5396
5397     if (st->codecpar->width == 1920) {
5398         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5399             data = avci100_1080p_extradata;
5400             size = sizeof(avci100_1080p_extradata);
5401         } else {
5402             data = avci100_1080i_extradata;
5403             size = sizeof(avci100_1080i_extradata);
5404         }
5405     } else if (st->codecpar->width == 1440) {
5406         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5407             data = avci50_1080p_extradata;
5408             size = sizeof(avci50_1080p_extradata);
5409         } else {
5410             data = avci50_1080i_extradata;
5411             size = sizeof(avci50_1080i_extradata);
5412         }
5413     } else if (st->codecpar->width == 1280) {
5414         data = avci100_720p_extradata;
5415         size = sizeof(avci100_720p_extradata);
5416     } else if (st->codecpar->width == 960) {
5417         data = avci50_720p_extradata;
5418         size = sizeof(avci50_720p_extradata);
5419     }
5420
5421     if (!size)
5422         return 0;
5423
5424     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5425         return ret;
5426     memcpy(st->codecpar->extradata, data, size);
5427
5428     return 0;
5429 }
5430
5431 uint8_t *av_stream_get_side_data(const AVStream *st,
5432                                  enum AVPacketSideDataType type, int *size)
5433 {
5434     int i;
5435
5436     for (i = 0; i < st->nb_side_data; i++) {
5437         if (st->side_data[i].type == type) {
5438             if (size)
5439                 *size = st->side_data[i].size;
5440             return st->side_data[i].data;
5441         }
5442     }
5443     if (size)
5444         *size = 0;
5445     return NULL;
5446 }
5447
5448 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5449                             uint8_t *data, size_t size)
5450 {
5451     AVPacketSideData *sd, *tmp;
5452     int i;
5453
5454     for (i = 0; i < st->nb_side_data; i++) {
5455         sd = &st->side_data[i];
5456
5457         if (sd->type == type) {
5458             av_freep(&sd->data);
5459             sd->data = data;
5460             sd->size = size;
5461             return 0;
5462         }
5463     }
5464
5465     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5466         return AVERROR(ERANGE);
5467
5468     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5469     if (!tmp) {
5470         return AVERROR(ENOMEM);
5471     }
5472
5473     st->side_data = tmp;
5474     st->nb_side_data++;
5475
5476     sd = &st->side_data[st->nb_side_data - 1];
5477     sd->type = type;
5478     sd->data = data;
5479     sd->size = size;
5480
5481     return 0;
5482 }
5483
5484 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5485                                  int size)
5486 {
5487     int ret;
5488     uint8_t *data = av_malloc(size);
5489
5490     if (!data)
5491         return NULL;
5492
5493     ret = av_stream_add_side_data(st, type, data, size);
5494     if (ret < 0) {
5495         av_freep(&data);
5496         return NULL;
5497     }
5498
5499     return data;
5500 }
5501
5502 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5503 {
5504     int ret;
5505     const AVBitStreamFilter *bsf;
5506     AVBSFContext *bsfc;
5507
5508     av_assert0(!st->internal->bsfc);
5509
5510     if (!(bsf = av_bsf_get_by_name(name))) {
5511         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5512         return AVERROR_BSF_NOT_FOUND;
5513     }
5514
5515     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5516         return ret;
5517
5518     bsfc->time_base_in = st->time_base;
5519     if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5520         av_bsf_free(&bsfc);
5521         return ret;
5522     }
5523
5524     if (args && bsfc->filter->priv_class) {
5525         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5526         const char * shorthand[2] = {NULL};
5527
5528         if (opt)
5529             shorthand[0] = opt->name;
5530
5531         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5532             av_bsf_free(&bsfc);
5533             return ret;
5534         }
5535     }
5536
5537     if ((ret = av_bsf_init(bsfc)) < 0) {
5538         av_bsf_free(&bsfc);
5539         return ret;
5540     }
5541
5542     st->internal->bsfc = bsfc;
5543
5544     av_log(NULL, AV_LOG_VERBOSE,
5545            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5546            name, args ? args : "");
5547     return 1;
5548 }
5549
5550 #if FF_API_OLD_BSF
5551 FF_DISABLE_DEPRECATION_WARNINGS
5552 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5553                                AVBitStreamFilterContext *bsfc)
5554 {
5555     int ret = 0;
5556     while (bsfc) {
5557         AVPacket new_pkt = *pkt;
5558         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5559                                            &new_pkt.data, &new_pkt.size,
5560                                            pkt->data, pkt->size,
5561                                            pkt->flags & AV_PKT_FLAG_KEY);
5562         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5563             av_packet_unref(pkt);
5564             memset(pkt, 0, sizeof(*pkt));
5565             return 0;
5566         }
5567         if(a == 0 && new_pkt.data != pkt->data) {
5568             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
5569             if (t) {
5570                 memcpy(t, new_pkt.data, new_pkt.size);
5571                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5572                 new_pkt.data = t;
5573                 new_pkt.buf = NULL;
5574                 a = 1;
5575             } else {
5576                 a = AVERROR(ENOMEM);
5577             }
5578         }
5579         if (a > 0) {
5580             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5581                                            av_buffer_default_free, NULL, 0);
5582             if (new_pkt.buf) {
5583                 pkt->side_data = NULL;
5584                 pkt->side_data_elems = 0;
5585                 av_packet_unref(pkt);
5586             } else {
5587                 av_freep(&new_pkt.data);
5588                 a = AVERROR(ENOMEM);
5589             }
5590         }
5591         if (a < 0) {
5592             av_log(codec, AV_LOG_ERROR,
5593                    "Failed to open bitstream filter %s for stream %d with codec %s",
5594                    bsfc->filter->name, pkt->stream_index,
5595                    codec->codec ? codec->codec->name : "copy");
5596             ret = a;
5597             break;
5598         }
5599         *pkt = new_pkt;
5600
5601         bsfc = bsfc->next;
5602     }
5603     return ret;
5604 }
5605 FF_ENABLE_DEPRECATION_WARNINGS
5606 #endif
5607
5608 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5609 {
5610     if (!s->oformat)
5611         return AVERROR(EINVAL);
5612
5613     if (!(s->oformat->flags & AVFMT_NOFILE))
5614         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5615     return 0;
5616 }
5617
5618 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5619 {
5620     if (*pb)
5621         s->io_close(s, *pb);
5622     *pb = NULL;
5623 }
5624
5625 int ff_is_http_proto(char *filename) {
5626     const char *proto = avio_find_protocol_name(filename);
5627     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5628 }
5629
5630 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5631 {
5632     AVDictionaryEntry *entry;
5633     int64_t parsed_timestamp;
5634     int ret;
5635     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5636         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5637             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5638             return 1;
5639         } else {
5640             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5641             return ret;
5642         }
5643     }
5644     return 0;
5645 }
5646
5647 int ff_standardize_creation_time(AVFormatContext *s)
5648 {
5649     int64_t timestamp;
5650     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5651     if (ret == 1)
5652         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5653     return ret;
5654 }
5655
5656 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5657 {
5658     uint8_t *side_data;
5659     int size;
5660
5661     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5662     if (side_data) {
5663         if (size != AVPALETTE_SIZE) {
5664             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5665             return AVERROR_INVALIDDATA;
5666         }
5667         memcpy(palette, side_data, AVPALETTE_SIZE);
5668         return 1;
5669     }
5670
5671     if (ret == CONTAINS_PAL) {
5672         int i;
5673         for (i = 0; i < AVPALETTE_COUNT; i++)
5674             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5675         return 1;
5676     }
5677
5678     return 0;
5679 }
5680
5681 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5682 {
5683     int ret;
5684     char *str;
5685
5686     ret = av_bprint_finalize(buf, &str);
5687     if (ret < 0)
5688         return ret;
5689     if (!av_bprint_is_complete(buf)) {
5690         av_free(str);
5691         return AVERROR(ENOMEM);
5692     }
5693
5694     par->extradata = str;
5695     /* Note: the string is NUL terminated (so extradata can be read as a
5696      * string), but the ending character is not accounted in the size (in
5697      * binary formats you are likely not supposed to mux that character). When
5698      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5699      * zeros. */
5700     par->extradata_size = buf->len;
5701     return 0;
5702 }
5703
5704 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5705                                                   AVStream *ost, const AVStream *ist,
5706                                                   enum AVTimebaseSource copy_tb)
5707 {
5708     //TODO: use [io]st->internal->avctx
5709     const AVCodecContext *dec_ctx;
5710     AVCodecContext       *enc_ctx;
5711
5712 #if FF_API_LAVF_AVCTX
5713 FF_DISABLE_DEPRECATION_WARNINGS
5714     dec_ctx = ist->codec;
5715     enc_ctx = ost->codec;
5716 FF_ENABLE_DEPRECATION_WARNINGS
5717 #else
5718     dec_ctx = ist->internal->avctx;
5719     enc_ctx = ost->internal->avctx;
5720 #endif
5721
5722     enc_ctx->time_base = ist->time_base;
5723     /*
5724      * Avi is a special case here because it supports variable fps but
5725      * having the fps and timebase differe significantly adds quite some
5726      * overhead
5727      */
5728     if (!strcmp(ofmt->name, "avi")) {
5729 #if FF_API_R_FRAME_RATE
5730         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5731             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5732             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5733             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5734             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5735             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5736             enc_ctx->time_base.num = ist->r_frame_rate.den;
5737             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5738             enc_ctx->ticks_per_frame = 2;
5739         } else
5740 #endif
5741             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5742                    && av_q2d(ist->time_base) < 1.0/500
5743                    || copy_tb == AVFMT_TBCF_DECODER) {
5744             enc_ctx->time_base = dec_ctx->time_base;
5745             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5746             enc_ctx->time_base.den *= 2;
5747             enc_ctx->ticks_per_frame = 2;
5748         }
5749     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5750                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5751         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5752             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5753             && av_q2d(ist->time_base) < 1.0/500
5754             || copy_tb == AVFMT_TBCF_DECODER) {
5755             enc_ctx->time_base = dec_ctx->time_base;
5756             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5757         }
5758     }
5759
5760     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5761         && dec_ctx->time_base.num < dec_ctx->time_base.den
5762         && dec_ctx->time_base.num > 0
5763         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5764         enc_ctx->time_base = dec_ctx->time_base;
5765     }
5766
5767     if (ost->avg_frame_rate.num)
5768         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5769
5770     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5771               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5772
5773     return 0;
5774 }
5775
5776 AVRational av_stream_get_codec_timebase(const AVStream *st)
5777 {
5778     // See avformat_transfer_internal_stream_timing_info() TODO.
5779 #if FF_API_LAVF_AVCTX
5780 FF_DISABLE_DEPRECATION_WARNINGS
5781     return st->codec->time_base;
5782 FF_ENABLE_DEPRECATION_WARNINGS
5783 #else
5784     return st->internal->avctx->time_base;
5785 #endif
5786 }
5787
5788 void ff_format_set_url(AVFormatContext *s, char *url)
5789 {
5790     av_assert0(url);
5791     av_freep(&s->url);
5792     s->url = url;
5793 #if FF_API_FORMAT_FILENAME
5794 FF_DISABLE_DEPRECATION_WARNINGS
5795     av_strlcpy(s->filename, url, sizeof(s->filename));
5796 FF_ENABLE_DEPRECATION_WARNINGS
5797 #endif
5798 }