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