2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/packet_internal.h"
41 #include "libavcodec/raw.h"
44 #include "avio_internal.h"
52 #include "libavutil/ffversion.h"
53 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
55 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
59 * various utility functions for use within FFmpeg
62 unsigned avformat_version(void)
64 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
65 return LIBAVFORMAT_VERSION_INT;
68 const char *avformat_configuration(void)
70 return FFMPEG_CONFIGURATION;
73 const char *avformat_license(void)
75 #define LICENSE_PREFIX "libavformat license: "
76 return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
79 int ff_lock_avformat(void)
81 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
84 int ff_unlock_avformat(void)
86 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
89 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
91 static int is_relative(int64_t ts) {
92 return ts > (RELATIVE_TS_BASE - (1LL<<48));
96 * Wrap a given time stamp, if there is an indication for an overflow
99 * @param timestamp the time stamp to wrap
100 * @return resulting time stamp
102 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
104 if (st->internal->pts_wrap_behavior != AV_PTS_WRAP_IGNORE && st->pts_wrap_bits < 64 &&
105 st->internal->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
106 if (st->internal->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
107 timestamp < st->internal->pts_wrap_reference)
108 return timestamp + (1ULL << st->pts_wrap_bits);
109 else if (st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
110 timestamp >= st->internal->pts_wrap_reference)
111 return timestamp - (1ULL << st->pts_wrap_bits);
116 #if FF_API_FORMAT_GET_SET
117 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
118 #if FF_API_LAVF_FFSERVER
119 FF_DISABLE_DEPRECATION_WARNINGS
120 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
121 FF_ENABLE_DEPRECATION_WARNINGS
123 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
124 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
125 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
126 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
127 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
128 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
129 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
130 #if FF_API_OLD_OPEN_CALLBACKS
131 FF_DISABLE_DEPRECATION_WARNINGS
132 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
133 FF_ENABLE_DEPRECATION_WARNINGS
137 int64_t av_stream_get_end_pts(const AVStream *st)
139 if (st->internal->priv_pts) {
140 return st->internal->priv_pts->val;
142 return AV_NOPTS_VALUE;
145 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
150 void av_format_inject_global_side_data(AVFormatContext *s)
153 s->internal->inject_global_side_data = 1;
154 for (i = 0; i < s->nb_streams; i++) {
155 AVStream *st = s->streams[i];
156 st->internal->inject_global_side_data = 1;
160 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
162 av_assert0(!dst->codec_whitelist &&
163 !dst->format_whitelist &&
164 !dst->protocol_whitelist &&
165 !dst->protocol_blacklist);
166 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
167 dst->format_whitelist = av_strdup(src->format_whitelist);
168 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
169 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
170 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
171 || (src-> format_whitelist && !dst-> format_whitelist)
172 || (src->protocol_whitelist && !dst->protocol_whitelist)
173 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
174 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
175 return AVERROR(ENOMEM);
180 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
182 #if FF_API_LAVF_AVCTX
183 FF_DISABLE_DEPRECATION_WARNINGS
184 if (st->codec->codec)
185 return st->codec->codec;
186 FF_ENABLE_DEPRECATION_WARNINGS
189 switch (st->codecpar->codec_type) {
190 case AVMEDIA_TYPE_VIDEO:
191 if (s->video_codec) return s->video_codec;
193 case AVMEDIA_TYPE_AUDIO:
194 if (s->audio_codec) return s->audio_codec;
196 case AVMEDIA_TYPE_SUBTITLE:
197 if (s->subtitle_codec) return s->subtitle_codec;
201 return avcodec_find_decoder(codec_id);
204 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
206 const AVCodec *codec;
208 #if CONFIG_H264_DECODER
209 /* Other parts of the code assume this decoder to be used for h264,
210 * so force it if possible. */
211 if (codec_id == AV_CODEC_ID_H264)
212 return avcodec_find_decoder_by_name("h264");
215 codec = find_decoder(s, st, codec_id);
219 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
220 const AVCodec *probe_codec = NULL;
222 while ((probe_codec = av_codec_iterate(&iter))) {
223 if (probe_codec->id == codec->id &&
224 av_codec_is_decoder(probe_codec) &&
225 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
234 #if FF_API_FORMAT_GET_SET
235 int av_format_get_probe_score(const AVFormatContext *s)
237 return s->probe_score;
241 /* an arbitrarily chosen "sane" max packet size -- 50M */
242 #define SANE_CHUNK_SIZE (50000000)
244 int ffio_limit(AVIOContext *s, int size)
246 if (s->maxsize>= 0) {
247 int64_t pos = avio_tell(s);
248 int64_t remaining= s->maxsize - pos;
249 if (remaining < size) {
250 int64_t newsize = avio_size(s);
251 if (!s->maxsize || s->maxsize<newsize)
252 s->maxsize = newsize - !newsize;
253 if (pos > s->maxsize && s->maxsize >= 0)
254 s->maxsize = AVERROR(EIO);
256 remaining = s->maxsize - pos;
259 if (s->maxsize >= 0 && remaining < size && size > 1) {
260 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG,
261 "Truncating packet of size %d to %"PRId64"\n",
262 size, remaining + !remaining);
263 size = remaining + !remaining;
269 /* Read the data in sane-sized chunks and append to pkt.
270 * Return the number of bytes read or an error. */
271 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
273 int orig_size = pkt->size;
277 int prev_size = pkt->size;
280 /* When the caller requests a lot of data, limit it to the amount
281 * left in file or SANE_CHUNK_SIZE when it is not known. */
283 if (read_size > SANE_CHUNK_SIZE/10) {
284 read_size = ffio_limit(s, read_size);
285 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
287 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
290 ret = av_grow_packet(pkt, read_size);
294 ret = avio_read(s, pkt->data + prev_size, read_size);
295 if (ret != read_size) {
296 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
303 pkt->flags |= AV_PKT_FLAG_CORRUPT;
306 av_packet_unref(pkt);
307 return pkt->size > orig_size ? pkt->size - orig_size : ret;
310 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
312 #if FF_API_INIT_PACKET
313 FF_DISABLE_DEPRECATION_WARNINGS
317 FF_ENABLE_DEPRECATION_WARNINGS
319 av_packet_unref(pkt);
321 pkt->pos = avio_tell(s);
323 return append_packet_chunked(s, pkt, size);
326 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
329 return av_get_packet(s, pkt, size);
330 return append_packet_chunked(s, pkt, size);
333 int av_filename_number_test(const char *filename)
337 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
340 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
343 static const struct {
346 enum AVMediaType type;
348 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
349 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
350 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
351 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
352 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
353 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
354 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
355 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
356 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
357 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
358 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
359 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
360 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
361 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
362 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
366 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
370 av_log(s, AV_LOG_DEBUG,
371 "Probe with size=%d, packets=%d detected %s with score=%d\n",
372 pd->buf_size, s->max_probe_packets - st->probe_packets,
374 for (i = 0; fmt_id_type[i].name; i++) {
375 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
376 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
377 st->codecpar->sample_rate)
379 if (st->internal->request_probe > score &&
380 st->codecpar->codec_id != fmt_id_type[i].id)
382 st->codecpar->codec_id = fmt_id_type[i].id;
383 st->codecpar->codec_type = fmt_id_type[i].type;
384 st->internal->need_context_update = 1;
385 #if FF_API_LAVF_AVCTX
386 FF_DISABLE_DEPRECATION_WARNINGS
387 st->codec->codec_type = st->codecpar->codec_type;
388 st->codec->codec_id = st->codecpar->codec_id;
389 FF_ENABLE_DEPRECATION_WARNINGS
398 /************************************************************/
399 /* input media file */
401 #if FF_API_DEMUXER_OPEN
402 int av_demuxer_open(AVFormatContext *ic) {
405 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
406 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
407 return AVERROR(EINVAL);
410 if (ic->iformat->read_header) {
411 err = ic->iformat->read_header(ic);
416 if (ic->pb && !ic->internal->data_offset)
417 ic->internal->data_offset = avio_tell(ic->pb);
422 /* Open input file and probe the format if necessary. */
423 static int init_input(AVFormatContext *s, const char *filename,
424 AVDictionary **options)
427 AVProbeData pd = { filename, NULL, 0 };
428 int score = AVPROBE_SCORE_RETRY;
431 s->flags |= AVFMT_FLAG_CUSTOM_IO;
433 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
434 s, 0, s->format_probesize);
435 else if (s->iformat->flags & AVFMT_NOFILE)
436 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
437 "will be ignored with AVFMT_NOFILE format.\n");
441 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
442 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
445 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
450 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
451 s, 0, s->format_probesize);
454 int avformat_queue_attached_pictures(AVFormatContext *s)
457 for (i = 0; i < s->nb_streams; i++)
458 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
459 s->streams[i]->discard < AVDISCARD_ALL) {
460 if (s->streams[i]->attached_pic.size <= 0) {
461 av_log(s, AV_LOG_WARNING,
462 "Attached picture on stream %d has invalid size, "
467 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
468 &s->internal->raw_packet_buffer_end,
469 &s->streams[i]->attached_pic,
477 int ff_add_attached_pic(AVFormatContext *s, AVStream *st0, AVIOContext *pb,
478 AVBufferRef **buf, int size)
484 if (!st && !(st = avformat_new_stream(s, NULL)))
485 return AVERROR(ENOMEM);
486 pkt = &st->attached_pic;
489 av_packet_unref(pkt);
491 pkt->data = (*buf)->data;
492 pkt->size = (*buf)->size - AV_INPUT_BUFFER_PADDING_SIZE;
495 ret = av_get_packet(pb, pkt, size);
499 st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
500 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
502 pkt->stream_index = st->index;
503 pkt->flags |= AV_PKT_FLAG_KEY;
508 ff_free_stream(s, st);
512 static int update_stream_avctx(AVFormatContext *s)
515 for (i = 0; i < s->nb_streams; i++) {
516 AVStream *st = s->streams[i];
518 if (!st->internal->need_context_update)
521 /* close parser, because it depends on the codec */
522 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
523 av_parser_close(st->parser);
527 /* update internal codec context, for the parser */
528 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
532 #if FF_API_LAVF_AVCTX
533 FF_DISABLE_DEPRECATION_WARNINGS
534 /* update deprecated public codec context */
535 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
538 FF_ENABLE_DEPRECATION_WARNINGS
541 st->internal->need_context_update = 0;
547 int avformat_open_input(AVFormatContext **ps, const char *filename,
548 ff_const59 AVInputFormat *fmt, AVDictionary **options)
550 AVFormatContext *s = *ps;
552 AVDictionary *tmp = NULL;
553 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
555 if (!s && !(s = avformat_alloc_context()))
556 return AVERROR(ENOMEM);
558 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
559 return AVERROR(EINVAL);
565 av_dict_copy(&tmp, *options, 0);
567 if (s->pb) // must be before any goto fail
568 s->flags |= AVFMT_FLAG_CUSTOM_IO;
570 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
573 if (!(s->url = av_strdup(filename ? filename : ""))) {
574 ret = AVERROR(ENOMEM);
578 #if FF_API_FORMAT_FILENAME
579 FF_DISABLE_DEPRECATION_WARNINGS
580 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
581 FF_ENABLE_DEPRECATION_WARNINGS
583 if ((ret = init_input(s, filename, &tmp)) < 0)
585 s->probe_score = ret;
587 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
588 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
589 if (!s->protocol_whitelist) {
590 ret = AVERROR(ENOMEM);
595 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
596 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
597 if (!s->protocol_blacklist) {
598 ret = AVERROR(ENOMEM);
603 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
604 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
605 ret = AVERROR(EINVAL);
609 avio_skip(s->pb, s->skip_initial_bytes);
611 /* Check filename in case an image number is expected. */
612 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
613 if (!av_filename_number_test(filename)) {
614 ret = AVERROR(EINVAL);
619 s->duration = s->start_time = AV_NOPTS_VALUE;
621 /* Allocate private data. */
622 if (s->iformat->priv_data_size > 0) {
623 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
624 ret = AVERROR(ENOMEM);
627 if (s->iformat->priv_class) {
628 *(const AVClass **) s->priv_data = s->iformat->priv_class;
629 av_opt_set_defaults(s->priv_data);
630 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
635 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
637 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
639 #if FF_API_DEMUXER_OPEN
640 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
642 if (s->iformat->read_header)
644 if ((ret = s->iformat->read_header(s)) < 0)
648 s->metadata = s->internal->id3v2_meta;
649 s->internal->id3v2_meta = NULL;
650 } else if (s->internal->id3v2_meta) {
651 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
652 av_dict_free(&s->internal->id3v2_meta);
655 if (id3v2_extra_meta) {
656 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
657 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
658 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
660 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
662 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
665 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
667 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
669 if ((ret = avformat_queue_attached_pictures(s)) < 0)
672 #if FF_API_DEMUXER_OPEN
673 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
675 if (s->pb && !s->internal->data_offset)
677 s->internal->data_offset = avio_tell(s->pb);
679 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
681 update_stream_avctx(s);
683 for (i = 0; i < s->nb_streams; i++)
684 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
687 av_dict_free(options);
694 if (s->iformat->read_close)
695 s->iformat->read_close(s);
697 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
699 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
701 avformat_free_context(s);
706 /*******************************************************/
708 static void force_codec_ids(AVFormatContext *s, AVStream *st)
710 switch (st->codecpar->codec_type) {
711 case AVMEDIA_TYPE_VIDEO:
712 if (s->video_codec_id)
713 st->codecpar->codec_id = s->video_codec_id;
715 case AVMEDIA_TYPE_AUDIO:
716 if (s->audio_codec_id)
717 st->codecpar->codec_id = s->audio_codec_id;
719 case AVMEDIA_TYPE_SUBTITLE:
720 if (s->subtitle_codec_id)
721 st->codecpar->codec_id = s->subtitle_codec_id;
723 case AVMEDIA_TYPE_DATA:
724 if (s->data_codec_id)
725 st->codecpar->codec_id = s->data_codec_id;
730 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
732 if (st->internal->request_probe>0) {
733 AVProbeData *pd = &st->internal->probe_data;
735 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
739 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
741 av_log(s, AV_LOG_WARNING,
742 "Failed to reallocate probe buffer for stream %d\n",
747 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
748 pd->buf_size += pkt->size;
749 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
752 st->probe_packets = 0;
754 av_log(s, AV_LOG_WARNING,
755 "nothing to probe for stream %d\n", st->index);
759 end= s->internal->raw_packet_buffer_remaining_size <= 0
760 || st->probe_packets<= 0;
762 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
763 int score = set_codec_from_probe_data(s, st, pd);
764 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
768 st->internal->request_probe = -1;
769 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
770 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
772 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
774 force_codec_ids(s, st);
780 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
782 int64_t ref = pkt->dts;
783 int i, pts_wrap_behavior;
784 int64_t pts_wrap_reference;
785 AVProgram *first_program;
787 if (ref == AV_NOPTS_VALUE)
789 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
791 ref &= (1LL << st->pts_wrap_bits)-1;
793 // reference time stamp should be 60 s before first time stamp
794 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
795 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
796 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
797 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
798 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
800 first_program = av_find_program_from_stream(s, NULL, stream_index);
802 if (!first_program) {
803 int default_stream_index = av_find_default_stream_index(s);
804 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
805 for (i = 0; i < s->nb_streams; i++) {
806 if (av_find_program_from_stream(s, NULL, i))
808 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
809 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
813 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
814 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
818 AVProgram *program = first_program;
820 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
821 pts_wrap_reference = program->pts_wrap_reference;
822 pts_wrap_behavior = program->pts_wrap_behavior;
825 program = av_find_program_from_stream(s, program, stream_index);
828 // update every program with differing pts_wrap_reference
829 program = first_program;
831 if (program->pts_wrap_reference != pts_wrap_reference) {
832 for (i = 0; i<program->nb_stream_indexes; i++) {
833 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
834 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
837 program->pts_wrap_reference = pts_wrap_reference;
838 program->pts_wrap_behavior = pts_wrap_behavior;
840 program = av_find_program_from_stream(s, program, stream_index);
846 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
851 #if FF_API_INIT_PACKET
852 FF_DISABLE_DEPRECATION_WARNINGS
856 FF_ENABLE_DEPRECATION_WARNINGS
858 av_packet_unref(pkt);
862 PacketList *pktl = s->internal->raw_packet_buffer;
863 const AVPacket *pkt1;
866 st = s->streams[pktl->pkt.stream_index];
867 if (s->internal->raw_packet_buffer_remaining_size <= 0)
868 if ((err = probe_codec(s, st, NULL)) < 0)
870 if (st->internal->request_probe <= 0) {
871 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
872 &s->internal->raw_packet_buffer_end, pkt);
873 s->internal->raw_packet_buffer_remaining_size += pkt->size;
878 err = s->iformat->read_packet(s, pkt);
880 av_packet_unref(pkt);
882 /* Some demuxers return FFERROR_REDO when they consume
883 data and discard it (ignored streams, junk, extradata).
884 We must re-call the demuxer to get the real packet. */
885 if (err == FFERROR_REDO)
887 if (!pktl || err == AVERROR(EAGAIN))
889 for (i = 0; i < s->nb_streams; i++) {
891 if (st->probe_packets || st->internal->request_probe > 0)
892 if ((err = probe_codec(s, st, NULL)) < 0)
894 av_assert0(st->internal->request_probe <= 0);
899 err = av_packet_make_refcounted(pkt);
901 av_packet_unref(pkt);
905 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
906 av_log(s, AV_LOG_WARNING,
907 "Packet corrupt (stream = %d, dts = %s)",
908 pkt->stream_index, av_ts2str(pkt->dts));
909 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
910 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
911 av_packet_unref(pkt);
914 av_log(s, AV_LOG_WARNING, ".\n");
917 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
918 "Invalid stream index.\n");
920 st = s->streams[pkt->stream_index];
922 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
923 // correct first time stamps to negative values
924 if (!is_relative(st->first_dts))
925 st->first_dts = wrap_timestamp(st, st->first_dts);
926 if (!is_relative(st->start_time))
927 st->start_time = wrap_timestamp(st, st->start_time);
928 if (!is_relative(st->cur_dts))
929 st->cur_dts = wrap_timestamp(st, st->cur_dts);
932 pkt->dts = wrap_timestamp(st, pkt->dts);
933 pkt->pts = wrap_timestamp(st, pkt->pts);
935 force_codec_ids(s, st);
937 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
938 if (s->use_wallclock_as_timestamps)
939 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
941 if (!pktl && st->internal->request_probe <= 0)
944 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
945 &s->internal->raw_packet_buffer_end,
948 av_packet_unref(pkt);
951 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
952 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
954 if ((err = probe_codec(s, st, pkt1)) < 0)
960 /**********************************************************/
962 static int determinable_frame_size(AVCodecContext *avctx)
964 switch(avctx->codec_id) {
965 case AV_CODEC_ID_MP1:
966 case AV_CODEC_ID_MP2:
967 case AV_CODEC_ID_MP3:
968 case AV_CODEC_ID_CODEC2:
976 * Return the frame duration in seconds. Return 0 if not available.
978 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
979 AVCodecParserContext *pc, AVPacket *pkt)
981 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
982 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
983 int frame_size, sample_rate;
985 #if FF_API_LAVF_AVCTX
986 FF_DISABLE_DEPRECATION_WARNINGS
987 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
988 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
989 FF_ENABLE_DEPRECATION_WARNINGS
994 switch (st->codecpar->codec_type) {
995 case AVMEDIA_TYPE_VIDEO:
996 if (st->r_frame_rate.num && !pc && s->iformat) {
997 *pnum = st->r_frame_rate.den;
998 *pden = st->r_frame_rate.num;
999 } else if (st->time_base.num * 1000LL > st->time_base.den) {
1000 *pnum = st->time_base.num;
1001 *pden = st->time_base.den;
1002 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
1003 av_assert0(st->internal->avctx->ticks_per_frame);
1004 av_reduce(pnum, pden,
1005 codec_framerate.den,
1006 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
1009 if (pc && pc->repeat_pict) {
1010 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
1011 av_reduce(pnum, pden,
1012 (*pnum) * (1LL + pc->repeat_pict),
1016 /* If this codec can be interlaced or progressive then we need
1017 * a parser to compute duration of a packet. Thus if we have
1018 * no parser in such case leave duration undefined. */
1019 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
1023 case AVMEDIA_TYPE_AUDIO:
1024 if (st->internal->avctx_inited) {
1025 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
1026 sample_rate = st->internal->avctx->sample_rate;
1028 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
1029 sample_rate = st->codecpar->sample_rate;
1031 if (frame_size <= 0 || sample_rate <= 0)
1034 *pden = sample_rate;
1041 int ff_is_intra_only(enum AVCodecID id)
1043 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1046 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1047 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1052 static int has_decode_delay_been_guessed(AVStream *st)
1054 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1055 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1057 #if CONFIG_H264_DECODER
1058 if (st->internal->avctx->has_b_frames &&
1059 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1062 if (st->internal->avctx->has_b_frames<3)
1063 return st->internal->nb_decoded_frames >= 7;
1064 else if (st->internal->avctx->has_b_frames<4)
1065 return st->internal->nb_decoded_frames >= 18;
1067 return st->internal->nb_decoded_frames >= 20;
1070 static PacketList *get_next_pkt(AVFormatContext *s, AVStream *st, PacketList *pktl)
1074 if (pktl == s->internal->packet_buffer_end)
1075 return s->internal->parse_queue;
1079 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1080 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1081 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1084 int delay = st->internal->avctx->has_b_frames;
1087 if (dts == AV_NOPTS_VALUE) {
1088 int64_t best_score = INT64_MAX;
1089 for (i = 0; i<delay; i++) {
1090 if (st->internal->pts_reorder_error_count[i]) {
1091 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1092 if (score < best_score) {
1094 dts = pts_buffer[i];
1099 for (i = 0; i<delay; i++) {
1100 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1101 int64_t diff = FFABS(pts_buffer[i] - dts)
1102 + (uint64_t)st->internal->pts_reorder_error[i];
1103 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1104 st->internal->pts_reorder_error[i] = diff;
1105 st->internal->pts_reorder_error_count[i]++;
1106 if (st->internal->pts_reorder_error_count[i] > 250) {
1107 st->internal->pts_reorder_error[i] >>= 1;
1108 st->internal->pts_reorder_error_count[i] >>= 1;
1115 if (dts == AV_NOPTS_VALUE)
1116 dts = pts_buffer[0];
1122 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1123 * of the packets in a window.
1125 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1126 PacketList *pkt_buffer)
1128 AVStream *st = s->streams[stream_index];
1129 int delay = st->internal->avctx->has_b_frames;
1132 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1134 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1135 pts_buffer[i] = AV_NOPTS_VALUE;
1137 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1138 if (pkt_buffer->pkt.stream_index != stream_index)
1141 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1142 pts_buffer[0] = pkt_buffer->pkt.pts;
1143 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1144 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1146 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1151 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1152 int64_t dts, int64_t pts, AVPacket *pkt)
1154 AVStream *st = s->streams[stream_index];
1155 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1156 PacketList *pktl_it;
1160 if (st->first_dts != AV_NOPTS_VALUE ||
1161 dts == AV_NOPTS_VALUE ||
1162 st->cur_dts == AV_NOPTS_VALUE ||
1163 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1164 dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1168 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1170 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1172 if (is_relative(pts))
1175 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1176 if (pktl_it->pkt.stream_index != stream_index)
1178 if (is_relative(pktl_it->pkt.pts))
1179 pktl_it->pkt.pts += shift;
1181 if (is_relative(pktl_it->pkt.dts))
1182 pktl_it->pkt.dts += shift;
1184 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1185 st->start_time = pktl_it->pkt.pts;
1186 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1187 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->internal->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1191 if (has_decode_delay_been_guessed(st)) {
1192 update_dts_from_pts(s, stream_index, pktl);
1195 if (st->start_time == AV_NOPTS_VALUE) {
1196 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1197 st->start_time = pts;
1199 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1200 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->internal->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1204 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1205 int stream_index, int64_t duration)
1207 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1208 int64_t cur_dts = RELATIVE_TS_BASE;
1210 if (st->first_dts != AV_NOPTS_VALUE) {
1211 if (st->internal->update_initial_durations_done)
1213 st->internal->update_initial_durations_done = 1;
1214 cur_dts = st->first_dts;
1215 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1216 if (pktl->pkt.stream_index == stream_index) {
1217 if (pktl->pkt.pts != pktl->pkt.dts ||
1218 pktl->pkt.dts != AV_NOPTS_VALUE ||
1221 cur_dts -= duration;
1224 if (pktl && pktl->pkt.dts != st->first_dts) {
1225 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1226 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1230 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1233 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1234 st->first_dts = cur_dts;
1235 } else if (st->cur_dts != RELATIVE_TS_BASE)
1238 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1239 if (pktl->pkt.stream_index != stream_index)
1241 if ((pktl->pkt.pts == pktl->pkt.dts ||
1242 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1243 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1244 pktl->pkt.dts == st->first_dts ||
1245 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1246 !pktl->pkt.duration) {
1247 pktl->pkt.dts = cur_dts;
1248 if (!st->internal->avctx->has_b_frames)
1249 pktl->pkt.pts = cur_dts;
1250 pktl->pkt.duration = duration;
1253 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1256 st->cur_dts = cur_dts;
1259 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1260 AVCodecParserContext *pc, AVPacket *pkt,
1261 int64_t next_dts, int64_t next_pts)
1263 int num, den, presentation_delayed, delay, i;
1265 AVRational duration;
1266 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1267 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1269 if (s->flags & AVFMT_FLAG_NOFILLIN)
1272 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1273 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1274 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1275 st->internal->dts_ordered++;
1277 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1278 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1280 st->internal->last_dts_for_order_check);
1281 st->internal->dts_misordered++;
1283 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1284 st->internal->dts_ordered >>= 1;
1285 st->internal->dts_misordered >>= 1;
1289 st->internal->last_dts_for_order_check = pkt->dts;
1290 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1291 pkt->dts = AV_NOPTS_VALUE;
1294 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1295 pkt->dts = AV_NOPTS_VALUE;
1297 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1298 && !st->internal->avctx->has_b_frames)
1299 //FIXME Set low_delay = 0 when has_b_frames = 1
1300 st->internal->avctx->has_b_frames = 1;
1302 /* do we have a video B-frame ? */
1303 delay = st->internal->avctx->has_b_frames;
1304 presentation_delayed = 0;
1306 /* XXX: need has_b_frame, but cannot get it if the codec is
1307 * not initialized */
1309 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1310 presentation_delayed = 1;
1312 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1313 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1314 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1315 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1316 pkt->dts -= 1LL << st->pts_wrap_bits;
1318 pkt->pts += 1LL << st->pts_wrap_bits;
1321 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1322 * We take the conservative approach and discard both.
1323 * Note: If this is misbehaving for an H.264 file, then possibly
1324 * presentation_delayed is not set correctly. */
1325 if (delay == 1 && pkt->dts == pkt->pts &&
1326 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1327 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1328 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1329 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1330 pkt->dts = AV_NOPTS_VALUE;
1333 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1334 if (pkt->duration <= 0) {
1335 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1337 duration = (AVRational) {num, den};
1338 pkt->duration = av_rescale_rnd(1,
1339 num * (int64_t) st->time_base.den,
1340 den * (int64_t) st->time_base.num,
1345 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1346 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1348 /* Correct timestamps with byte offset if demuxers only have timestamps
1349 * on packet boundaries */
1350 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1351 /* this will estimate bitrate based on this frame's duration and size */
1352 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1353 if (pkt->pts != AV_NOPTS_VALUE)
1355 if (pkt->dts != AV_NOPTS_VALUE)
1359 /* This may be redundant, but it should not hurt. */
1360 if (pkt->dts != AV_NOPTS_VALUE &&
1361 pkt->pts != AV_NOPTS_VALUE &&
1362 pkt->pts > pkt->dts)
1363 presentation_delayed = 1;
1365 if (s->debug & FF_FDEBUG_TS)
1366 av_log(s, AV_LOG_DEBUG,
1367 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1368 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1369 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1371 /* Interpolate PTS and DTS if they are not present. We skip H264
1372 * currently because delay and has_b_frames are not reliably set. */
1373 if ((delay == 0 || (delay == 1 && pc)) &&
1375 if (presentation_delayed) {
1376 /* DTS = decompression timestamp */
1377 /* PTS = presentation timestamp */
1378 if (pkt->dts == AV_NOPTS_VALUE)
1379 pkt->dts = st->last_IP_pts;
1380 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1381 if (pkt->dts == AV_NOPTS_VALUE)
1382 pkt->dts = st->cur_dts;
1384 /* This is tricky: the dts must be incremented by the duration
1385 * of the frame we are displaying, i.e. the last I- or P-frame. */
1386 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1387 st->last_IP_duration = pkt->duration;
1388 if (pkt->dts != AV_NOPTS_VALUE)
1389 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1390 if (pkt->dts != AV_NOPTS_VALUE &&
1391 pkt->pts == AV_NOPTS_VALUE &&
1392 st->last_IP_duration > 0 &&
1393 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1394 next_dts != next_pts &&
1395 next_pts != AV_NOPTS_VALUE)
1396 pkt->pts = next_dts;
1398 if ((uint64_t)pkt->duration <= INT32_MAX)
1399 st->last_IP_duration = pkt->duration;
1400 st->last_IP_pts = pkt->pts;
1401 /* Cannot compute PTS if not present (we can compute it only
1402 * by knowing the future. */
1403 } else if (pkt->pts != AV_NOPTS_VALUE ||
1404 pkt->dts != AV_NOPTS_VALUE ||
1405 pkt->duration > 0 ) {
1407 /* presentation is not delayed : PTS and DTS are the same */
1408 if (pkt->pts == AV_NOPTS_VALUE)
1409 pkt->pts = pkt->dts;
1410 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1412 if (pkt->pts == AV_NOPTS_VALUE)
1413 pkt->pts = st->cur_dts;
1414 pkt->dts = pkt->pts;
1415 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1416 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1420 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1421 st->internal->pts_buffer[0] = pkt->pts;
1422 for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1423 FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1425 if(has_decode_delay_been_guessed(st))
1426 pkt->dts = select_from_pts_buffer(st, st->internal->pts_buffer, pkt->dts);
1428 // We skipped it above so we try here.
1430 // This should happen on the first packet
1431 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1432 if (pkt->dts > st->cur_dts)
1433 st->cur_dts = pkt->dts;
1435 if (s->debug & FF_FDEBUG_TS)
1436 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1437 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1440 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1441 pkt->flags |= AV_PKT_FLAG_KEY;
1442 #if FF_API_CONVERGENCE_DURATION
1443 FF_DISABLE_DEPRECATION_WARNINGS
1445 pkt->convergence_duration = pc->convergence_duration;
1446 FF_ENABLE_DEPRECATION_WARNINGS
1451 * Parse a packet, add all split parts to parse_queue.
1453 * @param pkt Packet to parse; must not be NULL.
1454 * @param flush Indicates whether to flush. If set, pkt must be blank.
1456 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1457 int stream_index, int flush)
1459 AVPacket *out_pkt = s->internal->parse_pkt;
1460 AVStream *st = s->streams[stream_index];
1461 uint8_t *data = pkt->data;
1462 int size = pkt->size;
1463 int ret = 0, got_output = flush;
1465 if (!size && !flush && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1466 // preserve 0-size sync packets
1467 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1470 while (size > 0 || (flush && got_output)) {
1472 int64_t next_pts = pkt->pts;
1473 int64_t next_dts = pkt->dts;
1475 len = av_parser_parse2(st->parser, st->internal->avctx,
1476 &out_pkt->data, &out_pkt->size, data, size,
1477 pkt->pts, pkt->dts, pkt->pos);
1479 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1481 /* increment read pointer */
1482 av_assert1(data || !len);
1483 data = len ? data + len : data;
1486 got_output = !!out_pkt->size;
1491 if (pkt->buf && out_pkt->data == pkt->data) {
1492 /* reference pkt->buf only when out_pkt->data is guaranteed to point
1493 * to data in it and not in the parser's internal buffer. */
1494 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1495 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1496 out_pkt->buf = av_buffer_ref(pkt->buf);
1497 if (!out_pkt->buf) {
1498 ret = AVERROR(ENOMEM);
1502 ret = av_packet_make_refcounted(out_pkt);
1507 if (pkt->side_data) {
1508 out_pkt->side_data = pkt->side_data;
1509 out_pkt->side_data_elems = pkt->side_data_elems;
1510 pkt->side_data = NULL;
1511 pkt->side_data_elems = 0;
1514 /* set the duration */
1515 out_pkt->duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1516 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1517 if (st->internal->avctx->sample_rate > 0) {
1519 av_rescale_q_rnd(st->parser->duration,
1520 (AVRational) { 1, st->internal->avctx->sample_rate },
1526 out_pkt->stream_index = st->index;
1527 out_pkt->pts = st->parser->pts;
1528 out_pkt->dts = st->parser->dts;
1529 out_pkt->pos = st->parser->pos;
1530 out_pkt->flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1532 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1533 out_pkt->pos = st->parser->frame_offset;
1535 if (st->parser->key_frame == 1 ||
1536 (st->parser->key_frame == -1 &&
1537 st->parser->pict_type == AV_PICTURE_TYPE_I))
1538 out_pkt->flags |= AV_PKT_FLAG_KEY;
1540 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1541 out_pkt->flags |= AV_PKT_FLAG_KEY;
1543 compute_pkt_fields(s, st, st->parser, out_pkt, next_dts, next_pts);
1545 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1546 &s->internal->parse_queue_end,
1552 /* end of the stream => close and free the parser */
1554 av_parser_close(st->parser);
1560 av_packet_unref(out_pkt);
1561 av_packet_unref(pkt);
1565 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1567 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1570 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1572 int ret, i, got_packet = 0;
1573 AVDictionary *metadata = NULL;
1575 while (!got_packet && !s->internal->parse_queue) {
1578 /* read next packet */
1579 ret = ff_read_packet(s, pkt);
1581 if (ret == AVERROR(EAGAIN))
1583 /* flush the parsers */
1584 for (i = 0; i < s->nb_streams; i++) {
1586 if (st->parser && st->need_parsing)
1587 parse_packet(s, pkt, st->index, 1);
1589 /* all remaining packets are now in parse_queue =>
1590 * really terminate parsing */
1594 st = s->streams[pkt->stream_index];
1596 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1598 /* update context if required */
1599 if (st->internal->need_context_update) {
1600 if (avcodec_is_open(st->internal->avctx)) {
1601 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1602 avcodec_close(st->internal->avctx);
1603 st->internal->info->found_decoder = 0;
1606 /* close parser, because it depends on the codec */
1607 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1608 av_parser_close(st->parser);
1612 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1614 av_packet_unref(pkt);
1618 #if FF_API_LAVF_AVCTX
1619 FF_DISABLE_DEPRECATION_WARNINGS
1620 /* update deprecated public codec context */
1621 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1623 av_packet_unref(pkt);
1626 FF_ENABLE_DEPRECATION_WARNINGS
1629 st->internal->need_context_update = 0;
1632 if (pkt->pts != AV_NOPTS_VALUE &&
1633 pkt->dts != AV_NOPTS_VALUE &&
1634 pkt->pts < pkt->dts) {
1635 av_log(s, AV_LOG_WARNING,
1636 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1638 av_ts2str(pkt->pts),
1639 av_ts2str(pkt->dts),
1642 if (s->debug & FF_FDEBUG_TS)
1643 av_log(s, AV_LOG_DEBUG,
1644 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1646 av_ts2str(pkt->pts),
1647 av_ts2str(pkt->dts),
1648 pkt->size, pkt->duration, pkt->flags);
1650 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1651 st->parser = av_parser_init(st->codecpar->codec_id);
1653 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1654 "%s, packets or times may be invalid.\n",
1655 avcodec_get_name(st->codecpar->codec_id));
1656 /* no parser available: just output the raw packets */
1657 st->need_parsing = AVSTREAM_PARSE_NONE;
1658 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1659 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1660 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1661 st->parser->flags |= PARSER_FLAG_ONCE;
1662 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1663 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1666 if (!st->need_parsing || !st->parser) {
1667 /* no parsing needed: we just output the packet as is */
1668 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1669 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1670 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1671 ff_reduce_index(s, st->index);
1672 av_add_index_entry(st, pkt->pos, pkt->dts,
1673 0, 0, AVINDEX_KEYFRAME);
1676 } else if (st->discard < AVDISCARD_ALL) {
1677 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1679 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1680 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1681 st->codecpar->channels = st->internal->avctx->channels;
1682 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1683 st->codecpar->codec_id = st->internal->avctx->codec_id;
1686 av_packet_unref(pkt);
1688 if (pkt->flags & AV_PKT_FLAG_KEY)
1689 st->internal->skip_to_keyframe = 0;
1690 if (st->internal->skip_to_keyframe) {
1691 av_packet_unref(pkt);
1696 if (!got_packet && s->internal->parse_queue)
1697 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1700 AVStream *st = s->streams[pkt->stream_index];
1701 int discard_padding = 0;
1702 if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1703 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1704 int64_t sample = ts_to_samples(st, pts);
1705 int duration = ts_to_samples(st, pkt->duration);
1706 int64_t end_sample = sample + duration;
1707 if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1708 sample < st->internal->last_discard_sample)
1709 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1711 if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1712 st->internal->skip_samples = st->internal->start_skip_samples;
1713 if (st->internal->skip_samples || discard_padding) {
1714 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1716 AV_WL32(p, st->internal->skip_samples);
1717 AV_WL32(p + 4, discard_padding);
1718 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1720 st->internal->skip_samples = 0;
1723 if (st->internal->inject_global_side_data) {
1724 for (i = 0; i < st->nb_side_data; i++) {
1725 AVPacketSideData *src_sd = &st->side_data[i];
1728 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1731 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1733 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1737 memcpy(dst_data, src_sd->data, src_sd->size);
1739 st->internal->inject_global_side_data = 0;
1743 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1745 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1746 av_dict_copy(&s->metadata, metadata, 0);
1747 av_dict_free(&metadata);
1748 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1751 #if FF_API_LAVF_AVCTX
1752 update_stream_avctx(s);
1755 if (s->debug & FF_FDEBUG_TS)
1756 av_log(s, AV_LOG_DEBUG,
1757 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1758 "size=%d, duration=%"PRId64", flags=%d\n",
1760 av_ts2str(pkt->pts),
1761 av_ts2str(pkt->dts),
1762 pkt->size, pkt->duration, pkt->flags);
1764 /* A demuxer might have returned EOF because of an IO error, let's
1765 * propagate this back to the user. */
1766 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1772 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1774 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1780 ret = s->internal->packet_buffer
1781 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1782 &s->internal->packet_buffer_end, pkt)
1783 : read_frame_internal(s, pkt);
1790 PacketList *pktl = s->internal->packet_buffer;
1793 AVPacket *next_pkt = &pktl->pkt;
1795 if (next_pkt->dts != AV_NOPTS_VALUE) {
1796 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1797 // last dts seen for this stream. if any of packets following
1798 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1799 int64_t last_dts = next_pkt->dts;
1800 av_assert2(wrap_bits <= 64);
1801 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1802 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1803 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1804 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1806 next_pkt->pts = pktl->pkt.dts;
1808 if (last_dts != AV_NOPTS_VALUE) {
1809 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1810 last_dts = pktl->pkt.dts;
1815 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1816 // Fixing the last reference frame had none pts issue (For MXF etc).
1817 // We only do this when
1819 // 2. we are not able to resolve a pts value for current packet.
1820 // 3. the packets for this stream at the end of the files had valid dts.
1821 next_pkt->pts = last_dts + next_pkt->duration;
1823 pktl = s->internal->packet_buffer;
1826 /* read packet from packet buffer, if there is data */
1827 st = s->streams[next_pkt->stream_index];
1828 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1829 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1830 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1831 &s->internal->packet_buffer_end, pkt);
1836 ret = read_frame_internal(s, pkt);
1838 if (pktl && ret != AVERROR(EAGAIN)) {
1845 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1846 &s->internal->packet_buffer_end,
1849 av_packet_unref(pkt);
1856 st = s->streams[pkt->stream_index];
1857 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1858 ff_reduce_index(s, st->index);
1859 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1862 if (is_relative(pkt->dts))
1863 pkt->dts -= RELATIVE_TS_BASE;
1864 if (is_relative(pkt->pts))
1865 pkt->pts -= RELATIVE_TS_BASE;
1870 /* XXX: suppress the packet queue */
1871 static void flush_packet_queue(AVFormatContext *s)
1875 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1876 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1877 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1879 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1882 /*******************************************************/
1885 int av_find_default_stream_index(AVFormatContext *s)
1889 int best_stream = 0;
1890 int best_score = INT_MIN;
1892 if (s->nb_streams <= 0)
1894 for (i = 0; i < s->nb_streams; i++) {
1897 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1898 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1900 if (st->codecpar->width && st->codecpar->height)
1904 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1905 if (st->codecpar->sample_rate)
1908 if (st->codec_info_nb_frames)
1911 if (st->discard != AVDISCARD_ALL)
1914 if (score > best_score) {
1922 /** Flush the frame reader. */
1923 void ff_read_frame_flush(AVFormatContext *s)
1928 flush_packet_queue(s);
1930 /* Reset read state for each stream. */
1931 for (i = 0; i < s->nb_streams; i++) {
1935 av_parser_close(st->parser);
1938 st->last_IP_pts = AV_NOPTS_VALUE;
1939 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1940 if (st->first_dts == AV_NOPTS_VALUE)
1941 st->cur_dts = RELATIVE_TS_BASE;
1943 /* We set the current DTS to an unspecified origin. */
1944 st->cur_dts = AV_NOPTS_VALUE;
1946 st->probe_packets = s->max_probe_packets;
1948 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1949 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1951 if (s->internal->inject_global_side_data)
1952 st->internal->inject_global_side_data = 1;
1954 st->internal->skip_samples = 0;
1958 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1962 for (i = 0; i < s->nb_streams; i++) {
1963 AVStream *st = s->streams[i];
1966 av_rescale(timestamp,
1967 st->time_base.den * (int64_t) ref_st->time_base.num,
1968 st->time_base.num * (int64_t) ref_st->time_base.den);
1972 void ff_reduce_index(AVFormatContext *s, int stream_index)
1974 AVStream *st = s->streams[stream_index];
1975 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1977 if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1979 for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1980 st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1981 st->internal->nb_index_entries = i;
1985 int ff_add_index_entry(AVIndexEntry **index_entries,
1986 int *nb_index_entries,
1987 unsigned int *index_entries_allocated_size,
1988 int64_t pos, int64_t timestamp,
1989 int size, int distance, int flags)
1991 AVIndexEntry *entries, *ie;
1994 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1997 if (timestamp == AV_NOPTS_VALUE)
1998 return AVERROR(EINVAL);
2000 if (size < 0 || size > 0x3FFFFFFF)
2001 return AVERROR(EINVAL);
2003 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
2004 timestamp -= RELATIVE_TS_BASE;
2006 entries = av_fast_realloc(*index_entries,
2007 index_entries_allocated_size,
2008 (*nb_index_entries + 1) *
2009 sizeof(AVIndexEntry));
2013 *index_entries = entries;
2015 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2016 timestamp, AVSEEK_FLAG_ANY);
2019 index = (*nb_index_entries)++;
2020 ie = &entries[index];
2021 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2023 ie = &entries[index];
2024 if (ie->timestamp != timestamp) {
2025 if (ie->timestamp <= timestamp)
2027 memmove(entries + index + 1, entries + index,
2028 sizeof(AVIndexEntry) * (*nb_index_entries - index));
2029 (*nb_index_entries)++;
2030 } else if (ie->pos == pos && distance < ie->min_distance)
2031 // do not reduce the distance
2032 distance = ie->min_distance;
2036 ie->timestamp = timestamp;
2037 ie->min_distance = distance;
2044 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2045 int size, int distance, int flags)
2047 timestamp = wrap_timestamp(st, timestamp);
2048 return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
2049 &st->internal->index_entries_allocated_size, pos,
2050 timestamp, size, distance, flags);
2053 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2054 int64_t wanted_timestamp, int flags)
2062 // Optimize appending index entries at the end.
2063 if (b && entries[b - 1].timestamp < wanted_timestamp)
2069 // Search for the next non-discarded packet.
2070 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2072 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2078 timestamp = entries[m].timestamp;
2079 if (timestamp >= wanted_timestamp)
2081 if (timestamp <= wanted_timestamp)
2084 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2086 if (!(flags & AVSEEK_FLAG_ANY))
2087 while (m >= 0 && m < nb_entries &&
2088 !(entries[m].flags & AVINDEX_KEYFRAME))
2089 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2091 if (m == nb_entries)
2096 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2099 int64_t pos_delta = 0;
2101 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2102 const char *proto = avio_find_protocol_name(s->url);
2104 av_assert0(time_tolerance >= 0);
2107 av_log(s, AV_LOG_INFO,
2108 "Protocol name not provided, cannot determine if input is local or "
2109 "a network protocol, buffers and access patterns cannot be configured "
2110 "optimally without knowing the protocol\n");
2113 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2116 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2117 AVStream *st1 = s->streams[ist1];
2118 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2119 AVStream *st2 = s->streams[ist2];
2125 for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2126 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2127 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2129 skip = FFMAX(skip, e1->size);
2130 for (; i2 < st2->internal->nb_index_entries; i2++) {
2131 AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2132 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2133 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2135 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2143 /* XXX This could be adjusted depending on protocol*/
2144 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2145 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2147 /* realloc the buffer and the original data will be retained */
2148 if (ffio_realloc_buf(s->pb, pos_delta)) {
2149 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2153 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2156 if (skip < (1<<23)) {
2157 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2161 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2163 return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2164 wanted_timestamp, flags);
2167 int avformat_index_get_entries_count(const AVStream *st)
2169 return st->internal->nb_index_entries;
2172 const AVIndexEntry *avformat_index_get_entry(const AVStream *st, int idx)
2174 if (idx < 0 || idx >= st->internal->nb_index_entries)
2177 return &st->internal->index_entries[idx];
2180 const AVIndexEntry *avformat_index_get_entry_from_timestamp(const AVStream *st,
2181 int64_t wanted_timestamp,
2184 int idx = ff_index_search_timestamp(st->internal->index_entries,
2185 st->internal->nb_index_entries,
2186 wanted_timestamp, flags);
2191 return &st->internal->index_entries[idx];
2194 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2195 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2197 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2198 if (stream_index >= 0)
2199 ts = wrap_timestamp(s->streams[stream_index], ts);
2203 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2204 int64_t target_ts, int flags)
2206 const AVInputFormat *avif = s->iformat;
2207 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2208 int64_t ts_min, ts_max, ts;
2213 if (stream_index < 0)
2216 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2219 ts_min = AV_NOPTS_VALUE;
2220 pos_limit = -1; // GCC falsely says it may be uninitialized.
2222 st = s->streams[stream_index];
2223 if (st->internal->index_entries) {
2226 /* FIXME: Whole function must be checked for non-keyframe entries in
2227 * index case, especially read_timestamp(). */
2228 index = av_index_search_timestamp(st, target_ts,
2229 flags | AVSEEK_FLAG_BACKWARD);
2230 index = FFMAX(index, 0);
2231 e = &st->internal->index_entries[index];
2233 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2235 ts_min = e->timestamp;
2236 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2237 pos_min, av_ts2str(ts_min));
2239 av_assert1(index == 0);
2242 index = av_index_search_timestamp(st, target_ts,
2243 flags & ~AVSEEK_FLAG_BACKWARD);
2244 av_assert0(index < st->internal->nb_index_entries);
2246 e = &st->internal->index_entries[index];
2247 av_assert1(e->timestamp >= target_ts);
2249 ts_max = e->timestamp;
2250 pos_limit = pos_max - e->min_distance;
2251 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2252 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2256 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2257 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2262 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2265 ff_read_frame_flush(s);
2266 ff_update_cur_dts(s, st, ts);
2271 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2272 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2274 int64_t step = 1024;
2275 int64_t limit, ts_max;
2276 int64_t filesize = avio_size(s->pb);
2277 int64_t pos_max = filesize - 1;
2280 pos_max = FFMAX(0, (pos_max) - step);
2281 ts_max = ff_read_timestamp(s, stream_index,
2282 &pos_max, limit, read_timestamp);
2284 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2285 if (ts_max == AV_NOPTS_VALUE)
2289 int64_t tmp_pos = pos_max + 1;
2290 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2291 &tmp_pos, INT64_MAX, read_timestamp);
2292 if (tmp_ts == AV_NOPTS_VALUE)
2294 av_assert0(tmp_pos > pos_max);
2297 if (tmp_pos >= filesize)
2309 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2310 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2311 int64_t ts_min, int64_t ts_max,
2312 int flags, int64_t *ts_ret,
2313 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2314 int64_t *, int64_t))
2321 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2323 if (ts_min == AV_NOPTS_VALUE) {
2324 pos_min = s->internal->data_offset;
2325 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2326 if (ts_min == AV_NOPTS_VALUE)
2330 if (ts_min >= target_ts) {
2335 if (ts_max == AV_NOPTS_VALUE) {
2336 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2338 pos_limit = pos_max;
2341 if (ts_max <= target_ts) {
2346 av_assert0(ts_min < ts_max);
2349 while (pos_min < pos_limit) {
2350 av_log(s, AV_LOG_TRACE,
2351 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2352 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2353 av_assert0(pos_limit <= pos_max);
2355 if (no_change == 0) {
2356 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2357 // interpolate position (better than dichotomy)
2358 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2360 pos_min - approximate_keyframe_distance;
2361 } else if (no_change == 1) {
2362 // bisection if interpolation did not change min / max pos last time
2363 pos = (pos_min + pos_limit) >> 1;
2365 /* linear search if bisection failed, can only happen if there
2366 * are very few or no keyframes between min/max */
2371 else if (pos > pos_limit)
2375 // May pass pos_limit instead of -1.
2376 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2381 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2382 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2383 pos_min, pos, pos_max,
2384 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2385 pos_limit, start_pos, no_change);
2386 if (ts == AV_NOPTS_VALUE) {
2387 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2390 if (target_ts <= ts) {
2391 pos_limit = start_pos - 1;
2395 if (target_ts >= ts) {
2401 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2402 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2405 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2407 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2408 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2409 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2415 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2416 int64_t pos, int flags)
2418 int64_t pos_min, pos_max;
2420 pos_min = s->internal->data_offset;
2421 pos_max = avio_size(s->pb) - 1;
2425 else if (pos > pos_max)
2428 avio_seek(s->pb, pos, SEEK_SET);
2430 s->io_repositioned = 1;
2435 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2436 int64_t timestamp, int flags)
2443 st = s->streams[stream_index];
2445 index = av_index_search_timestamp(st, timestamp, flags);
2447 if (index < 0 && st->internal->nb_index_entries &&
2448 timestamp < st->internal->index_entries[0].timestamp)
2451 if (index < 0 || index == st->internal->nb_index_entries - 1) {
2452 AVPacket *pkt = s->internal->pkt;
2455 if (st->internal->nb_index_entries) {
2456 av_assert0(st->internal->index_entries);
2457 ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2458 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2460 ff_update_cur_dts(s, st, ie->timestamp);
2462 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2465 av_packet_unref(pkt);
2469 read_status = av_read_frame(s, pkt);
2470 } while (read_status == AVERROR(EAGAIN));
2471 if (read_status < 0)
2473 if (stream_index == pkt->stream_index && pkt->dts > timestamp) {
2474 if (pkt->flags & AV_PKT_FLAG_KEY) {
2475 av_packet_unref(pkt);
2478 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2479 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);
2480 av_packet_unref(pkt);
2484 av_packet_unref(pkt);
2486 index = av_index_search_timestamp(st, timestamp, flags);
2491 ff_read_frame_flush(s);
2492 if (s->iformat->read_seek)
2493 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2495 ie = &st->internal->index_entries[index];
2496 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2498 ff_update_cur_dts(s, st, ie->timestamp);
2503 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2504 int64_t timestamp, int flags)
2509 if (flags & AVSEEK_FLAG_BYTE) {
2510 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2512 ff_read_frame_flush(s);
2513 return seek_frame_byte(s, stream_index, timestamp, flags);
2516 if (stream_index < 0) {
2517 stream_index = av_find_default_stream_index(s);
2518 if (stream_index < 0)
2521 st = s->streams[stream_index];
2522 /* timestamp for default must be expressed in AV_TIME_BASE units */
2523 timestamp = av_rescale(timestamp, st->time_base.den,
2524 AV_TIME_BASE * (int64_t) st->time_base.num);
2527 /* first, we try the format specific seek */
2528 if (s->iformat->read_seek) {
2529 ff_read_frame_flush(s);
2530 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2536 if (s->iformat->read_timestamp &&
2537 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2538 ff_read_frame_flush(s);
2539 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2540 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2541 ff_read_frame_flush(s);
2542 return seek_frame_generic(s, stream_index, timestamp, flags);
2547 int av_seek_frame(AVFormatContext *s, int stream_index,
2548 int64_t timestamp, int flags)
2552 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2553 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2554 if ((flags & AVSEEK_FLAG_BACKWARD))
2558 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2559 flags & ~AVSEEK_FLAG_BACKWARD);
2562 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2565 ret = avformat_queue_attached_pictures(s);
2570 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2571 int64_t ts, int64_t max_ts, int flags)
2573 if (min_ts > ts || max_ts < ts)
2575 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2576 return AVERROR(EINVAL);
2579 flags |= AVSEEK_FLAG_ANY;
2580 flags &= ~AVSEEK_FLAG_BACKWARD;
2582 if (s->iformat->read_seek2) {
2584 ff_read_frame_flush(s);
2586 if (stream_index == -1 && s->nb_streams == 1) {
2587 AVRational time_base = s->streams[0]->time_base;
2588 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2589 min_ts = av_rescale_rnd(min_ts, time_base.den,
2590 time_base.num * (int64_t)AV_TIME_BASE,
2591 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2592 max_ts = av_rescale_rnd(max_ts, time_base.den,
2593 time_base.num * (int64_t)AV_TIME_BASE,
2594 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2598 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2602 ret = avformat_queue_attached_pictures(s);
2606 if (s->iformat->read_timestamp) {
2607 // try to seek via read_timestamp()
2610 // Fall back on old API if new is not implemented but old is.
2611 // Note the old API has somewhat different semantics.
2612 if (s->iformat->read_seek || 1) {
2613 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2614 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2615 if (ret<0 && ts != min_ts && max_ts != ts) {
2616 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2618 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2623 // try some generic seek like seek_frame_generic() but with new ts semantics
2624 return -1; //unreachable
2627 int avformat_flush(AVFormatContext *s)
2629 ff_read_frame_flush(s);
2633 /*******************************************************/
2636 * Return TRUE if the stream has accurate duration in any stream.
2638 * @return TRUE if the stream has accurate duration for at least one component.
2640 static int has_duration(AVFormatContext *ic)
2645 for (i = 0; i < ic->nb_streams; i++) {
2646 st = ic->streams[i];
2647 if (st->duration != AV_NOPTS_VALUE)
2650 if (ic->duration != AV_NOPTS_VALUE)
2656 * Estimate the stream timings from the one of each components.
2658 * Also computes the global bitrate if possible.
2660 static void update_stream_timings(AVFormatContext *ic)
2662 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2663 int64_t duration, duration1, duration_text, filesize;
2667 start_time = INT64_MAX;
2668 start_time_text = INT64_MAX;
2669 end_time = INT64_MIN;
2670 end_time_text = INT64_MIN;
2671 duration = INT64_MIN;
2672 duration_text = INT64_MIN;
2674 for (i = 0; i < ic->nb_streams; i++) {
2675 AVStream *st = ic->streams[i];
2676 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2677 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2678 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2679 start_time1 = av_rescale_q(st->start_time, st->time_base,
2682 start_time_text = FFMIN(start_time_text, start_time1);
2684 start_time = FFMIN(start_time, start_time1);
2685 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2687 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2688 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2689 end_time1 += start_time1;
2691 end_time_text = FFMAX(end_time_text, end_time1);
2693 end_time = FFMAX(end_time, end_time1);
2695 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2696 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2697 p->start_time = start_time1;
2698 if (p->end_time < end_time1)
2699 p->end_time = end_time1;
2702 if (st->duration != AV_NOPTS_VALUE) {
2703 duration1 = av_rescale_q(st->duration, st->time_base,
2706 duration_text = FFMAX(duration_text, duration1);
2708 duration = FFMAX(duration, duration1);
2711 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2712 start_time = start_time_text;
2713 else if (start_time > start_time_text)
2714 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2716 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2717 end_time = end_time_text;
2718 else if (end_time < end_time_text)
2719 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2721 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2722 duration = duration_text;
2723 else if (duration < duration_text)
2724 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2726 if (start_time != INT64_MAX) {
2727 ic->start_time = start_time;
2728 if (end_time != INT64_MIN) {
2729 if (ic->nb_programs > 1) {
2730 for (i = 0; i < ic->nb_programs; i++) {
2731 p = ic->programs[i];
2732 if (p->start_time != AV_NOPTS_VALUE &&
2733 p->end_time > p->start_time &&
2734 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2735 duration = FFMAX(duration, p->end_time - p->start_time);
2737 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2738 duration = FFMAX(duration, end_time - start_time);
2742 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2743 ic->duration = duration;
2745 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2746 /* compute the bitrate */
2747 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2748 (double) ic->duration;
2749 if (bitrate >= 0 && bitrate <= INT64_MAX)
2750 ic->bit_rate = bitrate;
2754 static void fill_all_stream_timings(AVFormatContext *ic)
2759 update_stream_timings(ic);
2760 for (i = 0; i < ic->nb_streams; i++) {
2761 st = ic->streams[i];
2762 if (st->start_time == AV_NOPTS_VALUE) {
2763 if (ic->start_time != AV_NOPTS_VALUE)
2764 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2766 if (ic->duration != AV_NOPTS_VALUE)
2767 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2773 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2775 int64_t filesize, duration;
2776 int i, show_warning = 0;
2779 /* if bit_rate is already set, we believe it */
2780 if (ic->bit_rate <= 0) {
2781 int64_t bit_rate = 0;
2782 for (i = 0; i < ic->nb_streams; i++) {
2783 st = ic->streams[i];
2784 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2785 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2786 if (st->codecpar->bit_rate > 0) {
2787 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2791 bit_rate += st->codecpar->bit_rate;
2792 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2793 // If we have a videostream with packets but without a bitrate
2794 // then consider the sum not known
2799 ic->bit_rate = bit_rate;
2802 /* if duration is already set, we believe it */
2803 if (ic->duration == AV_NOPTS_VALUE &&
2804 ic->bit_rate != 0) {
2805 filesize = ic->pb ? avio_size(ic->pb) : 0;
2806 if (filesize > ic->internal->data_offset) {
2807 filesize -= ic->internal->data_offset;
2808 for (i = 0; i < ic->nb_streams; i++) {
2809 st = ic->streams[i];
2810 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2811 && st->duration == AV_NOPTS_VALUE) {
2812 duration = av_rescale(filesize, 8LL * st->time_base.den,
2814 (int64_t) st->time_base.num);
2815 st->duration = duration;
2822 av_log(ic, AV_LOG_WARNING,
2823 "Estimating duration from bitrate, this may be inaccurate\n");
2826 #define DURATION_MAX_READ_SIZE 250000LL
2827 #define DURATION_MAX_RETRY 6
2829 /* only usable for MPEG-PS streams */
2830 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2832 AVPacket *pkt = ic->internal->pkt;
2834 int num, den, read_size, i, ret;
2835 int found_duration = 0;
2837 int64_t filesize, offset, duration;
2840 /* flush packet queue */
2841 flush_packet_queue(ic);
2843 for (i = 0; i < ic->nb_streams; i++) {
2844 st = ic->streams[i];
2845 if (st->start_time == AV_NOPTS_VALUE &&
2846 st->first_dts == AV_NOPTS_VALUE &&
2847 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2848 av_log(ic, AV_LOG_WARNING,
2849 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2852 av_parser_close(st->parser);
2857 if (ic->skip_estimate_duration_from_pts) {
2858 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2859 goto skip_duration_calc;
2862 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2863 /* estimate the end time (duration) */
2864 /* XXX: may need to support wrapping */
2865 filesize = ic->pb ? avio_size(ic->pb) : 0;
2867 is_end = found_duration;
2868 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2872 avio_seek(ic->pb, offset, SEEK_SET);
2875 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2879 ret = ff_read_packet(ic, pkt);
2880 } while (ret == AVERROR(EAGAIN));
2883 read_size += pkt->size;
2884 st = ic->streams[pkt->stream_index];
2885 if (pkt->pts != AV_NOPTS_VALUE &&
2886 (st->start_time != AV_NOPTS_VALUE ||
2887 st->first_dts != AV_NOPTS_VALUE)) {
2888 if (pkt->duration == 0) {
2889 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2891 pkt->duration = av_rescale_rnd(1,
2892 num * (int64_t) st->time_base.den,
2893 den * (int64_t) st->time_base.num,
2897 duration = pkt->pts + pkt->duration;
2899 if (st->start_time != AV_NOPTS_VALUE)
2900 duration -= st->start_time;
2902 duration -= st->first_dts;
2904 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2905 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2906 st->duration = duration;
2907 st->internal->info->last_duration = duration;
2910 av_packet_unref(pkt);
2913 /* check if all audio/video streams have valid duration */
2916 for (i = 0; i < ic->nb_streams; i++) {
2917 st = ic->streams[i];
2918 switch (st->codecpar->codec_type) {
2919 case AVMEDIA_TYPE_VIDEO:
2920 case AVMEDIA_TYPE_AUDIO:
2921 if (st->duration == AV_NOPTS_VALUE)
2928 ++retry <= DURATION_MAX_RETRY);
2930 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2932 /* warn about audio/video streams which duration could not be estimated */
2933 for (i = 0; i < ic->nb_streams; i++) {
2934 st = ic->streams[i];
2935 if (st->duration == AV_NOPTS_VALUE) {
2936 switch (st->codecpar->codec_type) {
2937 case AVMEDIA_TYPE_VIDEO:
2938 case AVMEDIA_TYPE_AUDIO:
2939 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2940 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2942 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2947 fill_all_stream_timings(ic);
2949 avio_seek(ic->pb, old_offset, SEEK_SET);
2950 for (i = 0; i < ic->nb_streams; i++) {
2953 st = ic->streams[i];
2954 st->cur_dts = st->first_dts;
2955 st->last_IP_pts = AV_NOPTS_VALUE;
2956 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2957 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2958 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2962 /* 1:1 map to AVDurationEstimationMethod */
2963 static const char *const duration_name[] = {
2964 [AVFMT_DURATION_FROM_PTS] = "pts",
2965 [AVFMT_DURATION_FROM_STREAM] = "stream",
2966 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2969 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2971 return duration_name[method];
2974 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2978 /* get the file size, if possible */
2979 if (ic->iformat->flags & AVFMT_NOFILE) {
2982 file_size = avio_size(ic->pb);
2983 file_size = FFMAX(0, file_size);
2986 if ((!strcmp(ic->iformat->name, "mpeg") ||
2987 !strcmp(ic->iformat->name, "mpegts")) &&
2988 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2989 /* get accurate estimate from the PTSes */
2990 estimate_timings_from_pts(ic, old_offset);
2991 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2992 } else if (has_duration(ic)) {
2993 /* at least one component has timings - we use them for all
2995 fill_all_stream_timings(ic);
2996 /* nut demuxer estimate the duration from PTS */
2997 if(!strcmp(ic->iformat->name, "nut"))
2998 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
3000 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
3002 /* less precise: use bitrate info */
3003 estimate_timings_from_bit_rate(ic);
3004 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
3006 update_stream_timings(ic);
3008 for (unsigned i = 0; i < ic->nb_streams; i++) {
3009 AVStream *st = ic->streams[i];
3010 if (st->time_base.den)
3011 av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
3012 av_ts2timestr(st->start_time, &st->time_base),
3013 av_ts2timestr(st->duration, &st->time_base));
3015 av_log(ic, AV_LOG_TRACE,
3016 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
3017 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
3018 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
3019 duration_estimate_name(ic->duration_estimation_method),
3020 (int64_t)ic->bit_rate / 1000);
3023 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
3025 AVCodecContext *avctx = st->internal->avctx;
3027 #define FAIL(errmsg) do { \
3029 *errmsg_ptr = errmsg; \
3033 if ( avctx->codec_id == AV_CODEC_ID_NONE
3034 && avctx->codec_type != AVMEDIA_TYPE_DATA)
3035 FAIL("unknown codec");
3036 switch (avctx->codec_type) {
3037 case AVMEDIA_TYPE_AUDIO:
3038 if (!avctx->frame_size && determinable_frame_size(avctx))
3039 FAIL("unspecified frame size");
3040 if (st->internal->info->found_decoder >= 0 &&
3041 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3042 FAIL("unspecified sample format");
3043 if (!avctx->sample_rate)
3044 FAIL("unspecified sample rate");
3045 if (!avctx->channels)
3046 FAIL("unspecified number of channels");
3047 if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3048 FAIL("no decodable DTS frames");
3050 case AVMEDIA_TYPE_VIDEO:
3052 FAIL("unspecified size");
3053 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3054 FAIL("unspecified pixel format");
3055 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3056 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3057 FAIL("no frame in rv30/40 and no sar");
3059 case AVMEDIA_TYPE_SUBTITLE:
3060 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3061 FAIL("unspecified size");
3063 case AVMEDIA_TYPE_DATA:
3064 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3070 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3071 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3072 const AVPacket *avpkt, AVDictionary **options)
3074 AVCodecContext *avctx = st->internal->avctx;
3075 const AVCodec *codec;
3076 int got_picture = 1, ret = 0;
3077 AVFrame *frame = av_frame_alloc();
3078 AVSubtitle subtitle;
3079 AVPacket pkt = *avpkt;
3080 int do_skip_frame = 0;
3081 enum AVDiscard skip_frame;
3084 return AVERROR(ENOMEM);
3086 if (!avcodec_is_open(avctx) &&
3087 st->internal->info->found_decoder <= 0 &&
3088 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3089 AVDictionary *thread_opt = NULL;
3091 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3094 st->internal->info->found_decoder = -st->codecpar->codec_id;
3099 /* Force thread count to 1 since the H.264 decoder will not extract
3100 * SPS and PPS to extradata during multi-threaded decoding. */
3101 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3102 /* Force lowres to 0. The decoder might reduce the video size by the
3103 * lowres factor, and we don't want that propagated to the stream's
3105 av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
3106 if (s->codec_whitelist)
3107 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3108 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3110 av_dict_free(&thread_opt);
3112 st->internal->info->found_decoder = -avctx->codec_id;
3115 st->internal->info->found_decoder = 1;
3116 } else if (!st->internal->info->found_decoder)
3117 st->internal->info->found_decoder = 1;
3119 if (st->internal->info->found_decoder < 0) {
3124 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3126 skip_frame = avctx->skip_frame;
3127 avctx->skip_frame = AVDISCARD_ALL;
3130 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3132 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3133 (!st->codec_info_nb_frames &&
3134 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3136 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3137 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3138 ret = avcodec_send_packet(avctx, &pkt);
3139 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3143 ret = avcodec_receive_frame(avctx, frame);
3146 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3148 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3149 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3150 &got_picture, &pkt);
3152 avsubtitle_free(&subtitle);
3158 st->internal->nb_decoded_frames++;
3163 if (!pkt.data && !got_picture)
3167 if (do_skip_frame) {
3168 avctx->skip_frame = skip_frame;
3171 av_frame_free(&frame);
3175 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3177 while (tags->id != AV_CODEC_ID_NONE) {
3185 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3188 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3189 if (tag == tags[i].tag)
3191 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3192 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3194 return AV_CODEC_ID_NONE;
3197 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3199 if (bps <= 0 || bps > 64)
3200 return AV_CODEC_ID_NONE;
3205 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3207 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3209 return AV_CODEC_ID_NONE;
3214 if (sflags & (1 << (bps - 1))) {
3217 return AV_CODEC_ID_PCM_S8;
3219 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3221 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3223 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3225 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3227 return AV_CODEC_ID_NONE;
3232 return AV_CODEC_ID_PCM_U8;
3234 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3236 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3238 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3240 return AV_CODEC_ID_NONE;
3246 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3249 if (!av_codec_get_tag2(tags, id, &tag))
3254 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3258 for (i = 0; tags && tags[i]; i++) {
3259 const AVCodecTag *codec_tags = tags[i];
3260 while (codec_tags->id != AV_CODEC_ID_NONE) {
3261 if (codec_tags->id == id) {
3262 *tag = codec_tags->tag;
3271 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3274 for (i = 0; tags && tags[i]; i++) {
3275 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3276 if (id != AV_CODEC_ID_NONE)
3279 return AV_CODEC_ID_NONE;
3282 static int chapter_start_cmp(const void *p1, const void *p2)
3284 AVChapter *ch1 = *(AVChapter**)p1;
3285 AVChapter *ch2 = *(AVChapter**)p2;
3286 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3289 return (ch1 > ch2) - (ch1 < ch2);
3292 static int compute_chapters_end(AVFormatContext *s)
3295 int64_t max_time = 0;
3296 AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3299 return AVERROR(ENOMEM);
3301 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3302 max_time = s->duration +
3303 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3305 for (i = 0; i < s->nb_chapters; i++)
3306 timetable[i] = s->chapters[i];
3307 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3309 for (i = 0; i < s->nb_chapters; i++)
3310 if (timetable[i]->end == AV_NOPTS_VALUE) {
3311 AVChapter *ch = timetable[i];
3312 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3316 if (i + 1 < s->nb_chapters) {
3317 AVChapter *ch1 = timetable[i + 1];
3318 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3320 if (next_start > ch->start && next_start < end)
3323 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3329 static int get_std_framerate(int i)
3332 return (i + 1) * 1001;
3336 return (i + 31) * 1001 * 12;
3340 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3344 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3347 /* Is the time base unreliable?
3348 * This is a heuristic to balance between quick acceptance of the values in
3349 * the headers vs. some extra checks.
3350 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3351 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3352 * And there are "variable" fps files this needs to detect as well. */
3353 static int tb_unreliable(AVCodecContext *c)
3355 if (c->time_base.den >= 101LL * c->time_base.num ||
3356 c->time_base.den < 5LL * c->time_base.num ||
3357 // c->codec_tag == AV_RL32("DIVX") ||
3358 // c->codec_tag == AV_RL32("XVID") ||
3359 c->codec_tag == AV_RL32("mp4v") ||
3360 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3361 c->codec_id == AV_CODEC_ID_GIF ||
3362 c->codec_id == AV_CODEC_ID_HEVC ||
3363 c->codec_id == AV_CODEC_ID_H264)
3368 int ff_alloc_extradata(AVCodecParameters *par, int size)
3370 av_freep(&par->extradata);
3371 par->extradata_size = 0;
3373 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3374 return AVERROR(EINVAL);
3376 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3377 if (!par->extradata)
3378 return AVERROR(ENOMEM);
3380 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3381 par->extradata_size = size;
3386 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3388 int ret = ff_alloc_extradata(par, size);
3391 ret = avio_read(pb, par->extradata, size);
3393 av_freep(&par->extradata);
3394 par->extradata_size = 0;
3395 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3396 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3402 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3405 int64_t last = st->internal->info->last_dts;
3407 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3408 && ts - (uint64_t)last < INT64_MAX) {
3409 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3410 int64_t duration = ts - last;
3412 if (!st->internal->info->duration_error)
3413 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3414 if (!st->internal->info->duration_error)
3415 return AVERROR(ENOMEM);
3417 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3418 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3419 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3420 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3421 int framerate = get_std_framerate(i);
3422 double sdts = dts*framerate/(1001*12);
3423 for (j= 0; j<2; j++) {
3424 int64_t ticks = llrint(sdts+j*0.5);
3425 double error= sdts - ticks + j*0.5;
3426 st->internal->info->duration_error[j][0][i] += error;
3427 st->internal->info->duration_error[j][1][i] += error*error;
3431 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3432 st->internal->info->duration_count++;
3433 st->internal->info->rfps_duration_sum += duration;
3436 if (st->internal->info->duration_count % 10 == 0) {
3437 int n = st->internal->info->duration_count;
3438 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3439 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3440 double a0 = st->internal->info->duration_error[0][0][i] / n;
3441 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3442 double a1 = st->internal->info->duration_error[1][0][i] / n;
3443 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3444 if (error0 > 0.04 && error1 > 0.04) {
3445 st->internal->info->duration_error[0][1][i] = 2e10;
3446 st->internal->info->duration_error[1][1][i] = 2e10;
3452 // ignore the first 4 values, they might have some random jitter
3453 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3454 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3456 if (ts != AV_NOPTS_VALUE)
3457 st->internal->info->last_dts = ts;
3462 void ff_rfps_calculate(AVFormatContext *ic)
3466 for (i = 0; i < ic->nb_streams; i++) {
3467 AVStream *st = ic->streams[i];
3469 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3471 // the check for tb_unreliable() is not completely correct, since this is not about handling
3472 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3473 // ipmovie.c produces.
3474 if (tb_unreliable(st->internal->avctx) && st->internal->info->duration_count > 15 && st->internal->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num &&
3475 st->internal->info->duration_gcd < INT64_MAX / st->time_base.num)
3476 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->internal->info->duration_gcd, INT_MAX);
3477 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3478 && tb_unreliable(st->internal->avctx)) {
3480 double best_error= 0.01;
3481 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3483 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3486 if (st->internal->info->codec_info_duration &&
3487 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3489 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3492 if (av_q2d(st->time_base) * st->internal->info->rfps_duration_sum / st->internal->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3495 for (k= 0; k<2; k++) {
3496 int n = st->internal->info->duration_count;
3497 double a= st->internal->info->duration_error[k][0][j] / n;
3498 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3500 if (error < best_error && best_error> 0.000000001) {
3502 num = get_std_framerate(j);
3505 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3508 // do not increase frame rate by more than 1 % in order to match a standard rate.
3509 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3510 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3512 if ( !st->avg_frame_rate.num
3513 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3514 && st->internal->info->codec_info_duration <= 0
3515 && st->internal->info->duration_count > 2
3516 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->internal->info->rfps_duration_sum / (double)st->internal->info->duration_count) <= 1.0
3518 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3519 st->avg_frame_rate = st->r_frame_rate;
3522 av_freep(&st->internal->info->duration_error);
3523 st->internal->info->last_dts = AV_NOPTS_VALUE;
3524 st->internal->info->duration_count = 0;
3525 st->internal->info->rfps_duration_sum = 0;
3529 static int extract_extradata_check(AVStream *st)
3531 const AVBitStreamFilter *f;
3533 f = av_bsf_get_by_name("extract_extradata");
3538 const enum AVCodecID *ids;
3539 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3540 if (*ids == st->codecpar->codec_id)
3547 static int extract_extradata_init(AVStream *st)
3549 AVStreamInternal *sti = st->internal;
3550 const AVBitStreamFilter *f;
3553 f = av_bsf_get_by_name("extract_extradata");
3557 /* check that the codec id is supported */
3558 ret = extract_extradata_check(st);
3562 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3566 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3571 sti->extract_extradata.bsf->time_base_in = st->time_base;
3573 ret = av_bsf_init(sti->extract_extradata.bsf);
3578 sti->extract_extradata.inited = 1;
3582 av_bsf_free(&sti->extract_extradata.bsf);
3586 static int extract_extradata(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
3588 AVStreamInternal *sti = st->internal;
3589 AVPacket *pkt_ref = s->internal->parse_pkt;
3592 if (!sti->extract_extradata.inited) {
3593 ret = extract_extradata_init(st);
3598 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3601 ret = av_packet_ref(pkt_ref, pkt);
3605 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3607 av_packet_unref(pkt_ref);
3611 while (ret >= 0 && !sti->avctx->extradata) {
3612 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3614 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3619 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3620 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3621 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3622 sti->avctx->extradata = side_data->data;
3623 sti->avctx->extradata_size = side_data->size;
3624 side_data->data = NULL;
3625 side_data->size = 0;
3629 av_packet_unref(pkt_ref);
3635 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3639 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3640 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3642 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3644 return AVERROR(ENOMEM);
3645 memcpy(dst_data, sd_src->data, sd_src->size);
3650 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3652 int i, count = 0, ret = 0, j;
3655 AVCodecContext *avctx;
3656 AVPacket *pkt1 = ic->internal->pkt;
3657 int64_t old_offset = avio_tell(ic->pb);
3658 // new streams might appear, no options for those
3659 int orig_nb_streams = ic->nb_streams;
3661 int64_t max_analyze_duration = ic->max_analyze_duration;
3662 int64_t max_stream_analyze_duration;
3663 int64_t max_subtitle_analyze_duration;
3664 int64_t probesize = ic->probesize;
3665 int eof_reached = 0;
3666 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3668 flush_codecs = probesize > 0;
3670 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3672 max_stream_analyze_duration = max_analyze_duration;
3673 max_subtitle_analyze_duration = max_analyze_duration;
3674 if (!max_analyze_duration) {
3675 max_stream_analyze_duration =
3676 max_analyze_duration = 5*AV_TIME_BASE;
3677 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3678 if (!strcmp(ic->iformat->name, "flv"))
3679 max_stream_analyze_duration = 90*AV_TIME_BASE;
3680 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3681 max_stream_analyze_duration = 7*AV_TIME_BASE;
3685 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3686 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3688 for (i = 0; i < ic->nb_streams; i++) {
3689 const AVCodec *codec;
3690 AVDictionary *thread_opt = NULL;
3691 st = ic->streams[i];
3692 avctx = st->internal->avctx;
3694 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3695 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3696 /* if (!st->time_base.num)
3698 if (!avctx->time_base.num)
3699 avctx->time_base = st->time_base;
3702 /* check if the caller has overridden the codec id */
3703 #if FF_API_LAVF_AVCTX
3704 FF_DISABLE_DEPRECATION_WARNINGS
3705 if (st->codec->codec_id != st->internal->orig_codec_id) {
3706 st->codecpar->codec_id = st->codec->codec_id;
3707 st->codecpar->codec_type = st->codec->codec_type;
3708 st->internal->orig_codec_id = st->codec->codec_id;
3710 FF_ENABLE_DEPRECATION_WARNINGS
3712 // only for the split stuff
3713 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3714 st->parser = av_parser_init(st->codecpar->codec_id);
3716 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3717 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3718 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3719 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3721 } else if (st->need_parsing) {
3722 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3723 "%s, packets or times may be invalid.\n",
3724 avcodec_get_name(st->codecpar->codec_id));
3728 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3729 st->internal->orig_codec_id = st->codecpar->codec_id;
3731 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3733 goto find_stream_info_err;
3734 if (st->internal->request_probe <= 0)
3735 st->internal->avctx_inited = 1;
3737 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3739 /* Force thread count to 1 since the H.264 decoder will not extract
3740 * SPS and PPS to extradata during multi-threaded decoding. */
3741 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3742 /* Force lowres to 0. The decoder might reduce the video size by the
3743 * lowres factor, and we don't want that propagated to the stream's
3745 av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
3747 if (ic->codec_whitelist)
3748 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3750 /* Ensure that subtitle_header is properly set. */
3751 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3752 && codec && !avctx->codec) {
3753 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3754 av_log(ic, AV_LOG_WARNING,
3755 "Failed to open codec in %s\n",__FUNCTION__);
3758 // Try to just open decoders, in case this is enough to get parameters.
3759 if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0) {
3760 if (codec && !avctx->codec)
3761 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3762 av_log(ic, AV_LOG_WARNING,
3763 "Failed to open codec in %s\n",__FUNCTION__);
3766 av_dict_free(&thread_opt);
3769 for (i = 0; i < ic->nb_streams; i++) {
3770 #if FF_API_R_FRAME_RATE
3771 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3773 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3774 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3779 const AVPacket *pkt;
3780 int analyzed_all_streams;
3781 if (ff_check_interrupt(&ic->interrupt_callback)) {
3783 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3787 /* check if one codec still needs to be handled */
3788 for (i = 0; i < ic->nb_streams; i++) {
3789 int fps_analyze_framecount = 20;
3792 st = ic->streams[i];
3793 if (!has_codec_parameters(st, NULL))
3795 /* If the timebase is coarse (like the usual millisecond precision
3796 * of mkv), we need to analyze more frames to reliably arrive at
3797 * the correct fps. */
3798 if (av_q2d(st->time_base) > 0.0005)
3799 fps_analyze_framecount *= 2;
3800 if (!tb_unreliable(st->internal->avctx))
3801 fps_analyze_framecount = 0;
3802 if (ic->fps_probe_size >= 0)
3803 fps_analyze_framecount = ic->fps_probe_size;
3804 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3805 fps_analyze_framecount = 0;
3806 /* variable fps and no guess at the real fps */
3807 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3808 st->internal->info->codec_info_duration_fields/2 :
3809 st->internal->info->duration_count;
3810 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3811 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3812 if (count < fps_analyze_framecount)
3815 // Look at the first 3 frames if there is evidence of frame delay
3816 // but the decoder delay is not set.
3817 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3819 if (!st->internal->avctx->extradata &&
3820 (!st->internal->extract_extradata.inited ||
3821 st->internal->extract_extradata.bsf) &&
3822 extract_extradata_check(st))
3824 if (st->first_dts == AV_NOPTS_VALUE &&
3825 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3826 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3827 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3828 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3831 analyzed_all_streams = 0;
3832 if (!missing_streams || !*missing_streams)
3833 if (i == ic->nb_streams) {
3834 analyzed_all_streams = 1;
3835 /* NOTE: If the format has no header, then we need to read some
3836 * packets to get most of the streams, so we cannot stop here. */
3837 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3838 /* If we found the info for all the codecs, we can stop. */
3840 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3845 /* We did not get all the codec info, but we read too much data. */
3846 if (read_size >= probesize) {
3848 av_log(ic, AV_LOG_DEBUG,
3849 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3850 for (i = 0; i < ic->nb_streams; i++)
3851 if (!ic->streams[i]->r_frame_rate.num &&
3852 ic->streams[i]->internal->info->duration_count <= 1 &&
3853 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3854 strcmp(ic->iformat->name, "image2"))
3855 av_log(ic, AV_LOG_WARNING,
3856 "Stream #%d: not enough frames to estimate rate; "
3857 "consider increasing probesize\n", i);
3861 /* NOTE: A new stream can be added there if no header in file
3862 * (AVFMTCTX_NOHEADER). */
3863 ret = read_frame_internal(ic, pkt1);
3864 if (ret == AVERROR(EAGAIN))
3873 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3874 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3875 &ic->internal->packet_buffer_end,
3878 goto unref_then_goto_end;
3880 pkt = &ic->internal->packet_buffer_end->pkt;
3885 st = ic->streams[pkt->stream_index];
3886 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3887 read_size += pkt->size;
3889 avctx = st->internal->avctx;
3890 if (!st->internal->avctx_inited) {
3891 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3893 goto unref_then_goto_end;
3894 st->internal->avctx_inited = 1;
3897 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3898 /* check for non-increasing dts */
3899 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3900 st->internal->info->fps_last_dts >= pkt->dts) {
3901 av_log(ic, AV_LOG_DEBUG,
3902 "Non-increasing DTS in stream %d: packet %d with DTS "
3903 "%"PRId64", packet %d with DTS %"PRId64"\n",
3904 st->index, st->internal->info->fps_last_dts_idx,
3905 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3907 st->internal->info->fps_first_dts =
3908 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3910 /* Check for a discontinuity in dts. If the difference in dts
3911 * is more than 1000 times the average packet duration in the
3912 * sequence, we treat it as a discontinuity. */
3913 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3914 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3915 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3916 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3917 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3918 av_log(ic, AV_LOG_WARNING,
3919 "DTS discontinuity in stream %d: packet %d with DTS "
3920 "%"PRId64", packet %d with DTS %"PRId64"\n",
3921 st->index, st->internal->info->fps_last_dts_idx,
3922 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3924 st->internal->info->fps_first_dts =
3925 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3928 /* update stored dts values */
3929 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3930 st->internal->info->fps_first_dts = pkt->dts;
3931 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3933 st->internal->info->fps_last_dts = pkt->dts;
3934 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3936 if (st->codec_info_nb_frames>1) {
3940 if (st->time_base.den > 0)
3941 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3942 if (st->avg_frame_rate.num > 0)
3943 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3946 && st->codec_info_nb_frames>30
3947 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3948 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE) {
3949 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3950 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3953 if (analyzed_all_streams) limit = max_analyze_duration;
3954 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3955 else limit = max_stream_analyze_duration;
3958 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3960 t, pkt->stream_index);
3961 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3962 av_packet_unref(pkt1);
3965 if (pkt->duration) {
3966 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3967 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3969 st->internal->info->codec_info_duration += pkt->duration;
3970 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3973 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3974 #if FF_API_R_FRAME_RATE
3975 ff_rfps_add_frame(ic, st, pkt->dts);
3977 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3978 st->internal->info->frame_delay_evidence = 1;
3980 if (!st->internal->avctx->extradata) {
3981 ret = extract_extradata(ic, st, pkt);
3983 goto unref_then_goto_end;
3986 /* If still no information, we try to open the codec and to
3987 * decompress the frame. We try to avoid that in most cases as
3988 * it takes longer and uses more memory. For MPEG-4, we need to
3989 * decompress for QuickTime.
3991 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3992 * least one frame of codec data, this makes sure the codec initializes
3993 * the channel configuration and does not only trust the values from
3995 try_decode_frame(ic, st, pkt,
3996 (options && i < orig_nb_streams) ? &options[i] : NULL);
3998 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3999 av_packet_unref(pkt1);
4001 st->codec_info_nb_frames++;
4007 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
4008 st = ic->streams[stream_index];
4009 avctx = st->internal->avctx;
4010 if (!has_codec_parameters(st, NULL)) {
4011 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
4012 if (codec && !avctx->codec) {
4013 AVDictionary *opts = NULL;
4014 if (ic->codec_whitelist)
4015 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
4016 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
4017 av_log(ic, AV_LOG_WARNING,
4018 "Failed to open codec in %s\n",__FUNCTION__);
4019 av_dict_free(&opts);
4023 // EOF already reached while reading the stream above.
4024 // So continue with reoordering DTS with whatever delay we have.
4025 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
4026 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
4032 AVPacket *empty_pkt = ic->internal->pkt;
4034 av_packet_unref(empty_pkt);
4036 for (i = 0; i < ic->nb_streams; i++) {
4038 st = ic->streams[i];
4040 /* flush the decoders */
4041 if (st->internal->info->found_decoder == 1) {
4043 err = try_decode_frame(ic, st, empty_pkt,
4044 (options && i < orig_nb_streams)
4045 ? &options[i] : NULL);
4046 } while (err > 0 && !has_codec_parameters(st, NULL));
4049 av_log(ic, AV_LOG_INFO,
4050 "decoding for stream %d failed\n", st->index);
4056 ff_rfps_calculate(ic);
4058 for (i = 0; i < ic->nb_streams; i++) {
4059 st = ic->streams[i];
4060 avctx = st->internal->avctx;
4061 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4062 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4063 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4064 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4065 avctx->codec_tag= tag;
4068 /* estimate average framerate if not set by demuxer */
4069 if (st->internal->info->codec_info_duration_fields &&
4070 !st->avg_frame_rate.num &&
4071 st->internal->info->codec_info_duration) {
4073 double best_error = 0.01;
4074 AVRational codec_frame_rate = avctx->framerate;
4076 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4077 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4078 st->internal->info->codec_info_duration < 0)
4080 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4081 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4082 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4084 /* Round guessed framerate to a "standard" framerate if it's
4085 * within 1% of the original estimate. */
4086 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4087 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4088 double error = fabs(av_q2d(st->avg_frame_rate) /
4089 av_q2d(std_fps) - 1);
4091 if (error < best_error) {
4093 best_fps = std_fps.num;
4096 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4097 error = fabs(av_q2d(codec_frame_rate) /
4098 av_q2d(std_fps) - 1);
4099 if (error < best_error) {
4101 best_fps = std_fps.num;
4106 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4107 best_fps, 12 * 1001, INT_MAX);
4110 if (!st->r_frame_rate.num) {
4111 if ( avctx->time_base.den * (int64_t) st->time_base.num
4112 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4113 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4114 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4116 st->r_frame_rate.num = st->time_base.den;
4117 st->r_frame_rate.den = st->time_base.num;
4120 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4121 AVRational hw_ratio = { avctx->height, avctx->width };
4122 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4125 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4126 if (!avctx->bits_per_coded_sample)
4127 avctx->bits_per_coded_sample =
4128 av_get_bits_per_sample(avctx->codec_id);
4129 // set stream disposition based on audio service type
4130 switch (avctx->audio_service_type) {
4131 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4132 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4134 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4135 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4137 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4138 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4140 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4141 st->disposition = AV_DISPOSITION_COMMENT;
4143 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4144 st->disposition = AV_DISPOSITION_KARAOKE;
4151 estimate_timings(ic, old_offset);
4153 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4155 if (ret >= 0 && ic->nb_streams)
4156 /* We could not have all the codec parameters before EOF. */
4158 for (i = 0; i < ic->nb_streams; i++) {
4160 st = ic->streams[i];
4162 /* if no packet was ever seen, update context now for has_codec_parameters */
4163 if (!st->internal->avctx_inited) {
4164 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4165 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4166 st->codecpar->format = st->internal->avctx->sample_fmt;
4167 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4169 goto find_stream_info_err;
4171 if (!has_codec_parameters(st, &errmsg)) {
4173 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4174 av_log(ic, AV_LOG_WARNING,
4175 "Could not find codec parameters for stream %d (%s): %s\n"
4176 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4177 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4183 ret = compute_chapters_end(ic);
4185 goto find_stream_info_err;
4187 /* update the stream parameters from the internal codec contexts */
4188 for (i = 0; i < ic->nb_streams; i++) {
4189 st = ic->streams[i];
4191 if (st->internal->avctx_inited) {
4192 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4194 goto find_stream_info_err;
4195 ret = add_coded_side_data(st, st->internal->avctx);
4197 goto find_stream_info_err;
4200 #if FF_API_LAVF_AVCTX
4201 FF_DISABLE_DEPRECATION_WARNINGS
4202 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4204 goto find_stream_info_err;
4206 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4207 // by the lowres factor.
4208 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4209 st->codec->lowres = st->internal->avctx->lowres;
4210 st->codec->width = st->internal->avctx->width;
4211 st->codec->height = st->internal->avctx->height;
4214 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4215 st->codec->time_base = st->internal->avctx->time_base;
4216 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4218 st->codec->framerate = st->avg_frame_rate;
4220 if (st->internal->avctx->subtitle_header) {
4221 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4222 if (!st->codec->subtitle_header)
4223 goto find_stream_info_err;
4224 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4225 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4226 st->codec->subtitle_header_size);
4229 // Fields unavailable in AVCodecParameters
4230 st->codec->coded_width = st->internal->avctx->coded_width;
4231 st->codec->coded_height = st->internal->avctx->coded_height;
4232 st->codec->properties = st->internal->avctx->properties;
4233 FF_ENABLE_DEPRECATION_WARNINGS
4236 st->internal->avctx_inited = 0;
4239 find_stream_info_err:
4240 for (i = 0; i < ic->nb_streams; i++) {
4241 st = ic->streams[i];
4242 if (st->internal->info)
4243 av_freep(&st->internal->info->duration_error);
4244 avcodec_close(ic->streams[i]->internal->avctx);
4245 av_freep(&ic->streams[i]->internal->info);
4246 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4249 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4250 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4253 unref_then_goto_end:
4254 av_packet_unref(pkt1);
4255 goto find_stream_info_err;
4258 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4262 for (i = 0; i < ic->nb_programs; i++) {
4263 if (ic->programs[i] == last) {
4267 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4268 if (ic->programs[i]->stream_index[j] == s)
4269 return ic->programs[i];
4275 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4276 int wanted_stream_nb, int related_stream,
4277 AVCodec **decoder_ret, int flags)
4279 int i, nb_streams = ic->nb_streams;
4280 int ret = AVERROR_STREAM_NOT_FOUND;
4281 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4282 int count, multiframe, disposition;
4283 int64_t best_bitrate = -1;
4285 unsigned *program = NULL;
4286 const AVCodec *decoder = NULL, *best_decoder = NULL;
4288 if (related_stream >= 0 && wanted_stream_nb < 0) {
4289 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4291 program = p->stream_index;
4292 nb_streams = p->nb_stream_indexes;
4295 for (i = 0; i < nb_streams; i++) {
4296 int real_stream_index = program ? program[i] : i;
4297 AVStream *st = ic->streams[real_stream_index];
4298 AVCodecParameters *par = st->codecpar;
4299 if (par->codec_type != type)
4301 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4303 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4306 decoder = find_decoder(ic, st, par->codec_id);
4309 ret = AVERROR_DECODER_NOT_FOUND;
4313 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4314 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4315 count = st->codec_info_nb_frames;
4316 bitrate = par->bit_rate;
4317 multiframe = FFMIN(5, count);
4318 if ((best_disposition > disposition) ||
4319 (best_disposition == disposition && best_multiframe > multiframe) ||
4320 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4321 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4323 best_disposition = disposition;
4325 best_bitrate = bitrate;
4326 best_multiframe = multiframe;
4327 ret = real_stream_index;
4328 best_decoder = decoder;
4329 if (program && i == nb_streams - 1 && ret < 0) {
4331 nb_streams = ic->nb_streams;
4332 /* no related stream found, try again with everything */
4337 *decoder_ret = (AVCodec*)best_decoder;
4341 /*******************************************************/
4343 int av_read_play(AVFormatContext *s)
4345 if (s->iformat->read_play)
4346 return s->iformat->read_play(s);
4348 return avio_pause(s->pb, 0);
4349 return AVERROR(ENOSYS);
4352 int av_read_pause(AVFormatContext *s)
4354 if (s->iformat->read_pause)
4355 return s->iformat->read_pause(s);
4357 return avio_pause(s->pb, 1);
4358 return AVERROR(ENOSYS);
4361 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4366 dst->time_base = src->time_base;
4367 dst->nb_frames = src->nb_frames;
4368 dst->disposition = src->disposition;
4369 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4370 dst->avg_frame_rate = src->avg_frame_rate;
4371 dst->r_frame_rate = src->r_frame_rate;
4373 av_dict_free(&dst->metadata);
4374 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4378 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4382 /* Free existing side data*/
4383 for (i = 0; i < dst->nb_side_data; i++)
4384 av_free(dst->side_data[i].data);
4385 av_freep(&dst->side_data);
4386 dst->nb_side_data = 0;
4388 /* Copy side data if present */
4389 if (src->nb_side_data) {
4390 dst->side_data = av_mallocz_array(src->nb_side_data,
4391 sizeof(AVPacketSideData));
4392 if (!dst->side_data)
4393 return AVERROR(ENOMEM);
4394 dst->nb_side_data = src->nb_side_data;
4396 for (i = 0; i < src->nb_side_data; i++) {
4397 uint8_t *data = av_memdup(src->side_data[i].data,
4398 src->side_data[i].size);
4400 return AVERROR(ENOMEM);
4401 dst->side_data[i].type = src->side_data[i].type;
4402 dst->side_data[i].size = src->side_data[i].size;
4403 dst->side_data[i].data = data;
4407 #if FF_API_LAVF_FFSERVER
4408 FF_DISABLE_DEPRECATION_WARNINGS
4409 av_freep(&dst->recommended_encoder_configuration);
4410 if (src->recommended_encoder_configuration) {
4411 const char *conf_str = src->recommended_encoder_configuration;
4412 dst->recommended_encoder_configuration = av_strdup(conf_str);
4413 if (!dst->recommended_encoder_configuration)
4414 return AVERROR(ENOMEM);
4416 FF_ENABLE_DEPRECATION_WARNINGS
4422 static void free_stream(AVStream **pst)
4424 AVStream *st = *pst;
4430 for (i = 0; i < st->nb_side_data; i++)
4431 av_freep(&st->side_data[i].data);
4432 av_freep(&st->side_data);
4435 av_parser_close(st->parser);
4437 if (st->attached_pic.data)
4438 av_packet_unref(&st->attached_pic);
4441 avcodec_free_context(&st->internal->avctx);
4442 av_bsf_free(&st->internal->bsfc);
4443 av_freep(&st->internal->priv_pts);
4444 av_freep(&st->internal->index_entries);
4445 av_freep(&st->internal->probe_data.buf);
4447 av_bsf_free(&st->internal->extract_extradata.bsf);
4449 if (st->internal->info)
4450 av_freep(&st->internal->info->duration_error);
4451 av_freep(&st->internal->info);
4453 av_freep(&st->internal);
4455 av_dict_free(&st->metadata);
4456 avcodec_parameters_free(&st->codecpar);
4457 #if FF_API_LAVF_AVCTX
4458 FF_DISABLE_DEPRECATION_WARNINGS
4459 avcodec_free_context(&st->codec);
4460 FF_ENABLE_DEPRECATION_WARNINGS
4462 av_freep(&st->priv_data);
4463 #if FF_API_LAVF_FFSERVER
4464 FF_DISABLE_DEPRECATION_WARNINGS
4465 av_freep(&st->recommended_encoder_configuration);
4466 FF_ENABLE_DEPRECATION_WARNINGS
4472 void ff_free_stream(AVFormatContext *s, AVStream *st)
4474 av_assert0(s->nb_streams>0);
4475 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4477 free_stream(&s->streams[ --s->nb_streams ]);
4480 void avformat_free_context(AVFormatContext *s)
4487 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4488 s->oformat->deinit(s);
4491 if (s->iformat && s->iformat->priv_class && s->priv_data)
4492 av_opt_free(s->priv_data);
4493 if (s->oformat && s->oformat->priv_class && s->priv_data)
4494 av_opt_free(s->priv_data);
4496 for (i = 0; i < s->nb_streams; i++)
4497 free_stream(&s->streams[i]);
4500 for (i = 0; i < s->nb_programs; i++) {
4501 av_dict_free(&s->programs[i]->metadata);
4502 av_freep(&s->programs[i]->stream_index);
4503 av_freep(&s->programs[i]);
4507 av_freep(&s->programs);
4508 av_freep(&s->priv_data);
4509 while (s->nb_chapters--) {
4510 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4511 av_freep(&s->chapters[s->nb_chapters]);
4513 av_freep(&s->chapters);
4514 av_dict_free(&s->metadata);
4515 av_dict_free(&s->internal->id3v2_meta);
4516 av_packet_free(&s->internal->pkt);
4517 av_packet_free(&s->internal->parse_pkt);
4518 av_freep(&s->streams);
4519 flush_packet_queue(s);
4520 av_freep(&s->internal);
4525 void avformat_close_input(AVFormatContext **ps)
4536 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4537 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4540 flush_packet_queue(s);
4543 if (s->iformat->read_close)
4544 s->iformat->read_close(s);
4546 avformat_free_context(s);
4553 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4559 if (s->nb_streams >= s->max_streams) {
4560 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
4561 " (%d), see the documentation if you wish to increase it\n",
4565 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4568 s->streams = streams;
4570 st = av_mallocz(sizeof(AVStream));
4574 #if FF_API_LAVF_AVCTX
4575 FF_DISABLE_DEPRECATION_WARNINGS
4576 st->codec = avcodec_alloc_context3(c);
4581 FF_ENABLE_DEPRECATION_WARNINGS
4584 st->internal = av_mallocz(sizeof(*st->internal));
4588 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4589 if (!st->internal->info)
4591 st->internal->info->last_dts = AV_NOPTS_VALUE;
4593 st->codecpar = avcodec_parameters_alloc();
4597 st->internal->avctx = avcodec_alloc_context3(NULL);
4598 if (!st->internal->avctx)
4602 #if FF_API_LAVF_AVCTX
4603 FF_DISABLE_DEPRECATION_WARNINGS
4604 /* no default bitrate if decoding */
4605 st->codec->bit_rate = 0;
4606 FF_ENABLE_DEPRECATION_WARNINGS
4609 /* default pts setting is MPEG-like */
4610 avpriv_set_pts_info(st, 33, 1, 90000);
4611 /* we set the current DTS to 0 so that formats without any timestamps
4612 * but durations get some timestamps, formats with some unknown
4613 * timestamps have their first few packets buffered and the
4614 * timestamps corrected before they are returned to the user */
4615 st->cur_dts = RELATIVE_TS_BASE;
4617 st->cur_dts = AV_NOPTS_VALUE;
4620 st->index = s->nb_streams;
4621 st->start_time = AV_NOPTS_VALUE;
4622 st->duration = AV_NOPTS_VALUE;
4623 st->first_dts = AV_NOPTS_VALUE;
4624 st->probe_packets = s->max_probe_packets;
4625 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4626 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4628 st->last_IP_pts = AV_NOPTS_VALUE;
4629 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4630 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4631 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4633 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4635 #if FF_API_R_FRAME_RATE
4636 st->internal->info->last_dts = AV_NOPTS_VALUE;
4638 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4639 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4641 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4643 st->internal->need_context_update = 1;
4645 s->streams[s->nb_streams++] = st;
4652 AVProgram *av_new_program(AVFormatContext *ac, int id)
4654 AVProgram *program = NULL;
4657 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4659 for (i = 0; i < ac->nb_programs; i++)
4660 if (ac->programs[i]->id == id)
4661 program = ac->programs[i];
4664 program = av_mallocz(sizeof(AVProgram));
4667 ret = av_dynarray_add_nofree(&ac->programs, &ac->nb_programs, program);
4672 program->discard = AVDISCARD_NONE;
4673 program->pmt_version = -1;
4675 program->pts_wrap_reference = AV_NOPTS_VALUE;
4676 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4677 program->start_time =
4678 program->end_time = AV_NOPTS_VALUE;
4683 #if FF_API_CHAPTER_ID_INT
4684 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4686 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
4688 int64_t start, int64_t end, const char *title)
4690 AVChapter *chapter = NULL;
4693 if (end != AV_NOPTS_VALUE && start > end) {
4694 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4698 if (!s->nb_chapters) {
4699 s->internal->chapter_ids_monotonic = 1;
4700 } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4701 s->internal->chapter_ids_monotonic = 0;
4702 for (i = 0; i < s->nb_chapters; i++)
4703 if (s->chapters[i]->id == id)
4704 chapter = s->chapters[i];
4708 chapter = av_mallocz(sizeof(AVChapter));
4711 ret = av_dynarray_add_nofree(&s->chapters, &s->nb_chapters, chapter);
4717 av_dict_set(&chapter->metadata, "title", title, 0);
4719 chapter->time_base = time_base;
4720 chapter->start = start;
4726 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4729 AVProgram *program = NULL;
4732 if (idx >= ac->nb_streams) {
4733 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4737 for (i = 0; i < ac->nb_programs; i++) {
4738 if (ac->programs[i]->id != progid)
4740 program = ac->programs[i];
4741 for (j = 0; j < program->nb_stream_indexes; j++)
4742 if (program->stream_index[j] == idx)
4745 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4748 program->stream_index = tmp;
4749 program->stream_index[program->nb_stream_indexes++] = idx;
4754 uint64_t ff_ntp_time(void)
4756 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4759 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4761 uint64_t ntp_ts, frac_part, sec;
4764 //current ntp time in seconds and micro seconds
4765 sec = ntp_time_us / 1000000;
4766 usec = ntp_time_us % 1000000;
4768 //encoding in ntp timestamp format
4769 frac_part = usec * 0xFFFFFFFFULL;
4770 frac_part /= 1000000;
4772 if (sec > 0xFFFFFFFFULL)
4773 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4776 ntp_ts |= frac_part;
4781 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
4783 uint64_t sec = ntp_ts >> 32;
4784 uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
4785 uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
4787 return (sec * 1000000) + usec;
4790 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4793 char *q, buf1[20], c;
4794 int nd, len, percentd_found;
4806 while (av_isdigit(*p)) {
4807 if (nd >= INT_MAX / 10 - 255)
4809 nd = nd * 10 + *p++ - '0';
4812 } while (av_isdigit(c));
4818 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4823 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4825 if ((q - buf + len) > buf_size - 1)
4827 memcpy(q, buf1, len);
4835 if ((q - buf) < buf_size - 1)
4839 if (!percentd_found)
4848 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4850 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4853 void av_url_split(char *proto, int proto_size,
4854 char *authorization, int authorization_size,
4855 char *hostname, int hostname_size,
4856 int *port_ptr, char *path, int path_size, const char *url)
4858 const char *p, *ls, *at, *at2, *col, *brk;
4864 if (authorization_size > 0)
4865 authorization[0] = 0;
4866 if (hostname_size > 0)
4871 /* parse protocol */
4872 if ((p = strchr(url, ':'))) {
4873 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4880 /* no protocol means plain filename */
4881 av_strlcpy(path, url, path_size);
4885 /* separate path from hostname */
4886 ls = p + strcspn(p, "/?#");
4887 av_strlcpy(path, ls, path_size);
4889 /* the rest is hostname, use that to parse auth/port */
4891 /* authorization (user[:pass]@hostname) */
4893 while ((at = strchr(p, '@')) && at < ls) {
4894 av_strlcpy(authorization, at2,
4895 FFMIN(authorization_size, at + 1 - at2));
4896 p = at + 1; /* skip '@' */
4899 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4901 av_strlcpy(hostname, p + 1,
4902 FFMIN(hostname_size, brk - p));
4903 if (brk[1] == ':' && port_ptr)
4904 *port_ptr = atoi(brk + 2);
4905 } else if ((col = strchr(p, ':')) && col < ls) {
4906 av_strlcpy(hostname, p,
4907 FFMIN(col + 1 - p, hostname_size));
4909 *port_ptr = atoi(col + 1);
4911 av_strlcpy(hostname, p,
4912 FFMIN(ls + 1 - p, hostname_size));
4916 int ff_mkdir_p(const char *path)
4919 char *temp = av_strdup(path);
4923 if (!path || !temp) {
4927 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4929 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4933 for ( ; *pos != '\0'; ++pos) {
4934 if (*pos == '/' || *pos == '\\') {
4937 ret = mkdir(temp, 0755);
4942 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4943 ret = mkdir(temp, 0755);
4950 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4953 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4956 'C', 'D', 'E', 'F' };
4957 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4960 'c', 'd', 'e', 'f' };
4961 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4963 for (i = 0; i < s; i++) {
4964 buff[i * 2] = hex_table[src[i] >> 4];
4965 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4971 int ff_hex_to_data(uint8_t *data, const char *p)
4978 p += strspn(p, SPACE_CHARS);
4981 c = av_toupper((unsigned char) *p++);
4982 if (c >= '0' && c <= '9')
4984 else if (c >= 'A' && c <= 'F')
4999 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
5000 unsigned int pts_num, unsigned int pts_den)
5003 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
5004 if (new_tb.num != pts_num)
5005 av_log(NULL, AV_LOG_DEBUG,
5006 "st:%d removing common factor %d from timebase\n",
5007 s->index, pts_num / new_tb.num);
5009 av_log(NULL, AV_LOG_WARNING,
5010 "st:%d has too large timebase, reducing\n", s->index);
5012 if (new_tb.num <= 0 || new_tb.den <= 0) {
5013 av_log(NULL, AV_LOG_ERROR,
5014 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
5015 new_tb.num, new_tb.den,
5019 s->time_base = new_tb;
5020 #if FF_API_LAVF_AVCTX
5021 FF_DISABLE_DEPRECATION_WARNINGS
5022 s->codec->pkt_timebase = new_tb;
5023 FF_ENABLE_DEPRECATION_WARNINGS
5025 s->internal->avctx->pkt_timebase = new_tb;
5026 s->pts_wrap_bits = pts_wrap_bits;
5029 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
5032 const char *ptr = str;
5034 /* Parse key=value pairs. */
5037 char *dest = NULL, *dest_end;
5038 int key_len, dest_len = 0;
5040 /* Skip whitespace and potential commas. */
5041 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
5048 if (!(ptr = strchr(key, '=')))
5051 key_len = ptr - key;
5053 callback_get_buf(context, key, key_len, &dest, &dest_len);
5054 dest_end = dest + dest_len - 1;
5058 while (*ptr && *ptr != '\"') {
5062 if (dest && dest < dest_end)
5066 if (dest && dest < dest_end)
5074 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5075 if (dest && dest < dest_end)
5083 int ff_find_stream_index(AVFormatContext *s, int id)
5086 for (i = 0; i < s->nb_streams; i++)
5087 if (s->streams[i]->id == id)
5092 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5096 unsigned int codec_tag;
5097 if (ofmt->query_codec)
5098 return ofmt->query_codec(codec_id, std_compliance);
5099 else if (ofmt->codec_tag)
5100 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5101 else if (codec_id == ofmt->video_codec ||
5102 codec_id == ofmt->audio_codec ||
5103 codec_id == ofmt->subtitle_codec ||
5104 codec_id == ofmt->data_codec)
5107 return AVERROR_PATCHWELCOME;
5110 int avformat_network_init(void)
5114 if ((ret = ff_network_init()) < 0)
5116 if ((ret = ff_tls_init()) < 0)
5122 int avformat_network_deinit(void)
5131 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5132 uint64_t channel_layout, int32_t sample_rate,
5133 int32_t width, int32_t height)
5139 return AVERROR(EINVAL);
5142 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5144 if (channel_layout) {
5146 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5150 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5152 if (width || height) {
5154 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5156 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5158 return AVERROR(ENOMEM);
5159 bytestream_put_le32(&data, flags);
5161 bytestream_put_le32(&data, channels);
5163 bytestream_put_le64(&data, channel_layout);
5165 bytestream_put_le32(&data, sample_rate);
5166 if (width || height) {
5167 bytestream_put_le32(&data, width);
5168 bytestream_put_le32(&data, height);
5173 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5175 AVRational undef = {0, 1};
5176 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5177 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5178 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5180 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5181 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5182 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5183 stream_sample_aspect_ratio = undef;
5185 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5186 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5187 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5188 frame_sample_aspect_ratio = undef;
5190 if (stream_sample_aspect_ratio.num)
5191 return stream_sample_aspect_ratio;
5193 return frame_sample_aspect_ratio;
5196 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5198 AVRational fr = st->r_frame_rate;
5199 AVRational codec_fr = st->internal->avctx->framerate;
5200 AVRational avg_fr = st->avg_frame_rate;
5202 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5203 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5208 if (st->internal->avctx->ticks_per_frame > 1) {
5209 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5210 (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))
5218 * Matches a stream specifier (but ignores requested index).
5220 * @param indexptr set to point to the requested stream index if there is one
5222 * @return <0 on error
5223 * 0 if st is NOT a matching stream
5224 * >0 if st is a matching stream
5226 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5227 const char *spec, const char **indexptr, AVProgram **p)
5229 int match = 1; /* Stores if the specifier matches so far. */
5231 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5235 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5236 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5237 enum AVMediaType type;
5241 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5242 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5243 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5244 case 'd': type = AVMEDIA_TYPE_DATA; break;
5245 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5246 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5247 default: av_assert0(0);
5249 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5250 return AVERROR(EINVAL);
5252 #if FF_API_LAVF_AVCTX
5253 FF_DISABLE_DEPRECATION_WARNINGS
5254 if (type != st->codecpar->codec_type
5255 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5257 FF_ENABLE_DEPRECATION_WARNINGS
5259 if (type != st->codecpar->codec_type)
5262 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5264 } else if (*spec == 'p' && *(spec + 1) == ':') {
5269 prog_id = strtol(spec, &endptr, 0);
5270 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5271 if (spec == endptr || (*endptr && *endptr++ != ':'))
5272 return AVERROR(EINVAL);
5275 for (i = 0; i < s->nb_programs; i++) {
5276 if (s->programs[i]->id != prog_id)
5279 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5280 if (st->index == s->programs[i]->stream_index[j]) {
5283 *p = s->programs[i];
5292 } else if (*spec == '#' ||
5293 (*spec == 'i' && *(spec + 1) == ':')) {
5296 spec += 1 + (*spec == 'i');
5297 stream_id = strtol(spec, &endptr, 0);
5298 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5299 return AVERROR(EINVAL);
5300 return match && (stream_id == st->id);
5301 } else if (*spec == 'm' && *(spec + 1) == ':') {
5302 AVDictionaryEntry *tag;
5308 val = strchr(spec, ':');
5310 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5312 return AVERROR(ENOMEM);
5314 tag = av_dict_get(st->metadata, key, NULL, 0);
5316 if (!val || !strcmp(tag->value, val + 1))
5325 return match && ret;
5326 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5327 AVCodecParameters *par = st->codecpar;
5328 #if FF_API_LAVF_AVCTX
5329 FF_DISABLE_DEPRECATION_WARNINGS
5330 AVCodecContext *codec = st->codec;
5331 FF_ENABLE_DEPRECATION_WARNINGS
5334 switch (par->codec_type) {
5335 case AVMEDIA_TYPE_AUDIO:
5336 val = par->sample_rate && par->channels;
5337 #if FF_API_LAVF_AVCTX
5338 val = val || (codec->sample_rate && codec->channels);
5340 if (par->format == AV_SAMPLE_FMT_NONE
5341 #if FF_API_LAVF_AVCTX
5342 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5347 case AVMEDIA_TYPE_VIDEO:
5348 val = par->width && par->height;
5349 #if FF_API_LAVF_AVCTX
5350 val = val || (codec->width && codec->height);
5352 if (par->format == AV_PIX_FMT_NONE
5353 #if FF_API_LAVF_AVCTX
5354 && codec->pix_fmt == AV_PIX_FMT_NONE
5359 case AVMEDIA_TYPE_UNKNOWN:
5366 #if FF_API_LAVF_AVCTX
5367 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5369 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5372 return AVERROR(EINVAL);
5380 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5385 const char *indexptr = NULL;
5386 AVProgram *p = NULL;
5389 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5396 index = strtol(indexptr, &endptr, 0);
5397 if (*endptr) { /* We can't have anything after the requested index. */
5398 ret = AVERROR(EINVAL);
5402 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5403 if (spec == indexptr)
5404 return (index == st->index);
5406 /* If we requested a matching stream index, we have to ensure st is that. */
5407 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5408 for (int i = 0; i < nb_streams && index >= 0; i++) {
5409 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5410 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5413 if (ret > 0 && index-- == 0 && st == candidate)
5419 if (ret == AVERROR(EINVAL))
5420 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5424 int ff_generate_avci_extradata(AVStream *st)
5426 static const uint8_t avci100_1080p_extradata[] = {
5428 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5429 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5430 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5431 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5432 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5433 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5434 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5435 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5436 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5438 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5441 static const uint8_t avci100_1080i_extradata[] = {
5443 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5444 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5445 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5446 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5447 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5448 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5449 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5450 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5451 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5452 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5453 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5455 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5458 static const uint8_t avci50_1080p_extradata[] = {
5460 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5461 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5462 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5463 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5464 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5465 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5466 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5467 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5468 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5470 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5473 static const uint8_t avci50_1080i_extradata[] = {
5475 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5476 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5477 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5478 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5479 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5480 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5481 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5482 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5483 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5484 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5485 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5487 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5490 static const uint8_t avci100_720p_extradata[] = {
5492 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5493 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5494 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5495 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5496 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5497 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5498 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5499 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5500 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5501 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5503 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5506 static const uint8_t avci50_720p_extradata[] = {
5508 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5509 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5510 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5511 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5512 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5513 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5514 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5515 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5516 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5518 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5522 const uint8_t *data = NULL;
5525 if (st->codecpar->width == 1920) {
5526 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5527 data = avci100_1080p_extradata;
5528 size = sizeof(avci100_1080p_extradata);
5530 data = avci100_1080i_extradata;
5531 size = sizeof(avci100_1080i_extradata);
5533 } else if (st->codecpar->width == 1440) {
5534 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5535 data = avci50_1080p_extradata;
5536 size = sizeof(avci50_1080p_extradata);
5538 data = avci50_1080i_extradata;
5539 size = sizeof(avci50_1080i_extradata);
5541 } else if (st->codecpar->width == 1280) {
5542 data = avci100_720p_extradata;
5543 size = sizeof(avci100_720p_extradata);
5544 } else if (st->codecpar->width == 960) {
5545 data = avci50_720p_extradata;
5546 size = sizeof(avci50_720p_extradata);
5552 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5554 memcpy(st->codecpar->extradata, data, size);
5559 uint8_t *av_stream_get_side_data(const AVStream *st,
5560 enum AVPacketSideDataType type, buffer_size_t *size)
5564 for (i = 0; i < st->nb_side_data; i++) {
5565 if (st->side_data[i].type == type) {
5567 *size = st->side_data[i].size;
5568 return st->side_data[i].data;
5576 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5577 uint8_t *data, size_t size)
5579 AVPacketSideData *sd, *tmp;
5582 for (i = 0; i < st->nb_side_data; i++) {
5583 sd = &st->side_data[i];
5585 if (sd->type == type) {
5586 av_freep(&sd->data);
5593 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5594 return AVERROR(ERANGE);
5596 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5598 return AVERROR(ENOMEM);
5601 st->side_data = tmp;
5604 sd = &st->side_data[st->nb_side_data - 1];
5612 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5616 uint8_t *data = av_malloc(size);
5621 ret = av_stream_add_side_data(st, type, data, size);
5630 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5633 const AVBitStreamFilter *bsf;
5636 av_assert0(!st->internal->bsfc);
5638 if (!(bsf = av_bsf_get_by_name(name))) {
5639 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5640 return AVERROR_BSF_NOT_FOUND;
5643 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5646 bsfc->time_base_in = st->time_base;
5647 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5652 if (args && bsfc->filter->priv_class) {
5653 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5654 const char * shorthand[2] = {NULL};
5657 shorthand[0] = opt->name;
5659 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5665 if ((ret = av_bsf_init(bsfc)) < 0) {
5670 st->internal->bsfc = bsfc;
5672 av_log(NULL, AV_LOG_VERBOSE,
5673 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5674 name, args ? args : "");
5679 FF_DISABLE_DEPRECATION_WARNINGS
5680 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5681 AVBitStreamFilterContext *bsfc)
5685 AVPacket new_pkt = *pkt;
5686 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5687 &new_pkt.data, &new_pkt.size,
5688 pkt->data, pkt->size,
5689 pkt->flags & AV_PKT_FLAG_KEY);
5690 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5691 av_packet_unref(pkt);
5692 memset(pkt, 0, sizeof(*pkt));
5695 if(a == 0 && new_pkt.data != pkt->data) {
5696 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
5698 memcpy(t, new_pkt.data, new_pkt.size);
5699 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5704 a = AVERROR(ENOMEM);
5708 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5709 av_buffer_default_free, NULL, 0);
5711 pkt->side_data = NULL;
5712 pkt->side_data_elems = 0;
5713 av_packet_unref(pkt);
5715 av_freep(&new_pkt.data);
5716 a = AVERROR(ENOMEM);
5720 av_log(codec, AV_LOG_ERROR,
5721 "Failed to open bitstream filter %s for stream %d with codec %s",
5722 bsfc->filter->name, pkt->stream_index,
5723 codec->codec ? codec->codec->name : "copy");
5733 FF_ENABLE_DEPRECATION_WARNINGS
5736 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5739 return AVERROR(EINVAL);
5741 if (!(s->oformat->flags & AVFMT_NOFILE))
5742 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5746 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5749 s->io_close(s, *pb);
5753 int ff_is_http_proto(char *filename) {
5754 const char *proto = avio_find_protocol_name(filename);
5755 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5758 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5760 AVDictionaryEntry *entry;
5761 int64_t parsed_timestamp;
5763 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5764 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5765 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5768 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5775 int ff_standardize_creation_time(AVFormatContext *s)
5778 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5780 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5784 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5789 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5791 if (size != AVPALETTE_SIZE) {
5792 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5793 return AVERROR_INVALIDDATA;
5795 memcpy(palette, side_data, AVPALETTE_SIZE);
5799 if (ret == CONTAINS_PAL) {
5801 for (i = 0; i < AVPALETTE_COUNT; i++)
5802 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5809 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5814 ret = av_bprint_finalize(buf, &str);
5817 if (!av_bprint_is_complete(buf)) {
5819 return AVERROR(ENOMEM);
5822 par->extradata = str;
5823 /* Note: the string is NUL terminated (so extradata can be read as a
5824 * string), but the ending character is not accounted in the size (in
5825 * binary formats you are likely not supposed to mux that character). When
5826 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5828 par->extradata_size = buf->len;
5832 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5833 AVStream *ost, const AVStream *ist,
5834 enum AVTimebaseSource copy_tb)
5836 //TODO: use [io]st->internal->avctx
5837 const AVCodecContext *dec_ctx;
5838 AVCodecContext *enc_ctx;
5840 #if FF_API_LAVF_AVCTX
5841 FF_DISABLE_DEPRECATION_WARNINGS
5842 dec_ctx = ist->codec;
5843 enc_ctx = ost->codec;
5844 FF_ENABLE_DEPRECATION_WARNINGS
5846 dec_ctx = ist->internal->avctx;
5847 enc_ctx = ost->internal->avctx;
5850 enc_ctx->time_base = ist->time_base;
5852 * Avi is a special case here because it supports variable fps but
5853 * having the fps and timebase differe significantly adds quite some
5856 if (!strcmp(ofmt->name, "avi")) {
5857 #if FF_API_R_FRAME_RATE
5858 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5859 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5860 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5861 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5862 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5863 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5864 enc_ctx->time_base.num = ist->r_frame_rate.den;
5865 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5866 enc_ctx->ticks_per_frame = 2;
5869 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5870 && av_q2d(ist->time_base) < 1.0/500
5871 || copy_tb == AVFMT_TBCF_DECODER) {
5872 enc_ctx->time_base = dec_ctx->time_base;
5873 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5874 enc_ctx->time_base.den *= 2;
5875 enc_ctx->ticks_per_frame = 2;
5877 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5878 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5879 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5880 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5881 && av_q2d(ist->time_base) < 1.0/500
5882 || copy_tb == AVFMT_TBCF_DECODER) {
5883 enc_ctx->time_base = dec_ctx->time_base;
5884 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5888 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5889 && dec_ctx->time_base.num < dec_ctx->time_base.den
5890 && dec_ctx->time_base.num > 0
5891 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5892 enc_ctx->time_base = dec_ctx->time_base;
5895 if (ost->avg_frame_rate.num)
5896 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5898 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5899 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5904 AVRational av_stream_get_codec_timebase(const AVStream *st)
5906 // See avformat_transfer_internal_stream_timing_info() TODO.
5907 #if FF_API_LAVF_AVCTX
5908 FF_DISABLE_DEPRECATION_WARNINGS
5909 return st->codec->time_base;
5910 FF_ENABLE_DEPRECATION_WARNINGS
5912 return st->internal->avctx->time_base;
5916 void ff_format_set_url(AVFormatContext *s, char *url)
5921 #if FF_API_FORMAT_FILENAME
5922 FF_DISABLE_DEPRECATION_WARNINGS
5923 av_strlcpy(s->filename, url, sizeof(s->filename));
5924 FF_ENABLE_DEPRECATION_WARNINGS