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 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
108 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
113 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
114 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
115 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
116 #if FF_API_OLD_OPEN_CALLBACKS
117 FF_DISABLE_DEPRECATION_WARNINGS
118 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
119 FF_ENABLE_DEPRECATION_WARNINGS
122 int64_t av_stream_get_end_pts(const AVStream *st)
125 return st->priv_pts->val;
127 return AV_NOPTS_VALUE;
130 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
135 void av_format_inject_global_side_data(AVFormatContext *s)
138 s->internal->inject_global_side_data = 1;
139 for (i = 0; i < s->nb_streams; i++) {
140 AVStream *st = s->streams[i];
141 st->inject_global_side_data = 1;
145 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
147 av_assert0(!dst->codec_whitelist &&
148 !dst->format_whitelist &&
149 !dst->protocol_whitelist &&
150 !dst->protocol_blacklist);
151 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
152 dst->format_whitelist = av_strdup(src->format_whitelist);
153 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
154 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
155 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
156 || (src-> format_whitelist && !dst-> format_whitelist)
157 || (src->protocol_whitelist && !dst->protocol_whitelist)
158 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
159 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
160 return AVERROR(ENOMEM);
165 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
167 #if FF_API_LAVF_AVCTX
168 FF_DISABLE_DEPRECATION_WARNINGS
169 if (st->codec->codec)
170 return st->codec->codec;
171 FF_ENABLE_DEPRECATION_WARNINGS
174 switch (st->codecpar->codec_type) {
175 case AVMEDIA_TYPE_VIDEO:
176 if (s->video_codec) return s->video_codec;
178 case AVMEDIA_TYPE_AUDIO:
179 if (s->audio_codec) return s->audio_codec;
181 case AVMEDIA_TYPE_SUBTITLE:
182 if (s->subtitle_codec) return s->subtitle_codec;
186 return avcodec_find_decoder(codec_id);
189 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
191 const AVCodec *codec;
193 #if CONFIG_H264_DECODER
194 /* Other parts of the code assume this decoder to be used for h264,
195 * so force it if possible. */
196 if (codec_id == AV_CODEC_ID_H264)
197 return avcodec_find_decoder_by_name("h264");
200 codec = find_decoder(s, st, codec_id);
204 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
205 const AVCodec *probe_codec = NULL;
206 while (probe_codec = av_codec_next(probe_codec)) {
207 if (probe_codec->id == codec_id &&
208 av_codec_is_decoder(probe_codec) &&
209 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
218 int av_format_get_probe_score(const AVFormatContext *s)
220 return s->probe_score;
223 /* an arbitrarily chosen "sane" max packet size -- 50M */
224 #define SANE_CHUNK_SIZE (50000000)
226 int ffio_limit(AVIOContext *s, int size)
228 if (s->maxsize>= 0) {
229 int64_t remaining= s->maxsize - avio_tell(s);
230 if (remaining < size) {
231 int64_t newsize = avio_size(s);
232 if (!s->maxsize || s->maxsize<newsize)
233 s->maxsize = newsize - !newsize;
234 remaining= s->maxsize - avio_tell(s);
235 remaining= FFMAX(remaining, 0);
238 if (s->maxsize>= 0 && remaining+1 < size) {
239 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
246 /* Read the data in sane-sized chunks and append to pkt.
247 * Return the number of bytes read or an error. */
248 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
250 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
251 int orig_size = pkt->size;
255 int prev_size = pkt->size;
258 /* When the caller requests a lot of data, limit it to the amount
259 * left in file or SANE_CHUNK_SIZE when it is not known. */
261 if (read_size > SANE_CHUNK_SIZE/10) {
262 read_size = ffio_limit(s, read_size);
263 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
265 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
268 ret = av_grow_packet(pkt, read_size);
272 ret = avio_read(s, pkt->data + prev_size, read_size);
273 if (ret != read_size) {
274 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
281 pkt->flags |= AV_PKT_FLAG_CORRUPT;
285 av_packet_unref(pkt);
286 return pkt->size > orig_size ? pkt->size - orig_size : ret;
289 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
294 pkt->pos = avio_tell(s);
296 return append_packet_chunked(s, pkt, size);
299 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
302 return av_get_packet(s, pkt, size);
303 return append_packet_chunked(s, pkt, size);
306 int av_filename_number_test(const char *filename)
310 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
313 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
316 static const struct {
319 enum AVMediaType type;
321 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
322 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
323 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
324 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
325 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
326 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
327 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
328 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
329 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
330 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
331 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
332 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
333 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
334 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
338 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
342 av_log(s, AV_LOG_DEBUG,
343 "Probe with size=%d, packets=%d detected %s with score=%d\n",
344 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
346 for (i = 0; fmt_id_type[i].name; i++) {
347 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
348 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
349 st->codecpar->sample_rate)
351 if (st->request_probe > score &&
352 st->codecpar->codec_id != fmt_id_type[i].id)
354 st->codecpar->codec_id = fmt_id_type[i].id;
355 st->codecpar->codec_type = fmt_id_type[i].type;
356 st->internal->need_context_update = 1;
357 #if FF_API_LAVF_AVCTX
358 FF_DISABLE_DEPRECATION_WARNINGS
359 st->codec->codec_type = st->codecpar->codec_type;
360 st->codec->codec_id = st->codecpar->codec_id;
361 FF_ENABLE_DEPRECATION_WARNINGS
370 /************************************************************/
371 /* input media file */
373 int av_demuxer_open(AVFormatContext *ic) {
376 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
377 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
378 return AVERROR(EINVAL);
381 if (ic->iformat->read_header) {
382 err = ic->iformat->read_header(ic);
387 if (ic->pb && !ic->internal->data_offset)
388 ic->internal->data_offset = avio_tell(ic->pb);
393 /* Open input file and probe the format if necessary. */
394 static int init_input(AVFormatContext *s, const char *filename,
395 AVDictionary **options)
398 AVProbeData pd = { filename, NULL, 0 };
399 int score = AVPROBE_SCORE_RETRY;
402 s->flags |= AVFMT_FLAG_CUSTOM_IO;
404 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
405 s, 0, s->format_probesize);
406 else if (s->iformat->flags & AVFMT_NOFILE)
407 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
408 "will be ignored with AVFMT_NOFILE format.\n");
412 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
413 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
416 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
421 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
422 s, 0, s->format_probesize);
425 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
426 AVPacketList **plast_pktl, int ref)
428 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
432 return AVERROR(ENOMEM);
435 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
444 (*plast_pktl)->next = pktl;
446 *packet_buffer = pktl;
448 /* Add the packet in the buffered packet list. */
453 int avformat_queue_attached_pictures(AVFormatContext *s)
456 for (i = 0; i < s->nb_streams; i++)
457 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
458 s->streams[i]->discard < AVDISCARD_ALL) {
459 if (s->streams[i]->attached_pic.size <= 0) {
460 av_log(s, AV_LOG_WARNING,
461 "Attached picture on stream %d has invalid size, "
466 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
467 &s->streams[i]->attached_pic,
468 &s->internal->raw_packet_buffer_end, 1);
475 static int update_stream_avctx(AVFormatContext *s)
478 for (i = 0; i < s->nb_streams; i++) {
479 AVStream *st = s->streams[i];
481 if (!st->internal->need_context_update)
484 /* close parser, because it depends on the codec */
485 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
486 av_parser_close(st->parser);
490 /* update internal codec context, for the parser */
491 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
495 #if FF_API_LAVF_AVCTX
496 FF_DISABLE_DEPRECATION_WARNINGS
497 /* update deprecated public codec context */
498 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
501 FF_ENABLE_DEPRECATION_WARNINGS
504 st->internal->need_context_update = 0;
510 int avformat_open_input(AVFormatContext **ps, const char *filename,
511 AVInputFormat *fmt, AVDictionary **options)
513 AVFormatContext *s = *ps;
515 AVDictionary *tmp = NULL;
516 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
518 if (!s && !(s = avformat_alloc_context()))
519 return AVERROR(ENOMEM);
521 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
522 return AVERROR(EINVAL);
528 av_dict_copy(&tmp, *options, 0);
530 if (s->pb) // must be before any goto fail
531 s->flags |= AVFMT_FLAG_CUSTOM_IO;
533 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
536 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
537 if ((ret = init_input(s, filename, &tmp)) < 0)
539 s->probe_score = ret;
541 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
542 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
543 if (!s->protocol_whitelist) {
544 ret = AVERROR(ENOMEM);
549 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
550 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
551 if (!s->protocol_blacklist) {
552 ret = AVERROR(ENOMEM);
557 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
558 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
559 ret = AVERROR(EINVAL);
563 avio_skip(s->pb, s->skip_initial_bytes);
565 /* Check filename in case an image number is expected. */
566 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
567 if (!av_filename_number_test(filename)) {
568 ret = AVERROR(EINVAL);
573 s->duration = s->start_time = AV_NOPTS_VALUE;
575 /* Allocate private data. */
576 if (s->iformat->priv_data_size > 0) {
577 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
578 ret = AVERROR(ENOMEM);
581 if (s->iformat->priv_class) {
582 *(const AVClass **) s->priv_data = s->iformat->priv_class;
583 av_opt_set_defaults(s->priv_data);
584 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
589 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
591 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
594 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
595 if ((ret = s->iformat->read_header(s)) < 0)
599 s->metadata = s->internal->id3v2_meta;
600 s->internal->id3v2_meta = NULL;
601 } else if (s->internal->id3v2_meta) {
602 int level = AV_LOG_WARNING;
603 if (s->error_recognition & AV_EF_COMPLIANT)
604 level = AV_LOG_ERROR;
605 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
606 av_dict_free(&s->internal->id3v2_meta);
607 if (s->error_recognition & AV_EF_EXPLODE)
608 return AVERROR_INVALIDDATA;
611 if (id3v2_extra_meta) {
612 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
613 !strcmp(s->iformat->name, "tta")) {
614 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
617 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
619 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
621 if ((ret = avformat_queue_attached_pictures(s)) < 0)
624 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
625 s->internal->data_offset = avio_tell(s->pb);
627 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
629 update_stream_avctx(s);
631 for (i = 0; i < s->nb_streams; i++)
632 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
635 av_dict_free(options);
642 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
644 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
646 avformat_free_context(s);
651 /*******************************************************/
653 static void force_codec_ids(AVFormatContext *s, AVStream *st)
655 switch (st->codecpar->codec_type) {
656 case AVMEDIA_TYPE_VIDEO:
657 if (s->video_codec_id)
658 st->codecpar->codec_id = s->video_codec_id;
660 case AVMEDIA_TYPE_AUDIO:
661 if (s->audio_codec_id)
662 st->codecpar->codec_id = s->audio_codec_id;
664 case AVMEDIA_TYPE_SUBTITLE:
665 if (s->subtitle_codec_id)
666 st->codecpar->codec_id = s->subtitle_codec_id;
668 case AVMEDIA_TYPE_DATA:
669 if (s->data_codec_id)
670 st->codecpar->codec_id = s->data_codec_id;
675 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
677 if (st->request_probe>0) {
678 AVProbeData *pd = &st->probe_data;
680 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
684 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
686 av_log(s, AV_LOG_WARNING,
687 "Failed to reallocate probe buffer for stream %d\n",
692 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
693 pd->buf_size += pkt->size;
694 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
697 st->probe_packets = 0;
699 av_log(s, AV_LOG_WARNING,
700 "nothing to probe for stream %d\n", st->index);
704 end= s->internal->raw_packet_buffer_remaining_size <= 0
705 || st->probe_packets<= 0;
707 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
708 int score = set_codec_from_probe_data(s, st, pd);
709 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
713 st->request_probe = -1;
714 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
715 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
717 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
719 force_codec_ids(s, st);
725 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
727 int64_t ref = pkt->dts;
728 int i, pts_wrap_behavior;
729 int64_t pts_wrap_reference;
730 AVProgram *first_program;
732 if (ref == AV_NOPTS_VALUE)
734 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
736 ref &= (1LL << st->pts_wrap_bits)-1;
738 // reference time stamp should be 60 s before first time stamp
739 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
740 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
741 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
742 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
743 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
745 first_program = av_find_program_from_stream(s, NULL, stream_index);
747 if (!first_program) {
748 int default_stream_index = av_find_default_stream_index(s);
749 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
750 for (i = 0; i < s->nb_streams; i++) {
751 if (av_find_program_from_stream(s, NULL, i))
753 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
754 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
758 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
759 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
763 AVProgram *program = first_program;
765 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
766 pts_wrap_reference = program->pts_wrap_reference;
767 pts_wrap_behavior = program->pts_wrap_behavior;
770 program = av_find_program_from_stream(s, program, stream_index);
773 // update every program with differing pts_wrap_reference
774 program = first_program;
776 if (program->pts_wrap_reference != pts_wrap_reference) {
777 for (i = 0; i<program->nb_stream_indexes; i++) {
778 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
779 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
782 program->pts_wrap_reference = pts_wrap_reference;
783 program->pts_wrap_behavior = pts_wrap_behavior;
785 program = av_find_program_from_stream(s, program, stream_index);
791 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
797 AVPacketList *pktl = s->internal->raw_packet_buffer;
801 st = s->streams[pkt->stream_index];
802 if (s->internal->raw_packet_buffer_remaining_size <= 0)
803 if ((err = probe_codec(s, st, NULL)) < 0)
805 if (st->request_probe <= 0) {
806 s->internal->raw_packet_buffer = pktl->next;
807 s->internal->raw_packet_buffer_remaining_size += pkt->size;
816 ret = s->iformat->read_packet(s, pkt);
818 /* Some demuxers return FFERROR_REDO when they consume
819 data and discard it (ignored streams, junk, extradata).
820 We must re-call the demuxer to get the real packet. */
821 if (ret == FFERROR_REDO)
823 if (!pktl || ret == AVERROR(EAGAIN))
825 for (i = 0; i < s->nb_streams; i++) {
827 if (st->probe_packets || st->request_probe > 0)
828 if ((err = probe_codec(s, st, NULL)) < 0)
830 av_assert0(st->request_probe <= 0);
836 AVPacket tmp = { 0 };
837 ret = av_packet_ref(&tmp, pkt);
843 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
844 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
845 av_log(s, AV_LOG_WARNING,
846 "Dropped corrupted packet (stream = %d)\n",
848 av_packet_unref(pkt);
852 if (pkt->stream_index >= (unsigned)s->nb_streams) {
853 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
857 st = s->streams[pkt->stream_index];
859 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
860 // correct first time stamps to negative values
861 if (!is_relative(st->first_dts))
862 st->first_dts = wrap_timestamp(st, st->first_dts);
863 if (!is_relative(st->start_time))
864 st->start_time = wrap_timestamp(st, st->start_time);
865 if (!is_relative(st->cur_dts))
866 st->cur_dts = wrap_timestamp(st, st->cur_dts);
869 pkt->dts = wrap_timestamp(st, pkt->dts);
870 pkt->pts = wrap_timestamp(st, pkt->pts);
872 force_codec_ids(s, st);
874 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
875 if (s->use_wallclock_as_timestamps)
876 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
878 if (!pktl && st->request_probe <= 0)
881 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
882 &s->internal->raw_packet_buffer_end, 0);
885 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
887 if ((err = probe_codec(s, st, pkt)) < 0)
893 /**********************************************************/
895 static int determinable_frame_size(AVCodecContext *avctx)
897 switch(avctx->codec_id) {
898 case AV_CODEC_ID_MP1:
899 case AV_CODEC_ID_MP2:
900 case AV_CODEC_ID_MP3:
908 * Return the frame duration in seconds. Return 0 if not available.
910 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
911 AVCodecParserContext *pc, AVPacket *pkt)
913 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
914 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
915 int frame_size, sample_rate;
917 #if FF_API_LAVF_AVCTX
918 FF_DISABLE_DEPRECATION_WARNINGS
919 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
920 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
921 FF_ENABLE_DEPRECATION_WARNINGS
926 switch (st->codecpar->codec_type) {
927 case AVMEDIA_TYPE_VIDEO:
928 if (st->r_frame_rate.num && !pc && s->iformat) {
929 *pnum = st->r_frame_rate.den;
930 *pden = st->r_frame_rate.num;
931 } else if (st->time_base.num * 1000LL > st->time_base.den) {
932 *pnum = st->time_base.num;
933 *pden = st->time_base.den;
934 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
935 av_assert0(st->internal->avctx->ticks_per_frame);
936 av_reduce(pnum, pden,
938 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
941 if (pc && pc->repeat_pict) {
942 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
943 av_reduce(pnum, pden,
944 (*pnum) * (1LL + pc->repeat_pict),
948 /* If this codec can be interlaced or progressive then we need
949 * a parser to compute duration of a packet. Thus if we have
950 * no parser in such case leave duration undefined. */
951 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
955 case AVMEDIA_TYPE_AUDIO:
956 if (st->internal->avctx_inited) {
957 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
958 sample_rate = st->internal->avctx->sample_rate;
960 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
961 sample_rate = st->codecpar->sample_rate;
963 if (frame_size <= 0 || sample_rate <= 0)
973 static int is_intra_only(enum AVCodecID id)
975 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
978 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
983 static int has_decode_delay_been_guessed(AVStream *st)
985 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
986 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
988 #if CONFIG_H264_DECODER
989 if (st->internal->avctx->has_b_frames &&
990 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
993 if (st->internal->avctx->has_b_frames<3)
994 return st->nb_decoded_frames >= 7;
995 else if (st->internal->avctx->has_b_frames<4)
996 return st->nb_decoded_frames >= 18;
998 return st->nb_decoded_frames >= 20;
1001 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1005 if (pktl == s->internal->packet_buffer_end)
1006 return s->internal->parse_queue;
1010 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1011 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1012 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1015 int delay = st->internal->avctx->has_b_frames;
1018 if (dts == AV_NOPTS_VALUE) {
1019 int64_t best_score = INT64_MAX;
1020 for (i = 0; i<delay; i++) {
1021 if (st->pts_reorder_error_count[i]) {
1022 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1023 if (score < best_score) {
1025 dts = pts_buffer[i];
1030 for (i = 0; i<delay; i++) {
1031 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1032 int64_t diff = FFABS(pts_buffer[i] - dts)
1033 + (uint64_t)st->pts_reorder_error[i];
1034 diff = FFMAX(diff, st->pts_reorder_error[i]);
1035 st->pts_reorder_error[i] = diff;
1036 st->pts_reorder_error_count[i]++;
1037 if (st->pts_reorder_error_count[i] > 250) {
1038 st->pts_reorder_error[i] >>= 1;
1039 st->pts_reorder_error_count[i] >>= 1;
1046 if (dts == AV_NOPTS_VALUE)
1047 dts = pts_buffer[0];
1053 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1054 * of the packets in a window.
1056 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1057 AVPacketList *pkt_buffer)
1059 AVStream *st = s->streams[stream_index];
1060 int delay = st->internal->avctx->has_b_frames;
1063 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1065 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1066 pts_buffer[i] = AV_NOPTS_VALUE;
1068 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1069 if (pkt_buffer->pkt.stream_index != stream_index)
1072 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1073 pts_buffer[0] = pkt_buffer->pkt.pts;
1074 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1075 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1077 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1082 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1083 int64_t dts, int64_t pts, AVPacket *pkt)
1085 AVStream *st = s->streams[stream_index];
1086 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1087 AVPacketList *pktl_it;
1091 if (st->first_dts != AV_NOPTS_VALUE ||
1092 dts == AV_NOPTS_VALUE ||
1093 st->cur_dts == AV_NOPTS_VALUE ||
1097 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1099 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1101 if (is_relative(pts))
1104 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1105 if (pktl_it->pkt.stream_index != stream_index)
1107 if (is_relative(pktl_it->pkt.pts))
1108 pktl_it->pkt.pts += shift;
1110 if (is_relative(pktl_it->pkt.dts))
1111 pktl_it->pkt.dts += shift;
1113 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1114 st->start_time = pktl_it->pkt.pts;
1115 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1116 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1120 if (has_decode_delay_been_guessed(st)) {
1121 update_dts_from_pts(s, stream_index, pktl);
1124 if (st->start_time == AV_NOPTS_VALUE) {
1125 st->start_time = pts;
1126 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1127 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1131 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1132 int stream_index, int duration)
1134 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1135 int64_t cur_dts = RELATIVE_TS_BASE;
1137 if (st->first_dts != AV_NOPTS_VALUE) {
1138 if (st->update_initial_durations_done)
1140 st->update_initial_durations_done = 1;
1141 cur_dts = st->first_dts;
1142 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1143 if (pktl->pkt.stream_index == stream_index) {
1144 if (pktl->pkt.pts != pktl->pkt.dts ||
1145 pktl->pkt.dts != AV_NOPTS_VALUE ||
1148 cur_dts -= duration;
1151 if (pktl && pktl->pkt.dts != st->first_dts) {
1152 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1153 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1157 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1160 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1161 st->first_dts = cur_dts;
1162 } else if (st->cur_dts != RELATIVE_TS_BASE)
1165 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1166 if (pktl->pkt.stream_index != stream_index)
1168 if ((pktl->pkt.pts == pktl->pkt.dts ||
1169 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1170 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1171 pktl->pkt.dts == st->first_dts ||
1172 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1173 !pktl->pkt.duration) {
1174 pktl->pkt.dts = cur_dts;
1175 if (!st->internal->avctx->has_b_frames)
1176 pktl->pkt.pts = cur_dts;
1177 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1178 pktl->pkt.duration = duration;
1181 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1184 st->cur_dts = cur_dts;
1187 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1188 AVCodecParserContext *pc, AVPacket *pkt,
1189 int64_t next_dts, int64_t next_pts)
1191 int num, den, presentation_delayed, delay, i;
1193 AVRational duration;
1194 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1195 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1197 if (s->flags & AVFMT_FLAG_NOFILLIN)
1200 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1201 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1202 if (st->last_dts_for_order_check <= pkt->dts) {
1205 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1206 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1208 st->last_dts_for_order_check);
1209 st->dts_misordered++;
1211 if (st->dts_ordered + st->dts_misordered > 250) {
1212 st->dts_ordered >>= 1;
1213 st->dts_misordered >>= 1;
1217 st->last_dts_for_order_check = pkt->dts;
1218 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1219 pkt->dts = AV_NOPTS_VALUE;
1222 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1223 pkt->dts = AV_NOPTS_VALUE;
1225 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1226 && !st->internal->avctx->has_b_frames)
1227 //FIXME Set low_delay = 0 when has_b_frames = 1
1228 st->internal->avctx->has_b_frames = 1;
1230 /* do we have a video B-frame ? */
1231 delay = st->internal->avctx->has_b_frames;
1232 presentation_delayed = 0;
1234 /* XXX: need has_b_frame, but cannot get it if the codec is
1235 * not initialized */
1237 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1238 presentation_delayed = 1;
1240 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1241 st->pts_wrap_bits < 63 &&
1242 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1243 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1244 pkt->dts -= 1LL << st->pts_wrap_bits;
1246 pkt->pts += 1LL << st->pts_wrap_bits;
1249 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1250 * We take the conservative approach and discard both.
1251 * Note: If this is misbehaving for an H.264 file, then possibly
1252 * presentation_delayed is not set correctly. */
1253 if (delay == 1 && pkt->dts == pkt->pts &&
1254 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1255 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1256 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1257 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1258 pkt->dts = AV_NOPTS_VALUE;
1261 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1262 if (pkt->duration == 0) {
1263 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1265 duration = (AVRational) {num, den};
1266 pkt->duration = av_rescale_rnd(1,
1267 num * (int64_t) st->time_base.den,
1268 den * (int64_t) st->time_base.num,
1273 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1274 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1276 /* Correct timestamps with byte offset if demuxers only have timestamps
1277 * on packet boundaries */
1278 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1279 /* this will estimate bitrate based on this frame's duration and size */
1280 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1281 if (pkt->pts != AV_NOPTS_VALUE)
1283 if (pkt->dts != AV_NOPTS_VALUE)
1287 /* This may be redundant, but it should not hurt. */
1288 if (pkt->dts != AV_NOPTS_VALUE &&
1289 pkt->pts != AV_NOPTS_VALUE &&
1290 pkt->pts > pkt->dts)
1291 presentation_delayed = 1;
1293 if (s->debug & FF_FDEBUG_TS)
1294 av_log(s, AV_LOG_TRACE,
1295 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1296 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1297 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1299 /* Interpolate PTS and DTS if they are not present. We skip H264
1300 * currently because delay and has_b_frames are not reliably set. */
1301 if ((delay == 0 || (delay == 1 && pc)) &&
1303 if (presentation_delayed) {
1304 /* DTS = decompression timestamp */
1305 /* PTS = presentation timestamp */
1306 if (pkt->dts == AV_NOPTS_VALUE)
1307 pkt->dts = st->last_IP_pts;
1308 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1309 if (pkt->dts == AV_NOPTS_VALUE)
1310 pkt->dts = st->cur_dts;
1312 /* This is tricky: the dts must be incremented by the duration
1313 * of the frame we are displaying, i.e. the last I- or P-frame. */
1314 if (st->last_IP_duration == 0)
1315 st->last_IP_duration = pkt->duration;
1316 if (pkt->dts != AV_NOPTS_VALUE)
1317 st->cur_dts = pkt->dts + st->last_IP_duration;
1318 if (pkt->dts != AV_NOPTS_VALUE &&
1319 pkt->pts == AV_NOPTS_VALUE &&
1320 st->last_IP_duration > 0 &&
1321 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1322 next_dts != next_pts &&
1323 next_pts != AV_NOPTS_VALUE)
1324 pkt->pts = next_dts;
1326 st->last_IP_duration = pkt->duration;
1327 st->last_IP_pts = pkt->pts;
1328 /* Cannot compute PTS if not present (we can compute it only
1329 * by knowing the future. */
1330 } else if (pkt->pts != AV_NOPTS_VALUE ||
1331 pkt->dts != AV_NOPTS_VALUE ||
1334 /* presentation is not delayed : PTS and DTS are the same */
1335 if (pkt->pts == AV_NOPTS_VALUE)
1336 pkt->pts = pkt->dts;
1337 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1339 if (pkt->pts == AV_NOPTS_VALUE)
1340 pkt->pts = st->cur_dts;
1341 pkt->dts = pkt->pts;
1342 if (pkt->pts != AV_NOPTS_VALUE)
1343 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1347 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1348 st->pts_buffer[0] = pkt->pts;
1349 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1350 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1352 if(has_decode_delay_been_guessed(st))
1353 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1355 // We skipped it above so we try here.
1357 // This should happen on the first packet
1358 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1359 if (pkt->dts > st->cur_dts)
1360 st->cur_dts = pkt->dts;
1362 if (s->debug & FF_FDEBUG_TS)
1363 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1364 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1367 if (is_intra_only(st->codecpar->codec_id))
1368 pkt->flags |= AV_PKT_FLAG_KEY;
1369 #if FF_API_CONVERGENCE_DURATION
1370 FF_DISABLE_DEPRECATION_WARNINGS
1372 pkt->convergence_duration = pc->convergence_duration;
1373 FF_ENABLE_DEPRECATION_WARNINGS
1377 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1380 AVPacketList *pktl = *pkt_buf;
1381 *pkt_buf = pktl->next;
1382 av_packet_unref(&pktl->pkt);
1385 *pkt_buf_end = NULL;
1389 * Parse a packet, add all split parts to parse_queue.
1391 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1393 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1395 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1396 AVStream *st = s->streams[stream_index];
1397 uint8_t *data = pkt ? pkt->data : NULL;
1398 int size = pkt ? pkt->size : 0;
1399 int ret = 0, got_output = 0;
1402 av_init_packet(&flush_pkt);
1405 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1406 // preserve 0-size sync packets
1407 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1410 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1412 int64_t next_pts = pkt->pts;
1413 int64_t next_dts = pkt->dts;
1415 av_init_packet(&out_pkt);
1416 len = av_parser_parse2(st->parser, st->internal->avctx,
1417 &out_pkt.data, &out_pkt.size, data, size,
1418 pkt->pts, pkt->dts, pkt->pos);
1420 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1422 /* increment read pointer */
1426 got_output = !!out_pkt.size;
1431 if (pkt->side_data) {
1432 out_pkt.side_data = pkt->side_data;
1433 out_pkt.side_data_elems = pkt->side_data_elems;
1434 pkt->side_data = NULL;
1435 pkt->side_data_elems = 0;
1438 /* set the duration */
1439 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1440 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1441 if (st->internal->avctx->sample_rate > 0) {
1443 av_rescale_q_rnd(st->parser->duration,
1444 (AVRational) { 1, st->internal->avctx->sample_rate },
1450 out_pkt.stream_index = st->index;
1451 out_pkt.pts = st->parser->pts;
1452 out_pkt.dts = st->parser->dts;
1453 out_pkt.pos = st->parser->pos;
1455 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1456 out_pkt.pos = st->parser->frame_offset;
1458 if (st->parser->key_frame == 1 ||
1459 (st->parser->key_frame == -1 &&
1460 st->parser->pict_type == AV_PICTURE_TYPE_I))
1461 out_pkt.flags |= AV_PKT_FLAG_KEY;
1463 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1464 out_pkt.flags |= AV_PKT_FLAG_KEY;
1466 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1468 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1469 &s->internal->parse_queue_end, 1);
1470 av_packet_unref(&out_pkt);
1475 /* end of the stream => close and free the parser */
1476 if (pkt == &flush_pkt) {
1477 av_parser_close(st->parser);
1482 av_packet_unref(pkt);
1486 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1487 AVPacketList **pkt_buffer_end,
1491 av_assert0(*pkt_buffer);
1494 *pkt_buffer = pktl->next;
1496 *pkt_buffer_end = NULL;
1501 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1503 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1506 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1508 int ret = 0, i, got_packet = 0;
1509 AVDictionary *metadata = NULL;
1511 av_init_packet(pkt);
1513 while (!got_packet && !s->internal->parse_queue) {
1517 /* read next packet */
1518 ret = ff_read_packet(s, &cur_pkt);
1520 if (ret == AVERROR(EAGAIN))
1522 /* flush the parsers */
1523 for (i = 0; i < s->nb_streams; i++) {
1525 if (st->parser && st->need_parsing)
1526 parse_packet(s, NULL, st->index);
1528 /* all remaining packets are now in parse_queue =>
1529 * really terminate parsing */
1533 st = s->streams[cur_pkt.stream_index];
1535 /* update context if required */
1536 if (st->internal->need_context_update) {
1537 if (avcodec_is_open(st->internal->avctx)) {
1538 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1539 avcodec_close(st->internal->avctx);
1540 st->info->found_decoder = 0;
1543 /* close parser, because it depends on the codec */
1544 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1545 av_parser_close(st->parser);
1549 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1553 #if FF_API_LAVF_AVCTX
1554 FF_DISABLE_DEPRECATION_WARNINGS
1555 /* update deprecated public codec context */
1556 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1559 FF_ENABLE_DEPRECATION_WARNINGS
1562 st->internal->need_context_update = 0;
1565 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1566 cur_pkt.dts != AV_NOPTS_VALUE &&
1567 cur_pkt.pts < cur_pkt.dts) {
1568 av_log(s, AV_LOG_WARNING,
1569 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1570 cur_pkt.stream_index,
1571 av_ts2str(cur_pkt.pts),
1572 av_ts2str(cur_pkt.dts),
1575 if (s->debug & FF_FDEBUG_TS)
1576 av_log(s, AV_LOG_DEBUG,
1577 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1578 cur_pkt.stream_index,
1579 av_ts2str(cur_pkt.pts),
1580 av_ts2str(cur_pkt.dts),
1581 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1583 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1584 st->parser = av_parser_init(st->codecpar->codec_id);
1586 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1587 "%s, packets or times may be invalid.\n",
1588 avcodec_get_name(st->codecpar->codec_id));
1589 /* no parser available: just output the raw packets */
1590 st->need_parsing = AVSTREAM_PARSE_NONE;
1591 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1592 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1593 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1594 st->parser->flags |= PARSER_FLAG_ONCE;
1595 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1596 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1599 if (!st->need_parsing || !st->parser) {
1600 /* no parsing needed: we just output the packet as is */
1602 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1603 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1604 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1605 ff_reduce_index(s, st->index);
1606 av_add_index_entry(st, pkt->pos, pkt->dts,
1607 0, 0, AVINDEX_KEYFRAME);
1610 } else if (st->discard < AVDISCARD_ALL) {
1611 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1613 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1614 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1615 st->codecpar->channels = st->internal->avctx->channels;
1616 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1617 st->codecpar->codec_id = st->internal->avctx->codec_id;
1620 av_packet_unref(&cur_pkt);
1622 if (pkt->flags & AV_PKT_FLAG_KEY)
1623 st->skip_to_keyframe = 0;
1624 if (st->skip_to_keyframe) {
1625 av_packet_unref(&cur_pkt);
1633 if (!got_packet && s->internal->parse_queue)
1634 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1637 AVStream *st = s->streams[pkt->stream_index];
1638 int discard_padding = 0;
1639 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1640 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1641 int64_t sample = ts_to_samples(st, pts);
1642 int duration = ts_to_samples(st, pkt->duration);
1643 int64_t end_sample = sample + duration;
1644 if (duration > 0 && end_sample >= st->first_discard_sample &&
1645 sample < st->last_discard_sample)
1646 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1648 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1649 st->skip_samples = st->start_skip_samples;
1650 if (st->skip_samples || discard_padding) {
1651 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1653 AV_WL32(p, st->skip_samples);
1654 AV_WL32(p + 4, discard_padding);
1655 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1657 st->skip_samples = 0;
1660 if (st->inject_global_side_data) {
1661 for (i = 0; i < st->nb_side_data; i++) {
1662 AVPacketSideData *src_sd = &st->side_data[i];
1665 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1668 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1670 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1674 memcpy(dst_data, src_sd->data, src_sd->size);
1676 st->inject_global_side_data = 0;
1679 #if FF_API_LAVF_MERGE_SD
1680 FF_DISABLE_DEPRECATION_WARNINGS
1681 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1682 av_packet_merge_side_data(pkt);
1683 FF_ENABLE_DEPRECATION_WARNINGS
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 // close codecs which were opened in try_decode_frame()
3884 for (i = 0; i < ic->nb_streams; i++) {
3885 st = ic->streams[i];
3886 avcodec_close(st->internal->avctx);
3889 ff_rfps_calculate(ic);
3891 for (i = 0; i < ic->nb_streams; i++) {
3892 st = ic->streams[i];
3893 avctx = st->internal->avctx;
3894 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3895 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3896 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3897 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3898 avctx->codec_tag= tag;
3901 /* estimate average framerate if not set by demuxer */
3902 if (st->info->codec_info_duration_fields &&
3903 !st->avg_frame_rate.num &&
3904 st->info->codec_info_duration) {
3906 double best_error = 0.01;
3907 AVRational codec_frame_rate = avctx->framerate;
3909 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3910 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3911 st->info->codec_info_duration < 0)
3913 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3914 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3915 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3917 /* Round guessed framerate to a "standard" framerate if it's
3918 * within 1% of the original estimate. */
3919 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3920 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3921 double error = fabs(av_q2d(st->avg_frame_rate) /
3922 av_q2d(std_fps) - 1);
3924 if (error < best_error) {
3926 best_fps = std_fps.num;
3929 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3930 error = fabs(av_q2d(codec_frame_rate) /
3931 av_q2d(std_fps) - 1);
3932 if (error < best_error) {
3934 best_fps = std_fps.num;
3939 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3940 best_fps, 12 * 1001, INT_MAX);
3943 if (!st->r_frame_rate.num) {
3944 if ( avctx->time_base.den * (int64_t) st->time_base.num
3945 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3946 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3947 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3949 st->r_frame_rate.num = st->time_base.den;
3950 st->r_frame_rate.den = st->time_base.num;
3953 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3954 AVRational hw_ratio = { avctx->height, avctx->width };
3955 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3958 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3959 if (!avctx->bits_per_coded_sample)
3960 avctx->bits_per_coded_sample =
3961 av_get_bits_per_sample(avctx->codec_id);
3962 // set stream disposition based on audio service type
3963 switch (avctx->audio_service_type) {
3964 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3965 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3967 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3968 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3970 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3971 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3973 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3974 st->disposition = AV_DISPOSITION_COMMENT;
3976 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3977 st->disposition = AV_DISPOSITION_KARAOKE;
3984 estimate_timings(ic, old_offset);
3986 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3988 if (ret >= 0 && ic->nb_streams)
3989 /* We could not have all the codec parameters before EOF. */
3991 for (i = 0; i < ic->nb_streams; i++) {
3993 st = ic->streams[i];
3995 /* if no packet was ever seen, update context now for has_codec_parameters */
3996 if (!st->internal->avctx_inited) {
3997 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3998 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3999 st->codecpar->format = st->internal->avctx->sample_fmt;
4000 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4002 goto find_stream_info_err;
4004 if (!has_codec_parameters(st, &errmsg)) {
4006 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4007 av_log(ic, AV_LOG_WARNING,
4008 "Could not find codec parameters for stream %d (%s): %s\n"
4009 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4016 compute_chapters_end(ic);
4018 /* update the stream parameters from the internal codec contexts */
4019 for (i = 0; i < ic->nb_streams; i++) {
4020 st = ic->streams[i];
4022 if (st->internal->avctx_inited) {
4023 int orig_w = st->codecpar->width;
4024 int orig_h = st->codecpar->height;
4025 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4027 goto find_stream_info_err;
4028 // The decoder might reduce the video size by the lowres factor.
4029 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
4030 st->codecpar->width = orig_w;
4031 st->codecpar->height = orig_h;
4035 #if FF_API_LAVF_AVCTX
4036 FF_DISABLE_DEPRECATION_WARNINGS
4037 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4039 goto find_stream_info_err;
4041 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4042 // by the lowres factor.
4043 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
4044 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
4045 st->codec->width = st->internal->avctx->width;
4046 st->codec->height = st->internal->avctx->height;
4049 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4050 st->codec->time_base = st->internal->avctx->time_base;
4051 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4053 st->codec->framerate = st->avg_frame_rate;
4055 if (st->internal->avctx->subtitle_header) {
4056 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4057 if (!st->codec->subtitle_header)
4058 goto find_stream_info_err;
4059 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4060 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4061 st->codec->subtitle_header_size);
4064 // Fields unavailable in AVCodecParameters
4065 st->codec->coded_width = st->internal->avctx->coded_width;
4066 st->codec->coded_height = st->internal->avctx->coded_height;
4067 st->codec->properties = st->internal->avctx->properties;
4068 FF_ENABLE_DEPRECATION_WARNINGS
4071 st->internal->avctx_inited = 0;
4074 find_stream_info_err:
4075 for (i = 0; i < ic->nb_streams; i++) {
4076 st = ic->streams[i];
4078 av_freep(&st->info->duration_error);
4079 av_freep(&ic->streams[i]->info);
4080 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4081 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4084 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4085 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4089 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4093 for (i = 0; i < ic->nb_programs; i++) {
4094 if (ic->programs[i] == last) {
4098 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4099 if (ic->programs[i]->stream_index[j] == s)
4100 return ic->programs[i];
4106 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4107 int wanted_stream_nb, int related_stream,
4108 AVCodec **decoder_ret, int flags)
4110 int i, nb_streams = ic->nb_streams;
4111 int ret = AVERROR_STREAM_NOT_FOUND;
4112 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4113 int count, multiframe, disposition;
4114 int64_t best_bitrate = -1;
4116 unsigned *program = NULL;
4117 const AVCodec *decoder = NULL, *best_decoder = NULL;
4119 if (related_stream >= 0 && wanted_stream_nb < 0) {
4120 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4122 program = p->stream_index;
4123 nb_streams = p->nb_stream_indexes;
4126 for (i = 0; i < nb_streams; i++) {
4127 int real_stream_index = program ? program[i] : i;
4128 AVStream *st = ic->streams[real_stream_index];
4129 AVCodecParameters *par = st->codecpar;
4130 if (par->codec_type != type)
4132 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4134 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4137 decoder = find_decoder(ic, st, par->codec_id);
4140 ret = AVERROR_DECODER_NOT_FOUND;
4144 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4145 count = st->codec_info_nb_frames;
4146 bitrate = par->bit_rate;
4147 multiframe = FFMIN(5, count);
4148 if ((best_disposition > disposition) ||
4149 (best_disposition == disposition && best_multiframe > multiframe) ||
4150 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4151 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4153 best_disposition = disposition;
4155 best_bitrate = bitrate;
4156 best_multiframe = multiframe;
4157 ret = real_stream_index;
4158 best_decoder = decoder;
4159 if (program && i == nb_streams - 1 && ret < 0) {
4161 nb_streams = ic->nb_streams;
4162 /* no related stream found, try again with everything */
4167 *decoder_ret = (AVCodec*)best_decoder;
4171 /*******************************************************/
4173 int av_read_play(AVFormatContext *s)
4175 if (s->iformat->read_play)
4176 return s->iformat->read_play(s);
4178 return avio_pause(s->pb, 0);
4179 return AVERROR(ENOSYS);
4182 int av_read_pause(AVFormatContext *s)
4184 if (s->iformat->read_pause)
4185 return s->iformat->read_pause(s);
4187 return avio_pause(s->pb, 1);
4188 return AVERROR(ENOSYS);
4191 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4196 dst->time_base = src->time_base;
4197 dst->nb_frames = src->nb_frames;
4198 dst->disposition = src->disposition;
4199 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4200 dst->avg_frame_rate = src->avg_frame_rate;
4201 dst->r_frame_rate = src->r_frame_rate;
4203 av_dict_free(&dst->metadata);
4204 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4208 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4212 /* Free existing side data*/
4213 for (i = 0; i < dst->nb_side_data; i++)
4214 av_free(dst->side_data[i].data);
4215 av_freep(&dst->side_data);
4216 dst->nb_side_data = 0;
4218 /* Copy side data if present */
4219 if (src->nb_side_data) {
4220 dst->side_data = av_mallocz_array(src->nb_side_data,
4221 sizeof(AVPacketSideData));
4222 if (!dst->side_data)
4223 return AVERROR(ENOMEM);
4224 dst->nb_side_data = src->nb_side_data;
4226 for (i = 0; i < src->nb_side_data; i++) {
4227 uint8_t *data = av_memdup(src->side_data[i].data,
4228 src->side_data[i].size);
4230 return AVERROR(ENOMEM);
4231 dst->side_data[i].type = src->side_data[i].type;
4232 dst->side_data[i].size = src->side_data[i].size;
4233 dst->side_data[i].data = data;
4237 av_freep(&dst->recommended_encoder_configuration);
4238 if (src->recommended_encoder_configuration) {
4239 const char *conf_str = src->recommended_encoder_configuration;
4240 dst->recommended_encoder_configuration = av_strdup(conf_str);
4241 if (!dst->recommended_encoder_configuration)
4242 return AVERROR(ENOMEM);
4248 static void free_stream(AVStream **pst)
4250 AVStream *st = *pst;
4256 for (i = 0; i < st->nb_side_data; i++)
4257 av_freep(&st->side_data[i].data);
4258 av_freep(&st->side_data);
4261 av_parser_close(st->parser);
4263 if (st->attached_pic.data)
4264 av_packet_unref(&st->attached_pic);
4267 avcodec_free_context(&st->internal->avctx);
4268 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4269 av_bsf_free(&st->internal->bsfcs[i]);
4270 av_freep(&st->internal->bsfcs);
4272 av_bsf_free(&st->internal->extract_extradata.bsf);
4273 av_packet_free(&st->internal->extract_extradata.pkt);
4275 av_freep(&st->internal);
4277 av_dict_free(&st->metadata);
4278 avcodec_parameters_free(&st->codecpar);
4279 av_freep(&st->probe_data.buf);
4280 av_freep(&st->index_entries);
4281 #if FF_API_LAVF_AVCTX
4282 FF_DISABLE_DEPRECATION_WARNINGS
4283 avcodec_free_context(&st->codec);
4284 FF_ENABLE_DEPRECATION_WARNINGS
4286 av_freep(&st->priv_data);
4288 av_freep(&st->info->duration_error);
4289 av_freep(&st->info);
4290 av_freep(&st->recommended_encoder_configuration);
4291 av_freep(&st->priv_pts);
4296 void ff_free_stream(AVFormatContext *s, AVStream *st)
4298 av_assert0(s->nb_streams>0);
4299 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4301 free_stream(&s->streams[ --s->nb_streams ]);
4304 void avformat_free_context(AVFormatContext *s)
4312 if (s->iformat && s->iformat->priv_class && s->priv_data)
4313 av_opt_free(s->priv_data);
4314 if (s->oformat && s->oformat->priv_class && s->priv_data)
4315 av_opt_free(s->priv_data);
4317 for (i = s->nb_streams - 1; i >= 0; i--)
4318 ff_free_stream(s, s->streams[i]);
4321 for (i = s->nb_programs - 1; i >= 0; i--) {
4322 av_dict_free(&s->programs[i]->metadata);
4323 av_freep(&s->programs[i]->stream_index);
4324 av_freep(&s->programs[i]);
4326 av_freep(&s->programs);
4327 av_freep(&s->priv_data);
4328 while (s->nb_chapters--) {
4329 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4330 av_freep(&s->chapters[s->nb_chapters]);
4332 av_freep(&s->chapters);
4333 av_dict_free(&s->metadata);
4334 av_dict_free(&s->internal->id3v2_meta);
4335 av_freep(&s->streams);
4336 flush_packet_queue(s);
4337 av_freep(&s->internal);
4341 void avformat_close_input(AVFormatContext **ps)
4352 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4353 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4356 flush_packet_queue(s);
4359 if (s->iformat->read_close)
4360 s->iformat->read_close(s);
4362 avformat_free_context(s);
4369 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4375 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4376 if (s->max_streams < INT_MAX/sizeof(*streams))
4377 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);
4380 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4383 s->streams = streams;
4385 st = av_mallocz(sizeof(AVStream));
4388 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4392 st->info->last_dts = AV_NOPTS_VALUE;
4394 #if FF_API_LAVF_AVCTX
4395 FF_DISABLE_DEPRECATION_WARNINGS
4396 st->codec = avcodec_alloc_context3(c);
4402 FF_ENABLE_DEPRECATION_WARNINGS
4405 st->internal = av_mallocz(sizeof(*st->internal));
4409 st->codecpar = avcodec_parameters_alloc();
4413 st->internal->avctx = avcodec_alloc_context3(NULL);
4414 if (!st->internal->avctx)
4418 #if FF_API_LAVF_AVCTX
4419 FF_DISABLE_DEPRECATION_WARNINGS
4420 /* no default bitrate if decoding */
4421 st->codec->bit_rate = 0;
4422 FF_ENABLE_DEPRECATION_WARNINGS
4425 /* default pts setting is MPEG-like */
4426 avpriv_set_pts_info(st, 33, 1, 90000);
4427 /* we set the current DTS to 0 so that formats without any timestamps
4428 * but durations get some timestamps, formats with some unknown
4429 * timestamps have their first few packets buffered and the
4430 * timestamps corrected before they are returned to the user */
4431 st->cur_dts = RELATIVE_TS_BASE;
4433 st->cur_dts = AV_NOPTS_VALUE;
4436 st->index = s->nb_streams;
4437 st->start_time = AV_NOPTS_VALUE;
4438 st->duration = AV_NOPTS_VALUE;
4439 st->first_dts = AV_NOPTS_VALUE;
4440 st->probe_packets = MAX_PROBE_PACKETS;
4441 st->pts_wrap_reference = AV_NOPTS_VALUE;
4442 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4444 st->last_IP_pts = AV_NOPTS_VALUE;
4445 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4446 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4447 st->pts_buffer[i] = AV_NOPTS_VALUE;
4449 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4451 #if FF_API_R_FRAME_RATE
4452 st->info->last_dts = AV_NOPTS_VALUE;
4454 st->info->fps_first_dts = AV_NOPTS_VALUE;
4455 st->info->fps_last_dts = AV_NOPTS_VALUE;
4457 st->inject_global_side_data = s->internal->inject_global_side_data;
4459 st->internal->need_context_update = 1;
4461 s->streams[s->nb_streams++] = st;
4468 AVProgram *av_new_program(AVFormatContext *ac, int id)
4470 AVProgram *program = NULL;
4473 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4475 for (i = 0; i < ac->nb_programs; i++)
4476 if (ac->programs[i]->id == id)
4477 program = ac->programs[i];
4480 program = av_mallocz(sizeof(AVProgram));
4483 dynarray_add(&ac->programs, &ac->nb_programs, program);
4484 program->discard = AVDISCARD_NONE;
4487 program->pts_wrap_reference = AV_NOPTS_VALUE;
4488 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4490 program->start_time =
4491 program->end_time = AV_NOPTS_VALUE;
4496 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4497 int64_t start, int64_t end, const char *title)
4499 AVChapter *chapter = NULL;
4502 if (end != AV_NOPTS_VALUE && start > end) {
4503 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4507 for (i = 0; i < s->nb_chapters; i++)
4508 if (s->chapters[i]->id == id)
4509 chapter = s->chapters[i];
4512 chapter = av_mallocz(sizeof(AVChapter));
4515 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4517 av_dict_set(&chapter->metadata, "title", title, 0);
4519 chapter->time_base = time_base;
4520 chapter->start = start;
4526 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4529 AVProgram *program = NULL;
4532 if (idx >= ac->nb_streams) {
4533 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4537 for (i = 0; i < ac->nb_programs; i++) {
4538 if (ac->programs[i]->id != progid)
4540 program = ac->programs[i];
4541 for (j = 0; j < program->nb_stream_indexes; j++)
4542 if (program->stream_index[j] == idx)
4545 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4548 program->stream_index = tmp;
4549 program->stream_index[program->nb_stream_indexes++] = idx;
4554 uint64_t ff_ntp_time(void)
4556 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4559 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4562 char *q, buf1[20], c;
4563 int nd, len, percentd_found;
4575 while (av_isdigit(*p))
4576 nd = nd * 10 + *p++ - '0';
4578 } while (av_isdigit(c));
4584 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4589 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4591 if ((q - buf + len) > buf_size - 1)
4593 memcpy(q, buf1, len);
4601 if ((q - buf) < buf_size - 1)
4605 if (!percentd_found)
4614 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4616 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4619 void av_url_split(char *proto, int proto_size,
4620 char *authorization, int authorization_size,
4621 char *hostname, int hostname_size,
4622 int *port_ptr, char *path, int path_size, const char *url)
4624 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4630 if (authorization_size > 0)
4631 authorization[0] = 0;
4632 if (hostname_size > 0)
4637 /* parse protocol */
4638 if ((p = strchr(url, ':'))) {
4639 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4646 /* no protocol means plain filename */
4647 av_strlcpy(path, url, path_size);
4651 /* separate path from hostname */
4652 ls = strchr(p, '/');
4653 ls2 = strchr(p, '?');
4657 ls = FFMIN(ls, ls2);
4659 av_strlcpy(path, ls, path_size);
4661 ls = &p[strlen(p)]; // XXX
4663 /* the rest is hostname, use that to parse auth/port */
4665 /* authorization (user[:pass]@hostname) */
4667 while ((at = strchr(p, '@')) && at < ls) {
4668 av_strlcpy(authorization, at2,
4669 FFMIN(authorization_size, at + 1 - at2));
4670 p = at + 1; /* skip '@' */
4673 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4675 av_strlcpy(hostname, p + 1,
4676 FFMIN(hostname_size, brk - p));
4677 if (brk[1] == ':' && port_ptr)
4678 *port_ptr = atoi(brk + 2);
4679 } else if ((col = strchr(p, ':')) && col < ls) {
4680 av_strlcpy(hostname, p,
4681 FFMIN(col + 1 - p, hostname_size));
4683 *port_ptr = atoi(col + 1);
4685 av_strlcpy(hostname, p,
4686 FFMIN(ls + 1 - p, hostname_size));
4690 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4693 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4696 'C', 'D', 'E', 'F' };
4697 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4700 'c', 'd', 'e', 'f' };
4701 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4703 for (i = 0; i < s; i++) {
4704 buff[i * 2] = hex_table[src[i] >> 4];
4705 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4711 int ff_hex_to_data(uint8_t *data, const char *p)
4718 p += strspn(p, SPACE_CHARS);
4721 c = av_toupper((unsigned char) *p++);
4722 if (c >= '0' && c <= '9')
4724 else if (c >= 'A' && c <= 'F')
4739 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4740 unsigned int pts_num, unsigned int pts_den)
4743 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4744 if (new_tb.num != pts_num)
4745 av_log(NULL, AV_LOG_DEBUG,
4746 "st:%d removing common factor %d from timebase\n",
4747 s->index, pts_num / new_tb.num);
4749 av_log(NULL, AV_LOG_WARNING,
4750 "st:%d has too large timebase, reducing\n", s->index);
4752 if (new_tb.num <= 0 || new_tb.den <= 0) {
4753 av_log(NULL, AV_LOG_ERROR,
4754 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4755 new_tb.num, new_tb.den,
4759 s->time_base = new_tb;
4760 #if FF_API_LAVF_AVCTX
4761 FF_DISABLE_DEPRECATION_WARNINGS
4762 av_codec_set_pkt_timebase(s->codec, new_tb);
4763 FF_ENABLE_DEPRECATION_WARNINGS
4765 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4766 s->pts_wrap_bits = pts_wrap_bits;
4769 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4772 const char *ptr = str;
4774 /* Parse key=value pairs. */
4777 char *dest = NULL, *dest_end;
4778 int key_len, dest_len = 0;
4780 /* Skip whitespace and potential commas. */
4781 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4788 if (!(ptr = strchr(key, '=')))
4791 key_len = ptr - key;
4793 callback_get_buf(context, key, key_len, &dest, &dest_len);
4794 dest_end = dest + dest_len - 1;
4798 while (*ptr && *ptr != '\"') {
4802 if (dest && dest < dest_end)
4806 if (dest && dest < dest_end)
4814 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4815 if (dest && dest < dest_end)
4823 int ff_find_stream_index(AVFormatContext *s, int id)
4826 for (i = 0; i < s->nb_streams; i++)
4827 if (s->streams[i]->id == id)
4832 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4836 unsigned int codec_tag;
4837 if (ofmt->query_codec)
4838 return ofmt->query_codec(codec_id, std_compliance);
4839 else if (ofmt->codec_tag)
4840 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4841 else if (codec_id == ofmt->video_codec ||
4842 codec_id == ofmt->audio_codec ||
4843 codec_id == ofmt->subtitle_codec ||
4844 codec_id == ofmt->data_codec)
4847 return AVERROR_PATCHWELCOME;
4850 int avformat_network_init(void)
4854 ff_network_inited_globally = 1;
4855 if ((ret = ff_network_init()) < 0)
4857 if ((ret = ff_tls_init()) < 0)
4863 int avformat_network_deinit(void)
4868 ff_network_inited_globally = 0;
4873 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4874 uint64_t channel_layout, int32_t sample_rate,
4875 int32_t width, int32_t height)
4881 return AVERROR(EINVAL);
4884 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4886 if (channel_layout) {
4888 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4892 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4894 if (width || height) {
4896 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4898 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4900 return AVERROR(ENOMEM);
4901 bytestream_put_le32(&data, flags);
4903 bytestream_put_le32(&data, channels);
4905 bytestream_put_le64(&data, channel_layout);
4907 bytestream_put_le32(&data, sample_rate);
4908 if (width || height) {
4909 bytestream_put_le32(&data, width);
4910 bytestream_put_le32(&data, height);
4915 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4917 AVRational undef = {0, 1};
4918 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4919 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4920 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4922 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4923 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4924 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4925 stream_sample_aspect_ratio = undef;
4927 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4928 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4929 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4930 frame_sample_aspect_ratio = undef;
4932 if (stream_sample_aspect_ratio.num)
4933 return stream_sample_aspect_ratio;
4935 return frame_sample_aspect_ratio;
4938 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4940 AVRational fr = st->r_frame_rate;
4941 AVRational codec_fr = st->internal->avctx->framerate;
4942 AVRational avg_fr = st->avg_frame_rate;
4944 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4945 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4950 if (st->internal->avctx->ticks_per_frame > 1) {
4951 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4952 (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))
4959 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4962 if (*spec <= '9' && *spec >= '0') /* opt:index */
4963 return strtol(spec, NULL, 0) == st->index;
4964 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4965 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4966 enum AVMediaType type;
4970 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4971 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4972 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4973 case 'd': type = AVMEDIA_TYPE_DATA; break;
4974 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4975 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4976 default: av_assert0(0);
4978 #if FF_API_LAVF_AVCTX
4979 FF_DISABLE_DEPRECATION_WARNINGS
4980 if (type != st->codecpar->codec_type
4981 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4983 FF_ENABLE_DEPRECATION_WARNINGS
4985 if (type != st->codecpar->codec_type)
4988 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4990 if (*spec++ == ':') { /* possibly followed by :index */
4991 int i, index = strtol(spec, NULL, 0);
4992 for (i = 0; i < s->nb_streams; i++) {
4993 #if FF_API_LAVF_AVCTX
4994 FF_DISABLE_DEPRECATION_WARNINGS
4995 if ((s->streams[i]->codecpar->codec_type == type
4996 || s->streams[i]->codec->codec_type == type
4998 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5000 return i == st->index;
5001 FF_ENABLE_DEPRECATION_WARNINGS
5003 if ((s->streams[i]->codecpar->codec_type == type) &&
5004 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5006 return i == st->index;
5012 } else if (*spec == 'p' && *(spec + 1) == ':') {
5016 prog_id = strtol(spec, &endptr, 0);
5017 for (i = 0; i < s->nb_programs; i++) {
5018 if (s->programs[i]->id != prog_id)
5021 if (*endptr++ == ':') {
5022 int stream_idx = strtol(endptr, NULL, 0);
5023 return stream_idx >= 0 &&
5024 stream_idx < s->programs[i]->nb_stream_indexes &&
5025 st->index == s->programs[i]->stream_index[stream_idx];
5028 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5029 if (st->index == s->programs[i]->stream_index[j])
5033 } else if (*spec == '#' ||
5034 (*spec == 'i' && *(spec + 1) == ':')) {
5037 spec += 1 + (*spec == 'i');
5038 stream_id = strtol(spec, &endptr, 0);
5040 return stream_id == st->id;
5041 } else if (*spec == 'm' && *(spec + 1) == ':') {
5042 AVDictionaryEntry *tag;
5047 val = strchr(spec, ':');
5049 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5051 return AVERROR(ENOMEM);
5053 tag = av_dict_get(st->metadata, key, NULL, 0);
5055 if (!val || !strcmp(tag->value, val + 1))
5064 } else if (*spec == 'u') {
5065 AVCodecParameters *par = st->codecpar;
5066 #if FF_API_LAVF_AVCTX
5067 FF_DISABLE_DEPRECATION_WARNINGS
5068 AVCodecContext *codec = st->codec;
5069 FF_ENABLE_DEPRECATION_WARNINGS
5072 switch (par->codec_type) {
5073 case AVMEDIA_TYPE_AUDIO:
5074 val = par->sample_rate && par->channels;
5075 #if FF_API_LAVF_AVCTX
5076 val = val || (codec->sample_rate && codec->channels);
5078 if (par->format == AV_SAMPLE_FMT_NONE
5079 #if FF_API_LAVF_AVCTX
5080 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5085 case AVMEDIA_TYPE_VIDEO:
5086 val = par->width && par->height;
5087 #if FF_API_LAVF_AVCTX
5088 val = val || (codec->width && codec->height);
5090 if (par->format == AV_PIX_FMT_NONE
5091 #if FF_API_LAVF_AVCTX
5092 && codec->pix_fmt == AV_PIX_FMT_NONE
5097 case AVMEDIA_TYPE_UNKNOWN:
5104 #if FF_API_LAVF_AVCTX
5105 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5107 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5109 } else if (!*spec) /* empty specifier, matches everything */
5112 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5113 return AVERROR(EINVAL);
5116 int ff_generate_avci_extradata(AVStream *st)
5118 static const uint8_t avci100_1080p_extradata[] = {
5120 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5121 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5122 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5123 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5124 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5125 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5126 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5127 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5128 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5130 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5133 static const uint8_t avci100_1080i_extradata[] = {
5135 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5136 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5137 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5138 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5139 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5140 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5141 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5142 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5143 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5144 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5145 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5147 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5150 static const uint8_t avci50_1080p_extradata[] = {
5152 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5153 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5154 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5155 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5156 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5157 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5158 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5159 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5160 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5162 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5165 static const uint8_t avci50_1080i_extradata[] = {
5167 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5168 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5169 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5170 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5171 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5172 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5173 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5174 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5175 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5176 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5177 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5179 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5182 static const uint8_t avci100_720p_extradata[] = {
5184 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5185 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5186 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5187 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5188 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5189 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5190 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5191 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5192 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5193 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5195 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5198 static const uint8_t avci50_720p_extradata[] = {
5200 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5201 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5202 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5203 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5204 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5205 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5206 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5207 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5208 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5210 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5214 const uint8_t *data = NULL;
5217 if (st->codecpar->width == 1920) {
5218 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5219 data = avci100_1080p_extradata;
5220 size = sizeof(avci100_1080p_extradata);
5222 data = avci100_1080i_extradata;
5223 size = sizeof(avci100_1080i_extradata);
5225 } else if (st->codecpar->width == 1440) {
5226 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5227 data = avci50_1080p_extradata;
5228 size = sizeof(avci50_1080p_extradata);
5230 data = avci50_1080i_extradata;
5231 size = sizeof(avci50_1080i_extradata);
5233 } else if (st->codecpar->width == 1280) {
5234 data = avci100_720p_extradata;
5235 size = sizeof(avci100_720p_extradata);
5236 } else if (st->codecpar->width == 960) {
5237 data = avci50_720p_extradata;
5238 size = sizeof(avci50_720p_extradata);
5244 av_freep(&st->codecpar->extradata);
5245 if (ff_alloc_extradata(st->codecpar, size))
5246 return AVERROR(ENOMEM);
5247 memcpy(st->codecpar->extradata, data, size);
5252 #if FF_API_NOCONST_GET_SIDE_DATA
5253 uint8_t *av_stream_get_side_data(AVStream *st,
5254 enum AVPacketSideDataType type, int *size)
5256 uint8_t *av_stream_get_side_data(const AVStream *st,
5257 enum AVPacketSideDataType type, int *size)
5262 for (i = 0; i < st->nb_side_data; i++) {
5263 if (st->side_data[i].type == type) {
5265 *size = st->side_data[i].size;
5266 return st->side_data[i].data;
5272 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5273 uint8_t *data, size_t size)
5275 AVPacketSideData *sd, *tmp;
5278 for (i = 0; i < st->nb_side_data; i++) {
5279 sd = &st->side_data[i];
5281 if (sd->type == type) {
5282 av_freep(&sd->data);
5289 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5290 return AVERROR(ERANGE);
5292 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5294 return AVERROR(ENOMEM);
5297 st->side_data = tmp;
5300 sd = &st->side_data[st->nb_side_data - 1];
5308 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5312 uint8_t *data = av_malloc(size);
5317 ret = av_stream_add_side_data(st, type, data, size);
5326 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5329 const AVBitStreamFilter *bsf;
5331 AVCodecParameters *in_par;
5333 if (!(bsf = av_bsf_get_by_name(name))) {
5334 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5335 return AVERROR_BSF_NOT_FOUND;
5338 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5341 if (st->internal->nb_bsfcs) {
5342 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5343 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5345 in_par = st->codecpar;
5346 bsfc->time_base_in = st->time_base;
5349 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5354 if (args && bsfc->filter->priv_class) {
5355 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5356 const char * shorthand[2] = {NULL};
5359 shorthand[0] = opt->name;
5361 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5367 if ((ret = av_bsf_init(bsfc)) < 0) {
5372 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5377 av_log(NULL, AV_LOG_VERBOSE,
5378 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5379 name, args ? args : "");
5384 FF_DISABLE_DEPRECATION_WARNINGS
5385 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5386 AVBitStreamFilterContext *bsfc)
5390 AVPacket new_pkt = *pkt;
5391 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5392 &new_pkt.data, &new_pkt.size,
5393 pkt->data, pkt->size,
5394 pkt->flags & AV_PKT_FLAG_KEY);
5395 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5396 av_packet_unref(pkt);
5397 memset(pkt, 0, sizeof(*pkt));
5400 if(a == 0 && new_pkt.data != pkt->data) {
5401 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
5403 memcpy(t, new_pkt.data, new_pkt.size);
5404 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5409 a = AVERROR(ENOMEM);
5413 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5414 av_buffer_default_free, NULL, 0);
5416 pkt->side_data = NULL;
5417 pkt->side_data_elems = 0;
5418 av_packet_unref(pkt);
5420 av_freep(&new_pkt.data);
5421 a = AVERROR(ENOMEM);
5425 av_log(codec, AV_LOG_ERROR,
5426 "Failed to open bitstream filter %s for stream %d with codec %s",
5427 bsfc->filter->name, pkt->stream_index,
5428 codec->codec ? codec->codec->name : "copy");
5438 FF_ENABLE_DEPRECATION_WARNINGS
5441 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5444 return AVERROR(EINVAL);
5446 if (!(s->oformat->flags & AVFMT_NOFILE))
5447 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5451 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5454 s->io_close(s, *pb);
5458 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5460 AVDictionaryEntry *entry;
5461 int64_t parsed_timestamp;
5463 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5464 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5465 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5468 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5475 int ff_standardize_creation_time(AVFormatContext *s)
5478 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5480 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5484 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5489 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5491 if (size != AVPALETTE_SIZE) {
5492 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5493 return AVERROR_INVALIDDATA;
5495 memcpy(palette, side_data, AVPALETTE_SIZE);
5499 if (ret == CONTAINS_PAL) {
5501 for (i = 0; i < AVPALETTE_COUNT; i++)
5502 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5509 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5514 ret = av_bprint_finalize(buf, &str);
5517 if (!av_bprint_is_complete(buf)) {
5519 return AVERROR(ENOMEM);
5522 par->extradata = str;
5523 /* Note: the string is NUL terminated (so extradata can be read as a
5524 * string), but the ending character is not accounted in the size (in
5525 * binary formats you are likely not supposed to mux that character). When
5526 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5528 par->extradata_size = buf->len;
5532 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5533 AVStream *ost, const AVStream *ist,
5534 enum AVTimebaseSource copy_tb)
5536 //TODO: use [io]st->internal->avctx
5537 const AVCodecContext *dec_ctx = ist->codec;
5538 AVCodecContext *enc_ctx = ost->codec;
5540 enc_ctx->time_base = ist->time_base;
5542 * Avi is a special case here because it supports variable fps but
5543 * having the fps and timebase differe significantly adds quite some
5546 if (!strcmp(ofmt->name, "avi")) {
5547 #if FF_API_R_FRAME_RATE
5548 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5549 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5550 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5551 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5552 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5553 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5554 enc_ctx->time_base.num = ist->r_frame_rate.den;
5555 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5556 enc_ctx->ticks_per_frame = 2;
5559 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5560 && av_q2d(ist->time_base) < 1.0/500
5561 || copy_tb == AVFMT_TBCF_DECODER) {
5562 enc_ctx->time_base = dec_ctx->time_base;
5563 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5564 enc_ctx->time_base.den *= 2;
5565 enc_ctx->ticks_per_frame = 2;
5567 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5568 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5569 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5570 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5571 && av_q2d(ist->time_base) < 1.0/500
5572 || copy_tb == AVFMT_TBCF_DECODER) {
5573 enc_ctx->time_base = dec_ctx->time_base;
5574 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5578 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5579 && dec_ctx->time_base.num < dec_ctx->time_base.den
5580 && dec_ctx->time_base.num > 0
5581 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5582 enc_ctx->time_base = dec_ctx->time_base;
5585 if (ost->avg_frame_rate.num)
5586 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5588 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5589 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5594 AVRational av_stream_get_codec_timebase(const AVStream *st)
5596 // See avformat_transfer_internal_stream_timing_info() TODO.
5597 #if FF_API_LAVF_AVCTX
5598 FF_DISABLE_DEPRECATION_WARNINGS
5599 return st->codec->time_base;
5600 FF_ENABLE_DEPRECATION_WARNINGS
5602 return st->internal->avctx->time_base;