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