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