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