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)
616 if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
619 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
621 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
623 if ((ret = avformat_queue_attached_pictures(s)) < 0)
626 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
627 s->internal->data_offset = avio_tell(s->pb);
629 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
631 update_stream_avctx(s);
633 for (i = 0; i < s->nb_streams; i++)
634 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
637 av_dict_free(options);
644 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
646 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
648 avformat_free_context(s);
653 /*******************************************************/
655 static void force_codec_ids(AVFormatContext *s, AVStream *st)
657 switch (st->codecpar->codec_type) {
658 case AVMEDIA_TYPE_VIDEO:
659 if (s->video_codec_id)
660 st->codecpar->codec_id = s->video_codec_id;
662 case AVMEDIA_TYPE_AUDIO:
663 if (s->audio_codec_id)
664 st->codecpar->codec_id = s->audio_codec_id;
666 case AVMEDIA_TYPE_SUBTITLE:
667 if (s->subtitle_codec_id)
668 st->codecpar->codec_id = s->subtitle_codec_id;
670 case AVMEDIA_TYPE_DATA:
671 if (s->data_codec_id)
672 st->codecpar->codec_id = s->data_codec_id;
677 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
679 if (st->request_probe>0) {
680 AVProbeData *pd = &st->probe_data;
682 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
686 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
688 av_log(s, AV_LOG_WARNING,
689 "Failed to reallocate probe buffer for stream %d\n",
694 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
695 pd->buf_size += pkt->size;
696 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
699 st->probe_packets = 0;
701 av_log(s, AV_LOG_WARNING,
702 "nothing to probe for stream %d\n", st->index);
706 end= s->internal->raw_packet_buffer_remaining_size <= 0
707 || st->probe_packets<= 0;
709 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
710 int score = set_codec_from_probe_data(s, st, pd);
711 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
715 st->request_probe = -1;
716 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
717 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
719 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
721 force_codec_ids(s, st);
727 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
729 int64_t ref = pkt->dts;
730 int i, pts_wrap_behavior;
731 int64_t pts_wrap_reference;
732 AVProgram *first_program;
734 if (ref == AV_NOPTS_VALUE)
736 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
738 ref &= (1LL << st->pts_wrap_bits)-1;
740 // reference time stamp should be 60 s before first time stamp
741 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
742 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
743 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
744 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
745 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
747 first_program = av_find_program_from_stream(s, NULL, stream_index);
749 if (!first_program) {
750 int default_stream_index = av_find_default_stream_index(s);
751 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
752 for (i = 0; i < s->nb_streams; i++) {
753 if (av_find_program_from_stream(s, NULL, i))
755 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
756 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
760 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
761 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
765 AVProgram *program = first_program;
767 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
768 pts_wrap_reference = program->pts_wrap_reference;
769 pts_wrap_behavior = program->pts_wrap_behavior;
772 program = av_find_program_from_stream(s, program, stream_index);
775 // update every program with differing pts_wrap_reference
776 program = first_program;
778 if (program->pts_wrap_reference != pts_wrap_reference) {
779 for (i = 0; i<program->nb_stream_indexes; i++) {
780 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
781 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
784 program->pts_wrap_reference = pts_wrap_reference;
785 program->pts_wrap_behavior = pts_wrap_behavior;
787 program = av_find_program_from_stream(s, program, stream_index);
793 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
799 AVPacketList *pktl = s->internal->raw_packet_buffer;
803 st = s->streams[pkt->stream_index];
804 if (s->internal->raw_packet_buffer_remaining_size <= 0)
805 if ((err = probe_codec(s, st, NULL)) < 0)
807 if (st->request_probe <= 0) {
808 s->internal->raw_packet_buffer = pktl->next;
809 s->internal->raw_packet_buffer_remaining_size += pkt->size;
818 ret = s->iformat->read_packet(s, pkt);
820 /* Some demuxers return FFERROR_REDO when they consume
821 data and discard it (ignored streams, junk, extradata).
822 We must re-call the demuxer to get the real packet. */
823 if (ret == FFERROR_REDO)
825 if (!pktl || ret == AVERROR(EAGAIN))
827 for (i = 0; i < s->nb_streams; i++) {
829 if (st->probe_packets || st->request_probe > 0)
830 if ((err = probe_codec(s, st, NULL)) < 0)
832 av_assert0(st->request_probe <= 0);
838 AVPacket tmp = { 0 };
839 ret = av_packet_ref(&tmp, pkt);
845 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
846 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
847 av_log(s, AV_LOG_WARNING,
848 "Dropped corrupted packet (stream = %d)\n",
850 av_packet_unref(pkt);
854 if (pkt->stream_index >= (unsigned)s->nb_streams) {
855 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
859 st = s->streams[pkt->stream_index];
861 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
862 // correct first time stamps to negative values
863 if (!is_relative(st->first_dts))
864 st->first_dts = wrap_timestamp(st, st->first_dts);
865 if (!is_relative(st->start_time))
866 st->start_time = wrap_timestamp(st, st->start_time);
867 if (!is_relative(st->cur_dts))
868 st->cur_dts = wrap_timestamp(st, st->cur_dts);
871 pkt->dts = wrap_timestamp(st, pkt->dts);
872 pkt->pts = wrap_timestamp(st, pkt->pts);
874 force_codec_ids(s, st);
876 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
877 if (s->use_wallclock_as_timestamps)
878 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
880 if (!pktl && st->request_probe <= 0)
883 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
884 &s->internal->raw_packet_buffer_end, 0);
887 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
889 if ((err = probe_codec(s, st, pkt)) < 0)
895 /**********************************************************/
897 static int determinable_frame_size(AVCodecContext *avctx)
899 switch(avctx->codec_id) {
900 case AV_CODEC_ID_MP1:
901 case AV_CODEC_ID_MP2:
902 case AV_CODEC_ID_MP3:
910 * Return the frame duration in seconds. Return 0 if not available.
912 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
913 AVCodecParserContext *pc, AVPacket *pkt)
915 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
916 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
917 int frame_size, sample_rate;
919 #if FF_API_LAVF_AVCTX
920 FF_DISABLE_DEPRECATION_WARNINGS
921 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
922 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
923 FF_ENABLE_DEPRECATION_WARNINGS
928 switch (st->codecpar->codec_type) {
929 case AVMEDIA_TYPE_VIDEO:
930 if (st->r_frame_rate.num && !pc && s->iformat) {
931 *pnum = st->r_frame_rate.den;
932 *pden = st->r_frame_rate.num;
933 } else if (st->time_base.num * 1000LL > st->time_base.den) {
934 *pnum = st->time_base.num;
935 *pden = st->time_base.den;
936 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
937 av_assert0(st->internal->avctx->ticks_per_frame);
938 av_reduce(pnum, pden,
940 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
943 if (pc && pc->repeat_pict) {
944 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
945 av_reduce(pnum, pden,
946 (*pnum) * (1LL + pc->repeat_pict),
950 /* If this codec can be interlaced or progressive then we need
951 * a parser to compute duration of a packet. Thus if we have
952 * no parser in such case leave duration undefined. */
953 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
957 case AVMEDIA_TYPE_AUDIO:
958 if (st->internal->avctx_inited) {
959 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
960 sample_rate = st->internal->avctx->sample_rate;
962 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
963 sample_rate = st->codecpar->sample_rate;
965 if (frame_size <= 0 || sample_rate <= 0)
975 static int is_intra_only(enum AVCodecID id)
977 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
980 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
985 static int has_decode_delay_been_guessed(AVStream *st)
987 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
988 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
990 #if CONFIG_H264_DECODER
991 if (st->internal->avctx->has_b_frames &&
992 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
995 if (st->internal->avctx->has_b_frames<3)
996 return st->nb_decoded_frames >= 7;
997 else if (st->internal->avctx->has_b_frames<4)
998 return st->nb_decoded_frames >= 18;
1000 return st->nb_decoded_frames >= 20;
1003 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1007 if (pktl == s->internal->packet_buffer_end)
1008 return s->internal->parse_queue;
1012 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1013 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1014 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1017 int delay = st->internal->avctx->has_b_frames;
1020 if (dts == AV_NOPTS_VALUE) {
1021 int64_t best_score = INT64_MAX;
1022 for (i = 0; i<delay; i++) {
1023 if (st->pts_reorder_error_count[i]) {
1024 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1025 if (score < best_score) {
1027 dts = pts_buffer[i];
1032 for (i = 0; i<delay; i++) {
1033 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1034 int64_t diff = FFABS(pts_buffer[i] - dts)
1035 + (uint64_t)st->pts_reorder_error[i];
1036 diff = FFMAX(diff, st->pts_reorder_error[i]);
1037 st->pts_reorder_error[i] = diff;
1038 st->pts_reorder_error_count[i]++;
1039 if (st->pts_reorder_error_count[i] > 250) {
1040 st->pts_reorder_error[i] >>= 1;
1041 st->pts_reorder_error_count[i] >>= 1;
1048 if (dts == AV_NOPTS_VALUE)
1049 dts = pts_buffer[0];
1055 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1056 * of the packets in a window.
1058 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1059 AVPacketList *pkt_buffer)
1061 AVStream *st = s->streams[stream_index];
1062 int delay = st->internal->avctx->has_b_frames;
1065 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1067 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1068 pts_buffer[i] = AV_NOPTS_VALUE;
1070 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1071 if (pkt_buffer->pkt.stream_index != stream_index)
1074 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1075 pts_buffer[0] = pkt_buffer->pkt.pts;
1076 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1077 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1079 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1084 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1085 int64_t dts, int64_t pts, AVPacket *pkt)
1087 AVStream *st = s->streams[stream_index];
1088 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1089 AVPacketList *pktl_it;
1093 if (st->first_dts != AV_NOPTS_VALUE ||
1094 dts == AV_NOPTS_VALUE ||
1095 st->cur_dts == AV_NOPTS_VALUE ||
1099 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1101 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1103 if (is_relative(pts))
1106 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1107 if (pktl_it->pkt.stream_index != stream_index)
1109 if (is_relative(pktl_it->pkt.pts))
1110 pktl_it->pkt.pts += shift;
1112 if (is_relative(pktl_it->pkt.dts))
1113 pktl_it->pkt.dts += shift;
1115 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1116 st->start_time = pktl_it->pkt.pts;
1117 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1118 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1122 if (has_decode_delay_been_guessed(st)) {
1123 update_dts_from_pts(s, stream_index, pktl);
1126 if (st->start_time == AV_NOPTS_VALUE) {
1127 st->start_time = pts;
1128 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1129 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1133 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1134 int stream_index, int duration)
1136 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1137 int64_t cur_dts = RELATIVE_TS_BASE;
1139 if (st->first_dts != AV_NOPTS_VALUE) {
1140 if (st->update_initial_durations_done)
1142 st->update_initial_durations_done = 1;
1143 cur_dts = st->first_dts;
1144 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1145 if (pktl->pkt.stream_index == stream_index) {
1146 if (pktl->pkt.pts != pktl->pkt.dts ||
1147 pktl->pkt.dts != AV_NOPTS_VALUE ||
1150 cur_dts -= duration;
1153 if (pktl && pktl->pkt.dts != st->first_dts) {
1154 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1155 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1159 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1162 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1163 st->first_dts = cur_dts;
1164 } else if (st->cur_dts != RELATIVE_TS_BASE)
1167 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1168 if (pktl->pkt.stream_index != stream_index)
1170 if ((pktl->pkt.pts == pktl->pkt.dts ||
1171 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1172 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1173 pktl->pkt.dts == st->first_dts ||
1174 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1175 !pktl->pkt.duration) {
1176 pktl->pkt.dts = cur_dts;
1177 if (!st->internal->avctx->has_b_frames)
1178 pktl->pkt.pts = cur_dts;
1179 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1180 pktl->pkt.duration = duration;
1183 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1186 st->cur_dts = cur_dts;
1189 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1190 AVCodecParserContext *pc, AVPacket *pkt,
1191 int64_t next_dts, int64_t next_pts)
1193 int num, den, presentation_delayed, delay, i;
1195 AVRational duration;
1196 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1197 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1199 if (s->flags & AVFMT_FLAG_NOFILLIN)
1202 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1203 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1204 if (st->last_dts_for_order_check <= pkt->dts) {
1207 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1208 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1210 st->last_dts_for_order_check);
1211 st->dts_misordered++;
1213 if (st->dts_ordered + st->dts_misordered > 250) {
1214 st->dts_ordered >>= 1;
1215 st->dts_misordered >>= 1;
1219 st->last_dts_for_order_check = pkt->dts;
1220 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1221 pkt->dts = AV_NOPTS_VALUE;
1224 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1225 pkt->dts = AV_NOPTS_VALUE;
1227 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1228 && !st->internal->avctx->has_b_frames)
1229 //FIXME Set low_delay = 0 when has_b_frames = 1
1230 st->internal->avctx->has_b_frames = 1;
1232 /* do we have a video B-frame ? */
1233 delay = st->internal->avctx->has_b_frames;
1234 presentation_delayed = 0;
1236 /* XXX: need has_b_frame, but cannot get it if the codec is
1237 * not initialized */
1239 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1240 presentation_delayed = 1;
1242 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1243 st->pts_wrap_bits < 63 &&
1244 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1245 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1246 pkt->dts -= 1LL << st->pts_wrap_bits;
1248 pkt->pts += 1LL << st->pts_wrap_bits;
1251 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1252 * We take the conservative approach and discard both.
1253 * Note: If this is misbehaving for an H.264 file, then possibly
1254 * presentation_delayed is not set correctly. */
1255 if (delay == 1 && pkt->dts == pkt->pts &&
1256 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1257 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1258 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1259 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1260 pkt->dts = AV_NOPTS_VALUE;
1263 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1264 if (pkt->duration == 0) {
1265 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1267 duration = (AVRational) {num, den};
1268 pkt->duration = av_rescale_rnd(1,
1269 num * (int64_t) st->time_base.den,
1270 den * (int64_t) st->time_base.num,
1275 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1276 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1278 /* Correct timestamps with byte offset if demuxers only have timestamps
1279 * on packet boundaries */
1280 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1281 /* this will estimate bitrate based on this frame's duration and size */
1282 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1283 if (pkt->pts != AV_NOPTS_VALUE)
1285 if (pkt->dts != AV_NOPTS_VALUE)
1289 /* This may be redundant, but it should not hurt. */
1290 if (pkt->dts != AV_NOPTS_VALUE &&
1291 pkt->pts != AV_NOPTS_VALUE &&
1292 pkt->pts > pkt->dts)
1293 presentation_delayed = 1;
1295 if (s->debug & FF_FDEBUG_TS)
1296 av_log(s, AV_LOG_TRACE,
1297 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1298 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1299 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1301 /* Interpolate PTS and DTS if they are not present. We skip H264
1302 * currently because delay and has_b_frames are not reliably set. */
1303 if ((delay == 0 || (delay == 1 && pc)) &&
1305 if (presentation_delayed) {
1306 /* DTS = decompression timestamp */
1307 /* PTS = presentation timestamp */
1308 if (pkt->dts == AV_NOPTS_VALUE)
1309 pkt->dts = st->last_IP_pts;
1310 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1311 if (pkt->dts == AV_NOPTS_VALUE)
1312 pkt->dts = st->cur_dts;
1314 /* This is tricky: the dts must be incremented by the duration
1315 * of the frame we are displaying, i.e. the last I- or P-frame. */
1316 if (st->last_IP_duration == 0)
1317 st->last_IP_duration = pkt->duration;
1318 if (pkt->dts != AV_NOPTS_VALUE)
1319 st->cur_dts = pkt->dts + st->last_IP_duration;
1320 if (pkt->dts != AV_NOPTS_VALUE &&
1321 pkt->pts == AV_NOPTS_VALUE &&
1322 st->last_IP_duration > 0 &&
1323 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1324 next_dts != next_pts &&
1325 next_pts != AV_NOPTS_VALUE)
1326 pkt->pts = next_dts;
1328 st->last_IP_duration = pkt->duration;
1329 st->last_IP_pts = pkt->pts;
1330 /* Cannot compute PTS if not present (we can compute it only
1331 * by knowing the future. */
1332 } else if (pkt->pts != AV_NOPTS_VALUE ||
1333 pkt->dts != AV_NOPTS_VALUE ||
1336 /* presentation is not delayed : PTS and DTS are the same */
1337 if (pkt->pts == AV_NOPTS_VALUE)
1338 pkt->pts = pkt->dts;
1339 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1341 if (pkt->pts == AV_NOPTS_VALUE)
1342 pkt->pts = st->cur_dts;
1343 pkt->dts = pkt->pts;
1344 if (pkt->pts != AV_NOPTS_VALUE)
1345 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1349 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1350 st->pts_buffer[0] = pkt->pts;
1351 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1352 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1354 if(has_decode_delay_been_guessed(st))
1355 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1357 // We skipped it above so we try here.
1359 // This should happen on the first packet
1360 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1361 if (pkt->dts > st->cur_dts)
1362 st->cur_dts = pkt->dts;
1364 if (s->debug & FF_FDEBUG_TS)
1365 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1366 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1369 if (is_intra_only(st->codecpar->codec_id))
1370 pkt->flags |= AV_PKT_FLAG_KEY;
1371 #if FF_API_CONVERGENCE_DURATION
1372 FF_DISABLE_DEPRECATION_WARNINGS
1374 pkt->convergence_duration = pc->convergence_duration;
1375 FF_ENABLE_DEPRECATION_WARNINGS
1379 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1382 AVPacketList *pktl = *pkt_buf;
1383 *pkt_buf = pktl->next;
1384 av_packet_unref(&pktl->pkt);
1387 *pkt_buf_end = NULL;
1391 * Parse a packet, add all split parts to parse_queue.
1393 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1395 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1397 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1398 AVStream *st = s->streams[stream_index];
1399 uint8_t *data = pkt ? pkt->data : NULL;
1400 int size = pkt ? pkt->size : 0;
1401 int ret = 0, got_output = 0;
1404 av_init_packet(&flush_pkt);
1407 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1408 // preserve 0-size sync packets
1409 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1412 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1414 int64_t next_pts = pkt->pts;
1415 int64_t next_dts = pkt->dts;
1417 av_init_packet(&out_pkt);
1418 len = av_parser_parse2(st->parser, st->internal->avctx,
1419 &out_pkt.data, &out_pkt.size, data, size,
1420 pkt->pts, pkt->dts, pkt->pos);
1422 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1424 /* increment read pointer */
1428 got_output = !!out_pkt.size;
1433 if (pkt->side_data) {
1434 out_pkt.side_data = pkt->side_data;
1435 out_pkt.side_data_elems = pkt->side_data_elems;
1436 pkt->side_data = NULL;
1437 pkt->side_data_elems = 0;
1440 /* set the duration */
1441 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1442 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1443 if (st->internal->avctx->sample_rate > 0) {
1445 av_rescale_q_rnd(st->parser->duration,
1446 (AVRational) { 1, st->internal->avctx->sample_rate },
1452 out_pkt.stream_index = st->index;
1453 out_pkt.pts = st->parser->pts;
1454 out_pkt.dts = st->parser->dts;
1455 out_pkt.pos = st->parser->pos;
1457 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1458 out_pkt.pos = st->parser->frame_offset;
1460 if (st->parser->key_frame == 1 ||
1461 (st->parser->key_frame == -1 &&
1462 st->parser->pict_type == AV_PICTURE_TYPE_I))
1463 out_pkt.flags |= AV_PKT_FLAG_KEY;
1465 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1466 out_pkt.flags |= AV_PKT_FLAG_KEY;
1468 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1470 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1471 &s->internal->parse_queue_end, 1);
1472 av_packet_unref(&out_pkt);
1477 /* end of the stream => close and free the parser */
1478 if (pkt == &flush_pkt) {
1479 av_parser_close(st->parser);
1484 av_packet_unref(pkt);
1488 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1489 AVPacketList **pkt_buffer_end,
1493 av_assert0(*pkt_buffer);
1496 *pkt_buffer = pktl->next;
1498 *pkt_buffer_end = NULL;
1503 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1505 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1508 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1510 int ret = 0, i, got_packet = 0;
1511 AVDictionary *metadata = NULL;
1513 av_init_packet(pkt);
1515 while (!got_packet && !s->internal->parse_queue) {
1519 /* read next packet */
1520 ret = ff_read_packet(s, &cur_pkt);
1522 if (ret == AVERROR(EAGAIN))
1524 /* flush the parsers */
1525 for (i = 0; i < s->nb_streams; i++) {
1527 if (st->parser && st->need_parsing)
1528 parse_packet(s, NULL, st->index);
1530 /* all remaining packets are now in parse_queue =>
1531 * really terminate parsing */
1535 st = s->streams[cur_pkt.stream_index];
1537 /* update context if required */
1538 if (st->internal->need_context_update) {
1539 if (avcodec_is_open(st->internal->avctx)) {
1540 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1541 avcodec_close(st->internal->avctx);
1542 st->info->found_decoder = 0;
1545 /* close parser, because it depends on the codec */
1546 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1547 av_parser_close(st->parser);
1551 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1555 #if FF_API_LAVF_AVCTX
1556 FF_DISABLE_DEPRECATION_WARNINGS
1557 /* update deprecated public codec context */
1558 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1561 FF_ENABLE_DEPRECATION_WARNINGS
1564 st->internal->need_context_update = 0;
1567 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1568 cur_pkt.dts != AV_NOPTS_VALUE &&
1569 cur_pkt.pts < cur_pkt.dts) {
1570 av_log(s, AV_LOG_WARNING,
1571 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1572 cur_pkt.stream_index,
1573 av_ts2str(cur_pkt.pts),
1574 av_ts2str(cur_pkt.dts),
1577 if (s->debug & FF_FDEBUG_TS)
1578 av_log(s, AV_LOG_DEBUG,
1579 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1580 cur_pkt.stream_index,
1581 av_ts2str(cur_pkt.pts),
1582 av_ts2str(cur_pkt.dts),
1583 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1585 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1586 st->parser = av_parser_init(st->codecpar->codec_id);
1588 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1589 "%s, packets or times may be invalid.\n",
1590 avcodec_get_name(st->codecpar->codec_id));
1591 /* no parser available: just output the raw packets */
1592 st->need_parsing = AVSTREAM_PARSE_NONE;
1593 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1594 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1595 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1596 st->parser->flags |= PARSER_FLAG_ONCE;
1597 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1598 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1601 if (!st->need_parsing || !st->parser) {
1602 /* no parsing needed: we just output the packet as is */
1604 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1605 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1606 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1607 ff_reduce_index(s, st->index);
1608 av_add_index_entry(st, pkt->pos, pkt->dts,
1609 0, 0, AVINDEX_KEYFRAME);
1612 } else if (st->discard < AVDISCARD_ALL) {
1613 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1615 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1616 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1617 st->codecpar->channels = st->internal->avctx->channels;
1618 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1619 st->codecpar->codec_id = st->internal->avctx->codec_id;
1622 av_packet_unref(&cur_pkt);
1624 if (pkt->flags & AV_PKT_FLAG_KEY)
1625 st->skip_to_keyframe = 0;
1626 if (st->skip_to_keyframe) {
1627 av_packet_unref(&cur_pkt);
1635 if (!got_packet && s->internal->parse_queue)
1636 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1639 AVStream *st = s->streams[pkt->stream_index];
1640 int discard_padding = 0;
1641 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1642 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1643 int64_t sample = ts_to_samples(st, pts);
1644 int duration = ts_to_samples(st, pkt->duration);
1645 int64_t end_sample = sample + duration;
1646 if (duration > 0 && end_sample >= st->first_discard_sample &&
1647 sample < st->last_discard_sample)
1648 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1650 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1651 st->skip_samples = st->start_skip_samples;
1652 if (st->skip_samples || discard_padding) {
1653 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1655 AV_WL32(p, st->skip_samples);
1656 AV_WL32(p + 4, discard_padding);
1657 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1659 st->skip_samples = 0;
1662 if (st->inject_global_side_data) {
1663 for (i = 0; i < st->nb_side_data; i++) {
1664 AVPacketSideData *src_sd = &st->side_data[i];
1667 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1670 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1672 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1676 memcpy(dst_data, src_sd->data, src_sd->size);
1678 st->inject_global_side_data = 0;
1681 #if FF_API_LAVF_MERGE_SD
1682 FF_DISABLE_DEPRECATION_WARNINGS
1683 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1684 av_packet_merge_side_data(pkt);
1685 FF_ENABLE_DEPRECATION_WARNINGS
1689 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1691 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1692 av_dict_copy(&s->metadata, metadata, 0);
1693 av_dict_free(&metadata);
1694 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1697 #if FF_API_LAVF_AVCTX
1698 update_stream_avctx(s);
1701 if (s->debug & FF_FDEBUG_TS)
1702 av_log(s, AV_LOG_DEBUG,
1703 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1704 "size=%d, duration=%"PRId64", flags=%d\n",
1706 av_ts2str(pkt->pts),
1707 av_ts2str(pkt->dts),
1708 pkt->size, pkt->duration, pkt->flags);
1713 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1715 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1721 ret = s->internal->packet_buffer
1722 ? read_from_packet_buffer(&s->internal->packet_buffer,
1723 &s->internal->packet_buffer_end, pkt)
1724 : read_frame_internal(s, pkt);
1731 AVPacketList *pktl = s->internal->packet_buffer;
1734 AVPacket *next_pkt = &pktl->pkt;
1736 if (next_pkt->dts != AV_NOPTS_VALUE) {
1737 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1738 // last dts seen for this stream. if any of packets following
1739 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1740 int64_t last_dts = next_pkt->dts;
1741 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1742 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1743 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1744 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1746 next_pkt->pts = pktl->pkt.dts;
1748 if (last_dts != AV_NOPTS_VALUE) {
1749 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1750 last_dts = pktl->pkt.dts;
1755 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1756 // Fixing the last reference frame had none pts issue (For MXF etc).
1757 // We only do this when
1759 // 2. we are not able to resolve a pts value for current packet.
1760 // 3. the packets for this stream at the end of the files had valid dts.
1761 next_pkt->pts = last_dts + next_pkt->duration;
1763 pktl = s->internal->packet_buffer;
1766 /* read packet from packet buffer, if there is data */
1767 st = s->streams[next_pkt->stream_index];
1768 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1769 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1770 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1771 &s->internal->packet_buffer_end, pkt);
1776 ret = read_frame_internal(s, pkt);
1778 if (pktl && ret != AVERROR(EAGAIN)) {
1785 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1786 &s->internal->packet_buffer_end, 1);
1787 av_packet_unref(pkt);
1794 st = s->streams[pkt->stream_index];
1795 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1796 ff_reduce_index(s, st->index);
1797 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1800 if (is_relative(pkt->dts))
1801 pkt->dts -= RELATIVE_TS_BASE;
1802 if (is_relative(pkt->pts))
1803 pkt->pts -= RELATIVE_TS_BASE;
1808 /* XXX: suppress the packet queue */
1809 static void flush_packet_queue(AVFormatContext *s)
1813 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1814 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1815 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1817 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1820 /*******************************************************/
1823 int av_find_default_stream_index(AVFormatContext *s)
1827 int best_stream = 0;
1828 int best_score = INT_MIN;
1830 if (s->nb_streams <= 0)
1832 for (i = 0; i < s->nb_streams; i++) {
1835 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1836 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1838 if (st->codecpar->width && st->codecpar->height)
1842 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1843 if (st->codecpar->sample_rate)
1846 if (st->codec_info_nb_frames)
1849 if (st->discard != AVDISCARD_ALL)
1852 if (score > best_score) {
1860 /** Flush the frame reader. */
1861 void ff_read_frame_flush(AVFormatContext *s)
1866 flush_packet_queue(s);
1868 /* Reset read state for each stream. */
1869 for (i = 0; i < s->nb_streams; i++) {
1873 av_parser_close(st->parser);
1876 st->last_IP_pts = AV_NOPTS_VALUE;
1877 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1878 if (st->first_dts == AV_NOPTS_VALUE)
1879 st->cur_dts = RELATIVE_TS_BASE;
1881 /* We set the current DTS to an unspecified origin. */
1882 st->cur_dts = AV_NOPTS_VALUE;
1884 st->probe_packets = MAX_PROBE_PACKETS;
1886 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1887 st->pts_buffer[j] = AV_NOPTS_VALUE;
1889 if (s->internal->inject_global_side_data)
1890 st->inject_global_side_data = 1;
1892 st->skip_samples = 0;
1896 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1900 for (i = 0; i < s->nb_streams; i++) {
1901 AVStream *st = s->streams[i];
1904 av_rescale(timestamp,
1905 st->time_base.den * (int64_t) ref_st->time_base.num,
1906 st->time_base.num * (int64_t) ref_st->time_base.den);
1910 void ff_reduce_index(AVFormatContext *s, int stream_index)
1912 AVStream *st = s->streams[stream_index];
1913 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1915 if ((unsigned) st->nb_index_entries >= max_entries) {
1917 for (i = 0; 2 * i < st->nb_index_entries; i++)
1918 st->index_entries[i] = st->index_entries[2 * i];
1919 st->nb_index_entries = i;
1923 int ff_add_index_entry(AVIndexEntry **index_entries,
1924 int *nb_index_entries,
1925 unsigned int *index_entries_allocated_size,
1926 int64_t pos, int64_t timestamp,
1927 int size, int distance, int flags)
1929 AVIndexEntry *entries, *ie;
1932 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1935 if (timestamp == AV_NOPTS_VALUE)
1936 return AVERROR(EINVAL);
1938 if (size < 0 || size > 0x3FFFFFFF)
1939 return AVERROR(EINVAL);
1941 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1942 timestamp -= RELATIVE_TS_BASE;
1944 entries = av_fast_realloc(*index_entries,
1945 index_entries_allocated_size,
1946 (*nb_index_entries + 1) *
1947 sizeof(AVIndexEntry));
1951 *index_entries = entries;
1953 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1954 timestamp, AVSEEK_FLAG_ANY);
1957 index = (*nb_index_entries)++;
1958 ie = &entries[index];
1959 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1961 ie = &entries[index];
1962 if (ie->timestamp != timestamp) {
1963 if (ie->timestamp <= timestamp)
1965 memmove(entries + index + 1, entries + index,
1966 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1967 (*nb_index_entries)++;
1968 } else if (ie->pos == pos && distance < ie->min_distance)
1969 // do not reduce the distance
1970 distance = ie->min_distance;
1974 ie->timestamp = timestamp;
1975 ie->min_distance = distance;
1982 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1983 int size, int distance, int flags)
1985 timestamp = wrap_timestamp(st, timestamp);
1986 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1987 &st->index_entries_allocated_size, pos,
1988 timestamp, size, distance, flags);
1991 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1992 int64_t wanted_timestamp, int flags)
2000 // Optimize appending index entries at the end.
2001 if (b && entries[b - 1].timestamp < wanted_timestamp)
2007 // Search for the next non-discarded packet.
2008 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2010 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2016 timestamp = entries[m].timestamp;
2017 if (timestamp >= wanted_timestamp)
2019 if (timestamp <= wanted_timestamp)
2022 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2024 if (!(flags & AVSEEK_FLAG_ANY))
2025 while (m >= 0 && m < nb_entries &&
2026 !(entries[m].flags & AVINDEX_KEYFRAME))
2027 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2029 if (m == nb_entries)
2034 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2037 int64_t pos_delta = 0;
2039 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2040 const char *proto = avio_find_protocol_name(s->filename);
2043 av_log(s, AV_LOG_INFO,
2044 "Protocol name not provided, cannot determine if input is local or "
2045 "a network protocol, buffers and access patterns cannot be configured "
2046 "optimally without knowing the protocol\n");
2049 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2052 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2053 AVStream *st1 = s->streams[ist1];
2054 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2055 AVStream *st2 = s->streams[ist2];
2061 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2062 AVIndexEntry *e1 = &st1->index_entries[i1];
2063 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2065 skip = FFMAX(skip, e1->size);
2066 for (; i2 < st2->nb_index_entries; i2++) {
2067 AVIndexEntry *e2 = &st2->index_entries[i2];
2068 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2069 if (e2_pts - e1_pts < time_tolerance)
2071 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2079 /* XXX This could be adjusted depending on protocol*/
2080 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2081 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2082 ffio_set_buf_size(s->pb, pos_delta);
2083 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2086 if (skip < (1<<23)) {
2087 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2091 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2093 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2094 wanted_timestamp, flags);
2097 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2098 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2100 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2101 if (stream_index >= 0)
2102 ts = wrap_timestamp(s->streams[stream_index], ts);
2106 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2107 int64_t target_ts, int flags)
2109 AVInputFormat *avif = s->iformat;
2110 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2111 int64_t ts_min, ts_max, ts;
2116 if (stream_index < 0)
2119 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2122 ts_min = AV_NOPTS_VALUE;
2123 pos_limit = -1; // GCC falsely says it may be uninitialized.
2125 st = s->streams[stream_index];
2126 if (st->index_entries) {
2129 /* FIXME: Whole function must be checked for non-keyframe entries in
2130 * index case, especially read_timestamp(). */
2131 index = av_index_search_timestamp(st, target_ts,
2132 flags | AVSEEK_FLAG_BACKWARD);
2133 index = FFMAX(index, 0);
2134 e = &st->index_entries[index];
2136 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2138 ts_min = e->timestamp;
2139 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2140 pos_min, av_ts2str(ts_min));
2142 av_assert1(index == 0);
2145 index = av_index_search_timestamp(st, target_ts,
2146 flags & ~AVSEEK_FLAG_BACKWARD);
2147 av_assert0(index < st->nb_index_entries);
2149 e = &st->index_entries[index];
2150 av_assert1(e->timestamp >= target_ts);
2152 ts_max = e->timestamp;
2153 pos_limit = pos_max - e->min_distance;
2154 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2155 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2159 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2160 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2165 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2168 ff_read_frame_flush(s);
2169 ff_update_cur_dts(s, st, ts);
2174 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2175 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2177 int64_t step = 1024;
2178 int64_t limit, ts_max;
2179 int64_t filesize = avio_size(s->pb);
2180 int64_t pos_max = filesize - 1;
2183 pos_max = FFMAX(0, (pos_max) - step);
2184 ts_max = ff_read_timestamp(s, stream_index,
2185 &pos_max, limit, read_timestamp);
2187 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2188 if (ts_max == AV_NOPTS_VALUE)
2192 int64_t tmp_pos = pos_max + 1;
2193 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2194 &tmp_pos, INT64_MAX, read_timestamp);
2195 if (tmp_ts == AV_NOPTS_VALUE)
2197 av_assert0(tmp_pos > pos_max);
2200 if (tmp_pos >= filesize)
2212 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2213 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2214 int64_t ts_min, int64_t ts_max,
2215 int flags, int64_t *ts_ret,
2216 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2217 int64_t *, int64_t))
2224 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2226 if (ts_min == AV_NOPTS_VALUE) {
2227 pos_min = s->internal->data_offset;
2228 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2229 if (ts_min == AV_NOPTS_VALUE)
2233 if (ts_min >= target_ts) {
2238 if (ts_max == AV_NOPTS_VALUE) {
2239 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2241 pos_limit = pos_max;
2244 if (ts_max <= target_ts) {
2249 av_assert0(ts_min < ts_max);
2252 while (pos_min < pos_limit) {
2253 av_log(s, AV_LOG_TRACE,
2254 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2255 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2256 av_assert0(pos_limit <= pos_max);
2258 if (no_change == 0) {
2259 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2260 // interpolate position (better than dichotomy)
2261 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2263 pos_min - approximate_keyframe_distance;
2264 } else if (no_change == 1) {
2265 // bisection if interpolation did not change min / max pos last time
2266 pos = (pos_min + pos_limit) >> 1;
2268 /* linear search if bisection failed, can only happen if there
2269 * are very few or no keyframes between min/max */
2274 else if (pos > pos_limit)
2278 // May pass pos_limit instead of -1.
2279 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2284 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2285 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2286 pos_min, pos, pos_max,
2287 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2288 pos_limit, start_pos, no_change);
2289 if (ts == AV_NOPTS_VALUE) {
2290 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2293 if (target_ts <= ts) {
2294 pos_limit = start_pos - 1;
2298 if (target_ts >= ts) {
2304 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2305 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2308 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2310 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2311 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2312 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2318 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2319 int64_t pos, int flags)
2321 int64_t pos_min, pos_max;
2323 pos_min = s->internal->data_offset;
2324 pos_max = avio_size(s->pb) - 1;
2328 else if (pos > pos_max)
2331 avio_seek(s->pb, pos, SEEK_SET);
2333 s->io_repositioned = 1;
2338 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2339 int64_t timestamp, int flags)
2346 st = s->streams[stream_index];
2348 index = av_index_search_timestamp(st, timestamp, flags);
2350 if (index < 0 && st->nb_index_entries &&
2351 timestamp < st->index_entries[0].timestamp)
2354 if (index < 0 || index == st->nb_index_entries - 1) {
2358 if (st->nb_index_entries) {
2359 av_assert0(st->index_entries);
2360 ie = &st->index_entries[st->nb_index_entries - 1];
2361 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2363 ff_update_cur_dts(s, st, ie->timestamp);
2365 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2371 read_status = av_read_frame(s, &pkt);
2372 } while (read_status == AVERROR(EAGAIN));
2373 if (read_status < 0)
2375 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2376 if (pkt.flags & AV_PKT_FLAG_KEY) {
2377 av_packet_unref(&pkt);
2380 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2381 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);
2382 av_packet_unref(&pkt);
2386 av_packet_unref(&pkt);
2388 index = av_index_search_timestamp(st, timestamp, flags);
2393 ff_read_frame_flush(s);
2394 if (s->iformat->read_seek)
2395 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2397 ie = &st->index_entries[index];
2398 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2400 ff_update_cur_dts(s, st, ie->timestamp);
2405 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2406 int64_t timestamp, int flags)
2411 if (flags & AVSEEK_FLAG_BYTE) {
2412 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2414 ff_read_frame_flush(s);
2415 return seek_frame_byte(s, stream_index, timestamp, flags);
2418 if (stream_index < 0) {
2419 stream_index = av_find_default_stream_index(s);
2420 if (stream_index < 0)
2423 st = s->streams[stream_index];
2424 /* timestamp for default must be expressed in AV_TIME_BASE units */
2425 timestamp = av_rescale(timestamp, st->time_base.den,
2426 AV_TIME_BASE * (int64_t) st->time_base.num);
2429 /* first, we try the format specific seek */
2430 if (s->iformat->read_seek) {
2431 ff_read_frame_flush(s);
2432 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2438 if (s->iformat->read_timestamp &&
2439 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2440 ff_read_frame_flush(s);
2441 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2442 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2443 ff_read_frame_flush(s);
2444 return seek_frame_generic(s, stream_index, timestamp, flags);
2449 int av_seek_frame(AVFormatContext *s, int stream_index,
2450 int64_t timestamp, int flags)
2454 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2455 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2456 if ((flags & AVSEEK_FLAG_BACKWARD))
2460 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2461 flags & ~AVSEEK_FLAG_BACKWARD);
2464 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2467 ret = avformat_queue_attached_pictures(s);
2472 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2473 int64_t ts, int64_t max_ts, int flags)
2475 if (min_ts > ts || max_ts < ts)
2477 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2478 return AVERROR(EINVAL);
2481 flags |= AVSEEK_FLAG_ANY;
2482 flags &= ~AVSEEK_FLAG_BACKWARD;
2484 if (s->iformat->read_seek2) {
2486 ff_read_frame_flush(s);
2488 if (stream_index == -1 && s->nb_streams == 1) {
2489 AVRational time_base = s->streams[0]->time_base;
2490 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2491 min_ts = av_rescale_rnd(min_ts, time_base.den,
2492 time_base.num * (int64_t)AV_TIME_BASE,
2493 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2494 max_ts = av_rescale_rnd(max_ts, time_base.den,
2495 time_base.num * (int64_t)AV_TIME_BASE,
2496 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2500 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2504 ret = avformat_queue_attached_pictures(s);
2508 if (s->iformat->read_timestamp) {
2509 // try to seek via read_timestamp()
2512 // Fall back on old API if new is not implemented but old is.
2513 // Note the old API has somewhat different semantics.
2514 if (s->iformat->read_seek || 1) {
2515 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2516 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2517 if (ret<0 && ts != min_ts && max_ts != ts) {
2518 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2520 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2525 // try some generic seek like seek_frame_generic() but with new ts semantics
2526 return -1; //unreachable
2529 int avformat_flush(AVFormatContext *s)
2531 ff_read_frame_flush(s);
2535 /*******************************************************/
2538 * Return TRUE if the stream has accurate duration in any stream.
2540 * @return TRUE if the stream has accurate duration for at least one component.
2542 static int has_duration(AVFormatContext *ic)
2547 for (i = 0; i < ic->nb_streams; i++) {
2548 st = ic->streams[i];
2549 if (st->duration != AV_NOPTS_VALUE)
2552 if (ic->duration != AV_NOPTS_VALUE)
2558 * Estimate the stream timings from the one of each components.
2560 * Also computes the global bitrate if possible.
2562 static void update_stream_timings(AVFormatContext *ic)
2564 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2565 int64_t duration, duration1, filesize;
2570 start_time = INT64_MAX;
2571 start_time_text = INT64_MAX;
2572 end_time = INT64_MIN;
2573 end_time_text = INT64_MIN;
2574 duration = INT64_MIN;
2575 for (i = 0; i < ic->nb_streams; i++) {
2576 st = ic->streams[i];
2577 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2578 start_time1 = av_rescale_q(st->start_time, st->time_base,
2580 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2581 if (start_time1 < start_time_text)
2582 start_time_text = start_time1;
2584 start_time = FFMIN(start_time, start_time1);
2585 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2587 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2588 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2589 end_time1 += start_time1;
2590 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2591 end_time_text = FFMAX(end_time_text, end_time1);
2593 end_time = FFMAX(end_time, end_time1);
2595 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2596 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2597 p->start_time = start_time1;
2598 if (p->end_time < end_time1)
2599 p->end_time = end_time1;
2602 if (st->duration != AV_NOPTS_VALUE) {
2603 duration1 = av_rescale_q(st->duration, st->time_base,
2605 duration = FFMAX(duration, duration1);
2608 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2609 start_time = start_time_text;
2610 else if (start_time > start_time_text)
2611 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2613 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2614 end_time = end_time_text;
2615 } else if (end_time < end_time_text) {
2616 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2619 if (start_time != INT64_MAX) {
2620 ic->start_time = start_time;
2621 if (end_time != INT64_MIN) {
2622 if (ic->nb_programs > 1) {
2623 for (i = 0; i < ic->nb_programs; i++) {
2624 p = ic->programs[i];
2625 if (p->start_time != AV_NOPTS_VALUE &&
2626 p->end_time > p->start_time &&
2627 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2628 duration = FFMAX(duration, p->end_time - p->start_time);
2630 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2631 duration = FFMAX(duration, end_time - start_time);
2635 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2636 ic->duration = duration;
2638 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2639 /* compute the bitrate */
2640 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2641 (double) ic->duration;
2642 if (bitrate >= 0 && bitrate <= INT64_MAX)
2643 ic->bit_rate = bitrate;
2647 static void fill_all_stream_timings(AVFormatContext *ic)
2652 update_stream_timings(ic);
2653 for (i = 0; i < ic->nb_streams; i++) {
2654 st = ic->streams[i];
2655 if (st->start_time == AV_NOPTS_VALUE) {
2656 if (ic->start_time != AV_NOPTS_VALUE)
2657 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2659 if (ic->duration != AV_NOPTS_VALUE)
2660 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2666 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2668 int64_t filesize, duration;
2669 int i, show_warning = 0;
2672 /* if bit_rate is already set, we believe it */
2673 if (ic->bit_rate <= 0) {
2674 int64_t bit_rate = 0;
2675 for (i = 0; i < ic->nb_streams; i++) {
2676 st = ic->streams[i];
2677 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2678 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2679 if (st->codecpar->bit_rate > 0) {
2680 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2684 bit_rate += st->codecpar->bit_rate;
2685 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2686 // If we have a videostream with packets but without a bitrate
2687 // then consider the sum not known
2692 ic->bit_rate = bit_rate;
2695 /* if duration is already set, we believe it */
2696 if (ic->duration == AV_NOPTS_VALUE &&
2697 ic->bit_rate != 0) {
2698 filesize = ic->pb ? avio_size(ic->pb) : 0;
2699 if (filesize > ic->internal->data_offset) {
2700 filesize -= ic->internal->data_offset;
2701 for (i = 0; i < ic->nb_streams; i++) {
2702 st = ic->streams[i];
2703 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2704 && st->duration == AV_NOPTS_VALUE) {
2705 duration = av_rescale(8 * filesize, st->time_base.den,
2707 (int64_t) st->time_base.num);
2708 st->duration = duration;
2715 av_log(ic, AV_LOG_WARNING,
2716 "Estimating duration from bitrate, this may be inaccurate\n");
2719 #define DURATION_MAX_READ_SIZE 250000LL
2720 #define DURATION_MAX_RETRY 6
2722 /* only usable for MPEG-PS streams */
2723 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2725 AVPacket pkt1, *pkt = &pkt1;
2727 int num, den, read_size, i, ret;
2728 int found_duration = 0;
2730 int64_t filesize, offset, duration;
2733 /* flush packet queue */
2734 flush_packet_queue(ic);
2736 for (i = 0; i < ic->nb_streams; i++) {
2737 st = ic->streams[i];
2738 if (st->start_time == AV_NOPTS_VALUE &&
2739 st->first_dts == AV_NOPTS_VALUE &&
2740 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2741 av_log(ic, AV_LOG_WARNING,
2742 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2745 av_parser_close(st->parser);
2750 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2751 /* estimate the end time (duration) */
2752 /* XXX: may need to support wrapping */
2753 filesize = ic->pb ? avio_size(ic->pb) : 0;
2755 is_end = found_duration;
2756 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2760 avio_seek(ic->pb, offset, SEEK_SET);
2763 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2767 ret = ff_read_packet(ic, pkt);
2768 } while (ret == AVERROR(EAGAIN));
2771 read_size += pkt->size;
2772 st = ic->streams[pkt->stream_index];
2773 if (pkt->pts != AV_NOPTS_VALUE &&
2774 (st->start_time != AV_NOPTS_VALUE ||
2775 st->first_dts != AV_NOPTS_VALUE)) {
2776 if (pkt->duration == 0) {
2777 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2779 pkt->duration = av_rescale_rnd(1,
2780 num * (int64_t) st->time_base.den,
2781 den * (int64_t) st->time_base.num,
2785 duration = pkt->pts + pkt->duration;
2787 if (st->start_time != AV_NOPTS_VALUE)
2788 duration -= st->start_time;
2790 duration -= st->first_dts;
2792 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2793 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2794 st->duration = duration;
2795 st->info->last_duration = duration;
2798 av_packet_unref(pkt);
2801 /* check if all audio/video streams have valid duration */
2804 for (i = 0; i < ic->nb_streams; i++) {
2805 st = ic->streams[i];
2806 switch (st->codecpar->codec_type) {
2807 case AVMEDIA_TYPE_VIDEO:
2808 case AVMEDIA_TYPE_AUDIO:
2809 if (st->duration == AV_NOPTS_VALUE)
2816 ++retry <= DURATION_MAX_RETRY);
2818 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2820 /* warn about audio/video streams which duration could not be estimated */
2821 for (i = 0; i < ic->nb_streams; i++) {
2822 st = ic->streams[i];
2823 if (st->duration == AV_NOPTS_VALUE) {
2824 switch (st->codecpar->codec_type) {
2825 case AVMEDIA_TYPE_VIDEO:
2826 case AVMEDIA_TYPE_AUDIO:
2827 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2828 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2830 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2834 fill_all_stream_timings(ic);
2836 avio_seek(ic->pb, old_offset, SEEK_SET);
2837 for (i = 0; i < ic->nb_streams; i++) {
2840 st = ic->streams[i];
2841 st->cur_dts = st->first_dts;
2842 st->last_IP_pts = AV_NOPTS_VALUE;
2843 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2844 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2845 st->pts_buffer[j] = AV_NOPTS_VALUE;
2849 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2853 /* get the file size, if possible */
2854 if (ic->iformat->flags & AVFMT_NOFILE) {
2857 file_size = avio_size(ic->pb);
2858 file_size = FFMAX(0, file_size);
2861 if ((!strcmp(ic->iformat->name, "mpeg") ||
2862 !strcmp(ic->iformat->name, "mpegts")) &&
2863 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2864 /* get accurate estimate from the PTSes */
2865 estimate_timings_from_pts(ic, old_offset);
2866 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2867 } else if (has_duration(ic)) {
2868 /* at least one component has timings - we use them for all
2870 fill_all_stream_timings(ic);
2871 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2873 /* less precise: use bitrate info */
2874 estimate_timings_from_bit_rate(ic);
2875 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2877 update_stream_timings(ic);
2881 AVStream av_unused *st;
2882 for (i = 0; i < ic->nb_streams; i++) {
2883 st = ic->streams[i];
2884 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2885 (double) st->start_time * av_q2d(st->time_base),
2886 (double) st->duration * av_q2d(st->time_base));
2888 av_log(ic, AV_LOG_TRACE,
2889 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2890 (double) ic->start_time / AV_TIME_BASE,
2891 (double) ic->duration / AV_TIME_BASE,
2892 (int64_t)ic->bit_rate / 1000);
2896 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2898 AVCodecContext *avctx = st->internal->avctx;
2900 #define FAIL(errmsg) do { \
2902 *errmsg_ptr = errmsg; \
2906 if ( avctx->codec_id == AV_CODEC_ID_NONE
2907 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2908 FAIL("unknown codec");
2909 switch (avctx->codec_type) {
2910 case AVMEDIA_TYPE_AUDIO:
2911 if (!avctx->frame_size && determinable_frame_size(avctx))
2912 FAIL("unspecified frame size");
2913 if (st->info->found_decoder >= 0 &&
2914 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2915 FAIL("unspecified sample format");
2916 if (!avctx->sample_rate)
2917 FAIL("unspecified sample rate");
2918 if (!avctx->channels)
2919 FAIL("unspecified number of channels");
2920 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2921 FAIL("no decodable DTS frames");
2923 case AVMEDIA_TYPE_VIDEO:
2925 FAIL("unspecified size");
2926 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2927 FAIL("unspecified pixel format");
2928 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2929 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2930 FAIL("no frame in rv30/40 and no sar");
2932 case AVMEDIA_TYPE_SUBTITLE:
2933 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2934 FAIL("unspecified size");
2936 case AVMEDIA_TYPE_DATA:
2937 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2943 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2944 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2945 AVDictionary **options)
2947 AVCodecContext *avctx = st->internal->avctx;
2948 const AVCodec *codec;
2949 int got_picture = 1, ret = 0;
2950 AVFrame *frame = av_frame_alloc();
2951 AVSubtitle subtitle;
2952 AVPacket pkt = *avpkt;
2953 int do_skip_frame = 0;
2954 enum AVDiscard skip_frame;
2957 return AVERROR(ENOMEM);
2959 if (!avcodec_is_open(avctx) &&
2960 st->info->found_decoder <= 0 &&
2961 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2962 AVDictionary *thread_opt = NULL;
2964 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2967 st->info->found_decoder = -st->codecpar->codec_id;
2972 /* Force thread count to 1 since the H.264 decoder will not extract
2973 * SPS and PPS to extradata during multi-threaded decoding. */
2974 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2975 if (s->codec_whitelist)
2976 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2977 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2979 av_dict_free(&thread_opt);
2981 st->info->found_decoder = -avctx->codec_id;
2984 st->info->found_decoder = 1;
2985 } else if (!st->info->found_decoder)
2986 st->info->found_decoder = 1;
2988 if (st->info->found_decoder < 0) {
2993 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2995 skip_frame = avctx->skip_frame;
2996 avctx->skip_frame = AVDISCARD_ALL;
2999 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3001 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3002 (!st->codec_info_nb_frames &&
3003 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3005 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3006 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3007 ret = avcodec_send_packet(avctx, &pkt);
3008 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3012 ret = avcodec_receive_frame(avctx, frame);
3015 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3017 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3018 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3019 &got_picture, &pkt);
3025 st->nb_decoded_frames++;
3030 if (!pkt.data && !got_picture)
3034 if (do_skip_frame) {
3035 avctx->skip_frame = skip_frame;
3038 av_frame_free(&frame);
3042 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3044 while (tags->id != AV_CODEC_ID_NONE) {
3052 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3055 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3056 if (tag == tags[i].tag)
3058 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3059 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3061 return AV_CODEC_ID_NONE;
3064 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3066 if (bps <= 0 || bps > 64)
3067 return AV_CODEC_ID_NONE;
3072 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3074 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3076 return AV_CODEC_ID_NONE;
3081 if (sflags & (1 << (bps - 1))) {
3084 return AV_CODEC_ID_PCM_S8;
3086 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3088 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3090 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3092 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3094 return AV_CODEC_ID_NONE;
3099 return AV_CODEC_ID_PCM_U8;
3101 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3103 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3105 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3107 return AV_CODEC_ID_NONE;
3113 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3116 if (!av_codec_get_tag2(tags, id, &tag))
3121 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3125 for (i = 0; tags && tags[i]; i++) {
3126 const AVCodecTag *codec_tags = tags[i];
3127 while (codec_tags->id != AV_CODEC_ID_NONE) {
3128 if (codec_tags->id == id) {
3129 *tag = codec_tags->tag;
3138 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3141 for (i = 0; tags && tags[i]; i++) {
3142 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3143 if (id != AV_CODEC_ID_NONE)
3146 return AV_CODEC_ID_NONE;
3149 static void compute_chapters_end(AVFormatContext *s)
3152 int64_t max_time = 0;
3154 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3155 max_time = s->duration +
3156 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3158 for (i = 0; i < s->nb_chapters; i++)
3159 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3160 AVChapter *ch = s->chapters[i];
3161 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3165 for (j = 0; j < s->nb_chapters; j++) {
3166 AVChapter *ch1 = s->chapters[j];
3167 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3169 if (j != i && next_start > ch->start && next_start < end)
3172 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3176 static int get_std_framerate(int i)
3179 return (i + 1) * 1001;
3183 return (i + 31) * 1001 * 12;
3187 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3191 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3194 /* Is the time base unreliable?
3195 * This is a heuristic to balance between quick acceptance of the values in
3196 * the headers vs. some extra checks.
3197 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3198 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3199 * And there are "variable" fps files this needs to detect as well. */
3200 static int tb_unreliable(AVCodecContext *c)
3202 if (c->time_base.den >= 101LL * c->time_base.num ||
3203 c->time_base.den < 5LL * c->time_base.num ||
3204 // c->codec_tag == AV_RL32("DIVX") ||
3205 // c->codec_tag == AV_RL32("XVID") ||
3206 c->codec_tag == AV_RL32("mp4v") ||
3207 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3208 c->codec_id == AV_CODEC_ID_GIF ||
3209 c->codec_id == AV_CODEC_ID_HEVC ||
3210 c->codec_id == AV_CODEC_ID_H264)
3215 int ff_alloc_extradata(AVCodecParameters *par, int size)
3219 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3220 par->extradata = NULL;
3221 par->extradata_size = 0;
3222 return AVERROR(EINVAL);
3224 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3225 if (par->extradata) {
3226 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3227 par->extradata_size = size;
3230 par->extradata_size = 0;
3231 ret = AVERROR(ENOMEM);
3236 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3238 int ret = ff_alloc_extradata(par, size);
3241 ret = avio_read(pb, par->extradata, size);
3243 av_freep(&par->extradata);
3244 par->extradata_size = 0;
3245 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3246 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3252 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3255 int64_t last = st->info->last_dts;
3257 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3258 && ts - (uint64_t)last < INT64_MAX) {
3259 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3260 int64_t duration = ts - last;
3262 if (!st->info->duration_error)
3263 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3264 if (!st->info->duration_error)
3265 return AVERROR(ENOMEM);
3267 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3268 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3269 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3270 if (st->info->duration_error[0][1][i] < 1e10) {
3271 int framerate = get_std_framerate(i);
3272 double sdts = dts*framerate/(1001*12);
3273 for (j= 0; j<2; j++) {
3274 int64_t ticks = llrint(sdts+j*0.5);
3275 double error= sdts - ticks + j*0.5;
3276 st->info->duration_error[j][0][i] += error;
3277 st->info->duration_error[j][1][i] += error*error;
3281 st->info->duration_count++;
3282 st->info->rfps_duration_sum += duration;
3284 if (st->info->duration_count % 10 == 0) {
3285 int n = st->info->duration_count;
3286 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3287 if (st->info->duration_error[0][1][i] < 1e10) {
3288 double a0 = st->info->duration_error[0][0][i] / n;
3289 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3290 double a1 = st->info->duration_error[1][0][i] / n;
3291 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3292 if (error0 > 0.04 && error1 > 0.04) {
3293 st->info->duration_error[0][1][i] = 2e10;
3294 st->info->duration_error[1][1][i] = 2e10;
3300 // ignore the first 4 values, they might have some random jitter
3301 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3302 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3304 if (ts != AV_NOPTS_VALUE)
3305 st->info->last_dts = ts;
3310 void ff_rfps_calculate(AVFormatContext *ic)
3314 for (i = 0; i < ic->nb_streams; i++) {
3315 AVStream *st = ic->streams[i];
3317 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3319 // the check for tb_unreliable() is not completely correct, since this is not about handling
3320 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3321 // ipmovie.c produces.
3322 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)
3323 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);
3324 if (st->info->duration_count>1 && !st->r_frame_rate.num
3325 && tb_unreliable(st->internal->avctx)) {
3327 double best_error= 0.01;
3328 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3330 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3333 if (st->info->codec_info_duration &&
3334 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3336 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3339 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3342 for (k= 0; k<2; k++) {
3343 int n = st->info->duration_count;
3344 double a= st->info->duration_error[k][0][j] / n;
3345 double error= st->info->duration_error[k][1][j]/n - a*a;
3347 if (error < best_error && best_error> 0.000000001) {
3349 num = get_std_framerate(j);
3352 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3355 // do not increase frame rate by more than 1 % in order to match a standard rate.
3356 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3357 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3359 if ( !st->avg_frame_rate.num
3360 && st->r_frame_rate.num && st->info->rfps_duration_sum
3361 && st->info->codec_info_duration <= 0
3362 && st->info->duration_count > 2
3363 && 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
3365 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3366 st->avg_frame_rate = st->r_frame_rate;
3369 av_freep(&st->info->duration_error);
3370 st->info->last_dts = AV_NOPTS_VALUE;
3371 st->info->duration_count = 0;
3372 st->info->rfps_duration_sum = 0;
3376 static int extract_extradata_check(AVStream *st)
3378 const AVBitStreamFilter *f;
3380 f = av_bsf_get_by_name("extract_extradata");
3385 const enum AVCodecID *ids;
3386 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3387 if (*ids == st->codecpar->codec_id)
3394 static int extract_extradata_init(AVStream *st)
3396 AVStreamInternal *i = st->internal;
3397 const AVBitStreamFilter *f;
3400 f = av_bsf_get_by_name("extract_extradata");
3404 /* check that the codec id is supported */
3405 ret = extract_extradata_check(st);
3409 i->extract_extradata.pkt = av_packet_alloc();
3410 if (!i->extract_extradata.pkt)
3411 return AVERROR(ENOMEM);
3413 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3417 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3422 i->extract_extradata.bsf->time_base_in = st->time_base;
3424 /* if init fails here, we assume extracting extradata is just not
3425 * supported for this codec, so we return success */
3426 ret = av_bsf_init(i->extract_extradata.bsf);
3428 av_bsf_free(&i->extract_extradata.bsf);
3433 i->extract_extradata.inited = 1;
3437 av_bsf_free(&i->extract_extradata.bsf);
3438 av_packet_free(&i->extract_extradata.pkt);
3442 static int extract_extradata(AVStream *st, AVPacket *pkt)
3444 AVStreamInternal *i = st->internal;
3448 if (!i->extract_extradata.inited) {
3449 ret = extract_extradata_init(st);
3454 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3457 pkt_ref = i->extract_extradata.pkt;
3458 ret = av_packet_ref(pkt_ref, pkt);
3462 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3464 av_packet_unref(pkt_ref);
3468 while (ret >= 0 && !i->avctx->extradata) {
3472 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3474 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3479 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3483 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3484 if (!i->avctx->extradata) {
3485 av_packet_unref(pkt_ref);
3486 return AVERROR(ENOMEM);
3488 memcpy(i->avctx->extradata, extradata, extradata_size);
3489 i->avctx->extradata_size = extradata_size;
3491 av_packet_unref(pkt_ref);
3497 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3499 int i, count = 0, ret = 0, j;
3502 AVCodecContext *avctx;
3503 AVPacket pkt1, *pkt;
3504 int64_t old_offset = avio_tell(ic->pb);
3505 // new streams might appear, no options for those
3506 int orig_nb_streams = ic->nb_streams;
3508 int64_t max_analyze_duration = ic->max_analyze_duration;
3509 int64_t max_stream_analyze_duration;
3510 int64_t max_subtitle_analyze_duration;
3511 int64_t probesize = ic->probesize;
3512 int eof_reached = 0;
3513 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3515 flush_codecs = probesize > 0;
3517 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3519 max_stream_analyze_duration = max_analyze_duration;
3520 max_subtitle_analyze_duration = max_analyze_duration;
3521 if (!max_analyze_duration) {
3522 max_stream_analyze_duration =
3523 max_analyze_duration = 5*AV_TIME_BASE;
3524 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3525 if (!strcmp(ic->iformat->name, "flv"))
3526 max_stream_analyze_duration = 90*AV_TIME_BASE;
3527 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3528 max_stream_analyze_duration = 7*AV_TIME_BASE;
3532 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3533 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3535 for (i = 0; i < ic->nb_streams; i++) {
3536 const AVCodec *codec;
3537 AVDictionary *thread_opt = NULL;
3538 st = ic->streams[i];
3539 avctx = st->internal->avctx;
3541 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3542 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3543 /* if (!st->time_base.num)
3545 if (!avctx->time_base.num)
3546 avctx->time_base = st->time_base;
3549 /* check if the caller has overridden the codec id */
3550 #if FF_API_LAVF_AVCTX
3551 FF_DISABLE_DEPRECATION_WARNINGS
3552 if (st->codec->codec_id != st->internal->orig_codec_id) {
3553 st->codecpar->codec_id = st->codec->codec_id;
3554 st->codecpar->codec_type = st->codec->codec_type;
3555 st->internal->orig_codec_id = st->codec->codec_id;
3557 FF_ENABLE_DEPRECATION_WARNINGS
3559 // only for the split stuff
3560 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3561 st->parser = av_parser_init(st->codecpar->codec_id);
3563 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3564 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3565 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3566 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3568 } else if (st->need_parsing) {
3569 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3570 "%s, packets or times may be invalid.\n",
3571 avcodec_get_name(st->codecpar->codec_id));
3575 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3576 st->internal->orig_codec_id = st->codecpar->codec_id;
3578 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3580 goto find_stream_info_err;
3581 if (st->request_probe <= 0)
3582 st->internal->avctx_inited = 1;
3584 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3586 /* Force thread count to 1 since the H.264 decoder will not extract
3587 * SPS and PPS to extradata during multi-threaded decoding. */
3588 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3590 if (ic->codec_whitelist)
3591 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3593 /* Ensure that subtitle_header is properly set. */
3594 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3595 && codec && !avctx->codec) {
3596 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3597 av_log(ic, AV_LOG_WARNING,
3598 "Failed to open codec in %s\n",__FUNCTION__);
3601 // Try to just open decoders, in case this is enough to get parameters.
3602 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3603 if (codec && !avctx->codec)
3604 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3605 av_log(ic, AV_LOG_WARNING,
3606 "Failed to open codec in %s\n",__FUNCTION__);
3609 av_dict_free(&thread_opt);
3612 for (i = 0; i < ic->nb_streams; i++) {
3613 #if FF_API_R_FRAME_RATE
3614 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3616 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3617 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3622 int analyzed_all_streams;
3623 if (ff_check_interrupt(&ic->interrupt_callback)) {
3625 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3629 /* check if one codec still needs to be handled */
3630 for (i = 0; i < ic->nb_streams; i++) {
3631 int fps_analyze_framecount = 20;
3633 st = ic->streams[i];
3634 if (!has_codec_parameters(st, NULL))
3636 /* If the timebase is coarse (like the usual millisecond precision
3637 * of mkv), we need to analyze more frames to reliably arrive at
3638 * the correct fps. */
3639 if (av_q2d(st->time_base) > 0.0005)
3640 fps_analyze_framecount *= 2;
3641 if (!tb_unreliable(st->internal->avctx))
3642 fps_analyze_framecount = 0;
3643 if (ic->fps_probe_size >= 0)
3644 fps_analyze_framecount = ic->fps_probe_size;
3645 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3646 fps_analyze_framecount = 0;
3647 /* variable fps and no guess at the real fps */
3648 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3649 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3650 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3651 st->info->codec_info_duration_fields/2 :
3652 st->info->duration_count;
3653 if (count < fps_analyze_framecount)
3656 if (!st->internal->avctx->extradata &&
3657 (!st->internal->extract_extradata.inited ||
3658 st->internal->extract_extradata.bsf) &&
3659 extract_extradata_check(st))
3661 if (st->first_dts == AV_NOPTS_VALUE &&
3662 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3663 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3664 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3665 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3668 analyzed_all_streams = 0;
3669 if (!missing_streams || !*missing_streams)
3670 if (i == ic->nb_streams) {
3671 analyzed_all_streams = 1;
3672 /* NOTE: If the format has no header, then we need to read some
3673 * packets to get most of the streams, so we cannot stop here. */
3674 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3675 /* If we found the info for all the codecs, we can stop. */
3677 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3682 /* We did not get all the codec info, but we read too much data. */
3683 if (read_size >= probesize) {
3685 av_log(ic, AV_LOG_DEBUG,
3686 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3687 for (i = 0; i < ic->nb_streams; i++)
3688 if (!ic->streams[i]->r_frame_rate.num &&
3689 ic->streams[i]->info->duration_count <= 1 &&
3690 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3691 strcmp(ic->iformat->name, "image2"))
3692 av_log(ic, AV_LOG_WARNING,
3693 "Stream #%d: not enough frames to estimate rate; "
3694 "consider increasing probesize\n", i);
3698 /* NOTE: A new stream can be added there if no header in file
3699 * (AVFMTCTX_NOHEADER). */
3700 ret = read_frame_internal(ic, &pkt1);
3701 if (ret == AVERROR(EAGAIN))
3712 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3713 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3714 &ic->internal->packet_buffer_end, 0);
3716 goto find_stream_info_err;
3719 st = ic->streams[pkt->stream_index];
3720 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3721 read_size += pkt->size;
3723 avctx = st->internal->avctx;
3724 if (!st->internal->avctx_inited) {
3725 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3727 goto find_stream_info_err;
3728 st->internal->avctx_inited = 1;
3731 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3732 /* check for non-increasing dts */
3733 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3734 st->info->fps_last_dts >= pkt->dts) {
3735 av_log(ic, AV_LOG_DEBUG,
3736 "Non-increasing DTS in stream %d: packet %d with DTS "
3737 "%"PRId64", packet %d with DTS %"PRId64"\n",
3738 st->index, st->info->fps_last_dts_idx,
3739 st->info->fps_last_dts, st->codec_info_nb_frames,
3741 st->info->fps_first_dts =
3742 st->info->fps_last_dts = AV_NOPTS_VALUE;
3744 /* Check for a discontinuity in dts. If the difference in dts
3745 * is more than 1000 times the average packet duration in the
3746 * sequence, we treat it as a discontinuity. */
3747 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3748 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3749 (pkt->dts - st->info->fps_last_dts) / 1000 >
3750 (st->info->fps_last_dts - st->info->fps_first_dts) /
3751 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3752 av_log(ic, AV_LOG_WARNING,
3753 "DTS discontinuity in stream %d: packet %d with DTS "
3754 "%"PRId64", packet %d with DTS %"PRId64"\n",
3755 st->index, st->info->fps_last_dts_idx,
3756 st->info->fps_last_dts, st->codec_info_nb_frames,
3758 st->info->fps_first_dts =
3759 st->info->fps_last_dts = AV_NOPTS_VALUE;
3762 /* update stored dts values */
3763 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3764 st->info->fps_first_dts = pkt->dts;
3765 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3767 st->info->fps_last_dts = pkt->dts;
3768 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3770 if (st->codec_info_nb_frames>1) {
3774 if (st->time_base.den > 0)
3775 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3776 if (st->avg_frame_rate.num > 0)
3777 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3780 && st->codec_info_nb_frames>30
3781 && st->info->fps_first_dts != AV_NOPTS_VALUE
3782 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3783 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3785 if (analyzed_all_streams) limit = max_analyze_duration;
3786 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3787 else limit = max_stream_analyze_duration;
3790 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3792 t, pkt->stream_index);
3793 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3794 av_packet_unref(pkt);
3797 if (pkt->duration) {
3798 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3799 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3801 st->info->codec_info_duration += pkt->duration;
3802 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3805 #if FF_API_R_FRAME_RATE
3806 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3807 ff_rfps_add_frame(ic, st, pkt->dts);
3809 if (!st->internal->avctx->extradata) {
3810 ret = extract_extradata(st, pkt);
3812 goto find_stream_info_err;
3815 /* If still no information, we try to open the codec and to
3816 * decompress the frame. We try to avoid that in most cases as
3817 * it takes longer and uses more memory. For MPEG-4, we need to
3818 * decompress for QuickTime.
3820 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3821 * least one frame of codec data, this makes sure the codec initializes
3822 * the channel configuration and does not only trust the values from
3824 try_decode_frame(ic, st, pkt,
3825 (options && i < orig_nb_streams) ? &options[i] : NULL);
3827 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3828 av_packet_unref(pkt);
3830 st->codec_info_nb_frames++;
3836 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3837 st = ic->streams[stream_index];
3838 avctx = st->internal->avctx;
3839 if (!has_codec_parameters(st, NULL)) {
3840 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3841 if (codec && !avctx->codec) {
3842 AVDictionary *opts = NULL;
3843 if (ic->codec_whitelist)
3844 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3845 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3846 av_log(ic, AV_LOG_WARNING,
3847 "Failed to open codec in %s\n",__FUNCTION__);
3848 av_dict_free(&opts);
3852 // EOF already reached while reading the stream above.
3853 // So continue with reoordering DTS with whatever delay we have.
3854 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3855 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3861 AVPacket empty_pkt = { 0 };
3863 av_init_packet(&empty_pkt);
3865 for (i = 0; i < ic->nb_streams; i++) {
3867 st = ic->streams[i];
3869 /* flush the decoders */
3870 if (st->info->found_decoder == 1) {
3872 err = try_decode_frame(ic, st, &empty_pkt,
3873 (options && i < orig_nb_streams)
3874 ? &options[i] : NULL);
3875 } while (err > 0 && !has_codec_parameters(st, NULL));
3878 av_log(ic, AV_LOG_INFO,
3879 "decoding for stream %d failed\n", st->index);
3885 // close codecs which were opened in try_decode_frame()
3886 for (i = 0; i < ic->nb_streams; i++) {
3887 st = ic->streams[i];
3888 avcodec_close(st->internal->avctx);
3891 ff_rfps_calculate(ic);
3893 for (i = 0; i < ic->nb_streams; i++) {
3894 st = ic->streams[i];
3895 avctx = st->internal->avctx;
3896 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3897 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3898 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3899 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3900 avctx->codec_tag= tag;
3903 /* estimate average framerate if not set by demuxer */
3904 if (st->info->codec_info_duration_fields &&
3905 !st->avg_frame_rate.num &&
3906 st->info->codec_info_duration) {
3908 double best_error = 0.01;
3909 AVRational codec_frame_rate = avctx->framerate;
3911 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3912 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3913 st->info->codec_info_duration < 0)
3915 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3916 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3917 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3919 /* Round guessed framerate to a "standard" framerate if it's
3920 * within 1% of the original estimate. */
3921 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3922 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3923 double error = fabs(av_q2d(st->avg_frame_rate) /
3924 av_q2d(std_fps) - 1);
3926 if (error < best_error) {
3928 best_fps = std_fps.num;
3931 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3932 error = fabs(av_q2d(codec_frame_rate) /
3933 av_q2d(std_fps) - 1);
3934 if (error < best_error) {
3936 best_fps = std_fps.num;
3941 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3942 best_fps, 12 * 1001, INT_MAX);
3945 if (!st->r_frame_rate.num) {
3946 if ( avctx->time_base.den * (int64_t) st->time_base.num
3947 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3948 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3949 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3951 st->r_frame_rate.num = st->time_base.den;
3952 st->r_frame_rate.den = st->time_base.num;
3955 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3956 AVRational hw_ratio = { avctx->height, avctx->width };
3957 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3960 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3961 if (!avctx->bits_per_coded_sample)
3962 avctx->bits_per_coded_sample =
3963 av_get_bits_per_sample(avctx->codec_id);
3964 // set stream disposition based on audio service type
3965 switch (avctx->audio_service_type) {
3966 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3967 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3969 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3970 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3972 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3973 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3975 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3976 st->disposition = AV_DISPOSITION_COMMENT;
3978 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3979 st->disposition = AV_DISPOSITION_KARAOKE;
3986 estimate_timings(ic, old_offset);
3988 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3990 if (ret >= 0 && ic->nb_streams)
3991 /* We could not have all the codec parameters before EOF. */
3993 for (i = 0; i < ic->nb_streams; i++) {
3995 st = ic->streams[i];
3997 /* if no packet was ever seen, update context now for has_codec_parameters */
3998 if (!st->internal->avctx_inited) {
3999 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4000 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4001 st->codecpar->format = st->internal->avctx->sample_fmt;
4002 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4004 goto find_stream_info_err;
4006 if (!has_codec_parameters(st, &errmsg)) {
4008 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4009 av_log(ic, AV_LOG_WARNING,
4010 "Could not find codec parameters for stream %d (%s): %s\n"
4011 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4018 compute_chapters_end(ic);
4020 /* update the stream parameters from the internal codec contexts */
4021 for (i = 0; i < ic->nb_streams; i++) {
4022 st = ic->streams[i];
4024 if (st->internal->avctx_inited) {
4025 int orig_w = st->codecpar->width;
4026 int orig_h = st->codecpar->height;
4027 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4029 goto find_stream_info_err;
4030 // The decoder might reduce the video size by the lowres factor.
4031 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
4032 st->codecpar->width = orig_w;
4033 st->codecpar->height = orig_h;
4037 #if FF_API_LAVF_AVCTX
4038 FF_DISABLE_DEPRECATION_WARNINGS
4039 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4041 goto find_stream_info_err;
4043 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4044 // by the lowres factor.
4045 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
4046 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
4047 st->codec->width = st->internal->avctx->width;
4048 st->codec->height = st->internal->avctx->height;
4051 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4052 st->codec->time_base = st->internal->avctx->time_base;
4053 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4055 st->codec->framerate = st->avg_frame_rate;
4057 if (st->internal->avctx->subtitle_header) {
4058 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4059 if (!st->codec->subtitle_header)
4060 goto find_stream_info_err;
4061 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4062 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4063 st->codec->subtitle_header_size);
4066 // Fields unavailable in AVCodecParameters
4067 st->codec->coded_width = st->internal->avctx->coded_width;
4068 st->codec->coded_height = st->internal->avctx->coded_height;
4069 st->codec->properties = st->internal->avctx->properties;
4070 FF_ENABLE_DEPRECATION_WARNINGS
4073 st->internal->avctx_inited = 0;
4076 find_stream_info_err:
4077 for (i = 0; i < ic->nb_streams; i++) {
4078 st = ic->streams[i];
4080 av_freep(&st->info->duration_error);
4081 av_freep(&ic->streams[i]->info);
4082 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4083 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4086 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4087 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4091 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4095 for (i = 0; i < ic->nb_programs; i++) {
4096 if (ic->programs[i] == last) {
4100 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4101 if (ic->programs[i]->stream_index[j] == s)
4102 return ic->programs[i];
4108 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4109 int wanted_stream_nb, int related_stream,
4110 AVCodec **decoder_ret, int flags)
4112 int i, nb_streams = ic->nb_streams;
4113 int ret = AVERROR_STREAM_NOT_FOUND;
4114 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4115 int count, multiframe, disposition;
4116 int64_t best_bitrate = -1;
4118 unsigned *program = NULL;
4119 const AVCodec *decoder = NULL, *best_decoder = NULL;
4121 if (related_stream >= 0 && wanted_stream_nb < 0) {
4122 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4124 program = p->stream_index;
4125 nb_streams = p->nb_stream_indexes;
4128 for (i = 0; i < nb_streams; i++) {
4129 int real_stream_index = program ? program[i] : i;
4130 AVStream *st = ic->streams[real_stream_index];
4131 AVCodecParameters *par = st->codecpar;
4132 if (par->codec_type != type)
4134 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4136 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4139 decoder = find_decoder(ic, st, par->codec_id);
4142 ret = AVERROR_DECODER_NOT_FOUND;
4146 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4147 count = st->codec_info_nb_frames;
4148 bitrate = par->bit_rate;
4149 multiframe = FFMIN(5, count);
4150 if ((best_disposition > disposition) ||
4151 (best_disposition == disposition && best_multiframe > multiframe) ||
4152 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4153 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4155 best_disposition = disposition;
4157 best_bitrate = bitrate;
4158 best_multiframe = multiframe;
4159 ret = real_stream_index;
4160 best_decoder = decoder;
4161 if (program && i == nb_streams - 1 && ret < 0) {
4163 nb_streams = ic->nb_streams;
4164 /* no related stream found, try again with everything */
4169 *decoder_ret = (AVCodec*)best_decoder;
4173 /*******************************************************/
4175 int av_read_play(AVFormatContext *s)
4177 if (s->iformat->read_play)
4178 return s->iformat->read_play(s);
4180 return avio_pause(s->pb, 0);
4181 return AVERROR(ENOSYS);
4184 int av_read_pause(AVFormatContext *s)
4186 if (s->iformat->read_pause)
4187 return s->iformat->read_pause(s);
4189 return avio_pause(s->pb, 1);
4190 return AVERROR(ENOSYS);
4193 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4198 dst->time_base = src->time_base;
4199 dst->nb_frames = src->nb_frames;
4200 dst->disposition = src->disposition;
4201 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4202 dst->avg_frame_rate = src->avg_frame_rate;
4203 dst->r_frame_rate = src->r_frame_rate;
4205 av_dict_free(&dst->metadata);
4206 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4210 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4214 /* Free existing side data*/
4215 for (i = 0; i < dst->nb_side_data; i++)
4216 av_free(dst->side_data[i].data);
4217 av_freep(&dst->side_data);
4218 dst->nb_side_data = 0;
4220 /* Copy side data if present */
4221 if (src->nb_side_data) {
4222 dst->side_data = av_mallocz_array(src->nb_side_data,
4223 sizeof(AVPacketSideData));
4224 if (!dst->side_data)
4225 return AVERROR(ENOMEM);
4226 dst->nb_side_data = src->nb_side_data;
4228 for (i = 0; i < src->nb_side_data; i++) {
4229 uint8_t *data = av_memdup(src->side_data[i].data,
4230 src->side_data[i].size);
4232 return AVERROR(ENOMEM);
4233 dst->side_data[i].type = src->side_data[i].type;
4234 dst->side_data[i].size = src->side_data[i].size;
4235 dst->side_data[i].data = data;
4239 av_freep(&dst->recommended_encoder_configuration);
4240 if (src->recommended_encoder_configuration) {
4241 const char *conf_str = src->recommended_encoder_configuration;
4242 dst->recommended_encoder_configuration = av_strdup(conf_str);
4243 if (!dst->recommended_encoder_configuration)
4244 return AVERROR(ENOMEM);
4250 static void free_stream(AVStream **pst)
4252 AVStream *st = *pst;
4258 for (i = 0; i < st->nb_side_data; i++)
4259 av_freep(&st->side_data[i].data);
4260 av_freep(&st->side_data);
4263 av_parser_close(st->parser);
4265 if (st->attached_pic.data)
4266 av_packet_unref(&st->attached_pic);
4269 avcodec_free_context(&st->internal->avctx);
4270 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4271 av_bsf_free(&st->internal->bsfcs[i]);
4272 av_freep(&st->internal->bsfcs);
4274 av_bsf_free(&st->internal->extract_extradata.bsf);
4275 av_packet_free(&st->internal->extract_extradata.pkt);
4277 av_freep(&st->internal);
4279 av_dict_free(&st->metadata);
4280 avcodec_parameters_free(&st->codecpar);
4281 av_freep(&st->probe_data.buf);
4282 av_freep(&st->index_entries);
4283 #if FF_API_LAVF_AVCTX
4284 FF_DISABLE_DEPRECATION_WARNINGS
4285 avcodec_free_context(&st->codec);
4286 FF_ENABLE_DEPRECATION_WARNINGS
4288 av_freep(&st->priv_data);
4290 av_freep(&st->info->duration_error);
4291 av_freep(&st->info);
4292 av_freep(&st->recommended_encoder_configuration);
4293 av_freep(&st->priv_pts);
4298 void ff_free_stream(AVFormatContext *s, AVStream *st)
4300 av_assert0(s->nb_streams>0);
4301 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4303 free_stream(&s->streams[ --s->nb_streams ]);
4306 void avformat_free_context(AVFormatContext *s)
4314 if (s->iformat && s->iformat->priv_class && s->priv_data)
4315 av_opt_free(s->priv_data);
4316 if (s->oformat && s->oformat->priv_class && s->priv_data)
4317 av_opt_free(s->priv_data);
4319 for (i = s->nb_streams - 1; i >= 0; i--)
4320 ff_free_stream(s, s->streams[i]);
4323 for (i = s->nb_programs - 1; i >= 0; i--) {
4324 av_dict_free(&s->programs[i]->metadata);
4325 av_freep(&s->programs[i]->stream_index);
4326 av_freep(&s->programs[i]);
4328 av_freep(&s->programs);
4329 av_freep(&s->priv_data);
4330 while (s->nb_chapters--) {
4331 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4332 av_freep(&s->chapters[s->nb_chapters]);
4334 av_freep(&s->chapters);
4335 av_dict_free(&s->metadata);
4336 av_dict_free(&s->internal->id3v2_meta);
4337 av_freep(&s->streams);
4338 flush_packet_queue(s);
4339 av_freep(&s->internal);
4343 void avformat_close_input(AVFormatContext **ps)
4354 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4355 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4358 flush_packet_queue(s);
4361 if (s->iformat->read_close)
4362 s->iformat->read_close(s);
4364 avformat_free_context(s);
4371 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4377 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4378 if (s->max_streams < INT_MAX/sizeof(*streams))
4379 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);
4382 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4385 s->streams = streams;
4387 st = av_mallocz(sizeof(AVStream));
4390 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4394 st->info->last_dts = AV_NOPTS_VALUE;
4396 #if FF_API_LAVF_AVCTX
4397 FF_DISABLE_DEPRECATION_WARNINGS
4398 st->codec = avcodec_alloc_context3(c);
4404 FF_ENABLE_DEPRECATION_WARNINGS
4407 st->internal = av_mallocz(sizeof(*st->internal));
4411 st->codecpar = avcodec_parameters_alloc();
4415 st->internal->avctx = avcodec_alloc_context3(NULL);
4416 if (!st->internal->avctx)
4420 #if FF_API_LAVF_AVCTX
4421 FF_DISABLE_DEPRECATION_WARNINGS
4422 /* no default bitrate if decoding */
4423 st->codec->bit_rate = 0;
4424 FF_ENABLE_DEPRECATION_WARNINGS
4427 /* default pts setting is MPEG-like */
4428 avpriv_set_pts_info(st, 33, 1, 90000);
4429 /* we set the current DTS to 0 so that formats without any timestamps
4430 * but durations get some timestamps, formats with some unknown
4431 * timestamps have their first few packets buffered and the
4432 * timestamps corrected before they are returned to the user */
4433 st->cur_dts = RELATIVE_TS_BASE;
4435 st->cur_dts = AV_NOPTS_VALUE;
4438 st->index = s->nb_streams;
4439 st->start_time = AV_NOPTS_VALUE;
4440 st->duration = AV_NOPTS_VALUE;
4441 st->first_dts = AV_NOPTS_VALUE;
4442 st->probe_packets = MAX_PROBE_PACKETS;
4443 st->pts_wrap_reference = AV_NOPTS_VALUE;
4444 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4446 st->last_IP_pts = AV_NOPTS_VALUE;
4447 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4448 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4449 st->pts_buffer[i] = AV_NOPTS_VALUE;
4451 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4453 #if FF_API_R_FRAME_RATE
4454 st->info->last_dts = AV_NOPTS_VALUE;
4456 st->info->fps_first_dts = AV_NOPTS_VALUE;
4457 st->info->fps_last_dts = AV_NOPTS_VALUE;
4459 st->inject_global_side_data = s->internal->inject_global_side_data;
4461 st->internal->need_context_update = 1;
4463 s->streams[s->nb_streams++] = st;
4470 AVProgram *av_new_program(AVFormatContext *ac, int id)
4472 AVProgram *program = NULL;
4475 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4477 for (i = 0; i < ac->nb_programs; i++)
4478 if (ac->programs[i]->id == id)
4479 program = ac->programs[i];
4482 program = av_mallocz(sizeof(AVProgram));
4485 dynarray_add(&ac->programs, &ac->nb_programs, program);
4486 program->discard = AVDISCARD_NONE;
4489 program->pts_wrap_reference = AV_NOPTS_VALUE;
4490 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4492 program->start_time =
4493 program->end_time = AV_NOPTS_VALUE;
4498 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4499 int64_t start, int64_t end, const char *title)
4501 AVChapter *chapter = NULL;
4504 if (end != AV_NOPTS_VALUE && start > end) {
4505 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4509 for (i = 0; i < s->nb_chapters; i++)
4510 if (s->chapters[i]->id == id)
4511 chapter = s->chapters[i];
4514 chapter = av_mallocz(sizeof(AVChapter));
4517 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4519 av_dict_set(&chapter->metadata, "title", title, 0);
4521 chapter->time_base = time_base;
4522 chapter->start = start;
4528 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4531 AVProgram *program = NULL;
4534 if (idx >= ac->nb_streams) {
4535 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4539 for (i = 0; i < ac->nb_programs; i++) {
4540 if (ac->programs[i]->id != progid)
4542 program = ac->programs[i];
4543 for (j = 0; j < program->nb_stream_indexes; j++)
4544 if (program->stream_index[j] == idx)
4547 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4550 program->stream_index = tmp;
4551 program->stream_index[program->nb_stream_indexes++] = idx;
4556 uint64_t ff_ntp_time(void)
4558 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4561 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4564 char *q, buf1[20], c;
4565 int nd, len, percentd_found;
4577 while (av_isdigit(*p))
4578 nd = nd * 10 + *p++ - '0';
4580 } while (av_isdigit(c));
4586 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4591 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4593 if ((q - buf + len) > buf_size - 1)
4595 memcpy(q, buf1, len);
4603 if ((q - buf) < buf_size - 1)
4607 if (!percentd_found)
4616 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4618 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4621 void av_url_split(char *proto, int proto_size,
4622 char *authorization, int authorization_size,
4623 char *hostname, int hostname_size,
4624 int *port_ptr, char *path, int path_size, const char *url)
4626 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4632 if (authorization_size > 0)
4633 authorization[0] = 0;
4634 if (hostname_size > 0)
4639 /* parse protocol */
4640 if ((p = strchr(url, ':'))) {
4641 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4648 /* no protocol means plain filename */
4649 av_strlcpy(path, url, path_size);
4653 /* separate path from hostname */
4654 ls = strchr(p, '/');
4655 ls2 = strchr(p, '?');
4659 ls = FFMIN(ls, ls2);
4661 av_strlcpy(path, ls, path_size);
4663 ls = &p[strlen(p)]; // XXX
4665 /* the rest is hostname, use that to parse auth/port */
4667 /* authorization (user[:pass]@hostname) */
4669 while ((at = strchr(p, '@')) && at < ls) {
4670 av_strlcpy(authorization, at2,
4671 FFMIN(authorization_size, at + 1 - at2));
4672 p = at + 1; /* skip '@' */
4675 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4677 av_strlcpy(hostname, p + 1,
4678 FFMIN(hostname_size, brk - p));
4679 if (brk[1] == ':' && port_ptr)
4680 *port_ptr = atoi(brk + 2);
4681 } else if ((col = strchr(p, ':')) && col < ls) {
4682 av_strlcpy(hostname, p,
4683 FFMIN(col + 1 - p, hostname_size));
4685 *port_ptr = atoi(col + 1);
4687 av_strlcpy(hostname, p,
4688 FFMIN(ls + 1 - p, hostname_size));
4692 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4695 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4698 'C', 'D', 'E', 'F' };
4699 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4702 'c', 'd', 'e', 'f' };
4703 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4705 for (i = 0; i < s; i++) {
4706 buff[i * 2] = hex_table[src[i] >> 4];
4707 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4713 int ff_hex_to_data(uint8_t *data, const char *p)
4720 p += strspn(p, SPACE_CHARS);
4723 c = av_toupper((unsigned char) *p++);
4724 if (c >= '0' && c <= '9')
4726 else if (c >= 'A' && c <= 'F')
4741 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4742 unsigned int pts_num, unsigned int pts_den)
4745 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4746 if (new_tb.num != pts_num)
4747 av_log(NULL, AV_LOG_DEBUG,
4748 "st:%d removing common factor %d from timebase\n",
4749 s->index, pts_num / new_tb.num);
4751 av_log(NULL, AV_LOG_WARNING,
4752 "st:%d has too large timebase, reducing\n", s->index);
4754 if (new_tb.num <= 0 || new_tb.den <= 0) {
4755 av_log(NULL, AV_LOG_ERROR,
4756 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4757 new_tb.num, new_tb.den,
4761 s->time_base = new_tb;
4762 #if FF_API_LAVF_AVCTX
4763 FF_DISABLE_DEPRECATION_WARNINGS
4764 av_codec_set_pkt_timebase(s->codec, new_tb);
4765 FF_ENABLE_DEPRECATION_WARNINGS
4767 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4768 s->pts_wrap_bits = pts_wrap_bits;
4771 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4774 const char *ptr = str;
4776 /* Parse key=value pairs. */
4779 char *dest = NULL, *dest_end;
4780 int key_len, dest_len = 0;
4782 /* Skip whitespace and potential commas. */
4783 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4790 if (!(ptr = strchr(key, '=')))
4793 key_len = ptr - key;
4795 callback_get_buf(context, key, key_len, &dest, &dest_len);
4796 dest_end = dest + dest_len - 1;
4800 while (*ptr && *ptr != '\"') {
4804 if (dest && dest < dest_end)
4808 if (dest && dest < dest_end)
4816 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4817 if (dest && dest < dest_end)
4825 int ff_find_stream_index(AVFormatContext *s, int id)
4828 for (i = 0; i < s->nb_streams; i++)
4829 if (s->streams[i]->id == id)
4834 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4838 unsigned int codec_tag;
4839 if (ofmt->query_codec)
4840 return ofmt->query_codec(codec_id, std_compliance);
4841 else if (ofmt->codec_tag)
4842 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4843 else if (codec_id == ofmt->video_codec ||
4844 codec_id == ofmt->audio_codec ||
4845 codec_id == ofmt->subtitle_codec ||
4846 codec_id == ofmt->data_codec)
4849 return AVERROR_PATCHWELCOME;
4852 int avformat_network_init(void)
4856 ff_network_inited_globally = 1;
4857 if ((ret = ff_network_init()) < 0)
4859 if ((ret = ff_tls_init()) < 0)
4865 int avformat_network_deinit(void)
4870 ff_network_inited_globally = 0;
4875 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4876 uint64_t channel_layout, int32_t sample_rate,
4877 int32_t width, int32_t height)
4883 return AVERROR(EINVAL);
4886 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4888 if (channel_layout) {
4890 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4894 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4896 if (width || height) {
4898 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4900 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4902 return AVERROR(ENOMEM);
4903 bytestream_put_le32(&data, flags);
4905 bytestream_put_le32(&data, channels);
4907 bytestream_put_le64(&data, channel_layout);
4909 bytestream_put_le32(&data, sample_rate);
4910 if (width || height) {
4911 bytestream_put_le32(&data, width);
4912 bytestream_put_le32(&data, height);
4917 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4919 AVRational undef = {0, 1};
4920 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4921 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4922 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4924 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4925 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4926 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4927 stream_sample_aspect_ratio = undef;
4929 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4930 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4931 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4932 frame_sample_aspect_ratio = undef;
4934 if (stream_sample_aspect_ratio.num)
4935 return stream_sample_aspect_ratio;
4937 return frame_sample_aspect_ratio;
4940 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4942 AVRational fr = st->r_frame_rate;
4943 AVRational codec_fr = st->internal->avctx->framerate;
4944 AVRational avg_fr = st->avg_frame_rate;
4946 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4947 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4952 if (st->internal->avctx->ticks_per_frame > 1) {
4953 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4954 (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))
4961 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4964 if (*spec <= '9' && *spec >= '0') /* opt:index */
4965 return strtol(spec, NULL, 0) == st->index;
4966 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4967 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4968 enum AVMediaType type;
4972 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4973 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4974 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4975 case 'd': type = AVMEDIA_TYPE_DATA; break;
4976 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4977 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4978 default: av_assert0(0);
4980 #if FF_API_LAVF_AVCTX
4981 FF_DISABLE_DEPRECATION_WARNINGS
4982 if (type != st->codecpar->codec_type
4983 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4985 FF_ENABLE_DEPRECATION_WARNINGS
4987 if (type != st->codecpar->codec_type)
4990 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4992 if (*spec++ == ':') { /* possibly followed by :index */
4993 int i, index = strtol(spec, NULL, 0);
4994 for (i = 0; i < s->nb_streams; i++) {
4995 #if FF_API_LAVF_AVCTX
4996 FF_DISABLE_DEPRECATION_WARNINGS
4997 if ((s->streams[i]->codecpar->codec_type == type
4998 || s->streams[i]->codec->codec_type == type
5000 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5002 return i == st->index;
5003 FF_ENABLE_DEPRECATION_WARNINGS
5005 if ((s->streams[i]->codecpar->codec_type == type) &&
5006 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5008 return i == st->index;
5014 } else if (*spec == 'p' && *(spec + 1) == ':') {
5018 prog_id = strtol(spec, &endptr, 0);
5019 for (i = 0; i < s->nb_programs; i++) {
5020 if (s->programs[i]->id != prog_id)
5023 if (*endptr++ == ':') {
5024 int stream_idx = strtol(endptr, NULL, 0);
5025 return stream_idx >= 0 &&
5026 stream_idx < s->programs[i]->nb_stream_indexes &&
5027 st->index == s->programs[i]->stream_index[stream_idx];
5030 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5031 if (st->index == s->programs[i]->stream_index[j])
5035 } else if (*spec == '#' ||
5036 (*spec == 'i' && *(spec + 1) == ':')) {
5039 spec += 1 + (*spec == 'i');
5040 stream_id = strtol(spec, &endptr, 0);
5042 return stream_id == st->id;
5043 } else if (*spec == 'm' && *(spec + 1) == ':') {
5044 AVDictionaryEntry *tag;
5049 val = strchr(spec, ':');
5051 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5053 return AVERROR(ENOMEM);
5055 tag = av_dict_get(st->metadata, key, NULL, 0);
5057 if (!val || !strcmp(tag->value, val + 1))
5066 } else if (*spec == 'u') {
5067 AVCodecParameters *par = st->codecpar;
5068 #if FF_API_LAVF_AVCTX
5069 FF_DISABLE_DEPRECATION_WARNINGS
5070 AVCodecContext *codec = st->codec;
5071 FF_ENABLE_DEPRECATION_WARNINGS
5074 switch (par->codec_type) {
5075 case AVMEDIA_TYPE_AUDIO:
5076 val = par->sample_rate && par->channels;
5077 #if FF_API_LAVF_AVCTX
5078 val = val || (codec->sample_rate && codec->channels);
5080 if (par->format == AV_SAMPLE_FMT_NONE
5081 #if FF_API_LAVF_AVCTX
5082 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5087 case AVMEDIA_TYPE_VIDEO:
5088 val = par->width && par->height;
5089 #if FF_API_LAVF_AVCTX
5090 val = val || (codec->width && codec->height);
5092 if (par->format == AV_PIX_FMT_NONE
5093 #if FF_API_LAVF_AVCTX
5094 && codec->pix_fmt == AV_PIX_FMT_NONE
5099 case AVMEDIA_TYPE_UNKNOWN:
5106 #if FF_API_LAVF_AVCTX
5107 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5109 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5111 } else if (!*spec) /* empty specifier, matches everything */
5114 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5115 return AVERROR(EINVAL);
5118 int ff_generate_avci_extradata(AVStream *st)
5120 static const uint8_t avci100_1080p_extradata[] = {
5122 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5123 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5124 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5125 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5126 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5127 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5128 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5129 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5130 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5132 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5135 static const uint8_t avci100_1080i_extradata[] = {
5137 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5138 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5139 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5140 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5141 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5142 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5143 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5144 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5145 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5146 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5147 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5149 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5152 static const uint8_t avci50_1080p_extradata[] = {
5154 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5155 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5156 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5157 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5158 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5159 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5160 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5161 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5162 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5164 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5167 static const uint8_t avci50_1080i_extradata[] = {
5169 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5170 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5171 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5172 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5173 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5174 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5175 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5176 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5177 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5178 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5179 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5181 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5184 static const uint8_t avci100_720p_extradata[] = {
5186 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5187 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5188 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5189 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5190 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5191 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5192 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5193 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5194 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5195 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5197 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5200 static const uint8_t avci50_720p_extradata[] = {
5202 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5203 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5204 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5205 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5206 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5207 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5208 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5209 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5210 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5212 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5216 const uint8_t *data = NULL;
5219 if (st->codecpar->width == 1920) {
5220 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5221 data = avci100_1080p_extradata;
5222 size = sizeof(avci100_1080p_extradata);
5224 data = avci100_1080i_extradata;
5225 size = sizeof(avci100_1080i_extradata);
5227 } else if (st->codecpar->width == 1440) {
5228 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5229 data = avci50_1080p_extradata;
5230 size = sizeof(avci50_1080p_extradata);
5232 data = avci50_1080i_extradata;
5233 size = sizeof(avci50_1080i_extradata);
5235 } else if (st->codecpar->width == 1280) {
5236 data = avci100_720p_extradata;
5237 size = sizeof(avci100_720p_extradata);
5238 } else if (st->codecpar->width == 960) {
5239 data = avci50_720p_extradata;
5240 size = sizeof(avci50_720p_extradata);
5246 av_freep(&st->codecpar->extradata);
5247 if (ff_alloc_extradata(st->codecpar, size))
5248 return AVERROR(ENOMEM);
5249 memcpy(st->codecpar->extradata, data, size);
5254 #if FF_API_NOCONST_GET_SIDE_DATA
5255 uint8_t *av_stream_get_side_data(AVStream *st,
5256 enum AVPacketSideDataType type, int *size)
5258 uint8_t *av_stream_get_side_data(const AVStream *st,
5259 enum AVPacketSideDataType type, int *size)
5264 for (i = 0; i < st->nb_side_data; i++) {
5265 if (st->side_data[i].type == type) {
5267 *size = st->side_data[i].size;
5268 return st->side_data[i].data;
5274 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5275 uint8_t *data, size_t size)
5277 AVPacketSideData *sd, *tmp;
5280 for (i = 0; i < st->nb_side_data; i++) {
5281 sd = &st->side_data[i];
5283 if (sd->type == type) {
5284 av_freep(&sd->data);
5291 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5292 return AVERROR(ERANGE);
5294 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5296 return AVERROR(ENOMEM);
5299 st->side_data = tmp;
5302 sd = &st->side_data[st->nb_side_data - 1];
5310 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5314 uint8_t *data = av_malloc(size);
5319 ret = av_stream_add_side_data(st, type, data, size);
5328 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5331 const AVBitStreamFilter *bsf;
5333 AVCodecParameters *in_par;
5335 if (!(bsf = av_bsf_get_by_name(name))) {
5336 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5337 return AVERROR_BSF_NOT_FOUND;
5340 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5343 if (st->internal->nb_bsfcs) {
5344 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5345 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5347 in_par = st->codecpar;
5348 bsfc->time_base_in = st->time_base;
5351 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5356 if (args && bsfc->filter->priv_class) {
5357 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5358 const char * shorthand[2] = {NULL};
5361 shorthand[0] = opt->name;
5363 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5369 if ((ret = av_bsf_init(bsfc)) < 0) {
5374 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5379 av_log(NULL, AV_LOG_VERBOSE,
5380 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5381 name, args ? args : "");
5386 FF_DISABLE_DEPRECATION_WARNINGS
5387 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5388 AVBitStreamFilterContext *bsfc)
5392 AVPacket new_pkt = *pkt;
5393 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5394 &new_pkt.data, &new_pkt.size,
5395 pkt->data, pkt->size,
5396 pkt->flags & AV_PKT_FLAG_KEY);
5397 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5398 av_packet_unref(pkt);
5399 memset(pkt, 0, sizeof(*pkt));
5402 if(a == 0 && new_pkt.data != pkt->data) {
5403 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
5405 memcpy(t, new_pkt.data, new_pkt.size);
5406 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5411 a = AVERROR(ENOMEM);
5415 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5416 av_buffer_default_free, NULL, 0);
5418 pkt->side_data = NULL;
5419 pkt->side_data_elems = 0;
5420 av_packet_unref(pkt);
5422 av_freep(&new_pkt.data);
5423 a = AVERROR(ENOMEM);
5427 av_log(codec, AV_LOG_ERROR,
5428 "Failed to open bitstream filter %s for stream %d with codec %s",
5429 bsfc->filter->name, pkt->stream_index,
5430 codec->codec ? codec->codec->name : "copy");
5440 FF_ENABLE_DEPRECATION_WARNINGS
5443 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5446 return AVERROR(EINVAL);
5448 if (!(s->oformat->flags & AVFMT_NOFILE))
5449 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5453 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5456 s->io_close(s, *pb);
5460 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5462 AVDictionaryEntry *entry;
5463 int64_t parsed_timestamp;
5465 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5466 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5467 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5470 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5477 int ff_standardize_creation_time(AVFormatContext *s)
5480 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5482 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5486 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5491 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5493 if (size != AVPALETTE_SIZE) {
5494 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5495 return AVERROR_INVALIDDATA;
5497 memcpy(palette, side_data, AVPALETTE_SIZE);
5501 if (ret == CONTAINS_PAL) {
5503 for (i = 0; i < AVPALETTE_COUNT; i++)
5504 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5511 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5516 ret = av_bprint_finalize(buf, &str);
5519 if (!av_bprint_is_complete(buf)) {
5521 return AVERROR(ENOMEM);
5524 par->extradata = str;
5525 /* Note: the string is NUL terminated (so extradata can be read as a
5526 * string), but the ending character is not accounted in the size (in
5527 * binary formats you are likely not supposed to mux that character). When
5528 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5530 par->extradata_size = buf->len;
5534 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5535 AVStream *ost, const AVStream *ist,
5536 enum AVTimebaseSource copy_tb)
5538 //TODO: use [io]st->internal->avctx
5539 const AVCodecContext *dec_ctx = ist->codec;
5540 AVCodecContext *enc_ctx = ost->codec;
5542 enc_ctx->time_base = ist->time_base;
5544 * Avi is a special case here because it supports variable fps but
5545 * having the fps and timebase differe significantly adds quite some
5548 if (!strcmp(ofmt->name, "avi")) {
5549 #if FF_API_R_FRAME_RATE
5550 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5551 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5552 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5553 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5554 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5555 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5556 enc_ctx->time_base.num = ist->r_frame_rate.den;
5557 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5558 enc_ctx->ticks_per_frame = 2;
5561 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5562 && av_q2d(ist->time_base) < 1.0/500
5563 || copy_tb == AVFMT_TBCF_DECODER) {
5564 enc_ctx->time_base = dec_ctx->time_base;
5565 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5566 enc_ctx->time_base.den *= 2;
5567 enc_ctx->ticks_per_frame = 2;
5569 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5570 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5571 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5572 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5573 && av_q2d(ist->time_base) < 1.0/500
5574 || copy_tb == AVFMT_TBCF_DECODER) {
5575 enc_ctx->time_base = dec_ctx->time_base;
5576 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5580 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5581 && dec_ctx->time_base.num < dec_ctx->time_base.den
5582 && dec_ctx->time_base.num > 0
5583 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5584 enc_ctx->time_base = dec_ctx->time_base;
5587 if (ost->avg_frame_rate.num)
5588 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5590 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5591 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5596 AVRational av_stream_get_codec_timebase(const AVStream *st)
5598 // See avformat_transfer_internal_stream_timing_info() TODO.
5599 #if FF_API_LAVF_AVCTX
5600 FF_DISABLE_DEPRECATION_WARNINGS
5601 return st->codec->time_base;
5602 FF_ENABLE_DEPRECATION_WARNINGS
5604 return st->internal->avctx->time_base;