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)
315 pkt->pos = avio_tell(s);
317 return append_packet_chunked(s, pkt, size);
320 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
323 return av_get_packet(s, pkt, size);
324 return append_packet_chunked(s, pkt, size);
327 int av_filename_number_test(const char *filename)
331 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
334 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
337 static const struct {
340 enum AVMediaType type;
342 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
343 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
344 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
345 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
346 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
347 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
348 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
349 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
350 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
351 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
352 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
353 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
354 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
355 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
356 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
360 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
364 av_log(s, AV_LOG_DEBUG,
365 "Probe with size=%d, packets=%d detected %s with score=%d\n",
366 pd->buf_size, s->max_probe_packets - st->probe_packets,
368 for (i = 0; fmt_id_type[i].name; i++) {
369 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
370 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
371 st->codecpar->sample_rate)
373 if (st->internal->request_probe > score &&
374 st->codecpar->codec_id != fmt_id_type[i].id)
376 st->codecpar->codec_id = fmt_id_type[i].id;
377 st->codecpar->codec_type = fmt_id_type[i].type;
378 st->internal->need_context_update = 1;
379 #if FF_API_LAVF_AVCTX
380 FF_DISABLE_DEPRECATION_WARNINGS
381 st->codec->codec_type = st->codecpar->codec_type;
382 st->codec->codec_id = st->codecpar->codec_id;
383 FF_ENABLE_DEPRECATION_WARNINGS
392 /************************************************************/
393 /* input media file */
395 #if FF_API_DEMUXER_OPEN
396 int av_demuxer_open(AVFormatContext *ic) {
399 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
400 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
401 return AVERROR(EINVAL);
404 if (ic->iformat->read_header) {
405 err = ic->iformat->read_header(ic);
410 if (ic->pb && !ic->internal->data_offset)
411 ic->internal->data_offset = avio_tell(ic->pb);
416 /* Open input file and probe the format if necessary. */
417 static int init_input(AVFormatContext *s, const char *filename,
418 AVDictionary **options)
421 AVProbeData pd = { filename, NULL, 0 };
422 int score = AVPROBE_SCORE_RETRY;
425 s->flags |= AVFMT_FLAG_CUSTOM_IO;
427 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
428 s, 0, s->format_probesize);
429 else if (s->iformat->flags & AVFMT_NOFILE)
430 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
431 "will be ignored with AVFMT_NOFILE format.\n");
435 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
436 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
439 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
444 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
445 s, 0, s->format_probesize);
448 int avformat_queue_attached_pictures(AVFormatContext *s)
451 for (i = 0; i < s->nb_streams; i++)
452 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
453 s->streams[i]->discard < AVDISCARD_ALL) {
454 if (s->streams[i]->attached_pic.size <= 0) {
455 av_log(s, AV_LOG_WARNING,
456 "Attached picture on stream %d has invalid size, "
461 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
462 &s->internal->raw_packet_buffer_end,
463 &s->streams[i]->attached_pic,
471 static int update_stream_avctx(AVFormatContext *s)
474 for (i = 0; i < s->nb_streams; i++) {
475 AVStream *st = s->streams[i];
477 if (!st->internal->need_context_update)
480 /* close parser, because it depends on the codec */
481 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
482 av_parser_close(st->parser);
486 /* update internal codec context, for the parser */
487 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
491 #if FF_API_LAVF_AVCTX
492 FF_DISABLE_DEPRECATION_WARNINGS
493 /* update deprecated public codec context */
494 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
497 FF_ENABLE_DEPRECATION_WARNINGS
500 st->internal->need_context_update = 0;
506 int avformat_open_input(AVFormatContext **ps, const char *filename,
507 ff_const59 AVInputFormat *fmt, AVDictionary **options)
509 AVFormatContext *s = *ps;
511 AVDictionary *tmp = NULL;
512 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
514 if (!s && !(s = avformat_alloc_context()))
515 return AVERROR(ENOMEM);
517 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
518 return AVERROR(EINVAL);
524 av_dict_copy(&tmp, *options, 0);
526 if (s->pb) // must be before any goto fail
527 s->flags |= AVFMT_FLAG_CUSTOM_IO;
529 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
532 if (!(s->url = av_strdup(filename ? filename : ""))) {
533 ret = AVERROR(ENOMEM);
537 #if FF_API_FORMAT_FILENAME
538 FF_DISABLE_DEPRECATION_WARNINGS
539 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
540 FF_ENABLE_DEPRECATION_WARNINGS
542 if ((ret = init_input(s, filename, &tmp)) < 0)
544 s->probe_score = ret;
546 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
547 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
548 if (!s->protocol_whitelist) {
549 ret = AVERROR(ENOMEM);
554 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
555 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
556 if (!s->protocol_blacklist) {
557 ret = AVERROR(ENOMEM);
562 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
563 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
564 ret = AVERROR(EINVAL);
568 avio_skip(s->pb, s->skip_initial_bytes);
570 /* Check filename in case an image number is expected. */
571 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
572 if (!av_filename_number_test(filename)) {
573 ret = AVERROR(EINVAL);
578 s->duration = s->start_time = AV_NOPTS_VALUE;
580 /* Allocate private data. */
581 if (s->iformat->priv_data_size > 0) {
582 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
583 ret = AVERROR(ENOMEM);
586 if (s->iformat->priv_class) {
587 *(const AVClass **) s->priv_data = s->iformat->priv_class;
588 av_opt_set_defaults(s->priv_data);
589 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
594 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
596 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
598 #if FF_API_DEMUXER_OPEN
599 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
601 if (s->iformat->read_header)
603 if ((ret = s->iformat->read_header(s)) < 0)
607 s->metadata = s->internal->id3v2_meta;
608 s->internal->id3v2_meta = NULL;
609 } else if (s->internal->id3v2_meta) {
610 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
611 av_dict_free(&s->internal->id3v2_meta);
614 if (id3v2_extra_meta) {
615 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
616 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
617 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
619 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
621 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
624 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
626 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
628 if ((ret = avformat_queue_attached_pictures(s)) < 0)
631 #if FF_API_DEMUXER_OPEN
632 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
634 if (s->pb && !s->internal->data_offset)
636 s->internal->data_offset = avio_tell(s->pb);
638 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
640 update_stream_avctx(s);
642 for (i = 0; i < s->nb_streams; i++)
643 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
646 av_dict_free(options);
653 if (s->iformat->read_close)
654 s->iformat->read_close(s);
656 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
658 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
660 avformat_free_context(s);
665 /*******************************************************/
667 static void force_codec_ids(AVFormatContext *s, AVStream *st)
669 switch (st->codecpar->codec_type) {
670 case AVMEDIA_TYPE_VIDEO:
671 if (s->video_codec_id)
672 st->codecpar->codec_id = s->video_codec_id;
674 case AVMEDIA_TYPE_AUDIO:
675 if (s->audio_codec_id)
676 st->codecpar->codec_id = s->audio_codec_id;
678 case AVMEDIA_TYPE_SUBTITLE:
679 if (s->subtitle_codec_id)
680 st->codecpar->codec_id = s->subtitle_codec_id;
682 case AVMEDIA_TYPE_DATA:
683 if (s->data_codec_id)
684 st->codecpar->codec_id = s->data_codec_id;
689 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
691 if (st->internal->request_probe>0) {
692 AVProbeData *pd = &st->internal->probe_data;
694 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
698 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
700 av_log(s, AV_LOG_WARNING,
701 "Failed to reallocate probe buffer for stream %d\n",
706 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
707 pd->buf_size += pkt->size;
708 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
711 st->probe_packets = 0;
713 av_log(s, AV_LOG_WARNING,
714 "nothing to probe for stream %d\n", st->index);
718 end= s->internal->raw_packet_buffer_remaining_size <= 0
719 || st->probe_packets<= 0;
721 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
722 int score = set_codec_from_probe_data(s, st, pd);
723 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
727 st->internal->request_probe = -1;
728 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
729 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
731 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
733 force_codec_ids(s, st);
739 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
741 int64_t ref = pkt->dts;
742 int i, pts_wrap_behavior;
743 int64_t pts_wrap_reference;
744 AVProgram *first_program;
746 if (ref == AV_NOPTS_VALUE)
748 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
750 ref &= (1LL << st->pts_wrap_bits)-1;
752 // reference time stamp should be 60 s before first time stamp
753 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
754 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
755 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
756 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
757 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
759 first_program = av_find_program_from_stream(s, NULL, stream_index);
761 if (!first_program) {
762 int default_stream_index = av_find_default_stream_index(s);
763 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
764 for (i = 0; i < s->nb_streams; i++) {
765 if (av_find_program_from_stream(s, NULL, i))
767 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
768 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
772 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
773 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
777 AVProgram *program = first_program;
779 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
780 pts_wrap_reference = program->pts_wrap_reference;
781 pts_wrap_behavior = program->pts_wrap_behavior;
784 program = av_find_program_from_stream(s, program, stream_index);
787 // update every program with differing pts_wrap_reference
788 program = first_program;
790 if (program->pts_wrap_reference != pts_wrap_reference) {
791 for (i = 0; i<program->nb_stream_indexes; i++) {
792 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
793 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
796 program->pts_wrap_reference = pts_wrap_reference;
797 program->pts_wrap_behavior = pts_wrap_behavior;
799 program = av_find_program_from_stream(s, program, stream_index);
805 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
815 PacketList *pktl = s->internal->raw_packet_buffer;
816 const AVPacket *pkt1;
819 st = s->streams[pktl->pkt.stream_index];
820 if (s->internal->raw_packet_buffer_remaining_size <= 0)
821 if ((err = probe_codec(s, st, NULL)) < 0)
823 if (st->internal->request_probe <= 0) {
824 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
825 &s->internal->raw_packet_buffer_end, pkt);
826 s->internal->raw_packet_buffer_remaining_size += pkt->size;
831 ret = s->iformat->read_packet(s, pkt);
833 av_packet_unref(pkt);
835 /* Some demuxers return FFERROR_REDO when they consume
836 data and discard it (ignored streams, junk, extradata).
837 We must re-call the demuxer to get the real packet. */
838 if (ret == FFERROR_REDO)
840 if (!pktl || ret == AVERROR(EAGAIN))
842 for (i = 0; i < s->nb_streams; i++) {
844 if (st->probe_packets || st->internal->request_probe > 0)
845 if ((err = probe_codec(s, st, NULL)) < 0)
847 av_assert0(st->internal->request_probe <= 0);
852 err = av_packet_make_refcounted(pkt);
854 av_packet_unref(pkt);
858 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
859 av_log(s, AV_LOG_WARNING,
860 "Packet corrupt (stream = %d, dts = %s)",
861 pkt->stream_index, av_ts2str(pkt->dts));
862 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
863 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
864 av_packet_unref(pkt);
867 av_log(s, AV_LOG_WARNING, ".\n");
870 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
871 "Invalid stream index.\n");
873 st = s->streams[pkt->stream_index];
875 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
876 // correct first time stamps to negative values
877 if (!is_relative(st->first_dts))
878 st->first_dts = wrap_timestamp(st, st->first_dts);
879 if (!is_relative(st->start_time))
880 st->start_time = wrap_timestamp(st, st->start_time);
881 if (!is_relative(st->cur_dts))
882 st->cur_dts = wrap_timestamp(st, st->cur_dts);
885 pkt->dts = wrap_timestamp(st, pkt->dts);
886 pkt->pts = wrap_timestamp(st, pkt->pts);
888 force_codec_ids(s, st);
890 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
891 if (s->use_wallclock_as_timestamps)
892 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
894 if (!pktl && st->internal->request_probe <= 0)
897 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
898 &s->internal->raw_packet_buffer_end,
901 av_packet_unref(pkt);
904 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
905 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
907 if ((err = probe_codec(s, st, pkt1)) < 0)
913 /**********************************************************/
915 static int determinable_frame_size(AVCodecContext *avctx)
917 switch(avctx->codec_id) {
918 case AV_CODEC_ID_MP1:
919 case AV_CODEC_ID_MP2:
920 case AV_CODEC_ID_MP3:
921 case AV_CODEC_ID_CODEC2:
929 * Return the frame duration in seconds. Return 0 if not available.
931 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
932 AVCodecParserContext *pc, AVPacket *pkt)
934 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
935 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
936 int frame_size, sample_rate;
938 #if FF_API_LAVF_AVCTX
939 FF_DISABLE_DEPRECATION_WARNINGS
940 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
941 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
942 FF_ENABLE_DEPRECATION_WARNINGS
947 switch (st->codecpar->codec_type) {
948 case AVMEDIA_TYPE_VIDEO:
949 if (st->r_frame_rate.num && !pc && s->iformat) {
950 *pnum = st->r_frame_rate.den;
951 *pden = st->r_frame_rate.num;
952 } else if (st->time_base.num * 1000LL > st->time_base.den) {
953 *pnum = st->time_base.num;
954 *pden = st->time_base.den;
955 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
956 av_assert0(st->internal->avctx->ticks_per_frame);
957 av_reduce(pnum, pden,
959 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
962 if (pc && pc->repeat_pict) {
963 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
964 av_reduce(pnum, pden,
965 (*pnum) * (1LL + pc->repeat_pict),
969 /* If this codec can be interlaced or progressive then we need
970 * a parser to compute duration of a packet. Thus if we have
971 * no parser in such case leave duration undefined. */
972 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
976 case AVMEDIA_TYPE_AUDIO:
977 if (st->internal->avctx_inited) {
978 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
979 sample_rate = st->internal->avctx->sample_rate;
981 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
982 sample_rate = st->codecpar->sample_rate;
984 if (frame_size <= 0 || sample_rate <= 0)
994 int ff_is_intra_only(enum AVCodecID id)
996 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
999 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1000 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1005 static int has_decode_delay_been_guessed(AVStream *st)
1007 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1008 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1010 #if CONFIG_H264_DECODER
1011 if (st->internal->avctx->has_b_frames &&
1012 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1015 if (st->internal->avctx->has_b_frames<3)
1016 return st->internal->nb_decoded_frames >= 7;
1017 else if (st->internal->avctx->has_b_frames<4)
1018 return st->internal->nb_decoded_frames >= 18;
1020 return st->internal->nb_decoded_frames >= 20;
1023 static PacketList *get_next_pkt(AVFormatContext *s, AVStream *st, PacketList *pktl)
1027 if (pktl == s->internal->packet_buffer_end)
1028 return s->internal->parse_queue;
1032 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1033 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1034 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1037 int delay = st->internal->avctx->has_b_frames;
1040 if (dts == AV_NOPTS_VALUE) {
1041 int64_t best_score = INT64_MAX;
1042 for (i = 0; i<delay; i++) {
1043 if (st->internal->pts_reorder_error_count[i]) {
1044 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1045 if (score < best_score) {
1047 dts = pts_buffer[i];
1052 for (i = 0; i<delay; i++) {
1053 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1054 int64_t diff = FFABS(pts_buffer[i] - dts)
1055 + (uint64_t)st->internal->pts_reorder_error[i];
1056 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1057 st->internal->pts_reorder_error[i] = diff;
1058 st->internal->pts_reorder_error_count[i]++;
1059 if (st->internal->pts_reorder_error_count[i] > 250) {
1060 st->internal->pts_reorder_error[i] >>= 1;
1061 st->internal->pts_reorder_error_count[i] >>= 1;
1068 if (dts == AV_NOPTS_VALUE)
1069 dts = pts_buffer[0];
1075 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1076 * of the packets in a window.
1078 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1079 PacketList *pkt_buffer)
1081 AVStream *st = s->streams[stream_index];
1082 int delay = st->internal->avctx->has_b_frames;
1085 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1087 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1088 pts_buffer[i] = AV_NOPTS_VALUE;
1090 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1091 if (pkt_buffer->pkt.stream_index != stream_index)
1094 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1095 pts_buffer[0] = pkt_buffer->pkt.pts;
1096 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1097 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1099 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1104 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1105 int64_t dts, int64_t pts, AVPacket *pkt)
1107 AVStream *st = s->streams[stream_index];
1108 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1109 PacketList *pktl_it;
1113 if (st->first_dts != AV_NOPTS_VALUE ||
1114 dts == AV_NOPTS_VALUE ||
1115 st->cur_dts == AV_NOPTS_VALUE ||
1116 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1117 dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1121 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1123 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1125 if (is_relative(pts))
1128 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1129 if (pktl_it->pkt.stream_index != stream_index)
1131 if (is_relative(pktl_it->pkt.pts))
1132 pktl_it->pkt.pts += shift;
1134 if (is_relative(pktl_it->pkt.dts))
1135 pktl_it->pkt.dts += shift;
1137 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1138 st->start_time = pktl_it->pkt.pts;
1139 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1140 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));
1144 if (has_decode_delay_been_guessed(st)) {
1145 update_dts_from_pts(s, stream_index, pktl);
1148 if (st->start_time == AV_NOPTS_VALUE) {
1149 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1150 st->start_time = pts;
1152 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1153 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));
1157 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1158 int stream_index, int64_t duration)
1160 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1161 int64_t cur_dts = RELATIVE_TS_BASE;
1163 if (st->first_dts != AV_NOPTS_VALUE) {
1164 if (st->internal->update_initial_durations_done)
1166 st->internal->update_initial_durations_done = 1;
1167 cur_dts = st->first_dts;
1168 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1169 if (pktl->pkt.stream_index == stream_index) {
1170 if (pktl->pkt.pts != pktl->pkt.dts ||
1171 pktl->pkt.dts != AV_NOPTS_VALUE ||
1174 cur_dts -= duration;
1177 if (pktl && pktl->pkt.dts != st->first_dts) {
1178 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1179 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1183 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1186 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1187 st->first_dts = cur_dts;
1188 } else if (st->cur_dts != RELATIVE_TS_BASE)
1191 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1192 if (pktl->pkt.stream_index != stream_index)
1194 if ((pktl->pkt.pts == pktl->pkt.dts ||
1195 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1196 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1197 pktl->pkt.dts == st->first_dts ||
1198 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1199 !pktl->pkt.duration) {
1200 pktl->pkt.dts = cur_dts;
1201 if (!st->internal->avctx->has_b_frames)
1202 pktl->pkt.pts = cur_dts;
1203 pktl->pkt.duration = duration;
1206 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1209 st->cur_dts = cur_dts;
1212 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1213 AVCodecParserContext *pc, AVPacket *pkt,
1214 int64_t next_dts, int64_t next_pts)
1216 int num, den, presentation_delayed, delay, i;
1218 AVRational duration;
1219 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1220 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1222 if (s->flags & AVFMT_FLAG_NOFILLIN)
1225 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1226 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1227 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1228 st->internal->dts_ordered++;
1230 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1231 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1233 st->internal->last_dts_for_order_check);
1234 st->internal->dts_misordered++;
1236 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1237 st->internal->dts_ordered >>= 1;
1238 st->internal->dts_misordered >>= 1;
1242 st->internal->last_dts_for_order_check = pkt->dts;
1243 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1244 pkt->dts = AV_NOPTS_VALUE;
1247 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1248 pkt->dts = AV_NOPTS_VALUE;
1250 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1251 && !st->internal->avctx->has_b_frames)
1252 //FIXME Set low_delay = 0 when has_b_frames = 1
1253 st->internal->avctx->has_b_frames = 1;
1255 /* do we have a video B-frame ? */
1256 delay = st->internal->avctx->has_b_frames;
1257 presentation_delayed = 0;
1259 /* XXX: need has_b_frame, but cannot get it if the codec is
1260 * not initialized */
1262 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1263 presentation_delayed = 1;
1265 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1266 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << (st->pts_wrap_bits - 1)) &&
1267 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1268 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1269 pkt->dts -= 1LL << st->pts_wrap_bits;
1271 pkt->pts += 1LL << st->pts_wrap_bits;
1274 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1275 * We take the conservative approach and discard both.
1276 * Note: If this is misbehaving for an H.264 file, then possibly
1277 * presentation_delayed is not set correctly. */
1278 if (delay == 1 && pkt->dts == pkt->pts &&
1279 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1280 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1281 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1282 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1283 pkt->dts = AV_NOPTS_VALUE;
1286 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1287 if (pkt->duration <= 0) {
1288 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1290 duration = (AVRational) {num, den};
1291 pkt->duration = av_rescale_rnd(1,
1292 num * (int64_t) st->time_base.den,
1293 den * (int64_t) st->time_base.num,
1298 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1299 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1301 /* Correct timestamps with byte offset if demuxers only have timestamps
1302 * on packet boundaries */
1303 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1304 /* this will estimate bitrate based on this frame's duration and size */
1305 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1306 if (pkt->pts != AV_NOPTS_VALUE)
1308 if (pkt->dts != AV_NOPTS_VALUE)
1312 /* This may be redundant, but it should not hurt. */
1313 if (pkt->dts != AV_NOPTS_VALUE &&
1314 pkt->pts != AV_NOPTS_VALUE &&
1315 pkt->pts > pkt->dts)
1316 presentation_delayed = 1;
1318 if (s->debug & FF_FDEBUG_TS)
1319 av_log(s, AV_LOG_DEBUG,
1320 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1321 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1322 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1324 /* Interpolate PTS and DTS if they are not present. We skip H264
1325 * currently because delay and has_b_frames are not reliably set. */
1326 if ((delay == 0 || (delay == 1 && pc)) &&
1328 if (presentation_delayed) {
1329 /* DTS = decompression timestamp */
1330 /* PTS = presentation timestamp */
1331 if (pkt->dts == AV_NOPTS_VALUE)
1332 pkt->dts = st->last_IP_pts;
1333 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1334 if (pkt->dts == AV_NOPTS_VALUE)
1335 pkt->dts = st->cur_dts;
1337 /* This is tricky: the dts must be incremented by the duration
1338 * of the frame we are displaying, i.e. the last I- or P-frame. */
1339 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1340 st->last_IP_duration = pkt->duration;
1341 if (pkt->dts != AV_NOPTS_VALUE)
1342 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1343 if (pkt->dts != AV_NOPTS_VALUE &&
1344 pkt->pts == AV_NOPTS_VALUE &&
1345 st->last_IP_duration > 0 &&
1346 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1347 next_dts != next_pts &&
1348 next_pts != AV_NOPTS_VALUE)
1349 pkt->pts = next_dts;
1351 if ((uint64_t)pkt->duration <= INT32_MAX)
1352 st->last_IP_duration = pkt->duration;
1353 st->last_IP_pts = pkt->pts;
1354 /* Cannot compute PTS if not present (we can compute it only
1355 * by knowing the future. */
1356 } else if (pkt->pts != AV_NOPTS_VALUE ||
1357 pkt->dts != AV_NOPTS_VALUE ||
1358 pkt->duration > 0 ) {
1360 /* presentation is not delayed : PTS and DTS are the same */
1361 if (pkt->pts == AV_NOPTS_VALUE)
1362 pkt->pts = pkt->dts;
1363 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1365 if (pkt->pts == AV_NOPTS_VALUE)
1366 pkt->pts = st->cur_dts;
1367 pkt->dts = pkt->pts;
1368 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1369 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1373 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1374 st->internal->pts_buffer[0] = pkt->pts;
1375 for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1376 FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1378 if(has_decode_delay_been_guessed(st))
1379 pkt->dts = select_from_pts_buffer(st, st->internal->pts_buffer, pkt->dts);
1381 // We skipped it above so we try here.
1383 // This should happen on the first packet
1384 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1385 if (pkt->dts > st->cur_dts)
1386 st->cur_dts = pkt->dts;
1388 if (s->debug & FF_FDEBUG_TS)
1389 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1390 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1393 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1394 pkt->flags |= AV_PKT_FLAG_KEY;
1395 #if FF_API_CONVERGENCE_DURATION
1396 FF_DISABLE_DEPRECATION_WARNINGS
1398 pkt->convergence_duration = pc->convergence_duration;
1399 FF_ENABLE_DEPRECATION_WARNINGS
1404 * Parse a packet, add all split parts to parse_queue.
1406 * @param pkt Packet to parse; must not be NULL.
1407 * @param flush Indicates whether to flush. If set, pkt must be blank.
1409 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1410 int stream_index, int flush)
1413 AVStream *st = s->streams[stream_index];
1414 uint8_t *data = pkt->data;
1415 int size = pkt->size;
1416 int ret = 0, got_output = flush;
1418 if (size || flush) {
1419 av_init_packet(&out_pkt);
1420 } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1421 // preserve 0-size sync packets
1422 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1425 while (size > 0 || (flush && got_output)) {
1427 int64_t next_pts = pkt->pts;
1428 int64_t next_dts = pkt->dts;
1430 len = av_parser_parse2(st->parser, st->internal->avctx,
1431 &out_pkt.data, &out_pkt.size, data, size,
1432 pkt->pts, pkt->dts, pkt->pos);
1434 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1436 /* increment read pointer */
1437 av_assert1(data || !len);
1438 data = len ? data + len : data;
1441 got_output = !!out_pkt.size;
1446 if (pkt->buf && out_pkt.data == pkt->data) {
1447 /* reference pkt->buf only when out_pkt.data is guaranteed to point
1448 * to data in it and not in the parser's internal buffer. */
1449 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1450 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1451 out_pkt.buf = av_buffer_ref(pkt->buf);
1453 ret = AVERROR(ENOMEM);
1457 ret = av_packet_make_refcounted(&out_pkt);
1462 if (pkt->side_data) {
1463 out_pkt.side_data = pkt->side_data;
1464 out_pkt.side_data_elems = pkt->side_data_elems;
1465 pkt->side_data = NULL;
1466 pkt->side_data_elems = 0;
1469 /* set the duration */
1470 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1471 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1472 if (st->internal->avctx->sample_rate > 0) {
1474 av_rescale_q_rnd(st->parser->duration,
1475 (AVRational) { 1, st->internal->avctx->sample_rate },
1481 out_pkt.stream_index = st->index;
1482 out_pkt.pts = st->parser->pts;
1483 out_pkt.dts = st->parser->dts;
1484 out_pkt.pos = st->parser->pos;
1485 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1487 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1488 out_pkt.pos = st->parser->frame_offset;
1490 if (st->parser->key_frame == 1 ||
1491 (st->parser->key_frame == -1 &&
1492 st->parser->pict_type == AV_PICTURE_TYPE_I))
1493 out_pkt.flags |= AV_PKT_FLAG_KEY;
1495 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1496 out_pkt.flags |= AV_PKT_FLAG_KEY;
1498 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1500 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1501 &s->internal->parse_queue_end,
1504 av_packet_unref(&out_pkt);
1509 /* end of the stream => close and free the parser */
1511 av_parser_close(st->parser);
1516 av_packet_unref(pkt);
1520 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1522 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1525 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1527 int ret, i, got_packet = 0;
1528 AVDictionary *metadata = NULL;
1530 while (!got_packet && !s->internal->parse_queue) {
1533 /* read next packet */
1534 ret = ff_read_packet(s, pkt);
1536 if (ret == AVERROR(EAGAIN))
1538 /* flush the parsers */
1539 for (i = 0; i < s->nb_streams; i++) {
1541 if (st->parser && st->need_parsing)
1542 parse_packet(s, pkt, st->index, 1);
1544 /* all remaining packets are now in parse_queue =>
1545 * really terminate parsing */
1549 st = s->streams[pkt->stream_index];
1551 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1553 /* update context if required */
1554 if (st->internal->need_context_update) {
1555 if (avcodec_is_open(st->internal->avctx)) {
1556 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1557 avcodec_close(st->internal->avctx);
1558 st->internal->info->found_decoder = 0;
1561 /* close parser, because it depends on the codec */
1562 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1563 av_parser_close(st->parser);
1567 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1569 av_packet_unref(pkt);
1573 #if FF_API_LAVF_AVCTX
1574 FF_DISABLE_DEPRECATION_WARNINGS
1575 /* update deprecated public codec context */
1576 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1578 av_packet_unref(pkt);
1581 FF_ENABLE_DEPRECATION_WARNINGS
1584 st->internal->need_context_update = 0;
1587 if (pkt->pts != AV_NOPTS_VALUE &&
1588 pkt->dts != AV_NOPTS_VALUE &&
1589 pkt->pts < pkt->dts) {
1590 av_log(s, AV_LOG_WARNING,
1591 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1593 av_ts2str(pkt->pts),
1594 av_ts2str(pkt->dts),
1597 if (s->debug & FF_FDEBUG_TS)
1598 av_log(s, AV_LOG_DEBUG,
1599 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1601 av_ts2str(pkt->pts),
1602 av_ts2str(pkt->dts),
1603 pkt->size, pkt->duration, pkt->flags);
1605 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1606 st->parser = av_parser_init(st->codecpar->codec_id);
1608 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1609 "%s, packets or times may be invalid.\n",
1610 avcodec_get_name(st->codecpar->codec_id));
1611 /* no parser available: just output the raw packets */
1612 st->need_parsing = AVSTREAM_PARSE_NONE;
1613 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1614 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1615 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1616 st->parser->flags |= PARSER_FLAG_ONCE;
1617 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1618 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1621 if (!st->need_parsing || !st->parser) {
1622 /* no parsing needed: we just output the packet as is */
1623 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1624 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1625 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1626 ff_reduce_index(s, st->index);
1627 av_add_index_entry(st, pkt->pos, pkt->dts,
1628 0, 0, AVINDEX_KEYFRAME);
1631 } else if (st->discard < AVDISCARD_ALL) {
1632 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1634 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1635 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1636 st->codecpar->channels = st->internal->avctx->channels;
1637 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1638 st->codecpar->codec_id = st->internal->avctx->codec_id;
1641 av_packet_unref(pkt);
1643 if (pkt->flags & AV_PKT_FLAG_KEY)
1644 st->internal->skip_to_keyframe = 0;
1645 if (st->internal->skip_to_keyframe) {
1646 av_packet_unref(pkt);
1651 if (!got_packet && s->internal->parse_queue)
1652 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1655 AVStream *st = s->streams[pkt->stream_index];
1656 int discard_padding = 0;
1657 if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1658 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1659 int64_t sample = ts_to_samples(st, pts);
1660 int duration = ts_to_samples(st, pkt->duration);
1661 int64_t end_sample = sample + duration;
1662 if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1663 sample < st->internal->last_discard_sample)
1664 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1666 if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1667 st->internal->skip_samples = st->internal->start_skip_samples;
1668 if (st->internal->skip_samples || discard_padding) {
1669 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1671 AV_WL32(p, st->internal->skip_samples);
1672 AV_WL32(p + 4, discard_padding);
1673 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1675 st->internal->skip_samples = 0;
1678 if (st->internal->inject_global_side_data) {
1679 for (i = 0; i < st->nb_side_data; i++) {
1680 AVPacketSideData *src_sd = &st->side_data[i];
1683 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1686 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1688 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1692 memcpy(dst_data, src_sd->data, src_sd->size);
1694 st->internal->inject_global_side_data = 0;
1698 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1700 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1701 av_dict_copy(&s->metadata, metadata, 0);
1702 av_dict_free(&metadata);
1703 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1706 #if FF_API_LAVF_AVCTX
1707 update_stream_avctx(s);
1710 if (s->debug & FF_FDEBUG_TS)
1711 av_log(s, AV_LOG_DEBUG,
1712 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1713 "size=%d, duration=%"PRId64", flags=%d\n",
1715 av_ts2str(pkt->pts),
1716 av_ts2str(pkt->dts),
1717 pkt->size, pkt->duration, pkt->flags);
1719 /* A demuxer might have returned EOF because of an IO error, let's
1720 * propagate this back to the user. */
1721 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1727 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1729 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1735 ret = s->internal->packet_buffer
1736 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1737 &s->internal->packet_buffer_end, pkt)
1738 : read_frame_internal(s, pkt);
1745 PacketList *pktl = s->internal->packet_buffer;
1748 AVPacket *next_pkt = &pktl->pkt;
1750 if (next_pkt->dts != AV_NOPTS_VALUE) {
1751 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1752 // last dts seen for this stream. if any of packets following
1753 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1754 int64_t last_dts = next_pkt->dts;
1755 av_assert2(wrap_bits <= 64);
1756 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1757 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1758 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1759 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1761 next_pkt->pts = pktl->pkt.dts;
1763 if (last_dts != AV_NOPTS_VALUE) {
1764 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1765 last_dts = pktl->pkt.dts;
1770 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1771 // Fixing the last reference frame had none pts issue (For MXF etc).
1772 // We only do this when
1774 // 2. we are not able to resolve a pts value for current packet.
1775 // 3. the packets for this stream at the end of the files had valid dts.
1776 next_pkt->pts = last_dts + next_pkt->duration;
1778 pktl = s->internal->packet_buffer;
1781 /* read packet from packet buffer, if there is data */
1782 st = s->streams[next_pkt->stream_index];
1783 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1784 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1785 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1786 &s->internal->packet_buffer_end, pkt);
1791 ret = read_frame_internal(s, pkt);
1793 if (pktl && ret != AVERROR(EAGAIN)) {
1800 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1801 &s->internal->packet_buffer_end,
1804 av_packet_unref(pkt);
1811 st = s->streams[pkt->stream_index];
1812 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1813 ff_reduce_index(s, st->index);
1814 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1817 if (is_relative(pkt->dts))
1818 pkt->dts -= RELATIVE_TS_BASE;
1819 if (is_relative(pkt->pts))
1820 pkt->pts -= RELATIVE_TS_BASE;
1825 /* XXX: suppress the packet queue */
1826 static void flush_packet_queue(AVFormatContext *s)
1830 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1831 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1832 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1834 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1837 /*******************************************************/
1840 int av_find_default_stream_index(AVFormatContext *s)
1844 int best_stream = 0;
1845 int best_score = INT_MIN;
1847 if (s->nb_streams <= 0)
1849 for (i = 0; i < s->nb_streams; i++) {
1852 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1853 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1855 if (st->codecpar->width && st->codecpar->height)
1859 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1860 if (st->codecpar->sample_rate)
1863 if (st->codec_info_nb_frames)
1866 if (st->discard != AVDISCARD_ALL)
1869 if (score > best_score) {
1877 /** Flush the frame reader. */
1878 void ff_read_frame_flush(AVFormatContext *s)
1883 flush_packet_queue(s);
1885 /* Reset read state for each stream. */
1886 for (i = 0; i < s->nb_streams; i++) {
1890 av_parser_close(st->parser);
1893 st->last_IP_pts = AV_NOPTS_VALUE;
1894 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1895 if (st->first_dts == AV_NOPTS_VALUE)
1896 st->cur_dts = RELATIVE_TS_BASE;
1898 /* We set the current DTS to an unspecified origin. */
1899 st->cur_dts = AV_NOPTS_VALUE;
1901 st->probe_packets = s->max_probe_packets;
1903 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1904 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1906 if (s->internal->inject_global_side_data)
1907 st->internal->inject_global_side_data = 1;
1909 st->internal->skip_samples = 0;
1913 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1917 for (i = 0; i < s->nb_streams; i++) {
1918 AVStream *st = s->streams[i];
1921 av_rescale(timestamp,
1922 st->time_base.den * (int64_t) ref_st->time_base.num,
1923 st->time_base.num * (int64_t) ref_st->time_base.den);
1927 void ff_reduce_index(AVFormatContext *s, int stream_index)
1929 AVStream *st = s->streams[stream_index];
1930 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1932 if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1934 for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1935 st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1936 st->internal->nb_index_entries = i;
1940 int ff_add_index_entry(AVIndexEntry **index_entries,
1941 int *nb_index_entries,
1942 unsigned int *index_entries_allocated_size,
1943 int64_t pos, int64_t timestamp,
1944 int size, int distance, int flags)
1946 AVIndexEntry *entries, *ie;
1949 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1952 if (timestamp == AV_NOPTS_VALUE)
1953 return AVERROR(EINVAL);
1955 if (size < 0 || size > 0x3FFFFFFF)
1956 return AVERROR(EINVAL);
1958 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1959 timestamp -= RELATIVE_TS_BASE;
1961 entries = av_fast_realloc(*index_entries,
1962 index_entries_allocated_size,
1963 (*nb_index_entries + 1) *
1964 sizeof(AVIndexEntry));
1968 *index_entries = entries;
1970 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1971 timestamp, AVSEEK_FLAG_ANY);
1974 index = (*nb_index_entries)++;
1975 ie = &entries[index];
1976 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1978 ie = &entries[index];
1979 if (ie->timestamp != timestamp) {
1980 if (ie->timestamp <= timestamp)
1982 memmove(entries + index + 1, entries + index,
1983 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1984 (*nb_index_entries)++;
1985 } else if (ie->pos == pos && distance < ie->min_distance)
1986 // do not reduce the distance
1987 distance = ie->min_distance;
1991 ie->timestamp = timestamp;
1992 ie->min_distance = distance;
1999 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2000 int size, int distance, int flags)
2002 timestamp = wrap_timestamp(st, timestamp);
2003 return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
2004 &st->internal->index_entries_allocated_size, pos,
2005 timestamp, size, distance, flags);
2008 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2009 int64_t wanted_timestamp, int flags)
2017 // Optimize appending index entries at the end.
2018 if (b && entries[b - 1].timestamp < wanted_timestamp)
2024 // Search for the next non-discarded packet.
2025 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2027 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2033 timestamp = entries[m].timestamp;
2034 if (timestamp >= wanted_timestamp)
2036 if (timestamp <= wanted_timestamp)
2039 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2041 if (!(flags & AVSEEK_FLAG_ANY))
2042 while (m >= 0 && m < nb_entries &&
2043 !(entries[m].flags & AVINDEX_KEYFRAME))
2044 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2046 if (m == nb_entries)
2051 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2054 int64_t pos_delta = 0;
2056 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2057 const char *proto = avio_find_protocol_name(s->url);
2059 av_assert0(time_tolerance >= 0);
2062 av_log(s, AV_LOG_INFO,
2063 "Protocol name not provided, cannot determine if input is local or "
2064 "a network protocol, buffers and access patterns cannot be configured "
2065 "optimally without knowing the protocol\n");
2068 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2071 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2072 AVStream *st1 = s->streams[ist1];
2073 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2074 AVStream *st2 = s->streams[ist2];
2080 for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2081 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2082 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2084 skip = FFMAX(skip, e1->size);
2085 for (; i2 < st2->internal->nb_index_entries; i2++) {
2086 AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2087 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2088 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2090 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2098 /* XXX This could be adjusted depending on protocol*/
2099 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2100 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2102 /* realloc the buffer and the original data will be retained */
2103 if (ffio_realloc_buf(s->pb, pos_delta)) {
2104 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2108 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2111 if (skip < (1<<23)) {
2112 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2116 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2118 return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2119 wanted_timestamp, flags);
2122 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2123 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2125 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2126 if (stream_index >= 0)
2127 ts = wrap_timestamp(s->streams[stream_index], ts);
2131 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2132 int64_t target_ts, int flags)
2134 const AVInputFormat *avif = s->iformat;
2135 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2136 int64_t ts_min, ts_max, ts;
2141 if (stream_index < 0)
2144 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2147 ts_min = AV_NOPTS_VALUE;
2148 pos_limit = -1; // GCC falsely says it may be uninitialized.
2150 st = s->streams[stream_index];
2151 if (st->internal->index_entries) {
2154 /* FIXME: Whole function must be checked for non-keyframe entries in
2155 * index case, especially read_timestamp(). */
2156 index = av_index_search_timestamp(st, target_ts,
2157 flags | AVSEEK_FLAG_BACKWARD);
2158 index = FFMAX(index, 0);
2159 e = &st->internal->index_entries[index];
2161 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2163 ts_min = e->timestamp;
2164 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2165 pos_min, av_ts2str(ts_min));
2167 av_assert1(index == 0);
2170 index = av_index_search_timestamp(st, target_ts,
2171 flags & ~AVSEEK_FLAG_BACKWARD);
2172 av_assert0(index < st->internal->nb_index_entries);
2174 e = &st->internal->index_entries[index];
2175 av_assert1(e->timestamp >= target_ts);
2177 ts_max = e->timestamp;
2178 pos_limit = pos_max - e->min_distance;
2179 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2180 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2184 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2185 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2190 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2193 ff_read_frame_flush(s);
2194 ff_update_cur_dts(s, st, ts);
2199 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2200 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2202 int64_t step = 1024;
2203 int64_t limit, ts_max;
2204 int64_t filesize = avio_size(s->pb);
2205 int64_t pos_max = filesize - 1;
2208 pos_max = FFMAX(0, (pos_max) - step);
2209 ts_max = ff_read_timestamp(s, stream_index,
2210 &pos_max, limit, read_timestamp);
2212 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2213 if (ts_max == AV_NOPTS_VALUE)
2217 int64_t tmp_pos = pos_max + 1;
2218 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2219 &tmp_pos, INT64_MAX, read_timestamp);
2220 if (tmp_ts == AV_NOPTS_VALUE)
2222 av_assert0(tmp_pos > pos_max);
2225 if (tmp_pos >= filesize)
2237 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2238 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2239 int64_t ts_min, int64_t ts_max,
2240 int flags, int64_t *ts_ret,
2241 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2242 int64_t *, int64_t))
2249 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2251 if (ts_min == AV_NOPTS_VALUE) {
2252 pos_min = s->internal->data_offset;
2253 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2254 if (ts_min == AV_NOPTS_VALUE)
2258 if (ts_min >= target_ts) {
2263 if (ts_max == AV_NOPTS_VALUE) {
2264 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2266 pos_limit = pos_max;
2269 if (ts_max <= target_ts) {
2274 av_assert0(ts_min < ts_max);
2277 while (pos_min < pos_limit) {
2278 av_log(s, AV_LOG_TRACE,
2279 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2280 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2281 av_assert0(pos_limit <= pos_max);
2283 if (no_change == 0) {
2284 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2285 // interpolate position (better than dichotomy)
2286 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2288 pos_min - approximate_keyframe_distance;
2289 } else if (no_change == 1) {
2290 // bisection if interpolation did not change min / max pos last time
2291 pos = (pos_min + pos_limit) >> 1;
2293 /* linear search if bisection failed, can only happen if there
2294 * are very few or no keyframes between min/max */
2299 else if (pos > pos_limit)
2303 // May pass pos_limit instead of -1.
2304 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2309 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2310 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2311 pos_min, pos, pos_max,
2312 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2313 pos_limit, start_pos, no_change);
2314 if (ts == AV_NOPTS_VALUE) {
2315 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2318 if (target_ts <= ts) {
2319 pos_limit = start_pos - 1;
2323 if (target_ts >= ts) {
2329 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2330 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2333 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2335 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2336 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2337 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2343 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2344 int64_t pos, int flags)
2346 int64_t pos_min, pos_max;
2348 pos_min = s->internal->data_offset;
2349 pos_max = avio_size(s->pb) - 1;
2353 else if (pos > pos_max)
2356 avio_seek(s->pb, pos, SEEK_SET);
2358 s->io_repositioned = 1;
2363 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2364 int64_t timestamp, int flags)
2371 st = s->streams[stream_index];
2373 index = av_index_search_timestamp(st, timestamp, flags);
2375 if (index < 0 && st->internal->nb_index_entries &&
2376 timestamp < st->internal->index_entries[0].timestamp)
2379 if (index < 0 || index == st->internal->nb_index_entries - 1) {
2383 if (st->internal->nb_index_entries) {
2384 av_assert0(st->internal->index_entries);
2385 ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2386 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2388 ff_update_cur_dts(s, st, ie->timestamp);
2390 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2396 read_status = av_read_frame(s, &pkt);
2397 } while (read_status == AVERROR(EAGAIN));
2398 if (read_status < 0)
2400 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2401 if (pkt.flags & AV_PKT_FLAG_KEY) {
2402 av_packet_unref(&pkt);
2405 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2406 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);
2407 av_packet_unref(&pkt);
2411 av_packet_unref(&pkt);
2413 index = av_index_search_timestamp(st, timestamp, flags);
2418 ff_read_frame_flush(s);
2419 if (s->iformat->read_seek)
2420 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2422 ie = &st->internal->index_entries[index];
2423 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2425 ff_update_cur_dts(s, st, ie->timestamp);
2430 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2431 int64_t timestamp, int flags)
2436 if (flags & AVSEEK_FLAG_BYTE) {
2437 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2439 ff_read_frame_flush(s);
2440 return seek_frame_byte(s, stream_index, timestamp, flags);
2443 if (stream_index < 0) {
2444 stream_index = av_find_default_stream_index(s);
2445 if (stream_index < 0)
2448 st = s->streams[stream_index];
2449 /* timestamp for default must be expressed in AV_TIME_BASE units */
2450 timestamp = av_rescale(timestamp, st->time_base.den,
2451 AV_TIME_BASE * (int64_t) st->time_base.num);
2454 /* first, we try the format specific seek */
2455 if (s->iformat->read_seek) {
2456 ff_read_frame_flush(s);
2457 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2463 if (s->iformat->read_timestamp &&
2464 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2465 ff_read_frame_flush(s);
2466 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2467 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2468 ff_read_frame_flush(s);
2469 return seek_frame_generic(s, stream_index, timestamp, flags);
2474 int av_seek_frame(AVFormatContext *s, int stream_index,
2475 int64_t timestamp, int flags)
2479 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2480 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2481 if ((flags & AVSEEK_FLAG_BACKWARD))
2485 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2486 flags & ~AVSEEK_FLAG_BACKWARD);
2489 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2492 ret = avformat_queue_attached_pictures(s);
2497 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2498 int64_t ts, int64_t max_ts, int flags)
2500 if (min_ts > ts || max_ts < ts)
2502 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2503 return AVERROR(EINVAL);
2506 flags |= AVSEEK_FLAG_ANY;
2507 flags &= ~AVSEEK_FLAG_BACKWARD;
2509 if (s->iformat->read_seek2) {
2511 ff_read_frame_flush(s);
2513 if (stream_index == -1 && s->nb_streams == 1) {
2514 AVRational time_base = s->streams[0]->time_base;
2515 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2516 min_ts = av_rescale_rnd(min_ts, time_base.den,
2517 time_base.num * (int64_t)AV_TIME_BASE,
2518 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2519 max_ts = av_rescale_rnd(max_ts, time_base.den,
2520 time_base.num * (int64_t)AV_TIME_BASE,
2521 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2525 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2529 ret = avformat_queue_attached_pictures(s);
2533 if (s->iformat->read_timestamp) {
2534 // try to seek via read_timestamp()
2537 // Fall back on old API if new is not implemented but old is.
2538 // Note the old API has somewhat different semantics.
2539 if (s->iformat->read_seek || 1) {
2540 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2541 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2542 if (ret<0 && ts != min_ts && max_ts != ts) {
2543 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2545 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2550 // try some generic seek like seek_frame_generic() but with new ts semantics
2551 return -1; //unreachable
2554 int avformat_flush(AVFormatContext *s)
2556 ff_read_frame_flush(s);
2560 /*******************************************************/
2563 * Return TRUE if the stream has accurate duration in any stream.
2565 * @return TRUE if the stream has accurate duration for at least one component.
2567 static int has_duration(AVFormatContext *ic)
2572 for (i = 0; i < ic->nb_streams; i++) {
2573 st = ic->streams[i];
2574 if (st->duration != AV_NOPTS_VALUE)
2577 if (ic->duration != AV_NOPTS_VALUE)
2583 * Estimate the stream timings from the one of each components.
2585 * Also computes the global bitrate if possible.
2587 static void update_stream_timings(AVFormatContext *ic)
2589 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2590 int64_t duration, duration1, duration_text, filesize;
2594 start_time = INT64_MAX;
2595 start_time_text = INT64_MAX;
2596 end_time = INT64_MIN;
2597 end_time_text = INT64_MIN;
2598 duration = INT64_MIN;
2599 duration_text = INT64_MIN;
2601 for (i = 0; i < ic->nb_streams; i++) {
2602 AVStream *st = ic->streams[i];
2603 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2604 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2605 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2606 start_time1 = av_rescale_q(st->start_time, st->time_base,
2609 start_time_text = FFMIN(start_time_text, start_time1);
2611 start_time = FFMIN(start_time, start_time1);
2612 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2614 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2615 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2616 end_time1 += start_time1;
2618 end_time_text = FFMAX(end_time_text, end_time1);
2620 end_time = FFMAX(end_time, end_time1);
2622 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2623 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2624 p->start_time = start_time1;
2625 if (p->end_time < end_time1)
2626 p->end_time = end_time1;
2629 if (st->duration != AV_NOPTS_VALUE) {
2630 duration1 = av_rescale_q(st->duration, st->time_base,
2633 duration_text = FFMAX(duration_text, duration1);
2635 duration = FFMAX(duration, duration1);
2638 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2639 start_time = start_time_text;
2640 else if (start_time > start_time_text)
2641 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2643 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2644 end_time = end_time_text;
2645 else if (end_time < end_time_text)
2646 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2648 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2649 duration = duration_text;
2650 else if (duration < duration_text)
2651 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2653 if (start_time != INT64_MAX) {
2654 ic->start_time = start_time;
2655 if (end_time != INT64_MIN) {
2656 if (ic->nb_programs > 1) {
2657 for (i = 0; i < ic->nb_programs; i++) {
2658 p = ic->programs[i];
2659 if (p->start_time != AV_NOPTS_VALUE &&
2660 p->end_time > p->start_time &&
2661 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2662 duration = FFMAX(duration, p->end_time - p->start_time);
2664 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2665 duration = FFMAX(duration, end_time - start_time);
2669 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2670 ic->duration = duration;
2672 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2673 /* compute the bitrate */
2674 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2675 (double) ic->duration;
2676 if (bitrate >= 0 && bitrate <= INT64_MAX)
2677 ic->bit_rate = bitrate;
2681 static void fill_all_stream_timings(AVFormatContext *ic)
2686 update_stream_timings(ic);
2687 for (i = 0; i < ic->nb_streams; i++) {
2688 st = ic->streams[i];
2689 if (st->start_time == AV_NOPTS_VALUE) {
2690 if (ic->start_time != AV_NOPTS_VALUE)
2691 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2693 if (ic->duration != AV_NOPTS_VALUE)
2694 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2700 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2702 int64_t filesize, duration;
2703 int i, show_warning = 0;
2706 /* if bit_rate is already set, we believe it */
2707 if (ic->bit_rate <= 0) {
2708 int64_t bit_rate = 0;
2709 for (i = 0; i < ic->nb_streams; i++) {
2710 st = ic->streams[i];
2711 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2712 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2713 if (st->codecpar->bit_rate > 0) {
2714 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2718 bit_rate += st->codecpar->bit_rate;
2719 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2720 // If we have a videostream with packets but without a bitrate
2721 // then consider the sum not known
2726 ic->bit_rate = bit_rate;
2729 /* if duration is already set, we believe it */
2730 if (ic->duration == AV_NOPTS_VALUE &&
2731 ic->bit_rate != 0) {
2732 filesize = ic->pb ? avio_size(ic->pb) : 0;
2733 if (filesize > ic->internal->data_offset) {
2734 filesize -= ic->internal->data_offset;
2735 for (i = 0; i < ic->nb_streams; i++) {
2736 st = ic->streams[i];
2737 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2738 && st->duration == AV_NOPTS_VALUE) {
2739 duration = av_rescale(filesize, 8LL * st->time_base.den,
2741 (int64_t) st->time_base.num);
2742 st->duration = duration;
2749 av_log(ic, AV_LOG_WARNING,
2750 "Estimating duration from bitrate, this may be inaccurate\n");
2753 #define DURATION_MAX_READ_SIZE 250000LL
2754 #define DURATION_MAX_RETRY 6
2756 /* only usable for MPEG-PS streams */
2757 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2759 AVPacket pkt1, *pkt = &pkt1;
2761 int num, den, read_size, i, ret;
2762 int found_duration = 0;
2764 int64_t filesize, offset, duration;
2767 /* flush packet queue */
2768 flush_packet_queue(ic);
2770 for (i = 0; i < ic->nb_streams; i++) {
2771 st = ic->streams[i];
2772 if (st->start_time == AV_NOPTS_VALUE &&
2773 st->first_dts == AV_NOPTS_VALUE &&
2774 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2775 av_log(ic, AV_LOG_WARNING,
2776 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2779 av_parser_close(st->parser);
2784 if (ic->skip_estimate_duration_from_pts) {
2785 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2786 goto skip_duration_calc;
2789 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2790 /* estimate the end time (duration) */
2791 /* XXX: may need to support wrapping */
2792 filesize = ic->pb ? avio_size(ic->pb) : 0;
2794 is_end = found_duration;
2795 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2799 avio_seek(ic->pb, offset, SEEK_SET);
2802 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2806 ret = ff_read_packet(ic, pkt);
2807 } while (ret == AVERROR(EAGAIN));
2810 read_size += pkt->size;
2811 st = ic->streams[pkt->stream_index];
2812 if (pkt->pts != AV_NOPTS_VALUE &&
2813 (st->start_time != AV_NOPTS_VALUE ||
2814 st->first_dts != AV_NOPTS_VALUE)) {
2815 if (pkt->duration == 0) {
2816 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2818 pkt->duration = av_rescale_rnd(1,
2819 num * (int64_t) st->time_base.den,
2820 den * (int64_t) st->time_base.num,
2824 duration = pkt->pts + pkt->duration;
2826 if (st->start_time != AV_NOPTS_VALUE)
2827 duration -= st->start_time;
2829 duration -= st->first_dts;
2831 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2832 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2833 st->duration = duration;
2834 st->internal->info->last_duration = duration;
2837 av_packet_unref(pkt);
2840 /* check if all audio/video streams have valid duration */
2843 for (i = 0; i < ic->nb_streams; i++) {
2844 st = ic->streams[i];
2845 switch (st->codecpar->codec_type) {
2846 case AVMEDIA_TYPE_VIDEO:
2847 case AVMEDIA_TYPE_AUDIO:
2848 if (st->duration == AV_NOPTS_VALUE)
2855 ++retry <= DURATION_MAX_RETRY);
2857 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2859 /* warn about audio/video streams which duration could not be estimated */
2860 for (i = 0; i < ic->nb_streams; i++) {
2861 st = ic->streams[i];
2862 if (st->duration == AV_NOPTS_VALUE) {
2863 switch (st->codecpar->codec_type) {
2864 case AVMEDIA_TYPE_VIDEO:
2865 case AVMEDIA_TYPE_AUDIO:
2866 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2867 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2869 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2874 fill_all_stream_timings(ic);
2876 avio_seek(ic->pb, old_offset, SEEK_SET);
2877 for (i = 0; i < ic->nb_streams; i++) {
2880 st = ic->streams[i];
2881 st->cur_dts = st->first_dts;
2882 st->last_IP_pts = AV_NOPTS_VALUE;
2883 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2884 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2885 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2889 /* 1:1 map to AVDurationEstimationMethod */
2890 static const char *const duration_name[] = {
2891 [AVFMT_DURATION_FROM_PTS] = "pts",
2892 [AVFMT_DURATION_FROM_STREAM] = "stream",
2893 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2896 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2898 return duration_name[method];
2901 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2905 /* get the file size, if possible */
2906 if (ic->iformat->flags & AVFMT_NOFILE) {
2909 file_size = avio_size(ic->pb);
2910 file_size = FFMAX(0, file_size);
2913 if ((!strcmp(ic->iformat->name, "mpeg") ||
2914 !strcmp(ic->iformat->name, "mpegts")) &&
2915 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2916 /* get accurate estimate from the PTSes */
2917 estimate_timings_from_pts(ic, old_offset);
2918 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2919 } else if (has_duration(ic)) {
2920 /* at least one component has timings - we use them for all
2922 fill_all_stream_timings(ic);
2923 /* nut demuxer estimate the duration from PTS */
2924 if(!strcmp(ic->iformat->name, "nut"))
2925 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2927 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2929 /* less precise: use bitrate info */
2930 estimate_timings_from_bit_rate(ic);
2931 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2933 update_stream_timings(ic);
2937 AVStream av_unused *st;
2938 for (i = 0; i < ic->nb_streams; i++) {
2939 st = ic->streams[i];
2940 if (st->time_base.den)
2941 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2942 av_ts2timestr(st->start_time, &st->time_base),
2943 av_ts2timestr(st->duration, &st->time_base));
2945 av_log(ic, AV_LOG_TRACE,
2946 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2947 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2948 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2949 duration_estimate_name(ic->duration_estimation_method),
2950 (int64_t)ic->bit_rate / 1000);
2954 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2956 AVCodecContext *avctx = st->internal->avctx;
2958 #define FAIL(errmsg) do { \
2960 *errmsg_ptr = errmsg; \
2964 if ( avctx->codec_id == AV_CODEC_ID_NONE
2965 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2966 FAIL("unknown codec");
2967 switch (avctx->codec_type) {
2968 case AVMEDIA_TYPE_AUDIO:
2969 if (!avctx->frame_size && determinable_frame_size(avctx))
2970 FAIL("unspecified frame size");
2971 if (st->internal->info->found_decoder >= 0 &&
2972 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2973 FAIL("unspecified sample format");
2974 if (!avctx->sample_rate)
2975 FAIL("unspecified sample rate");
2976 if (!avctx->channels)
2977 FAIL("unspecified number of channels");
2978 if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2979 FAIL("no decodable DTS frames");
2981 case AVMEDIA_TYPE_VIDEO:
2983 FAIL("unspecified size");
2984 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2985 FAIL("unspecified pixel format");
2986 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2987 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2988 FAIL("no frame in rv30/40 and no sar");
2990 case AVMEDIA_TYPE_SUBTITLE:
2991 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2992 FAIL("unspecified size");
2994 case AVMEDIA_TYPE_DATA:
2995 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3001 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3002 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3003 const AVPacket *avpkt, AVDictionary **options)
3005 AVCodecContext *avctx = st->internal->avctx;
3006 const AVCodec *codec;
3007 int got_picture = 1, ret = 0;
3008 AVFrame *frame = av_frame_alloc();
3009 AVSubtitle subtitle;
3010 AVPacket pkt = *avpkt;
3011 int do_skip_frame = 0;
3012 enum AVDiscard skip_frame;
3015 return AVERROR(ENOMEM);
3017 if (!avcodec_is_open(avctx) &&
3018 st->internal->info->found_decoder <= 0 &&
3019 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3020 AVDictionary *thread_opt = NULL;
3022 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3025 st->internal->info->found_decoder = -st->codecpar->codec_id;
3030 /* Force thread count to 1 since the H.264 decoder will not extract
3031 * SPS and PPS to extradata during multi-threaded decoding. */
3032 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3033 /* Force lowres to 0. The decoder might reduce the video size by the
3034 * lowres factor, and we don't want that propagated to the stream's
3036 av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
3037 if (s->codec_whitelist)
3038 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3039 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3041 av_dict_free(&thread_opt);
3043 st->internal->info->found_decoder = -avctx->codec_id;
3046 st->internal->info->found_decoder = 1;
3047 } else if (!st->internal->info->found_decoder)
3048 st->internal->info->found_decoder = 1;
3050 if (st->internal->info->found_decoder < 0) {
3055 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3057 skip_frame = avctx->skip_frame;
3058 avctx->skip_frame = AVDISCARD_ALL;
3061 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3063 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3064 (!st->codec_info_nb_frames &&
3065 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3067 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3068 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3069 ret = avcodec_send_packet(avctx, &pkt);
3070 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3074 ret = avcodec_receive_frame(avctx, frame);
3077 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3079 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3080 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3081 &got_picture, &pkt);
3083 avsubtitle_free(&subtitle);
3089 st->internal->nb_decoded_frames++;
3094 if (!pkt.data && !got_picture)
3098 if (do_skip_frame) {
3099 avctx->skip_frame = skip_frame;
3102 av_frame_free(&frame);
3106 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3108 while (tags->id != AV_CODEC_ID_NONE) {
3116 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3119 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3120 if (tag == tags[i].tag)
3122 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3123 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3125 return AV_CODEC_ID_NONE;
3128 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3130 if (bps <= 0 || bps > 64)
3131 return AV_CODEC_ID_NONE;
3136 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3138 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3140 return AV_CODEC_ID_NONE;
3145 if (sflags & (1 << (bps - 1))) {
3148 return AV_CODEC_ID_PCM_S8;
3150 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3152 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3154 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3156 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3158 return AV_CODEC_ID_NONE;
3163 return AV_CODEC_ID_PCM_U8;
3165 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3167 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3169 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3171 return AV_CODEC_ID_NONE;
3177 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3180 if (!av_codec_get_tag2(tags, id, &tag))
3185 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3189 for (i = 0; tags && tags[i]; i++) {
3190 const AVCodecTag *codec_tags = tags[i];
3191 while (codec_tags->id != AV_CODEC_ID_NONE) {
3192 if (codec_tags->id == id) {
3193 *tag = codec_tags->tag;
3202 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3205 for (i = 0; tags && tags[i]; i++) {
3206 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3207 if (id != AV_CODEC_ID_NONE)
3210 return AV_CODEC_ID_NONE;
3213 static int chapter_start_cmp(const void *p1, const void *p2)
3215 AVChapter *ch1 = *(AVChapter**)p1;
3216 AVChapter *ch2 = *(AVChapter**)p2;
3217 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3220 return (ch1 > ch2) - (ch1 < ch2);
3223 static int compute_chapters_end(AVFormatContext *s)
3226 int64_t max_time = 0;
3227 AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3230 return AVERROR(ENOMEM);
3232 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3233 max_time = s->duration +
3234 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3236 for (i = 0; i < s->nb_chapters; i++)
3237 timetable[i] = s->chapters[i];
3238 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3240 for (i = 0; i < s->nb_chapters; i++)
3241 if (timetable[i]->end == AV_NOPTS_VALUE) {
3242 AVChapter *ch = timetable[i];
3243 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3247 if (i + 1 < s->nb_chapters) {
3248 AVChapter *ch1 = timetable[i + 1];
3249 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3251 if (next_start > ch->start && next_start < end)
3254 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3260 static int get_std_framerate(int i)
3263 return (i + 1) * 1001;
3267 return (i + 31) * 1001 * 12;
3271 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3275 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3278 /* Is the time base unreliable?
3279 * This is a heuristic to balance between quick acceptance of the values in
3280 * the headers vs. some extra checks.
3281 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3282 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3283 * And there are "variable" fps files this needs to detect as well. */
3284 static int tb_unreliable(AVCodecContext *c)
3286 if (c->time_base.den >= 101LL * c->time_base.num ||
3287 c->time_base.den < 5LL * c->time_base.num ||
3288 // c->codec_tag == AV_RL32("DIVX") ||
3289 // c->codec_tag == AV_RL32("XVID") ||
3290 c->codec_tag == AV_RL32("mp4v") ||
3291 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3292 c->codec_id == AV_CODEC_ID_GIF ||
3293 c->codec_id == AV_CODEC_ID_HEVC ||
3294 c->codec_id == AV_CODEC_ID_H264)
3299 int ff_alloc_extradata(AVCodecParameters *par, int size)
3301 av_freep(&par->extradata);
3302 par->extradata_size = 0;
3304 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3305 return AVERROR(EINVAL);
3307 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3308 if (!par->extradata)
3309 return AVERROR(ENOMEM);
3311 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3312 par->extradata_size = size;
3317 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3319 int ret = ff_alloc_extradata(par, size);
3322 ret = avio_read(pb, par->extradata, size);
3324 av_freep(&par->extradata);
3325 par->extradata_size = 0;
3326 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3327 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3333 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3336 int64_t last = st->internal->info->last_dts;
3338 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3339 && ts - (uint64_t)last < INT64_MAX) {
3340 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3341 int64_t duration = ts - last;
3343 if (!st->internal->info->duration_error)
3344 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3345 if (!st->internal->info->duration_error)
3346 return AVERROR(ENOMEM);
3348 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3349 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3350 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3351 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3352 int framerate = get_std_framerate(i);
3353 double sdts = dts*framerate/(1001*12);
3354 for (j= 0; j<2; j++) {
3355 int64_t ticks = llrint(sdts+j*0.5);
3356 double error= sdts - ticks + j*0.5;
3357 st->internal->info->duration_error[j][0][i] += error;
3358 st->internal->info->duration_error[j][1][i] += error*error;
3362 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3363 st->internal->info->duration_count++;
3364 st->internal->info->rfps_duration_sum += duration;
3367 if (st->internal->info->duration_count % 10 == 0) {
3368 int n = st->internal->info->duration_count;
3369 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3370 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3371 double a0 = st->internal->info->duration_error[0][0][i] / n;
3372 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3373 double a1 = st->internal->info->duration_error[1][0][i] / n;
3374 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3375 if (error0 > 0.04 && error1 > 0.04) {
3376 st->internal->info->duration_error[0][1][i] = 2e10;
3377 st->internal->info->duration_error[1][1][i] = 2e10;
3383 // ignore the first 4 values, they might have some random jitter
3384 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3385 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3387 if (ts != AV_NOPTS_VALUE)
3388 st->internal->info->last_dts = ts;
3393 void ff_rfps_calculate(AVFormatContext *ic)
3397 for (i = 0; i < ic->nb_streams; i++) {
3398 AVStream *st = ic->streams[i];
3400 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3402 // the check for tb_unreliable() is not completely correct, since this is not about handling
3403 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3404 // ipmovie.c produces.
3405 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)
3406 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);
3407 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3408 && tb_unreliable(st->internal->avctx)) {
3410 double best_error= 0.01;
3411 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3413 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3416 if (st->internal->info->codec_info_duration &&
3417 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3419 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3422 if (av_q2d(st->time_base) * st->internal->info->rfps_duration_sum / st->internal->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3425 for (k= 0; k<2; k++) {
3426 int n = st->internal->info->duration_count;
3427 double a= st->internal->info->duration_error[k][0][j] / n;
3428 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3430 if (error < best_error && best_error> 0.000000001) {
3432 num = get_std_framerate(j);
3435 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3438 // do not increase frame rate by more than 1 % in order to match a standard rate.
3439 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3440 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3442 if ( !st->avg_frame_rate.num
3443 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3444 && st->internal->info->codec_info_duration <= 0
3445 && st->internal->info->duration_count > 2
3446 && 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
3448 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3449 st->avg_frame_rate = st->r_frame_rate;
3452 av_freep(&st->internal->info->duration_error);
3453 st->internal->info->last_dts = AV_NOPTS_VALUE;
3454 st->internal->info->duration_count = 0;
3455 st->internal->info->rfps_duration_sum = 0;
3459 static int extract_extradata_check(AVStream *st)
3461 const AVBitStreamFilter *f;
3463 f = av_bsf_get_by_name("extract_extradata");
3468 const enum AVCodecID *ids;
3469 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3470 if (*ids == st->codecpar->codec_id)
3477 static int extract_extradata_init(AVStream *st)
3479 AVStreamInternal *sti = st->internal;
3480 const AVBitStreamFilter *f;
3483 f = av_bsf_get_by_name("extract_extradata");
3487 /* check that the codec id is supported */
3488 ret = extract_extradata_check(st);
3492 sti->extract_extradata.pkt = av_packet_alloc();
3493 if (!sti->extract_extradata.pkt)
3494 return AVERROR(ENOMEM);
3496 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3500 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3505 sti->extract_extradata.bsf->time_base_in = st->time_base;
3507 ret = av_bsf_init(sti->extract_extradata.bsf);
3512 sti->extract_extradata.inited = 1;
3516 av_bsf_free(&sti->extract_extradata.bsf);
3517 av_packet_free(&sti->extract_extradata.pkt);
3521 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3523 AVStreamInternal *sti = st->internal;
3527 if (!sti->extract_extradata.inited) {
3528 ret = extract_extradata_init(st);
3533 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3536 pkt_ref = sti->extract_extradata.pkt;
3537 ret = av_packet_ref(pkt_ref, pkt);
3541 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3543 av_packet_unref(pkt_ref);
3547 while (ret >= 0 && !sti->avctx->extradata) {
3548 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3550 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3555 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3556 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3557 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3558 sti->avctx->extradata = side_data->data;
3559 sti->avctx->extradata_size = side_data->size;
3560 side_data->data = NULL;
3561 side_data->size = 0;
3565 av_packet_unref(pkt_ref);
3571 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3575 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3576 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3578 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3580 return AVERROR(ENOMEM);
3581 memcpy(dst_data, sd_src->data, sd_src->size);
3586 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3588 int i, count = 0, ret = 0, j;
3591 AVCodecContext *avctx;
3593 int64_t old_offset = avio_tell(ic->pb);
3594 // new streams might appear, no options for those
3595 int orig_nb_streams = ic->nb_streams;
3597 int64_t max_analyze_duration = ic->max_analyze_duration;
3598 int64_t max_stream_analyze_duration;
3599 int64_t max_subtitle_analyze_duration;
3600 int64_t probesize = ic->probesize;
3601 int eof_reached = 0;
3602 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3604 flush_codecs = probesize > 0;
3606 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3608 max_stream_analyze_duration = max_analyze_duration;
3609 max_subtitle_analyze_duration = max_analyze_duration;
3610 if (!max_analyze_duration) {
3611 max_stream_analyze_duration =
3612 max_analyze_duration = 5*AV_TIME_BASE;
3613 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3614 if (!strcmp(ic->iformat->name, "flv"))
3615 max_stream_analyze_duration = 90*AV_TIME_BASE;
3616 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3617 max_stream_analyze_duration = 7*AV_TIME_BASE;
3621 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3622 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3624 for (i = 0; i < ic->nb_streams; i++) {
3625 const AVCodec *codec;
3626 AVDictionary *thread_opt = NULL;
3627 st = ic->streams[i];
3628 avctx = st->internal->avctx;
3630 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3631 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3632 /* if (!st->time_base.num)
3634 if (!avctx->time_base.num)
3635 avctx->time_base = st->time_base;
3638 /* check if the caller has overridden the codec id */
3639 #if FF_API_LAVF_AVCTX
3640 FF_DISABLE_DEPRECATION_WARNINGS
3641 if (st->codec->codec_id != st->internal->orig_codec_id) {
3642 st->codecpar->codec_id = st->codec->codec_id;
3643 st->codecpar->codec_type = st->codec->codec_type;
3644 st->internal->orig_codec_id = st->codec->codec_id;
3646 FF_ENABLE_DEPRECATION_WARNINGS
3648 // only for the split stuff
3649 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3650 st->parser = av_parser_init(st->codecpar->codec_id);
3652 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3653 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3654 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3655 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3657 } else if (st->need_parsing) {
3658 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3659 "%s, packets or times may be invalid.\n",
3660 avcodec_get_name(st->codecpar->codec_id));
3664 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3665 st->internal->orig_codec_id = st->codecpar->codec_id;
3667 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3669 goto find_stream_info_err;
3670 if (st->internal->request_probe <= 0)
3671 st->internal->avctx_inited = 1;
3673 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3675 /* Force thread count to 1 since the H.264 decoder will not extract
3676 * SPS and PPS to extradata during multi-threaded decoding. */
3677 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3678 /* Force lowres to 0. The decoder might reduce the video size by the
3679 * lowres factor, and we don't want that propagated to the stream's
3681 av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
3683 if (ic->codec_whitelist)
3684 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3686 /* Ensure that subtitle_header is properly set. */
3687 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3688 && codec && !avctx->codec) {
3689 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3690 av_log(ic, AV_LOG_WARNING,
3691 "Failed to open codec in %s\n",__FUNCTION__);
3694 // Try to just open decoders, in case this is enough to get parameters.
3695 if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0) {
3696 if (codec && !avctx->codec)
3697 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3698 av_log(ic, AV_LOG_WARNING,
3699 "Failed to open codec in %s\n",__FUNCTION__);
3702 av_dict_free(&thread_opt);
3705 for (i = 0; i < ic->nb_streams; i++) {
3706 #if FF_API_R_FRAME_RATE
3707 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3709 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3710 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3715 const AVPacket *pkt;
3716 int analyzed_all_streams;
3717 if (ff_check_interrupt(&ic->interrupt_callback)) {
3719 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3723 /* check if one codec still needs to be handled */
3724 for (i = 0; i < ic->nb_streams; i++) {
3725 int fps_analyze_framecount = 20;
3728 st = ic->streams[i];
3729 if (!has_codec_parameters(st, NULL))
3731 /* If the timebase is coarse (like the usual millisecond precision
3732 * of mkv), we need to analyze more frames to reliably arrive at
3733 * the correct fps. */
3734 if (av_q2d(st->time_base) > 0.0005)
3735 fps_analyze_framecount *= 2;
3736 if (!tb_unreliable(st->internal->avctx))
3737 fps_analyze_framecount = 0;
3738 if (ic->fps_probe_size >= 0)
3739 fps_analyze_framecount = ic->fps_probe_size;
3740 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3741 fps_analyze_framecount = 0;
3742 /* variable fps and no guess at the real fps */
3743 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3744 st->internal->info->codec_info_duration_fields/2 :
3745 st->internal->info->duration_count;
3746 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3747 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3748 if (count < fps_analyze_framecount)
3751 // Look at the first 3 frames if there is evidence of frame delay
3752 // but the decoder delay is not set.
3753 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3755 if (!st->internal->avctx->extradata &&
3756 (!st->internal->extract_extradata.inited ||
3757 st->internal->extract_extradata.bsf) &&
3758 extract_extradata_check(st))
3760 if (st->first_dts == AV_NOPTS_VALUE &&
3761 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3762 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3763 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3764 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3767 analyzed_all_streams = 0;
3768 if (!missing_streams || !*missing_streams)
3769 if (i == ic->nb_streams) {
3770 analyzed_all_streams = 1;
3771 /* NOTE: If the format has no header, then we need to read some
3772 * packets to get most of the streams, so we cannot stop here. */
3773 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3774 /* If we found the info for all the codecs, we can stop. */
3776 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3781 /* We did not get all the codec info, but we read too much data. */
3782 if (read_size >= probesize) {
3784 av_log(ic, AV_LOG_DEBUG,
3785 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3786 for (i = 0; i < ic->nb_streams; i++)
3787 if (!ic->streams[i]->r_frame_rate.num &&
3788 ic->streams[i]->internal->info->duration_count <= 1 &&
3789 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3790 strcmp(ic->iformat->name, "image2"))
3791 av_log(ic, AV_LOG_WARNING,
3792 "Stream #%d: not enough frames to estimate rate; "
3793 "consider increasing probesize\n", i);
3797 /* NOTE: A new stream can be added there if no header in file
3798 * (AVFMTCTX_NOHEADER). */
3799 ret = read_frame_internal(ic, &pkt1);
3800 if (ret == AVERROR(EAGAIN))
3809 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3810 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3811 &ic->internal->packet_buffer_end,
3814 goto unref_then_goto_end;
3816 pkt = &ic->internal->packet_buffer_end->pkt;
3821 st = ic->streams[pkt->stream_index];
3822 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3823 read_size += pkt->size;
3825 avctx = st->internal->avctx;
3826 if (!st->internal->avctx_inited) {
3827 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3829 goto unref_then_goto_end;
3830 st->internal->avctx_inited = 1;
3833 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3834 /* check for non-increasing dts */
3835 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3836 st->internal->info->fps_last_dts >= pkt->dts) {
3837 av_log(ic, AV_LOG_DEBUG,
3838 "Non-increasing DTS in stream %d: packet %d with DTS "
3839 "%"PRId64", packet %d with DTS %"PRId64"\n",
3840 st->index, st->internal->info->fps_last_dts_idx,
3841 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3843 st->internal->info->fps_first_dts =
3844 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3846 /* Check for a discontinuity in dts. If the difference in dts
3847 * is more than 1000 times the average packet duration in the
3848 * sequence, we treat it as a discontinuity. */
3849 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3850 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3851 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3852 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3853 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3854 av_log(ic, AV_LOG_WARNING,
3855 "DTS discontinuity in stream %d: packet %d with DTS "
3856 "%"PRId64", packet %d with DTS %"PRId64"\n",
3857 st->index, st->internal->info->fps_last_dts_idx,
3858 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3860 st->internal->info->fps_first_dts =
3861 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3864 /* update stored dts values */
3865 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3866 st->internal->info->fps_first_dts = pkt->dts;
3867 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3869 st->internal->info->fps_last_dts = pkt->dts;
3870 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3872 if (st->codec_info_nb_frames>1) {
3876 if (st->time_base.den > 0)
3877 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3878 if (st->avg_frame_rate.num > 0)
3879 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3882 && st->codec_info_nb_frames>30
3883 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3884 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE) {
3885 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3886 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3889 if (analyzed_all_streams) limit = max_analyze_duration;
3890 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3891 else limit = max_stream_analyze_duration;
3894 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3896 t, pkt->stream_index);
3897 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3898 av_packet_unref(&pkt1);
3901 if (pkt->duration) {
3902 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3903 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3905 st->internal->info->codec_info_duration += pkt->duration;
3906 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3909 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3910 #if FF_API_R_FRAME_RATE
3911 ff_rfps_add_frame(ic, st, pkt->dts);
3913 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3914 st->internal->info->frame_delay_evidence = 1;
3916 if (!st->internal->avctx->extradata) {
3917 ret = extract_extradata(st, pkt);
3919 goto unref_then_goto_end;
3922 /* If still no information, we try to open the codec and to
3923 * decompress the frame. We try to avoid that in most cases as
3924 * it takes longer and uses more memory. For MPEG-4, we need to
3925 * decompress for QuickTime.
3927 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3928 * least one frame of codec data, this makes sure the codec initializes
3929 * the channel configuration and does not only trust the values from
3931 try_decode_frame(ic, st, pkt,
3932 (options && i < orig_nb_streams) ? &options[i] : NULL);
3934 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3935 av_packet_unref(&pkt1);
3937 st->codec_info_nb_frames++;
3943 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3944 st = ic->streams[stream_index];
3945 avctx = st->internal->avctx;
3946 if (!has_codec_parameters(st, NULL)) {
3947 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3948 if (codec && !avctx->codec) {
3949 AVDictionary *opts = NULL;
3950 if (ic->codec_whitelist)
3951 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3952 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3953 av_log(ic, AV_LOG_WARNING,
3954 "Failed to open codec in %s\n",__FUNCTION__);
3955 av_dict_free(&opts);
3959 // EOF already reached while reading the stream above.
3960 // So continue with reoordering DTS with whatever delay we have.
3961 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3962 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3968 AVPacket empty_pkt = { 0 };
3970 av_init_packet(&empty_pkt);
3972 for (i = 0; i < ic->nb_streams; i++) {
3974 st = ic->streams[i];
3976 /* flush the decoders */
3977 if (st->internal->info->found_decoder == 1) {
3979 err = try_decode_frame(ic, st, &empty_pkt,
3980 (options && i < orig_nb_streams)
3981 ? &options[i] : NULL);
3982 } while (err > 0 && !has_codec_parameters(st, NULL));
3985 av_log(ic, AV_LOG_INFO,
3986 "decoding for stream %d failed\n", st->index);
3992 ff_rfps_calculate(ic);
3994 for (i = 0; i < ic->nb_streams; i++) {
3995 st = ic->streams[i];
3996 avctx = st->internal->avctx;
3997 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3998 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3999 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4000 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4001 avctx->codec_tag= tag;
4004 /* estimate average framerate if not set by demuxer */
4005 if (st->internal->info->codec_info_duration_fields &&
4006 !st->avg_frame_rate.num &&
4007 st->internal->info->codec_info_duration) {
4009 double best_error = 0.01;
4010 AVRational codec_frame_rate = avctx->framerate;
4012 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4013 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4014 st->internal->info->codec_info_duration < 0)
4016 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4017 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4018 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4020 /* Round guessed framerate to a "standard" framerate if it's
4021 * within 1% of the original estimate. */
4022 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4023 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4024 double error = fabs(av_q2d(st->avg_frame_rate) /
4025 av_q2d(std_fps) - 1);
4027 if (error < best_error) {
4029 best_fps = std_fps.num;
4032 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4033 error = fabs(av_q2d(codec_frame_rate) /
4034 av_q2d(std_fps) - 1);
4035 if (error < best_error) {
4037 best_fps = std_fps.num;
4042 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4043 best_fps, 12 * 1001, INT_MAX);
4046 if (!st->r_frame_rate.num) {
4047 if ( avctx->time_base.den * (int64_t) st->time_base.num
4048 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4049 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4050 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4052 st->r_frame_rate.num = st->time_base.den;
4053 st->r_frame_rate.den = st->time_base.num;
4056 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4057 AVRational hw_ratio = { avctx->height, avctx->width };
4058 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4061 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4062 if (!avctx->bits_per_coded_sample)
4063 avctx->bits_per_coded_sample =
4064 av_get_bits_per_sample(avctx->codec_id);
4065 // set stream disposition based on audio service type
4066 switch (avctx->audio_service_type) {
4067 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4068 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4070 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4071 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4073 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4074 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4076 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4077 st->disposition = AV_DISPOSITION_COMMENT;
4079 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4080 st->disposition = AV_DISPOSITION_KARAOKE;
4087 estimate_timings(ic, old_offset);
4089 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4091 if (ret >= 0 && ic->nb_streams)
4092 /* We could not have all the codec parameters before EOF. */
4094 for (i = 0; i < ic->nb_streams; i++) {
4096 st = ic->streams[i];
4098 /* if no packet was ever seen, update context now for has_codec_parameters */
4099 if (!st->internal->avctx_inited) {
4100 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4101 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4102 st->codecpar->format = st->internal->avctx->sample_fmt;
4103 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4105 goto find_stream_info_err;
4107 if (!has_codec_parameters(st, &errmsg)) {
4109 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4110 av_log(ic, AV_LOG_WARNING,
4111 "Could not find codec parameters for stream %d (%s): %s\n"
4112 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4113 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4119 ret = compute_chapters_end(ic);
4121 goto find_stream_info_err;
4123 /* update the stream parameters from the internal codec contexts */
4124 for (i = 0; i < ic->nb_streams; i++) {
4125 st = ic->streams[i];
4127 if (st->internal->avctx_inited) {
4128 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4130 goto find_stream_info_err;
4131 ret = add_coded_side_data(st, st->internal->avctx);
4133 goto find_stream_info_err;
4136 #if FF_API_LAVF_AVCTX
4137 FF_DISABLE_DEPRECATION_WARNINGS
4138 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4140 goto find_stream_info_err;
4142 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4143 // by the lowres factor.
4144 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4145 st->codec->lowres = st->internal->avctx->lowres;
4146 st->codec->width = st->internal->avctx->width;
4147 st->codec->height = st->internal->avctx->height;
4150 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4151 st->codec->time_base = st->internal->avctx->time_base;
4152 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4154 st->codec->framerate = st->avg_frame_rate;
4156 if (st->internal->avctx->subtitle_header) {
4157 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4158 if (!st->codec->subtitle_header)
4159 goto find_stream_info_err;
4160 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4161 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4162 st->codec->subtitle_header_size);
4165 // Fields unavailable in AVCodecParameters
4166 st->codec->coded_width = st->internal->avctx->coded_width;
4167 st->codec->coded_height = st->internal->avctx->coded_height;
4168 st->codec->properties = st->internal->avctx->properties;
4169 FF_ENABLE_DEPRECATION_WARNINGS
4172 st->internal->avctx_inited = 0;
4175 find_stream_info_err:
4176 for (i = 0; i < ic->nb_streams; i++) {
4177 st = ic->streams[i];
4178 if (st->internal->info)
4179 av_freep(&st->internal->info->duration_error);
4180 avcodec_close(ic->streams[i]->internal->avctx);
4181 av_freep(&ic->streams[i]->internal->info);
4182 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4183 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4186 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4187 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4190 unref_then_goto_end:
4191 av_packet_unref(&pkt1);
4192 goto find_stream_info_err;
4195 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4199 for (i = 0; i < ic->nb_programs; i++) {
4200 if (ic->programs[i] == last) {
4204 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4205 if (ic->programs[i]->stream_index[j] == s)
4206 return ic->programs[i];
4212 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4213 int wanted_stream_nb, int related_stream,
4214 AVCodec **decoder_ret, int flags)
4216 int i, nb_streams = ic->nb_streams;
4217 int ret = AVERROR_STREAM_NOT_FOUND;
4218 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4219 int count, multiframe, disposition;
4220 int64_t best_bitrate = -1;
4222 unsigned *program = NULL;
4223 const AVCodec *decoder = NULL, *best_decoder = NULL;
4225 if (related_stream >= 0 && wanted_stream_nb < 0) {
4226 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4228 program = p->stream_index;
4229 nb_streams = p->nb_stream_indexes;
4232 for (i = 0; i < nb_streams; i++) {
4233 int real_stream_index = program ? program[i] : i;
4234 AVStream *st = ic->streams[real_stream_index];
4235 AVCodecParameters *par = st->codecpar;
4236 if (par->codec_type != type)
4238 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4240 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4243 decoder = find_decoder(ic, st, par->codec_id);
4246 ret = AVERROR_DECODER_NOT_FOUND;
4250 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4251 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4252 count = st->codec_info_nb_frames;
4253 bitrate = par->bit_rate;
4254 multiframe = FFMIN(5, count);
4255 if ((best_disposition > disposition) ||
4256 (best_disposition == disposition && best_multiframe > multiframe) ||
4257 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4258 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4260 best_disposition = disposition;
4262 best_bitrate = bitrate;
4263 best_multiframe = multiframe;
4264 ret = real_stream_index;
4265 best_decoder = decoder;
4266 if (program && i == nb_streams - 1 && ret < 0) {
4268 nb_streams = ic->nb_streams;
4269 /* no related stream found, try again with everything */
4274 *decoder_ret = (AVCodec*)best_decoder;
4278 /*******************************************************/
4280 int av_read_play(AVFormatContext *s)
4282 if (s->iformat->read_play)
4283 return s->iformat->read_play(s);
4285 return avio_pause(s->pb, 0);
4286 return AVERROR(ENOSYS);
4289 int av_read_pause(AVFormatContext *s)
4291 if (s->iformat->read_pause)
4292 return s->iformat->read_pause(s);
4294 return avio_pause(s->pb, 1);
4295 return AVERROR(ENOSYS);
4298 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4303 dst->time_base = src->time_base;
4304 dst->nb_frames = src->nb_frames;
4305 dst->disposition = src->disposition;
4306 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4307 dst->avg_frame_rate = src->avg_frame_rate;
4308 dst->r_frame_rate = src->r_frame_rate;
4310 av_dict_free(&dst->metadata);
4311 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4315 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4319 /* Free existing side data*/
4320 for (i = 0; i < dst->nb_side_data; i++)
4321 av_free(dst->side_data[i].data);
4322 av_freep(&dst->side_data);
4323 dst->nb_side_data = 0;
4325 /* Copy side data if present */
4326 if (src->nb_side_data) {
4327 dst->side_data = av_mallocz_array(src->nb_side_data,
4328 sizeof(AVPacketSideData));
4329 if (!dst->side_data)
4330 return AVERROR(ENOMEM);
4331 dst->nb_side_data = src->nb_side_data;
4333 for (i = 0; i < src->nb_side_data; i++) {
4334 uint8_t *data = av_memdup(src->side_data[i].data,
4335 src->side_data[i].size);
4337 return AVERROR(ENOMEM);
4338 dst->side_data[i].type = src->side_data[i].type;
4339 dst->side_data[i].size = src->side_data[i].size;
4340 dst->side_data[i].data = data;
4344 #if FF_API_LAVF_FFSERVER
4345 FF_DISABLE_DEPRECATION_WARNINGS
4346 av_freep(&dst->recommended_encoder_configuration);
4347 if (src->recommended_encoder_configuration) {
4348 const char *conf_str = src->recommended_encoder_configuration;
4349 dst->recommended_encoder_configuration = av_strdup(conf_str);
4350 if (!dst->recommended_encoder_configuration)
4351 return AVERROR(ENOMEM);
4353 FF_ENABLE_DEPRECATION_WARNINGS
4359 static void free_stream(AVStream **pst)
4361 AVStream *st = *pst;
4367 for (i = 0; i < st->nb_side_data; i++)
4368 av_freep(&st->side_data[i].data);
4369 av_freep(&st->side_data);
4372 av_parser_close(st->parser);
4374 if (st->attached_pic.data)
4375 av_packet_unref(&st->attached_pic);
4378 avcodec_free_context(&st->internal->avctx);
4379 av_bsf_free(&st->internal->bsfc);
4380 av_freep(&st->internal->priv_pts);
4381 av_freep(&st->internal->index_entries);
4382 av_freep(&st->internal->probe_data.buf);
4384 av_bsf_free(&st->internal->extract_extradata.bsf);
4385 av_packet_free(&st->internal->extract_extradata.pkt);
4387 if (st->internal->info)
4388 av_freep(&st->internal->info->duration_error);
4389 av_freep(&st->internal->info);
4391 av_freep(&st->internal);
4393 av_dict_free(&st->metadata);
4394 avcodec_parameters_free(&st->codecpar);
4395 #if FF_API_LAVF_AVCTX
4396 FF_DISABLE_DEPRECATION_WARNINGS
4397 avcodec_free_context(&st->codec);
4398 FF_ENABLE_DEPRECATION_WARNINGS
4400 av_freep(&st->priv_data);
4401 #if FF_API_LAVF_FFSERVER
4402 FF_DISABLE_DEPRECATION_WARNINGS
4403 av_freep(&st->recommended_encoder_configuration);
4404 FF_ENABLE_DEPRECATION_WARNINGS
4410 void ff_free_stream(AVFormatContext *s, AVStream *st)
4412 av_assert0(s->nb_streams>0);
4413 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4415 free_stream(&s->streams[ --s->nb_streams ]);
4418 void avformat_free_context(AVFormatContext *s)
4425 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4426 s->oformat->deinit(s);
4429 if (s->iformat && s->iformat->priv_class && s->priv_data)
4430 av_opt_free(s->priv_data);
4431 if (s->oformat && s->oformat->priv_class && s->priv_data)
4432 av_opt_free(s->priv_data);
4434 for (i = 0; i < s->nb_streams; i++)
4435 free_stream(&s->streams[i]);
4438 for (i = 0; i < s->nb_programs; i++) {
4439 av_dict_free(&s->programs[i]->metadata);
4440 av_freep(&s->programs[i]->stream_index);
4441 av_freep(&s->programs[i]);
4445 av_freep(&s->programs);
4446 av_freep(&s->priv_data);
4447 while (s->nb_chapters--) {
4448 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4449 av_freep(&s->chapters[s->nb_chapters]);
4451 av_freep(&s->chapters);
4452 av_dict_free(&s->metadata);
4453 av_dict_free(&s->internal->id3v2_meta);
4454 av_packet_free(&s->internal->pkt);
4455 av_freep(&s->streams);
4456 flush_packet_queue(s);
4457 av_freep(&s->internal);
4462 void avformat_close_input(AVFormatContext **ps)
4473 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4474 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4477 flush_packet_queue(s);
4480 if (s->iformat->read_close)
4481 s->iformat->read_close(s);
4483 avformat_free_context(s);
4490 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4496 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4497 if (s->max_streams < INT_MAX/sizeof(*streams))
4498 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4501 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4504 s->streams = streams;
4506 st = av_mallocz(sizeof(AVStream));
4510 #if FF_API_LAVF_AVCTX
4511 FF_DISABLE_DEPRECATION_WARNINGS
4512 st->codec = avcodec_alloc_context3(c);
4517 FF_ENABLE_DEPRECATION_WARNINGS
4520 st->internal = av_mallocz(sizeof(*st->internal));
4524 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4525 if (!st->internal->info)
4527 st->internal->info->last_dts = AV_NOPTS_VALUE;
4529 st->codecpar = avcodec_parameters_alloc();
4533 st->internal->avctx = avcodec_alloc_context3(NULL);
4534 if (!st->internal->avctx)
4538 #if FF_API_LAVF_AVCTX
4539 FF_DISABLE_DEPRECATION_WARNINGS
4540 /* no default bitrate if decoding */
4541 st->codec->bit_rate = 0;
4542 FF_ENABLE_DEPRECATION_WARNINGS
4545 /* default pts setting is MPEG-like */
4546 avpriv_set_pts_info(st, 33, 1, 90000);
4547 /* we set the current DTS to 0 so that formats without any timestamps
4548 * but durations get some timestamps, formats with some unknown
4549 * timestamps have their first few packets buffered and the
4550 * timestamps corrected before they are returned to the user */
4551 st->cur_dts = RELATIVE_TS_BASE;
4553 st->cur_dts = AV_NOPTS_VALUE;
4556 st->index = s->nb_streams;
4557 st->start_time = AV_NOPTS_VALUE;
4558 st->duration = AV_NOPTS_VALUE;
4559 st->first_dts = AV_NOPTS_VALUE;
4560 st->probe_packets = s->max_probe_packets;
4561 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4562 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4564 st->last_IP_pts = AV_NOPTS_VALUE;
4565 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4566 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4567 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4569 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4571 #if FF_API_R_FRAME_RATE
4572 st->internal->info->last_dts = AV_NOPTS_VALUE;
4574 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4575 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4577 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4579 st->internal->need_context_update = 1;
4581 s->streams[s->nb_streams++] = st;
4588 AVProgram *av_new_program(AVFormatContext *ac, int id)
4590 AVProgram *program = NULL;
4593 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4595 for (i = 0; i < ac->nb_programs; i++)
4596 if (ac->programs[i]->id == id)
4597 program = ac->programs[i];
4600 program = av_mallocz(sizeof(AVProgram));
4603 dynarray_add(&ac->programs, &ac->nb_programs, program);
4604 program->discard = AVDISCARD_NONE;
4605 program->pmt_version = -1;
4607 program->pts_wrap_reference = AV_NOPTS_VALUE;
4608 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4609 program->start_time =
4610 program->end_time = AV_NOPTS_VALUE;
4615 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4616 int64_t start, int64_t end, const char *title)
4618 AVChapter *chapter = NULL;
4621 if (end != AV_NOPTS_VALUE && start > end) {
4622 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4626 if (!s->nb_chapters) {
4627 s->internal->chapter_ids_monotonic = 1;
4628 } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4629 s->internal->chapter_ids_monotonic = 0;
4630 for (i = 0; i < s->nb_chapters; i++)
4631 if (s->chapters[i]->id == id)
4632 chapter = s->chapters[i];
4636 chapter = av_mallocz(sizeof(AVChapter));
4639 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4641 av_dict_set(&chapter->metadata, "title", title, 0);
4643 chapter->time_base = time_base;
4644 chapter->start = start;
4650 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4653 AVProgram *program = NULL;
4656 if (idx >= ac->nb_streams) {
4657 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4661 for (i = 0; i < ac->nb_programs; i++) {
4662 if (ac->programs[i]->id != progid)
4664 program = ac->programs[i];
4665 for (j = 0; j < program->nb_stream_indexes; j++)
4666 if (program->stream_index[j] == idx)
4669 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4672 program->stream_index = tmp;
4673 program->stream_index[program->nb_stream_indexes++] = idx;
4678 uint64_t ff_ntp_time(void)
4680 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4683 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4685 uint64_t ntp_ts, frac_part, sec;
4688 //current ntp time in seconds and micro seconds
4689 sec = ntp_time_us / 1000000;
4690 usec = ntp_time_us % 1000000;
4692 //encoding in ntp timestamp format
4693 frac_part = usec * 0xFFFFFFFFULL;
4694 frac_part /= 1000000;
4696 if (sec > 0xFFFFFFFFULL)
4697 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4700 ntp_ts |= frac_part;
4705 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4708 char *q, buf1[20], c;
4709 int nd, len, percentd_found;
4721 while (av_isdigit(*p)) {
4722 if (nd >= INT_MAX / 10 - 255)
4724 nd = nd * 10 + *p++ - '0';
4727 } while (av_isdigit(c));
4733 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4738 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4740 if ((q - buf + len) > buf_size - 1)
4742 memcpy(q, buf1, len);
4750 if ((q - buf) < buf_size - 1)
4754 if (!percentd_found)
4763 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4765 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4768 void av_url_split(char *proto, int proto_size,
4769 char *authorization, int authorization_size,
4770 char *hostname, int hostname_size,
4771 int *port_ptr, char *path, int path_size, const char *url)
4773 const char *p, *ls, *at, *at2, *col, *brk;
4779 if (authorization_size > 0)
4780 authorization[0] = 0;
4781 if (hostname_size > 0)
4786 /* parse protocol */
4787 if ((p = strchr(url, ':'))) {
4788 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4795 /* no protocol means plain filename */
4796 av_strlcpy(path, url, path_size);
4800 /* separate path from hostname */
4801 ls = p + strcspn(p, "/?#");
4802 av_strlcpy(path, ls, path_size);
4804 /* the rest is hostname, use that to parse auth/port */
4806 /* authorization (user[:pass]@hostname) */
4808 while ((at = strchr(p, '@')) && at < ls) {
4809 av_strlcpy(authorization, at2,
4810 FFMIN(authorization_size, at + 1 - at2));
4811 p = at + 1; /* skip '@' */
4814 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4816 av_strlcpy(hostname, p + 1,
4817 FFMIN(hostname_size, brk - p));
4818 if (brk[1] == ':' && port_ptr)
4819 *port_ptr = atoi(brk + 2);
4820 } else if ((col = strchr(p, ':')) && col < ls) {
4821 av_strlcpy(hostname, p,
4822 FFMIN(col + 1 - p, hostname_size));
4824 *port_ptr = atoi(col + 1);
4826 av_strlcpy(hostname, p,
4827 FFMIN(ls + 1 - p, hostname_size));
4831 int ff_mkdir_p(const char *path)
4834 char *temp = av_strdup(path);
4838 if (!path || !temp) {
4842 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4844 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4848 for ( ; *pos != '\0'; ++pos) {
4849 if (*pos == '/' || *pos == '\\') {
4852 ret = mkdir(temp, 0755);
4857 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4858 ret = mkdir(temp, 0755);
4865 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4868 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4871 'C', 'D', 'E', 'F' };
4872 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4875 'c', 'd', 'e', 'f' };
4876 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4878 for (i = 0; i < s; i++) {
4879 buff[i * 2] = hex_table[src[i] >> 4];
4880 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4886 int ff_hex_to_data(uint8_t *data, const char *p)
4893 p += strspn(p, SPACE_CHARS);
4896 c = av_toupper((unsigned char) *p++);
4897 if (c >= '0' && c <= '9')
4899 else if (c >= 'A' && c <= 'F')
4914 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4915 unsigned int pts_num, unsigned int pts_den)
4918 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4919 if (new_tb.num != pts_num)
4920 av_log(NULL, AV_LOG_DEBUG,
4921 "st:%d removing common factor %d from timebase\n",
4922 s->index, pts_num / new_tb.num);
4924 av_log(NULL, AV_LOG_WARNING,
4925 "st:%d has too large timebase, reducing\n", s->index);
4927 if (new_tb.num <= 0 || new_tb.den <= 0) {
4928 av_log(NULL, AV_LOG_ERROR,
4929 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4930 new_tb.num, new_tb.den,
4934 s->time_base = new_tb;
4935 #if FF_API_LAVF_AVCTX
4936 FF_DISABLE_DEPRECATION_WARNINGS
4937 s->codec->pkt_timebase = new_tb;
4938 FF_ENABLE_DEPRECATION_WARNINGS
4940 s->internal->avctx->pkt_timebase = new_tb;
4941 s->pts_wrap_bits = pts_wrap_bits;
4944 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4947 const char *ptr = str;
4949 /* Parse key=value pairs. */
4952 char *dest = NULL, *dest_end;
4953 int key_len, dest_len = 0;
4955 /* Skip whitespace and potential commas. */
4956 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4963 if (!(ptr = strchr(key, '=')))
4966 key_len = ptr - key;
4968 callback_get_buf(context, key, key_len, &dest, &dest_len);
4969 dest_end = dest + dest_len - 1;
4973 while (*ptr && *ptr != '\"') {
4977 if (dest && dest < dest_end)
4981 if (dest && dest < dest_end)
4989 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4990 if (dest && dest < dest_end)
4998 int ff_find_stream_index(AVFormatContext *s, int id)
5001 for (i = 0; i < s->nb_streams; i++)
5002 if (s->streams[i]->id == id)
5007 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5011 unsigned int codec_tag;
5012 if (ofmt->query_codec)
5013 return ofmt->query_codec(codec_id, std_compliance);
5014 else if (ofmt->codec_tag)
5015 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5016 else if (codec_id == ofmt->video_codec ||
5017 codec_id == ofmt->audio_codec ||
5018 codec_id == ofmt->subtitle_codec ||
5019 codec_id == ofmt->data_codec)
5022 return AVERROR_PATCHWELCOME;
5025 int avformat_network_init(void)
5029 if ((ret = ff_network_init()) < 0)
5031 if ((ret = ff_tls_init()) < 0)
5037 int avformat_network_deinit(void)
5046 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5047 uint64_t channel_layout, int32_t sample_rate,
5048 int32_t width, int32_t height)
5054 return AVERROR(EINVAL);
5057 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5059 if (channel_layout) {
5061 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5065 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5067 if (width || height) {
5069 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5071 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5073 return AVERROR(ENOMEM);
5074 bytestream_put_le32(&data, flags);
5076 bytestream_put_le32(&data, channels);
5078 bytestream_put_le64(&data, channel_layout);
5080 bytestream_put_le32(&data, sample_rate);
5081 if (width || height) {
5082 bytestream_put_le32(&data, width);
5083 bytestream_put_le32(&data, height);
5088 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5090 AVRational undef = {0, 1};
5091 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5092 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5093 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5095 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5096 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5097 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5098 stream_sample_aspect_ratio = undef;
5100 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5101 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5102 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5103 frame_sample_aspect_ratio = undef;
5105 if (stream_sample_aspect_ratio.num)
5106 return stream_sample_aspect_ratio;
5108 return frame_sample_aspect_ratio;
5111 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5113 AVRational fr = st->r_frame_rate;
5114 AVRational codec_fr = st->internal->avctx->framerate;
5115 AVRational avg_fr = st->avg_frame_rate;
5117 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5118 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5123 if (st->internal->avctx->ticks_per_frame > 1) {
5124 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5125 (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))
5133 * Matches a stream specifier (but ignores requested index).
5135 * @param indexptr set to point to the requested stream index if there is one
5137 * @return <0 on error
5138 * 0 if st is NOT a matching stream
5139 * >0 if st is a matching stream
5141 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5142 const char *spec, const char **indexptr, AVProgram **p)
5144 int match = 1; /* Stores if the specifier matches so far. */
5146 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5150 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5151 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5152 enum AVMediaType type;
5156 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5157 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5158 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5159 case 'd': type = AVMEDIA_TYPE_DATA; break;
5160 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5161 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5162 default: av_assert0(0);
5164 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5165 return AVERROR(EINVAL);
5167 #if FF_API_LAVF_AVCTX
5168 FF_DISABLE_DEPRECATION_WARNINGS
5169 if (type != st->codecpar->codec_type
5170 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5172 FF_ENABLE_DEPRECATION_WARNINGS
5174 if (type != st->codecpar->codec_type)
5177 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5179 } else if (*spec == 'p' && *(spec + 1) == ':') {
5184 prog_id = strtol(spec, &endptr, 0);
5185 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5186 if (spec == endptr || (*endptr && *endptr++ != ':'))
5187 return AVERROR(EINVAL);
5190 for (i = 0; i < s->nb_programs; i++) {
5191 if (s->programs[i]->id != prog_id)
5194 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5195 if (st->index == s->programs[i]->stream_index[j]) {
5198 *p = s->programs[i];
5207 } else if (*spec == '#' ||
5208 (*spec == 'i' && *(spec + 1) == ':')) {
5211 spec += 1 + (*spec == 'i');
5212 stream_id = strtol(spec, &endptr, 0);
5213 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5214 return AVERROR(EINVAL);
5215 return match && (stream_id == st->id);
5216 } else if (*spec == 'm' && *(spec + 1) == ':') {
5217 AVDictionaryEntry *tag;
5223 val = strchr(spec, ':');
5225 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5227 return AVERROR(ENOMEM);
5229 tag = av_dict_get(st->metadata, key, NULL, 0);
5231 if (!val || !strcmp(tag->value, val + 1))
5240 return match && ret;
5241 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5242 AVCodecParameters *par = st->codecpar;
5243 #if FF_API_LAVF_AVCTX
5244 FF_DISABLE_DEPRECATION_WARNINGS
5245 AVCodecContext *codec = st->codec;
5246 FF_ENABLE_DEPRECATION_WARNINGS
5249 switch (par->codec_type) {
5250 case AVMEDIA_TYPE_AUDIO:
5251 val = par->sample_rate && par->channels;
5252 #if FF_API_LAVF_AVCTX
5253 val = val || (codec->sample_rate && codec->channels);
5255 if (par->format == AV_SAMPLE_FMT_NONE
5256 #if FF_API_LAVF_AVCTX
5257 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5262 case AVMEDIA_TYPE_VIDEO:
5263 val = par->width && par->height;
5264 #if FF_API_LAVF_AVCTX
5265 val = val || (codec->width && codec->height);
5267 if (par->format == AV_PIX_FMT_NONE
5268 #if FF_API_LAVF_AVCTX
5269 && codec->pix_fmt == AV_PIX_FMT_NONE
5274 case AVMEDIA_TYPE_UNKNOWN:
5281 #if FF_API_LAVF_AVCTX
5282 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5284 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5287 return AVERROR(EINVAL);
5295 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5300 const char *indexptr = NULL;
5301 AVProgram *p = NULL;
5304 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5311 index = strtol(indexptr, &endptr, 0);
5312 if (*endptr) { /* We can't have anything after the requested index. */
5313 ret = AVERROR(EINVAL);
5317 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5318 if (spec == indexptr)
5319 return (index == st->index);
5321 /* If we requested a matching stream index, we have to ensure st is that. */
5322 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5323 for (int i = 0; i < nb_streams && index >= 0; i++) {
5324 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5325 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5328 if (ret > 0 && index-- == 0 && st == candidate)
5334 if (ret == AVERROR(EINVAL))
5335 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5339 int ff_generate_avci_extradata(AVStream *st)
5341 static const uint8_t avci100_1080p_extradata[] = {
5343 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5344 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5345 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5346 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5347 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5348 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5349 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5350 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5351 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5353 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5356 static const uint8_t avci100_1080i_extradata[] = {
5358 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5359 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5360 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5361 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5362 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5363 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5364 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5365 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5366 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5367 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5368 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5370 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5373 static const uint8_t avci50_1080p_extradata[] = {
5375 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5376 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5377 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5378 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5379 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5380 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5381 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5382 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5383 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5385 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5388 static const uint8_t avci50_1080i_extradata[] = {
5390 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5391 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5392 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5393 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5394 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5395 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5396 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5397 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5398 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5399 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5400 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5402 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5405 static const uint8_t avci100_720p_extradata[] = {
5407 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5408 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5409 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5410 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5411 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5412 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5413 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5414 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5415 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5416 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5418 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5421 static const uint8_t avci50_720p_extradata[] = {
5423 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5424 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5425 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5426 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5427 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5428 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5429 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5430 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5431 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5433 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5437 const uint8_t *data = NULL;
5440 if (st->codecpar->width == 1920) {
5441 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5442 data = avci100_1080p_extradata;
5443 size = sizeof(avci100_1080p_extradata);
5445 data = avci100_1080i_extradata;
5446 size = sizeof(avci100_1080i_extradata);
5448 } else if (st->codecpar->width == 1440) {
5449 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5450 data = avci50_1080p_extradata;
5451 size = sizeof(avci50_1080p_extradata);
5453 data = avci50_1080i_extradata;
5454 size = sizeof(avci50_1080i_extradata);
5456 } else if (st->codecpar->width == 1280) {
5457 data = avci100_720p_extradata;
5458 size = sizeof(avci100_720p_extradata);
5459 } else if (st->codecpar->width == 960) {
5460 data = avci50_720p_extradata;
5461 size = sizeof(avci50_720p_extradata);
5467 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5469 memcpy(st->codecpar->extradata, data, size);
5474 uint8_t *av_stream_get_side_data(const AVStream *st,
5475 enum AVPacketSideDataType type, buffer_size_t *size)
5479 for (i = 0; i < st->nb_side_data; i++) {
5480 if (st->side_data[i].type == type) {
5482 *size = st->side_data[i].size;
5483 return st->side_data[i].data;
5491 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5492 uint8_t *data, size_t size)
5494 AVPacketSideData *sd, *tmp;
5497 for (i = 0; i < st->nb_side_data; i++) {
5498 sd = &st->side_data[i];
5500 if (sd->type == type) {
5501 av_freep(&sd->data);
5508 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5509 return AVERROR(ERANGE);
5511 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5513 return AVERROR(ENOMEM);
5516 st->side_data = tmp;
5519 sd = &st->side_data[st->nb_side_data - 1];
5527 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5531 uint8_t *data = av_malloc(size);
5536 ret = av_stream_add_side_data(st, type, data, size);
5545 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5548 const AVBitStreamFilter *bsf;
5551 av_assert0(!st->internal->bsfc);
5553 if (!(bsf = av_bsf_get_by_name(name))) {
5554 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5555 return AVERROR_BSF_NOT_FOUND;
5558 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5561 bsfc->time_base_in = st->time_base;
5562 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5567 if (args && bsfc->filter->priv_class) {
5568 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5569 const char * shorthand[2] = {NULL};
5572 shorthand[0] = opt->name;
5574 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5580 if ((ret = av_bsf_init(bsfc)) < 0) {
5585 st->internal->bsfc = bsfc;
5587 av_log(NULL, AV_LOG_VERBOSE,
5588 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5589 name, args ? args : "");
5594 FF_DISABLE_DEPRECATION_WARNINGS
5595 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5596 AVBitStreamFilterContext *bsfc)
5600 AVPacket new_pkt = *pkt;
5601 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5602 &new_pkt.data, &new_pkt.size,
5603 pkt->data, pkt->size,
5604 pkt->flags & AV_PKT_FLAG_KEY);
5605 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5606 av_packet_unref(pkt);
5607 memset(pkt, 0, sizeof(*pkt));
5610 if(a == 0 && new_pkt.data != pkt->data) {
5611 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
5613 memcpy(t, new_pkt.data, new_pkt.size);
5614 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5619 a = AVERROR(ENOMEM);
5623 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5624 av_buffer_default_free, NULL, 0);
5626 pkt->side_data = NULL;
5627 pkt->side_data_elems = 0;
5628 av_packet_unref(pkt);
5630 av_freep(&new_pkt.data);
5631 a = AVERROR(ENOMEM);
5635 av_log(codec, AV_LOG_ERROR,
5636 "Failed to open bitstream filter %s for stream %d with codec %s",
5637 bsfc->filter->name, pkt->stream_index,
5638 codec->codec ? codec->codec->name : "copy");
5648 FF_ENABLE_DEPRECATION_WARNINGS
5651 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5654 return AVERROR(EINVAL);
5656 if (!(s->oformat->flags & AVFMT_NOFILE))
5657 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5661 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5664 s->io_close(s, *pb);
5668 int ff_is_http_proto(char *filename) {
5669 const char *proto = avio_find_protocol_name(filename);
5670 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5673 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5675 AVDictionaryEntry *entry;
5676 int64_t parsed_timestamp;
5678 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5679 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5680 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5683 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5690 int ff_standardize_creation_time(AVFormatContext *s)
5693 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5695 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5699 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5704 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5706 if (size != AVPALETTE_SIZE) {
5707 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5708 return AVERROR_INVALIDDATA;
5710 memcpy(palette, side_data, AVPALETTE_SIZE);
5714 if (ret == CONTAINS_PAL) {
5716 for (i = 0; i < AVPALETTE_COUNT; i++)
5717 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5724 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5729 ret = av_bprint_finalize(buf, &str);
5732 if (!av_bprint_is_complete(buf)) {
5734 return AVERROR(ENOMEM);
5737 par->extradata = str;
5738 /* Note: the string is NUL terminated (so extradata can be read as a
5739 * string), but the ending character is not accounted in the size (in
5740 * binary formats you are likely not supposed to mux that character). When
5741 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5743 par->extradata_size = buf->len;
5747 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5748 AVStream *ost, const AVStream *ist,
5749 enum AVTimebaseSource copy_tb)
5751 //TODO: use [io]st->internal->avctx
5752 const AVCodecContext *dec_ctx;
5753 AVCodecContext *enc_ctx;
5755 #if FF_API_LAVF_AVCTX
5756 FF_DISABLE_DEPRECATION_WARNINGS
5757 dec_ctx = ist->codec;
5758 enc_ctx = ost->codec;
5759 FF_ENABLE_DEPRECATION_WARNINGS
5761 dec_ctx = ist->internal->avctx;
5762 enc_ctx = ost->internal->avctx;
5765 enc_ctx->time_base = ist->time_base;
5767 * Avi is a special case here because it supports variable fps but
5768 * having the fps and timebase differe significantly adds quite some
5771 if (!strcmp(ofmt->name, "avi")) {
5772 #if FF_API_R_FRAME_RATE
5773 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5774 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5775 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5776 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5777 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5778 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5779 enc_ctx->time_base.num = ist->r_frame_rate.den;
5780 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5781 enc_ctx->ticks_per_frame = 2;
5784 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5785 && av_q2d(ist->time_base) < 1.0/500
5786 || copy_tb == AVFMT_TBCF_DECODER) {
5787 enc_ctx->time_base = dec_ctx->time_base;
5788 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5789 enc_ctx->time_base.den *= 2;
5790 enc_ctx->ticks_per_frame = 2;
5792 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5793 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5794 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5795 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5796 && av_q2d(ist->time_base) < 1.0/500
5797 || copy_tb == AVFMT_TBCF_DECODER) {
5798 enc_ctx->time_base = dec_ctx->time_base;
5799 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5803 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5804 && dec_ctx->time_base.num < dec_ctx->time_base.den
5805 && dec_ctx->time_base.num > 0
5806 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5807 enc_ctx->time_base = dec_ctx->time_base;
5810 if (ost->avg_frame_rate.num)
5811 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5813 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5814 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5819 AVRational av_stream_get_codec_timebase(const AVStream *st)
5821 // See avformat_transfer_internal_stream_timing_info() TODO.
5822 #if FF_API_LAVF_AVCTX
5823 FF_DISABLE_DEPRECATION_WARNINGS
5824 return st->codec->time_base;
5825 FF_ENABLE_DEPRECATION_WARNINGS
5827 return st->internal->avctx->time_base;
5831 void ff_format_set_url(AVFormatContext *s, char *url)
5836 #if FF_API_FORMAT_FILENAME
5837 FF_DISABLE_DEPRECATION_WARNINGS
5838 av_strlcpy(s->filename, url, sizeof(s->filename));
5839 FF_ENABLE_DEPRECATION_WARNINGS