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
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/thread.h"
36 #include "libavutil/time.h"
37 #include "libavutil/time_internal.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
56 #include "libavutil/ffversion.h"
57 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
59 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
63 * various utility functions for use within FFmpeg
66 unsigned avformat_version(void)
68 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
69 return LIBAVFORMAT_VERSION_INT;
72 const char *avformat_configuration(void)
74 return FFMPEG_CONFIGURATION;
77 const char *avformat_license(void)
79 #define LICENSE_PREFIX "libavformat license: "
80 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
83 int ff_lock_avformat(void)
85 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
88 int ff_unlock_avformat(void)
90 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
93 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
95 static int is_relative(int64_t ts) {
96 return ts > (RELATIVE_TS_BASE - (1LL<<48));
100 * Wrap a given time stamp, if there is an indication for an overflow
103 * @param timestamp the time stamp to wrap
104 * @return resulting time stamp
106 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
108 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
109 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
110 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
111 timestamp < st->pts_wrap_reference)
112 return timestamp + (1ULL << st->pts_wrap_bits);
113 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
114 timestamp >= st->pts_wrap_reference)
115 return timestamp - (1ULL << st->pts_wrap_bits);
120 #if FF_API_FORMAT_GET_SET
121 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
122 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
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->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;
221 while (probe_codec = av_codec_next(probe_codec)) {
222 if (probe_codec->id == codec_id &&
223 av_codec_is_decoder(probe_codec) &&
224 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
233 #if FF_API_FORMAT_GET_SET
234 int av_format_get_probe_score(const AVFormatContext *s)
236 return s->probe_score;
240 /* an arbitrarily chosen "sane" max packet size -- 50M */
241 #define SANE_CHUNK_SIZE (50000000)
243 int ffio_limit(AVIOContext *s, int size)
245 if (s->maxsize>= 0) {
246 int64_t remaining= s->maxsize - avio_tell(s);
247 if (remaining < size) {
248 int64_t newsize = avio_size(s);
249 if (!s->maxsize || s->maxsize<newsize)
250 s->maxsize = newsize - !newsize;
251 remaining= s->maxsize - avio_tell(s);
252 remaining= FFMAX(remaining, 0);
255 if (s->maxsize>= 0 && remaining+1 < size) {
256 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
263 /* Read the data in sane-sized chunks and append to pkt.
264 * Return the number of bytes read or an error. */
265 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
267 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
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;
302 av_packet_unref(pkt);
303 return pkt->size > orig_size ? pkt->size - orig_size : ret;
306 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
311 pkt->pos = avio_tell(s);
313 return append_packet_chunked(s, pkt, size);
316 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
319 return av_get_packet(s, pkt, size);
320 return append_packet_chunked(s, pkt, size);
323 int av_filename_number_test(const char *filename)
327 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
330 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
333 static const struct {
336 enum AVMediaType type;
338 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
339 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
340 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
341 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
342 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
343 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
344 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
345 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
346 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
347 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
348 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
349 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
350 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
351 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
352 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
356 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
360 av_log(s, AV_LOG_DEBUG,
361 "Probe with size=%d, packets=%d detected %s with score=%d\n",
362 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
364 for (i = 0; fmt_id_type[i].name; i++) {
365 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
366 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
367 st->codecpar->sample_rate)
369 if (st->request_probe > score &&
370 st->codecpar->codec_id != fmt_id_type[i].id)
372 st->codecpar->codec_id = fmt_id_type[i].id;
373 st->codecpar->codec_type = fmt_id_type[i].type;
374 st->internal->need_context_update = 1;
375 #if FF_API_LAVF_AVCTX
376 FF_DISABLE_DEPRECATION_WARNINGS
377 st->codec->codec_type = st->codecpar->codec_type;
378 st->codec->codec_id = st->codecpar->codec_id;
379 FF_ENABLE_DEPRECATION_WARNINGS
388 /************************************************************/
389 /* input media file */
391 int av_demuxer_open(AVFormatContext *ic) {
394 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
395 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
396 return AVERROR(EINVAL);
399 if (ic->iformat->read_header) {
400 err = ic->iformat->read_header(ic);
405 if (ic->pb && !ic->internal->data_offset)
406 ic->internal->data_offset = avio_tell(ic->pb);
411 /* Open input file and probe the format if necessary. */
412 static int init_input(AVFormatContext *s, const char *filename,
413 AVDictionary **options)
416 AVProbeData pd = { filename, NULL, 0 };
417 int score = AVPROBE_SCORE_RETRY;
420 s->flags |= AVFMT_FLAG_CUSTOM_IO;
422 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
423 s, 0, s->format_probesize);
424 else if (s->iformat->flags & AVFMT_NOFILE)
425 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
426 "will be ignored with AVFMT_NOFILE format.\n");
430 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
431 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
434 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
439 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
440 s, 0, s->format_probesize);
443 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
444 AVPacketList **plast_pktl, int ref)
446 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
450 return AVERROR(ENOMEM);
453 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
462 (*plast_pktl)->next = pktl;
464 *packet_buffer = pktl;
466 /* Add the packet in the buffered packet list. */
471 int avformat_queue_attached_pictures(AVFormatContext *s)
474 for (i = 0; i < s->nb_streams; i++)
475 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
476 s->streams[i]->discard < AVDISCARD_ALL) {
477 if (s->streams[i]->attached_pic.size <= 0) {
478 av_log(s, AV_LOG_WARNING,
479 "Attached picture on stream %d has invalid size, "
484 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
485 &s->streams[i]->attached_pic,
486 &s->internal->raw_packet_buffer_end, 1);
493 static int update_stream_avctx(AVFormatContext *s)
496 for (i = 0; i < s->nb_streams; i++) {
497 AVStream *st = s->streams[i];
499 if (!st->internal->need_context_update)
502 /* close parser, because it depends on the codec */
503 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
504 av_parser_close(st->parser);
508 /* update internal codec context, for the parser */
509 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
513 #if FF_API_LAVF_AVCTX
514 FF_DISABLE_DEPRECATION_WARNINGS
515 /* update deprecated public codec context */
516 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
519 FF_ENABLE_DEPRECATION_WARNINGS
522 st->internal->need_context_update = 0;
528 int avformat_open_input(AVFormatContext **ps, const char *filename,
529 AVInputFormat *fmt, AVDictionary **options)
531 AVFormatContext *s = *ps;
533 AVDictionary *tmp = NULL;
534 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
536 if (!s && !(s = avformat_alloc_context()))
537 return AVERROR(ENOMEM);
539 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
540 return AVERROR(EINVAL);
546 av_dict_copy(&tmp, *options, 0);
548 if (s->pb) // must be before any goto fail
549 s->flags |= AVFMT_FLAG_CUSTOM_IO;
551 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
554 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
555 if ((ret = init_input(s, filename, &tmp)) < 0)
557 s->probe_score = ret;
559 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
560 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
561 if (!s->protocol_whitelist) {
562 ret = AVERROR(ENOMEM);
567 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
568 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
569 if (!s->protocol_blacklist) {
570 ret = AVERROR(ENOMEM);
575 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
576 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
577 ret = AVERROR(EINVAL);
581 avio_skip(s->pb, s->skip_initial_bytes);
583 /* Check filename in case an image number is expected. */
584 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
585 if (!av_filename_number_test(filename)) {
586 ret = AVERROR(EINVAL);
591 s->duration = s->start_time = AV_NOPTS_VALUE;
593 /* Allocate private data. */
594 if (s->iformat->priv_data_size > 0) {
595 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
596 ret = AVERROR(ENOMEM);
599 if (s->iformat->priv_class) {
600 *(const AVClass **) s->priv_data = s->iformat->priv_class;
601 av_opt_set_defaults(s->priv_data);
602 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
607 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
609 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
612 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
613 if ((ret = s->iformat->read_header(s)) < 0)
617 s->metadata = s->internal->id3v2_meta;
618 s->internal->id3v2_meta = NULL;
619 } else if (s->internal->id3v2_meta) {
620 int level = AV_LOG_WARNING;
621 if (s->error_recognition & AV_EF_COMPLIANT)
622 level = AV_LOG_ERROR;
623 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
624 av_dict_free(&s->internal->id3v2_meta);
625 if (s->error_recognition & AV_EF_EXPLODE)
626 return AVERROR_INVALIDDATA;
629 if (id3v2_extra_meta) {
630 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
631 !strcmp(s->iformat->name, "tta")) {
632 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
634 if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
637 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
639 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
641 if ((ret = avformat_queue_attached_pictures(s)) < 0)
644 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
645 s->internal->data_offset = avio_tell(s->pb);
647 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
649 update_stream_avctx(s);
651 for (i = 0; i < s->nb_streams; i++)
652 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
655 av_dict_free(options);
662 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
664 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
666 avformat_free_context(s);
671 /*******************************************************/
673 static void force_codec_ids(AVFormatContext *s, AVStream *st)
675 switch (st->codecpar->codec_type) {
676 case AVMEDIA_TYPE_VIDEO:
677 if (s->video_codec_id)
678 st->codecpar->codec_id = s->video_codec_id;
680 case AVMEDIA_TYPE_AUDIO:
681 if (s->audio_codec_id)
682 st->codecpar->codec_id = s->audio_codec_id;
684 case AVMEDIA_TYPE_SUBTITLE:
685 if (s->subtitle_codec_id)
686 st->codecpar->codec_id = s->subtitle_codec_id;
688 case AVMEDIA_TYPE_DATA:
689 if (s->data_codec_id)
690 st->codecpar->codec_id = s->data_codec_id;
695 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
697 if (st->request_probe>0) {
698 AVProbeData *pd = &st->probe_data;
700 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
704 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
706 av_log(s, AV_LOG_WARNING,
707 "Failed to reallocate probe buffer for stream %d\n",
712 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
713 pd->buf_size += pkt->size;
714 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
717 st->probe_packets = 0;
719 av_log(s, AV_LOG_WARNING,
720 "nothing to probe for stream %d\n", st->index);
724 end= s->internal->raw_packet_buffer_remaining_size <= 0
725 || st->probe_packets<= 0;
727 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
728 int score = set_codec_from_probe_data(s, st, pd);
729 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
733 st->request_probe = -1;
734 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
735 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
737 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
739 force_codec_ids(s, st);
745 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
747 int64_t ref = pkt->dts;
748 int i, pts_wrap_behavior;
749 int64_t pts_wrap_reference;
750 AVProgram *first_program;
752 if (ref == AV_NOPTS_VALUE)
754 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
756 ref &= (1LL << st->pts_wrap_bits)-1;
758 // reference time stamp should be 60 s before first time stamp
759 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
760 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
761 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
762 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
763 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
765 first_program = av_find_program_from_stream(s, NULL, stream_index);
767 if (!first_program) {
768 int default_stream_index = av_find_default_stream_index(s);
769 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
770 for (i = 0; i < s->nb_streams; i++) {
771 if (av_find_program_from_stream(s, NULL, i))
773 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
774 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
778 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
779 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
783 AVProgram *program = first_program;
785 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
786 pts_wrap_reference = program->pts_wrap_reference;
787 pts_wrap_behavior = program->pts_wrap_behavior;
790 program = av_find_program_from_stream(s, program, stream_index);
793 // update every program with differing pts_wrap_reference
794 program = first_program;
796 if (program->pts_wrap_reference != pts_wrap_reference) {
797 for (i = 0; i<program->nb_stream_indexes; i++) {
798 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
799 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
802 program->pts_wrap_reference = pts_wrap_reference;
803 program->pts_wrap_behavior = pts_wrap_behavior;
805 program = av_find_program_from_stream(s, program, stream_index);
811 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
817 AVPacketList *pktl = s->internal->raw_packet_buffer;
821 st = s->streams[pkt->stream_index];
822 if (s->internal->raw_packet_buffer_remaining_size <= 0)
823 if ((err = probe_codec(s, st, NULL)) < 0)
825 if (st->request_probe <= 0) {
826 s->internal->raw_packet_buffer = pktl->next;
827 s->internal->raw_packet_buffer_remaining_size += pkt->size;
836 ret = s->iformat->read_packet(s, pkt);
838 /* Some demuxers return FFERROR_REDO when they consume
839 data and discard it (ignored streams, junk, extradata).
840 We must re-call the demuxer to get the real packet. */
841 if (ret == FFERROR_REDO)
843 if (!pktl || ret == AVERROR(EAGAIN))
845 for (i = 0; i < s->nb_streams; i++) {
847 if (st->probe_packets || st->request_probe > 0)
848 if ((err = probe_codec(s, st, NULL)) < 0)
850 av_assert0(st->request_probe <= 0);
856 AVPacket tmp = { 0 };
857 ret = av_packet_ref(&tmp, pkt);
863 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
864 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
865 av_log(s, AV_LOG_WARNING,
866 "Dropped corrupted packet (stream = %d)\n",
868 av_packet_unref(pkt);
872 if (pkt->stream_index >= (unsigned)s->nb_streams) {
873 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
877 st = s->streams[pkt->stream_index];
879 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
880 // correct first time stamps to negative values
881 if (!is_relative(st->first_dts))
882 st->first_dts = wrap_timestamp(st, st->first_dts);
883 if (!is_relative(st->start_time))
884 st->start_time = wrap_timestamp(st, st->start_time);
885 if (!is_relative(st->cur_dts))
886 st->cur_dts = wrap_timestamp(st, st->cur_dts);
889 pkt->dts = wrap_timestamp(st, pkt->dts);
890 pkt->pts = wrap_timestamp(st, pkt->pts);
892 force_codec_ids(s, st);
894 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
895 if (s->use_wallclock_as_timestamps)
896 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
898 if (!pktl && st->request_probe <= 0)
901 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
902 &s->internal->raw_packet_buffer_end, 0);
905 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
907 if ((err = probe_codec(s, st, pkt)) < 0)
913 /**********************************************************/
915 static int determinable_frame_size(AVCodecContext *avctx)
917 switch(avctx->codec_id) {
918 case AV_CODEC_ID_MP1:
919 case AV_CODEC_ID_MP2:
920 case AV_CODEC_ID_MP3:
928 * Return the frame duration in seconds. Return 0 if not available.
930 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
931 AVCodecParserContext *pc, AVPacket *pkt)
933 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
934 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
935 int frame_size, sample_rate;
937 #if FF_API_LAVF_AVCTX
938 FF_DISABLE_DEPRECATION_WARNINGS
939 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
940 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
941 FF_ENABLE_DEPRECATION_WARNINGS
946 switch (st->codecpar->codec_type) {
947 case AVMEDIA_TYPE_VIDEO:
948 if (st->r_frame_rate.num && !pc && s->iformat) {
949 *pnum = st->r_frame_rate.den;
950 *pden = st->r_frame_rate.num;
951 } else if (st->time_base.num * 1000LL > st->time_base.den) {
952 *pnum = st->time_base.num;
953 *pden = st->time_base.den;
954 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
955 av_assert0(st->internal->avctx->ticks_per_frame);
956 av_reduce(pnum, pden,
958 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
961 if (pc && pc->repeat_pict) {
962 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
963 av_reduce(pnum, pden,
964 (*pnum) * (1LL + pc->repeat_pict),
968 /* If this codec can be interlaced or progressive then we need
969 * a parser to compute duration of a packet. Thus if we have
970 * no parser in such case leave duration undefined. */
971 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
975 case AVMEDIA_TYPE_AUDIO:
976 if (st->internal->avctx_inited) {
977 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
978 sample_rate = st->internal->avctx->sample_rate;
980 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
981 sample_rate = st->codecpar->sample_rate;
983 if (frame_size <= 0 || sample_rate <= 0)
993 static int is_intra_only(enum AVCodecID id)
995 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
998 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1003 static int has_decode_delay_been_guessed(AVStream *st)
1005 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1006 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1008 #if CONFIG_H264_DECODER
1009 if (st->internal->avctx->has_b_frames &&
1010 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1013 if (st->internal->avctx->has_b_frames<3)
1014 return st->nb_decoded_frames >= 7;
1015 else if (st->internal->avctx->has_b_frames<4)
1016 return st->nb_decoded_frames >= 18;
1018 return st->nb_decoded_frames >= 20;
1021 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1025 if (pktl == s->internal->packet_buffer_end)
1026 return s->internal->parse_queue;
1030 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1031 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1032 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1035 int delay = st->internal->avctx->has_b_frames;
1038 if (dts == AV_NOPTS_VALUE) {
1039 int64_t best_score = INT64_MAX;
1040 for (i = 0; i<delay; i++) {
1041 if (st->pts_reorder_error_count[i]) {
1042 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1043 if (score < best_score) {
1045 dts = pts_buffer[i];
1050 for (i = 0; i<delay; i++) {
1051 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1052 int64_t diff = FFABS(pts_buffer[i] - dts)
1053 + (uint64_t)st->pts_reorder_error[i];
1054 diff = FFMAX(diff, st->pts_reorder_error[i]);
1055 st->pts_reorder_error[i] = diff;
1056 st->pts_reorder_error_count[i]++;
1057 if (st->pts_reorder_error_count[i] > 250) {
1058 st->pts_reorder_error[i] >>= 1;
1059 st->pts_reorder_error_count[i] >>= 1;
1066 if (dts == AV_NOPTS_VALUE)
1067 dts = pts_buffer[0];
1073 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1074 * of the packets in a window.
1076 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1077 AVPacketList *pkt_buffer)
1079 AVStream *st = s->streams[stream_index];
1080 int delay = st->internal->avctx->has_b_frames;
1083 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1085 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1086 pts_buffer[i] = AV_NOPTS_VALUE;
1088 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1089 if (pkt_buffer->pkt.stream_index != stream_index)
1092 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1093 pts_buffer[0] = pkt_buffer->pkt.pts;
1094 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1095 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1097 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1102 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1103 int64_t dts, int64_t pts, AVPacket *pkt)
1105 AVStream *st = s->streams[stream_index];
1106 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1107 AVPacketList *pktl_it;
1111 if (st->first_dts != AV_NOPTS_VALUE ||
1112 dts == AV_NOPTS_VALUE ||
1113 st->cur_dts == AV_NOPTS_VALUE ||
1117 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1119 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1121 if (is_relative(pts))
1124 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1125 if (pktl_it->pkt.stream_index != stream_index)
1127 if (is_relative(pktl_it->pkt.pts))
1128 pktl_it->pkt.pts += shift;
1130 if (is_relative(pktl_it->pkt.dts))
1131 pktl_it->pkt.dts += shift;
1133 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1134 st->start_time = pktl_it->pkt.pts;
1135 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1136 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1140 if (has_decode_delay_been_guessed(st)) {
1141 update_dts_from_pts(s, stream_index, pktl);
1144 if (st->start_time == AV_NOPTS_VALUE) {
1145 st->start_time = pts;
1146 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1147 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1151 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1152 int stream_index, int duration)
1154 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1155 int64_t cur_dts = RELATIVE_TS_BASE;
1157 if (st->first_dts != AV_NOPTS_VALUE) {
1158 if (st->update_initial_durations_done)
1160 st->update_initial_durations_done = 1;
1161 cur_dts = st->first_dts;
1162 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1163 if (pktl->pkt.stream_index == stream_index) {
1164 if (pktl->pkt.pts != pktl->pkt.dts ||
1165 pktl->pkt.dts != AV_NOPTS_VALUE ||
1168 cur_dts -= duration;
1171 if (pktl && pktl->pkt.dts != st->first_dts) {
1172 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1173 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1177 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1180 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1181 st->first_dts = cur_dts;
1182 } else if (st->cur_dts != RELATIVE_TS_BASE)
1185 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1186 if (pktl->pkt.stream_index != stream_index)
1188 if ((pktl->pkt.pts == pktl->pkt.dts ||
1189 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1190 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1191 pktl->pkt.dts == st->first_dts ||
1192 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1193 !pktl->pkt.duration) {
1194 pktl->pkt.dts = cur_dts;
1195 if (!st->internal->avctx->has_b_frames)
1196 pktl->pkt.pts = cur_dts;
1197 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1198 pktl->pkt.duration = duration;
1201 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1204 st->cur_dts = cur_dts;
1207 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1208 AVCodecParserContext *pc, AVPacket *pkt,
1209 int64_t next_dts, int64_t next_pts)
1211 int num, den, presentation_delayed, delay, i;
1213 AVRational duration;
1214 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1215 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1217 if (s->flags & AVFMT_FLAG_NOFILLIN)
1220 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1221 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1222 if (st->last_dts_for_order_check <= pkt->dts) {
1225 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1226 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1228 st->last_dts_for_order_check);
1229 st->dts_misordered++;
1231 if (st->dts_ordered + st->dts_misordered > 250) {
1232 st->dts_ordered >>= 1;
1233 st->dts_misordered >>= 1;
1237 st->last_dts_for_order_check = pkt->dts;
1238 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1239 pkt->dts = AV_NOPTS_VALUE;
1242 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1243 pkt->dts = AV_NOPTS_VALUE;
1245 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1246 && !st->internal->avctx->has_b_frames)
1247 //FIXME Set low_delay = 0 when has_b_frames = 1
1248 st->internal->avctx->has_b_frames = 1;
1250 /* do we have a video B-frame ? */
1251 delay = st->internal->avctx->has_b_frames;
1252 presentation_delayed = 0;
1254 /* XXX: need has_b_frame, but cannot get it if the codec is
1255 * not initialized */
1257 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1258 presentation_delayed = 1;
1260 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1261 st->pts_wrap_bits < 63 &&
1262 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1263 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1264 pkt->dts -= 1LL << st->pts_wrap_bits;
1266 pkt->pts += 1LL << st->pts_wrap_bits;
1269 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1270 * We take the conservative approach and discard both.
1271 * Note: If this is misbehaving for an H.264 file, then possibly
1272 * presentation_delayed is not set correctly. */
1273 if (delay == 1 && pkt->dts == pkt->pts &&
1274 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1275 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1276 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1277 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1278 pkt->dts = AV_NOPTS_VALUE;
1281 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1282 if (pkt->duration == 0) {
1283 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1285 duration = (AVRational) {num, den};
1286 pkt->duration = av_rescale_rnd(1,
1287 num * (int64_t) st->time_base.den,
1288 den * (int64_t) st->time_base.num,
1293 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1294 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1296 /* Correct timestamps with byte offset if demuxers only have timestamps
1297 * on packet boundaries */
1298 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1299 /* this will estimate bitrate based on this frame's duration and size */
1300 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1301 if (pkt->pts != AV_NOPTS_VALUE)
1303 if (pkt->dts != AV_NOPTS_VALUE)
1307 /* This may be redundant, but it should not hurt. */
1308 if (pkt->dts != AV_NOPTS_VALUE &&
1309 pkt->pts != AV_NOPTS_VALUE &&
1310 pkt->pts > pkt->dts)
1311 presentation_delayed = 1;
1313 if (s->debug & FF_FDEBUG_TS)
1314 av_log(s, AV_LOG_TRACE,
1315 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1316 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1317 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1319 /* Interpolate PTS and DTS if they are not present. We skip H264
1320 * currently because delay and has_b_frames are not reliably set. */
1321 if ((delay == 0 || (delay == 1 && pc)) &&
1323 if (presentation_delayed) {
1324 /* DTS = decompression timestamp */
1325 /* PTS = presentation timestamp */
1326 if (pkt->dts == AV_NOPTS_VALUE)
1327 pkt->dts = st->last_IP_pts;
1328 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1329 if (pkt->dts == AV_NOPTS_VALUE)
1330 pkt->dts = st->cur_dts;
1332 /* This is tricky: the dts must be incremented by the duration
1333 * of the frame we are displaying, i.e. the last I- or P-frame. */
1334 if (st->last_IP_duration == 0)
1335 st->last_IP_duration = pkt->duration;
1336 if (pkt->dts != AV_NOPTS_VALUE)
1337 st->cur_dts = pkt->dts + st->last_IP_duration;
1338 if (pkt->dts != AV_NOPTS_VALUE &&
1339 pkt->pts == AV_NOPTS_VALUE &&
1340 st->last_IP_duration > 0 &&
1341 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1342 next_dts != next_pts &&
1343 next_pts != AV_NOPTS_VALUE)
1344 pkt->pts = next_dts;
1346 st->last_IP_duration = pkt->duration;
1347 st->last_IP_pts = pkt->pts;
1348 /* Cannot compute PTS if not present (we can compute it only
1349 * by knowing the future. */
1350 } else if (pkt->pts != AV_NOPTS_VALUE ||
1351 pkt->dts != AV_NOPTS_VALUE ||
1354 /* presentation is not delayed : PTS and DTS are the same */
1355 if (pkt->pts == AV_NOPTS_VALUE)
1356 pkt->pts = pkt->dts;
1357 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1359 if (pkt->pts == AV_NOPTS_VALUE)
1360 pkt->pts = st->cur_dts;
1361 pkt->dts = pkt->pts;
1362 if (pkt->pts != AV_NOPTS_VALUE)
1363 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1367 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1368 st->pts_buffer[0] = pkt->pts;
1369 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1370 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1372 if(has_decode_delay_been_guessed(st))
1373 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1375 // We skipped it above so we try here.
1377 // This should happen on the first packet
1378 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1379 if (pkt->dts > st->cur_dts)
1380 st->cur_dts = pkt->dts;
1382 if (s->debug & FF_FDEBUG_TS)
1383 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1384 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1387 if (is_intra_only(st->codecpar->codec_id))
1388 pkt->flags |= AV_PKT_FLAG_KEY;
1389 #if FF_API_CONVERGENCE_DURATION
1390 FF_DISABLE_DEPRECATION_WARNINGS
1392 pkt->convergence_duration = pc->convergence_duration;
1393 FF_ENABLE_DEPRECATION_WARNINGS
1397 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1400 AVPacketList *pktl = *pkt_buf;
1401 *pkt_buf = pktl->next;
1402 av_packet_unref(&pktl->pkt);
1405 *pkt_buf_end = NULL;
1409 * Parse a packet, add all split parts to parse_queue.
1411 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1413 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1415 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1416 AVStream *st = s->streams[stream_index];
1417 uint8_t *data = pkt ? pkt->data : NULL;
1418 int size = pkt ? pkt->size : 0;
1419 int ret = 0, got_output = 0;
1422 av_init_packet(&flush_pkt);
1425 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1426 // preserve 0-size sync packets
1427 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1430 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1432 int64_t next_pts = pkt->pts;
1433 int64_t next_dts = pkt->dts;
1435 av_init_packet(&out_pkt);
1436 len = av_parser_parse2(st->parser, st->internal->avctx,
1437 &out_pkt.data, &out_pkt.size, data, size,
1438 pkt->pts, pkt->dts, pkt->pos);
1440 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1442 /* increment read pointer */
1446 got_output = !!out_pkt.size;
1451 if (pkt->side_data) {
1452 out_pkt.side_data = pkt->side_data;
1453 out_pkt.side_data_elems = pkt->side_data_elems;
1454 pkt->side_data = NULL;
1455 pkt->side_data_elems = 0;
1458 /* set the duration */
1459 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1460 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1461 if (st->internal->avctx->sample_rate > 0) {
1463 av_rescale_q_rnd(st->parser->duration,
1464 (AVRational) { 1, st->internal->avctx->sample_rate },
1470 out_pkt.stream_index = st->index;
1471 out_pkt.pts = st->parser->pts;
1472 out_pkt.dts = st->parser->dts;
1473 out_pkt.pos = st->parser->pos;
1474 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1476 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1477 out_pkt.pos = st->parser->frame_offset;
1479 if (st->parser->key_frame == 1 ||
1480 (st->parser->key_frame == -1 &&
1481 st->parser->pict_type == AV_PICTURE_TYPE_I))
1482 out_pkt.flags |= AV_PKT_FLAG_KEY;
1484 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1485 out_pkt.flags |= AV_PKT_FLAG_KEY;
1487 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1489 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1490 &s->internal->parse_queue_end, 1);
1491 av_packet_unref(&out_pkt);
1496 /* end of the stream => close and free the parser */
1497 if (pkt == &flush_pkt) {
1498 av_parser_close(st->parser);
1503 av_packet_unref(pkt);
1507 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1508 AVPacketList **pkt_buffer_end,
1512 av_assert0(*pkt_buffer);
1515 *pkt_buffer = pktl->next;
1517 *pkt_buffer_end = NULL;
1522 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1524 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1527 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1529 int ret = 0, i, got_packet = 0;
1530 AVDictionary *metadata = NULL;
1532 av_init_packet(pkt);
1534 while (!got_packet && !s->internal->parse_queue) {
1538 /* read next packet */
1539 ret = ff_read_packet(s, &cur_pkt);
1541 if (ret == AVERROR(EAGAIN))
1543 /* flush the parsers */
1544 for (i = 0; i < s->nb_streams; i++) {
1546 if (st->parser && st->need_parsing)
1547 parse_packet(s, NULL, st->index);
1549 /* all remaining packets are now in parse_queue =>
1550 * really terminate parsing */
1554 st = s->streams[cur_pkt.stream_index];
1556 /* update context if required */
1557 if (st->internal->need_context_update) {
1558 if (avcodec_is_open(st->internal->avctx)) {
1559 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1560 avcodec_close(st->internal->avctx);
1561 st->info->found_decoder = 0;
1564 /* close parser, because it depends on the codec */
1565 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1566 av_parser_close(st->parser);
1570 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1574 #if FF_API_LAVF_AVCTX
1575 FF_DISABLE_DEPRECATION_WARNINGS
1576 /* update deprecated public codec context */
1577 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1580 FF_ENABLE_DEPRECATION_WARNINGS
1583 st->internal->need_context_update = 0;
1586 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1587 cur_pkt.dts != AV_NOPTS_VALUE &&
1588 cur_pkt.pts < cur_pkt.dts) {
1589 av_log(s, AV_LOG_WARNING,
1590 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1591 cur_pkt.stream_index,
1592 av_ts2str(cur_pkt.pts),
1593 av_ts2str(cur_pkt.dts),
1596 if (s->debug & FF_FDEBUG_TS)
1597 av_log(s, AV_LOG_DEBUG,
1598 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1599 cur_pkt.stream_index,
1600 av_ts2str(cur_pkt.pts),
1601 av_ts2str(cur_pkt.dts),
1602 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1604 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1605 st->parser = av_parser_init(st->codecpar->codec_id);
1607 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1608 "%s, packets or times may be invalid.\n",
1609 avcodec_get_name(st->codecpar->codec_id));
1610 /* no parser available: just output the raw packets */
1611 st->need_parsing = AVSTREAM_PARSE_NONE;
1612 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1613 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1614 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1615 st->parser->flags |= PARSER_FLAG_ONCE;
1616 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1617 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1620 if (!st->need_parsing || !st->parser) {
1621 /* no parsing needed: we just output the packet as is */
1623 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1624 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1625 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1626 ff_reduce_index(s, st->index);
1627 av_add_index_entry(st, pkt->pos, pkt->dts,
1628 0, 0, AVINDEX_KEYFRAME);
1631 } else if (st->discard < AVDISCARD_ALL) {
1632 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1634 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1635 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1636 st->codecpar->channels = st->internal->avctx->channels;
1637 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1638 st->codecpar->codec_id = st->internal->avctx->codec_id;
1641 av_packet_unref(&cur_pkt);
1643 if (pkt->flags & AV_PKT_FLAG_KEY)
1644 st->skip_to_keyframe = 0;
1645 if (st->skip_to_keyframe) {
1646 av_packet_unref(&cur_pkt);
1654 if (!got_packet && s->internal->parse_queue)
1655 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1658 AVStream *st = s->streams[pkt->stream_index];
1659 int discard_padding = 0;
1660 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1661 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1662 int64_t sample = ts_to_samples(st, pts);
1663 int duration = ts_to_samples(st, pkt->duration);
1664 int64_t end_sample = sample + duration;
1665 if (duration > 0 && end_sample >= st->first_discard_sample &&
1666 sample < st->last_discard_sample)
1667 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1669 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1670 st->skip_samples = st->start_skip_samples;
1671 if (st->skip_samples || discard_padding) {
1672 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1674 AV_WL32(p, st->skip_samples);
1675 AV_WL32(p + 4, discard_padding);
1676 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1678 st->skip_samples = 0;
1681 if (st->inject_global_side_data) {
1682 for (i = 0; i < st->nb_side_data; i++) {
1683 AVPacketSideData *src_sd = &st->side_data[i];
1686 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1689 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1691 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1695 memcpy(dst_data, src_sd->data, src_sd->size);
1697 st->inject_global_side_data = 0;
1701 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1703 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1704 av_dict_copy(&s->metadata, metadata, 0);
1705 av_dict_free(&metadata);
1706 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1709 #if FF_API_LAVF_AVCTX
1710 update_stream_avctx(s);
1713 if (s->debug & FF_FDEBUG_TS)
1714 av_log(s, AV_LOG_DEBUG,
1715 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1716 "size=%d, duration=%"PRId64", flags=%d\n",
1718 av_ts2str(pkt->pts),
1719 av_ts2str(pkt->dts),
1720 pkt->size, pkt->duration, pkt->flags);
1725 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1727 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1733 ret = s->internal->packet_buffer
1734 ? read_from_packet_buffer(&s->internal->packet_buffer,
1735 &s->internal->packet_buffer_end, pkt)
1736 : read_frame_internal(s, pkt);
1743 AVPacketList *pktl = s->internal->packet_buffer;
1746 AVPacket *next_pkt = &pktl->pkt;
1748 if (next_pkt->dts != AV_NOPTS_VALUE) {
1749 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1750 // last dts seen for this stream. if any of packets following
1751 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1752 int64_t last_dts = next_pkt->dts;
1753 av_assert2(wrap_bits <= 64);
1754 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1755 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1756 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1757 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1759 next_pkt->pts = pktl->pkt.dts;
1761 if (last_dts != AV_NOPTS_VALUE) {
1762 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1763 last_dts = pktl->pkt.dts;
1768 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1769 // Fixing the last reference frame had none pts issue (For MXF etc).
1770 // We only do this when
1772 // 2. we are not able to resolve a pts value for current packet.
1773 // 3. the packets for this stream at the end of the files had valid dts.
1774 next_pkt->pts = last_dts + next_pkt->duration;
1776 pktl = s->internal->packet_buffer;
1779 /* read packet from packet buffer, if there is data */
1780 st = s->streams[next_pkt->stream_index];
1781 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1782 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1783 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1784 &s->internal->packet_buffer_end, pkt);
1789 ret = read_frame_internal(s, pkt);
1791 if (pktl && ret != AVERROR(EAGAIN)) {
1798 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1799 &s->internal->packet_buffer_end, 1);
1800 av_packet_unref(pkt);
1807 st = s->streams[pkt->stream_index];
1808 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1809 ff_reduce_index(s, st->index);
1810 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1813 if (is_relative(pkt->dts))
1814 pkt->dts -= RELATIVE_TS_BASE;
1815 if (is_relative(pkt->pts))
1816 pkt->pts -= RELATIVE_TS_BASE;
1821 /* XXX: suppress the packet queue */
1822 static void flush_packet_queue(AVFormatContext *s)
1826 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1827 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1828 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1830 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1833 /*******************************************************/
1836 int av_find_default_stream_index(AVFormatContext *s)
1840 int best_stream = 0;
1841 int best_score = INT_MIN;
1843 if (s->nb_streams <= 0)
1845 for (i = 0; i < s->nb_streams; i++) {
1848 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1849 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1851 if (st->codecpar->width && st->codecpar->height)
1855 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1856 if (st->codecpar->sample_rate)
1859 if (st->codec_info_nb_frames)
1862 if (st->discard != AVDISCARD_ALL)
1865 if (score > best_score) {
1873 /** Flush the frame reader. */
1874 void ff_read_frame_flush(AVFormatContext *s)
1879 flush_packet_queue(s);
1881 /* Reset read state for each stream. */
1882 for (i = 0; i < s->nb_streams; i++) {
1886 av_parser_close(st->parser);
1889 st->last_IP_pts = AV_NOPTS_VALUE;
1890 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1891 if (st->first_dts == AV_NOPTS_VALUE)
1892 st->cur_dts = RELATIVE_TS_BASE;
1894 /* We set the current DTS to an unspecified origin. */
1895 st->cur_dts = AV_NOPTS_VALUE;
1897 st->probe_packets = MAX_PROBE_PACKETS;
1899 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1900 st->pts_buffer[j] = AV_NOPTS_VALUE;
1902 if (s->internal->inject_global_side_data)
1903 st->inject_global_side_data = 1;
1905 st->skip_samples = 0;
1909 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1913 for (i = 0; i < s->nb_streams; i++) {
1914 AVStream *st = s->streams[i];
1917 av_rescale(timestamp,
1918 st->time_base.den * (int64_t) ref_st->time_base.num,
1919 st->time_base.num * (int64_t) ref_st->time_base.den);
1923 void ff_reduce_index(AVFormatContext *s, int stream_index)
1925 AVStream *st = s->streams[stream_index];
1926 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1928 if ((unsigned) st->nb_index_entries >= max_entries) {
1930 for (i = 0; 2 * i < st->nb_index_entries; i++)
1931 st->index_entries[i] = st->index_entries[2 * i];
1932 st->nb_index_entries = i;
1936 int ff_add_index_entry(AVIndexEntry **index_entries,
1937 int *nb_index_entries,
1938 unsigned int *index_entries_allocated_size,
1939 int64_t pos, int64_t timestamp,
1940 int size, int distance, int flags)
1942 AVIndexEntry *entries, *ie;
1945 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1948 if (timestamp == AV_NOPTS_VALUE)
1949 return AVERROR(EINVAL);
1951 if (size < 0 || size > 0x3FFFFFFF)
1952 return AVERROR(EINVAL);
1954 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1955 timestamp -= RELATIVE_TS_BASE;
1957 entries = av_fast_realloc(*index_entries,
1958 index_entries_allocated_size,
1959 (*nb_index_entries + 1) *
1960 sizeof(AVIndexEntry));
1964 *index_entries = entries;
1966 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1967 timestamp, AVSEEK_FLAG_ANY);
1970 index = (*nb_index_entries)++;
1971 ie = &entries[index];
1972 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1974 ie = &entries[index];
1975 if (ie->timestamp != timestamp) {
1976 if (ie->timestamp <= timestamp)
1978 memmove(entries + index + 1, entries + index,
1979 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1980 (*nb_index_entries)++;
1981 } else if (ie->pos == pos && distance < ie->min_distance)
1982 // do not reduce the distance
1983 distance = ie->min_distance;
1987 ie->timestamp = timestamp;
1988 ie->min_distance = distance;
1995 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1996 int size, int distance, int flags)
1998 timestamp = wrap_timestamp(st, timestamp);
1999 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2000 &st->index_entries_allocated_size, pos,
2001 timestamp, size, distance, flags);
2004 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2005 int64_t wanted_timestamp, int flags)
2013 // Optimize appending index entries at the end.
2014 if (b && entries[b - 1].timestamp < wanted_timestamp)
2020 // Search for the next non-discarded packet.
2021 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2023 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2029 timestamp = entries[m].timestamp;
2030 if (timestamp >= wanted_timestamp)
2032 if (timestamp <= wanted_timestamp)
2035 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2037 if (!(flags & AVSEEK_FLAG_ANY))
2038 while (m >= 0 && m < nb_entries &&
2039 !(entries[m].flags & AVINDEX_KEYFRAME))
2040 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2042 if (m == nb_entries)
2047 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2050 int64_t pos_delta = 0;
2052 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2053 const char *proto = avio_find_protocol_name(s->filename);
2056 av_log(s, AV_LOG_INFO,
2057 "Protocol name not provided, cannot determine if input is local or "
2058 "a network protocol, buffers and access patterns cannot be configured "
2059 "optimally without knowing the protocol\n");
2062 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2065 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2066 AVStream *st1 = s->streams[ist1];
2067 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2068 AVStream *st2 = s->streams[ist2];
2074 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2075 AVIndexEntry *e1 = &st1->index_entries[i1];
2076 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2078 skip = FFMAX(skip, e1->size);
2079 for (; i2 < st2->nb_index_entries; i2++) {
2080 AVIndexEntry *e2 = &st2->index_entries[i2];
2081 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2082 if (e2_pts - e1_pts < time_tolerance)
2084 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2092 /* XXX This could be adjusted depending on protocol*/
2093 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2094 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2095 ffio_set_buf_size(s->pb, pos_delta);
2096 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2099 if (skip < (1<<23)) {
2100 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2104 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2106 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2107 wanted_timestamp, flags);
2110 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2111 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2113 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2114 if (stream_index >= 0)
2115 ts = wrap_timestamp(s->streams[stream_index], ts);
2119 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2120 int64_t target_ts, int flags)
2122 AVInputFormat *avif = s->iformat;
2123 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2124 int64_t ts_min, ts_max, ts;
2129 if (stream_index < 0)
2132 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2135 ts_min = AV_NOPTS_VALUE;
2136 pos_limit = -1; // GCC falsely says it may be uninitialized.
2138 st = s->streams[stream_index];
2139 if (st->index_entries) {
2142 /* FIXME: Whole function must be checked for non-keyframe entries in
2143 * index case, especially read_timestamp(). */
2144 index = av_index_search_timestamp(st, target_ts,
2145 flags | AVSEEK_FLAG_BACKWARD);
2146 index = FFMAX(index, 0);
2147 e = &st->index_entries[index];
2149 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2151 ts_min = e->timestamp;
2152 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2153 pos_min, av_ts2str(ts_min));
2155 av_assert1(index == 0);
2158 index = av_index_search_timestamp(st, target_ts,
2159 flags & ~AVSEEK_FLAG_BACKWARD);
2160 av_assert0(index < st->nb_index_entries);
2162 e = &st->index_entries[index];
2163 av_assert1(e->timestamp >= target_ts);
2165 ts_max = e->timestamp;
2166 pos_limit = pos_max - e->min_distance;
2167 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2168 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2172 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2173 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2178 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2181 ff_read_frame_flush(s);
2182 ff_update_cur_dts(s, st, ts);
2187 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2188 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2190 int64_t step = 1024;
2191 int64_t limit, ts_max;
2192 int64_t filesize = avio_size(s->pb);
2193 int64_t pos_max = filesize - 1;
2196 pos_max = FFMAX(0, (pos_max) - step);
2197 ts_max = ff_read_timestamp(s, stream_index,
2198 &pos_max, limit, read_timestamp);
2200 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2201 if (ts_max == AV_NOPTS_VALUE)
2205 int64_t tmp_pos = pos_max + 1;
2206 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2207 &tmp_pos, INT64_MAX, read_timestamp);
2208 if (tmp_ts == AV_NOPTS_VALUE)
2210 av_assert0(tmp_pos > pos_max);
2213 if (tmp_pos >= filesize)
2225 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2226 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2227 int64_t ts_min, int64_t ts_max,
2228 int flags, int64_t *ts_ret,
2229 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2230 int64_t *, int64_t))
2237 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2239 if (ts_min == AV_NOPTS_VALUE) {
2240 pos_min = s->internal->data_offset;
2241 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2242 if (ts_min == AV_NOPTS_VALUE)
2246 if (ts_min >= target_ts) {
2251 if (ts_max == AV_NOPTS_VALUE) {
2252 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2254 pos_limit = pos_max;
2257 if (ts_max <= target_ts) {
2262 av_assert0(ts_min < ts_max);
2265 while (pos_min < pos_limit) {
2266 av_log(s, AV_LOG_TRACE,
2267 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2268 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2269 av_assert0(pos_limit <= pos_max);
2271 if (no_change == 0) {
2272 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2273 // interpolate position (better than dichotomy)
2274 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2276 pos_min - approximate_keyframe_distance;
2277 } else if (no_change == 1) {
2278 // bisection if interpolation did not change min / max pos last time
2279 pos = (pos_min + pos_limit) >> 1;
2281 /* linear search if bisection failed, can only happen if there
2282 * are very few or no keyframes between min/max */
2287 else if (pos > pos_limit)
2291 // May pass pos_limit instead of -1.
2292 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2297 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2298 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2299 pos_min, pos, pos_max,
2300 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2301 pos_limit, start_pos, no_change);
2302 if (ts == AV_NOPTS_VALUE) {
2303 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2306 if (target_ts <= ts) {
2307 pos_limit = start_pos - 1;
2311 if (target_ts >= ts) {
2317 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2318 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2321 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2323 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2324 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2325 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2331 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2332 int64_t pos, int flags)
2334 int64_t pos_min, pos_max;
2336 pos_min = s->internal->data_offset;
2337 pos_max = avio_size(s->pb) - 1;
2341 else if (pos > pos_max)
2344 avio_seek(s->pb, pos, SEEK_SET);
2346 s->io_repositioned = 1;
2351 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2352 int64_t timestamp, int flags)
2359 st = s->streams[stream_index];
2361 index = av_index_search_timestamp(st, timestamp, flags);
2363 if (index < 0 && st->nb_index_entries &&
2364 timestamp < st->index_entries[0].timestamp)
2367 if (index < 0 || index == st->nb_index_entries - 1) {
2371 if (st->nb_index_entries) {
2372 av_assert0(st->index_entries);
2373 ie = &st->index_entries[st->nb_index_entries - 1];
2374 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2376 ff_update_cur_dts(s, st, ie->timestamp);
2378 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2384 read_status = av_read_frame(s, &pkt);
2385 } while (read_status == AVERROR(EAGAIN));
2386 if (read_status < 0)
2388 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2389 if (pkt.flags & AV_PKT_FLAG_KEY) {
2390 av_packet_unref(&pkt);
2393 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2394 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);
2395 av_packet_unref(&pkt);
2399 av_packet_unref(&pkt);
2401 index = av_index_search_timestamp(st, timestamp, flags);
2406 ff_read_frame_flush(s);
2407 if (s->iformat->read_seek)
2408 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2410 ie = &st->index_entries[index];
2411 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2413 ff_update_cur_dts(s, st, ie->timestamp);
2418 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2419 int64_t timestamp, int flags)
2424 if (flags & AVSEEK_FLAG_BYTE) {
2425 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2427 ff_read_frame_flush(s);
2428 return seek_frame_byte(s, stream_index, timestamp, flags);
2431 if (stream_index < 0) {
2432 stream_index = av_find_default_stream_index(s);
2433 if (stream_index < 0)
2436 st = s->streams[stream_index];
2437 /* timestamp for default must be expressed in AV_TIME_BASE units */
2438 timestamp = av_rescale(timestamp, st->time_base.den,
2439 AV_TIME_BASE * (int64_t) st->time_base.num);
2442 /* first, we try the format specific seek */
2443 if (s->iformat->read_seek) {
2444 ff_read_frame_flush(s);
2445 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2451 if (s->iformat->read_timestamp &&
2452 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2453 ff_read_frame_flush(s);
2454 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2455 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2456 ff_read_frame_flush(s);
2457 return seek_frame_generic(s, stream_index, timestamp, flags);
2462 int av_seek_frame(AVFormatContext *s, int stream_index,
2463 int64_t timestamp, int flags)
2467 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2468 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2469 if ((flags & AVSEEK_FLAG_BACKWARD))
2473 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2474 flags & ~AVSEEK_FLAG_BACKWARD);
2477 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2480 ret = avformat_queue_attached_pictures(s);
2485 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2486 int64_t ts, int64_t max_ts, int flags)
2488 if (min_ts > ts || max_ts < ts)
2490 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2491 return AVERROR(EINVAL);
2494 flags |= AVSEEK_FLAG_ANY;
2495 flags &= ~AVSEEK_FLAG_BACKWARD;
2497 if (s->iformat->read_seek2) {
2499 ff_read_frame_flush(s);
2501 if (stream_index == -1 && s->nb_streams == 1) {
2502 AVRational time_base = s->streams[0]->time_base;
2503 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2504 min_ts = av_rescale_rnd(min_ts, time_base.den,
2505 time_base.num * (int64_t)AV_TIME_BASE,
2506 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2507 max_ts = av_rescale_rnd(max_ts, time_base.den,
2508 time_base.num * (int64_t)AV_TIME_BASE,
2509 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2513 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2517 ret = avformat_queue_attached_pictures(s);
2521 if (s->iformat->read_timestamp) {
2522 // try to seek via read_timestamp()
2525 // Fall back on old API if new is not implemented but old is.
2526 // Note the old API has somewhat different semantics.
2527 if (s->iformat->read_seek || 1) {
2528 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2529 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2530 if (ret<0 && ts != min_ts && max_ts != ts) {
2531 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2533 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2538 // try some generic seek like seek_frame_generic() but with new ts semantics
2539 return -1; //unreachable
2542 int avformat_flush(AVFormatContext *s)
2544 ff_read_frame_flush(s);
2548 /*******************************************************/
2551 * Return TRUE if the stream has accurate duration in any stream.
2553 * @return TRUE if the stream has accurate duration for at least one component.
2555 static int has_duration(AVFormatContext *ic)
2560 for (i = 0; i < ic->nb_streams; i++) {
2561 st = ic->streams[i];
2562 if (st->duration != AV_NOPTS_VALUE)
2565 if (ic->duration != AV_NOPTS_VALUE)
2571 * Estimate the stream timings from the one of each components.
2573 * Also computes the global bitrate if possible.
2575 static void update_stream_timings(AVFormatContext *ic)
2577 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2578 int64_t duration, duration1, filesize;
2583 start_time = INT64_MAX;
2584 start_time_text = INT64_MAX;
2585 end_time = INT64_MIN;
2586 end_time_text = INT64_MIN;
2587 duration = INT64_MIN;
2588 for (i = 0; i < ic->nb_streams; i++) {
2589 st = ic->streams[i];
2590 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2591 start_time1 = av_rescale_q(st->start_time, st->time_base,
2593 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2594 if (start_time1 < start_time_text)
2595 start_time_text = start_time1;
2597 start_time = FFMIN(start_time, start_time1);
2598 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2600 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2601 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2602 end_time1 += start_time1;
2603 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2604 end_time_text = FFMAX(end_time_text, end_time1);
2606 end_time = FFMAX(end_time, end_time1);
2608 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2609 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2610 p->start_time = start_time1;
2611 if (p->end_time < end_time1)
2612 p->end_time = end_time1;
2615 if (st->duration != AV_NOPTS_VALUE) {
2616 duration1 = av_rescale_q(st->duration, st->time_base,
2618 duration = FFMAX(duration, duration1);
2621 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2622 start_time = start_time_text;
2623 else if (start_time > start_time_text)
2624 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2626 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2627 end_time = end_time_text;
2628 } else if (end_time < end_time_text) {
2629 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2632 if (start_time != INT64_MAX) {
2633 ic->start_time = start_time;
2634 if (end_time != INT64_MIN) {
2635 if (ic->nb_programs > 1) {
2636 for (i = 0; i < ic->nb_programs; i++) {
2637 p = ic->programs[i];
2638 if (p->start_time != AV_NOPTS_VALUE &&
2639 p->end_time > p->start_time &&
2640 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2641 duration = FFMAX(duration, p->end_time - p->start_time);
2643 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2644 duration = FFMAX(duration, end_time - start_time);
2648 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2649 ic->duration = duration;
2651 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2652 /* compute the bitrate */
2653 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2654 (double) ic->duration;
2655 if (bitrate >= 0 && bitrate <= INT64_MAX)
2656 ic->bit_rate = bitrate;
2660 static void fill_all_stream_timings(AVFormatContext *ic)
2665 update_stream_timings(ic);
2666 for (i = 0; i < ic->nb_streams; i++) {
2667 st = ic->streams[i];
2668 if (st->start_time == AV_NOPTS_VALUE) {
2669 if (ic->start_time != AV_NOPTS_VALUE)
2670 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2672 if (ic->duration != AV_NOPTS_VALUE)
2673 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2679 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2681 int64_t filesize, duration;
2682 int i, show_warning = 0;
2685 /* if bit_rate is already set, we believe it */
2686 if (ic->bit_rate <= 0) {
2687 int64_t bit_rate = 0;
2688 for (i = 0; i < ic->nb_streams; i++) {
2689 st = ic->streams[i];
2690 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2691 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2692 if (st->codecpar->bit_rate > 0) {
2693 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2697 bit_rate += st->codecpar->bit_rate;
2698 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2699 // If we have a videostream with packets but without a bitrate
2700 // then consider the sum not known
2705 ic->bit_rate = bit_rate;
2708 /* if duration is already set, we believe it */
2709 if (ic->duration == AV_NOPTS_VALUE &&
2710 ic->bit_rate != 0) {
2711 filesize = ic->pb ? avio_size(ic->pb) : 0;
2712 if (filesize > ic->internal->data_offset) {
2713 filesize -= ic->internal->data_offset;
2714 for (i = 0; i < ic->nb_streams; i++) {
2715 st = ic->streams[i];
2716 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2717 && st->duration == AV_NOPTS_VALUE) {
2718 duration = av_rescale(8 * filesize, st->time_base.den,
2720 (int64_t) st->time_base.num);
2721 st->duration = duration;
2728 av_log(ic, AV_LOG_WARNING,
2729 "Estimating duration from bitrate, this may be inaccurate\n");
2732 #define DURATION_MAX_READ_SIZE 250000LL
2733 #define DURATION_MAX_RETRY 6
2735 /* only usable for MPEG-PS streams */
2736 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2738 AVPacket pkt1, *pkt = &pkt1;
2740 int num, den, read_size, i, ret;
2741 int found_duration = 0;
2743 int64_t filesize, offset, duration;
2746 /* flush packet queue */
2747 flush_packet_queue(ic);
2749 for (i = 0; i < ic->nb_streams; i++) {
2750 st = ic->streams[i];
2751 if (st->start_time == AV_NOPTS_VALUE &&
2752 st->first_dts == AV_NOPTS_VALUE &&
2753 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2754 av_log(ic, AV_LOG_WARNING,
2755 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2758 av_parser_close(st->parser);
2763 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2764 /* estimate the end time (duration) */
2765 /* XXX: may need to support wrapping */
2766 filesize = ic->pb ? avio_size(ic->pb) : 0;
2768 is_end = found_duration;
2769 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2773 avio_seek(ic->pb, offset, SEEK_SET);
2776 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2780 ret = ff_read_packet(ic, pkt);
2781 } while (ret == AVERROR(EAGAIN));
2784 read_size += pkt->size;
2785 st = ic->streams[pkt->stream_index];
2786 if (pkt->pts != AV_NOPTS_VALUE &&
2787 (st->start_time != AV_NOPTS_VALUE ||
2788 st->first_dts != AV_NOPTS_VALUE)) {
2789 if (pkt->duration == 0) {
2790 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2792 pkt->duration = av_rescale_rnd(1,
2793 num * (int64_t) st->time_base.den,
2794 den * (int64_t) st->time_base.num,
2798 duration = pkt->pts + pkt->duration;
2800 if (st->start_time != AV_NOPTS_VALUE)
2801 duration -= st->start_time;
2803 duration -= st->first_dts;
2805 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2806 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2807 st->duration = duration;
2808 st->info->last_duration = duration;
2811 av_packet_unref(pkt);
2814 /* check if all audio/video streams have valid duration */
2817 for (i = 0; i < ic->nb_streams; i++) {
2818 st = ic->streams[i];
2819 switch (st->codecpar->codec_type) {
2820 case AVMEDIA_TYPE_VIDEO:
2821 case AVMEDIA_TYPE_AUDIO:
2822 if (st->duration == AV_NOPTS_VALUE)
2829 ++retry <= DURATION_MAX_RETRY);
2831 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2833 /* warn about audio/video streams which duration could not be estimated */
2834 for (i = 0; i < ic->nb_streams; i++) {
2835 st = ic->streams[i];
2836 if (st->duration == AV_NOPTS_VALUE) {
2837 switch (st->codecpar->codec_type) {
2838 case AVMEDIA_TYPE_VIDEO:
2839 case AVMEDIA_TYPE_AUDIO:
2840 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2841 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2843 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2847 fill_all_stream_timings(ic);
2849 avio_seek(ic->pb, old_offset, SEEK_SET);
2850 for (i = 0; i < ic->nb_streams; i++) {
2853 st = ic->streams[i];
2854 st->cur_dts = st->first_dts;
2855 st->last_IP_pts = AV_NOPTS_VALUE;
2856 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2857 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2858 st->pts_buffer[j] = AV_NOPTS_VALUE;
2862 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2866 /* get the file size, if possible */
2867 if (ic->iformat->flags & AVFMT_NOFILE) {
2870 file_size = avio_size(ic->pb);
2871 file_size = FFMAX(0, file_size);
2874 if ((!strcmp(ic->iformat->name, "mpeg") ||
2875 !strcmp(ic->iformat->name, "mpegts")) &&
2876 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2877 /* get accurate estimate from the PTSes */
2878 estimate_timings_from_pts(ic, old_offset);
2879 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2880 } else if (has_duration(ic)) {
2881 /* at least one component has timings - we use them for all
2883 fill_all_stream_timings(ic);
2884 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2886 /* less precise: use bitrate info */
2887 estimate_timings_from_bit_rate(ic);
2888 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2890 update_stream_timings(ic);
2894 AVStream av_unused *st;
2895 for (i = 0; i < ic->nb_streams; i++) {
2896 st = ic->streams[i];
2897 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2898 (double) st->start_time * av_q2d(st->time_base),
2899 (double) st->duration * av_q2d(st->time_base));
2901 av_log(ic, AV_LOG_TRACE,
2902 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2903 (double) ic->start_time / AV_TIME_BASE,
2904 (double) ic->duration / AV_TIME_BASE,
2905 (int64_t)ic->bit_rate / 1000);
2909 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2911 AVCodecContext *avctx = st->internal->avctx;
2913 #define FAIL(errmsg) do { \
2915 *errmsg_ptr = errmsg; \
2919 if ( avctx->codec_id == AV_CODEC_ID_NONE
2920 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2921 FAIL("unknown codec");
2922 switch (avctx->codec_type) {
2923 case AVMEDIA_TYPE_AUDIO:
2924 if (!avctx->frame_size && determinable_frame_size(avctx))
2925 FAIL("unspecified frame size");
2926 if (st->info->found_decoder >= 0 &&
2927 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2928 FAIL("unspecified sample format");
2929 if (!avctx->sample_rate)
2930 FAIL("unspecified sample rate");
2931 if (!avctx->channels)
2932 FAIL("unspecified number of channels");
2933 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2934 FAIL("no decodable DTS frames");
2936 case AVMEDIA_TYPE_VIDEO:
2938 FAIL("unspecified size");
2939 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2940 FAIL("unspecified pixel format");
2941 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2942 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2943 FAIL("no frame in rv30/40 and no sar");
2945 case AVMEDIA_TYPE_SUBTITLE:
2946 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2947 FAIL("unspecified size");
2949 case AVMEDIA_TYPE_DATA:
2950 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2956 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2957 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2958 AVDictionary **options)
2960 AVCodecContext *avctx = st->internal->avctx;
2961 const AVCodec *codec;
2962 int got_picture = 1, ret = 0;
2963 AVFrame *frame = av_frame_alloc();
2964 AVSubtitle subtitle;
2965 AVPacket pkt = *avpkt;
2966 int do_skip_frame = 0;
2967 enum AVDiscard skip_frame;
2970 return AVERROR(ENOMEM);
2972 if (!avcodec_is_open(avctx) &&
2973 st->info->found_decoder <= 0 &&
2974 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2975 AVDictionary *thread_opt = NULL;
2977 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2980 st->info->found_decoder = -st->codecpar->codec_id;
2985 /* Force thread count to 1 since the H.264 decoder will not extract
2986 * SPS and PPS to extradata during multi-threaded decoding. */
2987 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2988 if (s->codec_whitelist)
2989 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2990 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2992 av_dict_free(&thread_opt);
2994 st->info->found_decoder = -avctx->codec_id;
2997 st->info->found_decoder = 1;
2998 } else if (!st->info->found_decoder)
2999 st->info->found_decoder = 1;
3001 if (st->info->found_decoder < 0) {
3006 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3008 skip_frame = avctx->skip_frame;
3009 avctx->skip_frame = AVDISCARD_ALL;
3012 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3014 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3015 (!st->codec_info_nb_frames &&
3016 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3018 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3019 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3020 ret = avcodec_send_packet(avctx, &pkt);
3021 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3025 ret = avcodec_receive_frame(avctx, frame);
3028 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3030 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3031 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3032 &got_picture, &pkt);
3038 st->nb_decoded_frames++;
3043 if (!pkt.data && !got_picture)
3047 if (do_skip_frame) {
3048 avctx->skip_frame = skip_frame;
3051 av_frame_free(&frame);
3055 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3057 while (tags->id != AV_CODEC_ID_NONE) {
3065 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3068 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3069 if (tag == tags[i].tag)
3071 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3072 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3074 return AV_CODEC_ID_NONE;
3077 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3079 if (bps <= 0 || bps > 64)
3080 return AV_CODEC_ID_NONE;
3085 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3087 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3089 return AV_CODEC_ID_NONE;
3094 if (sflags & (1 << (bps - 1))) {
3097 return AV_CODEC_ID_PCM_S8;
3099 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3101 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3103 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3105 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3107 return AV_CODEC_ID_NONE;
3112 return AV_CODEC_ID_PCM_U8;
3114 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3116 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3118 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3120 return AV_CODEC_ID_NONE;
3126 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3129 if (!av_codec_get_tag2(tags, id, &tag))
3134 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3138 for (i = 0; tags && tags[i]; i++) {
3139 const AVCodecTag *codec_tags = tags[i];
3140 while (codec_tags->id != AV_CODEC_ID_NONE) {
3141 if (codec_tags->id == id) {
3142 *tag = codec_tags->tag;
3151 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3154 for (i = 0; tags && tags[i]; i++) {
3155 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3156 if (id != AV_CODEC_ID_NONE)
3159 return AV_CODEC_ID_NONE;
3162 static void compute_chapters_end(AVFormatContext *s)
3165 int64_t max_time = 0;
3167 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3168 max_time = s->duration +
3169 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3171 for (i = 0; i < s->nb_chapters; i++)
3172 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3173 AVChapter *ch = s->chapters[i];
3174 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3178 for (j = 0; j < s->nb_chapters; j++) {
3179 AVChapter *ch1 = s->chapters[j];
3180 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3182 if (j != i && next_start > ch->start && next_start < end)
3185 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3189 static int get_std_framerate(int i)
3192 return (i + 1) * 1001;
3196 return (i + 31) * 1001 * 12;
3200 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3204 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3207 /* Is the time base unreliable?
3208 * This is a heuristic to balance between quick acceptance of the values in
3209 * the headers vs. some extra checks.
3210 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3211 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3212 * And there are "variable" fps files this needs to detect as well. */
3213 static int tb_unreliable(AVCodecContext *c)
3215 if (c->time_base.den >= 101LL * c->time_base.num ||
3216 c->time_base.den < 5LL * c->time_base.num ||
3217 // c->codec_tag == AV_RL32("DIVX") ||
3218 // c->codec_tag == AV_RL32("XVID") ||
3219 c->codec_tag == AV_RL32("mp4v") ||
3220 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3221 c->codec_id == AV_CODEC_ID_GIF ||
3222 c->codec_id == AV_CODEC_ID_HEVC ||
3223 c->codec_id == AV_CODEC_ID_H264)
3228 int ff_alloc_extradata(AVCodecParameters *par, int size)
3232 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3233 par->extradata = NULL;
3234 par->extradata_size = 0;
3235 return AVERROR(EINVAL);
3237 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3238 if (par->extradata) {
3239 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3240 par->extradata_size = size;
3243 par->extradata_size = 0;
3244 ret = AVERROR(ENOMEM);
3249 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3251 int ret = ff_alloc_extradata(par, size);
3254 ret = avio_read(pb, par->extradata, size);
3256 av_freep(&par->extradata);
3257 par->extradata_size = 0;
3258 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3259 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3265 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3268 int64_t last = st->info->last_dts;
3270 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3271 && ts - (uint64_t)last < INT64_MAX) {
3272 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3273 int64_t duration = ts - last;
3275 if (!st->info->duration_error)
3276 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3277 if (!st->info->duration_error)
3278 return AVERROR(ENOMEM);
3280 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3281 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3282 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3283 if (st->info->duration_error[0][1][i] < 1e10) {
3284 int framerate = get_std_framerate(i);
3285 double sdts = dts*framerate/(1001*12);
3286 for (j= 0; j<2; j++) {
3287 int64_t ticks = llrint(sdts+j*0.5);
3288 double error= sdts - ticks + j*0.5;
3289 st->info->duration_error[j][0][i] += error;
3290 st->info->duration_error[j][1][i] += error*error;
3294 st->info->duration_count++;
3295 st->info->rfps_duration_sum += duration;
3297 if (st->info->duration_count % 10 == 0) {
3298 int n = st->info->duration_count;
3299 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3300 if (st->info->duration_error[0][1][i] < 1e10) {
3301 double a0 = st->info->duration_error[0][0][i] / n;
3302 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3303 double a1 = st->info->duration_error[1][0][i] / n;
3304 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3305 if (error0 > 0.04 && error1 > 0.04) {
3306 st->info->duration_error[0][1][i] = 2e10;
3307 st->info->duration_error[1][1][i] = 2e10;
3313 // ignore the first 4 values, they might have some random jitter
3314 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3315 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3317 if (ts != AV_NOPTS_VALUE)
3318 st->info->last_dts = ts;
3323 void ff_rfps_calculate(AVFormatContext *ic)
3327 for (i = 0; i < ic->nb_streams; i++) {
3328 AVStream *st = ic->streams[i];
3330 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3332 // the check for tb_unreliable() is not completely correct, since this is not about handling
3333 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3334 // ipmovie.c produces.
3335 if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3336 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3337 if (st->info->duration_count>1 && !st->r_frame_rate.num
3338 && tb_unreliable(st->internal->avctx)) {
3340 double best_error= 0.01;
3341 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3343 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3346 if (st->info->codec_info_duration &&
3347 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3349 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3352 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3355 for (k= 0; k<2; k++) {
3356 int n = st->info->duration_count;
3357 double a= st->info->duration_error[k][0][j] / n;
3358 double error= st->info->duration_error[k][1][j]/n - a*a;
3360 if (error < best_error && best_error> 0.000000001) {
3362 num = get_std_framerate(j);
3365 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3368 // do not increase frame rate by more than 1 % in order to match a standard rate.
3369 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3370 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3372 if ( !st->avg_frame_rate.num
3373 && st->r_frame_rate.num && st->info->rfps_duration_sum
3374 && st->info->codec_info_duration <= 0
3375 && st->info->duration_count > 2
3376 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3378 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3379 st->avg_frame_rate = st->r_frame_rate;
3382 av_freep(&st->info->duration_error);
3383 st->info->last_dts = AV_NOPTS_VALUE;
3384 st->info->duration_count = 0;
3385 st->info->rfps_duration_sum = 0;
3389 static int extract_extradata_check(AVStream *st)
3391 const AVBitStreamFilter *f;
3393 f = av_bsf_get_by_name("extract_extradata");
3398 const enum AVCodecID *ids;
3399 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3400 if (*ids == st->codecpar->codec_id)
3407 static int extract_extradata_init(AVStream *st)
3409 AVStreamInternal *i = st->internal;
3410 const AVBitStreamFilter *f;
3413 f = av_bsf_get_by_name("extract_extradata");
3417 /* check that the codec id is supported */
3418 ret = extract_extradata_check(st);
3422 i->extract_extradata.pkt = av_packet_alloc();
3423 if (!i->extract_extradata.pkt)
3424 return AVERROR(ENOMEM);
3426 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3430 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3435 i->extract_extradata.bsf->time_base_in = st->time_base;
3437 /* if init fails here, we assume extracting extradata is just not
3438 * supported for this codec, so we return success */
3439 ret = av_bsf_init(i->extract_extradata.bsf);
3441 av_bsf_free(&i->extract_extradata.bsf);
3446 i->extract_extradata.inited = 1;
3450 av_bsf_free(&i->extract_extradata.bsf);
3451 av_packet_free(&i->extract_extradata.pkt);
3455 static int extract_extradata(AVStream *st, AVPacket *pkt)
3457 AVStreamInternal *i = st->internal;
3461 if (!i->extract_extradata.inited) {
3462 ret = extract_extradata_init(st);
3467 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3470 pkt_ref = i->extract_extradata.pkt;
3471 ret = av_packet_ref(pkt_ref, pkt);
3475 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3477 av_packet_unref(pkt_ref);
3481 while (ret >= 0 && !i->avctx->extradata) {
3485 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3487 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3492 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3496 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3497 if (!i->avctx->extradata) {
3498 av_packet_unref(pkt_ref);
3499 return AVERROR(ENOMEM);
3501 memcpy(i->avctx->extradata, extradata, extradata_size);
3502 i->avctx->extradata_size = extradata_size;
3504 av_packet_unref(pkt_ref);
3510 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3512 int i, count = 0, ret = 0, j;
3515 AVCodecContext *avctx;
3516 AVPacket pkt1, *pkt;
3517 int64_t old_offset = avio_tell(ic->pb);
3518 // new streams might appear, no options for those
3519 int orig_nb_streams = ic->nb_streams;
3521 int64_t max_analyze_duration = ic->max_analyze_duration;
3522 int64_t max_stream_analyze_duration;
3523 int64_t max_subtitle_analyze_duration;
3524 int64_t probesize = ic->probesize;
3525 int eof_reached = 0;
3526 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3528 flush_codecs = probesize > 0;
3530 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3532 max_stream_analyze_duration = max_analyze_duration;
3533 max_subtitle_analyze_duration = max_analyze_duration;
3534 if (!max_analyze_duration) {
3535 max_stream_analyze_duration =
3536 max_analyze_duration = 5*AV_TIME_BASE;
3537 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3538 if (!strcmp(ic->iformat->name, "flv"))
3539 max_stream_analyze_duration = 90*AV_TIME_BASE;
3540 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3541 max_stream_analyze_duration = 7*AV_TIME_BASE;
3545 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3546 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3548 for (i = 0; i < ic->nb_streams; i++) {
3549 const AVCodec *codec;
3550 AVDictionary *thread_opt = NULL;
3551 st = ic->streams[i];
3552 avctx = st->internal->avctx;
3554 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3555 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3556 /* if (!st->time_base.num)
3558 if (!avctx->time_base.num)
3559 avctx->time_base = st->time_base;
3562 /* check if the caller has overridden the codec id */
3563 #if FF_API_LAVF_AVCTX
3564 FF_DISABLE_DEPRECATION_WARNINGS
3565 if (st->codec->codec_id != st->internal->orig_codec_id) {
3566 st->codecpar->codec_id = st->codec->codec_id;
3567 st->codecpar->codec_type = st->codec->codec_type;
3568 st->internal->orig_codec_id = st->codec->codec_id;
3570 FF_ENABLE_DEPRECATION_WARNINGS
3572 // only for the split stuff
3573 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3574 st->parser = av_parser_init(st->codecpar->codec_id);
3576 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3577 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3578 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3579 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3581 } else if (st->need_parsing) {
3582 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3583 "%s, packets or times may be invalid.\n",
3584 avcodec_get_name(st->codecpar->codec_id));
3588 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3589 st->internal->orig_codec_id = st->codecpar->codec_id;
3591 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3593 goto find_stream_info_err;
3594 if (st->request_probe <= 0)
3595 st->internal->avctx_inited = 1;
3597 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3599 /* Force thread count to 1 since the H.264 decoder will not extract
3600 * SPS and PPS to extradata during multi-threaded decoding. */
3601 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3603 if (ic->codec_whitelist)
3604 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3606 /* Ensure that subtitle_header is properly set. */
3607 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3608 && codec && !avctx->codec) {
3609 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3610 av_log(ic, AV_LOG_WARNING,
3611 "Failed to open codec in %s\n",__FUNCTION__);
3614 // Try to just open decoders, in case this is enough to get parameters.
3615 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3616 if (codec && !avctx->codec)
3617 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3618 av_log(ic, AV_LOG_WARNING,
3619 "Failed to open codec in %s\n",__FUNCTION__);
3622 av_dict_free(&thread_opt);
3625 for (i = 0; i < ic->nb_streams; i++) {
3626 #if FF_API_R_FRAME_RATE
3627 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3629 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3630 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3635 int analyzed_all_streams;
3636 if (ff_check_interrupt(&ic->interrupt_callback)) {
3638 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3642 /* check if one codec still needs to be handled */
3643 for (i = 0; i < ic->nb_streams; i++) {
3644 int fps_analyze_framecount = 20;
3647 st = ic->streams[i];
3648 if (!has_codec_parameters(st, NULL))
3650 /* If the timebase is coarse (like the usual millisecond precision
3651 * of mkv), we need to analyze more frames to reliably arrive at
3652 * the correct fps. */
3653 if (av_q2d(st->time_base) > 0.0005)
3654 fps_analyze_framecount *= 2;
3655 if (!tb_unreliable(st->internal->avctx))
3656 fps_analyze_framecount = 0;
3657 if (ic->fps_probe_size >= 0)
3658 fps_analyze_framecount = ic->fps_probe_size;
3659 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3660 fps_analyze_framecount = 0;
3661 /* variable fps and no guess at the real fps */
3662 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3663 st->info->codec_info_duration_fields/2 :
3664 st->info->duration_count;
3665 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3666 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3667 if (count < fps_analyze_framecount)
3670 // Look at the first 3 frames if there is evidence of frame delay
3671 // but the decoder delay is not set.
3672 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3674 if (!st->internal->avctx->extradata &&
3675 (!st->internal->extract_extradata.inited ||
3676 st->internal->extract_extradata.bsf) &&
3677 extract_extradata_check(st))
3679 if (st->first_dts == AV_NOPTS_VALUE &&
3680 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3681 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3682 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3683 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3686 analyzed_all_streams = 0;
3687 if (!missing_streams || !*missing_streams)
3688 if (i == ic->nb_streams) {
3689 analyzed_all_streams = 1;
3690 /* NOTE: If the format has no header, then we need to read some
3691 * packets to get most of the streams, so we cannot stop here. */
3692 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3693 /* If we found the info for all the codecs, we can stop. */
3695 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3700 /* We did not get all the codec info, but we read too much data. */
3701 if (read_size >= probesize) {
3703 av_log(ic, AV_LOG_DEBUG,
3704 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3705 for (i = 0; i < ic->nb_streams; i++)
3706 if (!ic->streams[i]->r_frame_rate.num &&
3707 ic->streams[i]->info->duration_count <= 1 &&
3708 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3709 strcmp(ic->iformat->name, "image2"))
3710 av_log(ic, AV_LOG_WARNING,
3711 "Stream #%d: not enough frames to estimate rate; "
3712 "consider increasing probesize\n", i);
3716 /* NOTE: A new stream can be added there if no header in file
3717 * (AVFMTCTX_NOHEADER). */
3718 ret = read_frame_internal(ic, &pkt1);
3719 if (ret == AVERROR(EAGAIN))
3730 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3731 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3732 &ic->internal->packet_buffer_end, 0);
3734 goto find_stream_info_err;
3737 st = ic->streams[pkt->stream_index];
3738 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3739 read_size += pkt->size;
3741 avctx = st->internal->avctx;
3742 if (!st->internal->avctx_inited) {
3743 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3745 goto find_stream_info_err;
3746 st->internal->avctx_inited = 1;
3749 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3750 /* check for non-increasing dts */
3751 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3752 st->info->fps_last_dts >= pkt->dts) {
3753 av_log(ic, AV_LOG_DEBUG,
3754 "Non-increasing DTS in stream %d: packet %d with DTS "
3755 "%"PRId64", packet %d with DTS %"PRId64"\n",
3756 st->index, st->info->fps_last_dts_idx,
3757 st->info->fps_last_dts, st->codec_info_nb_frames,
3759 st->info->fps_first_dts =
3760 st->info->fps_last_dts = AV_NOPTS_VALUE;
3762 /* Check for a discontinuity in dts. If the difference in dts
3763 * is more than 1000 times the average packet duration in the
3764 * sequence, we treat it as a discontinuity. */
3765 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3766 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3767 (pkt->dts - st->info->fps_last_dts) / 1000 >
3768 (st->info->fps_last_dts - st->info->fps_first_dts) /
3769 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3770 av_log(ic, AV_LOG_WARNING,
3771 "DTS discontinuity in stream %d: packet %d with DTS "
3772 "%"PRId64", packet %d with DTS %"PRId64"\n",
3773 st->index, st->info->fps_last_dts_idx,
3774 st->info->fps_last_dts, st->codec_info_nb_frames,
3776 st->info->fps_first_dts =
3777 st->info->fps_last_dts = AV_NOPTS_VALUE;
3780 /* update stored dts values */
3781 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3782 st->info->fps_first_dts = pkt->dts;
3783 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3785 st->info->fps_last_dts = pkt->dts;
3786 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3788 if (st->codec_info_nb_frames>1) {
3792 if (st->time_base.den > 0)
3793 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3794 if (st->avg_frame_rate.num > 0)
3795 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3798 && st->codec_info_nb_frames>30
3799 && st->info->fps_first_dts != AV_NOPTS_VALUE
3800 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3801 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3803 if (analyzed_all_streams) limit = max_analyze_duration;
3804 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3805 else limit = max_stream_analyze_duration;
3808 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3810 t, pkt->stream_index);
3811 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3812 av_packet_unref(pkt);
3815 if (pkt->duration) {
3816 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3817 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3819 st->info->codec_info_duration += pkt->duration;
3820 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3823 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3824 #if FF_API_R_FRAME_RATE
3825 ff_rfps_add_frame(ic, st, pkt->dts);
3827 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3828 st->info->frame_delay_evidence = 1;
3830 if (!st->internal->avctx->extradata) {
3831 ret = extract_extradata(st, pkt);
3833 goto find_stream_info_err;
3836 /* If still no information, we try to open the codec and to
3837 * decompress the frame. We try to avoid that in most cases as
3838 * it takes longer and uses more memory. For MPEG-4, we need to
3839 * decompress for QuickTime.
3841 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3842 * least one frame of codec data, this makes sure the codec initializes
3843 * the channel configuration and does not only trust the values from
3845 try_decode_frame(ic, st, pkt,
3846 (options && i < orig_nb_streams) ? &options[i] : NULL);
3848 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3849 av_packet_unref(pkt);
3851 st->codec_info_nb_frames++;
3857 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3858 st = ic->streams[stream_index];
3859 avctx = st->internal->avctx;
3860 if (!has_codec_parameters(st, NULL)) {
3861 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3862 if (codec && !avctx->codec) {
3863 AVDictionary *opts = NULL;
3864 if (ic->codec_whitelist)
3865 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3866 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3867 av_log(ic, AV_LOG_WARNING,
3868 "Failed to open codec in %s\n",__FUNCTION__);
3869 av_dict_free(&opts);
3873 // EOF already reached while reading the stream above.
3874 // So continue with reoordering DTS with whatever delay we have.
3875 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3876 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3882 AVPacket empty_pkt = { 0 };
3884 av_init_packet(&empty_pkt);
3886 for (i = 0; i < ic->nb_streams; i++) {
3888 st = ic->streams[i];
3890 /* flush the decoders */
3891 if (st->info->found_decoder == 1) {
3893 err = try_decode_frame(ic, st, &empty_pkt,
3894 (options && i < orig_nb_streams)
3895 ? &options[i] : NULL);
3896 } while (err > 0 && !has_codec_parameters(st, NULL));
3899 av_log(ic, AV_LOG_INFO,
3900 "decoding for stream %d failed\n", st->index);
3906 ff_rfps_calculate(ic);
3908 for (i = 0; i < ic->nb_streams; i++) {
3909 st = ic->streams[i];
3910 avctx = st->internal->avctx;
3911 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3912 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3913 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3914 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3915 avctx->codec_tag= tag;
3918 /* estimate average framerate if not set by demuxer */
3919 if (st->info->codec_info_duration_fields &&
3920 !st->avg_frame_rate.num &&
3921 st->info->codec_info_duration) {
3923 double best_error = 0.01;
3924 AVRational codec_frame_rate = avctx->framerate;
3926 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3927 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3928 st->info->codec_info_duration < 0)
3930 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3931 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3932 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3934 /* Round guessed framerate to a "standard" framerate if it's
3935 * within 1% of the original estimate. */
3936 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3937 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3938 double error = fabs(av_q2d(st->avg_frame_rate) /
3939 av_q2d(std_fps) - 1);
3941 if (error < best_error) {
3943 best_fps = std_fps.num;
3946 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3947 error = fabs(av_q2d(codec_frame_rate) /
3948 av_q2d(std_fps) - 1);
3949 if (error < best_error) {
3951 best_fps = std_fps.num;
3956 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3957 best_fps, 12 * 1001, INT_MAX);
3960 if (!st->r_frame_rate.num) {
3961 if ( avctx->time_base.den * (int64_t) st->time_base.num
3962 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3963 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3964 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3966 st->r_frame_rate.num = st->time_base.den;
3967 st->r_frame_rate.den = st->time_base.num;
3970 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3971 AVRational hw_ratio = { avctx->height, avctx->width };
3972 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3975 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3976 if (!avctx->bits_per_coded_sample)
3977 avctx->bits_per_coded_sample =
3978 av_get_bits_per_sample(avctx->codec_id);
3979 // set stream disposition based on audio service type
3980 switch (avctx->audio_service_type) {
3981 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3982 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3984 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3985 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3987 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3988 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3990 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3991 st->disposition = AV_DISPOSITION_COMMENT;
3993 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3994 st->disposition = AV_DISPOSITION_KARAOKE;
4001 estimate_timings(ic, old_offset);
4003 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4005 if (ret >= 0 && ic->nb_streams)
4006 /* We could not have all the codec parameters before EOF. */
4008 for (i = 0; i < ic->nb_streams; i++) {
4010 st = ic->streams[i];
4012 /* if no packet was ever seen, update context now for has_codec_parameters */
4013 if (!st->internal->avctx_inited) {
4014 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4015 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4016 st->codecpar->format = st->internal->avctx->sample_fmt;
4017 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4019 goto find_stream_info_err;
4021 if (!has_codec_parameters(st, &errmsg)) {
4023 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4024 av_log(ic, AV_LOG_WARNING,
4025 "Could not find codec parameters for stream %d (%s): %s\n"
4026 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4033 compute_chapters_end(ic);
4035 /* update the stream parameters from the internal codec contexts */
4036 for (i = 0; i < ic->nb_streams; i++) {
4037 st = ic->streams[i];
4039 if (st->internal->avctx_inited) {
4040 int orig_w = st->codecpar->width;
4041 int orig_h = st->codecpar->height;
4042 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4044 goto find_stream_info_err;
4046 // The decoder might reduce the video size by the lowres factor.
4047 if (st->internal->avctx->lowres && orig_w) {
4048 st->codecpar->width = orig_w;
4049 st->codecpar->height = orig_h;
4054 #if FF_API_LAVF_AVCTX
4055 FF_DISABLE_DEPRECATION_WARNINGS
4056 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4058 goto find_stream_info_err;
4061 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4062 // by the lowres factor.
4063 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4064 st->codec->lowres = st->internal->avctx->lowres;
4065 st->codec->width = st->internal->avctx->width;
4066 st->codec->height = st->internal->avctx->height;
4070 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4071 st->codec->time_base = st->internal->avctx->time_base;
4072 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4074 st->codec->framerate = st->avg_frame_rate;
4076 if (st->internal->avctx->subtitle_header) {
4077 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4078 if (!st->codec->subtitle_header)
4079 goto find_stream_info_err;
4080 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4081 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4082 st->codec->subtitle_header_size);
4085 // Fields unavailable in AVCodecParameters
4086 st->codec->coded_width = st->internal->avctx->coded_width;
4087 st->codec->coded_height = st->internal->avctx->coded_height;
4088 st->codec->properties = st->internal->avctx->properties;
4089 FF_ENABLE_DEPRECATION_WARNINGS
4092 st->internal->avctx_inited = 0;
4095 find_stream_info_err:
4096 for (i = 0; i < ic->nb_streams; i++) {
4097 st = ic->streams[i];
4099 av_freep(&st->info->duration_error);
4100 avcodec_close(ic->streams[i]->internal->avctx);
4101 av_freep(&ic->streams[i]->info);
4102 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4103 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4106 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4107 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4111 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4115 for (i = 0; i < ic->nb_programs; i++) {
4116 if (ic->programs[i] == last) {
4120 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4121 if (ic->programs[i]->stream_index[j] == s)
4122 return ic->programs[i];
4128 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4129 int wanted_stream_nb, int related_stream,
4130 AVCodec **decoder_ret, int flags)
4132 int i, nb_streams = ic->nb_streams;
4133 int ret = AVERROR_STREAM_NOT_FOUND;
4134 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4135 int count, multiframe, disposition;
4136 int64_t best_bitrate = -1;
4138 unsigned *program = NULL;
4139 const AVCodec *decoder = NULL, *best_decoder = NULL;
4141 if (related_stream >= 0 && wanted_stream_nb < 0) {
4142 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4144 program = p->stream_index;
4145 nb_streams = p->nb_stream_indexes;
4148 for (i = 0; i < nb_streams; i++) {
4149 int real_stream_index = program ? program[i] : i;
4150 AVStream *st = ic->streams[real_stream_index];
4151 AVCodecParameters *par = st->codecpar;
4152 if (par->codec_type != type)
4154 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4156 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4159 decoder = find_decoder(ic, st, par->codec_id);
4162 ret = AVERROR_DECODER_NOT_FOUND;
4166 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4167 count = st->codec_info_nb_frames;
4168 bitrate = par->bit_rate;
4169 multiframe = FFMIN(5, count);
4170 if ((best_disposition > disposition) ||
4171 (best_disposition == disposition && best_multiframe > multiframe) ||
4172 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4173 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4175 best_disposition = disposition;
4177 best_bitrate = bitrate;
4178 best_multiframe = multiframe;
4179 ret = real_stream_index;
4180 best_decoder = decoder;
4181 if (program && i == nb_streams - 1 && ret < 0) {
4183 nb_streams = ic->nb_streams;
4184 /* no related stream found, try again with everything */
4189 *decoder_ret = (AVCodec*)best_decoder;
4193 /*******************************************************/
4195 int av_read_play(AVFormatContext *s)
4197 if (s->iformat->read_play)
4198 return s->iformat->read_play(s);
4200 return avio_pause(s->pb, 0);
4201 return AVERROR(ENOSYS);
4204 int av_read_pause(AVFormatContext *s)
4206 if (s->iformat->read_pause)
4207 return s->iformat->read_pause(s);
4209 return avio_pause(s->pb, 1);
4210 return AVERROR(ENOSYS);
4213 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4218 dst->time_base = src->time_base;
4219 dst->nb_frames = src->nb_frames;
4220 dst->disposition = src->disposition;
4221 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4222 dst->avg_frame_rate = src->avg_frame_rate;
4223 dst->r_frame_rate = src->r_frame_rate;
4225 av_dict_free(&dst->metadata);
4226 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4230 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4234 /* Free existing side data*/
4235 for (i = 0; i < dst->nb_side_data; i++)
4236 av_free(dst->side_data[i].data);
4237 av_freep(&dst->side_data);
4238 dst->nb_side_data = 0;
4240 /* Copy side data if present */
4241 if (src->nb_side_data) {
4242 dst->side_data = av_mallocz_array(src->nb_side_data,
4243 sizeof(AVPacketSideData));
4244 if (!dst->side_data)
4245 return AVERROR(ENOMEM);
4246 dst->nb_side_data = src->nb_side_data;
4248 for (i = 0; i < src->nb_side_data; i++) {
4249 uint8_t *data = av_memdup(src->side_data[i].data,
4250 src->side_data[i].size);
4252 return AVERROR(ENOMEM);
4253 dst->side_data[i].type = src->side_data[i].type;
4254 dst->side_data[i].size = src->side_data[i].size;
4255 dst->side_data[i].data = data;
4259 av_freep(&dst->recommended_encoder_configuration);
4260 if (src->recommended_encoder_configuration) {
4261 const char *conf_str = src->recommended_encoder_configuration;
4262 dst->recommended_encoder_configuration = av_strdup(conf_str);
4263 if (!dst->recommended_encoder_configuration)
4264 return AVERROR(ENOMEM);
4270 static void free_stream(AVStream **pst)
4272 AVStream *st = *pst;
4278 for (i = 0; i < st->nb_side_data; i++)
4279 av_freep(&st->side_data[i].data);
4280 av_freep(&st->side_data);
4283 av_parser_close(st->parser);
4285 if (st->attached_pic.data)
4286 av_packet_unref(&st->attached_pic);
4289 avcodec_free_context(&st->internal->avctx);
4290 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4291 av_bsf_free(&st->internal->bsfcs[i]);
4292 av_freep(&st->internal->bsfcs);
4294 av_freep(&st->internal->priv_pts);
4295 av_bsf_free(&st->internal->extract_extradata.bsf);
4296 av_packet_free(&st->internal->extract_extradata.pkt);
4298 av_freep(&st->internal);
4300 av_dict_free(&st->metadata);
4301 avcodec_parameters_free(&st->codecpar);
4302 av_freep(&st->probe_data.buf);
4303 av_freep(&st->index_entries);
4304 #if FF_API_LAVF_AVCTX
4305 FF_DISABLE_DEPRECATION_WARNINGS
4306 avcodec_free_context(&st->codec);
4307 FF_ENABLE_DEPRECATION_WARNINGS
4309 av_freep(&st->priv_data);
4311 av_freep(&st->info->duration_error);
4312 av_freep(&st->info);
4313 av_freep(&st->recommended_encoder_configuration);
4318 void ff_free_stream(AVFormatContext *s, AVStream *st)
4320 av_assert0(s->nb_streams>0);
4321 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4323 free_stream(&s->streams[ --s->nb_streams ]);
4326 void avformat_free_context(AVFormatContext *s)
4334 if (s->iformat && s->iformat->priv_class && s->priv_data)
4335 av_opt_free(s->priv_data);
4336 if (s->oformat && s->oformat->priv_class && s->priv_data)
4337 av_opt_free(s->priv_data);
4339 for (i = s->nb_streams - 1; i >= 0; i--)
4340 ff_free_stream(s, s->streams[i]);
4343 for (i = s->nb_programs - 1; i >= 0; i--) {
4344 av_dict_free(&s->programs[i]->metadata);
4345 av_freep(&s->programs[i]->stream_index);
4346 av_freep(&s->programs[i]);
4348 av_freep(&s->programs);
4349 av_freep(&s->priv_data);
4350 while (s->nb_chapters--) {
4351 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4352 av_freep(&s->chapters[s->nb_chapters]);
4354 av_freep(&s->chapters);
4355 av_dict_free(&s->metadata);
4356 av_dict_free(&s->internal->id3v2_meta);
4357 av_freep(&s->streams);
4358 flush_packet_queue(s);
4359 av_freep(&s->internal);
4363 void avformat_close_input(AVFormatContext **ps)
4374 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4375 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4378 flush_packet_queue(s);
4381 if (s->iformat->read_close)
4382 s->iformat->read_close(s);
4384 avformat_free_context(s);
4391 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4397 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4398 if (s->max_streams < INT_MAX/sizeof(*streams))
4399 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);
4402 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4405 s->streams = streams;
4407 st = av_mallocz(sizeof(AVStream));
4410 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4414 st->info->last_dts = AV_NOPTS_VALUE;
4416 #if FF_API_LAVF_AVCTX
4417 FF_DISABLE_DEPRECATION_WARNINGS
4418 st->codec = avcodec_alloc_context3(c);
4424 FF_ENABLE_DEPRECATION_WARNINGS
4427 st->internal = av_mallocz(sizeof(*st->internal));
4431 st->codecpar = avcodec_parameters_alloc();
4435 st->internal->avctx = avcodec_alloc_context3(NULL);
4436 if (!st->internal->avctx)
4440 #if FF_API_LAVF_AVCTX
4441 FF_DISABLE_DEPRECATION_WARNINGS
4442 /* no default bitrate if decoding */
4443 st->codec->bit_rate = 0;
4444 FF_ENABLE_DEPRECATION_WARNINGS
4447 /* default pts setting is MPEG-like */
4448 avpriv_set_pts_info(st, 33, 1, 90000);
4449 /* we set the current DTS to 0 so that formats without any timestamps
4450 * but durations get some timestamps, formats with some unknown
4451 * timestamps have their first few packets buffered and the
4452 * timestamps corrected before they are returned to the user */
4453 st->cur_dts = RELATIVE_TS_BASE;
4455 st->cur_dts = AV_NOPTS_VALUE;
4458 st->index = s->nb_streams;
4459 st->start_time = AV_NOPTS_VALUE;
4460 st->duration = AV_NOPTS_VALUE;
4461 st->first_dts = AV_NOPTS_VALUE;
4462 st->probe_packets = MAX_PROBE_PACKETS;
4463 st->pts_wrap_reference = AV_NOPTS_VALUE;
4464 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4466 st->last_IP_pts = AV_NOPTS_VALUE;
4467 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4468 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4469 st->pts_buffer[i] = AV_NOPTS_VALUE;
4471 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4473 #if FF_API_R_FRAME_RATE
4474 st->info->last_dts = AV_NOPTS_VALUE;
4476 st->info->fps_first_dts = AV_NOPTS_VALUE;
4477 st->info->fps_last_dts = AV_NOPTS_VALUE;
4479 st->inject_global_side_data = s->internal->inject_global_side_data;
4481 st->internal->need_context_update = 1;
4483 s->streams[s->nb_streams++] = st;
4490 AVProgram *av_new_program(AVFormatContext *ac, int id)
4492 AVProgram *program = NULL;
4495 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4497 for (i = 0; i < ac->nb_programs; i++)
4498 if (ac->programs[i]->id == id)
4499 program = ac->programs[i];
4502 program = av_mallocz(sizeof(AVProgram));
4505 dynarray_add(&ac->programs, &ac->nb_programs, program);
4506 program->discard = AVDISCARD_NONE;
4509 program->pts_wrap_reference = AV_NOPTS_VALUE;
4510 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4512 program->start_time =
4513 program->end_time = AV_NOPTS_VALUE;
4518 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4519 int64_t start, int64_t end, const char *title)
4521 AVChapter *chapter = NULL;
4524 if (end != AV_NOPTS_VALUE && start > end) {
4525 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4529 for (i = 0; i < s->nb_chapters; i++)
4530 if (s->chapters[i]->id == id)
4531 chapter = s->chapters[i];
4534 chapter = av_mallocz(sizeof(AVChapter));
4537 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4539 av_dict_set(&chapter->metadata, "title", title, 0);
4541 chapter->time_base = time_base;
4542 chapter->start = start;
4548 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4551 AVProgram *program = NULL;
4554 if (idx >= ac->nb_streams) {
4555 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4559 for (i = 0; i < ac->nb_programs; i++) {
4560 if (ac->programs[i]->id != progid)
4562 program = ac->programs[i];
4563 for (j = 0; j < program->nb_stream_indexes; j++)
4564 if (program->stream_index[j] == idx)
4567 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4570 program->stream_index = tmp;
4571 program->stream_index[program->nb_stream_indexes++] = idx;
4576 uint64_t ff_ntp_time(void)
4578 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4581 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4584 char *q, buf1[20], c;
4585 int nd, len, percentd_found;
4597 while (av_isdigit(*p))
4598 nd = nd * 10 + *p++ - '0';
4600 } while (av_isdigit(c));
4606 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4611 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4613 if ((q - buf + len) > buf_size - 1)
4615 memcpy(q, buf1, len);
4623 if ((q - buf) < buf_size - 1)
4627 if (!percentd_found)
4636 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4638 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4641 void av_url_split(char *proto, int proto_size,
4642 char *authorization, int authorization_size,
4643 char *hostname, int hostname_size,
4644 int *port_ptr, char *path, int path_size, const char *url)
4646 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4652 if (authorization_size > 0)
4653 authorization[0] = 0;
4654 if (hostname_size > 0)
4659 /* parse protocol */
4660 if ((p = strchr(url, ':'))) {
4661 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4668 /* no protocol means plain filename */
4669 av_strlcpy(path, url, path_size);
4673 /* separate path from hostname */
4674 ls = strchr(p, '/');
4675 ls2 = strchr(p, '?');
4679 ls = FFMIN(ls, ls2);
4681 av_strlcpy(path, ls, path_size);
4683 ls = &p[strlen(p)]; // XXX
4685 /* the rest is hostname, use that to parse auth/port */
4687 /* authorization (user[:pass]@hostname) */
4689 while ((at = strchr(p, '@')) && at < ls) {
4690 av_strlcpy(authorization, at2,
4691 FFMIN(authorization_size, at + 1 - at2));
4692 p = at + 1; /* skip '@' */
4695 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4697 av_strlcpy(hostname, p + 1,
4698 FFMIN(hostname_size, brk - p));
4699 if (brk[1] == ':' && port_ptr)
4700 *port_ptr = atoi(brk + 2);
4701 } else if ((col = strchr(p, ':')) && col < ls) {
4702 av_strlcpy(hostname, p,
4703 FFMIN(col + 1 - p, hostname_size));
4705 *port_ptr = atoi(col + 1);
4707 av_strlcpy(hostname, p,
4708 FFMIN(ls + 1 - p, hostname_size));
4712 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4715 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4718 'C', 'D', 'E', 'F' };
4719 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4722 'c', 'd', 'e', 'f' };
4723 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4725 for (i = 0; i < s; i++) {
4726 buff[i * 2] = hex_table[src[i] >> 4];
4727 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4733 int ff_hex_to_data(uint8_t *data, const char *p)
4740 p += strspn(p, SPACE_CHARS);
4743 c = av_toupper((unsigned char) *p++);
4744 if (c >= '0' && c <= '9')
4746 else if (c >= 'A' && c <= 'F')
4761 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4762 unsigned int pts_num, unsigned int pts_den)
4765 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4766 if (new_tb.num != pts_num)
4767 av_log(NULL, AV_LOG_DEBUG,
4768 "st:%d removing common factor %d from timebase\n",
4769 s->index, pts_num / new_tb.num);
4771 av_log(NULL, AV_LOG_WARNING,
4772 "st:%d has too large timebase, reducing\n", s->index);
4774 if (new_tb.num <= 0 || new_tb.den <= 0) {
4775 av_log(NULL, AV_LOG_ERROR,
4776 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4777 new_tb.num, new_tb.den,
4781 s->time_base = new_tb;
4782 #if FF_API_LAVF_AVCTX
4783 FF_DISABLE_DEPRECATION_WARNINGS
4784 s->codec->pkt_timebase = new_tb;
4785 FF_ENABLE_DEPRECATION_WARNINGS
4787 s->internal->avctx->pkt_timebase = new_tb;
4788 s->pts_wrap_bits = pts_wrap_bits;
4791 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4794 const char *ptr = str;
4796 /* Parse key=value pairs. */
4799 char *dest = NULL, *dest_end;
4800 int key_len, dest_len = 0;
4802 /* Skip whitespace and potential commas. */
4803 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4810 if (!(ptr = strchr(key, '=')))
4813 key_len = ptr - key;
4815 callback_get_buf(context, key, key_len, &dest, &dest_len);
4816 dest_end = dest + dest_len - 1;
4820 while (*ptr && *ptr != '\"') {
4824 if (dest && dest < dest_end)
4828 if (dest && dest < dest_end)
4836 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4837 if (dest && dest < dest_end)
4845 int ff_find_stream_index(AVFormatContext *s, int id)
4848 for (i = 0; i < s->nb_streams; i++)
4849 if (s->streams[i]->id == id)
4854 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4858 unsigned int codec_tag;
4859 if (ofmt->query_codec)
4860 return ofmt->query_codec(codec_id, std_compliance);
4861 else if (ofmt->codec_tag)
4862 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4863 else if (codec_id == ofmt->video_codec ||
4864 codec_id == ofmt->audio_codec ||
4865 codec_id == ofmt->subtitle_codec ||
4866 codec_id == ofmt->data_codec)
4869 return AVERROR_PATCHWELCOME;
4872 int avformat_network_init(void)
4876 ff_network_inited_globally = 1;
4877 if ((ret = ff_network_init()) < 0)
4879 if ((ret = ff_tls_init()) < 0)
4885 int avformat_network_deinit(void)
4890 ff_network_inited_globally = 0;
4895 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4896 uint64_t channel_layout, int32_t sample_rate,
4897 int32_t width, int32_t height)
4903 return AVERROR(EINVAL);
4906 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4908 if (channel_layout) {
4910 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4914 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4916 if (width || height) {
4918 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4920 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4922 return AVERROR(ENOMEM);
4923 bytestream_put_le32(&data, flags);
4925 bytestream_put_le32(&data, channels);
4927 bytestream_put_le64(&data, channel_layout);
4929 bytestream_put_le32(&data, sample_rate);
4930 if (width || height) {
4931 bytestream_put_le32(&data, width);
4932 bytestream_put_le32(&data, height);
4937 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4939 AVRational undef = {0, 1};
4940 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4941 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4942 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4944 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4945 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4946 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4947 stream_sample_aspect_ratio = undef;
4949 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4950 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4951 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4952 frame_sample_aspect_ratio = undef;
4954 if (stream_sample_aspect_ratio.num)
4955 return stream_sample_aspect_ratio;
4957 return frame_sample_aspect_ratio;
4960 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4962 AVRational fr = st->r_frame_rate;
4963 AVRational codec_fr = st->internal->avctx->framerate;
4964 AVRational avg_fr = st->avg_frame_rate;
4966 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4967 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4972 if (st->internal->avctx->ticks_per_frame > 1) {
4973 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4974 (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))
4981 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4984 if (*spec <= '9' && *spec >= '0') /* opt:index */
4985 return strtol(spec, NULL, 0) == st->index;
4986 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4987 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4988 enum AVMediaType type;
4992 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4993 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4994 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4995 case 'd': type = AVMEDIA_TYPE_DATA; break;
4996 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4997 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4998 default: av_assert0(0);
5000 #if FF_API_LAVF_AVCTX
5001 FF_DISABLE_DEPRECATION_WARNINGS
5002 if (type != st->codecpar->codec_type
5003 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5005 FF_ENABLE_DEPRECATION_WARNINGS
5007 if (type != st->codecpar->codec_type)
5010 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5012 if (*spec++ == ':') { /* possibly followed by :index */
5013 int i, index = strtol(spec, NULL, 0);
5014 for (i = 0; i < s->nb_streams; i++) {
5015 #if FF_API_LAVF_AVCTX
5016 FF_DISABLE_DEPRECATION_WARNINGS
5017 if ((s->streams[i]->codecpar->codec_type == type
5018 || s->streams[i]->codec->codec_type == type
5020 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5022 return i == st->index;
5023 FF_ENABLE_DEPRECATION_WARNINGS
5025 if ((s->streams[i]->codecpar->codec_type == type) &&
5026 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5028 return i == st->index;
5034 } else if (*spec == 'p' && *(spec + 1) == ':') {
5038 prog_id = strtol(spec, &endptr, 0);
5039 for (i = 0; i < s->nb_programs; i++) {
5040 if (s->programs[i]->id != prog_id)
5043 if (*endptr++ == ':') {
5044 int stream_idx = strtol(endptr, NULL, 0);
5045 return stream_idx >= 0 &&
5046 stream_idx < s->programs[i]->nb_stream_indexes &&
5047 st->index == s->programs[i]->stream_index[stream_idx];
5050 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5051 if (st->index == s->programs[i]->stream_index[j])
5055 } else if (*spec == '#' ||
5056 (*spec == 'i' && *(spec + 1) == ':')) {
5059 spec += 1 + (*spec == 'i');
5060 stream_id = strtol(spec, &endptr, 0);
5062 return stream_id == st->id;
5063 } else if (*spec == 'm' && *(spec + 1) == ':') {
5064 AVDictionaryEntry *tag;
5069 val = strchr(spec, ':');
5071 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5073 return AVERROR(ENOMEM);
5075 tag = av_dict_get(st->metadata, key, NULL, 0);
5077 if (!val || !strcmp(tag->value, val + 1))
5086 } else if (*spec == 'u') {
5087 AVCodecParameters *par = st->codecpar;
5088 #if FF_API_LAVF_AVCTX
5089 FF_DISABLE_DEPRECATION_WARNINGS
5090 AVCodecContext *codec = st->codec;
5091 FF_ENABLE_DEPRECATION_WARNINGS
5094 switch (par->codec_type) {
5095 case AVMEDIA_TYPE_AUDIO:
5096 val = par->sample_rate && par->channels;
5097 #if FF_API_LAVF_AVCTX
5098 val = val || (codec->sample_rate && codec->channels);
5100 if (par->format == AV_SAMPLE_FMT_NONE
5101 #if FF_API_LAVF_AVCTX
5102 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5107 case AVMEDIA_TYPE_VIDEO:
5108 val = par->width && par->height;
5109 #if FF_API_LAVF_AVCTX
5110 val = val || (codec->width && codec->height);
5112 if (par->format == AV_PIX_FMT_NONE
5113 #if FF_API_LAVF_AVCTX
5114 && codec->pix_fmt == AV_PIX_FMT_NONE
5119 case AVMEDIA_TYPE_UNKNOWN:
5126 #if FF_API_LAVF_AVCTX
5127 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5129 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5131 } else if (!*spec) /* empty specifier, matches everything */
5134 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5135 return AVERROR(EINVAL);
5138 int ff_generate_avci_extradata(AVStream *st)
5140 static const uint8_t avci100_1080p_extradata[] = {
5142 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5143 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5144 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5145 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5146 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5147 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5148 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5149 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5150 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5152 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5155 static const uint8_t avci100_1080i_extradata[] = {
5157 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5158 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5159 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5160 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5161 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5162 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5163 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5164 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5165 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5166 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5167 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5169 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5172 static const uint8_t avci50_1080p_extradata[] = {
5174 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5175 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5176 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5177 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5178 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5179 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5180 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5181 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5182 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5184 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5187 static const uint8_t avci50_1080i_extradata[] = {
5189 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5190 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5191 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5192 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5193 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5194 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5195 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5196 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5197 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5198 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5199 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5201 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5204 static const uint8_t avci100_720p_extradata[] = {
5206 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5207 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5208 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5209 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5210 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5211 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5212 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5213 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5214 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5215 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5217 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5220 static const uint8_t avci50_720p_extradata[] = {
5222 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5223 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5224 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5225 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5226 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5227 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5228 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5229 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5230 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5232 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5236 const uint8_t *data = NULL;
5239 if (st->codecpar->width == 1920) {
5240 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5241 data = avci100_1080p_extradata;
5242 size = sizeof(avci100_1080p_extradata);
5244 data = avci100_1080i_extradata;
5245 size = sizeof(avci100_1080i_extradata);
5247 } else if (st->codecpar->width == 1440) {
5248 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5249 data = avci50_1080p_extradata;
5250 size = sizeof(avci50_1080p_extradata);
5252 data = avci50_1080i_extradata;
5253 size = sizeof(avci50_1080i_extradata);
5255 } else if (st->codecpar->width == 1280) {
5256 data = avci100_720p_extradata;
5257 size = sizeof(avci100_720p_extradata);
5258 } else if (st->codecpar->width == 960) {
5259 data = avci50_720p_extradata;
5260 size = sizeof(avci50_720p_extradata);
5266 av_freep(&st->codecpar->extradata);
5267 if (ff_alloc_extradata(st->codecpar, size))
5268 return AVERROR(ENOMEM);
5269 memcpy(st->codecpar->extradata, data, size);
5274 uint8_t *av_stream_get_side_data(const AVStream *st,
5275 enum AVPacketSideDataType type, int *size)
5279 for (i = 0; i < st->nb_side_data; i++) {
5280 if (st->side_data[i].type == type) {
5282 *size = st->side_data[i].size;
5283 return st->side_data[i].data;
5289 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5290 uint8_t *data, size_t size)
5292 AVPacketSideData *sd, *tmp;
5295 for (i = 0; i < st->nb_side_data; i++) {
5296 sd = &st->side_data[i];
5298 if (sd->type == type) {
5299 av_freep(&sd->data);
5306 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5307 return AVERROR(ERANGE);
5309 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5311 return AVERROR(ENOMEM);
5314 st->side_data = tmp;
5317 sd = &st->side_data[st->nb_side_data - 1];
5325 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5329 uint8_t *data = av_malloc(size);
5334 ret = av_stream_add_side_data(st, type, data, size);
5343 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5346 const AVBitStreamFilter *bsf;
5348 AVCodecParameters *in_par;
5350 if (!(bsf = av_bsf_get_by_name(name))) {
5351 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5352 return AVERROR_BSF_NOT_FOUND;
5355 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5358 if (st->internal->nb_bsfcs) {
5359 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5360 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5362 in_par = st->codecpar;
5363 bsfc->time_base_in = st->time_base;
5366 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5371 if (args && bsfc->filter->priv_class) {
5372 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5373 const char * shorthand[2] = {NULL};
5376 shorthand[0] = opt->name;
5378 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5384 if ((ret = av_bsf_init(bsfc)) < 0) {
5389 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5394 av_log(NULL, AV_LOG_VERBOSE,
5395 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5396 name, args ? args : "");
5401 FF_DISABLE_DEPRECATION_WARNINGS
5402 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5403 AVBitStreamFilterContext *bsfc)
5407 AVPacket new_pkt = *pkt;
5408 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5409 &new_pkt.data, &new_pkt.size,
5410 pkt->data, pkt->size,
5411 pkt->flags & AV_PKT_FLAG_KEY);
5412 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5413 av_packet_unref(pkt);
5414 memset(pkt, 0, sizeof(*pkt));
5417 if(a == 0 && new_pkt.data != pkt->data) {
5418 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
5420 memcpy(t, new_pkt.data, new_pkt.size);
5421 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5426 a = AVERROR(ENOMEM);
5430 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5431 av_buffer_default_free, NULL, 0);
5433 pkt->side_data = NULL;
5434 pkt->side_data_elems = 0;
5435 av_packet_unref(pkt);
5437 av_freep(&new_pkt.data);
5438 a = AVERROR(ENOMEM);
5442 av_log(codec, AV_LOG_ERROR,
5443 "Failed to open bitstream filter %s for stream %d with codec %s",
5444 bsfc->filter->name, pkt->stream_index,
5445 codec->codec ? codec->codec->name : "copy");
5455 FF_ENABLE_DEPRECATION_WARNINGS
5458 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5461 return AVERROR(EINVAL);
5463 if (!(s->oformat->flags & AVFMT_NOFILE))
5464 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5468 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5471 s->io_close(s, *pb);
5475 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5477 AVDictionaryEntry *entry;
5478 int64_t parsed_timestamp;
5480 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5481 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5482 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5485 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5492 int ff_standardize_creation_time(AVFormatContext *s)
5495 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5497 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5501 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5506 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5508 if (size != AVPALETTE_SIZE) {
5509 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5510 return AVERROR_INVALIDDATA;
5512 memcpy(palette, side_data, AVPALETTE_SIZE);
5516 if (ret == CONTAINS_PAL) {
5518 for (i = 0; i < AVPALETTE_COUNT; i++)
5519 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5526 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5531 ret = av_bprint_finalize(buf, &str);
5534 if (!av_bprint_is_complete(buf)) {
5536 return AVERROR(ENOMEM);
5539 par->extradata = str;
5540 /* Note: the string is NUL terminated (so extradata can be read as a
5541 * string), but the ending character is not accounted in the size (in
5542 * binary formats you are likely not supposed to mux that character). When
5543 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5545 par->extradata_size = buf->len;
5549 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5550 AVStream *ost, const AVStream *ist,
5551 enum AVTimebaseSource copy_tb)
5553 //TODO: use [io]st->internal->avctx
5554 const AVCodecContext *dec_ctx = ist->codec;
5555 AVCodecContext *enc_ctx = ost->codec;
5557 enc_ctx->time_base = ist->time_base;
5559 * Avi is a special case here because it supports variable fps but
5560 * having the fps and timebase differe significantly adds quite some
5563 if (!strcmp(ofmt->name, "avi")) {
5564 #if FF_API_R_FRAME_RATE
5565 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5566 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5567 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5568 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5569 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5570 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5571 enc_ctx->time_base.num = ist->r_frame_rate.den;
5572 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5573 enc_ctx->ticks_per_frame = 2;
5576 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5577 && av_q2d(ist->time_base) < 1.0/500
5578 || copy_tb == AVFMT_TBCF_DECODER) {
5579 enc_ctx->time_base = dec_ctx->time_base;
5580 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5581 enc_ctx->time_base.den *= 2;
5582 enc_ctx->ticks_per_frame = 2;
5584 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5585 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5586 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5587 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5588 && av_q2d(ist->time_base) < 1.0/500
5589 || copy_tb == AVFMT_TBCF_DECODER) {
5590 enc_ctx->time_base = dec_ctx->time_base;
5591 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5595 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5596 && dec_ctx->time_base.num < dec_ctx->time_base.den
5597 && dec_ctx->time_base.num > 0
5598 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5599 enc_ctx->time_base = dec_ctx->time_base;
5602 if (ost->avg_frame_rate.num)
5603 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5605 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5606 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5611 AVRational av_stream_get_codec_timebase(const AVStream *st)
5613 // See avformat_transfer_internal_stream_timing_info() TODO.
5614 #if FF_API_LAVF_AVCTX
5615 FF_DISABLE_DEPRECATION_WARNINGS
5616 return st->codec->time_base;
5617 FF_ENABLE_DEPRECATION_WARNINGS
5619 return st->internal->avctx->time_base;