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;
1462 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1463 out_pkt.pos = st->parser->frame_offset;
1465 if (st->parser->key_frame == 1 ||
1466 (st->parser->key_frame == -1 &&
1467 st->parser->pict_type == AV_PICTURE_TYPE_I))
1468 out_pkt.flags |= AV_PKT_FLAG_KEY;
1470 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1471 out_pkt.flags |= AV_PKT_FLAG_KEY;
1473 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1475 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1476 &s->internal->parse_queue_end, 1);
1477 av_packet_unref(&out_pkt);
1482 /* end of the stream => close and free the parser */
1483 if (pkt == &flush_pkt) {
1484 av_parser_close(st->parser);
1489 av_packet_unref(pkt);
1493 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1494 AVPacketList **pkt_buffer_end,
1498 av_assert0(*pkt_buffer);
1501 *pkt_buffer = pktl->next;
1503 *pkt_buffer_end = NULL;
1508 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1510 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1513 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1515 int ret = 0, i, got_packet = 0;
1516 AVDictionary *metadata = NULL;
1518 av_init_packet(pkt);
1520 while (!got_packet && !s->internal->parse_queue) {
1524 /* read next packet */
1525 ret = ff_read_packet(s, &cur_pkt);
1527 if (ret == AVERROR(EAGAIN))
1529 /* flush the parsers */
1530 for (i = 0; i < s->nb_streams; i++) {
1532 if (st->parser && st->need_parsing)
1533 parse_packet(s, NULL, st->index);
1535 /* all remaining packets are now in parse_queue =>
1536 * really terminate parsing */
1540 st = s->streams[cur_pkt.stream_index];
1542 /* update context if required */
1543 if (st->internal->need_context_update) {
1544 if (avcodec_is_open(st->internal->avctx)) {
1545 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1546 avcodec_close(st->internal->avctx);
1547 st->info->found_decoder = 0;
1550 /* close parser, because it depends on the codec */
1551 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1552 av_parser_close(st->parser);
1556 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1560 #if FF_API_LAVF_AVCTX
1561 FF_DISABLE_DEPRECATION_WARNINGS
1562 /* update deprecated public codec context */
1563 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1566 FF_ENABLE_DEPRECATION_WARNINGS
1569 st->internal->need_context_update = 0;
1572 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1573 cur_pkt.dts != AV_NOPTS_VALUE &&
1574 cur_pkt.pts < cur_pkt.dts) {
1575 av_log(s, AV_LOG_WARNING,
1576 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1577 cur_pkt.stream_index,
1578 av_ts2str(cur_pkt.pts),
1579 av_ts2str(cur_pkt.dts),
1582 if (s->debug & FF_FDEBUG_TS)
1583 av_log(s, AV_LOG_DEBUG,
1584 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1585 cur_pkt.stream_index,
1586 av_ts2str(cur_pkt.pts),
1587 av_ts2str(cur_pkt.dts),
1588 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1590 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1591 st->parser = av_parser_init(st->codecpar->codec_id);
1593 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1594 "%s, packets or times may be invalid.\n",
1595 avcodec_get_name(st->codecpar->codec_id));
1596 /* no parser available: just output the raw packets */
1597 st->need_parsing = AVSTREAM_PARSE_NONE;
1598 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1599 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1600 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1601 st->parser->flags |= PARSER_FLAG_ONCE;
1602 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1603 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1606 if (!st->need_parsing || !st->parser) {
1607 /* no parsing needed: we just output the packet as is */
1609 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1610 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1611 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1612 ff_reduce_index(s, st->index);
1613 av_add_index_entry(st, pkt->pos, pkt->dts,
1614 0, 0, AVINDEX_KEYFRAME);
1617 } else if (st->discard < AVDISCARD_ALL) {
1618 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1620 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1621 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1622 st->codecpar->channels = st->internal->avctx->channels;
1623 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1624 st->codecpar->codec_id = st->internal->avctx->codec_id;
1627 av_packet_unref(&cur_pkt);
1629 if (pkt->flags & AV_PKT_FLAG_KEY)
1630 st->skip_to_keyframe = 0;
1631 if (st->skip_to_keyframe) {
1632 av_packet_unref(&cur_pkt);
1640 if (!got_packet && s->internal->parse_queue)
1641 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1644 AVStream *st = s->streams[pkt->stream_index];
1645 int discard_padding = 0;
1646 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1647 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1648 int64_t sample = ts_to_samples(st, pts);
1649 int duration = ts_to_samples(st, pkt->duration);
1650 int64_t end_sample = sample + duration;
1651 if (duration > 0 && end_sample >= st->first_discard_sample &&
1652 sample < st->last_discard_sample)
1653 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1655 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1656 st->skip_samples = st->start_skip_samples;
1657 if (st->skip_samples || discard_padding) {
1658 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1660 AV_WL32(p, st->skip_samples);
1661 AV_WL32(p + 4, discard_padding);
1662 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1664 st->skip_samples = 0;
1667 if (st->inject_global_side_data) {
1668 for (i = 0; i < st->nb_side_data; i++) {
1669 AVPacketSideData *src_sd = &st->side_data[i];
1672 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1675 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1677 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1681 memcpy(dst_data, src_sd->data, src_sd->size);
1683 st->inject_global_side_data = 0;
1687 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1689 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1690 av_dict_copy(&s->metadata, metadata, 0);
1691 av_dict_free(&metadata);
1692 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1695 #if FF_API_LAVF_AVCTX
1696 update_stream_avctx(s);
1699 if (s->debug & FF_FDEBUG_TS)
1700 av_log(s, AV_LOG_DEBUG,
1701 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1702 "size=%d, duration=%"PRId64", flags=%d\n",
1704 av_ts2str(pkt->pts),
1705 av_ts2str(pkt->dts),
1706 pkt->size, pkt->duration, pkt->flags);
1711 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1713 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1719 ret = s->internal->packet_buffer
1720 ? read_from_packet_buffer(&s->internal->packet_buffer,
1721 &s->internal->packet_buffer_end, pkt)
1722 : read_frame_internal(s, pkt);
1729 AVPacketList *pktl = s->internal->packet_buffer;
1732 AVPacket *next_pkt = &pktl->pkt;
1734 if (next_pkt->dts != AV_NOPTS_VALUE) {
1735 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1736 // last dts seen for this stream. if any of packets following
1737 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1738 int64_t last_dts = next_pkt->dts;
1739 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1740 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1741 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1742 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1744 next_pkt->pts = pktl->pkt.dts;
1746 if (last_dts != AV_NOPTS_VALUE) {
1747 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1748 last_dts = pktl->pkt.dts;
1753 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1754 // Fixing the last reference frame had none pts issue (For MXF etc).
1755 // We only do this when
1757 // 2. we are not able to resolve a pts value for current packet.
1758 // 3. the packets for this stream at the end of the files had valid dts.
1759 next_pkt->pts = last_dts + next_pkt->duration;
1761 pktl = s->internal->packet_buffer;
1764 /* read packet from packet buffer, if there is data */
1765 st = s->streams[next_pkt->stream_index];
1766 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1767 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1768 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1769 &s->internal->packet_buffer_end, pkt);
1774 ret = read_frame_internal(s, pkt);
1776 if (pktl && ret != AVERROR(EAGAIN)) {
1783 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1784 &s->internal->packet_buffer_end, 1);
1785 av_packet_unref(pkt);
1792 st = s->streams[pkt->stream_index];
1793 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1794 ff_reduce_index(s, st->index);
1795 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1798 if (is_relative(pkt->dts))
1799 pkt->dts -= RELATIVE_TS_BASE;
1800 if (is_relative(pkt->pts))
1801 pkt->pts -= RELATIVE_TS_BASE;
1806 /* XXX: suppress the packet queue */
1807 static void flush_packet_queue(AVFormatContext *s)
1811 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1812 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1813 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1815 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1818 /*******************************************************/
1821 int av_find_default_stream_index(AVFormatContext *s)
1825 int best_stream = 0;
1826 int best_score = INT_MIN;
1828 if (s->nb_streams <= 0)
1830 for (i = 0; i < s->nb_streams; i++) {
1833 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1834 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1836 if (st->codecpar->width && st->codecpar->height)
1840 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1841 if (st->codecpar->sample_rate)
1844 if (st->codec_info_nb_frames)
1847 if (st->discard != AVDISCARD_ALL)
1850 if (score > best_score) {
1858 /** Flush the frame reader. */
1859 void ff_read_frame_flush(AVFormatContext *s)
1864 flush_packet_queue(s);
1866 /* Reset read state for each stream. */
1867 for (i = 0; i < s->nb_streams; i++) {
1871 av_parser_close(st->parser);
1874 st->last_IP_pts = AV_NOPTS_VALUE;
1875 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1876 if (st->first_dts == AV_NOPTS_VALUE)
1877 st->cur_dts = RELATIVE_TS_BASE;
1879 /* We set the current DTS to an unspecified origin. */
1880 st->cur_dts = AV_NOPTS_VALUE;
1882 st->probe_packets = MAX_PROBE_PACKETS;
1884 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1885 st->pts_buffer[j] = AV_NOPTS_VALUE;
1887 if (s->internal->inject_global_side_data)
1888 st->inject_global_side_data = 1;
1890 st->skip_samples = 0;
1894 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1898 for (i = 0; i < s->nb_streams; i++) {
1899 AVStream *st = s->streams[i];
1902 av_rescale(timestamp,
1903 st->time_base.den * (int64_t) ref_st->time_base.num,
1904 st->time_base.num * (int64_t) ref_st->time_base.den);
1908 void ff_reduce_index(AVFormatContext *s, int stream_index)
1910 AVStream *st = s->streams[stream_index];
1911 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1913 if ((unsigned) st->nb_index_entries >= max_entries) {
1915 for (i = 0; 2 * i < st->nb_index_entries; i++)
1916 st->index_entries[i] = st->index_entries[2 * i];
1917 st->nb_index_entries = i;
1921 int ff_add_index_entry(AVIndexEntry **index_entries,
1922 int *nb_index_entries,
1923 unsigned int *index_entries_allocated_size,
1924 int64_t pos, int64_t timestamp,
1925 int size, int distance, int flags)
1927 AVIndexEntry *entries, *ie;
1930 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1933 if (timestamp == AV_NOPTS_VALUE)
1934 return AVERROR(EINVAL);
1936 if (size < 0 || size > 0x3FFFFFFF)
1937 return AVERROR(EINVAL);
1939 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1940 timestamp -= RELATIVE_TS_BASE;
1942 entries = av_fast_realloc(*index_entries,
1943 index_entries_allocated_size,
1944 (*nb_index_entries + 1) *
1945 sizeof(AVIndexEntry));
1949 *index_entries = entries;
1951 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1952 timestamp, AVSEEK_FLAG_ANY);
1955 index = (*nb_index_entries)++;
1956 ie = &entries[index];
1957 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1959 ie = &entries[index];
1960 if (ie->timestamp != timestamp) {
1961 if (ie->timestamp <= timestamp)
1963 memmove(entries + index + 1, entries + index,
1964 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1965 (*nb_index_entries)++;
1966 } else if (ie->pos == pos && distance < ie->min_distance)
1967 // do not reduce the distance
1968 distance = ie->min_distance;
1972 ie->timestamp = timestamp;
1973 ie->min_distance = distance;
1980 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1981 int size, int distance, int flags)
1983 timestamp = wrap_timestamp(st, timestamp);
1984 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1985 &st->index_entries_allocated_size, pos,
1986 timestamp, size, distance, flags);
1989 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1990 int64_t wanted_timestamp, int flags)
1998 // Optimize appending index entries at the end.
1999 if (b && entries[b - 1].timestamp < wanted_timestamp)
2005 // Search for the next non-discarded packet.
2006 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2008 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2014 timestamp = entries[m].timestamp;
2015 if (timestamp >= wanted_timestamp)
2017 if (timestamp <= wanted_timestamp)
2020 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2022 if (!(flags & AVSEEK_FLAG_ANY))
2023 while (m >= 0 && m < nb_entries &&
2024 !(entries[m].flags & AVINDEX_KEYFRAME))
2025 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2027 if (m == nb_entries)
2032 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2035 int64_t pos_delta = 0;
2037 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2038 const char *proto = avio_find_protocol_name(s->filename);
2041 av_log(s, AV_LOG_INFO,
2042 "Protocol name not provided, cannot determine if input is local or "
2043 "a network protocol, buffers and access patterns cannot be configured "
2044 "optimally without knowing the protocol\n");
2047 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2050 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2051 AVStream *st1 = s->streams[ist1];
2052 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2053 AVStream *st2 = s->streams[ist2];
2059 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2060 AVIndexEntry *e1 = &st1->index_entries[i1];
2061 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2063 skip = FFMAX(skip, e1->size);
2064 for (; i2 < st2->nb_index_entries; i2++) {
2065 AVIndexEntry *e2 = &st2->index_entries[i2];
2066 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2067 if (e2_pts - e1_pts < time_tolerance)
2069 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2077 /* XXX This could be adjusted depending on protocol*/
2078 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2079 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2080 ffio_set_buf_size(s->pb, pos_delta);
2081 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2084 if (skip < (1<<23)) {
2085 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2089 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2091 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2092 wanted_timestamp, flags);
2095 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2096 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2098 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2099 if (stream_index >= 0)
2100 ts = wrap_timestamp(s->streams[stream_index], ts);
2104 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2105 int64_t target_ts, int flags)
2107 AVInputFormat *avif = s->iformat;
2108 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2109 int64_t ts_min, ts_max, ts;
2114 if (stream_index < 0)
2117 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2120 ts_min = AV_NOPTS_VALUE;
2121 pos_limit = -1; // GCC falsely says it may be uninitialized.
2123 st = s->streams[stream_index];
2124 if (st->index_entries) {
2127 /* FIXME: Whole function must be checked for non-keyframe entries in
2128 * index case, especially read_timestamp(). */
2129 index = av_index_search_timestamp(st, target_ts,
2130 flags | AVSEEK_FLAG_BACKWARD);
2131 index = FFMAX(index, 0);
2132 e = &st->index_entries[index];
2134 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2136 ts_min = e->timestamp;
2137 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2138 pos_min, av_ts2str(ts_min));
2140 av_assert1(index == 0);
2143 index = av_index_search_timestamp(st, target_ts,
2144 flags & ~AVSEEK_FLAG_BACKWARD);
2145 av_assert0(index < st->nb_index_entries);
2147 e = &st->index_entries[index];
2148 av_assert1(e->timestamp >= target_ts);
2150 ts_max = e->timestamp;
2151 pos_limit = pos_max - e->min_distance;
2152 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2153 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2157 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2158 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2163 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2166 ff_read_frame_flush(s);
2167 ff_update_cur_dts(s, st, ts);
2172 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2173 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2175 int64_t step = 1024;
2176 int64_t limit, ts_max;
2177 int64_t filesize = avio_size(s->pb);
2178 int64_t pos_max = filesize - 1;
2181 pos_max = FFMAX(0, (pos_max) - step);
2182 ts_max = ff_read_timestamp(s, stream_index,
2183 &pos_max, limit, read_timestamp);
2185 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2186 if (ts_max == AV_NOPTS_VALUE)
2190 int64_t tmp_pos = pos_max + 1;
2191 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2192 &tmp_pos, INT64_MAX, read_timestamp);
2193 if (tmp_ts == AV_NOPTS_VALUE)
2195 av_assert0(tmp_pos > pos_max);
2198 if (tmp_pos >= filesize)
2210 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2211 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2212 int64_t ts_min, int64_t ts_max,
2213 int flags, int64_t *ts_ret,
2214 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2215 int64_t *, int64_t))
2222 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2224 if (ts_min == AV_NOPTS_VALUE) {
2225 pos_min = s->internal->data_offset;
2226 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2227 if (ts_min == AV_NOPTS_VALUE)
2231 if (ts_min >= target_ts) {
2236 if (ts_max == AV_NOPTS_VALUE) {
2237 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2239 pos_limit = pos_max;
2242 if (ts_max <= target_ts) {
2247 av_assert0(ts_min < ts_max);
2250 while (pos_min < pos_limit) {
2251 av_log(s, AV_LOG_TRACE,
2252 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2253 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2254 av_assert0(pos_limit <= pos_max);
2256 if (no_change == 0) {
2257 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2258 // interpolate position (better than dichotomy)
2259 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2261 pos_min - approximate_keyframe_distance;
2262 } else if (no_change == 1) {
2263 // bisection if interpolation did not change min / max pos last time
2264 pos = (pos_min + pos_limit) >> 1;
2266 /* linear search if bisection failed, can only happen if there
2267 * are very few or no keyframes between min/max */
2272 else if (pos > pos_limit)
2276 // May pass pos_limit instead of -1.
2277 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2282 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2283 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2284 pos_min, pos, pos_max,
2285 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2286 pos_limit, start_pos, no_change);
2287 if (ts == AV_NOPTS_VALUE) {
2288 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2291 if (target_ts <= ts) {
2292 pos_limit = start_pos - 1;
2296 if (target_ts >= ts) {
2302 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2303 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2306 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2308 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2309 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2310 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2316 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2317 int64_t pos, int flags)
2319 int64_t pos_min, pos_max;
2321 pos_min = s->internal->data_offset;
2322 pos_max = avio_size(s->pb) - 1;
2326 else if (pos > pos_max)
2329 avio_seek(s->pb, pos, SEEK_SET);
2331 s->io_repositioned = 1;
2336 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2337 int64_t timestamp, int flags)
2344 st = s->streams[stream_index];
2346 index = av_index_search_timestamp(st, timestamp, flags);
2348 if (index < 0 && st->nb_index_entries &&
2349 timestamp < st->index_entries[0].timestamp)
2352 if (index < 0 || index == st->nb_index_entries - 1) {
2356 if (st->nb_index_entries) {
2357 av_assert0(st->index_entries);
2358 ie = &st->index_entries[st->nb_index_entries - 1];
2359 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2361 ff_update_cur_dts(s, st, ie->timestamp);
2363 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2369 read_status = av_read_frame(s, &pkt);
2370 } while (read_status == AVERROR(EAGAIN));
2371 if (read_status < 0)
2373 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2374 if (pkt.flags & AV_PKT_FLAG_KEY) {
2375 av_packet_unref(&pkt);
2378 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2379 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);
2380 av_packet_unref(&pkt);
2384 av_packet_unref(&pkt);
2386 index = av_index_search_timestamp(st, timestamp, flags);
2391 ff_read_frame_flush(s);
2392 if (s->iformat->read_seek)
2393 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2395 ie = &st->index_entries[index];
2396 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2398 ff_update_cur_dts(s, st, ie->timestamp);
2403 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2404 int64_t timestamp, int flags)
2409 if (flags & AVSEEK_FLAG_BYTE) {
2410 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2412 ff_read_frame_flush(s);
2413 return seek_frame_byte(s, stream_index, timestamp, flags);
2416 if (stream_index < 0) {
2417 stream_index = av_find_default_stream_index(s);
2418 if (stream_index < 0)
2421 st = s->streams[stream_index];
2422 /* timestamp for default must be expressed in AV_TIME_BASE units */
2423 timestamp = av_rescale(timestamp, st->time_base.den,
2424 AV_TIME_BASE * (int64_t) st->time_base.num);
2427 /* first, we try the format specific seek */
2428 if (s->iformat->read_seek) {
2429 ff_read_frame_flush(s);
2430 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2436 if (s->iformat->read_timestamp &&
2437 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2438 ff_read_frame_flush(s);
2439 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2440 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2441 ff_read_frame_flush(s);
2442 return seek_frame_generic(s, stream_index, timestamp, flags);
2447 int av_seek_frame(AVFormatContext *s, int stream_index,
2448 int64_t timestamp, int flags)
2452 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2453 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2454 if ((flags & AVSEEK_FLAG_BACKWARD))
2458 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2459 flags & ~AVSEEK_FLAG_BACKWARD);
2462 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2465 ret = avformat_queue_attached_pictures(s);
2470 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2471 int64_t ts, int64_t max_ts, int flags)
2473 if (min_ts > ts || max_ts < ts)
2475 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2476 return AVERROR(EINVAL);
2479 flags |= AVSEEK_FLAG_ANY;
2480 flags &= ~AVSEEK_FLAG_BACKWARD;
2482 if (s->iformat->read_seek2) {
2484 ff_read_frame_flush(s);
2486 if (stream_index == -1 && s->nb_streams == 1) {
2487 AVRational time_base = s->streams[0]->time_base;
2488 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2489 min_ts = av_rescale_rnd(min_ts, time_base.den,
2490 time_base.num * (int64_t)AV_TIME_BASE,
2491 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2492 max_ts = av_rescale_rnd(max_ts, time_base.den,
2493 time_base.num * (int64_t)AV_TIME_BASE,
2494 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2498 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2502 ret = avformat_queue_attached_pictures(s);
2506 if (s->iformat->read_timestamp) {
2507 // try to seek via read_timestamp()
2510 // Fall back on old API if new is not implemented but old is.
2511 // Note the old API has somewhat different semantics.
2512 if (s->iformat->read_seek || 1) {
2513 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2514 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2515 if (ret<0 && ts != min_ts && max_ts != ts) {
2516 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2518 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2523 // try some generic seek like seek_frame_generic() but with new ts semantics
2524 return -1; //unreachable
2527 int avformat_flush(AVFormatContext *s)
2529 ff_read_frame_flush(s);
2533 /*******************************************************/
2536 * Return TRUE if the stream has accurate duration in any stream.
2538 * @return TRUE if the stream has accurate duration for at least one component.
2540 static int has_duration(AVFormatContext *ic)
2545 for (i = 0; i < ic->nb_streams; i++) {
2546 st = ic->streams[i];
2547 if (st->duration != AV_NOPTS_VALUE)
2550 if (ic->duration != AV_NOPTS_VALUE)
2556 * Estimate the stream timings from the one of each components.
2558 * Also computes the global bitrate if possible.
2560 static void update_stream_timings(AVFormatContext *ic)
2562 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2563 int64_t duration, duration1, filesize;
2568 start_time = INT64_MAX;
2569 start_time_text = INT64_MAX;
2570 end_time = INT64_MIN;
2571 end_time_text = INT64_MIN;
2572 duration = INT64_MIN;
2573 for (i = 0; i < ic->nb_streams; i++) {
2574 st = ic->streams[i];
2575 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2576 start_time1 = av_rescale_q(st->start_time, st->time_base,
2578 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2579 if (start_time1 < start_time_text)
2580 start_time_text = start_time1;
2582 start_time = FFMIN(start_time, start_time1);
2583 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2585 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2586 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2587 end_time1 += start_time1;
2588 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2589 end_time_text = FFMAX(end_time_text, end_time1);
2591 end_time = FFMAX(end_time, end_time1);
2593 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2594 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2595 p->start_time = start_time1;
2596 if (p->end_time < end_time1)
2597 p->end_time = end_time1;
2600 if (st->duration != AV_NOPTS_VALUE) {
2601 duration1 = av_rescale_q(st->duration, st->time_base,
2603 duration = FFMAX(duration, duration1);
2606 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2607 start_time = start_time_text;
2608 else if (start_time > start_time_text)
2609 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2611 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2612 end_time = end_time_text;
2613 } else if (end_time < end_time_text) {
2614 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2617 if (start_time != INT64_MAX) {
2618 ic->start_time = start_time;
2619 if (end_time != INT64_MIN) {
2620 if (ic->nb_programs > 1) {
2621 for (i = 0; i < ic->nb_programs; i++) {
2622 p = ic->programs[i];
2623 if (p->start_time != AV_NOPTS_VALUE &&
2624 p->end_time > p->start_time &&
2625 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2626 duration = FFMAX(duration, p->end_time - p->start_time);
2628 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2629 duration = FFMAX(duration, end_time - start_time);
2633 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2634 ic->duration = duration;
2636 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2637 /* compute the bitrate */
2638 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2639 (double) ic->duration;
2640 if (bitrate >= 0 && bitrate <= INT64_MAX)
2641 ic->bit_rate = bitrate;
2645 static void fill_all_stream_timings(AVFormatContext *ic)
2650 update_stream_timings(ic);
2651 for (i = 0; i < ic->nb_streams; i++) {
2652 st = ic->streams[i];
2653 if (st->start_time == AV_NOPTS_VALUE) {
2654 if (ic->start_time != AV_NOPTS_VALUE)
2655 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2657 if (ic->duration != AV_NOPTS_VALUE)
2658 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2664 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2666 int64_t filesize, duration;
2667 int i, show_warning = 0;
2670 /* if bit_rate is already set, we believe it */
2671 if (ic->bit_rate <= 0) {
2672 int64_t bit_rate = 0;
2673 for (i = 0; i < ic->nb_streams; i++) {
2674 st = ic->streams[i];
2675 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2676 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2677 if (st->codecpar->bit_rate > 0) {
2678 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2682 bit_rate += st->codecpar->bit_rate;
2683 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2684 // If we have a videostream with packets but without a bitrate
2685 // then consider the sum not known
2690 ic->bit_rate = bit_rate;
2693 /* if duration is already set, we believe it */
2694 if (ic->duration == AV_NOPTS_VALUE &&
2695 ic->bit_rate != 0) {
2696 filesize = ic->pb ? avio_size(ic->pb) : 0;
2697 if (filesize > ic->internal->data_offset) {
2698 filesize -= ic->internal->data_offset;
2699 for (i = 0; i < ic->nb_streams; i++) {
2700 st = ic->streams[i];
2701 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2702 && st->duration == AV_NOPTS_VALUE) {
2703 duration = av_rescale(8 * filesize, st->time_base.den,
2705 (int64_t) st->time_base.num);
2706 st->duration = duration;
2713 av_log(ic, AV_LOG_WARNING,
2714 "Estimating duration from bitrate, this may be inaccurate\n");
2717 #define DURATION_MAX_READ_SIZE 250000LL
2718 #define DURATION_MAX_RETRY 6
2720 /* only usable for MPEG-PS streams */
2721 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2723 AVPacket pkt1, *pkt = &pkt1;
2725 int num, den, read_size, i, ret;
2726 int found_duration = 0;
2728 int64_t filesize, offset, duration;
2731 /* flush packet queue */
2732 flush_packet_queue(ic);
2734 for (i = 0; i < ic->nb_streams; i++) {
2735 st = ic->streams[i];
2736 if (st->start_time == AV_NOPTS_VALUE &&
2737 st->first_dts == AV_NOPTS_VALUE &&
2738 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2739 av_log(ic, AV_LOG_WARNING,
2740 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2743 av_parser_close(st->parser);
2748 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2749 /* estimate the end time (duration) */
2750 /* XXX: may need to support wrapping */
2751 filesize = ic->pb ? avio_size(ic->pb) : 0;
2753 is_end = found_duration;
2754 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2758 avio_seek(ic->pb, offset, SEEK_SET);
2761 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2765 ret = ff_read_packet(ic, pkt);
2766 } while (ret == AVERROR(EAGAIN));
2769 read_size += pkt->size;
2770 st = ic->streams[pkt->stream_index];
2771 if (pkt->pts != AV_NOPTS_VALUE &&
2772 (st->start_time != AV_NOPTS_VALUE ||
2773 st->first_dts != AV_NOPTS_VALUE)) {
2774 if (pkt->duration == 0) {
2775 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2777 pkt->duration = av_rescale_rnd(1,
2778 num * (int64_t) st->time_base.den,
2779 den * (int64_t) st->time_base.num,
2783 duration = pkt->pts + pkt->duration;
2785 if (st->start_time != AV_NOPTS_VALUE)
2786 duration -= st->start_time;
2788 duration -= st->first_dts;
2790 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2791 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2792 st->duration = duration;
2793 st->info->last_duration = duration;
2796 av_packet_unref(pkt);
2799 /* check if all audio/video streams have valid duration */
2802 for (i = 0; i < ic->nb_streams; i++) {
2803 st = ic->streams[i];
2804 switch (st->codecpar->codec_type) {
2805 case AVMEDIA_TYPE_VIDEO:
2806 case AVMEDIA_TYPE_AUDIO:
2807 if (st->duration == AV_NOPTS_VALUE)
2814 ++retry <= DURATION_MAX_RETRY);
2816 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2818 /* warn about audio/video streams which duration could not be estimated */
2819 for (i = 0; i < ic->nb_streams; i++) {
2820 st = ic->streams[i];
2821 if (st->duration == AV_NOPTS_VALUE) {
2822 switch (st->codecpar->codec_type) {
2823 case AVMEDIA_TYPE_VIDEO:
2824 case AVMEDIA_TYPE_AUDIO:
2825 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2826 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2828 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2832 fill_all_stream_timings(ic);
2834 avio_seek(ic->pb, old_offset, SEEK_SET);
2835 for (i = 0; i < ic->nb_streams; i++) {
2838 st = ic->streams[i];
2839 st->cur_dts = st->first_dts;
2840 st->last_IP_pts = AV_NOPTS_VALUE;
2841 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2842 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2843 st->pts_buffer[j] = AV_NOPTS_VALUE;
2847 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2851 /* get the file size, if possible */
2852 if (ic->iformat->flags & AVFMT_NOFILE) {
2855 file_size = avio_size(ic->pb);
2856 file_size = FFMAX(0, file_size);
2859 if ((!strcmp(ic->iformat->name, "mpeg") ||
2860 !strcmp(ic->iformat->name, "mpegts")) &&
2861 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2862 /* get accurate estimate from the PTSes */
2863 estimate_timings_from_pts(ic, old_offset);
2864 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2865 } else if (has_duration(ic)) {
2866 /* at least one component has timings - we use them for all
2868 fill_all_stream_timings(ic);
2869 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2871 /* less precise: use bitrate info */
2872 estimate_timings_from_bit_rate(ic);
2873 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2875 update_stream_timings(ic);
2879 AVStream av_unused *st;
2880 for (i = 0; i < ic->nb_streams; i++) {
2881 st = ic->streams[i];
2882 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2883 (double) st->start_time * av_q2d(st->time_base),
2884 (double) st->duration * av_q2d(st->time_base));
2886 av_log(ic, AV_LOG_TRACE,
2887 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2888 (double) ic->start_time / AV_TIME_BASE,
2889 (double) ic->duration / AV_TIME_BASE,
2890 (int64_t)ic->bit_rate / 1000);
2894 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2896 AVCodecContext *avctx = st->internal->avctx;
2898 #define FAIL(errmsg) do { \
2900 *errmsg_ptr = errmsg; \
2904 if ( avctx->codec_id == AV_CODEC_ID_NONE
2905 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2906 FAIL("unknown codec");
2907 switch (avctx->codec_type) {
2908 case AVMEDIA_TYPE_AUDIO:
2909 if (!avctx->frame_size && determinable_frame_size(avctx))
2910 FAIL("unspecified frame size");
2911 if (st->info->found_decoder >= 0 &&
2912 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2913 FAIL("unspecified sample format");
2914 if (!avctx->sample_rate)
2915 FAIL("unspecified sample rate");
2916 if (!avctx->channels)
2917 FAIL("unspecified number of channels");
2918 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2919 FAIL("no decodable DTS frames");
2921 case AVMEDIA_TYPE_VIDEO:
2923 FAIL("unspecified size");
2924 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2925 FAIL("unspecified pixel format");
2926 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2927 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2928 FAIL("no frame in rv30/40 and no sar");
2930 case AVMEDIA_TYPE_SUBTITLE:
2931 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2932 FAIL("unspecified size");
2934 case AVMEDIA_TYPE_DATA:
2935 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2941 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2942 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2943 AVDictionary **options)
2945 AVCodecContext *avctx = st->internal->avctx;
2946 const AVCodec *codec;
2947 int got_picture = 1, ret = 0;
2948 AVFrame *frame = av_frame_alloc();
2949 AVSubtitle subtitle;
2950 AVPacket pkt = *avpkt;
2951 int do_skip_frame = 0;
2952 enum AVDiscard skip_frame;
2955 return AVERROR(ENOMEM);
2957 if (!avcodec_is_open(avctx) &&
2958 st->info->found_decoder <= 0 &&
2959 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2960 AVDictionary *thread_opt = NULL;
2962 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2965 st->info->found_decoder = -st->codecpar->codec_id;
2970 /* Force thread count to 1 since the H.264 decoder will not extract
2971 * SPS and PPS to extradata during multi-threaded decoding. */
2972 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2973 if (s->codec_whitelist)
2974 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2975 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2977 av_dict_free(&thread_opt);
2979 st->info->found_decoder = -avctx->codec_id;
2982 st->info->found_decoder = 1;
2983 } else if (!st->info->found_decoder)
2984 st->info->found_decoder = 1;
2986 if (st->info->found_decoder < 0) {
2991 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2993 skip_frame = avctx->skip_frame;
2994 avctx->skip_frame = AVDISCARD_ALL;
2997 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2999 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3000 (!st->codec_info_nb_frames &&
3001 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3003 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3004 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3005 ret = avcodec_send_packet(avctx, &pkt);
3006 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3010 ret = avcodec_receive_frame(avctx, frame);
3013 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3015 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3016 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3017 &got_picture, &pkt);
3023 st->nb_decoded_frames++;
3028 if (!pkt.data && !got_picture)
3032 if (do_skip_frame) {
3033 avctx->skip_frame = skip_frame;
3036 av_frame_free(&frame);
3040 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3042 while (tags->id != AV_CODEC_ID_NONE) {
3050 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3053 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3054 if (tag == tags[i].tag)
3056 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3057 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3059 return AV_CODEC_ID_NONE;
3062 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3064 if (bps <= 0 || bps > 64)
3065 return AV_CODEC_ID_NONE;
3070 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3072 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3074 return AV_CODEC_ID_NONE;
3079 if (sflags & (1 << (bps - 1))) {
3082 return AV_CODEC_ID_PCM_S8;
3084 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3086 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3088 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3090 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3092 return AV_CODEC_ID_NONE;
3097 return AV_CODEC_ID_PCM_U8;
3099 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3101 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3103 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3105 return AV_CODEC_ID_NONE;
3111 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3114 if (!av_codec_get_tag2(tags, id, &tag))
3119 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3123 for (i = 0; tags && tags[i]; i++) {
3124 const AVCodecTag *codec_tags = tags[i];
3125 while (codec_tags->id != AV_CODEC_ID_NONE) {
3126 if (codec_tags->id == id) {
3127 *tag = codec_tags->tag;
3136 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3139 for (i = 0; tags && tags[i]; i++) {
3140 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3141 if (id != AV_CODEC_ID_NONE)
3144 return AV_CODEC_ID_NONE;
3147 static void compute_chapters_end(AVFormatContext *s)
3150 int64_t max_time = 0;
3152 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3153 max_time = s->duration +
3154 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3156 for (i = 0; i < s->nb_chapters; i++)
3157 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3158 AVChapter *ch = s->chapters[i];
3159 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3163 for (j = 0; j < s->nb_chapters; j++) {
3164 AVChapter *ch1 = s->chapters[j];
3165 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3167 if (j != i && next_start > ch->start && next_start < end)
3170 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3174 static int get_std_framerate(int i)
3177 return (i + 1) * 1001;
3181 return (i + 31) * 1001 * 12;
3185 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3189 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3192 /* Is the time base unreliable?
3193 * This is a heuristic to balance between quick acceptance of the values in
3194 * the headers vs. some extra checks.
3195 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3196 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3197 * And there are "variable" fps files this needs to detect as well. */
3198 static int tb_unreliable(AVCodecContext *c)
3200 if (c->time_base.den >= 101LL * c->time_base.num ||
3201 c->time_base.den < 5LL * c->time_base.num ||
3202 // c->codec_tag == AV_RL32("DIVX") ||
3203 // c->codec_tag == AV_RL32("XVID") ||
3204 c->codec_tag == AV_RL32("mp4v") ||
3205 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3206 c->codec_id == AV_CODEC_ID_GIF ||
3207 c->codec_id == AV_CODEC_ID_HEVC ||
3208 c->codec_id == AV_CODEC_ID_H264)
3213 int ff_alloc_extradata(AVCodecParameters *par, int size)
3217 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3218 par->extradata = NULL;
3219 par->extradata_size = 0;
3220 return AVERROR(EINVAL);
3222 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3223 if (par->extradata) {
3224 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3225 par->extradata_size = size;
3228 par->extradata_size = 0;
3229 ret = AVERROR(ENOMEM);
3234 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3236 int ret = ff_alloc_extradata(par, size);
3239 ret = avio_read(pb, par->extradata, size);
3241 av_freep(&par->extradata);
3242 par->extradata_size = 0;
3243 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3244 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3250 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3253 int64_t last = st->info->last_dts;
3255 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3256 && ts - (uint64_t)last < INT64_MAX) {
3257 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3258 int64_t duration = ts - last;
3260 if (!st->info->duration_error)
3261 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3262 if (!st->info->duration_error)
3263 return AVERROR(ENOMEM);
3265 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3266 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3267 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3268 if (st->info->duration_error[0][1][i] < 1e10) {
3269 int framerate = get_std_framerate(i);
3270 double sdts = dts*framerate/(1001*12);
3271 for (j= 0; j<2; j++) {
3272 int64_t ticks = llrint(sdts+j*0.5);
3273 double error= sdts - ticks + j*0.5;
3274 st->info->duration_error[j][0][i] += error;
3275 st->info->duration_error[j][1][i] += error*error;
3279 st->info->duration_count++;
3280 st->info->rfps_duration_sum += duration;
3282 if (st->info->duration_count % 10 == 0) {
3283 int n = st->info->duration_count;
3284 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3285 if (st->info->duration_error[0][1][i] < 1e10) {
3286 double a0 = st->info->duration_error[0][0][i] / n;
3287 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3288 double a1 = st->info->duration_error[1][0][i] / n;
3289 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3290 if (error0 > 0.04 && error1 > 0.04) {
3291 st->info->duration_error[0][1][i] = 2e10;
3292 st->info->duration_error[1][1][i] = 2e10;
3298 // ignore the first 4 values, they might have some random jitter
3299 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3300 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3302 if (ts != AV_NOPTS_VALUE)
3303 st->info->last_dts = ts;
3308 void ff_rfps_calculate(AVFormatContext *ic)
3312 for (i = 0; i < ic->nb_streams; i++) {
3313 AVStream *st = ic->streams[i];
3315 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3317 // the check for tb_unreliable() is not completely correct, since this is not about handling
3318 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3319 // ipmovie.c produces.
3320 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)
3321 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);
3322 if (st->info->duration_count>1 && !st->r_frame_rate.num
3323 && tb_unreliable(st->internal->avctx)) {
3325 double best_error= 0.01;
3326 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3328 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3331 if (st->info->codec_info_duration &&
3332 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3334 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3337 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3340 for (k= 0; k<2; k++) {
3341 int n = st->info->duration_count;
3342 double a= st->info->duration_error[k][0][j] / n;
3343 double error= st->info->duration_error[k][1][j]/n - a*a;
3345 if (error < best_error && best_error> 0.000000001) {
3347 num = get_std_framerate(j);
3350 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3353 // do not increase frame rate by more than 1 % in order to match a standard rate.
3354 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3355 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3357 if ( !st->avg_frame_rate.num
3358 && st->r_frame_rate.num && st->info->rfps_duration_sum
3359 && st->info->codec_info_duration <= 0
3360 && st->info->duration_count > 2
3361 && 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
3363 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3364 st->avg_frame_rate = st->r_frame_rate;
3367 av_freep(&st->info->duration_error);
3368 st->info->last_dts = AV_NOPTS_VALUE;
3369 st->info->duration_count = 0;
3370 st->info->rfps_duration_sum = 0;
3374 static int extract_extradata_check(AVStream *st)
3376 const AVBitStreamFilter *f;
3378 f = av_bsf_get_by_name("extract_extradata");
3383 const enum AVCodecID *ids;
3384 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3385 if (*ids == st->codecpar->codec_id)
3392 static int extract_extradata_init(AVStream *st)
3394 AVStreamInternal *i = st->internal;
3395 const AVBitStreamFilter *f;
3398 f = av_bsf_get_by_name("extract_extradata");
3402 /* check that the codec id is supported */
3403 ret = extract_extradata_check(st);
3407 i->extract_extradata.pkt = av_packet_alloc();
3408 if (!i->extract_extradata.pkt)
3409 return AVERROR(ENOMEM);
3411 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3415 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3420 i->extract_extradata.bsf->time_base_in = st->time_base;
3422 /* if init fails here, we assume extracting extradata is just not
3423 * supported for this codec, so we return success */
3424 ret = av_bsf_init(i->extract_extradata.bsf);
3426 av_bsf_free(&i->extract_extradata.bsf);
3431 i->extract_extradata.inited = 1;
3435 av_bsf_free(&i->extract_extradata.bsf);
3436 av_packet_free(&i->extract_extradata.pkt);
3440 static int extract_extradata(AVStream *st, AVPacket *pkt)
3442 AVStreamInternal *i = st->internal;
3446 if (!i->extract_extradata.inited) {
3447 ret = extract_extradata_init(st);
3452 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3455 pkt_ref = i->extract_extradata.pkt;
3456 ret = av_packet_ref(pkt_ref, pkt);
3460 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3462 av_packet_unref(pkt_ref);
3466 while (ret >= 0 && !i->avctx->extradata) {
3470 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3472 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3477 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3481 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3482 if (!i->avctx->extradata) {
3483 av_packet_unref(pkt_ref);
3484 return AVERROR(ENOMEM);
3486 memcpy(i->avctx->extradata, extradata, extradata_size);
3487 i->avctx->extradata_size = extradata_size;
3489 av_packet_unref(pkt_ref);
3495 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3497 int i, count = 0, ret = 0, j;
3500 AVCodecContext *avctx;
3501 AVPacket pkt1, *pkt;
3502 int64_t old_offset = avio_tell(ic->pb);
3503 // new streams might appear, no options for those
3504 int orig_nb_streams = ic->nb_streams;
3506 int64_t max_analyze_duration = ic->max_analyze_duration;
3507 int64_t max_stream_analyze_duration;
3508 int64_t max_subtitle_analyze_duration;
3509 int64_t probesize = ic->probesize;
3510 int eof_reached = 0;
3511 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3513 flush_codecs = probesize > 0;
3515 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3517 max_stream_analyze_duration = max_analyze_duration;
3518 max_subtitle_analyze_duration = max_analyze_duration;
3519 if (!max_analyze_duration) {
3520 max_stream_analyze_duration =
3521 max_analyze_duration = 5*AV_TIME_BASE;
3522 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3523 if (!strcmp(ic->iformat->name, "flv"))
3524 max_stream_analyze_duration = 90*AV_TIME_BASE;
3525 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3526 max_stream_analyze_duration = 7*AV_TIME_BASE;
3530 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3531 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3533 for (i = 0; i < ic->nb_streams; i++) {
3534 const AVCodec *codec;
3535 AVDictionary *thread_opt = NULL;
3536 st = ic->streams[i];
3537 avctx = st->internal->avctx;
3539 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3540 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3541 /* if (!st->time_base.num)
3543 if (!avctx->time_base.num)
3544 avctx->time_base = st->time_base;
3547 /* check if the caller has overridden the codec id */
3548 #if FF_API_LAVF_AVCTX
3549 FF_DISABLE_DEPRECATION_WARNINGS
3550 if (st->codec->codec_id != st->internal->orig_codec_id) {
3551 st->codecpar->codec_id = st->codec->codec_id;
3552 st->codecpar->codec_type = st->codec->codec_type;
3553 st->internal->orig_codec_id = st->codec->codec_id;
3555 FF_ENABLE_DEPRECATION_WARNINGS
3557 // only for the split stuff
3558 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3559 st->parser = av_parser_init(st->codecpar->codec_id);
3561 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3562 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3563 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3564 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3566 } else if (st->need_parsing) {
3567 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3568 "%s, packets or times may be invalid.\n",
3569 avcodec_get_name(st->codecpar->codec_id));
3573 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3574 st->internal->orig_codec_id = st->codecpar->codec_id;
3576 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3578 goto find_stream_info_err;
3579 if (st->request_probe <= 0)
3580 st->internal->avctx_inited = 1;
3582 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3584 /* Force thread count to 1 since the H.264 decoder will not extract
3585 * SPS and PPS to extradata during multi-threaded decoding. */
3586 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3588 if (ic->codec_whitelist)
3589 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3591 /* Ensure that subtitle_header is properly set. */
3592 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3593 && codec && !avctx->codec) {
3594 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3595 av_log(ic, AV_LOG_WARNING,
3596 "Failed to open codec in %s\n",__FUNCTION__);
3599 // Try to just open decoders, in case this is enough to get parameters.
3600 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3601 if (codec && !avctx->codec)
3602 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3603 av_log(ic, AV_LOG_WARNING,
3604 "Failed to open codec in %s\n",__FUNCTION__);
3607 av_dict_free(&thread_opt);
3610 for (i = 0; i < ic->nb_streams; i++) {
3611 #if FF_API_R_FRAME_RATE
3612 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3614 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3615 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3620 int analyzed_all_streams;
3621 if (ff_check_interrupt(&ic->interrupt_callback)) {
3623 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3627 /* check if one codec still needs to be handled */
3628 for (i = 0; i < ic->nb_streams; i++) {
3629 int fps_analyze_framecount = 20;
3631 st = ic->streams[i];
3632 if (!has_codec_parameters(st, NULL))
3634 /* If the timebase is coarse (like the usual millisecond precision
3635 * of mkv), we need to analyze more frames to reliably arrive at
3636 * the correct fps. */
3637 if (av_q2d(st->time_base) > 0.0005)
3638 fps_analyze_framecount *= 2;
3639 if (!tb_unreliable(st->internal->avctx))
3640 fps_analyze_framecount = 0;
3641 if (ic->fps_probe_size >= 0)
3642 fps_analyze_framecount = ic->fps_probe_size;
3643 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3644 fps_analyze_framecount = 0;
3645 /* variable fps and no guess at the real fps */
3646 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3647 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3648 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3649 st->info->codec_info_duration_fields/2 :
3650 st->info->duration_count;
3651 if (count < fps_analyze_framecount)
3654 if (!st->internal->avctx->extradata &&
3655 (!st->internal->extract_extradata.inited ||
3656 st->internal->extract_extradata.bsf) &&
3657 extract_extradata_check(st))
3659 if (st->first_dts == AV_NOPTS_VALUE &&
3660 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3661 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3662 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3663 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3666 analyzed_all_streams = 0;
3667 if (!missing_streams || !*missing_streams)
3668 if (i == ic->nb_streams) {
3669 analyzed_all_streams = 1;
3670 /* NOTE: If the format has no header, then we need to read some
3671 * packets to get most of the streams, so we cannot stop here. */
3672 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3673 /* If we found the info for all the codecs, we can stop. */
3675 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3680 /* We did not get all the codec info, but we read too much data. */
3681 if (read_size >= probesize) {
3683 av_log(ic, AV_LOG_DEBUG,
3684 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3685 for (i = 0; i < ic->nb_streams; i++)
3686 if (!ic->streams[i]->r_frame_rate.num &&
3687 ic->streams[i]->info->duration_count <= 1 &&
3688 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3689 strcmp(ic->iformat->name, "image2"))
3690 av_log(ic, AV_LOG_WARNING,
3691 "Stream #%d: not enough frames to estimate rate; "
3692 "consider increasing probesize\n", i);
3696 /* NOTE: A new stream can be added there if no header in file
3697 * (AVFMTCTX_NOHEADER). */
3698 ret = read_frame_internal(ic, &pkt1);
3699 if (ret == AVERROR(EAGAIN))
3710 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3711 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3712 &ic->internal->packet_buffer_end, 0);
3714 goto find_stream_info_err;
3717 st = ic->streams[pkt->stream_index];
3718 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3719 read_size += pkt->size;
3721 avctx = st->internal->avctx;
3722 if (!st->internal->avctx_inited) {
3723 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3725 goto find_stream_info_err;
3726 st->internal->avctx_inited = 1;
3729 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3730 /* check for non-increasing dts */
3731 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3732 st->info->fps_last_dts >= pkt->dts) {
3733 av_log(ic, AV_LOG_DEBUG,
3734 "Non-increasing DTS in stream %d: packet %d with DTS "
3735 "%"PRId64", packet %d with DTS %"PRId64"\n",
3736 st->index, st->info->fps_last_dts_idx,
3737 st->info->fps_last_dts, st->codec_info_nb_frames,
3739 st->info->fps_first_dts =
3740 st->info->fps_last_dts = AV_NOPTS_VALUE;
3742 /* Check for a discontinuity in dts. If the difference in dts
3743 * is more than 1000 times the average packet duration in the
3744 * sequence, we treat it as a discontinuity. */
3745 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3746 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3747 (pkt->dts - st->info->fps_last_dts) / 1000 >
3748 (st->info->fps_last_dts - st->info->fps_first_dts) /
3749 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3750 av_log(ic, AV_LOG_WARNING,
3751 "DTS discontinuity in stream %d: packet %d with DTS "
3752 "%"PRId64", packet %d with DTS %"PRId64"\n",
3753 st->index, st->info->fps_last_dts_idx,
3754 st->info->fps_last_dts, st->codec_info_nb_frames,
3756 st->info->fps_first_dts =
3757 st->info->fps_last_dts = AV_NOPTS_VALUE;
3760 /* update stored dts values */
3761 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3762 st->info->fps_first_dts = pkt->dts;
3763 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3765 st->info->fps_last_dts = pkt->dts;
3766 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3768 if (st->codec_info_nb_frames>1) {
3772 if (st->time_base.den > 0)
3773 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3774 if (st->avg_frame_rate.num > 0)
3775 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3778 && st->codec_info_nb_frames>30
3779 && st->info->fps_first_dts != AV_NOPTS_VALUE
3780 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3781 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3783 if (analyzed_all_streams) limit = max_analyze_duration;
3784 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3785 else limit = max_stream_analyze_duration;
3788 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3790 t, pkt->stream_index);
3791 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3792 av_packet_unref(pkt);
3795 if (pkt->duration) {
3796 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3797 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3799 st->info->codec_info_duration += pkt->duration;
3800 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3803 #if FF_API_R_FRAME_RATE
3804 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3805 ff_rfps_add_frame(ic, st, pkt->dts);
3807 if (!st->internal->avctx->extradata) {
3808 ret = extract_extradata(st, pkt);
3810 goto find_stream_info_err;
3813 /* If still no information, we try to open the codec and to
3814 * decompress the frame. We try to avoid that in most cases as
3815 * it takes longer and uses more memory. For MPEG-4, we need to
3816 * decompress for QuickTime.
3818 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3819 * least one frame of codec data, this makes sure the codec initializes
3820 * the channel configuration and does not only trust the values from
3822 try_decode_frame(ic, st, pkt,
3823 (options && i < orig_nb_streams) ? &options[i] : NULL);
3825 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3826 av_packet_unref(pkt);
3828 st->codec_info_nb_frames++;
3834 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3835 st = ic->streams[stream_index];
3836 avctx = st->internal->avctx;
3837 if (!has_codec_parameters(st, NULL)) {
3838 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3839 if (codec && !avctx->codec) {
3840 AVDictionary *opts = NULL;
3841 if (ic->codec_whitelist)
3842 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3843 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3844 av_log(ic, AV_LOG_WARNING,
3845 "Failed to open codec in %s\n",__FUNCTION__);
3846 av_dict_free(&opts);
3850 // EOF already reached while reading the stream above.
3851 // So continue with reoordering DTS with whatever delay we have.
3852 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3853 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3859 AVPacket empty_pkt = { 0 };
3861 av_init_packet(&empty_pkt);
3863 for (i = 0; i < ic->nb_streams; i++) {
3865 st = ic->streams[i];
3867 /* flush the decoders */
3868 if (st->info->found_decoder == 1) {
3870 err = try_decode_frame(ic, st, &empty_pkt,
3871 (options && i < orig_nb_streams)
3872 ? &options[i] : NULL);
3873 } while (err > 0 && !has_codec_parameters(st, NULL));
3876 av_log(ic, AV_LOG_INFO,
3877 "decoding for stream %d failed\n", st->index);
3883 ff_rfps_calculate(ic);
3885 for (i = 0; i < ic->nb_streams; i++) {
3886 st = ic->streams[i];
3887 avctx = st->internal->avctx;
3888 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3889 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3890 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3891 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3892 avctx->codec_tag= tag;
3895 /* estimate average framerate if not set by demuxer */
3896 if (st->info->codec_info_duration_fields &&
3897 !st->avg_frame_rate.num &&
3898 st->info->codec_info_duration) {
3900 double best_error = 0.01;
3901 AVRational codec_frame_rate = avctx->framerate;
3903 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3904 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3905 st->info->codec_info_duration < 0)
3907 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3908 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3909 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3911 /* Round guessed framerate to a "standard" framerate if it's
3912 * within 1% of the original estimate. */
3913 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3914 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3915 double error = fabs(av_q2d(st->avg_frame_rate) /
3916 av_q2d(std_fps) - 1);
3918 if (error < best_error) {
3920 best_fps = std_fps.num;
3923 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3924 error = fabs(av_q2d(codec_frame_rate) /
3925 av_q2d(std_fps) - 1);
3926 if (error < best_error) {
3928 best_fps = std_fps.num;
3933 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3934 best_fps, 12 * 1001, INT_MAX);
3937 if (!st->r_frame_rate.num) {
3938 if ( avctx->time_base.den * (int64_t) st->time_base.num
3939 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3940 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3941 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3943 st->r_frame_rate.num = st->time_base.den;
3944 st->r_frame_rate.den = st->time_base.num;
3947 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3948 AVRational hw_ratio = { avctx->height, avctx->width };
3949 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3952 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3953 if (!avctx->bits_per_coded_sample)
3954 avctx->bits_per_coded_sample =
3955 av_get_bits_per_sample(avctx->codec_id);
3956 // set stream disposition based on audio service type
3957 switch (avctx->audio_service_type) {
3958 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3959 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3961 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3962 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3964 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3965 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3967 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3968 st->disposition = AV_DISPOSITION_COMMENT;
3970 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3971 st->disposition = AV_DISPOSITION_KARAOKE;
3978 estimate_timings(ic, old_offset);
3980 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3982 if (ret >= 0 && ic->nb_streams)
3983 /* We could not have all the codec parameters before EOF. */
3985 for (i = 0; i < ic->nb_streams; i++) {
3987 st = ic->streams[i];
3989 /* if no packet was ever seen, update context now for has_codec_parameters */
3990 if (!st->internal->avctx_inited) {
3991 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3992 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3993 st->codecpar->format = st->internal->avctx->sample_fmt;
3994 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3996 goto find_stream_info_err;
3998 if (!has_codec_parameters(st, &errmsg)) {
4000 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4001 av_log(ic, AV_LOG_WARNING,
4002 "Could not find codec parameters for stream %d (%s): %s\n"
4003 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4010 compute_chapters_end(ic);
4012 /* update the stream parameters from the internal codec contexts */
4013 for (i = 0; i < ic->nb_streams; i++) {
4014 st = ic->streams[i];
4016 if (st->internal->avctx_inited) {
4017 int orig_w = st->codecpar->width;
4018 int orig_h = st->codecpar->height;
4019 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4021 goto find_stream_info_err;
4022 // The decoder might reduce the video size by the lowres factor.
4023 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
4024 st->codecpar->width = orig_w;
4025 st->codecpar->height = orig_h;
4029 #if FF_API_LAVF_AVCTX
4030 FF_DISABLE_DEPRECATION_WARNINGS
4031 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4033 goto find_stream_info_err;
4035 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4036 // by the lowres factor.
4037 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
4038 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
4039 st->codec->width = st->internal->avctx->width;
4040 st->codec->height = st->internal->avctx->height;
4043 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4044 st->codec->time_base = st->internal->avctx->time_base;
4045 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4047 st->codec->framerate = st->avg_frame_rate;
4049 if (st->internal->avctx->subtitle_header) {
4050 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4051 if (!st->codec->subtitle_header)
4052 goto find_stream_info_err;
4053 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4054 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4055 st->codec->subtitle_header_size);
4058 // Fields unavailable in AVCodecParameters
4059 st->codec->coded_width = st->internal->avctx->coded_width;
4060 st->codec->coded_height = st->internal->avctx->coded_height;
4061 st->codec->properties = st->internal->avctx->properties;
4062 FF_ENABLE_DEPRECATION_WARNINGS
4065 st->internal->avctx_inited = 0;
4068 find_stream_info_err:
4069 for (i = 0; i < ic->nb_streams; i++) {
4070 st = ic->streams[i];
4072 av_freep(&st->info->duration_error);
4073 avcodec_close(ic->streams[i]->internal->avctx);
4074 av_freep(&ic->streams[i]->info);
4075 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4076 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4079 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4080 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4084 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4088 for (i = 0; i < ic->nb_programs; i++) {
4089 if (ic->programs[i] == last) {
4093 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4094 if (ic->programs[i]->stream_index[j] == s)
4095 return ic->programs[i];
4101 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4102 int wanted_stream_nb, int related_stream,
4103 AVCodec **decoder_ret, int flags)
4105 int i, nb_streams = ic->nb_streams;
4106 int ret = AVERROR_STREAM_NOT_FOUND;
4107 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4108 int count, multiframe, disposition;
4109 int64_t best_bitrate = -1;
4111 unsigned *program = NULL;
4112 const AVCodec *decoder = NULL, *best_decoder = NULL;
4114 if (related_stream >= 0 && wanted_stream_nb < 0) {
4115 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4117 program = p->stream_index;
4118 nb_streams = p->nb_stream_indexes;
4121 for (i = 0; i < nb_streams; i++) {
4122 int real_stream_index = program ? program[i] : i;
4123 AVStream *st = ic->streams[real_stream_index];
4124 AVCodecParameters *par = st->codecpar;
4125 if (par->codec_type != type)
4127 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4129 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4132 decoder = find_decoder(ic, st, par->codec_id);
4135 ret = AVERROR_DECODER_NOT_FOUND;
4139 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4140 count = st->codec_info_nb_frames;
4141 bitrate = par->bit_rate;
4142 multiframe = FFMIN(5, count);
4143 if ((best_disposition > disposition) ||
4144 (best_disposition == disposition && best_multiframe > multiframe) ||
4145 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4146 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4148 best_disposition = disposition;
4150 best_bitrate = bitrate;
4151 best_multiframe = multiframe;
4152 ret = real_stream_index;
4153 best_decoder = decoder;
4154 if (program && i == nb_streams - 1 && ret < 0) {
4156 nb_streams = ic->nb_streams;
4157 /* no related stream found, try again with everything */
4162 *decoder_ret = (AVCodec*)best_decoder;
4166 /*******************************************************/
4168 int av_read_play(AVFormatContext *s)
4170 if (s->iformat->read_play)
4171 return s->iformat->read_play(s);
4173 return avio_pause(s->pb, 0);
4174 return AVERROR(ENOSYS);
4177 int av_read_pause(AVFormatContext *s)
4179 if (s->iformat->read_pause)
4180 return s->iformat->read_pause(s);
4182 return avio_pause(s->pb, 1);
4183 return AVERROR(ENOSYS);
4186 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4191 dst->time_base = src->time_base;
4192 dst->nb_frames = src->nb_frames;
4193 dst->disposition = src->disposition;
4194 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4195 dst->avg_frame_rate = src->avg_frame_rate;
4196 dst->r_frame_rate = src->r_frame_rate;
4198 av_dict_free(&dst->metadata);
4199 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4203 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4207 /* Free existing side data*/
4208 for (i = 0; i < dst->nb_side_data; i++)
4209 av_free(dst->side_data[i].data);
4210 av_freep(&dst->side_data);
4211 dst->nb_side_data = 0;
4213 /* Copy side data if present */
4214 if (src->nb_side_data) {
4215 dst->side_data = av_mallocz_array(src->nb_side_data,
4216 sizeof(AVPacketSideData));
4217 if (!dst->side_data)
4218 return AVERROR(ENOMEM);
4219 dst->nb_side_data = src->nb_side_data;
4221 for (i = 0; i < src->nb_side_data; i++) {
4222 uint8_t *data = av_memdup(src->side_data[i].data,
4223 src->side_data[i].size);
4225 return AVERROR(ENOMEM);
4226 dst->side_data[i].type = src->side_data[i].type;
4227 dst->side_data[i].size = src->side_data[i].size;
4228 dst->side_data[i].data = data;
4232 av_freep(&dst->recommended_encoder_configuration);
4233 if (src->recommended_encoder_configuration) {
4234 const char *conf_str = src->recommended_encoder_configuration;
4235 dst->recommended_encoder_configuration = av_strdup(conf_str);
4236 if (!dst->recommended_encoder_configuration)
4237 return AVERROR(ENOMEM);
4243 static void free_stream(AVStream **pst)
4245 AVStream *st = *pst;
4251 for (i = 0; i < st->nb_side_data; i++)
4252 av_freep(&st->side_data[i].data);
4253 av_freep(&st->side_data);
4256 av_parser_close(st->parser);
4258 if (st->attached_pic.data)
4259 av_packet_unref(&st->attached_pic);
4262 avcodec_free_context(&st->internal->avctx);
4263 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4264 av_bsf_free(&st->internal->bsfcs[i]);
4265 av_freep(&st->internal->bsfcs);
4267 av_freep(&st->internal->priv_pts);
4268 av_bsf_free(&st->internal->extract_extradata.bsf);
4269 av_packet_free(&st->internal->extract_extradata.pkt);
4271 av_freep(&st->internal);
4273 av_dict_free(&st->metadata);
4274 avcodec_parameters_free(&st->codecpar);
4275 av_freep(&st->probe_data.buf);
4276 av_freep(&st->index_entries);
4277 #if FF_API_LAVF_AVCTX
4278 FF_DISABLE_DEPRECATION_WARNINGS
4279 avcodec_free_context(&st->codec);
4280 FF_ENABLE_DEPRECATION_WARNINGS
4282 av_freep(&st->priv_data);
4284 av_freep(&st->info->duration_error);
4285 av_freep(&st->info);
4286 av_freep(&st->recommended_encoder_configuration);
4291 void ff_free_stream(AVFormatContext *s, AVStream *st)
4293 av_assert0(s->nb_streams>0);
4294 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4296 free_stream(&s->streams[ --s->nb_streams ]);
4299 void avformat_free_context(AVFormatContext *s)
4307 if (s->iformat && s->iformat->priv_class && s->priv_data)
4308 av_opt_free(s->priv_data);
4309 if (s->oformat && s->oformat->priv_class && s->priv_data)
4310 av_opt_free(s->priv_data);
4312 for (i = s->nb_streams - 1; i >= 0; i--)
4313 ff_free_stream(s, s->streams[i]);
4316 for (i = s->nb_programs - 1; i >= 0; i--) {
4317 av_dict_free(&s->programs[i]->metadata);
4318 av_freep(&s->programs[i]->stream_index);
4319 av_freep(&s->programs[i]);
4321 av_freep(&s->programs);
4322 av_freep(&s->priv_data);
4323 while (s->nb_chapters--) {
4324 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4325 av_freep(&s->chapters[s->nb_chapters]);
4327 av_freep(&s->chapters);
4328 av_dict_free(&s->metadata);
4329 av_dict_free(&s->internal->id3v2_meta);
4330 av_freep(&s->streams);
4331 flush_packet_queue(s);
4332 av_freep(&s->internal);
4336 void avformat_close_input(AVFormatContext **ps)
4347 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4348 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4351 flush_packet_queue(s);
4354 if (s->iformat->read_close)
4355 s->iformat->read_close(s);
4357 avformat_free_context(s);
4364 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4370 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4371 if (s->max_streams < INT_MAX/sizeof(*streams))
4372 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);
4375 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4378 s->streams = streams;
4380 st = av_mallocz(sizeof(AVStream));
4383 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4387 st->info->last_dts = AV_NOPTS_VALUE;
4389 #if FF_API_LAVF_AVCTX
4390 FF_DISABLE_DEPRECATION_WARNINGS
4391 st->codec = avcodec_alloc_context3(c);
4397 FF_ENABLE_DEPRECATION_WARNINGS
4400 st->internal = av_mallocz(sizeof(*st->internal));
4404 st->codecpar = avcodec_parameters_alloc();
4408 st->internal->avctx = avcodec_alloc_context3(NULL);
4409 if (!st->internal->avctx)
4413 #if FF_API_LAVF_AVCTX
4414 FF_DISABLE_DEPRECATION_WARNINGS
4415 /* no default bitrate if decoding */
4416 st->codec->bit_rate = 0;
4417 FF_ENABLE_DEPRECATION_WARNINGS
4420 /* default pts setting is MPEG-like */
4421 avpriv_set_pts_info(st, 33, 1, 90000);
4422 /* we set the current DTS to 0 so that formats without any timestamps
4423 * but durations get some timestamps, formats with some unknown
4424 * timestamps have their first few packets buffered and the
4425 * timestamps corrected before they are returned to the user */
4426 st->cur_dts = RELATIVE_TS_BASE;
4428 st->cur_dts = AV_NOPTS_VALUE;
4431 st->index = s->nb_streams;
4432 st->start_time = AV_NOPTS_VALUE;
4433 st->duration = AV_NOPTS_VALUE;
4434 st->first_dts = AV_NOPTS_VALUE;
4435 st->probe_packets = MAX_PROBE_PACKETS;
4436 st->pts_wrap_reference = AV_NOPTS_VALUE;
4437 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4439 st->last_IP_pts = AV_NOPTS_VALUE;
4440 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4441 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4442 st->pts_buffer[i] = AV_NOPTS_VALUE;
4444 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4446 #if FF_API_R_FRAME_RATE
4447 st->info->last_dts = AV_NOPTS_VALUE;
4449 st->info->fps_first_dts = AV_NOPTS_VALUE;
4450 st->info->fps_last_dts = AV_NOPTS_VALUE;
4452 st->inject_global_side_data = s->internal->inject_global_side_data;
4454 st->internal->need_context_update = 1;
4456 s->streams[s->nb_streams++] = st;
4463 AVProgram *av_new_program(AVFormatContext *ac, int id)
4465 AVProgram *program = NULL;
4468 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4470 for (i = 0; i < ac->nb_programs; i++)
4471 if (ac->programs[i]->id == id)
4472 program = ac->programs[i];
4475 program = av_mallocz(sizeof(AVProgram));
4478 dynarray_add(&ac->programs, &ac->nb_programs, program);
4479 program->discard = AVDISCARD_NONE;
4482 program->pts_wrap_reference = AV_NOPTS_VALUE;
4483 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4485 program->start_time =
4486 program->end_time = AV_NOPTS_VALUE;
4491 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4492 int64_t start, int64_t end, const char *title)
4494 AVChapter *chapter = NULL;
4497 if (end != AV_NOPTS_VALUE && start > end) {
4498 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4502 for (i = 0; i < s->nb_chapters; i++)
4503 if (s->chapters[i]->id == id)
4504 chapter = s->chapters[i];
4507 chapter = av_mallocz(sizeof(AVChapter));
4510 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4512 av_dict_set(&chapter->metadata, "title", title, 0);
4514 chapter->time_base = time_base;
4515 chapter->start = start;
4521 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4524 AVProgram *program = NULL;
4527 if (idx >= ac->nb_streams) {
4528 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4532 for (i = 0; i < ac->nb_programs; i++) {
4533 if (ac->programs[i]->id != progid)
4535 program = ac->programs[i];
4536 for (j = 0; j < program->nb_stream_indexes; j++)
4537 if (program->stream_index[j] == idx)
4540 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4543 program->stream_index = tmp;
4544 program->stream_index[program->nb_stream_indexes++] = idx;
4549 uint64_t ff_ntp_time(void)
4551 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4554 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4557 char *q, buf1[20], c;
4558 int nd, len, percentd_found;
4570 while (av_isdigit(*p))
4571 nd = nd * 10 + *p++ - '0';
4573 } while (av_isdigit(c));
4579 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4584 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4586 if ((q - buf + len) > buf_size - 1)
4588 memcpy(q, buf1, len);
4596 if ((q - buf) < buf_size - 1)
4600 if (!percentd_found)
4609 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4611 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4614 void av_url_split(char *proto, int proto_size,
4615 char *authorization, int authorization_size,
4616 char *hostname, int hostname_size,
4617 int *port_ptr, char *path, int path_size, const char *url)
4619 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4625 if (authorization_size > 0)
4626 authorization[0] = 0;
4627 if (hostname_size > 0)
4632 /* parse protocol */
4633 if ((p = strchr(url, ':'))) {
4634 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4641 /* no protocol means plain filename */
4642 av_strlcpy(path, url, path_size);
4646 /* separate path from hostname */
4647 ls = strchr(p, '/');
4648 ls2 = strchr(p, '?');
4652 ls = FFMIN(ls, ls2);
4654 av_strlcpy(path, ls, path_size);
4656 ls = &p[strlen(p)]; // XXX
4658 /* the rest is hostname, use that to parse auth/port */
4660 /* authorization (user[:pass]@hostname) */
4662 while ((at = strchr(p, '@')) && at < ls) {
4663 av_strlcpy(authorization, at2,
4664 FFMIN(authorization_size, at + 1 - at2));
4665 p = at + 1; /* skip '@' */
4668 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4670 av_strlcpy(hostname, p + 1,
4671 FFMIN(hostname_size, brk - p));
4672 if (brk[1] == ':' && port_ptr)
4673 *port_ptr = atoi(brk + 2);
4674 } else if ((col = strchr(p, ':')) && col < ls) {
4675 av_strlcpy(hostname, p,
4676 FFMIN(col + 1 - p, hostname_size));
4678 *port_ptr = atoi(col + 1);
4680 av_strlcpy(hostname, p,
4681 FFMIN(ls + 1 - p, hostname_size));
4685 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4688 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4691 'C', 'D', 'E', 'F' };
4692 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4695 'c', 'd', 'e', 'f' };
4696 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4698 for (i = 0; i < s; i++) {
4699 buff[i * 2] = hex_table[src[i] >> 4];
4700 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4706 int ff_hex_to_data(uint8_t *data, const char *p)
4713 p += strspn(p, SPACE_CHARS);
4716 c = av_toupper((unsigned char) *p++);
4717 if (c >= '0' && c <= '9')
4719 else if (c >= 'A' && c <= 'F')
4734 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4735 unsigned int pts_num, unsigned int pts_den)
4738 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4739 if (new_tb.num != pts_num)
4740 av_log(NULL, AV_LOG_DEBUG,
4741 "st:%d removing common factor %d from timebase\n",
4742 s->index, pts_num / new_tb.num);
4744 av_log(NULL, AV_LOG_WARNING,
4745 "st:%d has too large timebase, reducing\n", s->index);
4747 if (new_tb.num <= 0 || new_tb.den <= 0) {
4748 av_log(NULL, AV_LOG_ERROR,
4749 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4750 new_tb.num, new_tb.den,
4754 s->time_base = new_tb;
4755 #if FF_API_LAVF_AVCTX
4756 FF_DISABLE_DEPRECATION_WARNINGS
4757 av_codec_set_pkt_timebase(s->codec, new_tb);
4758 FF_ENABLE_DEPRECATION_WARNINGS
4760 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4761 s->pts_wrap_bits = pts_wrap_bits;
4764 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4767 const char *ptr = str;
4769 /* Parse key=value pairs. */
4772 char *dest = NULL, *dest_end;
4773 int key_len, dest_len = 0;
4775 /* Skip whitespace and potential commas. */
4776 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4783 if (!(ptr = strchr(key, '=')))
4786 key_len = ptr - key;
4788 callback_get_buf(context, key, key_len, &dest, &dest_len);
4789 dest_end = dest + dest_len - 1;
4793 while (*ptr && *ptr != '\"') {
4797 if (dest && dest < dest_end)
4801 if (dest && dest < dest_end)
4809 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4810 if (dest && dest < dest_end)
4818 int ff_find_stream_index(AVFormatContext *s, int id)
4821 for (i = 0; i < s->nb_streams; i++)
4822 if (s->streams[i]->id == id)
4827 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4831 unsigned int codec_tag;
4832 if (ofmt->query_codec)
4833 return ofmt->query_codec(codec_id, std_compliance);
4834 else if (ofmt->codec_tag)
4835 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4836 else if (codec_id == ofmt->video_codec ||
4837 codec_id == ofmt->audio_codec ||
4838 codec_id == ofmt->subtitle_codec ||
4839 codec_id == ofmt->data_codec)
4842 return AVERROR_PATCHWELCOME;
4845 int avformat_network_init(void)
4849 ff_network_inited_globally = 1;
4850 if ((ret = ff_network_init()) < 0)
4852 if ((ret = ff_tls_init()) < 0)
4858 int avformat_network_deinit(void)
4863 ff_network_inited_globally = 0;
4868 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4869 uint64_t channel_layout, int32_t sample_rate,
4870 int32_t width, int32_t height)
4876 return AVERROR(EINVAL);
4879 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4881 if (channel_layout) {
4883 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4887 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4889 if (width || height) {
4891 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4893 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4895 return AVERROR(ENOMEM);
4896 bytestream_put_le32(&data, flags);
4898 bytestream_put_le32(&data, channels);
4900 bytestream_put_le64(&data, channel_layout);
4902 bytestream_put_le32(&data, sample_rate);
4903 if (width || height) {
4904 bytestream_put_le32(&data, width);
4905 bytestream_put_le32(&data, height);
4910 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4912 AVRational undef = {0, 1};
4913 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4914 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4915 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4917 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4918 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4919 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4920 stream_sample_aspect_ratio = undef;
4922 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4923 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4924 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4925 frame_sample_aspect_ratio = undef;
4927 if (stream_sample_aspect_ratio.num)
4928 return stream_sample_aspect_ratio;
4930 return frame_sample_aspect_ratio;
4933 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4935 AVRational fr = st->r_frame_rate;
4936 AVRational codec_fr = st->internal->avctx->framerate;
4937 AVRational avg_fr = st->avg_frame_rate;
4939 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4940 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4945 if (st->internal->avctx->ticks_per_frame > 1) {
4946 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4947 (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))
4954 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4957 if (*spec <= '9' && *spec >= '0') /* opt:index */
4958 return strtol(spec, NULL, 0) == st->index;
4959 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4960 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4961 enum AVMediaType type;
4965 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4966 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4967 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4968 case 'd': type = AVMEDIA_TYPE_DATA; break;
4969 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4970 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4971 default: av_assert0(0);
4973 #if FF_API_LAVF_AVCTX
4974 FF_DISABLE_DEPRECATION_WARNINGS
4975 if (type != st->codecpar->codec_type
4976 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4978 FF_ENABLE_DEPRECATION_WARNINGS
4980 if (type != st->codecpar->codec_type)
4983 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4985 if (*spec++ == ':') { /* possibly followed by :index */
4986 int i, index = strtol(spec, NULL, 0);
4987 for (i = 0; i < s->nb_streams; i++) {
4988 #if FF_API_LAVF_AVCTX
4989 FF_DISABLE_DEPRECATION_WARNINGS
4990 if ((s->streams[i]->codecpar->codec_type == type
4991 || s->streams[i]->codec->codec_type == type
4993 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4995 return i == st->index;
4996 FF_ENABLE_DEPRECATION_WARNINGS
4998 if ((s->streams[i]->codecpar->codec_type == type) &&
4999 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5001 return i == st->index;
5007 } else if (*spec == 'p' && *(spec + 1) == ':') {
5011 prog_id = strtol(spec, &endptr, 0);
5012 for (i = 0; i < s->nb_programs; i++) {
5013 if (s->programs[i]->id != prog_id)
5016 if (*endptr++ == ':') {
5017 int stream_idx = strtol(endptr, NULL, 0);
5018 return stream_idx >= 0 &&
5019 stream_idx < s->programs[i]->nb_stream_indexes &&
5020 st->index == s->programs[i]->stream_index[stream_idx];
5023 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5024 if (st->index == s->programs[i]->stream_index[j])
5028 } else if (*spec == '#' ||
5029 (*spec == 'i' && *(spec + 1) == ':')) {
5032 spec += 1 + (*spec == 'i');
5033 stream_id = strtol(spec, &endptr, 0);
5035 return stream_id == st->id;
5036 } else if (*spec == 'm' && *(spec + 1) == ':') {
5037 AVDictionaryEntry *tag;
5042 val = strchr(spec, ':');
5044 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5046 return AVERROR(ENOMEM);
5048 tag = av_dict_get(st->metadata, key, NULL, 0);
5050 if (!val || !strcmp(tag->value, val + 1))
5059 } else if (*spec == 'u') {
5060 AVCodecParameters *par = st->codecpar;
5061 #if FF_API_LAVF_AVCTX
5062 FF_DISABLE_DEPRECATION_WARNINGS
5063 AVCodecContext *codec = st->codec;
5064 FF_ENABLE_DEPRECATION_WARNINGS
5067 switch (par->codec_type) {
5068 case AVMEDIA_TYPE_AUDIO:
5069 val = par->sample_rate && par->channels;
5070 #if FF_API_LAVF_AVCTX
5071 val = val || (codec->sample_rate && codec->channels);
5073 if (par->format == AV_SAMPLE_FMT_NONE
5074 #if FF_API_LAVF_AVCTX
5075 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5080 case AVMEDIA_TYPE_VIDEO:
5081 val = par->width && par->height;
5082 #if FF_API_LAVF_AVCTX
5083 val = val || (codec->width && codec->height);
5085 if (par->format == AV_PIX_FMT_NONE
5086 #if FF_API_LAVF_AVCTX
5087 && codec->pix_fmt == AV_PIX_FMT_NONE
5092 case AVMEDIA_TYPE_UNKNOWN:
5099 #if FF_API_LAVF_AVCTX
5100 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5102 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5104 } else if (!*spec) /* empty specifier, matches everything */
5107 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5108 return AVERROR(EINVAL);
5111 int ff_generate_avci_extradata(AVStream *st)
5113 static const uint8_t avci100_1080p_extradata[] = {
5115 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5116 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5117 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5118 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5119 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5120 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5121 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5122 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5123 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5125 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5128 static const uint8_t avci100_1080i_extradata[] = {
5130 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5131 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5132 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5133 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5134 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5135 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5136 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5137 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5138 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5139 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5140 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5142 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5145 static const uint8_t avci50_1080p_extradata[] = {
5147 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5148 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5149 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5150 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5151 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5152 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5153 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5154 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5155 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5157 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5160 static const uint8_t avci50_1080i_extradata[] = {
5162 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5163 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5164 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5165 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5166 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5167 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5168 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5169 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5170 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5171 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5172 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5174 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5177 static const uint8_t avci100_720p_extradata[] = {
5179 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5180 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5181 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5182 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5183 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5184 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5185 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5186 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5187 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5188 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5190 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5193 static const uint8_t avci50_720p_extradata[] = {
5195 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5196 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5197 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5198 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5199 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5200 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5201 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5202 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5203 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5205 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5209 const uint8_t *data = NULL;
5212 if (st->codecpar->width == 1920) {
5213 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5214 data = avci100_1080p_extradata;
5215 size = sizeof(avci100_1080p_extradata);
5217 data = avci100_1080i_extradata;
5218 size = sizeof(avci100_1080i_extradata);
5220 } else if (st->codecpar->width == 1440) {
5221 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5222 data = avci50_1080p_extradata;
5223 size = sizeof(avci50_1080p_extradata);
5225 data = avci50_1080i_extradata;
5226 size = sizeof(avci50_1080i_extradata);
5228 } else if (st->codecpar->width == 1280) {
5229 data = avci100_720p_extradata;
5230 size = sizeof(avci100_720p_extradata);
5231 } else if (st->codecpar->width == 960) {
5232 data = avci50_720p_extradata;
5233 size = sizeof(avci50_720p_extradata);
5239 av_freep(&st->codecpar->extradata);
5240 if (ff_alloc_extradata(st->codecpar, size))
5241 return AVERROR(ENOMEM);
5242 memcpy(st->codecpar->extradata, data, size);
5247 uint8_t *av_stream_get_side_data(const AVStream *st,
5248 enum AVPacketSideDataType type, int *size)
5252 for (i = 0; i < st->nb_side_data; i++) {
5253 if (st->side_data[i].type == type) {
5255 *size = st->side_data[i].size;
5256 return st->side_data[i].data;
5262 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5263 uint8_t *data, size_t size)
5265 AVPacketSideData *sd, *tmp;
5268 for (i = 0; i < st->nb_side_data; i++) {
5269 sd = &st->side_data[i];
5271 if (sd->type == type) {
5272 av_freep(&sd->data);
5279 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5280 return AVERROR(ERANGE);
5282 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5284 return AVERROR(ENOMEM);
5287 st->side_data = tmp;
5290 sd = &st->side_data[st->nb_side_data - 1];
5298 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5302 uint8_t *data = av_malloc(size);
5307 ret = av_stream_add_side_data(st, type, data, size);
5316 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5319 const AVBitStreamFilter *bsf;
5321 AVCodecParameters *in_par;
5323 if (!(bsf = av_bsf_get_by_name(name))) {
5324 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5325 return AVERROR_BSF_NOT_FOUND;
5328 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5331 if (st->internal->nb_bsfcs) {
5332 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5333 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5335 in_par = st->codecpar;
5336 bsfc->time_base_in = st->time_base;
5339 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5344 if (args && bsfc->filter->priv_class) {
5345 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5346 const char * shorthand[2] = {NULL};
5349 shorthand[0] = opt->name;
5351 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5357 if ((ret = av_bsf_init(bsfc)) < 0) {
5362 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5367 av_log(NULL, AV_LOG_VERBOSE,
5368 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5369 name, args ? args : "");
5374 FF_DISABLE_DEPRECATION_WARNINGS
5375 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5376 AVBitStreamFilterContext *bsfc)
5380 AVPacket new_pkt = *pkt;
5381 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5382 &new_pkt.data, &new_pkt.size,
5383 pkt->data, pkt->size,
5384 pkt->flags & AV_PKT_FLAG_KEY);
5385 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5386 av_packet_unref(pkt);
5387 memset(pkt, 0, sizeof(*pkt));
5390 if(a == 0 && new_pkt.data != pkt->data) {
5391 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
5393 memcpy(t, new_pkt.data, new_pkt.size);
5394 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5399 a = AVERROR(ENOMEM);
5403 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5404 av_buffer_default_free, NULL, 0);
5406 pkt->side_data = NULL;
5407 pkt->side_data_elems = 0;
5408 av_packet_unref(pkt);
5410 av_freep(&new_pkt.data);
5411 a = AVERROR(ENOMEM);
5415 av_log(codec, AV_LOG_ERROR,
5416 "Failed to open bitstream filter %s for stream %d with codec %s",
5417 bsfc->filter->name, pkt->stream_index,
5418 codec->codec ? codec->codec->name : "copy");
5428 FF_ENABLE_DEPRECATION_WARNINGS
5431 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5434 return AVERROR(EINVAL);
5436 if (!(s->oformat->flags & AVFMT_NOFILE))
5437 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5441 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5444 s->io_close(s, *pb);
5448 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5450 AVDictionaryEntry *entry;
5451 int64_t parsed_timestamp;
5453 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5454 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5455 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5458 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5465 int ff_standardize_creation_time(AVFormatContext *s)
5468 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5470 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5474 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5479 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5481 if (size != AVPALETTE_SIZE) {
5482 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5483 return AVERROR_INVALIDDATA;
5485 memcpy(palette, side_data, AVPALETTE_SIZE);
5489 if (ret == CONTAINS_PAL) {
5491 for (i = 0; i < AVPALETTE_COUNT; i++)
5492 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5499 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5504 ret = av_bprint_finalize(buf, &str);
5507 if (!av_bprint_is_complete(buf)) {
5509 return AVERROR(ENOMEM);
5512 par->extradata = str;
5513 /* Note: the string is NUL terminated (so extradata can be read as a
5514 * string), but the ending character is not accounted in the size (in
5515 * binary formats you are likely not supposed to mux that character). When
5516 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5518 par->extradata_size = buf->len;
5522 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5523 AVStream *ost, const AVStream *ist,
5524 enum AVTimebaseSource copy_tb)
5526 //TODO: use [io]st->internal->avctx
5527 const AVCodecContext *dec_ctx = ist->codec;
5528 AVCodecContext *enc_ctx = ost->codec;
5530 enc_ctx->time_base = ist->time_base;
5532 * Avi is a special case here because it supports variable fps but
5533 * having the fps and timebase differe significantly adds quite some
5536 if (!strcmp(ofmt->name, "avi")) {
5537 #if FF_API_R_FRAME_RATE
5538 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5539 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5540 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5541 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5542 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5543 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5544 enc_ctx->time_base.num = ist->r_frame_rate.den;
5545 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5546 enc_ctx->ticks_per_frame = 2;
5549 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5550 && av_q2d(ist->time_base) < 1.0/500
5551 || copy_tb == AVFMT_TBCF_DECODER) {
5552 enc_ctx->time_base = dec_ctx->time_base;
5553 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5554 enc_ctx->time_base.den *= 2;
5555 enc_ctx->ticks_per_frame = 2;
5557 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5558 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5559 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5560 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5561 && av_q2d(ist->time_base) < 1.0/500
5562 || copy_tb == AVFMT_TBCF_DECODER) {
5563 enc_ctx->time_base = dec_ctx->time_base;
5564 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5568 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5569 && dec_ctx->time_base.num < dec_ctx->time_base.den
5570 && dec_ctx->time_base.num > 0
5571 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5572 enc_ctx->time_base = dec_ctx->time_base;
5575 if (ost->avg_frame_rate.num)
5576 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5578 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5579 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5584 AVRational av_stream_get_codec_timebase(const AVStream *st)
5586 // See avformat_transfer_internal_stream_timing_info() TODO.
5587 #if FF_API_LAVF_AVCTX
5588 FF_DISABLE_DEPRECATION_WARNINGS
5589 return st->codec->time_base;
5590 FF_ENABLE_DEPRECATION_WARNINGS
5592 return st->internal->avctx->time_base;