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 AVPacketList *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 AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *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 AVPacketList *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 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1109 AVPacketList *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 AVPacketList *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 AVPacketList *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_freep(&s->streams);
4455 flush_packet_queue(s);
4456 av_freep(&s->internal);
4461 void avformat_close_input(AVFormatContext **ps)
4472 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4473 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4476 flush_packet_queue(s);
4479 if (s->iformat->read_close)
4480 s->iformat->read_close(s);
4482 avformat_free_context(s);
4489 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4495 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4496 if (s->max_streams < INT_MAX/sizeof(*streams))
4497 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);
4500 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4503 s->streams = streams;
4505 st = av_mallocz(sizeof(AVStream));
4509 #if FF_API_LAVF_AVCTX
4510 FF_DISABLE_DEPRECATION_WARNINGS
4511 st->codec = avcodec_alloc_context3(c);
4516 FF_ENABLE_DEPRECATION_WARNINGS
4519 st->internal = av_mallocz(sizeof(*st->internal));
4523 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4524 if (!st->internal->info)
4526 st->internal->info->last_dts = AV_NOPTS_VALUE;
4528 st->codecpar = avcodec_parameters_alloc();
4532 st->internal->avctx = avcodec_alloc_context3(NULL);
4533 if (!st->internal->avctx)
4537 #if FF_API_LAVF_AVCTX
4538 FF_DISABLE_DEPRECATION_WARNINGS
4539 /* no default bitrate if decoding */
4540 st->codec->bit_rate = 0;
4541 FF_ENABLE_DEPRECATION_WARNINGS
4544 /* default pts setting is MPEG-like */
4545 avpriv_set_pts_info(st, 33, 1, 90000);
4546 /* we set the current DTS to 0 so that formats without any timestamps
4547 * but durations get some timestamps, formats with some unknown
4548 * timestamps have their first few packets buffered and the
4549 * timestamps corrected before they are returned to the user */
4550 st->cur_dts = RELATIVE_TS_BASE;
4552 st->cur_dts = AV_NOPTS_VALUE;
4555 st->index = s->nb_streams;
4556 st->start_time = AV_NOPTS_VALUE;
4557 st->duration = AV_NOPTS_VALUE;
4558 st->first_dts = AV_NOPTS_VALUE;
4559 st->probe_packets = s->max_probe_packets;
4560 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4561 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4563 st->last_IP_pts = AV_NOPTS_VALUE;
4564 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4565 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4566 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4568 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4570 #if FF_API_R_FRAME_RATE
4571 st->internal->info->last_dts = AV_NOPTS_VALUE;
4573 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4574 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4576 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4578 st->internal->need_context_update = 1;
4580 s->streams[s->nb_streams++] = st;
4587 AVProgram *av_new_program(AVFormatContext *ac, int id)
4589 AVProgram *program = NULL;
4592 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4594 for (i = 0; i < ac->nb_programs; i++)
4595 if (ac->programs[i]->id == id)
4596 program = ac->programs[i];
4599 program = av_mallocz(sizeof(AVProgram));
4602 dynarray_add(&ac->programs, &ac->nb_programs, program);
4603 program->discard = AVDISCARD_NONE;
4604 program->pmt_version = -1;
4606 program->pts_wrap_reference = AV_NOPTS_VALUE;
4607 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4608 program->start_time =
4609 program->end_time = AV_NOPTS_VALUE;
4614 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4615 int64_t start, int64_t end, const char *title)
4617 AVChapter *chapter = NULL;
4620 if (end != AV_NOPTS_VALUE && start > end) {
4621 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4625 if (!s->nb_chapters) {
4626 s->internal->chapter_ids_monotonic = 1;
4627 } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4628 s->internal->chapter_ids_monotonic = 0;
4629 for (i = 0; i < s->nb_chapters; i++)
4630 if (s->chapters[i]->id == id)
4631 chapter = s->chapters[i];
4635 chapter = av_mallocz(sizeof(AVChapter));
4638 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4640 av_dict_set(&chapter->metadata, "title", title, 0);
4642 chapter->time_base = time_base;
4643 chapter->start = start;
4649 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4652 AVProgram *program = NULL;
4655 if (idx >= ac->nb_streams) {
4656 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4660 for (i = 0; i < ac->nb_programs; i++) {
4661 if (ac->programs[i]->id != progid)
4663 program = ac->programs[i];
4664 for (j = 0; j < program->nb_stream_indexes; j++)
4665 if (program->stream_index[j] == idx)
4668 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4671 program->stream_index = tmp;
4672 program->stream_index[program->nb_stream_indexes++] = idx;
4677 uint64_t ff_ntp_time(void)
4679 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4682 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4684 uint64_t ntp_ts, frac_part, sec;
4687 //current ntp time in seconds and micro seconds
4688 sec = ntp_time_us / 1000000;
4689 usec = ntp_time_us % 1000000;
4691 //encoding in ntp timestamp format
4692 frac_part = usec * 0xFFFFFFFFULL;
4693 frac_part /= 1000000;
4695 if (sec > 0xFFFFFFFFULL)
4696 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4699 ntp_ts |= frac_part;
4704 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4707 char *q, buf1[20], c;
4708 int nd, len, percentd_found;
4720 while (av_isdigit(*p)) {
4721 if (nd >= INT_MAX / 10 - 255)
4723 nd = nd * 10 + *p++ - '0';
4726 } while (av_isdigit(c));
4732 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4737 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4739 if ((q - buf + len) > buf_size - 1)
4741 memcpy(q, buf1, len);
4749 if ((q - buf) < buf_size - 1)
4753 if (!percentd_found)
4762 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4764 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4767 void av_url_split(char *proto, int proto_size,
4768 char *authorization, int authorization_size,
4769 char *hostname, int hostname_size,
4770 int *port_ptr, char *path, int path_size, const char *url)
4772 const char *p, *ls, *at, *at2, *col, *brk;
4778 if (authorization_size > 0)
4779 authorization[0] = 0;
4780 if (hostname_size > 0)
4785 /* parse protocol */
4786 if ((p = strchr(url, ':'))) {
4787 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4794 /* no protocol means plain filename */
4795 av_strlcpy(path, url, path_size);
4799 /* separate path from hostname */
4800 ls = p + strcspn(p, "/?#");
4801 av_strlcpy(path, ls, path_size);
4803 /* the rest is hostname, use that to parse auth/port */
4805 /* authorization (user[:pass]@hostname) */
4807 while ((at = strchr(p, '@')) && at < ls) {
4808 av_strlcpy(authorization, at2,
4809 FFMIN(authorization_size, at + 1 - at2));
4810 p = at + 1; /* skip '@' */
4813 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4815 av_strlcpy(hostname, p + 1,
4816 FFMIN(hostname_size, brk - p));
4817 if (brk[1] == ':' && port_ptr)
4818 *port_ptr = atoi(brk + 2);
4819 } else if ((col = strchr(p, ':')) && col < ls) {
4820 av_strlcpy(hostname, p,
4821 FFMIN(col + 1 - p, hostname_size));
4823 *port_ptr = atoi(col + 1);
4825 av_strlcpy(hostname, p,
4826 FFMIN(ls + 1 - p, hostname_size));
4830 int ff_mkdir_p(const char *path)
4833 char *temp = av_strdup(path);
4837 if (!path || !temp) {
4841 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4843 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4847 for ( ; *pos != '\0'; ++pos) {
4848 if (*pos == '/' || *pos == '\\') {
4851 ret = mkdir(temp, 0755);
4856 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4857 ret = mkdir(temp, 0755);
4864 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4867 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4870 'C', 'D', 'E', 'F' };
4871 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4874 'c', 'd', 'e', 'f' };
4875 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4877 for (i = 0; i < s; i++) {
4878 buff[i * 2] = hex_table[src[i] >> 4];
4879 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4885 int ff_hex_to_data(uint8_t *data, const char *p)
4892 p += strspn(p, SPACE_CHARS);
4895 c = av_toupper((unsigned char) *p++);
4896 if (c >= '0' && c <= '9')
4898 else if (c >= 'A' && c <= 'F')
4913 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4914 unsigned int pts_num, unsigned int pts_den)
4917 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4918 if (new_tb.num != pts_num)
4919 av_log(NULL, AV_LOG_DEBUG,
4920 "st:%d removing common factor %d from timebase\n",
4921 s->index, pts_num / new_tb.num);
4923 av_log(NULL, AV_LOG_WARNING,
4924 "st:%d has too large timebase, reducing\n", s->index);
4926 if (new_tb.num <= 0 || new_tb.den <= 0) {
4927 av_log(NULL, AV_LOG_ERROR,
4928 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4929 new_tb.num, new_tb.den,
4933 s->time_base = new_tb;
4934 #if FF_API_LAVF_AVCTX
4935 FF_DISABLE_DEPRECATION_WARNINGS
4936 s->codec->pkt_timebase = new_tb;
4937 FF_ENABLE_DEPRECATION_WARNINGS
4939 s->internal->avctx->pkt_timebase = new_tb;
4940 s->pts_wrap_bits = pts_wrap_bits;
4943 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4946 const char *ptr = str;
4948 /* Parse key=value pairs. */
4951 char *dest = NULL, *dest_end;
4952 int key_len, dest_len = 0;
4954 /* Skip whitespace and potential commas. */
4955 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4962 if (!(ptr = strchr(key, '=')))
4965 key_len = ptr - key;
4967 callback_get_buf(context, key, key_len, &dest, &dest_len);
4968 dest_end = dest + dest_len - 1;
4972 while (*ptr && *ptr != '\"') {
4976 if (dest && dest < dest_end)
4980 if (dest && dest < dest_end)
4988 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4989 if (dest && dest < dest_end)
4997 int ff_find_stream_index(AVFormatContext *s, int id)
5000 for (i = 0; i < s->nb_streams; i++)
5001 if (s->streams[i]->id == id)
5006 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5010 unsigned int codec_tag;
5011 if (ofmt->query_codec)
5012 return ofmt->query_codec(codec_id, std_compliance);
5013 else if (ofmt->codec_tag)
5014 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5015 else if (codec_id == ofmt->video_codec ||
5016 codec_id == ofmt->audio_codec ||
5017 codec_id == ofmt->subtitle_codec ||
5018 codec_id == ofmt->data_codec)
5021 return AVERROR_PATCHWELCOME;
5024 int avformat_network_init(void)
5028 if ((ret = ff_network_init()) < 0)
5030 if ((ret = ff_tls_init()) < 0)
5036 int avformat_network_deinit(void)
5045 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5046 uint64_t channel_layout, int32_t sample_rate,
5047 int32_t width, int32_t height)
5053 return AVERROR(EINVAL);
5056 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5058 if (channel_layout) {
5060 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5064 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5066 if (width || height) {
5068 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5070 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5072 return AVERROR(ENOMEM);
5073 bytestream_put_le32(&data, flags);
5075 bytestream_put_le32(&data, channels);
5077 bytestream_put_le64(&data, channel_layout);
5079 bytestream_put_le32(&data, sample_rate);
5080 if (width || height) {
5081 bytestream_put_le32(&data, width);
5082 bytestream_put_le32(&data, height);
5087 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5089 AVRational undef = {0, 1};
5090 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5091 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5092 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5094 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5095 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5096 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5097 stream_sample_aspect_ratio = undef;
5099 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5100 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5101 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5102 frame_sample_aspect_ratio = undef;
5104 if (stream_sample_aspect_ratio.num)
5105 return stream_sample_aspect_ratio;
5107 return frame_sample_aspect_ratio;
5110 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5112 AVRational fr = st->r_frame_rate;
5113 AVRational codec_fr = st->internal->avctx->framerate;
5114 AVRational avg_fr = st->avg_frame_rate;
5116 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5117 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5122 if (st->internal->avctx->ticks_per_frame > 1) {
5123 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5124 (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))
5132 * Matches a stream specifier (but ignores requested index).
5134 * @param indexptr set to point to the requested stream index if there is one
5136 * @return <0 on error
5137 * 0 if st is NOT a matching stream
5138 * >0 if st is a matching stream
5140 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5141 const char *spec, const char **indexptr, AVProgram **p)
5143 int match = 1; /* Stores if the specifier matches so far. */
5145 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5149 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5150 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5151 enum AVMediaType type;
5155 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5156 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5157 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5158 case 'd': type = AVMEDIA_TYPE_DATA; break;
5159 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5160 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5161 default: av_assert0(0);
5163 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5164 return AVERROR(EINVAL);
5166 #if FF_API_LAVF_AVCTX
5167 FF_DISABLE_DEPRECATION_WARNINGS
5168 if (type != st->codecpar->codec_type
5169 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5171 FF_ENABLE_DEPRECATION_WARNINGS
5173 if (type != st->codecpar->codec_type)
5176 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5178 } else if (*spec == 'p' && *(spec + 1) == ':') {
5183 prog_id = strtol(spec, &endptr, 0);
5184 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5185 if (spec == endptr || (*endptr && *endptr++ != ':'))
5186 return AVERROR(EINVAL);
5189 for (i = 0; i < s->nb_programs; i++) {
5190 if (s->programs[i]->id != prog_id)
5193 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5194 if (st->index == s->programs[i]->stream_index[j]) {
5197 *p = s->programs[i];
5206 } else if (*spec == '#' ||
5207 (*spec == 'i' && *(spec + 1) == ':')) {
5210 spec += 1 + (*spec == 'i');
5211 stream_id = strtol(spec, &endptr, 0);
5212 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5213 return AVERROR(EINVAL);
5214 return match && (stream_id == st->id);
5215 } else if (*spec == 'm' && *(spec + 1) == ':') {
5216 AVDictionaryEntry *tag;
5222 val = strchr(spec, ':');
5224 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5226 return AVERROR(ENOMEM);
5228 tag = av_dict_get(st->metadata, key, NULL, 0);
5230 if (!val || !strcmp(tag->value, val + 1))
5239 return match && ret;
5240 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5241 AVCodecParameters *par = st->codecpar;
5242 #if FF_API_LAVF_AVCTX
5243 FF_DISABLE_DEPRECATION_WARNINGS
5244 AVCodecContext *codec = st->codec;
5245 FF_ENABLE_DEPRECATION_WARNINGS
5248 switch (par->codec_type) {
5249 case AVMEDIA_TYPE_AUDIO:
5250 val = par->sample_rate && par->channels;
5251 #if FF_API_LAVF_AVCTX
5252 val = val || (codec->sample_rate && codec->channels);
5254 if (par->format == AV_SAMPLE_FMT_NONE
5255 #if FF_API_LAVF_AVCTX
5256 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5261 case AVMEDIA_TYPE_VIDEO:
5262 val = par->width && par->height;
5263 #if FF_API_LAVF_AVCTX
5264 val = val || (codec->width && codec->height);
5266 if (par->format == AV_PIX_FMT_NONE
5267 #if FF_API_LAVF_AVCTX
5268 && codec->pix_fmt == AV_PIX_FMT_NONE
5273 case AVMEDIA_TYPE_UNKNOWN:
5280 #if FF_API_LAVF_AVCTX
5281 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5283 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5286 return AVERROR(EINVAL);
5294 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5299 const char *indexptr = NULL;
5300 AVProgram *p = NULL;
5303 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5310 index = strtol(indexptr, &endptr, 0);
5311 if (*endptr) { /* We can't have anything after the requested index. */
5312 ret = AVERROR(EINVAL);
5316 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5317 if (spec == indexptr)
5318 return (index == st->index);
5320 /* If we requested a matching stream index, we have to ensure st is that. */
5321 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5322 for (int i = 0; i < nb_streams && index >= 0; i++) {
5323 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5324 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5327 if (ret > 0 && index-- == 0 && st == candidate)
5333 if (ret == AVERROR(EINVAL))
5334 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5338 int ff_generate_avci_extradata(AVStream *st)
5340 static const uint8_t avci100_1080p_extradata[] = {
5342 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5343 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5344 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5345 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5346 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5347 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5348 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5349 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5350 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5352 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5355 static const uint8_t avci100_1080i_extradata[] = {
5357 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5358 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5359 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5360 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5361 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5362 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5363 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5364 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5365 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5366 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5367 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5369 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5372 static const uint8_t avci50_1080p_extradata[] = {
5374 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5375 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5376 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5377 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5378 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5379 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5380 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5381 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5382 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5384 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5387 static const uint8_t avci50_1080i_extradata[] = {
5389 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5390 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5391 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5392 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5393 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5394 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5395 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5396 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5397 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5398 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5399 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5401 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5404 static const uint8_t avci100_720p_extradata[] = {
5406 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5407 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5408 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5409 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5410 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5411 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5412 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5413 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5414 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5415 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5417 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5420 static const uint8_t avci50_720p_extradata[] = {
5422 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5423 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5424 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5425 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5426 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5427 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5428 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5429 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5430 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5432 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5436 const uint8_t *data = NULL;
5439 if (st->codecpar->width == 1920) {
5440 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5441 data = avci100_1080p_extradata;
5442 size = sizeof(avci100_1080p_extradata);
5444 data = avci100_1080i_extradata;
5445 size = sizeof(avci100_1080i_extradata);
5447 } else if (st->codecpar->width == 1440) {
5448 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5449 data = avci50_1080p_extradata;
5450 size = sizeof(avci50_1080p_extradata);
5452 data = avci50_1080i_extradata;
5453 size = sizeof(avci50_1080i_extradata);
5455 } else if (st->codecpar->width == 1280) {
5456 data = avci100_720p_extradata;
5457 size = sizeof(avci100_720p_extradata);
5458 } else if (st->codecpar->width == 960) {
5459 data = avci50_720p_extradata;
5460 size = sizeof(avci50_720p_extradata);
5466 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5468 memcpy(st->codecpar->extradata, data, size);
5473 uint8_t *av_stream_get_side_data(const AVStream *st,
5474 enum AVPacketSideDataType type, buffer_size_t *size)
5478 for (i = 0; i < st->nb_side_data; i++) {
5479 if (st->side_data[i].type == type) {
5481 *size = st->side_data[i].size;
5482 return st->side_data[i].data;
5490 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5491 uint8_t *data, size_t size)
5493 AVPacketSideData *sd, *tmp;
5496 for (i = 0; i < st->nb_side_data; i++) {
5497 sd = &st->side_data[i];
5499 if (sd->type == type) {
5500 av_freep(&sd->data);
5507 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5508 return AVERROR(ERANGE);
5510 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5512 return AVERROR(ENOMEM);
5515 st->side_data = tmp;
5518 sd = &st->side_data[st->nb_side_data - 1];
5526 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5530 uint8_t *data = av_malloc(size);
5535 ret = av_stream_add_side_data(st, type, data, size);
5544 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5547 const AVBitStreamFilter *bsf;
5550 av_assert0(!st->internal->bsfc);
5552 if (!(bsf = av_bsf_get_by_name(name))) {
5553 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5554 return AVERROR_BSF_NOT_FOUND;
5557 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5560 bsfc->time_base_in = st->time_base;
5561 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5566 if (args && bsfc->filter->priv_class) {
5567 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5568 const char * shorthand[2] = {NULL};
5571 shorthand[0] = opt->name;
5573 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5579 if ((ret = av_bsf_init(bsfc)) < 0) {
5584 st->internal->bsfc = bsfc;
5586 av_log(NULL, AV_LOG_VERBOSE,
5587 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5588 name, args ? args : "");
5593 FF_DISABLE_DEPRECATION_WARNINGS
5594 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5595 AVBitStreamFilterContext *bsfc)
5599 AVPacket new_pkt = *pkt;
5600 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5601 &new_pkt.data, &new_pkt.size,
5602 pkt->data, pkt->size,
5603 pkt->flags & AV_PKT_FLAG_KEY);
5604 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5605 av_packet_unref(pkt);
5606 memset(pkt, 0, sizeof(*pkt));
5609 if(a == 0 && new_pkt.data != pkt->data) {
5610 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
5612 memcpy(t, new_pkt.data, new_pkt.size);
5613 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5618 a = AVERROR(ENOMEM);
5622 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5623 av_buffer_default_free, NULL, 0);
5625 pkt->side_data = NULL;
5626 pkt->side_data_elems = 0;
5627 av_packet_unref(pkt);
5629 av_freep(&new_pkt.data);
5630 a = AVERROR(ENOMEM);
5634 av_log(codec, AV_LOG_ERROR,
5635 "Failed to open bitstream filter %s for stream %d with codec %s",
5636 bsfc->filter->name, pkt->stream_index,
5637 codec->codec ? codec->codec->name : "copy");
5647 FF_ENABLE_DEPRECATION_WARNINGS
5650 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5653 return AVERROR(EINVAL);
5655 if (!(s->oformat->flags & AVFMT_NOFILE))
5656 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5660 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5663 s->io_close(s, *pb);
5667 int ff_is_http_proto(char *filename) {
5668 const char *proto = avio_find_protocol_name(filename);
5669 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5672 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5674 AVDictionaryEntry *entry;
5675 int64_t parsed_timestamp;
5677 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5678 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5679 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5682 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5689 int ff_standardize_creation_time(AVFormatContext *s)
5692 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5694 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5698 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5703 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5705 if (size != AVPALETTE_SIZE) {
5706 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5707 return AVERROR_INVALIDDATA;
5709 memcpy(palette, side_data, AVPALETTE_SIZE);
5713 if (ret == CONTAINS_PAL) {
5715 for (i = 0; i < AVPALETTE_COUNT; i++)
5716 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5723 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5728 ret = av_bprint_finalize(buf, &str);
5731 if (!av_bprint_is_complete(buf)) {
5733 return AVERROR(ENOMEM);
5736 par->extradata = str;
5737 /* Note: the string is NUL terminated (so extradata can be read as a
5738 * string), but the ending character is not accounted in the size (in
5739 * binary formats you are likely not supposed to mux that character). When
5740 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5742 par->extradata_size = buf->len;
5746 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5747 AVStream *ost, const AVStream *ist,
5748 enum AVTimebaseSource copy_tb)
5750 //TODO: use [io]st->internal->avctx
5751 const AVCodecContext *dec_ctx;
5752 AVCodecContext *enc_ctx;
5754 #if FF_API_LAVF_AVCTX
5755 FF_DISABLE_DEPRECATION_WARNINGS
5756 dec_ctx = ist->codec;
5757 enc_ctx = ost->codec;
5758 FF_ENABLE_DEPRECATION_WARNINGS
5760 dec_ctx = ist->internal->avctx;
5761 enc_ctx = ost->internal->avctx;
5764 enc_ctx->time_base = ist->time_base;
5766 * Avi is a special case here because it supports variable fps but
5767 * having the fps and timebase differe significantly adds quite some
5770 if (!strcmp(ofmt->name, "avi")) {
5771 #if FF_API_R_FRAME_RATE
5772 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5773 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5774 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5775 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5776 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5777 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5778 enc_ctx->time_base.num = ist->r_frame_rate.den;
5779 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5780 enc_ctx->ticks_per_frame = 2;
5783 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5784 && av_q2d(ist->time_base) < 1.0/500
5785 || copy_tb == AVFMT_TBCF_DECODER) {
5786 enc_ctx->time_base = dec_ctx->time_base;
5787 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5788 enc_ctx->time_base.den *= 2;
5789 enc_ctx->ticks_per_frame = 2;
5791 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5792 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5793 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5794 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5795 && av_q2d(ist->time_base) < 1.0/500
5796 || copy_tb == AVFMT_TBCF_DECODER) {
5797 enc_ctx->time_base = dec_ctx->time_base;
5798 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5802 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5803 && dec_ctx->time_base.num < dec_ctx->time_base.den
5804 && dec_ctx->time_base.num > 0
5805 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5806 enc_ctx->time_base = dec_ctx->time_base;
5809 if (ost->avg_frame_rate.num)
5810 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5812 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5813 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5818 AVRational av_stream_get_codec_timebase(const AVStream *st)
5820 // See avformat_transfer_internal_stream_timing_info() TODO.
5821 #if FF_API_LAVF_AVCTX
5822 FF_DISABLE_DEPRECATION_WARNINGS
5823 return st->codec->time_base;
5824 FF_ENABLE_DEPRECATION_WARNINGS
5826 return st->internal->avctx->time_base;
5830 void ff_format_set_url(AVFormatContext *s, char *url)
5835 #if FF_API_FORMAT_FILENAME
5836 FF_DISABLE_DEPRECATION_WARNINGS
5837 av_strlcpy(s->filename, url, sizeof(s->filename));
5838 FF_ENABLE_DEPRECATION_WARNINGS