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 &&
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 remaining= s->maxsize - avio_tell(s);
248 if (remaining < size) {
249 int64_t newsize = avio_size(s);
250 if (!s->maxsize || s->maxsize<newsize)
251 s->maxsize = newsize - !newsize;
252 remaining= s->maxsize - avio_tell(s);
253 remaining= FFMAX(remaining, 0);
256 if (s->maxsize>= 0 && remaining+1 < size) {
257 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
264 /* Read the data in sane-sized chunks and append to pkt.
265 * Return the number of bytes read or an error. */
266 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
268 int orig_size = pkt->size;
272 int prev_size = pkt->size;
275 /* When the caller requests a lot of data, limit it to the amount
276 * left in file or SANE_CHUNK_SIZE when it is not known. */
278 if (read_size > SANE_CHUNK_SIZE/10) {
279 read_size = ffio_limit(s, read_size);
280 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
282 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
285 ret = av_grow_packet(pkt, read_size);
289 ret = avio_read(s, pkt->data + prev_size, read_size);
290 if (ret != read_size) {
291 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
298 pkt->flags |= AV_PKT_FLAG_CORRUPT;
301 av_packet_unref(pkt);
302 return pkt->size > orig_size ? pkt->size - orig_size : ret;
305 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
310 pkt->pos = avio_tell(s);
312 return append_packet_chunked(s, pkt, size);
315 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
318 return av_get_packet(s, pkt, size);
319 return append_packet_chunked(s, pkt, size);
322 int av_filename_number_test(const char *filename)
326 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
329 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
332 static const struct {
335 enum AVMediaType type;
337 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
338 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
339 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
340 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
341 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
342 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
343 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
344 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
345 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
346 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
347 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
348 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
349 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
350 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
351 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
355 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
359 av_log(s, AV_LOG_DEBUG,
360 "Probe with size=%d, packets=%d detected %s with score=%d\n",
361 pd->buf_size, s->max_probe_packets - st->probe_packets,
363 for (i = 0; fmt_id_type[i].name; i++) {
364 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
365 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
366 st->codecpar->sample_rate)
368 if (st->request_probe > score &&
369 st->codecpar->codec_id != fmt_id_type[i].id)
371 st->codecpar->codec_id = fmt_id_type[i].id;
372 st->codecpar->codec_type = fmt_id_type[i].type;
373 st->internal->need_context_update = 1;
374 #if FF_API_LAVF_AVCTX
375 FF_DISABLE_DEPRECATION_WARNINGS
376 st->codec->codec_type = st->codecpar->codec_type;
377 st->codec->codec_id = st->codecpar->codec_id;
378 FF_ENABLE_DEPRECATION_WARNINGS
387 /************************************************************/
388 /* input media file */
390 int av_demuxer_open(AVFormatContext *ic) {
393 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
394 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
395 return AVERROR(EINVAL);
398 if (ic->iformat->read_header) {
399 err = ic->iformat->read_header(ic);
404 if (ic->pb && !ic->internal->data_offset)
405 ic->internal->data_offset = avio_tell(ic->pb);
410 /* Open input file and probe the format if necessary. */
411 static int init_input(AVFormatContext *s, const char *filename,
412 AVDictionary **options)
415 AVProbeData pd = { filename, NULL, 0 };
416 int score = AVPROBE_SCORE_RETRY;
419 s->flags |= AVFMT_FLAG_CUSTOM_IO;
421 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
422 s, 0, s->format_probesize);
423 else if (s->iformat->flags & AVFMT_NOFILE)
424 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
425 "will be ignored with AVFMT_NOFILE format.\n");
429 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
430 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
433 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
438 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
439 s, 0, s->format_probesize);
442 int avformat_queue_attached_pictures(AVFormatContext *s)
445 for (i = 0; i < s->nb_streams; i++)
446 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
447 s->streams[i]->discard < AVDISCARD_ALL) {
448 if (s->streams[i]->attached_pic.size <= 0) {
449 av_log(s, AV_LOG_WARNING,
450 "Attached picture on stream %d has invalid size, "
455 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
456 &s->internal->raw_packet_buffer_end,
457 &s->streams[i]->attached_pic,
465 static int update_stream_avctx(AVFormatContext *s)
468 for (i = 0; i < s->nb_streams; i++) {
469 AVStream *st = s->streams[i];
471 if (!st->internal->need_context_update)
474 /* close parser, because it depends on the codec */
475 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
476 av_parser_close(st->parser);
480 /* update internal codec context, for the parser */
481 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
485 #if FF_API_LAVF_AVCTX
486 FF_DISABLE_DEPRECATION_WARNINGS
487 /* update deprecated public codec context */
488 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
491 FF_ENABLE_DEPRECATION_WARNINGS
494 st->internal->need_context_update = 0;
500 int avformat_open_input(AVFormatContext **ps, const char *filename,
501 ff_const59 AVInputFormat *fmt, AVDictionary **options)
503 AVFormatContext *s = *ps;
505 AVDictionary *tmp = NULL;
506 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
508 if (!s && !(s = avformat_alloc_context()))
509 return AVERROR(ENOMEM);
511 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
512 return AVERROR(EINVAL);
518 av_dict_copy(&tmp, *options, 0);
520 if (s->pb) // must be before any goto fail
521 s->flags |= AVFMT_FLAG_CUSTOM_IO;
523 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
526 if (!(s->url = av_strdup(filename ? filename : ""))) {
527 ret = AVERROR(ENOMEM);
531 #if FF_API_FORMAT_FILENAME
532 FF_DISABLE_DEPRECATION_WARNINGS
533 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
534 FF_ENABLE_DEPRECATION_WARNINGS
536 if ((ret = init_input(s, filename, &tmp)) < 0)
538 s->probe_score = ret;
540 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
541 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
542 if (!s->protocol_whitelist) {
543 ret = AVERROR(ENOMEM);
548 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
549 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
550 if (!s->protocol_blacklist) {
551 ret = AVERROR(ENOMEM);
556 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
557 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
558 ret = AVERROR(EINVAL);
562 avio_skip(s->pb, s->skip_initial_bytes);
564 /* Check filename in case an image number is expected. */
565 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
566 if (!av_filename_number_test(filename)) {
567 ret = AVERROR(EINVAL);
572 s->duration = s->start_time = AV_NOPTS_VALUE;
574 /* Allocate private data. */
575 if (s->iformat->priv_data_size > 0) {
576 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
577 ret = AVERROR(ENOMEM);
580 if (s->iformat->priv_class) {
581 *(const AVClass **) s->priv_data = s->iformat->priv_class;
582 av_opt_set_defaults(s->priv_data);
583 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
588 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
590 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
593 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
594 if ((ret = s->iformat->read_header(s)) < 0)
598 s->metadata = s->internal->id3v2_meta;
599 s->internal->id3v2_meta = NULL;
600 } else if (s->internal->id3v2_meta) {
601 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
602 av_dict_free(&s->internal->id3v2_meta);
605 if (id3v2_extra_meta) {
606 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
607 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
608 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
610 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
612 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
615 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
617 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
619 if ((ret = avformat_queue_attached_pictures(s)) < 0)
622 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
623 s->internal->data_offset = avio_tell(s->pb);
625 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
627 update_stream_avctx(s);
629 for (i = 0; i < s->nb_streams; i++)
630 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
633 av_dict_free(options);
640 if (s->iformat->read_close)
641 s->iformat->read_close(s);
643 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
645 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
647 avformat_free_context(s);
652 /*******************************************************/
654 static void force_codec_ids(AVFormatContext *s, AVStream *st)
656 switch (st->codecpar->codec_type) {
657 case AVMEDIA_TYPE_VIDEO:
658 if (s->video_codec_id)
659 st->codecpar->codec_id = s->video_codec_id;
661 case AVMEDIA_TYPE_AUDIO:
662 if (s->audio_codec_id)
663 st->codecpar->codec_id = s->audio_codec_id;
665 case AVMEDIA_TYPE_SUBTITLE:
666 if (s->subtitle_codec_id)
667 st->codecpar->codec_id = s->subtitle_codec_id;
669 case AVMEDIA_TYPE_DATA:
670 if (s->data_codec_id)
671 st->codecpar->codec_id = s->data_codec_id;
676 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
678 if (st->request_probe>0) {
679 AVProbeData *pd = &st->probe_data;
681 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
685 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
687 av_log(s, AV_LOG_WARNING,
688 "Failed to reallocate probe buffer for stream %d\n",
693 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
694 pd->buf_size += pkt->size;
695 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
698 st->probe_packets = 0;
700 av_log(s, AV_LOG_WARNING,
701 "nothing to probe for stream %d\n", st->index);
705 end= s->internal->raw_packet_buffer_remaining_size <= 0
706 || st->probe_packets<= 0;
708 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
709 int score = set_codec_from_probe_data(s, st, pd);
710 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
714 st->request_probe = -1;
715 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
716 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
718 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
720 force_codec_ids(s, st);
726 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
728 int64_t ref = pkt->dts;
729 int i, pts_wrap_behavior;
730 int64_t pts_wrap_reference;
731 AVProgram *first_program;
733 if (ref == AV_NOPTS_VALUE)
735 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
737 ref &= (1LL << st->pts_wrap_bits)-1;
739 // reference time stamp should be 60 s before first time stamp
740 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
741 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
742 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
743 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
744 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
746 first_program = av_find_program_from_stream(s, NULL, stream_index);
748 if (!first_program) {
749 int default_stream_index = av_find_default_stream_index(s);
750 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
751 for (i = 0; i < s->nb_streams; i++) {
752 if (av_find_program_from_stream(s, NULL, i))
754 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
755 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
759 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
760 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
764 AVProgram *program = first_program;
766 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
767 pts_wrap_reference = program->pts_wrap_reference;
768 pts_wrap_behavior = program->pts_wrap_behavior;
771 program = av_find_program_from_stream(s, program, stream_index);
774 // update every program with differing pts_wrap_reference
775 program = first_program;
777 if (program->pts_wrap_reference != pts_wrap_reference) {
778 for (i = 0; i<program->nb_stream_indexes; i++) {
779 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
780 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
783 program->pts_wrap_reference = pts_wrap_reference;
784 program->pts_wrap_behavior = pts_wrap_behavior;
786 program = av_find_program_from_stream(s, program, stream_index);
792 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
802 AVPacketList *pktl = s->internal->raw_packet_buffer;
803 const AVPacket *pkt1;
806 st = s->streams[pktl->pkt.stream_index];
807 if (s->internal->raw_packet_buffer_remaining_size <= 0)
808 if ((err = probe_codec(s, st, NULL)) < 0)
810 if (st->request_probe <= 0) {
811 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
812 &s->internal->raw_packet_buffer_end, pkt);
813 s->internal->raw_packet_buffer_remaining_size += pkt->size;
818 ret = s->iformat->read_packet(s, pkt);
820 av_packet_unref(pkt);
822 /* Some demuxers return FFERROR_REDO when they consume
823 data and discard it (ignored streams, junk, extradata).
824 We must re-call the demuxer to get the real packet. */
825 if (ret == FFERROR_REDO)
827 if (!pktl || ret == AVERROR(EAGAIN))
829 for (i = 0; i < s->nb_streams; i++) {
831 if (st->probe_packets || st->request_probe > 0)
832 if ((err = probe_codec(s, st, NULL)) < 0)
834 av_assert0(st->request_probe <= 0);
839 err = av_packet_make_refcounted(pkt);
841 av_packet_unref(pkt);
845 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
846 av_log(s, AV_LOG_WARNING,
847 "Packet corrupt (stream = %d, dts = %s)",
848 pkt->stream_index, av_ts2str(pkt->dts));
849 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
850 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
851 av_packet_unref(pkt);
854 av_log(s, AV_LOG_WARNING, ".\n");
857 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
858 "Invalid stream index.\n");
860 st = s->streams[pkt->stream_index];
862 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
863 // correct first time stamps to negative values
864 if (!is_relative(st->first_dts))
865 st->first_dts = wrap_timestamp(st, st->first_dts);
866 if (!is_relative(st->start_time))
867 st->start_time = wrap_timestamp(st, st->start_time);
868 if (!is_relative(st->cur_dts))
869 st->cur_dts = wrap_timestamp(st, st->cur_dts);
872 pkt->dts = wrap_timestamp(st, pkt->dts);
873 pkt->pts = wrap_timestamp(st, pkt->pts);
875 force_codec_ids(s, st);
877 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
878 if (s->use_wallclock_as_timestamps)
879 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
881 if (!pktl && st->request_probe <= 0)
884 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
885 &s->internal->raw_packet_buffer_end,
888 av_packet_unref(pkt);
891 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
892 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
894 if ((err = probe_codec(s, st, pkt1)) < 0)
900 /**********************************************************/
902 static int determinable_frame_size(AVCodecContext *avctx)
904 switch(avctx->codec_id) {
905 case AV_CODEC_ID_MP1:
906 case AV_CODEC_ID_MP2:
907 case AV_CODEC_ID_MP3:
908 case AV_CODEC_ID_CODEC2:
916 * Return the frame duration in seconds. Return 0 if not available.
918 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
919 AVCodecParserContext *pc, AVPacket *pkt)
921 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
922 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
923 int frame_size, sample_rate;
925 #if FF_API_LAVF_AVCTX
926 FF_DISABLE_DEPRECATION_WARNINGS
927 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
928 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
929 FF_ENABLE_DEPRECATION_WARNINGS
934 switch (st->codecpar->codec_type) {
935 case AVMEDIA_TYPE_VIDEO:
936 if (st->r_frame_rate.num && !pc && s->iformat) {
937 *pnum = st->r_frame_rate.den;
938 *pden = st->r_frame_rate.num;
939 } else if (st->time_base.num * 1000LL > st->time_base.den) {
940 *pnum = st->time_base.num;
941 *pden = st->time_base.den;
942 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
943 av_assert0(st->internal->avctx->ticks_per_frame);
944 av_reduce(pnum, pden,
946 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
949 if (pc && pc->repeat_pict) {
950 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
951 av_reduce(pnum, pden,
952 (*pnum) * (1LL + pc->repeat_pict),
956 /* If this codec can be interlaced or progressive then we need
957 * a parser to compute duration of a packet. Thus if we have
958 * no parser in such case leave duration undefined. */
959 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
963 case AVMEDIA_TYPE_AUDIO:
964 if (st->internal->avctx_inited) {
965 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
966 sample_rate = st->internal->avctx->sample_rate;
968 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
969 sample_rate = st->codecpar->sample_rate;
971 if (frame_size <= 0 || sample_rate <= 0)
981 int ff_is_intra_only(enum AVCodecID id)
983 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
986 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
987 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
992 static int has_decode_delay_been_guessed(AVStream *st)
994 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
995 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
997 #if CONFIG_H264_DECODER
998 if (st->internal->avctx->has_b_frames &&
999 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1002 if (st->internal->avctx->has_b_frames<3)
1003 return st->nb_decoded_frames >= 7;
1004 else if (st->internal->avctx->has_b_frames<4)
1005 return st->nb_decoded_frames >= 18;
1007 return st->nb_decoded_frames >= 20;
1010 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1014 if (pktl == s->internal->packet_buffer_end)
1015 return s->internal->parse_queue;
1019 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1020 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1021 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1024 int delay = st->internal->avctx->has_b_frames;
1027 if (dts == AV_NOPTS_VALUE) {
1028 int64_t best_score = INT64_MAX;
1029 for (i = 0; i<delay; i++) {
1030 if (st->internal->pts_reorder_error_count[i]) {
1031 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1032 if (score < best_score) {
1034 dts = pts_buffer[i];
1039 for (i = 0; i<delay; i++) {
1040 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1041 int64_t diff = FFABS(pts_buffer[i] - dts)
1042 + (uint64_t)st->internal->pts_reorder_error[i];
1043 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1044 st->internal->pts_reorder_error[i] = diff;
1045 st->internal->pts_reorder_error_count[i]++;
1046 if (st->internal->pts_reorder_error_count[i] > 250) {
1047 st->internal->pts_reorder_error[i] >>= 1;
1048 st->internal->pts_reorder_error_count[i] >>= 1;
1055 if (dts == AV_NOPTS_VALUE)
1056 dts = pts_buffer[0];
1062 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1063 * of the packets in a window.
1065 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1066 AVPacketList *pkt_buffer)
1068 AVStream *st = s->streams[stream_index];
1069 int delay = st->internal->avctx->has_b_frames;
1072 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1074 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1075 pts_buffer[i] = AV_NOPTS_VALUE;
1077 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1078 if (pkt_buffer->pkt.stream_index != stream_index)
1081 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1082 pts_buffer[0] = pkt_buffer->pkt.pts;
1083 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1084 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1086 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1091 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1092 int64_t dts, int64_t pts, AVPacket *pkt)
1094 AVStream *st = s->streams[stream_index];
1095 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1096 AVPacketList *pktl_it;
1100 if (st->first_dts != AV_NOPTS_VALUE ||
1101 dts == AV_NOPTS_VALUE ||
1102 st->cur_dts == AV_NOPTS_VALUE ||
1103 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1107 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1109 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1111 if (is_relative(pts))
1114 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1115 if (pktl_it->pkt.stream_index != stream_index)
1117 if (is_relative(pktl_it->pkt.pts))
1118 pktl_it->pkt.pts += shift;
1120 if (is_relative(pktl_it->pkt.dts))
1121 pktl_it->pkt.dts += shift;
1123 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1124 st->start_time = pktl_it->pkt.pts;
1125 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1126 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1130 if (has_decode_delay_been_guessed(st)) {
1131 update_dts_from_pts(s, stream_index, pktl);
1134 if (st->start_time == AV_NOPTS_VALUE) {
1135 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1136 st->start_time = pts;
1138 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1139 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1143 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1144 int stream_index, int64_t duration)
1146 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1147 int64_t cur_dts = RELATIVE_TS_BASE;
1149 if (st->first_dts != AV_NOPTS_VALUE) {
1150 if (st->internal->update_initial_durations_done)
1152 st->internal->update_initial_durations_done = 1;
1153 cur_dts = st->first_dts;
1154 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1155 if (pktl->pkt.stream_index == stream_index) {
1156 if (pktl->pkt.pts != pktl->pkt.dts ||
1157 pktl->pkt.dts != AV_NOPTS_VALUE ||
1160 cur_dts -= duration;
1163 if (pktl && pktl->pkt.dts != st->first_dts) {
1164 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1165 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1169 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1172 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1173 st->first_dts = cur_dts;
1174 } else if (st->cur_dts != RELATIVE_TS_BASE)
1177 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1178 if (pktl->pkt.stream_index != stream_index)
1180 if ((pktl->pkt.pts == pktl->pkt.dts ||
1181 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1182 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1183 pktl->pkt.dts == st->first_dts ||
1184 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1185 !pktl->pkt.duration) {
1186 pktl->pkt.dts = cur_dts;
1187 if (!st->internal->avctx->has_b_frames)
1188 pktl->pkt.pts = cur_dts;
1189 pktl->pkt.duration = duration;
1192 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1195 st->cur_dts = cur_dts;
1198 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1199 AVCodecParserContext *pc, AVPacket *pkt,
1200 int64_t next_dts, int64_t next_pts)
1202 int num, den, presentation_delayed, delay, i;
1204 AVRational duration;
1205 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1206 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1208 if (s->flags & AVFMT_FLAG_NOFILLIN)
1211 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1212 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1213 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1214 st->internal->dts_ordered++;
1216 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1217 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1219 st->internal->last_dts_for_order_check);
1220 st->internal->dts_misordered++;
1222 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1223 st->internal->dts_ordered >>= 1;
1224 st->internal->dts_misordered >>= 1;
1228 st->internal->last_dts_for_order_check = pkt->dts;
1229 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1230 pkt->dts = AV_NOPTS_VALUE;
1233 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1234 pkt->dts = AV_NOPTS_VALUE;
1236 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1237 && !st->internal->avctx->has_b_frames)
1238 //FIXME Set low_delay = 0 when has_b_frames = 1
1239 st->internal->avctx->has_b_frames = 1;
1241 /* do we have a video B-frame ? */
1242 delay = st->internal->avctx->has_b_frames;
1243 presentation_delayed = 0;
1245 /* XXX: need has_b_frame, but cannot get it if the codec is
1246 * not initialized */
1248 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1249 presentation_delayed = 1;
1251 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1252 st->pts_wrap_bits < 63 &&
1253 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1254 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1255 pkt->dts -= 1LL << st->pts_wrap_bits;
1257 pkt->pts += 1LL << st->pts_wrap_bits;
1260 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1261 * We take the conservative approach and discard both.
1262 * Note: If this is misbehaving for an H.264 file, then possibly
1263 * presentation_delayed is not set correctly. */
1264 if (delay == 1 && pkt->dts == pkt->pts &&
1265 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1266 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1267 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1268 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1269 pkt->dts = AV_NOPTS_VALUE;
1272 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1273 if (pkt->duration <= 0) {
1274 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1276 duration = (AVRational) {num, den};
1277 pkt->duration = av_rescale_rnd(1,
1278 num * (int64_t) st->time_base.den,
1279 den * (int64_t) st->time_base.num,
1284 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1285 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1287 /* Correct timestamps with byte offset if demuxers only have timestamps
1288 * on packet boundaries */
1289 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1290 /* this will estimate bitrate based on this frame's duration and size */
1291 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1292 if (pkt->pts != AV_NOPTS_VALUE)
1294 if (pkt->dts != AV_NOPTS_VALUE)
1298 /* This may be redundant, but it should not hurt. */
1299 if (pkt->dts != AV_NOPTS_VALUE &&
1300 pkt->pts != AV_NOPTS_VALUE &&
1301 pkt->pts > pkt->dts)
1302 presentation_delayed = 1;
1304 if (s->debug & FF_FDEBUG_TS)
1305 av_log(s, AV_LOG_DEBUG,
1306 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1307 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1308 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1310 /* Interpolate PTS and DTS if they are not present. We skip H264
1311 * currently because delay and has_b_frames are not reliably set. */
1312 if ((delay == 0 || (delay == 1 && pc)) &&
1314 if (presentation_delayed) {
1315 /* DTS = decompression timestamp */
1316 /* PTS = presentation timestamp */
1317 if (pkt->dts == AV_NOPTS_VALUE)
1318 pkt->dts = st->last_IP_pts;
1319 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1320 if (pkt->dts == AV_NOPTS_VALUE)
1321 pkt->dts = st->cur_dts;
1323 /* This is tricky: the dts must be incremented by the duration
1324 * of the frame we are displaying, i.e. the last I- or P-frame. */
1325 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1326 st->last_IP_duration = pkt->duration;
1327 if (pkt->dts != AV_NOPTS_VALUE)
1328 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1329 if (pkt->dts != AV_NOPTS_VALUE &&
1330 pkt->pts == AV_NOPTS_VALUE &&
1331 st->last_IP_duration > 0 &&
1332 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1333 next_dts != next_pts &&
1334 next_pts != AV_NOPTS_VALUE)
1335 pkt->pts = next_dts;
1337 if ((uint64_t)pkt->duration <= INT32_MAX)
1338 st->last_IP_duration = pkt->duration;
1339 st->last_IP_pts = pkt->pts;
1340 /* Cannot compute PTS if not present (we can compute it only
1341 * by knowing the future. */
1342 } else if (pkt->pts != AV_NOPTS_VALUE ||
1343 pkt->dts != AV_NOPTS_VALUE ||
1344 pkt->duration > 0 ) {
1346 /* presentation is not delayed : PTS and DTS are the same */
1347 if (pkt->pts == AV_NOPTS_VALUE)
1348 pkt->pts = pkt->dts;
1349 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1351 if (pkt->pts == AV_NOPTS_VALUE)
1352 pkt->pts = st->cur_dts;
1353 pkt->dts = pkt->pts;
1354 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1355 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1359 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1360 st->pts_buffer[0] = pkt->pts;
1361 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1362 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1364 if(has_decode_delay_been_guessed(st))
1365 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1367 // We skipped it above so we try here.
1369 // This should happen on the first packet
1370 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1371 if (pkt->dts > st->cur_dts)
1372 st->cur_dts = pkt->dts;
1374 if (s->debug & FF_FDEBUG_TS)
1375 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1376 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1379 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1380 pkt->flags |= AV_PKT_FLAG_KEY;
1381 #if FF_API_CONVERGENCE_DURATION
1382 FF_DISABLE_DEPRECATION_WARNINGS
1384 pkt->convergence_duration = pc->convergence_duration;
1385 FF_ENABLE_DEPRECATION_WARNINGS
1390 * Parse a packet, add all split parts to parse_queue.
1392 * @param pkt Packet to parse; must not be NULL.
1393 * @param flush Indicates whether to flush. If set, pkt must be blank.
1395 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1396 int stream_index, int flush)
1399 AVStream *st = s->streams[stream_index];
1400 uint8_t *data = pkt->data;
1401 int size = pkt->size;
1402 int ret = 0, got_output = flush;
1404 if (size || flush) {
1405 av_init_packet(&out_pkt);
1406 } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1407 // preserve 0-size sync packets
1408 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1411 while (size > 0 || (flush && got_output)) {
1413 int64_t next_pts = pkt->pts;
1414 int64_t next_dts = pkt->dts;
1416 len = av_parser_parse2(st->parser, st->internal->avctx,
1417 &out_pkt.data, &out_pkt.size, data, size,
1418 pkt->pts, pkt->dts, pkt->pos);
1420 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1422 /* increment read pointer */
1426 got_output = !!out_pkt.size;
1431 if (pkt->buf && out_pkt.data == pkt->data) {
1432 /* reference pkt->buf only when out_pkt.data is guaranteed to point
1433 * to data in it and not in the parser's internal buffer. */
1434 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1435 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1436 out_pkt.buf = av_buffer_ref(pkt->buf);
1438 ret = AVERROR(ENOMEM);
1442 ret = av_packet_make_refcounted(&out_pkt);
1447 if (pkt->side_data) {
1448 out_pkt.side_data = pkt->side_data;
1449 out_pkt.side_data_elems = pkt->side_data_elems;
1450 pkt->side_data = NULL;
1451 pkt->side_data_elems = 0;
1454 /* set the duration */
1455 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1456 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1457 if (st->internal->avctx->sample_rate > 0) {
1459 av_rescale_q_rnd(st->parser->duration,
1460 (AVRational) { 1, st->internal->avctx->sample_rate },
1466 out_pkt.stream_index = st->index;
1467 out_pkt.pts = st->parser->pts;
1468 out_pkt.dts = st->parser->dts;
1469 out_pkt.pos = st->parser->pos;
1470 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1472 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1473 out_pkt.pos = st->parser->frame_offset;
1475 if (st->parser->key_frame == 1 ||
1476 (st->parser->key_frame == -1 &&
1477 st->parser->pict_type == AV_PICTURE_TYPE_I))
1478 out_pkt.flags |= AV_PKT_FLAG_KEY;
1480 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1481 out_pkt.flags |= AV_PKT_FLAG_KEY;
1483 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1485 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1486 &s->internal->parse_queue_end,
1489 av_packet_unref(&out_pkt);
1494 /* end of the stream => close and free the parser */
1496 av_parser_close(st->parser);
1501 av_packet_unref(pkt);
1505 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1507 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1510 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1512 int ret, i, got_packet = 0;
1513 AVDictionary *metadata = NULL;
1515 while (!got_packet && !s->internal->parse_queue) {
1518 /* read next packet */
1519 ret = ff_read_packet(s, pkt);
1521 if (ret == AVERROR(EAGAIN))
1523 /* flush the parsers */
1524 for (i = 0; i < s->nb_streams; i++) {
1526 if (st->parser && st->need_parsing)
1527 parse_packet(s, pkt, st->index, 1);
1529 /* all remaining packets are now in parse_queue =>
1530 * really terminate parsing */
1534 st = s->streams[pkt->stream_index];
1536 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1538 /* update context if required */
1539 if (st->internal->need_context_update) {
1540 if (avcodec_is_open(st->internal->avctx)) {
1541 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1542 avcodec_close(st->internal->avctx);
1543 st->internal->info->found_decoder = 0;
1546 /* close parser, because it depends on the codec */
1547 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1548 av_parser_close(st->parser);
1552 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1554 av_packet_unref(pkt);
1558 #if FF_API_LAVF_AVCTX
1559 FF_DISABLE_DEPRECATION_WARNINGS
1560 /* update deprecated public codec context */
1561 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1563 av_packet_unref(pkt);
1566 FF_ENABLE_DEPRECATION_WARNINGS
1569 st->internal->need_context_update = 0;
1572 if (pkt->pts != AV_NOPTS_VALUE &&
1573 pkt->dts != AV_NOPTS_VALUE &&
1574 pkt->pts < pkt->dts) {
1575 av_log(s, AV_LOG_WARNING,
1576 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1578 av_ts2str(pkt->pts),
1579 av_ts2str(pkt->dts),
1582 if (s->debug & FF_FDEBUG_TS)
1583 av_log(s, AV_LOG_DEBUG,
1584 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1586 av_ts2str(pkt->pts),
1587 av_ts2str(pkt->dts),
1588 pkt->size, pkt->duration, pkt->flags);
1590 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1591 st->parser = av_parser_init(st->codecpar->codec_id);
1593 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1594 "%s, packets or times may be invalid.\n",
1595 avcodec_get_name(st->codecpar->codec_id));
1596 /* no parser available: just output the raw packets */
1597 st->need_parsing = AVSTREAM_PARSE_NONE;
1598 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1599 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1600 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1601 st->parser->flags |= PARSER_FLAG_ONCE;
1602 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1603 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1606 if (!st->need_parsing || !st->parser) {
1607 /* no parsing needed: we just output the packet as is */
1608 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1609 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1610 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1611 ff_reduce_index(s, st->index);
1612 av_add_index_entry(st, pkt->pos, pkt->dts,
1613 0, 0, AVINDEX_KEYFRAME);
1616 } else if (st->discard < AVDISCARD_ALL) {
1617 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1619 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1620 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1621 st->codecpar->channels = st->internal->avctx->channels;
1622 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1623 st->codecpar->codec_id = st->internal->avctx->codec_id;
1626 av_packet_unref(pkt);
1628 if (pkt->flags & AV_PKT_FLAG_KEY)
1629 st->skip_to_keyframe = 0;
1630 if (st->skip_to_keyframe) {
1631 av_packet_unref(pkt);
1636 if (!got_packet && s->internal->parse_queue)
1637 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1640 AVStream *st = s->streams[pkt->stream_index];
1641 int discard_padding = 0;
1642 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1643 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1644 int64_t sample = ts_to_samples(st, pts);
1645 int duration = ts_to_samples(st, pkt->duration);
1646 int64_t end_sample = sample + duration;
1647 if (duration > 0 && end_sample >= st->first_discard_sample &&
1648 sample < st->last_discard_sample)
1649 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1651 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1652 st->skip_samples = st->start_skip_samples;
1653 if (st->skip_samples || discard_padding) {
1654 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1656 AV_WL32(p, st->skip_samples);
1657 AV_WL32(p + 4, discard_padding);
1658 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1660 st->skip_samples = 0;
1663 if (st->internal->inject_global_side_data) {
1664 for (i = 0; i < st->nb_side_data; i++) {
1665 AVPacketSideData *src_sd = &st->side_data[i];
1668 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1671 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1673 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1677 memcpy(dst_data, src_sd->data, src_sd->size);
1679 st->internal->inject_global_side_data = 0;
1683 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1685 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1686 av_dict_copy(&s->metadata, metadata, 0);
1687 av_dict_free(&metadata);
1688 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1691 #if FF_API_LAVF_AVCTX
1692 update_stream_avctx(s);
1695 if (s->debug & FF_FDEBUG_TS)
1696 av_log(s, AV_LOG_DEBUG,
1697 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1698 "size=%d, duration=%"PRId64", flags=%d\n",
1700 av_ts2str(pkt->pts),
1701 av_ts2str(pkt->dts),
1702 pkt->size, pkt->duration, pkt->flags);
1704 /* A demuxer might have returned EOF because of an IO error, let's
1705 * propagate this back to the user. */
1706 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1712 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1714 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1720 ret = s->internal->packet_buffer
1721 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1722 &s->internal->packet_buffer_end, pkt)
1723 : read_frame_internal(s, pkt);
1730 AVPacketList *pktl = s->internal->packet_buffer;
1733 AVPacket *next_pkt = &pktl->pkt;
1735 if (next_pkt->dts != AV_NOPTS_VALUE) {
1736 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1737 // last dts seen for this stream. if any of packets following
1738 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1739 int64_t last_dts = next_pkt->dts;
1740 av_assert2(wrap_bits <= 64);
1741 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1742 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1743 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1744 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1746 next_pkt->pts = pktl->pkt.dts;
1748 if (last_dts != AV_NOPTS_VALUE) {
1749 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1750 last_dts = pktl->pkt.dts;
1755 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1756 // Fixing the last reference frame had none pts issue (For MXF etc).
1757 // We only do this when
1759 // 2. we are not able to resolve a pts value for current packet.
1760 // 3. the packets for this stream at the end of the files had valid dts.
1761 next_pkt->pts = last_dts + next_pkt->duration;
1763 pktl = s->internal->packet_buffer;
1766 /* read packet from packet buffer, if there is data */
1767 st = s->streams[next_pkt->stream_index];
1768 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1769 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1770 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1771 &s->internal->packet_buffer_end, pkt);
1776 ret = read_frame_internal(s, pkt);
1778 if (pktl && ret != AVERROR(EAGAIN)) {
1785 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1786 &s->internal->packet_buffer_end,
1789 av_packet_unref(pkt);
1796 st = s->streams[pkt->stream_index];
1797 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1798 ff_reduce_index(s, st->index);
1799 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1802 if (is_relative(pkt->dts))
1803 pkt->dts -= RELATIVE_TS_BASE;
1804 if (is_relative(pkt->pts))
1805 pkt->pts -= RELATIVE_TS_BASE;
1810 /* XXX: suppress the packet queue */
1811 static void flush_packet_queue(AVFormatContext *s)
1815 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1816 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1817 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1819 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1822 /*******************************************************/
1825 int av_find_default_stream_index(AVFormatContext *s)
1829 int best_stream = 0;
1830 int best_score = INT_MIN;
1832 if (s->nb_streams <= 0)
1834 for (i = 0; i < s->nb_streams; i++) {
1837 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1838 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1840 if (st->codecpar->width && st->codecpar->height)
1844 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1845 if (st->codecpar->sample_rate)
1848 if (st->codec_info_nb_frames)
1851 if (st->discard != AVDISCARD_ALL)
1854 if (score > best_score) {
1862 /** Flush the frame reader. */
1863 void ff_read_frame_flush(AVFormatContext *s)
1868 flush_packet_queue(s);
1870 /* Reset read state for each stream. */
1871 for (i = 0; i < s->nb_streams; i++) {
1875 av_parser_close(st->parser);
1878 st->last_IP_pts = AV_NOPTS_VALUE;
1879 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1880 if (st->first_dts == AV_NOPTS_VALUE)
1881 st->cur_dts = RELATIVE_TS_BASE;
1883 /* We set the current DTS to an unspecified origin. */
1884 st->cur_dts = AV_NOPTS_VALUE;
1886 st->probe_packets = s->max_probe_packets;
1888 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1889 st->pts_buffer[j] = AV_NOPTS_VALUE;
1891 if (s->internal->inject_global_side_data)
1892 st->internal->inject_global_side_data = 1;
1894 st->skip_samples = 0;
1898 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1902 for (i = 0; i < s->nb_streams; i++) {
1903 AVStream *st = s->streams[i];
1906 av_rescale(timestamp,
1907 st->time_base.den * (int64_t) ref_st->time_base.num,
1908 st->time_base.num * (int64_t) ref_st->time_base.den);
1912 void ff_reduce_index(AVFormatContext *s, int stream_index)
1914 AVStream *st = s->streams[stream_index];
1915 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1917 if ((unsigned) st->nb_index_entries >= max_entries) {
1919 for (i = 0; 2 * i < st->nb_index_entries; i++)
1920 st->index_entries[i] = st->index_entries[2 * i];
1921 st->nb_index_entries = i;
1925 int ff_add_index_entry(AVIndexEntry **index_entries,
1926 int *nb_index_entries,
1927 unsigned int *index_entries_allocated_size,
1928 int64_t pos, int64_t timestamp,
1929 int size, int distance, int flags)
1931 AVIndexEntry *entries, *ie;
1934 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1937 if (timestamp == AV_NOPTS_VALUE)
1938 return AVERROR(EINVAL);
1940 if (size < 0 || size > 0x3FFFFFFF)
1941 return AVERROR(EINVAL);
1943 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1944 timestamp -= RELATIVE_TS_BASE;
1946 entries = av_fast_realloc(*index_entries,
1947 index_entries_allocated_size,
1948 (*nb_index_entries + 1) *
1949 sizeof(AVIndexEntry));
1953 *index_entries = entries;
1955 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1956 timestamp, AVSEEK_FLAG_ANY);
1959 index = (*nb_index_entries)++;
1960 ie = &entries[index];
1961 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1963 ie = &entries[index];
1964 if (ie->timestamp != timestamp) {
1965 if (ie->timestamp <= timestamp)
1967 memmove(entries + index + 1, entries + index,
1968 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1969 (*nb_index_entries)++;
1970 } else if (ie->pos == pos && distance < ie->min_distance)
1971 // do not reduce the distance
1972 distance = ie->min_distance;
1976 ie->timestamp = timestamp;
1977 ie->min_distance = distance;
1984 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1985 int size, int distance, int flags)
1987 timestamp = wrap_timestamp(st, timestamp);
1988 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1989 &st->index_entries_allocated_size, pos,
1990 timestamp, size, distance, flags);
1993 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1994 int64_t wanted_timestamp, int flags)
2002 // Optimize appending index entries at the end.
2003 if (b && entries[b - 1].timestamp < wanted_timestamp)
2009 // Search for the next non-discarded packet.
2010 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2012 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2018 timestamp = entries[m].timestamp;
2019 if (timestamp >= wanted_timestamp)
2021 if (timestamp <= wanted_timestamp)
2024 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2026 if (!(flags & AVSEEK_FLAG_ANY))
2027 while (m >= 0 && m < nb_entries &&
2028 !(entries[m].flags & AVINDEX_KEYFRAME))
2029 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2031 if (m == nb_entries)
2036 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2039 int64_t pos_delta = 0;
2041 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2042 const char *proto = avio_find_protocol_name(s->url);
2044 av_assert0(time_tolerance >= 0);
2047 av_log(s, AV_LOG_INFO,
2048 "Protocol name not provided, cannot determine if input is local or "
2049 "a network protocol, buffers and access patterns cannot be configured "
2050 "optimally without knowing the protocol\n");
2053 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2056 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2057 AVStream *st1 = s->streams[ist1];
2058 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2059 AVStream *st2 = s->streams[ist2];
2065 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2066 AVIndexEntry *e1 = &st1->index_entries[i1];
2067 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2069 skip = FFMAX(skip, e1->size);
2070 for (; i2 < st2->nb_index_entries; i2++) {
2071 AVIndexEntry *e2 = &st2->index_entries[i2];
2072 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2073 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2075 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2083 /* XXX This could be adjusted depending on protocol*/
2084 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2085 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2087 /* realloc the buffer and the original data will be retained */
2088 if (ffio_realloc_buf(s->pb, pos_delta)) {
2089 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2093 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2096 if (skip < (1<<23)) {
2097 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2101 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2103 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2104 wanted_timestamp, flags);
2107 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2108 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2110 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2111 if (stream_index >= 0)
2112 ts = wrap_timestamp(s->streams[stream_index], ts);
2116 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2117 int64_t target_ts, int flags)
2119 const AVInputFormat *avif = s->iformat;
2120 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2121 int64_t ts_min, ts_max, ts;
2126 if (stream_index < 0)
2129 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2132 ts_min = AV_NOPTS_VALUE;
2133 pos_limit = -1; // GCC falsely says it may be uninitialized.
2135 st = s->streams[stream_index];
2136 if (st->index_entries) {
2139 /* FIXME: Whole function must be checked for non-keyframe entries in
2140 * index case, especially read_timestamp(). */
2141 index = av_index_search_timestamp(st, target_ts,
2142 flags | AVSEEK_FLAG_BACKWARD);
2143 index = FFMAX(index, 0);
2144 e = &st->index_entries[index];
2146 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2148 ts_min = e->timestamp;
2149 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2150 pos_min, av_ts2str(ts_min));
2152 av_assert1(index == 0);
2155 index = av_index_search_timestamp(st, target_ts,
2156 flags & ~AVSEEK_FLAG_BACKWARD);
2157 av_assert0(index < st->nb_index_entries);
2159 e = &st->index_entries[index];
2160 av_assert1(e->timestamp >= target_ts);
2162 ts_max = e->timestamp;
2163 pos_limit = pos_max - e->min_distance;
2164 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2165 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2169 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2170 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2175 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2178 ff_read_frame_flush(s);
2179 ff_update_cur_dts(s, st, ts);
2184 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2185 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2187 int64_t step = 1024;
2188 int64_t limit, ts_max;
2189 int64_t filesize = avio_size(s->pb);
2190 int64_t pos_max = filesize - 1;
2193 pos_max = FFMAX(0, (pos_max) - step);
2194 ts_max = ff_read_timestamp(s, stream_index,
2195 &pos_max, limit, read_timestamp);
2197 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2198 if (ts_max == AV_NOPTS_VALUE)
2202 int64_t tmp_pos = pos_max + 1;
2203 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2204 &tmp_pos, INT64_MAX, read_timestamp);
2205 if (tmp_ts == AV_NOPTS_VALUE)
2207 av_assert0(tmp_pos > pos_max);
2210 if (tmp_pos >= filesize)
2222 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2223 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2224 int64_t ts_min, int64_t ts_max,
2225 int flags, int64_t *ts_ret,
2226 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2227 int64_t *, int64_t))
2234 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2236 if (ts_min == AV_NOPTS_VALUE) {
2237 pos_min = s->internal->data_offset;
2238 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2239 if (ts_min == AV_NOPTS_VALUE)
2243 if (ts_min >= target_ts) {
2248 if (ts_max == AV_NOPTS_VALUE) {
2249 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2251 pos_limit = pos_max;
2254 if (ts_max <= target_ts) {
2259 av_assert0(ts_min < ts_max);
2262 while (pos_min < pos_limit) {
2263 av_log(s, AV_LOG_TRACE,
2264 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2265 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2266 av_assert0(pos_limit <= pos_max);
2268 if (no_change == 0) {
2269 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2270 // interpolate position (better than dichotomy)
2271 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2273 pos_min - approximate_keyframe_distance;
2274 } else if (no_change == 1) {
2275 // bisection if interpolation did not change min / max pos last time
2276 pos = (pos_min + pos_limit) >> 1;
2278 /* linear search if bisection failed, can only happen if there
2279 * are very few or no keyframes between min/max */
2284 else if (pos > pos_limit)
2288 // May pass pos_limit instead of -1.
2289 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2294 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2295 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2296 pos_min, pos, pos_max,
2297 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2298 pos_limit, start_pos, no_change);
2299 if (ts == AV_NOPTS_VALUE) {
2300 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2303 if (target_ts <= ts) {
2304 pos_limit = start_pos - 1;
2308 if (target_ts >= ts) {
2314 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2315 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2318 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2320 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2321 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2322 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2328 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2329 int64_t pos, int flags)
2331 int64_t pos_min, pos_max;
2333 pos_min = s->internal->data_offset;
2334 pos_max = avio_size(s->pb) - 1;
2338 else if (pos > pos_max)
2341 avio_seek(s->pb, pos, SEEK_SET);
2343 s->io_repositioned = 1;
2348 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2349 int64_t timestamp, int flags)
2356 st = s->streams[stream_index];
2358 index = av_index_search_timestamp(st, timestamp, flags);
2360 if (index < 0 && st->nb_index_entries &&
2361 timestamp < st->index_entries[0].timestamp)
2364 if (index < 0 || index == st->nb_index_entries - 1) {
2368 if (st->nb_index_entries) {
2369 av_assert0(st->index_entries);
2370 ie = &st->index_entries[st->nb_index_entries - 1];
2371 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2373 ff_update_cur_dts(s, st, ie->timestamp);
2375 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2381 read_status = av_read_frame(s, &pkt);
2382 } while (read_status == AVERROR(EAGAIN));
2383 if (read_status < 0)
2385 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2386 if (pkt.flags & AV_PKT_FLAG_KEY) {
2387 av_packet_unref(&pkt);
2390 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2391 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);
2392 av_packet_unref(&pkt);
2396 av_packet_unref(&pkt);
2398 index = av_index_search_timestamp(st, timestamp, flags);
2403 ff_read_frame_flush(s);
2404 if (s->iformat->read_seek)
2405 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2407 ie = &st->index_entries[index];
2408 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2410 ff_update_cur_dts(s, st, ie->timestamp);
2415 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2416 int64_t timestamp, int flags)
2421 if (flags & AVSEEK_FLAG_BYTE) {
2422 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2424 ff_read_frame_flush(s);
2425 return seek_frame_byte(s, stream_index, timestamp, flags);
2428 if (stream_index < 0) {
2429 stream_index = av_find_default_stream_index(s);
2430 if (stream_index < 0)
2433 st = s->streams[stream_index];
2434 /* timestamp for default must be expressed in AV_TIME_BASE units */
2435 timestamp = av_rescale(timestamp, st->time_base.den,
2436 AV_TIME_BASE * (int64_t) st->time_base.num);
2439 /* first, we try the format specific seek */
2440 if (s->iformat->read_seek) {
2441 ff_read_frame_flush(s);
2442 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2448 if (s->iformat->read_timestamp &&
2449 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2450 ff_read_frame_flush(s);
2451 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2452 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2453 ff_read_frame_flush(s);
2454 return seek_frame_generic(s, stream_index, timestamp, flags);
2459 int av_seek_frame(AVFormatContext *s, int stream_index,
2460 int64_t timestamp, int flags)
2464 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2465 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2466 if ((flags & AVSEEK_FLAG_BACKWARD))
2470 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2471 flags & ~AVSEEK_FLAG_BACKWARD);
2474 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2477 ret = avformat_queue_attached_pictures(s);
2482 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2483 int64_t ts, int64_t max_ts, int flags)
2485 if (min_ts > ts || max_ts < ts)
2487 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2488 return AVERROR(EINVAL);
2491 flags |= AVSEEK_FLAG_ANY;
2492 flags &= ~AVSEEK_FLAG_BACKWARD;
2494 if (s->iformat->read_seek2) {
2496 ff_read_frame_flush(s);
2498 if (stream_index == -1 && s->nb_streams == 1) {
2499 AVRational time_base = s->streams[0]->time_base;
2500 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2501 min_ts = av_rescale_rnd(min_ts, time_base.den,
2502 time_base.num * (int64_t)AV_TIME_BASE,
2503 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2504 max_ts = av_rescale_rnd(max_ts, time_base.den,
2505 time_base.num * (int64_t)AV_TIME_BASE,
2506 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2510 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2514 ret = avformat_queue_attached_pictures(s);
2518 if (s->iformat->read_timestamp) {
2519 // try to seek via read_timestamp()
2522 // Fall back on old API if new is not implemented but old is.
2523 // Note the old API has somewhat different semantics.
2524 if (s->iformat->read_seek || 1) {
2525 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2526 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2527 if (ret<0 && ts != min_ts && max_ts != ts) {
2528 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2530 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2535 // try some generic seek like seek_frame_generic() but with new ts semantics
2536 return -1; //unreachable
2539 int avformat_flush(AVFormatContext *s)
2541 ff_read_frame_flush(s);
2545 /*******************************************************/
2548 * Return TRUE if the stream has accurate duration in any stream.
2550 * @return TRUE if the stream has accurate duration for at least one component.
2552 static int has_duration(AVFormatContext *ic)
2557 for (i = 0; i < ic->nb_streams; i++) {
2558 st = ic->streams[i];
2559 if (st->duration != AV_NOPTS_VALUE)
2562 if (ic->duration != AV_NOPTS_VALUE)
2568 * Estimate the stream timings from the one of each components.
2570 * Also computes the global bitrate if possible.
2572 static void update_stream_timings(AVFormatContext *ic)
2574 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2575 int64_t duration, duration1, duration_text, filesize;
2579 start_time = INT64_MAX;
2580 start_time_text = INT64_MAX;
2581 end_time = INT64_MIN;
2582 end_time_text = INT64_MIN;
2583 duration = INT64_MIN;
2584 duration_text = INT64_MIN;
2586 for (i = 0; i < ic->nb_streams; i++) {
2587 AVStream *st = ic->streams[i];
2588 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2589 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2590 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2591 start_time1 = av_rescale_q(st->start_time, st->time_base,
2594 start_time_text = FFMIN(start_time_text, start_time1);
2596 start_time = FFMIN(start_time, start_time1);
2597 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2599 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2600 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2601 end_time1 += start_time1;
2603 end_time_text = FFMAX(end_time_text, end_time1);
2605 end_time = FFMAX(end_time, end_time1);
2607 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2608 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2609 p->start_time = start_time1;
2610 if (p->end_time < end_time1)
2611 p->end_time = end_time1;
2614 if (st->duration != AV_NOPTS_VALUE) {
2615 duration1 = av_rescale_q(st->duration, st->time_base,
2618 duration_text = FFMAX(duration_text, duration1);
2620 duration = FFMAX(duration, duration1);
2623 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2624 start_time = start_time_text;
2625 else if (start_time > start_time_text)
2626 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2628 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2629 end_time = end_time_text;
2630 else if (end_time < end_time_text)
2631 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2633 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2634 duration = duration_text;
2635 else if (duration < duration_text)
2636 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2638 if (start_time != INT64_MAX) {
2639 ic->start_time = start_time;
2640 if (end_time != INT64_MIN) {
2641 if (ic->nb_programs > 1) {
2642 for (i = 0; i < ic->nb_programs; i++) {
2643 p = ic->programs[i];
2644 if (p->start_time != AV_NOPTS_VALUE &&
2645 p->end_time > p->start_time &&
2646 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2647 duration = FFMAX(duration, p->end_time - p->start_time);
2649 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2650 duration = FFMAX(duration, end_time - start_time);
2654 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2655 ic->duration = duration;
2657 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2658 /* compute the bitrate */
2659 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2660 (double) ic->duration;
2661 if (bitrate >= 0 && bitrate <= INT64_MAX)
2662 ic->bit_rate = bitrate;
2666 static void fill_all_stream_timings(AVFormatContext *ic)
2671 update_stream_timings(ic);
2672 for (i = 0; i < ic->nb_streams; i++) {
2673 st = ic->streams[i];
2674 if (st->start_time == AV_NOPTS_VALUE) {
2675 if (ic->start_time != AV_NOPTS_VALUE)
2676 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2678 if (ic->duration != AV_NOPTS_VALUE)
2679 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2685 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2687 int64_t filesize, duration;
2688 int i, show_warning = 0;
2691 /* if bit_rate is already set, we believe it */
2692 if (ic->bit_rate <= 0) {
2693 int64_t bit_rate = 0;
2694 for (i = 0; i < ic->nb_streams; i++) {
2695 st = ic->streams[i];
2696 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2697 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2698 if (st->codecpar->bit_rate > 0) {
2699 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2703 bit_rate += st->codecpar->bit_rate;
2704 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2705 // If we have a videostream with packets but without a bitrate
2706 // then consider the sum not known
2711 ic->bit_rate = bit_rate;
2714 /* if duration is already set, we believe it */
2715 if (ic->duration == AV_NOPTS_VALUE &&
2716 ic->bit_rate != 0) {
2717 filesize = ic->pb ? avio_size(ic->pb) : 0;
2718 if (filesize > ic->internal->data_offset) {
2719 filesize -= ic->internal->data_offset;
2720 for (i = 0; i < ic->nb_streams; i++) {
2721 st = ic->streams[i];
2722 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2723 && st->duration == AV_NOPTS_VALUE) {
2724 duration = av_rescale(filesize, 8LL * st->time_base.den,
2726 (int64_t) st->time_base.num);
2727 st->duration = duration;
2734 av_log(ic, AV_LOG_WARNING,
2735 "Estimating duration from bitrate, this may be inaccurate\n");
2738 #define DURATION_MAX_READ_SIZE 250000LL
2739 #define DURATION_MAX_RETRY 6
2741 /* only usable for MPEG-PS streams */
2742 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2744 AVPacket pkt1, *pkt = &pkt1;
2746 int num, den, read_size, i, ret;
2747 int found_duration = 0;
2749 int64_t filesize, offset, duration;
2752 /* flush packet queue */
2753 flush_packet_queue(ic);
2755 for (i = 0; i < ic->nb_streams; i++) {
2756 st = ic->streams[i];
2757 if (st->start_time == AV_NOPTS_VALUE &&
2758 st->first_dts == AV_NOPTS_VALUE &&
2759 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2760 av_log(ic, AV_LOG_WARNING,
2761 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2764 av_parser_close(st->parser);
2769 if (ic->skip_estimate_duration_from_pts) {
2770 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2771 goto skip_duration_calc;
2774 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2775 /* estimate the end time (duration) */
2776 /* XXX: may need to support wrapping */
2777 filesize = ic->pb ? avio_size(ic->pb) : 0;
2779 is_end = found_duration;
2780 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2784 avio_seek(ic->pb, offset, SEEK_SET);
2787 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2791 ret = ff_read_packet(ic, pkt);
2792 } while (ret == AVERROR(EAGAIN));
2795 read_size += pkt->size;
2796 st = ic->streams[pkt->stream_index];
2797 if (pkt->pts != AV_NOPTS_VALUE &&
2798 (st->start_time != AV_NOPTS_VALUE ||
2799 st->first_dts != AV_NOPTS_VALUE)) {
2800 if (pkt->duration == 0) {
2801 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2803 pkt->duration = av_rescale_rnd(1,
2804 num * (int64_t) st->time_base.den,
2805 den * (int64_t) st->time_base.num,
2809 duration = pkt->pts + pkt->duration;
2811 if (st->start_time != AV_NOPTS_VALUE)
2812 duration -= st->start_time;
2814 duration -= st->first_dts;
2816 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2817 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2818 st->duration = duration;
2819 st->internal->info->last_duration = duration;
2822 av_packet_unref(pkt);
2825 /* check if all audio/video streams have valid duration */
2828 for (i = 0; i < ic->nb_streams; i++) {
2829 st = ic->streams[i];
2830 switch (st->codecpar->codec_type) {
2831 case AVMEDIA_TYPE_VIDEO:
2832 case AVMEDIA_TYPE_AUDIO:
2833 if (st->duration == AV_NOPTS_VALUE)
2840 ++retry <= DURATION_MAX_RETRY);
2842 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2844 /* warn about audio/video streams which duration could not be estimated */
2845 for (i = 0; i < ic->nb_streams; i++) {
2846 st = ic->streams[i];
2847 if (st->duration == AV_NOPTS_VALUE) {
2848 switch (st->codecpar->codec_type) {
2849 case AVMEDIA_TYPE_VIDEO:
2850 case AVMEDIA_TYPE_AUDIO:
2851 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2852 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2854 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2859 fill_all_stream_timings(ic);
2861 avio_seek(ic->pb, old_offset, SEEK_SET);
2862 for (i = 0; i < ic->nb_streams; i++) {
2865 st = ic->streams[i];
2866 st->cur_dts = st->first_dts;
2867 st->last_IP_pts = AV_NOPTS_VALUE;
2868 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2869 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2870 st->pts_buffer[j] = AV_NOPTS_VALUE;
2874 /* 1:1 map to AVDurationEstimationMethod */
2875 static const char *duration_name[] = {
2876 [AVFMT_DURATION_FROM_PTS] = "pts",
2877 [AVFMT_DURATION_FROM_STREAM] = "stream",
2878 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2881 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2883 return duration_name[method];
2886 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2890 /* get the file size, if possible */
2891 if (ic->iformat->flags & AVFMT_NOFILE) {
2894 file_size = avio_size(ic->pb);
2895 file_size = FFMAX(0, file_size);
2898 if ((!strcmp(ic->iformat->name, "mpeg") ||
2899 !strcmp(ic->iformat->name, "mpegts")) &&
2900 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2901 /* get accurate estimate from the PTSes */
2902 estimate_timings_from_pts(ic, old_offset);
2903 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2904 } else if (has_duration(ic)) {
2905 /* at least one component has timings - we use them for all
2907 fill_all_stream_timings(ic);
2908 /* nut demuxer estimate the duration from PTS */
2909 if(!strcmp(ic->iformat->name, "nut"))
2910 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2912 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2914 /* less precise: use bitrate info */
2915 estimate_timings_from_bit_rate(ic);
2916 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2918 update_stream_timings(ic);
2922 AVStream av_unused *st;
2923 for (i = 0; i < ic->nb_streams; i++) {
2924 st = ic->streams[i];
2925 if (st->time_base.den)
2926 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2927 av_ts2timestr(st->start_time, &st->time_base),
2928 av_ts2timestr(st->duration, &st->time_base));
2930 av_log(ic, AV_LOG_TRACE,
2931 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2932 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2933 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2934 duration_estimate_name(ic->duration_estimation_method),
2935 (int64_t)ic->bit_rate / 1000);
2939 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2941 AVCodecContext *avctx = st->internal->avctx;
2943 #define FAIL(errmsg) do { \
2945 *errmsg_ptr = errmsg; \
2949 if ( avctx->codec_id == AV_CODEC_ID_NONE
2950 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2951 FAIL("unknown codec");
2952 switch (avctx->codec_type) {
2953 case AVMEDIA_TYPE_AUDIO:
2954 if (!avctx->frame_size && determinable_frame_size(avctx))
2955 FAIL("unspecified frame size");
2956 if (st->internal->info->found_decoder >= 0 &&
2957 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2958 FAIL("unspecified sample format");
2959 if (!avctx->sample_rate)
2960 FAIL("unspecified sample rate");
2961 if (!avctx->channels)
2962 FAIL("unspecified number of channels");
2963 if (st->internal->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2964 FAIL("no decodable DTS frames");
2966 case AVMEDIA_TYPE_VIDEO:
2968 FAIL("unspecified size");
2969 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2970 FAIL("unspecified pixel format");
2971 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2972 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2973 FAIL("no frame in rv30/40 and no sar");
2975 case AVMEDIA_TYPE_SUBTITLE:
2976 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2977 FAIL("unspecified size");
2979 case AVMEDIA_TYPE_DATA:
2980 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2986 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2987 static int try_decode_frame(AVFormatContext *s, AVStream *st,
2988 const AVPacket *avpkt, AVDictionary **options)
2990 AVCodecContext *avctx = st->internal->avctx;
2991 const AVCodec *codec;
2992 int got_picture = 1, ret = 0;
2993 AVFrame *frame = av_frame_alloc();
2994 AVSubtitle subtitle;
2995 AVPacket pkt = *avpkt;
2996 int do_skip_frame = 0;
2997 enum AVDiscard skip_frame;
3000 return AVERROR(ENOMEM);
3002 if (!avcodec_is_open(avctx) &&
3003 st->internal->info->found_decoder <= 0 &&
3004 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3005 AVDictionary *thread_opt = NULL;
3007 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3010 st->internal->info->found_decoder = -st->codecpar->codec_id;
3015 /* Force thread count to 1 since the H.264 decoder will not extract
3016 * SPS and PPS to extradata during multi-threaded decoding. */
3017 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3018 if (s->codec_whitelist)
3019 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3020 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3022 av_dict_free(&thread_opt);
3024 st->internal->info->found_decoder = -avctx->codec_id;
3027 st->internal->info->found_decoder = 1;
3028 } else if (!st->internal->info->found_decoder)
3029 st->internal->info->found_decoder = 1;
3031 if (st->internal->info->found_decoder < 0) {
3036 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3038 skip_frame = avctx->skip_frame;
3039 avctx->skip_frame = AVDISCARD_ALL;
3042 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3044 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3045 (!st->codec_info_nb_frames &&
3046 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3048 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3049 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3050 ret = avcodec_send_packet(avctx, &pkt);
3051 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3055 ret = avcodec_receive_frame(avctx, frame);
3058 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3060 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3061 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3062 &got_picture, &pkt);
3064 avsubtitle_free(&subtitle);
3070 st->nb_decoded_frames++;
3075 if (!pkt.data && !got_picture)
3079 if (do_skip_frame) {
3080 avctx->skip_frame = skip_frame;
3083 av_frame_free(&frame);
3087 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3089 while (tags->id != AV_CODEC_ID_NONE) {
3097 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3100 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3101 if (tag == tags[i].tag)
3103 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3104 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3106 return AV_CODEC_ID_NONE;
3109 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3111 if (bps <= 0 || bps > 64)
3112 return AV_CODEC_ID_NONE;
3117 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3119 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3121 return AV_CODEC_ID_NONE;
3126 if (sflags & (1 << (bps - 1))) {
3129 return AV_CODEC_ID_PCM_S8;
3131 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3133 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3135 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3137 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3139 return AV_CODEC_ID_NONE;
3144 return AV_CODEC_ID_PCM_U8;
3146 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3148 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3150 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3152 return AV_CODEC_ID_NONE;
3158 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3161 if (!av_codec_get_tag2(tags, id, &tag))
3166 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3170 for (i = 0; tags && tags[i]; i++) {
3171 const AVCodecTag *codec_tags = tags[i];
3172 while (codec_tags->id != AV_CODEC_ID_NONE) {
3173 if (codec_tags->id == id) {
3174 *tag = codec_tags->tag;
3183 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3186 for (i = 0; tags && tags[i]; i++) {
3187 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3188 if (id != AV_CODEC_ID_NONE)
3191 return AV_CODEC_ID_NONE;
3194 static void compute_chapters_end(AVFormatContext *s)
3197 int64_t max_time = 0;
3199 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3200 max_time = s->duration +
3201 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3203 for (i = 0; i < s->nb_chapters; i++)
3204 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3205 AVChapter *ch = s->chapters[i];
3206 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3210 for (j = 0; j < s->nb_chapters; j++) {
3211 AVChapter *ch1 = s->chapters[j];
3212 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3214 if (j != i && next_start > ch->start && next_start < end)
3217 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3221 static int get_std_framerate(int i)
3224 return (i + 1) * 1001;
3228 return (i + 31) * 1001 * 12;
3232 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3236 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3239 /* Is the time base unreliable?
3240 * This is a heuristic to balance between quick acceptance of the values in
3241 * the headers vs. some extra checks.
3242 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3243 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3244 * And there are "variable" fps files this needs to detect as well. */
3245 static int tb_unreliable(AVCodecContext *c)
3247 if (c->time_base.den >= 101LL * c->time_base.num ||
3248 c->time_base.den < 5LL * c->time_base.num ||
3249 // c->codec_tag == AV_RL32("DIVX") ||
3250 // c->codec_tag == AV_RL32("XVID") ||
3251 c->codec_tag == AV_RL32("mp4v") ||
3252 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3253 c->codec_id == AV_CODEC_ID_GIF ||
3254 c->codec_id == AV_CODEC_ID_HEVC ||
3255 c->codec_id == AV_CODEC_ID_H264)
3260 int ff_alloc_extradata(AVCodecParameters *par, int size)
3262 av_freep(&par->extradata);
3263 par->extradata_size = 0;
3265 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3266 return AVERROR(EINVAL);
3268 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3269 if (!par->extradata)
3270 return AVERROR(ENOMEM);
3272 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3273 par->extradata_size = size;
3278 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3280 int ret = ff_alloc_extradata(par, size);
3283 ret = avio_read(pb, par->extradata, size);
3285 av_freep(&par->extradata);
3286 par->extradata_size = 0;
3287 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3288 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3294 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3297 int64_t last = st->internal->info->last_dts;
3299 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3300 && ts - (uint64_t)last < INT64_MAX) {
3301 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3302 int64_t duration = ts - last;
3304 if (!st->internal->info->duration_error)
3305 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3306 if (!st->internal->info->duration_error)
3307 return AVERROR(ENOMEM);
3309 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3310 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3311 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3312 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3313 int framerate = get_std_framerate(i);
3314 double sdts = dts*framerate/(1001*12);
3315 for (j= 0; j<2; j++) {
3316 int64_t ticks = llrint(sdts+j*0.5);
3317 double error= sdts - ticks + j*0.5;
3318 st->internal->info->duration_error[j][0][i] += error;
3319 st->internal->info->duration_error[j][1][i] += error*error;
3323 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3324 st->internal->info->duration_count++;
3325 st->internal->info->rfps_duration_sum += duration;
3328 if (st->internal->info->duration_count % 10 == 0) {
3329 int n = st->internal->info->duration_count;
3330 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3331 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3332 double a0 = st->internal->info->duration_error[0][0][i] / n;
3333 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3334 double a1 = st->internal->info->duration_error[1][0][i] / n;
3335 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3336 if (error0 > 0.04 && error1 > 0.04) {
3337 st->internal->info->duration_error[0][1][i] = 2e10;
3338 st->internal->info->duration_error[1][1][i] = 2e10;
3344 // ignore the first 4 values, they might have some random jitter
3345 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3346 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3348 if (ts != AV_NOPTS_VALUE)
3349 st->internal->info->last_dts = ts;
3354 void ff_rfps_calculate(AVFormatContext *ic)
3358 for (i = 0; i < ic->nb_streams; i++) {
3359 AVStream *st = ic->streams[i];
3361 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3363 // the check for tb_unreliable() is not completely correct, since this is not about handling
3364 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3365 // ipmovie.c produces.
3366 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)
3367 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);
3368 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3369 && tb_unreliable(st->internal->avctx)) {
3371 double best_error= 0.01;
3372 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3374 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3377 if (st->internal->info->codec_info_duration &&
3378 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3380 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3383 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))
3386 for (k= 0; k<2; k++) {
3387 int n = st->internal->info->duration_count;
3388 double a= st->internal->info->duration_error[k][0][j] / n;
3389 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3391 if (error < best_error && best_error> 0.000000001) {
3393 num = get_std_framerate(j);
3396 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3399 // do not increase frame rate by more than 1 % in order to match a standard rate.
3400 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3401 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3403 if ( !st->avg_frame_rate.num
3404 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3405 && st->internal->info->codec_info_duration <= 0
3406 && st->internal->info->duration_count > 2
3407 && 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
3409 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3410 st->avg_frame_rate = st->r_frame_rate;
3413 av_freep(&st->internal->info->duration_error);
3414 st->internal->info->last_dts = AV_NOPTS_VALUE;
3415 st->internal->info->duration_count = 0;
3416 st->internal->info->rfps_duration_sum = 0;
3420 static int extract_extradata_check(AVStream *st)
3422 const AVBitStreamFilter *f;
3424 f = av_bsf_get_by_name("extract_extradata");
3429 const enum AVCodecID *ids;
3430 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3431 if (*ids == st->codecpar->codec_id)
3438 static int extract_extradata_init(AVStream *st)
3440 AVStreamInternal *sti = st->internal;
3441 const AVBitStreamFilter *f;
3444 f = av_bsf_get_by_name("extract_extradata");
3448 /* check that the codec id is supported */
3449 ret = extract_extradata_check(st);
3453 sti->extract_extradata.pkt = av_packet_alloc();
3454 if (!sti->extract_extradata.pkt)
3455 return AVERROR(ENOMEM);
3457 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3461 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3466 sti->extract_extradata.bsf->time_base_in = st->time_base;
3468 ret = av_bsf_init(sti->extract_extradata.bsf);
3473 sti->extract_extradata.inited = 1;
3477 av_bsf_free(&sti->extract_extradata.bsf);
3478 av_packet_free(&sti->extract_extradata.pkt);
3482 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3484 AVStreamInternal *sti = st->internal;
3488 if (!sti->extract_extradata.inited) {
3489 ret = extract_extradata_init(st);
3494 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3497 pkt_ref = sti->extract_extradata.pkt;
3498 ret = av_packet_ref(pkt_ref, pkt);
3502 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3504 av_packet_unref(pkt_ref);
3508 while (ret >= 0 && !sti->avctx->extradata) {
3509 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3511 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3516 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3517 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3518 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3519 sti->avctx->extradata = side_data->data;
3520 sti->avctx->extradata_size = side_data->size;
3521 side_data->data = NULL;
3522 side_data->size = 0;
3526 av_packet_unref(pkt_ref);
3532 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3536 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3537 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3539 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3541 return AVERROR(ENOMEM);
3542 memcpy(dst_data, sd_src->data, sd_src->size);
3547 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3549 int i, count = 0, ret = 0, j;
3552 AVCodecContext *avctx;
3554 int64_t old_offset = avio_tell(ic->pb);
3555 // new streams might appear, no options for those
3556 int orig_nb_streams = ic->nb_streams;
3558 int64_t max_analyze_duration = ic->max_analyze_duration;
3559 int64_t max_stream_analyze_duration;
3560 int64_t max_subtitle_analyze_duration;
3561 int64_t probesize = ic->probesize;
3562 int eof_reached = 0;
3563 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3565 flush_codecs = probesize > 0;
3567 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3569 max_stream_analyze_duration = max_analyze_duration;
3570 max_subtitle_analyze_duration = max_analyze_duration;
3571 if (!max_analyze_duration) {
3572 max_stream_analyze_duration =
3573 max_analyze_duration = 5*AV_TIME_BASE;
3574 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3575 if (!strcmp(ic->iformat->name, "flv"))
3576 max_stream_analyze_duration = 90*AV_TIME_BASE;
3577 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3578 max_stream_analyze_duration = 7*AV_TIME_BASE;
3582 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3583 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3585 for (i = 0; i < ic->nb_streams; i++) {
3586 const AVCodec *codec;
3587 AVDictionary *thread_opt = NULL;
3588 st = ic->streams[i];
3589 avctx = st->internal->avctx;
3591 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3592 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3593 /* if (!st->time_base.num)
3595 if (!avctx->time_base.num)
3596 avctx->time_base = st->time_base;
3599 /* check if the caller has overridden the codec id */
3600 #if FF_API_LAVF_AVCTX
3601 FF_DISABLE_DEPRECATION_WARNINGS
3602 if (st->codec->codec_id != st->internal->orig_codec_id) {
3603 st->codecpar->codec_id = st->codec->codec_id;
3604 st->codecpar->codec_type = st->codec->codec_type;
3605 st->internal->orig_codec_id = st->codec->codec_id;
3607 FF_ENABLE_DEPRECATION_WARNINGS
3609 // only for the split stuff
3610 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3611 st->parser = av_parser_init(st->codecpar->codec_id);
3613 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3614 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3615 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3616 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3618 } else if (st->need_parsing) {
3619 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3620 "%s, packets or times may be invalid.\n",
3621 avcodec_get_name(st->codecpar->codec_id));
3625 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3626 st->internal->orig_codec_id = st->codecpar->codec_id;
3628 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3630 goto find_stream_info_err;
3631 if (st->request_probe <= 0)
3632 st->internal->avctx_inited = 1;
3634 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3636 /* Force thread count to 1 since the H.264 decoder will not extract
3637 * SPS and PPS to extradata during multi-threaded decoding. */
3638 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3640 if (ic->codec_whitelist)
3641 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3643 /* Ensure that subtitle_header is properly set. */
3644 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3645 && codec && !avctx->codec) {
3646 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3647 av_log(ic, AV_LOG_WARNING,
3648 "Failed to open codec in %s\n",__FUNCTION__);
3651 // Try to just open decoders, in case this is enough to get parameters.
3652 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3653 if (codec && !avctx->codec)
3654 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3655 av_log(ic, AV_LOG_WARNING,
3656 "Failed to open codec in %s\n",__FUNCTION__);
3659 av_dict_free(&thread_opt);
3662 for (i = 0; i < ic->nb_streams; i++) {
3663 #if FF_API_R_FRAME_RATE
3664 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3666 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3667 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3672 const AVPacket *pkt;
3673 int analyzed_all_streams;
3674 if (ff_check_interrupt(&ic->interrupt_callback)) {
3676 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3680 /* check if one codec still needs to be handled */
3681 for (i = 0; i < ic->nb_streams; i++) {
3682 int fps_analyze_framecount = 20;
3685 st = ic->streams[i];
3686 if (!has_codec_parameters(st, NULL))
3688 /* If the timebase is coarse (like the usual millisecond precision
3689 * of mkv), we need to analyze more frames to reliably arrive at
3690 * the correct fps. */
3691 if (av_q2d(st->time_base) > 0.0005)
3692 fps_analyze_framecount *= 2;
3693 if (!tb_unreliable(st->internal->avctx))
3694 fps_analyze_framecount = 0;
3695 if (ic->fps_probe_size >= 0)
3696 fps_analyze_framecount = ic->fps_probe_size;
3697 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3698 fps_analyze_framecount = 0;
3699 /* variable fps and no guess at the real fps */
3700 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3701 st->internal->info->codec_info_duration_fields/2 :
3702 st->internal->info->duration_count;
3703 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3704 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3705 if (count < fps_analyze_framecount)
3708 // Look at the first 3 frames if there is evidence of frame delay
3709 // but the decoder delay is not set.
3710 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3712 if (!st->internal->avctx->extradata &&
3713 (!st->internal->extract_extradata.inited ||
3714 st->internal->extract_extradata.bsf) &&
3715 extract_extradata_check(st))
3717 if (st->first_dts == AV_NOPTS_VALUE &&
3718 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3719 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3720 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3721 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3724 analyzed_all_streams = 0;
3725 if (!missing_streams || !*missing_streams)
3726 if (i == ic->nb_streams) {
3727 analyzed_all_streams = 1;
3728 /* NOTE: If the format has no header, then we need to read some
3729 * packets to get most of the streams, so we cannot stop here. */
3730 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3731 /* If we found the info for all the codecs, we can stop. */
3733 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3738 /* We did not get all the codec info, but we read too much data. */
3739 if (read_size >= probesize) {
3741 av_log(ic, AV_LOG_DEBUG,
3742 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3743 for (i = 0; i < ic->nb_streams; i++)
3744 if (!ic->streams[i]->r_frame_rate.num &&
3745 ic->streams[i]->internal->info->duration_count <= 1 &&
3746 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3747 strcmp(ic->iformat->name, "image2"))
3748 av_log(ic, AV_LOG_WARNING,
3749 "Stream #%d: not enough frames to estimate rate; "
3750 "consider increasing probesize\n", i);
3754 /* NOTE: A new stream can be added there if no header in file
3755 * (AVFMTCTX_NOHEADER). */
3756 ret = read_frame_internal(ic, &pkt1);
3757 if (ret == AVERROR(EAGAIN))
3766 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3767 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3768 &ic->internal->packet_buffer_end,
3771 goto unref_then_goto_end;
3773 pkt = &ic->internal->packet_buffer_end->pkt;
3778 st = ic->streams[pkt->stream_index];
3779 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3780 read_size += pkt->size;
3782 avctx = st->internal->avctx;
3783 if (!st->internal->avctx_inited) {
3784 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3786 goto unref_then_goto_end;
3787 st->internal->avctx_inited = 1;
3790 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3791 /* check for non-increasing dts */
3792 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3793 st->internal->info->fps_last_dts >= pkt->dts) {
3794 av_log(ic, AV_LOG_DEBUG,
3795 "Non-increasing DTS in stream %d: packet %d with DTS "
3796 "%"PRId64", packet %d with DTS %"PRId64"\n",
3797 st->index, st->internal->info->fps_last_dts_idx,
3798 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3800 st->internal->info->fps_first_dts =
3801 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3803 /* Check for a discontinuity in dts. If the difference in dts
3804 * is more than 1000 times the average packet duration in the
3805 * sequence, we treat it as a discontinuity. */
3806 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3807 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3808 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3809 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3810 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3811 av_log(ic, AV_LOG_WARNING,
3812 "DTS discontinuity in stream %d: packet %d with DTS "
3813 "%"PRId64", packet %d with DTS %"PRId64"\n",
3814 st->index, st->internal->info->fps_last_dts_idx,
3815 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3817 st->internal->info->fps_first_dts =
3818 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3821 /* update stored dts values */
3822 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3823 st->internal->info->fps_first_dts = pkt->dts;
3824 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3826 st->internal->info->fps_last_dts = pkt->dts;
3827 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3829 if (st->codec_info_nb_frames>1) {
3833 if (st->time_base.den > 0)
3834 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3835 if (st->avg_frame_rate.num > 0)
3836 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3839 && st->codec_info_nb_frames>30
3840 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3841 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE)
3842 t = FFMAX(t, av_rescale_q(st->internal->info->fps_last_dts - st->internal->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3844 if (analyzed_all_streams) limit = max_analyze_duration;
3845 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3846 else limit = max_stream_analyze_duration;
3849 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3851 t, pkt->stream_index);
3852 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3853 av_packet_unref(&pkt1);
3856 if (pkt->duration) {
3857 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3858 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3860 st->internal->info->codec_info_duration += pkt->duration;
3861 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3864 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3865 #if FF_API_R_FRAME_RATE
3866 ff_rfps_add_frame(ic, st, pkt->dts);
3868 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3869 st->internal->info->frame_delay_evidence = 1;
3871 if (!st->internal->avctx->extradata) {
3872 ret = extract_extradata(st, pkt);
3874 goto unref_then_goto_end;
3877 /* If still no information, we try to open the codec and to
3878 * decompress the frame. We try to avoid that in most cases as
3879 * it takes longer and uses more memory. For MPEG-4, we need to
3880 * decompress for QuickTime.
3882 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3883 * least one frame of codec data, this makes sure the codec initializes
3884 * the channel configuration and does not only trust the values from
3886 try_decode_frame(ic, st, pkt,
3887 (options && i < orig_nb_streams) ? &options[i] : NULL);
3889 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3890 av_packet_unref(&pkt1);
3892 st->codec_info_nb_frames++;
3898 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3899 st = ic->streams[stream_index];
3900 avctx = st->internal->avctx;
3901 if (!has_codec_parameters(st, NULL)) {
3902 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3903 if (codec && !avctx->codec) {
3904 AVDictionary *opts = NULL;
3905 if (ic->codec_whitelist)
3906 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3907 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3908 av_log(ic, AV_LOG_WARNING,
3909 "Failed to open codec in %s\n",__FUNCTION__);
3910 av_dict_free(&opts);
3914 // EOF already reached while reading the stream above.
3915 // So continue with reoordering DTS with whatever delay we have.
3916 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3917 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3923 AVPacket empty_pkt = { 0 };
3925 av_init_packet(&empty_pkt);
3927 for (i = 0; i < ic->nb_streams; i++) {
3929 st = ic->streams[i];
3931 /* flush the decoders */
3932 if (st->internal->info->found_decoder == 1) {
3934 err = try_decode_frame(ic, st, &empty_pkt,
3935 (options && i < orig_nb_streams)
3936 ? &options[i] : NULL);
3937 } while (err > 0 && !has_codec_parameters(st, NULL));
3940 av_log(ic, AV_LOG_INFO,
3941 "decoding for stream %d failed\n", st->index);
3947 ff_rfps_calculate(ic);
3949 for (i = 0; i < ic->nb_streams; i++) {
3950 st = ic->streams[i];
3951 avctx = st->internal->avctx;
3952 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3953 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3954 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3955 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3956 avctx->codec_tag= tag;
3959 /* estimate average framerate if not set by demuxer */
3960 if (st->internal->info->codec_info_duration_fields &&
3961 !st->avg_frame_rate.num &&
3962 st->internal->info->codec_info_duration) {
3964 double best_error = 0.01;
3965 AVRational codec_frame_rate = avctx->framerate;
3967 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3968 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3969 st->internal->info->codec_info_duration < 0)
3971 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3972 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3973 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3975 /* Round guessed framerate to a "standard" framerate if it's
3976 * within 1% of the original estimate. */
3977 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3978 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3979 double error = fabs(av_q2d(st->avg_frame_rate) /
3980 av_q2d(std_fps) - 1);
3982 if (error < best_error) {
3984 best_fps = std_fps.num;
3987 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3988 error = fabs(av_q2d(codec_frame_rate) /
3989 av_q2d(std_fps) - 1);
3990 if (error < best_error) {
3992 best_fps = std_fps.num;
3997 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3998 best_fps, 12 * 1001, INT_MAX);
4001 if (!st->r_frame_rate.num) {
4002 if ( avctx->time_base.den * (int64_t) st->time_base.num
4003 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4004 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4005 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4007 st->r_frame_rate.num = st->time_base.den;
4008 st->r_frame_rate.den = st->time_base.num;
4011 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4012 AVRational hw_ratio = { avctx->height, avctx->width };
4013 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4016 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4017 if (!avctx->bits_per_coded_sample)
4018 avctx->bits_per_coded_sample =
4019 av_get_bits_per_sample(avctx->codec_id);
4020 // set stream disposition based on audio service type
4021 switch (avctx->audio_service_type) {
4022 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4023 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4025 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4026 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4028 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4029 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4031 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4032 st->disposition = AV_DISPOSITION_COMMENT;
4034 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4035 st->disposition = AV_DISPOSITION_KARAOKE;
4042 estimate_timings(ic, old_offset);
4044 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4046 if (ret >= 0 && ic->nb_streams)
4047 /* We could not have all the codec parameters before EOF. */
4049 for (i = 0; i < ic->nb_streams; i++) {
4051 st = ic->streams[i];
4053 /* if no packet was ever seen, update context now for has_codec_parameters */
4054 if (!st->internal->avctx_inited) {
4055 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4056 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4057 st->codecpar->format = st->internal->avctx->sample_fmt;
4058 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4060 goto find_stream_info_err;
4062 if (!has_codec_parameters(st, &errmsg)) {
4064 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4065 av_log(ic, AV_LOG_WARNING,
4066 "Could not find codec parameters for stream %d (%s): %s\n"
4067 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4068 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4074 compute_chapters_end(ic);
4076 /* update the stream parameters from the internal codec contexts */
4077 for (i = 0; i < ic->nb_streams; i++) {
4078 st = ic->streams[i];
4080 if (st->internal->avctx_inited) {
4081 int orig_w = st->codecpar->width;
4082 int orig_h = st->codecpar->height;
4083 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4085 goto find_stream_info_err;
4086 ret = add_coded_side_data(st, st->internal->avctx);
4088 goto find_stream_info_err;
4090 // The decoder might reduce the video size by the lowres factor.
4091 if (st->internal->avctx->lowres && orig_w) {
4092 st->codecpar->width = orig_w;
4093 st->codecpar->height = orig_h;
4098 #if FF_API_LAVF_AVCTX
4099 FF_DISABLE_DEPRECATION_WARNINGS
4100 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4102 goto find_stream_info_err;
4105 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4106 // by the lowres factor.
4107 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4108 st->codec->lowres = st->internal->avctx->lowres;
4109 st->codec->width = st->internal->avctx->width;
4110 st->codec->height = st->internal->avctx->height;
4114 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4115 st->codec->time_base = st->internal->avctx->time_base;
4116 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4118 st->codec->framerate = st->avg_frame_rate;
4120 if (st->internal->avctx->subtitle_header) {
4121 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4122 if (!st->codec->subtitle_header)
4123 goto find_stream_info_err;
4124 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4125 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4126 st->codec->subtitle_header_size);
4129 // Fields unavailable in AVCodecParameters
4130 st->codec->coded_width = st->internal->avctx->coded_width;
4131 st->codec->coded_height = st->internal->avctx->coded_height;
4132 st->codec->properties = st->internal->avctx->properties;
4133 FF_ENABLE_DEPRECATION_WARNINGS
4136 st->internal->avctx_inited = 0;
4139 find_stream_info_err:
4140 for (i = 0; i < ic->nb_streams; i++) {
4141 st = ic->streams[i];
4142 if (st->internal->info)
4143 av_freep(&st->internal->info->duration_error);
4144 avcodec_close(ic->streams[i]->internal->avctx);
4145 av_freep(&ic->streams[i]->internal->info);
4146 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4147 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4150 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4151 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4154 unref_then_goto_end:
4155 av_packet_unref(&pkt1);
4156 goto find_stream_info_err;
4159 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4163 for (i = 0; i < ic->nb_programs; i++) {
4164 if (ic->programs[i] == last) {
4168 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4169 if (ic->programs[i]->stream_index[j] == s)
4170 return ic->programs[i];
4176 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4177 int wanted_stream_nb, int related_stream,
4178 AVCodec **decoder_ret, int flags)
4180 int i, nb_streams = ic->nb_streams;
4181 int ret = AVERROR_STREAM_NOT_FOUND;
4182 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4183 int count, multiframe, disposition;
4184 int64_t best_bitrate = -1;
4186 unsigned *program = NULL;
4187 const AVCodec *decoder = NULL, *best_decoder = NULL;
4189 if (related_stream >= 0 && wanted_stream_nb < 0) {
4190 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4192 program = p->stream_index;
4193 nb_streams = p->nb_stream_indexes;
4196 for (i = 0; i < nb_streams; i++) {
4197 int real_stream_index = program ? program[i] : i;
4198 AVStream *st = ic->streams[real_stream_index];
4199 AVCodecParameters *par = st->codecpar;
4200 if (par->codec_type != type)
4202 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4204 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4207 decoder = find_decoder(ic, st, par->codec_id);
4210 ret = AVERROR_DECODER_NOT_FOUND;
4214 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4215 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4216 count = st->codec_info_nb_frames;
4217 bitrate = par->bit_rate;
4218 multiframe = FFMIN(5, count);
4219 if ((best_disposition > disposition) ||
4220 (best_disposition == disposition && best_multiframe > multiframe) ||
4221 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4222 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4224 best_disposition = disposition;
4226 best_bitrate = bitrate;
4227 best_multiframe = multiframe;
4228 ret = real_stream_index;
4229 best_decoder = decoder;
4230 if (program && i == nb_streams - 1 && ret < 0) {
4232 nb_streams = ic->nb_streams;
4233 /* no related stream found, try again with everything */
4238 *decoder_ret = (AVCodec*)best_decoder;
4242 /*******************************************************/
4244 int av_read_play(AVFormatContext *s)
4246 if (s->iformat->read_play)
4247 return s->iformat->read_play(s);
4249 return avio_pause(s->pb, 0);
4250 return AVERROR(ENOSYS);
4253 int av_read_pause(AVFormatContext *s)
4255 if (s->iformat->read_pause)
4256 return s->iformat->read_pause(s);
4258 return avio_pause(s->pb, 1);
4259 return AVERROR(ENOSYS);
4262 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4267 dst->time_base = src->time_base;
4268 dst->nb_frames = src->nb_frames;
4269 dst->disposition = src->disposition;
4270 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4271 dst->avg_frame_rate = src->avg_frame_rate;
4272 dst->r_frame_rate = src->r_frame_rate;
4274 av_dict_free(&dst->metadata);
4275 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4279 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4283 /* Free existing side data*/
4284 for (i = 0; i < dst->nb_side_data; i++)
4285 av_free(dst->side_data[i].data);
4286 av_freep(&dst->side_data);
4287 dst->nb_side_data = 0;
4289 /* Copy side data if present */
4290 if (src->nb_side_data) {
4291 dst->side_data = av_mallocz_array(src->nb_side_data,
4292 sizeof(AVPacketSideData));
4293 if (!dst->side_data)
4294 return AVERROR(ENOMEM);
4295 dst->nb_side_data = src->nb_side_data;
4297 for (i = 0; i < src->nb_side_data; i++) {
4298 uint8_t *data = av_memdup(src->side_data[i].data,
4299 src->side_data[i].size);
4301 return AVERROR(ENOMEM);
4302 dst->side_data[i].type = src->side_data[i].type;
4303 dst->side_data[i].size = src->side_data[i].size;
4304 dst->side_data[i].data = data;
4308 #if FF_API_LAVF_FFSERVER
4309 FF_DISABLE_DEPRECATION_WARNINGS
4310 av_freep(&dst->recommended_encoder_configuration);
4311 if (src->recommended_encoder_configuration) {
4312 const char *conf_str = src->recommended_encoder_configuration;
4313 dst->recommended_encoder_configuration = av_strdup(conf_str);
4314 if (!dst->recommended_encoder_configuration)
4315 return AVERROR(ENOMEM);
4317 FF_ENABLE_DEPRECATION_WARNINGS
4323 static void free_stream(AVStream **pst)
4325 AVStream *st = *pst;
4331 for (i = 0; i < st->nb_side_data; i++)
4332 av_freep(&st->side_data[i].data);
4333 av_freep(&st->side_data);
4336 av_parser_close(st->parser);
4338 if (st->attached_pic.data)
4339 av_packet_unref(&st->attached_pic);
4342 avcodec_free_context(&st->internal->avctx);
4343 av_bsf_free(&st->internal->bsfc);
4344 av_freep(&st->internal->priv_pts);
4345 av_bsf_free(&st->internal->extract_extradata.bsf);
4346 av_packet_free(&st->internal->extract_extradata.pkt);
4348 if (st->internal->info)
4349 av_freep(&st->internal->info->duration_error);
4350 av_freep(&st->internal->info);
4352 av_freep(&st->internal);
4354 av_dict_free(&st->metadata);
4355 avcodec_parameters_free(&st->codecpar);
4356 av_freep(&st->probe_data.buf);
4357 av_freep(&st->index_entries);
4358 #if FF_API_LAVF_AVCTX
4359 FF_DISABLE_DEPRECATION_WARNINGS
4360 avcodec_free_context(&st->codec);
4361 FF_ENABLE_DEPRECATION_WARNINGS
4363 av_freep(&st->priv_data);
4364 #if FF_API_LAVF_FFSERVER
4365 FF_DISABLE_DEPRECATION_WARNINGS
4366 av_freep(&st->recommended_encoder_configuration);
4367 FF_ENABLE_DEPRECATION_WARNINGS
4373 void ff_free_stream(AVFormatContext *s, AVStream *st)
4375 av_assert0(s->nb_streams>0);
4376 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4378 free_stream(&s->streams[ --s->nb_streams ]);
4381 void avformat_free_context(AVFormatContext *s)
4388 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4389 s->oformat->deinit(s);
4392 if (s->iformat && s->iformat->priv_class && s->priv_data)
4393 av_opt_free(s->priv_data);
4394 if (s->oformat && s->oformat->priv_class && s->priv_data)
4395 av_opt_free(s->priv_data);
4397 for (i = 0; i < s->nb_streams; i++)
4398 free_stream(&s->streams[i]);
4401 for (i = 0; i < s->nb_programs; i++) {
4402 av_dict_free(&s->programs[i]->metadata);
4403 av_freep(&s->programs[i]->stream_index);
4404 av_freep(&s->programs[i]);
4408 av_freep(&s->programs);
4409 av_freep(&s->priv_data);
4410 while (s->nb_chapters--) {
4411 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4412 av_freep(&s->chapters[s->nb_chapters]);
4414 av_freep(&s->chapters);
4415 av_dict_free(&s->metadata);
4416 av_dict_free(&s->internal->id3v2_meta);
4417 av_freep(&s->streams);
4418 flush_packet_queue(s);
4419 av_freep(&s->internal);
4424 void avformat_close_input(AVFormatContext **ps)
4435 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4436 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4439 flush_packet_queue(s);
4442 if (s->iformat->read_close)
4443 s->iformat->read_close(s);
4445 avformat_free_context(s);
4452 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4458 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4459 if (s->max_streams < INT_MAX/sizeof(*streams))
4460 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);
4463 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4466 s->streams = streams;
4468 st = av_mallocz(sizeof(AVStream));
4472 #if FF_API_LAVF_AVCTX
4473 FF_DISABLE_DEPRECATION_WARNINGS
4474 st->codec = avcodec_alloc_context3(c);
4479 FF_ENABLE_DEPRECATION_WARNINGS
4482 st->internal = av_mallocz(sizeof(*st->internal));
4486 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4487 if (!st->internal->info)
4489 st->internal->info->last_dts = AV_NOPTS_VALUE;
4491 st->codecpar = avcodec_parameters_alloc();
4495 st->internal->avctx = avcodec_alloc_context3(NULL);
4496 if (!st->internal->avctx)
4500 #if FF_API_LAVF_AVCTX
4501 FF_DISABLE_DEPRECATION_WARNINGS
4502 /* no default bitrate if decoding */
4503 st->codec->bit_rate = 0;
4504 FF_ENABLE_DEPRECATION_WARNINGS
4507 /* default pts setting is MPEG-like */
4508 avpriv_set_pts_info(st, 33, 1, 90000);
4509 /* we set the current DTS to 0 so that formats without any timestamps
4510 * but durations get some timestamps, formats with some unknown
4511 * timestamps have their first few packets buffered and the
4512 * timestamps corrected before they are returned to the user */
4513 st->cur_dts = RELATIVE_TS_BASE;
4515 st->cur_dts = AV_NOPTS_VALUE;
4518 st->index = s->nb_streams;
4519 st->start_time = AV_NOPTS_VALUE;
4520 st->duration = AV_NOPTS_VALUE;
4521 st->first_dts = AV_NOPTS_VALUE;
4522 st->probe_packets = s->max_probe_packets;
4523 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4524 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4526 st->last_IP_pts = AV_NOPTS_VALUE;
4527 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4528 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4529 st->pts_buffer[i] = AV_NOPTS_VALUE;
4531 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4533 #if FF_API_R_FRAME_RATE
4534 st->internal->info->last_dts = AV_NOPTS_VALUE;
4536 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4537 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4539 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4541 st->internal->need_context_update = 1;
4543 s->streams[s->nb_streams++] = st;
4550 AVProgram *av_new_program(AVFormatContext *ac, int id)
4552 AVProgram *program = NULL;
4555 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4557 for (i = 0; i < ac->nb_programs; i++)
4558 if (ac->programs[i]->id == id)
4559 program = ac->programs[i];
4562 program = av_mallocz(sizeof(AVProgram));
4565 dynarray_add(&ac->programs, &ac->nb_programs, program);
4566 program->discard = AVDISCARD_NONE;
4567 program->pmt_version = -1;
4570 program->pts_wrap_reference = AV_NOPTS_VALUE;
4571 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4573 program->start_time =
4574 program->end_time = AV_NOPTS_VALUE;
4579 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4580 int64_t start, int64_t end, const char *title)
4582 AVChapter *chapter = NULL;
4585 if (end != AV_NOPTS_VALUE && start > end) {
4586 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4590 for (i = 0; i < s->nb_chapters; i++)
4591 if (s->chapters[i]->id == id)
4592 chapter = s->chapters[i];
4595 chapter = av_mallocz(sizeof(AVChapter));
4598 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4600 av_dict_set(&chapter->metadata, "title", title, 0);
4602 chapter->time_base = time_base;
4603 chapter->start = start;
4609 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4612 AVProgram *program = NULL;
4615 if (idx >= ac->nb_streams) {
4616 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4620 for (i = 0; i < ac->nb_programs; i++) {
4621 if (ac->programs[i]->id != progid)
4623 program = ac->programs[i];
4624 for (j = 0; j < program->nb_stream_indexes; j++)
4625 if (program->stream_index[j] == idx)
4628 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4631 program->stream_index = tmp;
4632 program->stream_index[program->nb_stream_indexes++] = idx;
4637 uint64_t ff_ntp_time(void)
4639 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4642 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4644 uint64_t ntp_ts, frac_part, sec;
4647 //current ntp time in seconds and micro seconds
4648 sec = ntp_time_us / 1000000;
4649 usec = ntp_time_us % 1000000;
4651 //encoding in ntp timestamp format
4652 frac_part = usec * 0xFFFFFFFFULL;
4653 frac_part /= 1000000;
4655 if (sec > 0xFFFFFFFFULL)
4656 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4659 ntp_ts |= frac_part;
4664 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4667 char *q, buf1[20], c;
4668 int nd, len, percentd_found;
4680 while (av_isdigit(*p))
4681 nd = nd * 10 + *p++ - '0';
4683 } while (av_isdigit(c));
4689 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4694 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4696 if ((q - buf + len) > buf_size - 1)
4698 memcpy(q, buf1, len);
4706 if ((q - buf) < buf_size - 1)
4710 if (!percentd_found)
4719 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4721 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4724 void av_url_split(char *proto, int proto_size,
4725 char *authorization, int authorization_size,
4726 char *hostname, int hostname_size,
4727 int *port_ptr, char *path, int path_size, const char *url)
4729 const char *p, *ls, *at, *at2, *col, *brk;
4735 if (authorization_size > 0)
4736 authorization[0] = 0;
4737 if (hostname_size > 0)
4742 /* parse protocol */
4743 if ((p = strchr(url, ':'))) {
4744 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4751 /* no protocol means plain filename */
4752 av_strlcpy(path, url, path_size);
4756 /* separate path from hostname */
4757 ls = p + strcspn(p, "/?#");
4758 av_strlcpy(path, ls, path_size);
4760 /* the rest is hostname, use that to parse auth/port */
4762 /* authorization (user[:pass]@hostname) */
4764 while ((at = strchr(p, '@')) && at < ls) {
4765 av_strlcpy(authorization, at2,
4766 FFMIN(authorization_size, at + 1 - at2));
4767 p = at + 1; /* skip '@' */
4770 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4772 av_strlcpy(hostname, p + 1,
4773 FFMIN(hostname_size, brk - p));
4774 if (brk[1] == ':' && port_ptr)
4775 *port_ptr = atoi(brk + 2);
4776 } else if ((col = strchr(p, ':')) && col < ls) {
4777 av_strlcpy(hostname, p,
4778 FFMIN(col + 1 - p, hostname_size));
4780 *port_ptr = atoi(col + 1);
4782 av_strlcpy(hostname, p,
4783 FFMIN(ls + 1 - p, hostname_size));
4787 int ff_mkdir_p(const char *path)
4790 char *temp = av_strdup(path);
4794 if (!path || !temp) {
4798 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4800 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4804 for ( ; *pos != '\0'; ++pos) {
4805 if (*pos == '/' || *pos == '\\') {
4808 ret = mkdir(temp, 0755);
4813 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4814 ret = mkdir(temp, 0755);
4821 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4824 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4827 'C', 'D', 'E', 'F' };
4828 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4831 'c', 'd', 'e', 'f' };
4832 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4834 for (i = 0; i < s; i++) {
4835 buff[i * 2] = hex_table[src[i] >> 4];
4836 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4842 int ff_hex_to_data(uint8_t *data, const char *p)
4849 p += strspn(p, SPACE_CHARS);
4852 c = av_toupper((unsigned char) *p++);
4853 if (c >= '0' && c <= '9')
4855 else if (c >= 'A' && c <= 'F')
4870 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4871 unsigned int pts_num, unsigned int pts_den)
4874 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4875 if (new_tb.num != pts_num)
4876 av_log(NULL, AV_LOG_DEBUG,
4877 "st:%d removing common factor %d from timebase\n",
4878 s->index, pts_num / new_tb.num);
4880 av_log(NULL, AV_LOG_WARNING,
4881 "st:%d has too large timebase, reducing\n", s->index);
4883 if (new_tb.num <= 0 || new_tb.den <= 0) {
4884 av_log(NULL, AV_LOG_ERROR,
4885 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4886 new_tb.num, new_tb.den,
4890 s->time_base = new_tb;
4891 #if FF_API_LAVF_AVCTX
4892 FF_DISABLE_DEPRECATION_WARNINGS
4893 s->codec->pkt_timebase = new_tb;
4894 FF_ENABLE_DEPRECATION_WARNINGS
4896 s->internal->avctx->pkt_timebase = new_tb;
4897 s->pts_wrap_bits = pts_wrap_bits;
4900 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4903 const char *ptr = str;
4905 /* Parse key=value pairs. */
4908 char *dest = NULL, *dest_end;
4909 int key_len, dest_len = 0;
4911 /* Skip whitespace and potential commas. */
4912 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4919 if (!(ptr = strchr(key, '=')))
4922 key_len = ptr - key;
4924 callback_get_buf(context, key, key_len, &dest, &dest_len);
4925 dest_end = dest + dest_len - 1;
4929 while (*ptr && *ptr != '\"') {
4933 if (dest && dest < dest_end)
4937 if (dest && dest < dest_end)
4945 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4946 if (dest && dest < dest_end)
4954 int ff_find_stream_index(AVFormatContext *s, int id)
4957 for (i = 0; i < s->nb_streams; i++)
4958 if (s->streams[i]->id == id)
4963 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4967 unsigned int codec_tag;
4968 if (ofmt->query_codec)
4969 return ofmt->query_codec(codec_id, std_compliance);
4970 else if (ofmt->codec_tag)
4971 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4972 else if (codec_id == ofmt->video_codec ||
4973 codec_id == ofmt->audio_codec ||
4974 codec_id == ofmt->subtitle_codec ||
4975 codec_id == ofmt->data_codec)
4978 return AVERROR_PATCHWELCOME;
4981 int avformat_network_init(void)
4985 if ((ret = ff_network_init()) < 0)
4987 if ((ret = ff_tls_init()) < 0)
4993 int avformat_network_deinit(void)
5002 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5003 uint64_t channel_layout, int32_t sample_rate,
5004 int32_t width, int32_t height)
5010 return AVERROR(EINVAL);
5013 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5015 if (channel_layout) {
5017 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5021 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5023 if (width || height) {
5025 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5027 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5029 return AVERROR(ENOMEM);
5030 bytestream_put_le32(&data, flags);
5032 bytestream_put_le32(&data, channels);
5034 bytestream_put_le64(&data, channel_layout);
5036 bytestream_put_le32(&data, sample_rate);
5037 if (width || height) {
5038 bytestream_put_le32(&data, width);
5039 bytestream_put_le32(&data, height);
5044 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5046 AVRational undef = {0, 1};
5047 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5048 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5049 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5051 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5052 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5053 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5054 stream_sample_aspect_ratio = undef;
5056 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5057 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5058 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5059 frame_sample_aspect_ratio = undef;
5061 if (stream_sample_aspect_ratio.num)
5062 return stream_sample_aspect_ratio;
5064 return frame_sample_aspect_ratio;
5067 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5069 AVRational fr = st->r_frame_rate;
5070 AVRational codec_fr = st->internal->avctx->framerate;
5071 AVRational avg_fr = st->avg_frame_rate;
5073 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5074 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5079 if (st->internal->avctx->ticks_per_frame > 1) {
5080 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5081 (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))
5089 * Matches a stream specifier (but ignores requested index).
5091 * @param indexptr set to point to the requested stream index if there is one
5093 * @return <0 on error
5094 * 0 if st is NOT a matching stream
5095 * >0 if st is a matching stream
5097 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5098 const char *spec, const char **indexptr, AVProgram **p)
5100 int match = 1; /* Stores if the specifier matches so far. */
5102 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5106 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5107 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5108 enum AVMediaType type;
5112 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5113 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5114 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5115 case 'd': type = AVMEDIA_TYPE_DATA; break;
5116 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5117 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5118 default: av_assert0(0);
5120 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5121 return AVERROR(EINVAL);
5123 #if FF_API_LAVF_AVCTX
5124 FF_DISABLE_DEPRECATION_WARNINGS
5125 if (type != st->codecpar->codec_type
5126 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5128 FF_ENABLE_DEPRECATION_WARNINGS
5130 if (type != st->codecpar->codec_type)
5133 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5135 } else if (*spec == 'p' && *(spec + 1) == ':') {
5140 prog_id = strtol(spec, &endptr, 0);
5141 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5142 if (spec == endptr || (*endptr && *endptr++ != ':'))
5143 return AVERROR(EINVAL);
5146 for (i = 0; i < s->nb_programs; i++) {
5147 if (s->programs[i]->id != prog_id)
5150 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5151 if (st->index == s->programs[i]->stream_index[j]) {
5154 *p = s->programs[i];
5163 } else if (*spec == '#' ||
5164 (*spec == 'i' && *(spec + 1) == ':')) {
5167 spec += 1 + (*spec == 'i');
5168 stream_id = strtol(spec, &endptr, 0);
5169 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5170 return AVERROR(EINVAL);
5171 return match && (stream_id == st->id);
5172 } else if (*spec == 'm' && *(spec + 1) == ':') {
5173 AVDictionaryEntry *tag;
5179 val = strchr(spec, ':');
5181 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5183 return AVERROR(ENOMEM);
5185 tag = av_dict_get(st->metadata, key, NULL, 0);
5187 if (!val || !strcmp(tag->value, val + 1))
5196 return match && ret;
5197 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5198 AVCodecParameters *par = st->codecpar;
5199 #if FF_API_LAVF_AVCTX
5200 FF_DISABLE_DEPRECATION_WARNINGS
5201 AVCodecContext *codec = st->codec;
5202 FF_ENABLE_DEPRECATION_WARNINGS
5205 switch (par->codec_type) {
5206 case AVMEDIA_TYPE_AUDIO:
5207 val = par->sample_rate && par->channels;
5208 #if FF_API_LAVF_AVCTX
5209 val = val || (codec->sample_rate && codec->channels);
5211 if (par->format == AV_SAMPLE_FMT_NONE
5212 #if FF_API_LAVF_AVCTX
5213 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5218 case AVMEDIA_TYPE_VIDEO:
5219 val = par->width && par->height;
5220 #if FF_API_LAVF_AVCTX
5221 val = val || (codec->width && codec->height);
5223 if (par->format == AV_PIX_FMT_NONE
5224 #if FF_API_LAVF_AVCTX
5225 && codec->pix_fmt == AV_PIX_FMT_NONE
5230 case AVMEDIA_TYPE_UNKNOWN:
5237 #if FF_API_LAVF_AVCTX
5238 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5240 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5243 return AVERROR(EINVAL);
5251 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5256 const char *indexptr = NULL;
5257 AVProgram *p = NULL;
5260 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5267 index = strtol(indexptr, &endptr, 0);
5268 if (*endptr) { /* We can't have anything after the requested index. */
5269 ret = AVERROR(EINVAL);
5273 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5274 if (spec == indexptr)
5275 return (index == st->index);
5277 /* If we requested a matching stream index, we have to ensure st is that. */
5278 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5279 for (int i = 0; i < nb_streams && index >= 0; i++) {
5280 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5281 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5284 if (ret > 0 && index-- == 0 && st == candidate)
5290 if (ret == AVERROR(EINVAL))
5291 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5295 int ff_generate_avci_extradata(AVStream *st)
5297 static const uint8_t avci100_1080p_extradata[] = {
5299 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5300 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5301 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5302 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5303 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5304 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5305 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5306 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5307 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5309 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5312 static const uint8_t avci100_1080i_extradata[] = {
5314 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5315 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5316 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5317 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5318 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5319 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5320 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5321 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5322 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5323 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5324 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5326 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5329 static const uint8_t avci50_1080p_extradata[] = {
5331 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5332 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5333 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5334 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5335 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5336 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5337 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5338 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5339 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5341 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5344 static const uint8_t avci50_1080i_extradata[] = {
5346 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5347 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5348 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5349 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5350 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5351 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5352 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5353 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5354 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5355 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5356 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5358 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5361 static const uint8_t avci100_720p_extradata[] = {
5363 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5364 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5365 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5366 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5367 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5368 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5369 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5370 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5371 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5372 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5374 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5377 static const uint8_t avci50_720p_extradata[] = {
5379 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5380 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5381 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5382 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5383 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5384 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5385 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5386 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5387 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5389 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5393 const uint8_t *data = NULL;
5396 if (st->codecpar->width == 1920) {
5397 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5398 data = avci100_1080p_extradata;
5399 size = sizeof(avci100_1080p_extradata);
5401 data = avci100_1080i_extradata;
5402 size = sizeof(avci100_1080i_extradata);
5404 } else if (st->codecpar->width == 1440) {
5405 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5406 data = avci50_1080p_extradata;
5407 size = sizeof(avci50_1080p_extradata);
5409 data = avci50_1080i_extradata;
5410 size = sizeof(avci50_1080i_extradata);
5412 } else if (st->codecpar->width == 1280) {
5413 data = avci100_720p_extradata;
5414 size = sizeof(avci100_720p_extradata);
5415 } else if (st->codecpar->width == 960) {
5416 data = avci50_720p_extradata;
5417 size = sizeof(avci50_720p_extradata);
5423 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5425 memcpy(st->codecpar->extradata, data, size);
5430 uint8_t *av_stream_get_side_data(const AVStream *st,
5431 enum AVPacketSideDataType type, int *size)
5435 for (i = 0; i < st->nb_side_data; i++) {
5436 if (st->side_data[i].type == type) {
5438 *size = st->side_data[i].size;
5439 return st->side_data[i].data;
5447 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5448 uint8_t *data, size_t size)
5450 AVPacketSideData *sd, *tmp;
5453 for (i = 0; i < st->nb_side_data; i++) {
5454 sd = &st->side_data[i];
5456 if (sd->type == type) {
5457 av_freep(&sd->data);
5464 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5465 return AVERROR(ERANGE);
5467 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5469 return AVERROR(ENOMEM);
5472 st->side_data = tmp;
5475 sd = &st->side_data[st->nb_side_data - 1];
5483 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5487 uint8_t *data = av_malloc(size);
5492 ret = av_stream_add_side_data(st, type, data, size);
5501 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5504 const AVBitStreamFilter *bsf;
5507 av_assert0(!st->internal->bsfc);
5509 if (!(bsf = av_bsf_get_by_name(name))) {
5510 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5511 return AVERROR_BSF_NOT_FOUND;
5514 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5517 bsfc->time_base_in = st->time_base;
5518 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5523 if (args && bsfc->filter->priv_class) {
5524 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5525 const char * shorthand[2] = {NULL};
5528 shorthand[0] = opt->name;
5530 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5536 if ((ret = av_bsf_init(bsfc)) < 0) {
5541 st->internal->bsfc = bsfc;
5543 av_log(NULL, AV_LOG_VERBOSE,
5544 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5545 name, args ? args : "");
5550 FF_DISABLE_DEPRECATION_WARNINGS
5551 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5552 AVBitStreamFilterContext *bsfc)
5556 AVPacket new_pkt = *pkt;
5557 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5558 &new_pkt.data, &new_pkt.size,
5559 pkt->data, pkt->size,
5560 pkt->flags & AV_PKT_FLAG_KEY);
5561 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5562 av_packet_unref(pkt);
5563 memset(pkt, 0, sizeof(*pkt));
5566 if(a == 0 && new_pkt.data != pkt->data) {
5567 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
5569 memcpy(t, new_pkt.data, new_pkt.size);
5570 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5575 a = AVERROR(ENOMEM);
5579 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5580 av_buffer_default_free, NULL, 0);
5582 pkt->side_data = NULL;
5583 pkt->side_data_elems = 0;
5584 av_packet_unref(pkt);
5586 av_freep(&new_pkt.data);
5587 a = AVERROR(ENOMEM);
5591 av_log(codec, AV_LOG_ERROR,
5592 "Failed to open bitstream filter %s for stream %d with codec %s",
5593 bsfc->filter->name, pkt->stream_index,
5594 codec->codec ? codec->codec->name : "copy");
5604 FF_ENABLE_DEPRECATION_WARNINGS
5607 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5610 return AVERROR(EINVAL);
5612 if (!(s->oformat->flags & AVFMT_NOFILE))
5613 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5617 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5620 s->io_close(s, *pb);
5624 int ff_is_http_proto(char *filename) {
5625 const char *proto = avio_find_protocol_name(filename);
5626 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5629 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5631 AVDictionaryEntry *entry;
5632 int64_t parsed_timestamp;
5634 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5635 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5636 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5639 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5646 int ff_standardize_creation_time(AVFormatContext *s)
5649 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5651 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5655 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5660 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5662 if (size != AVPALETTE_SIZE) {
5663 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5664 return AVERROR_INVALIDDATA;
5666 memcpy(palette, side_data, AVPALETTE_SIZE);
5670 if (ret == CONTAINS_PAL) {
5672 for (i = 0; i < AVPALETTE_COUNT; i++)
5673 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5680 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5685 ret = av_bprint_finalize(buf, &str);
5688 if (!av_bprint_is_complete(buf)) {
5690 return AVERROR(ENOMEM);
5693 par->extradata = str;
5694 /* Note: the string is NUL terminated (so extradata can be read as a
5695 * string), but the ending character is not accounted in the size (in
5696 * binary formats you are likely not supposed to mux that character). When
5697 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5699 par->extradata_size = buf->len;
5703 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5704 AVStream *ost, const AVStream *ist,
5705 enum AVTimebaseSource copy_tb)
5707 //TODO: use [io]st->internal->avctx
5708 const AVCodecContext *dec_ctx;
5709 AVCodecContext *enc_ctx;
5711 #if FF_API_LAVF_AVCTX
5712 FF_DISABLE_DEPRECATION_WARNINGS
5713 dec_ctx = ist->codec;
5714 enc_ctx = ost->codec;
5715 FF_ENABLE_DEPRECATION_WARNINGS
5717 dec_ctx = ist->internal->avctx;
5718 enc_ctx = ost->internal->avctx;
5721 enc_ctx->time_base = ist->time_base;
5723 * Avi is a special case here because it supports variable fps but
5724 * having the fps and timebase differe significantly adds quite some
5727 if (!strcmp(ofmt->name, "avi")) {
5728 #if FF_API_R_FRAME_RATE
5729 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5730 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5731 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5732 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5733 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5734 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5735 enc_ctx->time_base.num = ist->r_frame_rate.den;
5736 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5737 enc_ctx->ticks_per_frame = 2;
5740 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5741 && av_q2d(ist->time_base) < 1.0/500
5742 || copy_tb == AVFMT_TBCF_DECODER) {
5743 enc_ctx->time_base = dec_ctx->time_base;
5744 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5745 enc_ctx->time_base.den *= 2;
5746 enc_ctx->ticks_per_frame = 2;
5748 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5749 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5750 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5751 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5752 && av_q2d(ist->time_base) < 1.0/500
5753 || copy_tb == AVFMT_TBCF_DECODER) {
5754 enc_ctx->time_base = dec_ctx->time_base;
5755 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5759 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5760 && dec_ctx->time_base.num < dec_ctx->time_base.den
5761 && dec_ctx->time_base.num > 0
5762 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5763 enc_ctx->time_base = dec_ctx->time_base;
5766 if (ost->avg_frame_rate.num)
5767 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5769 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5770 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5775 AVRational av_stream_get_codec_timebase(const AVStream *st)
5777 // See avformat_transfer_internal_stream_timing_info() TODO.
5778 #if FF_API_LAVF_AVCTX
5779 FF_DISABLE_DEPRECATION_WARNINGS
5780 return st->codec->time_base;
5781 FF_ENABLE_DEPRECATION_WARNINGS
5783 return st->internal->avctx->time_base;
5787 void ff_format_set_url(AVFormatContext *s, char *url)
5792 #if FF_API_FORMAT_FILENAME
5793 FF_DISABLE_DEPRECATION_WARNINGS
5794 av_strlcpy(s->filename, url, sizeof(s->filename));
5795 FF_ENABLE_DEPRECATION_WARNINGS