git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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