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/time.h"
36 #include "libavutil/time_internal.h"
37 #include "libavutil/timestamp.h"
39 #include "libavcodec/bytestream.h"
40 #include "libavcodec/internal.h"
41 #include "libavcodec/raw.h"
43 #include "audiointerleave.h"
45 #include "avio_internal.h"
55 #include "libavutil/ffversion.h"
56 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
60 * various utility functions for use within FFmpeg
63 unsigned avformat_version(void)
65 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
66 return LIBAVFORMAT_VERSION_INT;
69 const char *avformat_configuration(void)
71 return FFMPEG_CONFIGURATION;
74 const char *avformat_license(void)
76 #define LICENSE_PREFIX "libavformat license: "
77 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
80 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
82 static int is_relative(int64_t ts) {
83 return ts > (RELATIVE_TS_BASE - (1LL<<48));
87 * Wrap a given time stamp, if there is an indication for an overflow
90 * @param timestamp the time stamp to wrap
91 * @return resulting time stamp
93 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
95 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
96 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
97 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
98 timestamp < st->pts_wrap_reference)
99 return timestamp + (1ULL << st->pts_wrap_bits);
100 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
101 timestamp >= st->pts_wrap_reference)
102 return timestamp - (1ULL << st->pts_wrap_bits);
107 #if FF_API_FORMAT_GET_SET
108 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
109 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
113 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
114 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
115 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
116 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
117 #if FF_API_OLD_OPEN_CALLBACKS
118 FF_DISABLE_DEPRECATION_WARNINGS
119 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
120 FF_ENABLE_DEPRECATION_WARNINGS
124 int64_t av_stream_get_end_pts(const AVStream *st)
126 if (st->internal->priv_pts) {
127 return st->internal->priv_pts->val;
129 return AV_NOPTS_VALUE;
132 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
137 void av_format_inject_global_side_data(AVFormatContext *s)
140 s->internal->inject_global_side_data = 1;
141 for (i = 0; i < s->nb_streams; i++) {
142 AVStream *st = s->streams[i];
143 st->inject_global_side_data = 1;
147 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
149 av_assert0(!dst->codec_whitelist &&
150 !dst->format_whitelist &&
151 !dst->protocol_whitelist &&
152 !dst->protocol_blacklist);
153 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
154 dst->format_whitelist = av_strdup(src->format_whitelist);
155 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
156 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
157 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
158 || (src-> format_whitelist && !dst-> format_whitelist)
159 || (src->protocol_whitelist && !dst->protocol_whitelist)
160 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
161 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
162 return AVERROR(ENOMEM);
167 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
169 #if FF_API_LAVF_AVCTX
170 FF_DISABLE_DEPRECATION_WARNINGS
171 if (st->codec->codec)
172 return st->codec->codec;
173 FF_ENABLE_DEPRECATION_WARNINGS
176 switch (st->codecpar->codec_type) {
177 case AVMEDIA_TYPE_VIDEO:
178 if (s->video_codec) return s->video_codec;
180 case AVMEDIA_TYPE_AUDIO:
181 if (s->audio_codec) return s->audio_codec;
183 case AVMEDIA_TYPE_SUBTITLE:
184 if (s->subtitle_codec) return s->subtitle_codec;
188 return avcodec_find_decoder(codec_id);
191 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
193 const AVCodec *codec;
195 #if CONFIG_H264_DECODER
196 /* Other parts of the code assume this decoder to be used for h264,
197 * so force it if possible. */
198 if (codec_id == AV_CODEC_ID_H264)
199 return avcodec_find_decoder_by_name("h264");
202 codec = find_decoder(s, st, codec_id);
206 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
207 const AVCodec *probe_codec = NULL;
208 while (probe_codec = av_codec_next(probe_codec)) {
209 if (probe_codec->id == codec_id &&
210 av_codec_is_decoder(probe_codec) &&
211 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
220 #if FF_API_FORMAT_GET_SET
221 int av_format_get_probe_score(const AVFormatContext *s)
223 return s->probe_score;
227 /* an arbitrarily chosen "sane" max packet size -- 50M */
228 #define SANE_CHUNK_SIZE (50000000)
230 int ffio_limit(AVIOContext *s, int size)
232 if (s->maxsize>= 0) {
233 int64_t remaining= s->maxsize - avio_tell(s);
234 if (remaining < size) {
235 int64_t newsize = avio_size(s);
236 if (!s->maxsize || s->maxsize<newsize)
237 s->maxsize = newsize - !newsize;
238 remaining= s->maxsize - avio_tell(s);
239 remaining= FFMAX(remaining, 0);
242 if (s->maxsize>= 0 && remaining+1 < size) {
243 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
250 /* Read the data in sane-sized chunks and append to pkt.
251 * Return the number of bytes read or an error. */
252 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
254 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
255 int orig_size = pkt->size;
259 int prev_size = pkt->size;
262 /* When the caller requests a lot of data, limit it to the amount
263 * left in file or SANE_CHUNK_SIZE when it is not known. */
265 if (read_size > SANE_CHUNK_SIZE/10) {
266 read_size = ffio_limit(s, read_size);
267 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
269 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
272 ret = av_grow_packet(pkt, read_size);
276 ret = avio_read(s, pkt->data + prev_size, read_size);
277 if (ret != read_size) {
278 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
285 pkt->flags |= AV_PKT_FLAG_CORRUPT;
289 av_packet_unref(pkt);
290 return pkt->size > orig_size ? pkt->size - orig_size : ret;
293 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
298 pkt->pos = avio_tell(s);
300 return append_packet_chunked(s, pkt, size);
303 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
306 return av_get_packet(s, pkt, size);
307 return append_packet_chunked(s, pkt, size);
310 int av_filename_number_test(const char *filename)
314 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
317 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
320 static const struct {
323 enum AVMediaType type;
325 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
326 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
327 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
328 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
329 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
330 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
331 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
332 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
333 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
334 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
335 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
336 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
337 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
338 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
339 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
343 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
347 av_log(s, AV_LOG_DEBUG,
348 "Probe with size=%d, packets=%d detected %s with score=%d\n",
349 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
351 for (i = 0; fmt_id_type[i].name; i++) {
352 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
353 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
354 st->codecpar->sample_rate)
356 if (st->request_probe > score &&
357 st->codecpar->codec_id != fmt_id_type[i].id)
359 st->codecpar->codec_id = fmt_id_type[i].id;
360 st->codecpar->codec_type = fmt_id_type[i].type;
361 st->internal->need_context_update = 1;
362 #if FF_API_LAVF_AVCTX
363 FF_DISABLE_DEPRECATION_WARNINGS
364 st->codec->codec_type = st->codecpar->codec_type;
365 st->codec->codec_id = st->codecpar->codec_id;
366 FF_ENABLE_DEPRECATION_WARNINGS
375 /************************************************************/
376 /* input media file */
378 int av_demuxer_open(AVFormatContext *ic) {
381 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
382 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
383 return AVERROR(EINVAL);
386 if (ic->iformat->read_header) {
387 err = ic->iformat->read_header(ic);
392 if (ic->pb && !ic->internal->data_offset)
393 ic->internal->data_offset = avio_tell(ic->pb);
398 /* Open input file and probe the format if necessary. */
399 static int init_input(AVFormatContext *s, const char *filename,
400 AVDictionary **options)
403 AVProbeData pd = { filename, NULL, 0 };
404 int score = AVPROBE_SCORE_RETRY;
407 s->flags |= AVFMT_FLAG_CUSTOM_IO;
409 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
410 s, 0, s->format_probesize);
411 else if (s->iformat->flags & AVFMT_NOFILE)
412 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
413 "will be ignored with AVFMT_NOFILE format.\n");
417 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
418 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
421 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
426 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
427 s, 0, s->format_probesize);
430 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
431 AVPacketList **plast_pktl, int ref)
433 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
437 return AVERROR(ENOMEM);
440 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
449 (*plast_pktl)->next = pktl;
451 *packet_buffer = pktl;
453 /* Add the packet in the buffered packet list. */
458 int avformat_queue_attached_pictures(AVFormatContext *s)
461 for (i = 0; i < s->nb_streams; i++)
462 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
463 s->streams[i]->discard < AVDISCARD_ALL) {
464 if (s->streams[i]->attached_pic.size <= 0) {
465 av_log(s, AV_LOG_WARNING,
466 "Attached picture on stream %d has invalid size, "
471 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
472 &s->streams[i]->attached_pic,
473 &s->internal->raw_packet_buffer_end, 1);
480 static int update_stream_avctx(AVFormatContext *s)
483 for (i = 0; i < s->nb_streams; i++) {
484 AVStream *st = s->streams[i];
486 if (!st->internal->need_context_update)
489 /* close parser, because it depends on the codec */
490 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
491 av_parser_close(st->parser);
495 /* update internal codec context, for the parser */
496 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
500 #if FF_API_LAVF_AVCTX
501 FF_DISABLE_DEPRECATION_WARNINGS
502 /* update deprecated public codec context */
503 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
506 FF_ENABLE_DEPRECATION_WARNINGS
509 st->internal->need_context_update = 0;
515 int avformat_open_input(AVFormatContext **ps, const char *filename,
516 AVInputFormat *fmt, AVDictionary **options)
518 AVFormatContext *s = *ps;
520 AVDictionary *tmp = NULL;
521 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
523 if (!s && !(s = avformat_alloc_context()))
524 return AVERROR(ENOMEM);
526 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
527 return AVERROR(EINVAL);
533 av_dict_copy(&tmp, *options, 0);
535 if (s->pb) // must be before any goto fail
536 s->flags |= AVFMT_FLAG_CUSTOM_IO;
538 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
541 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
542 if ((ret = init_input(s, filename, &tmp)) < 0)
544 s->probe_score = ret;
546 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
547 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
548 if (!s->protocol_whitelist) {
549 ret = AVERROR(ENOMEM);
554 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
555 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
556 if (!s->protocol_blacklist) {
557 ret = AVERROR(ENOMEM);
562 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
563 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
564 ret = AVERROR(EINVAL);
568 avio_skip(s->pb, s->skip_initial_bytes);
570 /* Check filename in case an image number is expected. */
571 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
572 if (!av_filename_number_test(filename)) {
573 ret = AVERROR(EINVAL);
578 s->duration = s->start_time = AV_NOPTS_VALUE;
580 /* Allocate private data. */
581 if (s->iformat->priv_data_size > 0) {
582 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
583 ret = AVERROR(ENOMEM);
586 if (s->iformat->priv_class) {
587 *(const AVClass **) s->priv_data = s->iformat->priv_class;
588 av_opt_set_defaults(s->priv_data);
589 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
594 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
596 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
599 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
600 if ((ret = s->iformat->read_header(s)) < 0)
604 s->metadata = s->internal->id3v2_meta;
605 s->internal->id3v2_meta = NULL;
606 } else if (s->internal->id3v2_meta) {
607 int level = AV_LOG_WARNING;
608 if (s->error_recognition & AV_EF_COMPLIANT)
609 level = AV_LOG_ERROR;
610 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
611 av_dict_free(&s->internal->id3v2_meta);
612 if (s->error_recognition & AV_EF_EXPLODE)
613 return AVERROR_INVALIDDATA;
616 if (id3v2_extra_meta) {
617 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
618 !strcmp(s->iformat->name, "tta")) {
619 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
621 if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
624 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
626 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
628 if ((ret = avformat_queue_attached_pictures(s)) < 0)
631 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
632 s->internal->data_offset = avio_tell(s->pb);
634 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
636 update_stream_avctx(s);
638 for (i = 0; i < s->nb_streams; i++)
639 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
642 av_dict_free(options);
649 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
651 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
653 avformat_free_context(s);
658 /*******************************************************/
660 static void force_codec_ids(AVFormatContext *s, AVStream *st)
662 switch (st->codecpar->codec_type) {
663 case AVMEDIA_TYPE_VIDEO:
664 if (s->video_codec_id)
665 st->codecpar->codec_id = s->video_codec_id;
667 case AVMEDIA_TYPE_AUDIO:
668 if (s->audio_codec_id)
669 st->codecpar->codec_id = s->audio_codec_id;
671 case AVMEDIA_TYPE_SUBTITLE:
672 if (s->subtitle_codec_id)
673 st->codecpar->codec_id = s->subtitle_codec_id;
675 case AVMEDIA_TYPE_DATA:
676 if (s->data_codec_id)
677 st->codecpar->codec_id = s->data_codec_id;
682 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
684 if (st->request_probe>0) {
685 AVProbeData *pd = &st->probe_data;
687 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
691 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
693 av_log(s, AV_LOG_WARNING,
694 "Failed to reallocate probe buffer for stream %d\n",
699 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
700 pd->buf_size += pkt->size;
701 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
704 st->probe_packets = 0;
706 av_log(s, AV_LOG_WARNING,
707 "nothing to probe for stream %d\n", st->index);
711 end= s->internal->raw_packet_buffer_remaining_size <= 0
712 || st->probe_packets<= 0;
714 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
715 int score = set_codec_from_probe_data(s, st, pd);
716 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
720 st->request_probe = -1;
721 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
722 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
724 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
726 force_codec_ids(s, st);
732 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
734 int64_t ref = pkt->dts;
735 int i, pts_wrap_behavior;
736 int64_t pts_wrap_reference;
737 AVProgram *first_program;
739 if (ref == AV_NOPTS_VALUE)
741 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
743 ref &= (1LL << st->pts_wrap_bits)-1;
745 // reference time stamp should be 60 s before first time stamp
746 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
747 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
748 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
749 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
750 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
752 first_program = av_find_program_from_stream(s, NULL, stream_index);
754 if (!first_program) {
755 int default_stream_index = av_find_default_stream_index(s);
756 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
757 for (i = 0; i < s->nb_streams; i++) {
758 if (av_find_program_from_stream(s, NULL, i))
760 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
761 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
765 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
766 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
770 AVProgram *program = first_program;
772 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
773 pts_wrap_reference = program->pts_wrap_reference;
774 pts_wrap_behavior = program->pts_wrap_behavior;
777 program = av_find_program_from_stream(s, program, stream_index);
780 // update every program with differing pts_wrap_reference
781 program = first_program;
783 if (program->pts_wrap_reference != pts_wrap_reference) {
784 for (i = 0; i<program->nb_stream_indexes; i++) {
785 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
786 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
789 program->pts_wrap_reference = pts_wrap_reference;
790 program->pts_wrap_behavior = pts_wrap_behavior;
792 program = av_find_program_from_stream(s, program, stream_index);
798 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
804 AVPacketList *pktl = s->internal->raw_packet_buffer;
808 st = s->streams[pkt->stream_index];
809 if (s->internal->raw_packet_buffer_remaining_size <= 0)
810 if ((err = probe_codec(s, st, NULL)) < 0)
812 if (st->request_probe <= 0) {
813 s->internal->raw_packet_buffer = pktl->next;
814 s->internal->raw_packet_buffer_remaining_size += pkt->size;
823 ret = s->iformat->read_packet(s, pkt);
825 /* Some demuxers return FFERROR_REDO when they consume
826 data and discard it (ignored streams, junk, extradata).
827 We must re-call the demuxer to get the real packet. */
828 if (ret == FFERROR_REDO)
830 if (!pktl || ret == AVERROR(EAGAIN))
832 for (i = 0; i < s->nb_streams; i++) {
834 if (st->probe_packets || st->request_probe > 0)
835 if ((err = probe_codec(s, st, NULL)) < 0)
837 av_assert0(st->request_probe <= 0);
843 AVPacket tmp = { 0 };
844 ret = av_packet_ref(&tmp, pkt);
850 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
851 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
852 av_log(s, AV_LOG_WARNING,
853 "Dropped corrupted packet (stream = %d)\n",
855 av_packet_unref(pkt);
859 if (pkt->stream_index >= (unsigned)s->nb_streams) {
860 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
864 st = s->streams[pkt->stream_index];
866 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
867 // correct first time stamps to negative values
868 if (!is_relative(st->first_dts))
869 st->first_dts = wrap_timestamp(st, st->first_dts);
870 if (!is_relative(st->start_time))
871 st->start_time = wrap_timestamp(st, st->start_time);
872 if (!is_relative(st->cur_dts))
873 st->cur_dts = wrap_timestamp(st, st->cur_dts);
876 pkt->dts = wrap_timestamp(st, pkt->dts);
877 pkt->pts = wrap_timestamp(st, pkt->pts);
879 force_codec_ids(s, st);
881 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
882 if (s->use_wallclock_as_timestamps)
883 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
885 if (!pktl && st->request_probe <= 0)
888 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
889 &s->internal->raw_packet_buffer_end, 0);
892 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
894 if ((err = probe_codec(s, st, pkt)) < 0)
900 /**********************************************************/
902 static int determinable_frame_size(AVCodecContext *avctx)
904 switch(avctx->codec_id) {
905 case AV_CODEC_ID_MP1:
906 case AV_CODEC_ID_MP2:
907 case AV_CODEC_ID_MP3:
915 * Return the frame duration in seconds. Return 0 if not available.
917 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
918 AVCodecParserContext *pc, AVPacket *pkt)
920 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
921 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
922 int frame_size, sample_rate;
924 #if FF_API_LAVF_AVCTX
925 FF_DISABLE_DEPRECATION_WARNINGS
926 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
927 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
928 FF_ENABLE_DEPRECATION_WARNINGS
933 switch (st->codecpar->codec_type) {
934 case AVMEDIA_TYPE_VIDEO:
935 if (st->r_frame_rate.num && !pc && s->iformat) {
936 *pnum = st->r_frame_rate.den;
937 *pden = st->r_frame_rate.num;
938 } else if (st->time_base.num * 1000LL > st->time_base.den) {
939 *pnum = st->time_base.num;
940 *pden = st->time_base.den;
941 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
942 av_assert0(st->internal->avctx->ticks_per_frame);
943 av_reduce(pnum, pden,
945 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
948 if (pc && pc->repeat_pict) {
949 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
950 av_reduce(pnum, pden,
951 (*pnum) * (1LL + pc->repeat_pict),
955 /* If this codec can be interlaced or progressive then we need
956 * a parser to compute duration of a packet. Thus if we have
957 * no parser in such case leave duration undefined. */
958 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
962 case AVMEDIA_TYPE_AUDIO:
963 if (st->internal->avctx_inited) {
964 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
965 sample_rate = st->internal->avctx->sample_rate;
967 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
968 sample_rate = st->codecpar->sample_rate;
970 if (frame_size <= 0 || sample_rate <= 0)
980 static int is_intra_only(enum AVCodecID id)
982 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
985 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
990 static int has_decode_delay_been_guessed(AVStream *st)
992 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
993 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
995 #if CONFIG_H264_DECODER
996 if (st->internal->avctx->has_b_frames &&
997 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1000 if (st->internal->avctx->has_b_frames<3)
1001 return st->nb_decoded_frames >= 7;
1002 else if (st->internal->avctx->has_b_frames<4)
1003 return st->nb_decoded_frames >= 18;
1005 return st->nb_decoded_frames >= 20;
1008 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1012 if (pktl == s->internal->packet_buffer_end)
1013 return s->internal->parse_queue;
1017 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1018 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1019 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1022 int delay = st->internal->avctx->has_b_frames;
1025 if (dts == AV_NOPTS_VALUE) {
1026 int64_t best_score = INT64_MAX;
1027 for (i = 0; i<delay; i++) {
1028 if (st->pts_reorder_error_count[i]) {
1029 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1030 if (score < best_score) {
1032 dts = pts_buffer[i];
1037 for (i = 0; i<delay; i++) {
1038 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1039 int64_t diff = FFABS(pts_buffer[i] - dts)
1040 + (uint64_t)st->pts_reorder_error[i];
1041 diff = FFMAX(diff, st->pts_reorder_error[i]);
1042 st->pts_reorder_error[i] = diff;
1043 st->pts_reorder_error_count[i]++;
1044 if (st->pts_reorder_error_count[i] > 250) {
1045 st->pts_reorder_error[i] >>= 1;
1046 st->pts_reorder_error_count[i] >>= 1;
1053 if (dts == AV_NOPTS_VALUE)
1054 dts = pts_buffer[0];
1060 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1061 * of the packets in a window.
1063 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1064 AVPacketList *pkt_buffer)
1066 AVStream *st = s->streams[stream_index];
1067 int delay = st->internal->avctx->has_b_frames;
1070 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1072 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1073 pts_buffer[i] = AV_NOPTS_VALUE;
1075 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1076 if (pkt_buffer->pkt.stream_index != stream_index)
1079 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1080 pts_buffer[0] = pkt_buffer->pkt.pts;
1081 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1082 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1084 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1089 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1090 int64_t dts, int64_t pts, AVPacket *pkt)
1092 AVStream *st = s->streams[stream_index];
1093 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1094 AVPacketList *pktl_it;
1098 if (st->first_dts != AV_NOPTS_VALUE ||
1099 dts == AV_NOPTS_VALUE ||
1100 st->cur_dts == AV_NOPTS_VALUE ||
1104 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1106 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1108 if (is_relative(pts))
1111 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1112 if (pktl_it->pkt.stream_index != stream_index)
1114 if (is_relative(pktl_it->pkt.pts))
1115 pktl_it->pkt.pts += shift;
1117 if (is_relative(pktl_it->pkt.dts))
1118 pktl_it->pkt.dts += shift;
1120 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1121 st->start_time = pktl_it->pkt.pts;
1122 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1123 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1127 if (has_decode_delay_been_guessed(st)) {
1128 update_dts_from_pts(s, stream_index, pktl);
1131 if (st->start_time == AV_NOPTS_VALUE) {
1132 st->start_time = pts;
1133 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1134 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1138 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1139 int stream_index, int duration)
1141 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1142 int64_t cur_dts = RELATIVE_TS_BASE;
1144 if (st->first_dts != AV_NOPTS_VALUE) {
1145 if (st->update_initial_durations_done)
1147 st->update_initial_durations_done = 1;
1148 cur_dts = st->first_dts;
1149 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1150 if (pktl->pkt.stream_index == stream_index) {
1151 if (pktl->pkt.pts != pktl->pkt.dts ||
1152 pktl->pkt.dts != AV_NOPTS_VALUE ||
1155 cur_dts -= duration;
1158 if (pktl && pktl->pkt.dts != st->first_dts) {
1159 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1160 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1164 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1167 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1168 st->first_dts = cur_dts;
1169 } else if (st->cur_dts != RELATIVE_TS_BASE)
1172 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1173 if (pktl->pkt.stream_index != stream_index)
1175 if ((pktl->pkt.pts == pktl->pkt.dts ||
1176 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1177 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1178 pktl->pkt.dts == st->first_dts ||
1179 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1180 !pktl->pkt.duration) {
1181 pktl->pkt.dts = cur_dts;
1182 if (!st->internal->avctx->has_b_frames)
1183 pktl->pkt.pts = cur_dts;
1184 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1185 pktl->pkt.duration = duration;
1188 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1191 st->cur_dts = cur_dts;
1194 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1195 AVCodecParserContext *pc, AVPacket *pkt,
1196 int64_t next_dts, int64_t next_pts)
1198 int num, den, presentation_delayed, delay, i;
1200 AVRational duration;
1201 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1202 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1204 if (s->flags & AVFMT_FLAG_NOFILLIN)
1207 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1208 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1209 if (st->last_dts_for_order_check <= pkt->dts) {
1212 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1213 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1215 st->last_dts_for_order_check);
1216 st->dts_misordered++;
1218 if (st->dts_ordered + st->dts_misordered > 250) {
1219 st->dts_ordered >>= 1;
1220 st->dts_misordered >>= 1;
1224 st->last_dts_for_order_check = pkt->dts;
1225 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1226 pkt->dts = AV_NOPTS_VALUE;
1229 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1230 pkt->dts = AV_NOPTS_VALUE;
1232 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1233 && !st->internal->avctx->has_b_frames)
1234 //FIXME Set low_delay = 0 when has_b_frames = 1
1235 st->internal->avctx->has_b_frames = 1;
1237 /* do we have a video B-frame ? */
1238 delay = st->internal->avctx->has_b_frames;
1239 presentation_delayed = 0;
1241 /* XXX: need has_b_frame, but cannot get it if the codec is
1242 * not initialized */
1244 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1245 presentation_delayed = 1;
1247 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1248 st->pts_wrap_bits < 63 &&
1249 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1250 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1251 pkt->dts -= 1LL << st->pts_wrap_bits;
1253 pkt->pts += 1LL << st->pts_wrap_bits;
1256 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1257 * We take the conservative approach and discard both.
1258 * Note: If this is misbehaving for an H.264 file, then possibly
1259 * presentation_delayed is not set correctly. */
1260 if (delay == 1 && pkt->dts == pkt->pts &&
1261 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1262 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1263 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1264 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1265 pkt->dts = AV_NOPTS_VALUE;
1268 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1269 if (pkt->duration == 0) {
1270 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1272 duration = (AVRational) {num, den};
1273 pkt->duration = av_rescale_rnd(1,
1274 num * (int64_t) st->time_base.den,
1275 den * (int64_t) st->time_base.num,
1280 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1281 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1283 /* Correct timestamps with byte offset if demuxers only have timestamps
1284 * on packet boundaries */
1285 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1286 /* this will estimate bitrate based on this frame's duration and size */
1287 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1288 if (pkt->pts != AV_NOPTS_VALUE)
1290 if (pkt->dts != AV_NOPTS_VALUE)
1294 /* This may be redundant, but it should not hurt. */
1295 if (pkt->dts != AV_NOPTS_VALUE &&
1296 pkt->pts != AV_NOPTS_VALUE &&
1297 pkt->pts > pkt->dts)
1298 presentation_delayed = 1;
1300 if (s->debug & FF_FDEBUG_TS)
1301 av_log(s, AV_LOG_TRACE,
1302 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1303 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1304 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1306 /* Interpolate PTS and DTS if they are not present. We skip H264
1307 * currently because delay and has_b_frames are not reliably set. */
1308 if ((delay == 0 || (delay == 1 && pc)) &&
1310 if (presentation_delayed) {
1311 /* DTS = decompression timestamp */
1312 /* PTS = presentation timestamp */
1313 if (pkt->dts == AV_NOPTS_VALUE)
1314 pkt->dts = st->last_IP_pts;
1315 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1316 if (pkt->dts == AV_NOPTS_VALUE)
1317 pkt->dts = st->cur_dts;
1319 /* This is tricky: the dts must be incremented by the duration
1320 * of the frame we are displaying, i.e. the last I- or P-frame. */
1321 if (st->last_IP_duration == 0)
1322 st->last_IP_duration = pkt->duration;
1323 if (pkt->dts != AV_NOPTS_VALUE)
1324 st->cur_dts = pkt->dts + st->last_IP_duration;
1325 if (pkt->dts != AV_NOPTS_VALUE &&
1326 pkt->pts == AV_NOPTS_VALUE &&
1327 st->last_IP_duration > 0 &&
1328 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1329 next_dts != next_pts &&
1330 next_pts != AV_NOPTS_VALUE)
1331 pkt->pts = next_dts;
1333 st->last_IP_duration = pkt->duration;
1334 st->last_IP_pts = pkt->pts;
1335 /* Cannot compute PTS if not present (we can compute it only
1336 * by knowing the future. */
1337 } else if (pkt->pts != AV_NOPTS_VALUE ||
1338 pkt->dts != AV_NOPTS_VALUE ||
1341 /* presentation is not delayed : PTS and DTS are the same */
1342 if (pkt->pts == AV_NOPTS_VALUE)
1343 pkt->pts = pkt->dts;
1344 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1346 if (pkt->pts == AV_NOPTS_VALUE)
1347 pkt->pts = st->cur_dts;
1348 pkt->dts = pkt->pts;
1349 if (pkt->pts != AV_NOPTS_VALUE)
1350 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1354 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1355 st->pts_buffer[0] = pkt->pts;
1356 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1357 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1359 if(has_decode_delay_been_guessed(st))
1360 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1362 // We skipped it above so we try here.
1364 // This should happen on the first packet
1365 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1366 if (pkt->dts > st->cur_dts)
1367 st->cur_dts = pkt->dts;
1369 if (s->debug & FF_FDEBUG_TS)
1370 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1371 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1374 if (is_intra_only(st->codecpar->codec_id))
1375 pkt->flags |= AV_PKT_FLAG_KEY;
1376 #if FF_API_CONVERGENCE_DURATION
1377 FF_DISABLE_DEPRECATION_WARNINGS
1379 pkt->convergence_duration = pc->convergence_duration;
1380 FF_ENABLE_DEPRECATION_WARNINGS
1384 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1387 AVPacketList *pktl = *pkt_buf;
1388 *pkt_buf = pktl->next;
1389 av_packet_unref(&pktl->pkt);
1392 *pkt_buf_end = NULL;
1396 * Parse a packet, add all split parts to parse_queue.
1398 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1400 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1402 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1403 AVStream *st = s->streams[stream_index];
1404 uint8_t *data = pkt ? pkt->data : NULL;
1405 int size = pkt ? pkt->size : 0;
1406 int ret = 0, got_output = 0;
1409 av_init_packet(&flush_pkt);
1412 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1413 // preserve 0-size sync packets
1414 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1417 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1419 int64_t next_pts = pkt->pts;
1420 int64_t next_dts = pkt->dts;
1422 av_init_packet(&out_pkt);
1423 len = av_parser_parse2(st->parser, st->internal->avctx,
1424 &out_pkt.data, &out_pkt.size, data, size,
1425 pkt->pts, pkt->dts, pkt->pos);
1427 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1429 /* increment read pointer */
1433 got_output = !!out_pkt.size;
1438 if (pkt->side_data) {
1439 out_pkt.side_data = pkt->side_data;
1440 out_pkt.side_data_elems = pkt->side_data_elems;
1441 pkt->side_data = NULL;
1442 pkt->side_data_elems = 0;
1445 /* set the duration */
1446 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1447 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1448 if (st->internal->avctx->sample_rate > 0) {
1450 av_rescale_q_rnd(st->parser->duration,
1451 (AVRational) { 1, st->internal->avctx->sample_rate },
1457 out_pkt.stream_index = st->index;
1458 out_pkt.pts = st->parser->pts;
1459 out_pkt.dts = st->parser->dts;
1460 out_pkt.pos = st->parser->pos;
1461 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1463 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1464 out_pkt.pos = st->parser->frame_offset;
1466 if (st->parser->key_frame == 1 ||
1467 (st->parser->key_frame == -1 &&
1468 st->parser->pict_type == AV_PICTURE_TYPE_I))
1469 out_pkt.flags |= AV_PKT_FLAG_KEY;
1471 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1472 out_pkt.flags |= AV_PKT_FLAG_KEY;
1474 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1476 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1477 &s->internal->parse_queue_end, 1);
1478 av_packet_unref(&out_pkt);
1483 /* end of the stream => close and free the parser */
1484 if (pkt == &flush_pkt) {
1485 av_parser_close(st->parser);
1490 av_packet_unref(pkt);
1494 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1495 AVPacketList **pkt_buffer_end,
1499 av_assert0(*pkt_buffer);
1502 *pkt_buffer = pktl->next;
1504 *pkt_buffer_end = NULL;
1509 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1511 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1514 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1516 int ret = 0, i, got_packet = 0;
1517 AVDictionary *metadata = NULL;
1519 av_init_packet(pkt);
1521 while (!got_packet && !s->internal->parse_queue) {
1525 /* read next packet */
1526 ret = ff_read_packet(s, &cur_pkt);
1528 if (ret == AVERROR(EAGAIN))
1530 /* flush the parsers */
1531 for (i = 0; i < s->nb_streams; i++) {
1533 if (st->parser && st->need_parsing)
1534 parse_packet(s, NULL, st->index);
1536 /* all remaining packets are now in parse_queue =>
1537 * really terminate parsing */
1541 st = s->streams[cur_pkt.stream_index];
1543 /* update context if required */
1544 if (st->internal->need_context_update) {
1545 if (avcodec_is_open(st->internal->avctx)) {
1546 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1547 avcodec_close(st->internal->avctx);
1548 st->info->found_decoder = 0;
1551 /* close parser, because it depends on the codec */
1552 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1553 av_parser_close(st->parser);
1557 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1561 #if FF_API_LAVF_AVCTX
1562 FF_DISABLE_DEPRECATION_WARNINGS
1563 /* update deprecated public codec context */
1564 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1567 FF_ENABLE_DEPRECATION_WARNINGS
1570 st->internal->need_context_update = 0;
1573 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1574 cur_pkt.dts != AV_NOPTS_VALUE &&
1575 cur_pkt.pts < cur_pkt.dts) {
1576 av_log(s, AV_LOG_WARNING,
1577 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1578 cur_pkt.stream_index,
1579 av_ts2str(cur_pkt.pts),
1580 av_ts2str(cur_pkt.dts),
1583 if (s->debug & FF_FDEBUG_TS)
1584 av_log(s, AV_LOG_DEBUG,
1585 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1586 cur_pkt.stream_index,
1587 av_ts2str(cur_pkt.pts),
1588 av_ts2str(cur_pkt.dts),
1589 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1591 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1592 st->parser = av_parser_init(st->codecpar->codec_id);
1594 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1595 "%s, packets or times may be invalid.\n",
1596 avcodec_get_name(st->codecpar->codec_id));
1597 /* no parser available: just output the raw packets */
1598 st->need_parsing = AVSTREAM_PARSE_NONE;
1599 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1600 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1601 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1602 st->parser->flags |= PARSER_FLAG_ONCE;
1603 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1604 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1607 if (!st->need_parsing || !st->parser) {
1608 /* no parsing needed: we just output the packet as is */
1610 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1611 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1612 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1613 ff_reduce_index(s, st->index);
1614 av_add_index_entry(st, pkt->pos, pkt->dts,
1615 0, 0, AVINDEX_KEYFRAME);
1618 } else if (st->discard < AVDISCARD_ALL) {
1619 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1621 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1622 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1623 st->codecpar->channels = st->internal->avctx->channels;
1624 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1625 st->codecpar->codec_id = st->internal->avctx->codec_id;
1628 av_packet_unref(&cur_pkt);
1630 if (pkt->flags & AV_PKT_FLAG_KEY)
1631 st->skip_to_keyframe = 0;
1632 if (st->skip_to_keyframe) {
1633 av_packet_unref(&cur_pkt);
1641 if (!got_packet && s->internal->parse_queue)
1642 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1645 AVStream *st = s->streams[pkt->stream_index];
1646 int discard_padding = 0;
1647 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1648 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1649 int64_t sample = ts_to_samples(st, pts);
1650 int duration = ts_to_samples(st, pkt->duration);
1651 int64_t end_sample = sample + duration;
1652 if (duration > 0 && end_sample >= st->first_discard_sample &&
1653 sample < st->last_discard_sample)
1654 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1656 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1657 st->skip_samples = st->start_skip_samples;
1658 if (st->skip_samples || discard_padding) {
1659 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1661 AV_WL32(p, st->skip_samples);
1662 AV_WL32(p + 4, discard_padding);
1663 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1665 st->skip_samples = 0;
1668 if (st->inject_global_side_data) {
1669 for (i = 0; i < st->nb_side_data; i++) {
1670 AVPacketSideData *src_sd = &st->side_data[i];
1673 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1676 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1678 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1682 memcpy(dst_data, src_sd->data, src_sd->size);
1684 st->inject_global_side_data = 0;
1688 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1690 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1691 av_dict_copy(&s->metadata, metadata, 0);
1692 av_dict_free(&metadata);
1693 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1696 #if FF_API_LAVF_AVCTX
1697 update_stream_avctx(s);
1700 if (s->debug & FF_FDEBUG_TS)
1701 av_log(s, AV_LOG_DEBUG,
1702 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1703 "size=%d, duration=%"PRId64", flags=%d\n",
1705 av_ts2str(pkt->pts),
1706 av_ts2str(pkt->dts),
1707 pkt->size, pkt->duration, pkt->flags);
1712 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1714 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1720 ret = s->internal->packet_buffer
1721 ? read_from_packet_buffer(&s->internal->packet_buffer,
1722 &s->internal->packet_buffer_end, pkt)
1723 : read_frame_internal(s, pkt);
1730 AVPacketList *pktl = s->internal->packet_buffer;
1733 AVPacket *next_pkt = &pktl->pkt;
1735 if (next_pkt->dts != AV_NOPTS_VALUE) {
1736 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1737 // last dts seen for this stream. if any of packets following
1738 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1739 int64_t last_dts = next_pkt->dts;
1740 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1741 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1742 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1743 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1745 next_pkt->pts = pktl->pkt.dts;
1747 if (last_dts != AV_NOPTS_VALUE) {
1748 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1749 last_dts = pktl->pkt.dts;
1754 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1755 // Fixing the last reference frame had none pts issue (For MXF etc).
1756 // We only do this when
1758 // 2. we are not able to resolve a pts value for current packet.
1759 // 3. the packets for this stream at the end of the files had valid dts.
1760 next_pkt->pts = last_dts + next_pkt->duration;
1762 pktl = s->internal->packet_buffer;
1765 /* read packet from packet buffer, if there is data */
1766 st = s->streams[next_pkt->stream_index];
1767 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1768 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1769 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1770 &s->internal->packet_buffer_end, pkt);
1775 ret = read_frame_internal(s, pkt);
1777 if (pktl && ret != AVERROR(EAGAIN)) {
1784 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1785 &s->internal->packet_buffer_end, 1);
1786 av_packet_unref(pkt);
1793 st = s->streams[pkt->stream_index];
1794 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1795 ff_reduce_index(s, st->index);
1796 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1799 if (is_relative(pkt->dts))
1800 pkt->dts -= RELATIVE_TS_BASE;
1801 if (is_relative(pkt->pts))
1802 pkt->pts -= RELATIVE_TS_BASE;
1807 /* XXX: suppress the packet queue */
1808 static void flush_packet_queue(AVFormatContext *s)
1812 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1813 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1814 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1816 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1819 /*******************************************************/
1822 int av_find_default_stream_index(AVFormatContext *s)
1826 int best_stream = 0;
1827 int best_score = INT_MIN;
1829 if (s->nb_streams <= 0)
1831 for (i = 0; i < s->nb_streams; i++) {
1834 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1835 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1837 if (st->codecpar->width && st->codecpar->height)
1841 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1842 if (st->codecpar->sample_rate)
1845 if (st->codec_info_nb_frames)
1848 if (st->discard != AVDISCARD_ALL)
1851 if (score > best_score) {
1859 /** Flush the frame reader. */
1860 void ff_read_frame_flush(AVFormatContext *s)
1865 flush_packet_queue(s);
1867 /* Reset read state for each stream. */
1868 for (i = 0; i < s->nb_streams; i++) {
1872 av_parser_close(st->parser);
1875 st->last_IP_pts = AV_NOPTS_VALUE;
1876 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1877 if (st->first_dts == AV_NOPTS_VALUE)
1878 st->cur_dts = RELATIVE_TS_BASE;
1880 /* We set the current DTS to an unspecified origin. */
1881 st->cur_dts = AV_NOPTS_VALUE;
1883 st->probe_packets = MAX_PROBE_PACKETS;
1885 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1886 st->pts_buffer[j] = AV_NOPTS_VALUE;
1888 if (s->internal->inject_global_side_data)
1889 st->inject_global_side_data = 1;
1891 st->skip_samples = 0;
1895 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1899 for (i = 0; i < s->nb_streams; i++) {
1900 AVStream *st = s->streams[i];
1903 av_rescale(timestamp,
1904 st->time_base.den * (int64_t) ref_st->time_base.num,
1905 st->time_base.num * (int64_t) ref_st->time_base.den);
1909 void ff_reduce_index(AVFormatContext *s, int stream_index)
1911 AVStream *st = s->streams[stream_index];
1912 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1914 if ((unsigned) st->nb_index_entries >= max_entries) {
1916 for (i = 0; 2 * i < st->nb_index_entries; i++)
1917 st->index_entries[i] = st->index_entries[2 * i];
1918 st->nb_index_entries = i;
1922 int ff_add_index_entry(AVIndexEntry **index_entries,
1923 int *nb_index_entries,
1924 unsigned int *index_entries_allocated_size,
1925 int64_t pos, int64_t timestamp,
1926 int size, int distance, int flags)
1928 AVIndexEntry *entries, *ie;
1931 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1934 if (timestamp == AV_NOPTS_VALUE)
1935 return AVERROR(EINVAL);
1937 if (size < 0 || size > 0x3FFFFFFF)
1938 return AVERROR(EINVAL);
1940 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1941 timestamp -= RELATIVE_TS_BASE;
1943 entries = av_fast_realloc(*index_entries,
1944 index_entries_allocated_size,
1945 (*nb_index_entries + 1) *
1946 sizeof(AVIndexEntry));
1950 *index_entries = entries;
1952 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1953 timestamp, AVSEEK_FLAG_ANY);
1956 index = (*nb_index_entries)++;
1957 ie = &entries[index];
1958 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1960 ie = &entries[index];
1961 if (ie->timestamp != timestamp) {
1962 if (ie->timestamp <= timestamp)
1964 memmove(entries + index + 1, entries + index,
1965 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1966 (*nb_index_entries)++;
1967 } else if (ie->pos == pos && distance < ie->min_distance)
1968 // do not reduce the distance
1969 distance = ie->min_distance;
1973 ie->timestamp = timestamp;
1974 ie->min_distance = distance;
1981 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1982 int size, int distance, int flags)
1984 timestamp = wrap_timestamp(st, timestamp);
1985 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1986 &st->index_entries_allocated_size, pos,
1987 timestamp, size, distance, flags);
1990 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1991 int64_t wanted_timestamp, int flags)
1999 // Optimize appending index entries at the end.
2000 if (b && entries[b - 1].timestamp < wanted_timestamp)
2006 // Search for the next non-discarded packet.
2007 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2009 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2015 timestamp = entries[m].timestamp;
2016 if (timestamp >= wanted_timestamp)
2018 if (timestamp <= wanted_timestamp)
2021 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2023 if (!(flags & AVSEEK_FLAG_ANY))
2024 while (m >= 0 && m < nb_entries &&
2025 !(entries[m].flags & AVINDEX_KEYFRAME))
2026 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2028 if (m == nb_entries)
2033 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2036 int64_t pos_delta = 0;
2038 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2039 const char *proto = avio_find_protocol_name(s->filename);
2042 av_log(s, AV_LOG_INFO,
2043 "Protocol name not provided, cannot determine if input is local or "
2044 "a network protocol, buffers and access patterns cannot be configured "
2045 "optimally without knowing the protocol\n");
2048 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2051 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2052 AVStream *st1 = s->streams[ist1];
2053 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2054 AVStream *st2 = s->streams[ist2];
2060 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2061 AVIndexEntry *e1 = &st1->index_entries[i1];
2062 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2064 skip = FFMAX(skip, e1->size);
2065 for (; i2 < st2->nb_index_entries; i2++) {
2066 AVIndexEntry *e2 = &st2->index_entries[i2];
2067 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2068 if (e2_pts - e1_pts < time_tolerance)
2070 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2078 /* XXX This could be adjusted depending on protocol*/
2079 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2080 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2081 ffio_set_buf_size(s->pb, pos_delta);
2082 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2085 if (skip < (1<<23)) {
2086 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2090 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2092 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2093 wanted_timestamp, flags);
2096 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2097 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2099 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2100 if (stream_index >= 0)
2101 ts = wrap_timestamp(s->streams[stream_index], ts);
2105 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2106 int64_t target_ts, int flags)
2108 AVInputFormat *avif = s->iformat;
2109 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2110 int64_t ts_min, ts_max, ts;
2115 if (stream_index < 0)
2118 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2121 ts_min = AV_NOPTS_VALUE;
2122 pos_limit = -1; // GCC falsely says it may be uninitialized.
2124 st = s->streams[stream_index];
2125 if (st->index_entries) {
2128 /* FIXME: Whole function must be checked for non-keyframe entries in
2129 * index case, especially read_timestamp(). */
2130 index = av_index_search_timestamp(st, target_ts,
2131 flags | AVSEEK_FLAG_BACKWARD);
2132 index = FFMAX(index, 0);
2133 e = &st->index_entries[index];
2135 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2137 ts_min = e->timestamp;
2138 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2139 pos_min, av_ts2str(ts_min));
2141 av_assert1(index == 0);
2144 index = av_index_search_timestamp(st, target_ts,
2145 flags & ~AVSEEK_FLAG_BACKWARD);
2146 av_assert0(index < st->nb_index_entries);
2148 e = &st->index_entries[index];
2149 av_assert1(e->timestamp >= target_ts);
2151 ts_max = e->timestamp;
2152 pos_limit = pos_max - e->min_distance;
2153 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2154 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2158 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2159 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2164 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2167 ff_read_frame_flush(s);
2168 ff_update_cur_dts(s, st, ts);
2173 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2174 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2176 int64_t step = 1024;
2177 int64_t limit, ts_max;
2178 int64_t filesize = avio_size(s->pb);
2179 int64_t pos_max = filesize - 1;
2182 pos_max = FFMAX(0, (pos_max) - step);
2183 ts_max = ff_read_timestamp(s, stream_index,
2184 &pos_max, limit, read_timestamp);
2186 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2187 if (ts_max == AV_NOPTS_VALUE)
2191 int64_t tmp_pos = pos_max + 1;
2192 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2193 &tmp_pos, INT64_MAX, read_timestamp);
2194 if (tmp_ts == AV_NOPTS_VALUE)
2196 av_assert0(tmp_pos > pos_max);
2199 if (tmp_pos >= filesize)
2211 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2212 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2213 int64_t ts_min, int64_t ts_max,
2214 int flags, int64_t *ts_ret,
2215 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2216 int64_t *, int64_t))
2223 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2225 if (ts_min == AV_NOPTS_VALUE) {
2226 pos_min = s->internal->data_offset;
2227 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2228 if (ts_min == AV_NOPTS_VALUE)
2232 if (ts_min >= target_ts) {
2237 if (ts_max == AV_NOPTS_VALUE) {
2238 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2240 pos_limit = pos_max;
2243 if (ts_max <= target_ts) {
2248 av_assert0(ts_min < ts_max);
2251 while (pos_min < pos_limit) {
2252 av_log(s, AV_LOG_TRACE,
2253 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2254 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2255 av_assert0(pos_limit <= pos_max);
2257 if (no_change == 0) {
2258 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2259 // interpolate position (better than dichotomy)
2260 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2262 pos_min - approximate_keyframe_distance;
2263 } else if (no_change == 1) {
2264 // bisection if interpolation did not change min / max pos last time
2265 pos = (pos_min + pos_limit) >> 1;
2267 /* linear search if bisection failed, can only happen if there
2268 * are very few or no keyframes between min/max */
2273 else if (pos > pos_limit)
2277 // May pass pos_limit instead of -1.
2278 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2283 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2284 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2285 pos_min, pos, pos_max,
2286 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2287 pos_limit, start_pos, no_change);
2288 if (ts == AV_NOPTS_VALUE) {
2289 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2292 if (target_ts <= ts) {
2293 pos_limit = start_pos - 1;
2297 if (target_ts >= ts) {
2303 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2304 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2307 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2309 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2310 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2311 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2317 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2318 int64_t pos, int flags)
2320 int64_t pos_min, pos_max;
2322 pos_min = s->internal->data_offset;
2323 pos_max = avio_size(s->pb) - 1;
2327 else if (pos > pos_max)
2330 avio_seek(s->pb, pos, SEEK_SET);
2332 s->io_repositioned = 1;
2337 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2338 int64_t timestamp, int flags)
2345 st = s->streams[stream_index];
2347 index = av_index_search_timestamp(st, timestamp, flags);
2349 if (index < 0 && st->nb_index_entries &&
2350 timestamp < st->index_entries[0].timestamp)
2353 if (index < 0 || index == st->nb_index_entries - 1) {
2357 if (st->nb_index_entries) {
2358 av_assert0(st->index_entries);
2359 ie = &st->index_entries[st->nb_index_entries - 1];
2360 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2362 ff_update_cur_dts(s, st, ie->timestamp);
2364 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2370 read_status = av_read_frame(s, &pkt);
2371 } while (read_status == AVERROR(EAGAIN));
2372 if (read_status < 0)
2374 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2375 if (pkt.flags & AV_PKT_FLAG_KEY) {
2376 av_packet_unref(&pkt);
2379 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2380 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);
2381 av_packet_unref(&pkt);
2385 av_packet_unref(&pkt);
2387 index = av_index_search_timestamp(st, timestamp, flags);
2392 ff_read_frame_flush(s);
2393 if (s->iformat->read_seek)
2394 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2396 ie = &st->index_entries[index];
2397 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2399 ff_update_cur_dts(s, st, ie->timestamp);
2404 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2405 int64_t timestamp, int flags)
2410 if (flags & AVSEEK_FLAG_BYTE) {
2411 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2413 ff_read_frame_flush(s);
2414 return seek_frame_byte(s, stream_index, timestamp, flags);
2417 if (stream_index < 0) {
2418 stream_index = av_find_default_stream_index(s);
2419 if (stream_index < 0)
2422 st = s->streams[stream_index];
2423 /* timestamp for default must be expressed in AV_TIME_BASE units */
2424 timestamp = av_rescale(timestamp, st->time_base.den,
2425 AV_TIME_BASE * (int64_t) st->time_base.num);
2428 /* first, we try the format specific seek */
2429 if (s->iformat->read_seek) {
2430 ff_read_frame_flush(s);
2431 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2437 if (s->iformat->read_timestamp &&
2438 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2439 ff_read_frame_flush(s);
2440 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2441 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2442 ff_read_frame_flush(s);
2443 return seek_frame_generic(s, stream_index, timestamp, flags);
2448 int av_seek_frame(AVFormatContext *s, int stream_index,
2449 int64_t timestamp, int flags)
2453 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2454 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2455 if ((flags & AVSEEK_FLAG_BACKWARD))
2459 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2460 flags & ~AVSEEK_FLAG_BACKWARD);
2463 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2466 ret = avformat_queue_attached_pictures(s);
2471 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2472 int64_t ts, int64_t max_ts, int flags)
2474 if (min_ts > ts || max_ts < ts)
2476 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2477 return AVERROR(EINVAL);
2480 flags |= AVSEEK_FLAG_ANY;
2481 flags &= ~AVSEEK_FLAG_BACKWARD;
2483 if (s->iformat->read_seek2) {
2485 ff_read_frame_flush(s);
2487 if (stream_index == -1 && s->nb_streams == 1) {
2488 AVRational time_base = s->streams[0]->time_base;
2489 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2490 min_ts = av_rescale_rnd(min_ts, time_base.den,
2491 time_base.num * (int64_t)AV_TIME_BASE,
2492 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2493 max_ts = av_rescale_rnd(max_ts, time_base.den,
2494 time_base.num * (int64_t)AV_TIME_BASE,
2495 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2499 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2503 ret = avformat_queue_attached_pictures(s);
2507 if (s->iformat->read_timestamp) {
2508 // try to seek via read_timestamp()
2511 // Fall back on old API if new is not implemented but old is.
2512 // Note the old API has somewhat different semantics.
2513 if (s->iformat->read_seek || 1) {
2514 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2515 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2516 if (ret<0 && ts != min_ts && max_ts != ts) {
2517 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2519 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2524 // try some generic seek like seek_frame_generic() but with new ts semantics
2525 return -1; //unreachable
2528 int avformat_flush(AVFormatContext *s)
2530 ff_read_frame_flush(s);
2534 /*******************************************************/
2537 * Return TRUE if the stream has accurate duration in any stream.
2539 * @return TRUE if the stream has accurate duration for at least one component.
2541 static int has_duration(AVFormatContext *ic)
2546 for (i = 0; i < ic->nb_streams; i++) {
2547 st = ic->streams[i];
2548 if (st->duration != AV_NOPTS_VALUE)
2551 if (ic->duration != AV_NOPTS_VALUE)
2557 * Estimate the stream timings from the one of each components.
2559 * Also computes the global bitrate if possible.
2561 static void update_stream_timings(AVFormatContext *ic)
2563 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2564 int64_t duration, duration1, filesize;
2569 start_time = INT64_MAX;
2570 start_time_text = INT64_MAX;
2571 end_time = INT64_MIN;
2572 end_time_text = INT64_MIN;
2573 duration = INT64_MIN;
2574 for (i = 0; i < ic->nb_streams; i++) {
2575 st = ic->streams[i];
2576 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2577 start_time1 = av_rescale_q(st->start_time, st->time_base,
2579 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2580 if (start_time1 < start_time_text)
2581 start_time_text = start_time1;
2583 start_time = FFMIN(start_time, start_time1);
2584 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2586 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2587 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2588 end_time1 += start_time1;
2589 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2590 end_time_text = FFMAX(end_time_text, end_time1);
2592 end_time = FFMAX(end_time, end_time1);
2594 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2595 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2596 p->start_time = start_time1;
2597 if (p->end_time < end_time1)
2598 p->end_time = end_time1;
2601 if (st->duration != AV_NOPTS_VALUE) {
2602 duration1 = av_rescale_q(st->duration, st->time_base,
2604 duration = FFMAX(duration, duration1);
2607 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2608 start_time = start_time_text;
2609 else if (start_time > start_time_text)
2610 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2612 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2613 end_time = end_time_text;
2614 } else if (end_time < end_time_text) {
2615 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2618 if (start_time != INT64_MAX) {
2619 ic->start_time = start_time;
2620 if (end_time != INT64_MIN) {
2621 if (ic->nb_programs > 1) {
2622 for (i = 0; i < ic->nb_programs; i++) {
2623 p = ic->programs[i];
2624 if (p->start_time != AV_NOPTS_VALUE &&
2625 p->end_time > p->start_time &&
2626 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2627 duration = FFMAX(duration, p->end_time - p->start_time);
2629 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2630 duration = FFMAX(duration, end_time - start_time);
2634 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2635 ic->duration = duration;
2637 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2638 /* compute the bitrate */
2639 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2640 (double) ic->duration;
2641 if (bitrate >= 0 && bitrate <= INT64_MAX)
2642 ic->bit_rate = bitrate;
2646 static void fill_all_stream_timings(AVFormatContext *ic)
2651 update_stream_timings(ic);
2652 for (i = 0; i < ic->nb_streams; i++) {
2653 st = ic->streams[i];
2654 if (st->start_time == AV_NOPTS_VALUE) {
2655 if (ic->start_time != AV_NOPTS_VALUE)
2656 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2658 if (ic->duration != AV_NOPTS_VALUE)
2659 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2665 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2667 int64_t filesize, duration;
2668 int i, show_warning = 0;
2671 /* if bit_rate is already set, we believe it */
2672 if (ic->bit_rate <= 0) {
2673 int64_t bit_rate = 0;
2674 for (i = 0; i < ic->nb_streams; i++) {
2675 st = ic->streams[i];
2676 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2677 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2678 if (st->codecpar->bit_rate > 0) {
2679 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2683 bit_rate += st->codecpar->bit_rate;
2684 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2685 // If we have a videostream with packets but without a bitrate
2686 // then consider the sum not known
2691 ic->bit_rate = bit_rate;
2694 /* if duration is already set, we believe it */
2695 if (ic->duration == AV_NOPTS_VALUE &&
2696 ic->bit_rate != 0) {
2697 filesize = ic->pb ? avio_size(ic->pb) : 0;
2698 if (filesize > ic->internal->data_offset) {
2699 filesize -= ic->internal->data_offset;
2700 for (i = 0; i < ic->nb_streams; i++) {
2701 st = ic->streams[i];
2702 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2703 && st->duration == AV_NOPTS_VALUE) {
2704 duration = av_rescale(8 * filesize, st->time_base.den,
2706 (int64_t) st->time_base.num);
2707 st->duration = duration;
2714 av_log(ic, AV_LOG_WARNING,
2715 "Estimating duration from bitrate, this may be inaccurate\n");
2718 #define DURATION_MAX_READ_SIZE 250000LL
2719 #define DURATION_MAX_RETRY 6
2721 /* only usable for MPEG-PS streams */
2722 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2724 AVPacket pkt1, *pkt = &pkt1;
2726 int num, den, read_size, i, ret;
2727 int found_duration = 0;
2729 int64_t filesize, offset, duration;
2732 /* flush packet queue */
2733 flush_packet_queue(ic);
2735 for (i = 0; i < ic->nb_streams; i++) {
2736 st = ic->streams[i];
2737 if (st->start_time == AV_NOPTS_VALUE &&
2738 st->first_dts == AV_NOPTS_VALUE &&
2739 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2740 av_log(ic, AV_LOG_WARNING,
2741 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2744 av_parser_close(st->parser);
2749 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2750 /* estimate the end time (duration) */
2751 /* XXX: may need to support wrapping */
2752 filesize = ic->pb ? avio_size(ic->pb) : 0;
2754 is_end = found_duration;
2755 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2759 avio_seek(ic->pb, offset, SEEK_SET);
2762 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2766 ret = ff_read_packet(ic, pkt);
2767 } while (ret == AVERROR(EAGAIN));
2770 read_size += pkt->size;
2771 st = ic->streams[pkt->stream_index];
2772 if (pkt->pts != AV_NOPTS_VALUE &&
2773 (st->start_time != AV_NOPTS_VALUE ||
2774 st->first_dts != AV_NOPTS_VALUE)) {
2775 if (pkt->duration == 0) {
2776 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2778 pkt->duration = av_rescale_rnd(1,
2779 num * (int64_t) st->time_base.den,
2780 den * (int64_t) st->time_base.num,
2784 duration = pkt->pts + pkt->duration;
2786 if (st->start_time != AV_NOPTS_VALUE)
2787 duration -= st->start_time;
2789 duration -= st->first_dts;
2791 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2792 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2793 st->duration = duration;
2794 st->info->last_duration = duration;
2797 av_packet_unref(pkt);
2800 /* check if all audio/video streams have valid duration */
2803 for (i = 0; i < ic->nb_streams; i++) {
2804 st = ic->streams[i];
2805 switch (st->codecpar->codec_type) {
2806 case AVMEDIA_TYPE_VIDEO:
2807 case AVMEDIA_TYPE_AUDIO:
2808 if (st->duration == AV_NOPTS_VALUE)
2815 ++retry <= DURATION_MAX_RETRY);
2817 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2819 /* warn about audio/video streams which duration could not be estimated */
2820 for (i = 0; i < ic->nb_streams; i++) {
2821 st = ic->streams[i];
2822 if (st->duration == AV_NOPTS_VALUE) {
2823 switch (st->codecpar->codec_type) {
2824 case AVMEDIA_TYPE_VIDEO:
2825 case AVMEDIA_TYPE_AUDIO:
2826 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2827 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2829 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2833 fill_all_stream_timings(ic);
2835 avio_seek(ic->pb, old_offset, SEEK_SET);
2836 for (i = 0; i < ic->nb_streams; i++) {
2839 st = ic->streams[i];
2840 st->cur_dts = st->first_dts;
2841 st->last_IP_pts = AV_NOPTS_VALUE;
2842 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2843 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2844 st->pts_buffer[j] = AV_NOPTS_VALUE;
2848 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2852 /* get the file size, if possible */
2853 if (ic->iformat->flags & AVFMT_NOFILE) {
2856 file_size = avio_size(ic->pb);
2857 file_size = FFMAX(0, file_size);
2860 if ((!strcmp(ic->iformat->name, "mpeg") ||
2861 !strcmp(ic->iformat->name, "mpegts")) &&
2862 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2863 /* get accurate estimate from the PTSes */
2864 estimate_timings_from_pts(ic, old_offset);
2865 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2866 } else if (has_duration(ic)) {
2867 /* at least one component has timings - we use them for all
2869 fill_all_stream_timings(ic);
2870 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2872 /* less precise: use bitrate info */
2873 estimate_timings_from_bit_rate(ic);
2874 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2876 update_stream_timings(ic);
2880 AVStream av_unused *st;
2881 for (i = 0; i < ic->nb_streams; i++) {
2882 st = ic->streams[i];
2883 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2884 (double) st->start_time * av_q2d(st->time_base),
2885 (double) st->duration * av_q2d(st->time_base));
2887 av_log(ic, AV_LOG_TRACE,
2888 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2889 (double) ic->start_time / AV_TIME_BASE,
2890 (double) ic->duration / AV_TIME_BASE,
2891 (int64_t)ic->bit_rate / 1000);
2895 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2897 AVCodecContext *avctx = st->internal->avctx;
2899 #define FAIL(errmsg) do { \
2901 *errmsg_ptr = errmsg; \
2905 if ( avctx->codec_id == AV_CODEC_ID_NONE
2906 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2907 FAIL("unknown codec");
2908 switch (avctx->codec_type) {
2909 case AVMEDIA_TYPE_AUDIO:
2910 if (!avctx->frame_size && determinable_frame_size(avctx))
2911 FAIL("unspecified frame size");
2912 if (st->info->found_decoder >= 0 &&
2913 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2914 FAIL("unspecified sample format");
2915 if (!avctx->sample_rate)
2916 FAIL("unspecified sample rate");
2917 if (!avctx->channels)
2918 FAIL("unspecified number of channels");
2919 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2920 FAIL("no decodable DTS frames");
2922 case AVMEDIA_TYPE_VIDEO:
2924 FAIL("unspecified size");
2925 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2926 FAIL("unspecified pixel format");
2927 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2928 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2929 FAIL("no frame in rv30/40 and no sar");
2931 case AVMEDIA_TYPE_SUBTITLE:
2932 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2933 FAIL("unspecified size");
2935 case AVMEDIA_TYPE_DATA:
2936 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2942 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2943 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2944 AVDictionary **options)
2946 AVCodecContext *avctx = st->internal->avctx;
2947 const AVCodec *codec;
2948 int got_picture = 1, ret = 0;
2949 AVFrame *frame = av_frame_alloc();
2950 AVSubtitle subtitle;
2951 AVPacket pkt = *avpkt;
2952 int do_skip_frame = 0;
2953 enum AVDiscard skip_frame;
2956 return AVERROR(ENOMEM);
2958 if (!avcodec_is_open(avctx) &&
2959 st->info->found_decoder <= 0 &&
2960 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2961 AVDictionary *thread_opt = NULL;
2963 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2966 st->info->found_decoder = -st->codecpar->codec_id;
2971 /* Force thread count to 1 since the H.264 decoder will not extract
2972 * SPS and PPS to extradata during multi-threaded decoding. */
2973 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2974 if (s->codec_whitelist)
2975 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2976 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2978 av_dict_free(&thread_opt);
2980 st->info->found_decoder = -avctx->codec_id;
2983 st->info->found_decoder = 1;
2984 } else if (!st->info->found_decoder)
2985 st->info->found_decoder = 1;
2987 if (st->info->found_decoder < 0) {
2992 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2994 skip_frame = avctx->skip_frame;
2995 avctx->skip_frame = AVDISCARD_ALL;
2998 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3000 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3001 (!st->codec_info_nb_frames &&
3002 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3004 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3005 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3006 ret = avcodec_send_packet(avctx, &pkt);
3007 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3011 ret = avcodec_receive_frame(avctx, frame);
3014 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3016 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3017 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3018 &got_picture, &pkt);
3024 st->nb_decoded_frames++;
3029 if (!pkt.data && !got_picture)
3033 if (do_skip_frame) {
3034 avctx->skip_frame = skip_frame;
3037 av_frame_free(&frame);
3041 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3043 while (tags->id != AV_CODEC_ID_NONE) {
3051 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3054 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3055 if (tag == tags[i].tag)
3057 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3058 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3060 return AV_CODEC_ID_NONE;
3063 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3065 if (bps <= 0 || bps > 64)
3066 return AV_CODEC_ID_NONE;
3071 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3073 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3075 return AV_CODEC_ID_NONE;
3080 if (sflags & (1 << (bps - 1))) {
3083 return AV_CODEC_ID_PCM_S8;
3085 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3087 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3089 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3091 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3093 return AV_CODEC_ID_NONE;
3098 return AV_CODEC_ID_PCM_U8;
3100 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3102 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3104 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3106 return AV_CODEC_ID_NONE;
3112 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3115 if (!av_codec_get_tag2(tags, id, &tag))
3120 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3124 for (i = 0; tags && tags[i]; i++) {
3125 const AVCodecTag *codec_tags = tags[i];
3126 while (codec_tags->id != AV_CODEC_ID_NONE) {
3127 if (codec_tags->id == id) {
3128 *tag = codec_tags->tag;
3137 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3140 for (i = 0; tags && tags[i]; i++) {
3141 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3142 if (id != AV_CODEC_ID_NONE)
3145 return AV_CODEC_ID_NONE;
3148 static void compute_chapters_end(AVFormatContext *s)
3151 int64_t max_time = 0;
3153 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3154 max_time = s->duration +
3155 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3157 for (i = 0; i < s->nb_chapters; i++)
3158 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3159 AVChapter *ch = s->chapters[i];
3160 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3164 for (j = 0; j < s->nb_chapters; j++) {
3165 AVChapter *ch1 = s->chapters[j];
3166 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3168 if (j != i && next_start > ch->start && next_start < end)
3171 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3175 static int get_std_framerate(int i)
3178 return (i + 1) * 1001;
3182 return (i + 31) * 1001 * 12;
3186 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3190 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3193 /* Is the time base unreliable?
3194 * This is a heuristic to balance between quick acceptance of the values in
3195 * the headers vs. some extra checks.
3196 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3197 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3198 * And there are "variable" fps files this needs to detect as well. */
3199 static int tb_unreliable(AVCodecContext *c)
3201 if (c->time_base.den >= 101LL * c->time_base.num ||
3202 c->time_base.den < 5LL * c->time_base.num ||
3203 // c->codec_tag == AV_RL32("DIVX") ||
3204 // c->codec_tag == AV_RL32("XVID") ||
3205 c->codec_tag == AV_RL32("mp4v") ||
3206 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3207 c->codec_id == AV_CODEC_ID_GIF ||
3208 c->codec_id == AV_CODEC_ID_HEVC ||
3209 c->codec_id == AV_CODEC_ID_H264)
3214 int ff_alloc_extradata(AVCodecParameters *par, int size)
3218 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3219 par->extradata = NULL;
3220 par->extradata_size = 0;
3221 return AVERROR(EINVAL);
3223 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3224 if (par->extradata) {
3225 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3226 par->extradata_size = size;
3229 par->extradata_size = 0;
3230 ret = AVERROR(ENOMEM);
3235 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3237 int ret = ff_alloc_extradata(par, size);
3240 ret = avio_read(pb, par->extradata, size);
3242 av_freep(&par->extradata);
3243 par->extradata_size = 0;
3244 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3245 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3251 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3254 int64_t last = st->info->last_dts;
3256 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3257 && ts - (uint64_t)last < INT64_MAX) {
3258 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3259 int64_t duration = ts - last;
3261 if (!st->info->duration_error)
3262 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3263 if (!st->info->duration_error)
3264 return AVERROR(ENOMEM);
3266 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3267 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3268 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3269 if (st->info->duration_error[0][1][i] < 1e10) {
3270 int framerate = get_std_framerate(i);
3271 double sdts = dts*framerate/(1001*12);
3272 for (j= 0; j<2; j++) {
3273 int64_t ticks = llrint(sdts+j*0.5);
3274 double error= sdts - ticks + j*0.5;
3275 st->info->duration_error[j][0][i] += error;
3276 st->info->duration_error[j][1][i] += error*error;
3280 st->info->duration_count++;
3281 st->info->rfps_duration_sum += duration;
3283 if (st->info->duration_count % 10 == 0) {
3284 int n = st->info->duration_count;
3285 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3286 if (st->info->duration_error[0][1][i] < 1e10) {
3287 double a0 = st->info->duration_error[0][0][i] / n;
3288 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3289 double a1 = st->info->duration_error[1][0][i] / n;
3290 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3291 if (error0 > 0.04 && error1 > 0.04) {
3292 st->info->duration_error[0][1][i] = 2e10;
3293 st->info->duration_error[1][1][i] = 2e10;
3299 // ignore the first 4 values, they might have some random jitter
3300 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3301 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3303 if (ts != AV_NOPTS_VALUE)
3304 st->info->last_dts = ts;
3309 void ff_rfps_calculate(AVFormatContext *ic)
3313 for (i = 0; i < ic->nb_streams; i++) {
3314 AVStream *st = ic->streams[i];
3316 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3318 // the check for tb_unreliable() is not completely correct, since this is not about handling
3319 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3320 // ipmovie.c produces.
3321 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)
3322 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);
3323 if (st->info->duration_count>1 && !st->r_frame_rate.num
3324 && tb_unreliable(st->internal->avctx)) {
3326 double best_error= 0.01;
3327 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3329 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3332 if (st->info->codec_info_duration &&
3333 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3335 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3338 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3341 for (k= 0; k<2; k++) {
3342 int n = st->info->duration_count;
3343 double a= st->info->duration_error[k][0][j] / n;
3344 double error= st->info->duration_error[k][1][j]/n - a*a;
3346 if (error < best_error && best_error> 0.000000001) {
3348 num = get_std_framerate(j);
3351 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3354 // do not increase frame rate by more than 1 % in order to match a standard rate.
3355 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3356 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3358 if ( !st->avg_frame_rate.num
3359 && st->r_frame_rate.num && st->info->rfps_duration_sum
3360 && st->info->codec_info_duration <= 0
3361 && st->info->duration_count > 2
3362 && 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
3364 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3365 st->avg_frame_rate = st->r_frame_rate;
3368 av_freep(&st->info->duration_error);
3369 st->info->last_dts = AV_NOPTS_VALUE;
3370 st->info->duration_count = 0;
3371 st->info->rfps_duration_sum = 0;
3375 static int extract_extradata_check(AVStream *st)
3377 const AVBitStreamFilter *f;
3379 f = av_bsf_get_by_name("extract_extradata");
3384 const enum AVCodecID *ids;
3385 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3386 if (*ids == st->codecpar->codec_id)
3393 static int extract_extradata_init(AVStream *st)
3395 AVStreamInternal *i = st->internal;
3396 const AVBitStreamFilter *f;
3399 f = av_bsf_get_by_name("extract_extradata");
3403 /* check that the codec id is supported */
3404 ret = extract_extradata_check(st);
3408 i->extract_extradata.pkt = av_packet_alloc();
3409 if (!i->extract_extradata.pkt)
3410 return AVERROR(ENOMEM);
3412 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3416 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3421 i->extract_extradata.bsf->time_base_in = st->time_base;
3423 /* if init fails here, we assume extracting extradata is just not
3424 * supported for this codec, so we return success */
3425 ret = av_bsf_init(i->extract_extradata.bsf);
3427 av_bsf_free(&i->extract_extradata.bsf);
3432 i->extract_extradata.inited = 1;
3436 av_bsf_free(&i->extract_extradata.bsf);
3437 av_packet_free(&i->extract_extradata.pkt);
3441 static int extract_extradata(AVStream *st, AVPacket *pkt)
3443 AVStreamInternal *i = st->internal;
3447 if (!i->extract_extradata.inited) {
3448 ret = extract_extradata_init(st);
3453 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3456 pkt_ref = i->extract_extradata.pkt;
3457 ret = av_packet_ref(pkt_ref, pkt);
3461 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3463 av_packet_unref(pkt_ref);
3467 while (ret >= 0 && !i->avctx->extradata) {
3471 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3473 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3478 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3482 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3483 if (!i->avctx->extradata) {
3484 av_packet_unref(pkt_ref);
3485 return AVERROR(ENOMEM);
3487 memcpy(i->avctx->extradata, extradata, extradata_size);
3488 i->avctx->extradata_size = extradata_size;
3490 av_packet_unref(pkt_ref);
3496 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3498 int i, count = 0, ret = 0, j;
3501 AVCodecContext *avctx;
3502 AVPacket pkt1, *pkt;
3503 int64_t old_offset = avio_tell(ic->pb);
3504 // new streams might appear, no options for those
3505 int orig_nb_streams = ic->nb_streams;
3507 int64_t max_analyze_duration = ic->max_analyze_duration;
3508 int64_t max_stream_analyze_duration;
3509 int64_t max_subtitle_analyze_duration;
3510 int64_t probesize = ic->probesize;
3511 int eof_reached = 0;
3512 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3514 flush_codecs = probesize > 0;
3516 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3518 max_stream_analyze_duration = max_analyze_duration;
3519 max_subtitle_analyze_duration = max_analyze_duration;
3520 if (!max_analyze_duration) {
3521 max_stream_analyze_duration =
3522 max_analyze_duration = 5*AV_TIME_BASE;
3523 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3524 if (!strcmp(ic->iformat->name, "flv"))
3525 max_stream_analyze_duration = 90*AV_TIME_BASE;
3526 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3527 max_stream_analyze_duration = 7*AV_TIME_BASE;
3531 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3532 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3534 for (i = 0; i < ic->nb_streams; i++) {
3535 const AVCodec *codec;
3536 AVDictionary *thread_opt = NULL;
3537 st = ic->streams[i];
3538 avctx = st->internal->avctx;
3540 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3541 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3542 /* if (!st->time_base.num)
3544 if (!avctx->time_base.num)
3545 avctx->time_base = st->time_base;
3548 /* check if the caller has overridden the codec id */
3549 #if FF_API_LAVF_AVCTX
3550 FF_DISABLE_DEPRECATION_WARNINGS
3551 if (st->codec->codec_id != st->internal->orig_codec_id) {
3552 st->codecpar->codec_id = st->codec->codec_id;
3553 st->codecpar->codec_type = st->codec->codec_type;
3554 st->internal->orig_codec_id = st->codec->codec_id;
3556 FF_ENABLE_DEPRECATION_WARNINGS
3558 // only for the split stuff
3559 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3560 st->parser = av_parser_init(st->codecpar->codec_id);
3562 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3563 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3564 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3565 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3567 } else if (st->need_parsing) {
3568 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3569 "%s, packets or times may be invalid.\n",
3570 avcodec_get_name(st->codecpar->codec_id));
3574 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3575 st->internal->orig_codec_id = st->codecpar->codec_id;
3577 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3579 goto find_stream_info_err;
3580 if (st->request_probe <= 0)
3581 st->internal->avctx_inited = 1;
3583 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3585 /* Force thread count to 1 since the H.264 decoder will not extract
3586 * SPS and PPS to extradata during multi-threaded decoding. */
3587 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3589 if (ic->codec_whitelist)
3590 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3592 /* Ensure that subtitle_header is properly set. */
3593 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3594 && codec && !avctx->codec) {
3595 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3596 av_log(ic, AV_LOG_WARNING,
3597 "Failed to open codec in %s\n",__FUNCTION__);
3600 // Try to just open decoders, in case this is enough to get parameters.
3601 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3602 if (codec && !avctx->codec)
3603 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3604 av_log(ic, AV_LOG_WARNING,
3605 "Failed to open codec in %s\n",__FUNCTION__);
3608 av_dict_free(&thread_opt);
3611 for (i = 0; i < ic->nb_streams; i++) {
3612 #if FF_API_R_FRAME_RATE
3613 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3615 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3616 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3621 int analyzed_all_streams;
3622 if (ff_check_interrupt(&ic->interrupt_callback)) {
3624 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3628 /* check if one codec still needs to be handled */
3629 for (i = 0; i < ic->nb_streams; i++) {
3630 int fps_analyze_framecount = 20;
3633 st = ic->streams[i];
3634 if (!has_codec_parameters(st, NULL))
3636 /* If the timebase is coarse (like the usual millisecond precision
3637 * of mkv), we need to analyze more frames to reliably arrive at
3638 * the correct fps. */
3639 if (av_q2d(st->time_base) > 0.0005)
3640 fps_analyze_framecount *= 2;
3641 if (!tb_unreliable(st->internal->avctx))
3642 fps_analyze_framecount = 0;
3643 if (ic->fps_probe_size >= 0)
3644 fps_analyze_framecount = ic->fps_probe_size;
3645 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3646 fps_analyze_framecount = 0;
3647 /* variable fps and no guess at the real fps */
3648 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3649 st->info->codec_info_duration_fields/2 :
3650 st->info->duration_count;
3651 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3652 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3653 if (count < fps_analyze_framecount)
3656 // Look at the first 3 frames if there is evidence of frame delay
3657 // but the decoder delay is not set.
3658 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3660 if (!st->internal->avctx->extradata &&
3661 (!st->internal->extract_extradata.inited ||
3662 st->internal->extract_extradata.bsf) &&
3663 extract_extradata_check(st))
3665 if (st->first_dts == AV_NOPTS_VALUE &&
3666 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3667 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3668 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3669 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3672 analyzed_all_streams = 0;
3673 if (!missing_streams || !*missing_streams)
3674 if (i == ic->nb_streams) {
3675 analyzed_all_streams = 1;
3676 /* NOTE: If the format has no header, then we need to read some
3677 * packets to get most of the streams, so we cannot stop here. */
3678 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3679 /* If we found the info for all the codecs, we can stop. */
3681 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3686 /* We did not get all the codec info, but we read too much data. */
3687 if (read_size >= probesize) {
3689 av_log(ic, AV_LOG_DEBUG,
3690 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3691 for (i = 0; i < ic->nb_streams; i++)
3692 if (!ic->streams[i]->r_frame_rate.num &&
3693 ic->streams[i]->info->duration_count <= 1 &&
3694 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3695 strcmp(ic->iformat->name, "image2"))
3696 av_log(ic, AV_LOG_WARNING,
3697 "Stream #%d: not enough frames to estimate rate; "
3698 "consider increasing probesize\n", i);
3702 /* NOTE: A new stream can be added there if no header in file
3703 * (AVFMTCTX_NOHEADER). */
3704 ret = read_frame_internal(ic, &pkt1);
3705 if (ret == AVERROR(EAGAIN))
3716 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3717 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3718 &ic->internal->packet_buffer_end, 0);
3720 goto find_stream_info_err;
3723 st = ic->streams[pkt->stream_index];
3724 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3725 read_size += pkt->size;
3727 avctx = st->internal->avctx;
3728 if (!st->internal->avctx_inited) {
3729 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3731 goto find_stream_info_err;
3732 st->internal->avctx_inited = 1;
3735 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3736 /* check for non-increasing dts */
3737 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3738 st->info->fps_last_dts >= pkt->dts) {
3739 av_log(ic, AV_LOG_DEBUG,
3740 "Non-increasing DTS in stream %d: packet %d with DTS "
3741 "%"PRId64", packet %d with DTS %"PRId64"\n",
3742 st->index, st->info->fps_last_dts_idx,
3743 st->info->fps_last_dts, st->codec_info_nb_frames,
3745 st->info->fps_first_dts =
3746 st->info->fps_last_dts = AV_NOPTS_VALUE;
3748 /* Check for a discontinuity in dts. If the difference in dts
3749 * is more than 1000 times the average packet duration in the
3750 * sequence, we treat it as a discontinuity. */
3751 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3752 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3753 (pkt->dts - st->info->fps_last_dts) / 1000 >
3754 (st->info->fps_last_dts - st->info->fps_first_dts) /
3755 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3756 av_log(ic, AV_LOG_WARNING,
3757 "DTS discontinuity in stream %d: packet %d with DTS "
3758 "%"PRId64", packet %d with DTS %"PRId64"\n",
3759 st->index, st->info->fps_last_dts_idx,
3760 st->info->fps_last_dts, st->codec_info_nb_frames,
3762 st->info->fps_first_dts =
3763 st->info->fps_last_dts = AV_NOPTS_VALUE;
3766 /* update stored dts values */
3767 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3768 st->info->fps_first_dts = pkt->dts;
3769 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3771 st->info->fps_last_dts = pkt->dts;
3772 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3774 if (st->codec_info_nb_frames>1) {
3778 if (st->time_base.den > 0)
3779 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3780 if (st->avg_frame_rate.num > 0)
3781 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3784 && st->codec_info_nb_frames>30
3785 && st->info->fps_first_dts != AV_NOPTS_VALUE
3786 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3787 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3789 if (analyzed_all_streams) limit = max_analyze_duration;
3790 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3791 else limit = max_stream_analyze_duration;
3794 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3796 t, pkt->stream_index);
3797 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3798 av_packet_unref(pkt);
3801 if (pkt->duration) {
3802 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3803 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3805 st->info->codec_info_duration += pkt->duration;
3806 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3809 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3810 #if FF_API_R_FRAME_RATE
3811 ff_rfps_add_frame(ic, st, pkt->dts);
3813 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3814 st->info->frame_delay_evidence = 1;
3816 if (!st->internal->avctx->extradata) {
3817 ret = extract_extradata(st, pkt);
3819 goto find_stream_info_err;
3822 /* If still no information, we try to open the codec and to
3823 * decompress the frame. We try to avoid that in most cases as
3824 * it takes longer and uses more memory. For MPEG-4, we need to
3825 * decompress for QuickTime.
3827 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3828 * least one frame of codec data, this makes sure the codec initializes
3829 * the channel configuration and does not only trust the values from
3831 try_decode_frame(ic, st, pkt,
3832 (options && i < orig_nb_streams) ? &options[i] : NULL);
3834 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3835 av_packet_unref(pkt);
3837 st->codec_info_nb_frames++;
3843 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3844 st = ic->streams[stream_index];
3845 avctx = st->internal->avctx;
3846 if (!has_codec_parameters(st, NULL)) {
3847 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3848 if (codec && !avctx->codec) {
3849 AVDictionary *opts = NULL;
3850 if (ic->codec_whitelist)
3851 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3852 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3853 av_log(ic, AV_LOG_WARNING,
3854 "Failed to open codec in %s\n",__FUNCTION__);
3855 av_dict_free(&opts);
3859 // EOF already reached while reading the stream above.
3860 // So continue with reoordering DTS with whatever delay we have.
3861 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3862 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3868 AVPacket empty_pkt = { 0 };
3870 av_init_packet(&empty_pkt);
3872 for (i = 0; i < ic->nb_streams; i++) {
3874 st = ic->streams[i];
3876 /* flush the decoders */
3877 if (st->info->found_decoder == 1) {
3879 err = try_decode_frame(ic, st, &empty_pkt,
3880 (options && i < orig_nb_streams)
3881 ? &options[i] : NULL);
3882 } while (err > 0 && !has_codec_parameters(st, NULL));
3885 av_log(ic, AV_LOG_INFO,
3886 "decoding for stream %d failed\n", st->index);
3892 ff_rfps_calculate(ic);
3894 for (i = 0; i < ic->nb_streams; i++) {
3895 st = ic->streams[i];
3896 avctx = st->internal->avctx;
3897 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3898 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3899 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3900 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3901 avctx->codec_tag= tag;
3904 /* estimate average framerate if not set by demuxer */
3905 if (st->info->codec_info_duration_fields &&
3906 !st->avg_frame_rate.num &&
3907 st->info->codec_info_duration) {
3909 double best_error = 0.01;
3910 AVRational codec_frame_rate = avctx->framerate;
3912 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3913 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3914 st->info->codec_info_duration < 0)
3916 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3917 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3918 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3920 /* Round guessed framerate to a "standard" framerate if it's
3921 * within 1% of the original estimate. */
3922 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3923 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3924 double error = fabs(av_q2d(st->avg_frame_rate) /
3925 av_q2d(std_fps) - 1);
3927 if (error < best_error) {
3929 best_fps = std_fps.num;
3932 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3933 error = fabs(av_q2d(codec_frame_rate) /
3934 av_q2d(std_fps) - 1);
3935 if (error < best_error) {
3937 best_fps = std_fps.num;
3942 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3943 best_fps, 12 * 1001, INT_MAX);
3946 if (!st->r_frame_rate.num) {
3947 if ( avctx->time_base.den * (int64_t) st->time_base.num
3948 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3949 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3950 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3952 st->r_frame_rate.num = st->time_base.den;
3953 st->r_frame_rate.den = st->time_base.num;
3956 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3957 AVRational hw_ratio = { avctx->height, avctx->width };
3958 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3961 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3962 if (!avctx->bits_per_coded_sample)
3963 avctx->bits_per_coded_sample =
3964 av_get_bits_per_sample(avctx->codec_id);
3965 // set stream disposition based on audio service type
3966 switch (avctx->audio_service_type) {
3967 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3968 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3970 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3971 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3973 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3974 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3976 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3977 st->disposition = AV_DISPOSITION_COMMENT;
3979 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3980 st->disposition = AV_DISPOSITION_KARAOKE;
3987 estimate_timings(ic, old_offset);
3989 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3991 if (ret >= 0 && ic->nb_streams)
3992 /* We could not have all the codec parameters before EOF. */
3994 for (i = 0; i < ic->nb_streams; i++) {
3996 st = ic->streams[i];
3998 /* if no packet was ever seen, update context now for has_codec_parameters */
3999 if (!st->internal->avctx_inited) {
4000 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4001 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4002 st->codecpar->format = st->internal->avctx->sample_fmt;
4003 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4005 goto find_stream_info_err;
4007 if (!has_codec_parameters(st, &errmsg)) {
4009 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4010 av_log(ic, AV_LOG_WARNING,
4011 "Could not find codec parameters for stream %d (%s): %s\n"
4012 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4019 compute_chapters_end(ic);
4021 /* update the stream parameters from the internal codec contexts */
4022 for (i = 0; i < ic->nb_streams; i++) {
4023 st = ic->streams[i];
4025 if (st->internal->avctx_inited) {
4026 int orig_w = st->codecpar->width;
4027 int orig_h = st->codecpar->height;
4028 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4030 goto find_stream_info_err;
4032 // The decoder might reduce the video size by the lowres factor.
4033 if (st->internal->avctx->lowres && orig_w) {
4034 st->codecpar->width = orig_w;
4035 st->codecpar->height = orig_h;
4040 #if FF_API_LAVF_AVCTX
4041 FF_DISABLE_DEPRECATION_WARNINGS
4042 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4044 goto find_stream_info_err;
4047 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4048 // by the lowres factor.
4049 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4050 st->codec->lowres = st->internal->avctx->lowres;
4051 st->codec->width = st->internal->avctx->width;
4052 st->codec->height = st->internal->avctx->height;
4056 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4057 st->codec->time_base = st->internal->avctx->time_base;
4058 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4060 st->codec->framerate = st->avg_frame_rate;
4062 if (st->internal->avctx->subtitle_header) {
4063 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4064 if (!st->codec->subtitle_header)
4065 goto find_stream_info_err;
4066 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4067 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4068 st->codec->subtitle_header_size);
4071 // Fields unavailable in AVCodecParameters
4072 st->codec->coded_width = st->internal->avctx->coded_width;
4073 st->codec->coded_height = st->internal->avctx->coded_height;
4074 st->codec->properties = st->internal->avctx->properties;
4075 FF_ENABLE_DEPRECATION_WARNINGS
4078 st->internal->avctx_inited = 0;
4081 find_stream_info_err:
4082 for (i = 0; i < ic->nb_streams; i++) {
4083 st = ic->streams[i];
4085 av_freep(&st->info->duration_error);
4086 avcodec_close(ic->streams[i]->internal->avctx);
4087 av_freep(&ic->streams[i]->info);
4088 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4089 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4092 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4093 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4097 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4101 for (i = 0; i < ic->nb_programs; i++) {
4102 if (ic->programs[i] == last) {
4106 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4107 if (ic->programs[i]->stream_index[j] == s)
4108 return ic->programs[i];
4114 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4115 int wanted_stream_nb, int related_stream,
4116 AVCodec **decoder_ret, int flags)
4118 int i, nb_streams = ic->nb_streams;
4119 int ret = AVERROR_STREAM_NOT_FOUND;
4120 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4121 int count, multiframe, disposition;
4122 int64_t best_bitrate = -1;
4124 unsigned *program = NULL;
4125 const AVCodec *decoder = NULL, *best_decoder = NULL;
4127 if (related_stream >= 0 && wanted_stream_nb < 0) {
4128 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4130 program = p->stream_index;
4131 nb_streams = p->nb_stream_indexes;
4134 for (i = 0; i < nb_streams; i++) {
4135 int real_stream_index = program ? program[i] : i;
4136 AVStream *st = ic->streams[real_stream_index];
4137 AVCodecParameters *par = st->codecpar;
4138 if (par->codec_type != type)
4140 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4142 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4145 decoder = find_decoder(ic, st, par->codec_id);
4148 ret = AVERROR_DECODER_NOT_FOUND;
4152 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4153 count = st->codec_info_nb_frames;
4154 bitrate = par->bit_rate;
4155 multiframe = FFMIN(5, count);
4156 if ((best_disposition > disposition) ||
4157 (best_disposition == disposition && best_multiframe > multiframe) ||
4158 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4159 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4161 best_disposition = disposition;
4163 best_bitrate = bitrate;
4164 best_multiframe = multiframe;
4165 ret = real_stream_index;
4166 best_decoder = decoder;
4167 if (program && i == nb_streams - 1 && ret < 0) {
4169 nb_streams = ic->nb_streams;
4170 /* no related stream found, try again with everything */
4175 *decoder_ret = (AVCodec*)best_decoder;
4179 /*******************************************************/
4181 int av_read_play(AVFormatContext *s)
4183 if (s->iformat->read_play)
4184 return s->iformat->read_play(s);
4186 return avio_pause(s->pb, 0);
4187 return AVERROR(ENOSYS);
4190 int av_read_pause(AVFormatContext *s)
4192 if (s->iformat->read_pause)
4193 return s->iformat->read_pause(s);
4195 return avio_pause(s->pb, 1);
4196 return AVERROR(ENOSYS);
4199 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4204 dst->time_base = src->time_base;
4205 dst->nb_frames = src->nb_frames;
4206 dst->disposition = src->disposition;
4207 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4208 dst->avg_frame_rate = src->avg_frame_rate;
4209 dst->r_frame_rate = src->r_frame_rate;
4211 av_dict_free(&dst->metadata);
4212 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4216 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4220 /* Free existing side data*/
4221 for (i = 0; i < dst->nb_side_data; i++)
4222 av_free(dst->side_data[i].data);
4223 av_freep(&dst->side_data);
4224 dst->nb_side_data = 0;
4226 /* Copy side data if present */
4227 if (src->nb_side_data) {
4228 dst->side_data = av_mallocz_array(src->nb_side_data,
4229 sizeof(AVPacketSideData));
4230 if (!dst->side_data)
4231 return AVERROR(ENOMEM);
4232 dst->nb_side_data = src->nb_side_data;
4234 for (i = 0; i < src->nb_side_data; i++) {
4235 uint8_t *data = av_memdup(src->side_data[i].data,
4236 src->side_data[i].size);
4238 return AVERROR(ENOMEM);
4239 dst->side_data[i].type = src->side_data[i].type;
4240 dst->side_data[i].size = src->side_data[i].size;
4241 dst->side_data[i].data = data;
4245 av_freep(&dst->recommended_encoder_configuration);
4246 if (src->recommended_encoder_configuration) {
4247 const char *conf_str = src->recommended_encoder_configuration;
4248 dst->recommended_encoder_configuration = av_strdup(conf_str);
4249 if (!dst->recommended_encoder_configuration)
4250 return AVERROR(ENOMEM);
4256 static void free_stream(AVStream **pst)
4258 AVStream *st = *pst;
4264 for (i = 0; i < st->nb_side_data; i++)
4265 av_freep(&st->side_data[i].data);
4266 av_freep(&st->side_data);
4269 av_parser_close(st->parser);
4271 if (st->attached_pic.data)
4272 av_packet_unref(&st->attached_pic);
4275 avcodec_free_context(&st->internal->avctx);
4276 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4277 av_bsf_free(&st->internal->bsfcs[i]);
4278 av_freep(&st->internal->bsfcs);
4280 av_freep(&st->internal->priv_pts);
4281 av_bsf_free(&st->internal->extract_extradata.bsf);
4282 av_packet_free(&st->internal->extract_extradata.pkt);
4284 av_freep(&st->internal);
4286 av_dict_free(&st->metadata);
4287 avcodec_parameters_free(&st->codecpar);
4288 av_freep(&st->probe_data.buf);
4289 av_freep(&st->index_entries);
4290 #if FF_API_LAVF_AVCTX
4291 FF_DISABLE_DEPRECATION_WARNINGS
4292 avcodec_free_context(&st->codec);
4293 FF_ENABLE_DEPRECATION_WARNINGS
4295 av_freep(&st->priv_data);
4297 av_freep(&st->info->duration_error);
4298 av_freep(&st->info);
4299 av_freep(&st->recommended_encoder_configuration);
4304 void ff_free_stream(AVFormatContext *s, AVStream *st)
4306 av_assert0(s->nb_streams>0);
4307 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4309 free_stream(&s->streams[ --s->nb_streams ]);
4312 void avformat_free_context(AVFormatContext *s)
4320 if (s->iformat && s->iformat->priv_class && s->priv_data)
4321 av_opt_free(s->priv_data);
4322 if (s->oformat && s->oformat->priv_class && s->priv_data)
4323 av_opt_free(s->priv_data);
4325 for (i = s->nb_streams - 1; i >= 0; i--)
4326 ff_free_stream(s, s->streams[i]);
4329 for (i = s->nb_programs - 1; i >= 0; i--) {
4330 av_dict_free(&s->programs[i]->metadata);
4331 av_freep(&s->programs[i]->stream_index);
4332 av_freep(&s->programs[i]);
4334 av_freep(&s->programs);
4335 av_freep(&s->priv_data);
4336 while (s->nb_chapters--) {
4337 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4338 av_freep(&s->chapters[s->nb_chapters]);
4340 av_freep(&s->chapters);
4341 av_dict_free(&s->metadata);
4342 av_dict_free(&s->internal->id3v2_meta);
4343 av_freep(&s->streams);
4344 flush_packet_queue(s);
4345 av_freep(&s->internal);
4349 void avformat_close_input(AVFormatContext **ps)
4360 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4361 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4364 flush_packet_queue(s);
4367 if (s->iformat->read_close)
4368 s->iformat->read_close(s);
4370 avformat_free_context(s);
4377 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4383 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4384 if (s->max_streams < INT_MAX/sizeof(*streams))
4385 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);
4388 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4391 s->streams = streams;
4393 st = av_mallocz(sizeof(AVStream));
4396 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4400 st->info->last_dts = AV_NOPTS_VALUE;
4402 #if FF_API_LAVF_AVCTX
4403 FF_DISABLE_DEPRECATION_WARNINGS
4404 st->codec = avcodec_alloc_context3(c);
4410 FF_ENABLE_DEPRECATION_WARNINGS
4413 st->internal = av_mallocz(sizeof(*st->internal));
4417 st->codecpar = avcodec_parameters_alloc();
4421 st->internal->avctx = avcodec_alloc_context3(NULL);
4422 if (!st->internal->avctx)
4426 #if FF_API_LAVF_AVCTX
4427 FF_DISABLE_DEPRECATION_WARNINGS
4428 /* no default bitrate if decoding */
4429 st->codec->bit_rate = 0;
4430 FF_ENABLE_DEPRECATION_WARNINGS
4433 /* default pts setting is MPEG-like */
4434 avpriv_set_pts_info(st, 33, 1, 90000);
4435 /* we set the current DTS to 0 so that formats without any timestamps
4436 * but durations get some timestamps, formats with some unknown
4437 * timestamps have their first few packets buffered and the
4438 * timestamps corrected before they are returned to the user */
4439 st->cur_dts = RELATIVE_TS_BASE;
4441 st->cur_dts = AV_NOPTS_VALUE;
4444 st->index = s->nb_streams;
4445 st->start_time = AV_NOPTS_VALUE;
4446 st->duration = AV_NOPTS_VALUE;
4447 st->first_dts = AV_NOPTS_VALUE;
4448 st->probe_packets = MAX_PROBE_PACKETS;
4449 st->pts_wrap_reference = AV_NOPTS_VALUE;
4450 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4452 st->last_IP_pts = AV_NOPTS_VALUE;
4453 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4454 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4455 st->pts_buffer[i] = AV_NOPTS_VALUE;
4457 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4459 #if FF_API_R_FRAME_RATE
4460 st->info->last_dts = AV_NOPTS_VALUE;
4462 st->info->fps_first_dts = AV_NOPTS_VALUE;
4463 st->info->fps_last_dts = AV_NOPTS_VALUE;
4465 st->inject_global_side_data = s->internal->inject_global_side_data;
4467 st->internal->need_context_update = 1;
4469 s->streams[s->nb_streams++] = st;
4476 AVProgram *av_new_program(AVFormatContext *ac, int id)
4478 AVProgram *program = NULL;
4481 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4483 for (i = 0; i < ac->nb_programs; i++)
4484 if (ac->programs[i]->id == id)
4485 program = ac->programs[i];
4488 program = av_mallocz(sizeof(AVProgram));
4491 dynarray_add(&ac->programs, &ac->nb_programs, program);
4492 program->discard = AVDISCARD_NONE;
4495 program->pts_wrap_reference = AV_NOPTS_VALUE;
4496 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4498 program->start_time =
4499 program->end_time = AV_NOPTS_VALUE;
4504 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4505 int64_t start, int64_t end, const char *title)
4507 AVChapter *chapter = NULL;
4510 if (end != AV_NOPTS_VALUE && start > end) {
4511 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4515 for (i = 0; i < s->nb_chapters; i++)
4516 if (s->chapters[i]->id == id)
4517 chapter = s->chapters[i];
4520 chapter = av_mallocz(sizeof(AVChapter));
4523 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4525 av_dict_set(&chapter->metadata, "title", title, 0);
4527 chapter->time_base = time_base;
4528 chapter->start = start;
4534 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4537 AVProgram *program = NULL;
4540 if (idx >= ac->nb_streams) {
4541 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4545 for (i = 0; i < ac->nb_programs; i++) {
4546 if (ac->programs[i]->id != progid)
4548 program = ac->programs[i];
4549 for (j = 0; j < program->nb_stream_indexes; j++)
4550 if (program->stream_index[j] == idx)
4553 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4556 program->stream_index = tmp;
4557 program->stream_index[program->nb_stream_indexes++] = idx;
4562 uint64_t ff_ntp_time(void)
4564 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4567 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4570 char *q, buf1[20], c;
4571 int nd, len, percentd_found;
4583 while (av_isdigit(*p))
4584 nd = nd * 10 + *p++ - '0';
4586 } while (av_isdigit(c));
4592 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4597 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4599 if ((q - buf + len) > buf_size - 1)
4601 memcpy(q, buf1, len);
4609 if ((q - buf) < buf_size - 1)
4613 if (!percentd_found)
4622 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4624 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4627 void av_url_split(char *proto, int proto_size,
4628 char *authorization, int authorization_size,
4629 char *hostname, int hostname_size,
4630 int *port_ptr, char *path, int path_size, const char *url)
4632 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4638 if (authorization_size > 0)
4639 authorization[0] = 0;
4640 if (hostname_size > 0)
4645 /* parse protocol */
4646 if ((p = strchr(url, ':'))) {
4647 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4654 /* no protocol means plain filename */
4655 av_strlcpy(path, url, path_size);
4659 /* separate path from hostname */
4660 ls = strchr(p, '/');
4661 ls2 = strchr(p, '?');
4665 ls = FFMIN(ls, ls2);
4667 av_strlcpy(path, ls, path_size);
4669 ls = &p[strlen(p)]; // XXX
4671 /* the rest is hostname, use that to parse auth/port */
4673 /* authorization (user[:pass]@hostname) */
4675 while ((at = strchr(p, '@')) && at < ls) {
4676 av_strlcpy(authorization, at2,
4677 FFMIN(authorization_size, at + 1 - at2));
4678 p = at + 1; /* skip '@' */
4681 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4683 av_strlcpy(hostname, p + 1,
4684 FFMIN(hostname_size, brk - p));
4685 if (brk[1] == ':' && port_ptr)
4686 *port_ptr = atoi(brk + 2);
4687 } else if ((col = strchr(p, ':')) && col < ls) {
4688 av_strlcpy(hostname, p,
4689 FFMIN(col + 1 - p, hostname_size));
4691 *port_ptr = atoi(col + 1);
4693 av_strlcpy(hostname, p,
4694 FFMIN(ls + 1 - p, hostname_size));
4698 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4701 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4704 'C', 'D', 'E', 'F' };
4705 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4708 'c', 'd', 'e', 'f' };
4709 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4711 for (i = 0; i < s; i++) {
4712 buff[i * 2] = hex_table[src[i] >> 4];
4713 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4719 int ff_hex_to_data(uint8_t *data, const char *p)
4726 p += strspn(p, SPACE_CHARS);
4729 c = av_toupper((unsigned char) *p++);
4730 if (c >= '0' && c <= '9')
4732 else if (c >= 'A' && c <= 'F')
4747 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4748 unsigned int pts_num, unsigned int pts_den)
4751 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4752 if (new_tb.num != pts_num)
4753 av_log(NULL, AV_LOG_DEBUG,
4754 "st:%d removing common factor %d from timebase\n",
4755 s->index, pts_num / new_tb.num);
4757 av_log(NULL, AV_LOG_WARNING,
4758 "st:%d has too large timebase, reducing\n", s->index);
4760 if (new_tb.num <= 0 || new_tb.den <= 0) {
4761 av_log(NULL, AV_LOG_ERROR,
4762 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4763 new_tb.num, new_tb.den,
4767 s->time_base = new_tb;
4768 #if FF_API_LAVF_AVCTX
4769 FF_DISABLE_DEPRECATION_WARNINGS
4770 s->codec->pkt_timebase = new_tb;
4771 FF_ENABLE_DEPRECATION_WARNINGS
4773 s->internal->avctx->pkt_timebase = new_tb;
4774 s->pts_wrap_bits = pts_wrap_bits;
4777 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4780 const char *ptr = str;
4782 /* Parse key=value pairs. */
4785 char *dest = NULL, *dest_end;
4786 int key_len, dest_len = 0;
4788 /* Skip whitespace and potential commas. */
4789 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4796 if (!(ptr = strchr(key, '=')))
4799 key_len = ptr - key;
4801 callback_get_buf(context, key, key_len, &dest, &dest_len);
4802 dest_end = dest + dest_len - 1;
4806 while (*ptr && *ptr != '\"') {
4810 if (dest && dest < dest_end)
4814 if (dest && dest < dest_end)
4822 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4823 if (dest && dest < dest_end)
4831 int ff_find_stream_index(AVFormatContext *s, int id)
4834 for (i = 0; i < s->nb_streams; i++)
4835 if (s->streams[i]->id == id)
4840 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4844 unsigned int codec_tag;
4845 if (ofmt->query_codec)
4846 return ofmt->query_codec(codec_id, std_compliance);
4847 else if (ofmt->codec_tag)
4848 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4849 else if (codec_id == ofmt->video_codec ||
4850 codec_id == ofmt->audio_codec ||
4851 codec_id == ofmt->subtitle_codec ||
4852 codec_id == ofmt->data_codec)
4855 return AVERROR_PATCHWELCOME;
4858 int avformat_network_init(void)
4862 ff_network_inited_globally = 1;
4863 if ((ret = ff_network_init()) < 0)
4865 if ((ret = ff_tls_init()) < 0)
4871 int avformat_network_deinit(void)
4876 ff_network_inited_globally = 0;
4881 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4882 uint64_t channel_layout, int32_t sample_rate,
4883 int32_t width, int32_t height)
4889 return AVERROR(EINVAL);
4892 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4894 if (channel_layout) {
4896 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4900 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4902 if (width || height) {
4904 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4906 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4908 return AVERROR(ENOMEM);
4909 bytestream_put_le32(&data, flags);
4911 bytestream_put_le32(&data, channels);
4913 bytestream_put_le64(&data, channel_layout);
4915 bytestream_put_le32(&data, sample_rate);
4916 if (width || height) {
4917 bytestream_put_le32(&data, width);
4918 bytestream_put_le32(&data, height);
4923 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4925 AVRational undef = {0, 1};
4926 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4927 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4928 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4930 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4931 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4932 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4933 stream_sample_aspect_ratio = undef;
4935 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4936 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4937 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4938 frame_sample_aspect_ratio = undef;
4940 if (stream_sample_aspect_ratio.num)
4941 return stream_sample_aspect_ratio;
4943 return frame_sample_aspect_ratio;
4946 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4948 AVRational fr = st->r_frame_rate;
4949 AVRational codec_fr = st->internal->avctx->framerate;
4950 AVRational avg_fr = st->avg_frame_rate;
4952 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4953 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4958 if (st->internal->avctx->ticks_per_frame > 1) {
4959 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4960 (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))
4967 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4970 if (*spec <= '9' && *spec >= '0') /* opt:index */
4971 return strtol(spec, NULL, 0) == st->index;
4972 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4973 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4974 enum AVMediaType type;
4978 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4979 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4980 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4981 case 'd': type = AVMEDIA_TYPE_DATA; break;
4982 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4983 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4984 default: av_assert0(0);
4986 #if FF_API_LAVF_AVCTX
4987 FF_DISABLE_DEPRECATION_WARNINGS
4988 if (type != st->codecpar->codec_type
4989 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4991 FF_ENABLE_DEPRECATION_WARNINGS
4993 if (type != st->codecpar->codec_type)
4996 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4998 if (*spec++ == ':') { /* possibly followed by :index */
4999 int i, index = strtol(spec, NULL, 0);
5000 for (i = 0; i < s->nb_streams; i++) {
5001 #if FF_API_LAVF_AVCTX
5002 FF_DISABLE_DEPRECATION_WARNINGS
5003 if ((s->streams[i]->codecpar->codec_type == type
5004 || s->streams[i]->codec->codec_type == type
5006 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5008 return i == st->index;
5009 FF_ENABLE_DEPRECATION_WARNINGS
5011 if ((s->streams[i]->codecpar->codec_type == type) &&
5012 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5014 return i == st->index;
5020 } else if (*spec == 'p' && *(spec + 1) == ':') {
5024 prog_id = strtol(spec, &endptr, 0);
5025 for (i = 0; i < s->nb_programs; i++) {
5026 if (s->programs[i]->id != prog_id)
5029 if (*endptr++ == ':') {
5030 int stream_idx = strtol(endptr, NULL, 0);
5031 return stream_idx >= 0 &&
5032 stream_idx < s->programs[i]->nb_stream_indexes &&
5033 st->index == s->programs[i]->stream_index[stream_idx];
5036 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5037 if (st->index == s->programs[i]->stream_index[j])
5041 } else if (*spec == '#' ||
5042 (*spec == 'i' && *(spec + 1) == ':')) {
5045 spec += 1 + (*spec == 'i');
5046 stream_id = strtol(spec, &endptr, 0);
5048 return stream_id == st->id;
5049 } else if (*spec == 'm' && *(spec + 1) == ':') {
5050 AVDictionaryEntry *tag;
5055 val = strchr(spec, ':');
5057 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5059 return AVERROR(ENOMEM);
5061 tag = av_dict_get(st->metadata, key, NULL, 0);
5063 if (!val || !strcmp(tag->value, val + 1))
5072 } else if (*spec == 'u') {
5073 AVCodecParameters *par = st->codecpar;
5074 #if FF_API_LAVF_AVCTX
5075 FF_DISABLE_DEPRECATION_WARNINGS
5076 AVCodecContext *codec = st->codec;
5077 FF_ENABLE_DEPRECATION_WARNINGS
5080 switch (par->codec_type) {
5081 case AVMEDIA_TYPE_AUDIO:
5082 val = par->sample_rate && par->channels;
5083 #if FF_API_LAVF_AVCTX
5084 val = val || (codec->sample_rate && codec->channels);
5086 if (par->format == AV_SAMPLE_FMT_NONE
5087 #if FF_API_LAVF_AVCTX
5088 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5093 case AVMEDIA_TYPE_VIDEO:
5094 val = par->width && par->height;
5095 #if FF_API_LAVF_AVCTX
5096 val = val || (codec->width && codec->height);
5098 if (par->format == AV_PIX_FMT_NONE
5099 #if FF_API_LAVF_AVCTX
5100 && codec->pix_fmt == AV_PIX_FMT_NONE
5105 case AVMEDIA_TYPE_UNKNOWN:
5112 #if FF_API_LAVF_AVCTX
5113 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5115 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5117 } else if (!*spec) /* empty specifier, matches everything */
5120 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5121 return AVERROR(EINVAL);
5124 int ff_generate_avci_extradata(AVStream *st)
5126 static const uint8_t avci100_1080p_extradata[] = {
5128 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5129 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5130 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5131 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5132 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5133 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5134 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5135 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5136 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5138 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5141 static const uint8_t avci100_1080i_extradata[] = {
5143 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5144 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5145 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5146 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5147 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5148 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5149 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5150 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5151 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5152 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5153 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5155 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5158 static const uint8_t avci50_1080p_extradata[] = {
5160 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5161 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5162 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5163 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5164 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5165 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5166 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5167 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5168 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5170 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5173 static const uint8_t avci50_1080i_extradata[] = {
5175 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5176 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5177 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5178 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5179 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5180 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5181 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5182 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5183 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5184 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5185 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5187 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5190 static const uint8_t avci100_720p_extradata[] = {
5192 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5193 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5194 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5195 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5196 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5197 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5198 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5199 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5200 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5201 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5203 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5206 static const uint8_t avci50_720p_extradata[] = {
5208 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5209 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5210 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5211 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5212 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5213 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5214 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5215 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5216 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5218 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5222 const uint8_t *data = NULL;
5225 if (st->codecpar->width == 1920) {
5226 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5227 data = avci100_1080p_extradata;
5228 size = sizeof(avci100_1080p_extradata);
5230 data = avci100_1080i_extradata;
5231 size = sizeof(avci100_1080i_extradata);
5233 } else if (st->codecpar->width == 1440) {
5234 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5235 data = avci50_1080p_extradata;
5236 size = sizeof(avci50_1080p_extradata);
5238 data = avci50_1080i_extradata;
5239 size = sizeof(avci50_1080i_extradata);
5241 } else if (st->codecpar->width == 1280) {
5242 data = avci100_720p_extradata;
5243 size = sizeof(avci100_720p_extradata);
5244 } else if (st->codecpar->width == 960) {
5245 data = avci50_720p_extradata;
5246 size = sizeof(avci50_720p_extradata);
5252 av_freep(&st->codecpar->extradata);
5253 if (ff_alloc_extradata(st->codecpar, size))
5254 return AVERROR(ENOMEM);
5255 memcpy(st->codecpar->extradata, data, size);
5260 uint8_t *av_stream_get_side_data(const AVStream *st,
5261 enum AVPacketSideDataType type, int *size)
5265 for (i = 0; i < st->nb_side_data; i++) {
5266 if (st->side_data[i].type == type) {
5268 *size = st->side_data[i].size;
5269 return st->side_data[i].data;
5275 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5276 uint8_t *data, size_t size)
5278 AVPacketSideData *sd, *tmp;
5281 for (i = 0; i < st->nb_side_data; i++) {
5282 sd = &st->side_data[i];
5284 if (sd->type == type) {
5285 av_freep(&sd->data);
5292 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5293 return AVERROR(ERANGE);
5295 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5297 return AVERROR(ENOMEM);
5300 st->side_data = tmp;
5303 sd = &st->side_data[st->nb_side_data - 1];
5311 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5315 uint8_t *data = av_malloc(size);
5320 ret = av_stream_add_side_data(st, type, data, size);
5329 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5332 const AVBitStreamFilter *bsf;
5334 AVCodecParameters *in_par;
5336 if (!(bsf = av_bsf_get_by_name(name))) {
5337 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5338 return AVERROR_BSF_NOT_FOUND;
5341 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5344 if (st->internal->nb_bsfcs) {
5345 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5346 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5348 in_par = st->codecpar;
5349 bsfc->time_base_in = st->time_base;
5352 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5357 if (args && bsfc->filter->priv_class) {
5358 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5359 const char * shorthand[2] = {NULL};
5362 shorthand[0] = opt->name;
5364 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5370 if ((ret = av_bsf_init(bsfc)) < 0) {
5375 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5380 av_log(NULL, AV_LOG_VERBOSE,
5381 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5382 name, args ? args : "");
5387 FF_DISABLE_DEPRECATION_WARNINGS
5388 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5389 AVBitStreamFilterContext *bsfc)
5393 AVPacket new_pkt = *pkt;
5394 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5395 &new_pkt.data, &new_pkt.size,
5396 pkt->data, pkt->size,
5397 pkt->flags & AV_PKT_FLAG_KEY);
5398 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5399 av_packet_unref(pkt);
5400 memset(pkt, 0, sizeof(*pkt));
5403 if(a == 0 && new_pkt.data != pkt->data) {
5404 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
5406 memcpy(t, new_pkt.data, new_pkt.size);
5407 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5412 a = AVERROR(ENOMEM);
5416 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5417 av_buffer_default_free, NULL, 0);
5419 pkt->side_data = NULL;
5420 pkt->side_data_elems = 0;
5421 av_packet_unref(pkt);
5423 av_freep(&new_pkt.data);
5424 a = AVERROR(ENOMEM);
5428 av_log(codec, AV_LOG_ERROR,
5429 "Failed to open bitstream filter %s for stream %d with codec %s",
5430 bsfc->filter->name, pkt->stream_index,
5431 codec->codec ? codec->codec->name : "copy");
5441 FF_ENABLE_DEPRECATION_WARNINGS
5444 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5447 return AVERROR(EINVAL);
5449 if (!(s->oformat->flags & AVFMT_NOFILE))
5450 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5454 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5457 s->io_close(s, *pb);
5461 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5463 AVDictionaryEntry *entry;
5464 int64_t parsed_timestamp;
5466 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5467 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5468 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5471 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5478 int ff_standardize_creation_time(AVFormatContext *s)
5481 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5483 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5487 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5492 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5494 if (size != AVPALETTE_SIZE) {
5495 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5496 return AVERROR_INVALIDDATA;
5498 memcpy(palette, side_data, AVPALETTE_SIZE);
5502 if (ret == CONTAINS_PAL) {
5504 for (i = 0; i < AVPALETTE_COUNT; i++)
5505 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5512 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5517 ret = av_bprint_finalize(buf, &str);
5520 if (!av_bprint_is_complete(buf)) {
5522 return AVERROR(ENOMEM);
5525 par->extradata = str;
5526 /* Note: the string is NUL terminated (so extradata can be read as a
5527 * string), but the ending character is not accounted in the size (in
5528 * binary formats you are likely not supposed to mux that character). When
5529 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5531 par->extradata_size = buf->len;
5535 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5536 AVStream *ost, const AVStream *ist,
5537 enum AVTimebaseSource copy_tb)
5539 //TODO: use [io]st->internal->avctx
5540 const AVCodecContext *dec_ctx = ist->codec;
5541 AVCodecContext *enc_ctx = ost->codec;
5543 enc_ctx->time_base = ist->time_base;
5545 * Avi is a special case here because it supports variable fps but
5546 * having the fps and timebase differe significantly adds quite some
5549 if (!strcmp(ofmt->name, "avi")) {
5550 #if FF_API_R_FRAME_RATE
5551 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5552 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5553 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5554 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5555 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5556 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5557 enc_ctx->time_base.num = ist->r_frame_rate.den;
5558 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5559 enc_ctx->ticks_per_frame = 2;
5562 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5563 && av_q2d(ist->time_base) < 1.0/500
5564 || copy_tb == AVFMT_TBCF_DECODER) {
5565 enc_ctx->time_base = dec_ctx->time_base;
5566 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5567 enc_ctx->time_base.den *= 2;
5568 enc_ctx->ticks_per_frame = 2;
5570 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5571 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5572 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5573 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5574 && av_q2d(ist->time_base) < 1.0/500
5575 || copy_tb == AVFMT_TBCF_DECODER) {
5576 enc_ctx->time_base = dec_ctx->time_base;
5577 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5581 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5582 && dec_ctx->time_base.num < dec_ctx->time_base.den
5583 && dec_ctx->time_base.num > 0
5584 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5585 enc_ctx->time_base = dec_ctx->time_base;
5588 if (ost->avg_frame_rate.num)
5589 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5591 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5592 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5597 AVRational av_stream_get_codec_timebase(const AVStream *st)
5599 // See avformat_transfer_internal_stream_timing_info() TODO.
5600 #if FF_API_LAVF_AVCTX
5601 FF_DISABLE_DEPRECATION_WARNINGS
5602 return st->codec->time_base;
5603 FF_ENABLE_DEPRECATION_WARNINGS
5605 return st->internal->avctx->time_base;