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;
1682 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1684 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1685 av_dict_copy(&s->metadata, metadata, 0);
1686 av_dict_free(&metadata);
1687 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1690 #if FF_API_LAVF_AVCTX
1691 update_stream_avctx(s);
1694 if (s->debug & FF_FDEBUG_TS)
1695 av_log(s, AV_LOG_DEBUG,
1696 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1697 "size=%d, duration=%"PRId64", flags=%d\n",
1699 av_ts2str(pkt->pts),
1700 av_ts2str(pkt->dts),
1701 pkt->size, pkt->duration, pkt->flags);
1706 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1708 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1714 ret = s->internal->packet_buffer
1715 ? read_from_packet_buffer(&s->internal->packet_buffer,
1716 &s->internal->packet_buffer_end, pkt)
1717 : read_frame_internal(s, pkt);
1724 AVPacketList *pktl = s->internal->packet_buffer;
1727 AVPacket *next_pkt = &pktl->pkt;
1729 if (next_pkt->dts != AV_NOPTS_VALUE) {
1730 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1731 // last dts seen for this stream. if any of packets following
1732 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1733 int64_t last_dts = next_pkt->dts;
1734 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1735 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1736 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1737 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1739 next_pkt->pts = pktl->pkt.dts;
1741 if (last_dts != AV_NOPTS_VALUE) {
1742 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1743 last_dts = pktl->pkt.dts;
1748 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1749 // Fixing the last reference frame had none pts issue (For MXF etc).
1750 // We only do this when
1752 // 2. we are not able to resolve a pts value for current packet.
1753 // 3. the packets for this stream at the end of the files had valid dts.
1754 next_pkt->pts = last_dts + next_pkt->duration;
1756 pktl = s->internal->packet_buffer;
1759 /* read packet from packet buffer, if there is data */
1760 st = s->streams[next_pkt->stream_index];
1761 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1762 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1763 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1764 &s->internal->packet_buffer_end, pkt);
1769 ret = read_frame_internal(s, pkt);
1771 if (pktl && ret != AVERROR(EAGAIN)) {
1778 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1779 &s->internal->packet_buffer_end, 1);
1780 av_packet_unref(pkt);
1787 st = s->streams[pkt->stream_index];
1788 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1789 ff_reduce_index(s, st->index);
1790 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1793 if (is_relative(pkt->dts))
1794 pkt->dts -= RELATIVE_TS_BASE;
1795 if (is_relative(pkt->pts))
1796 pkt->pts -= RELATIVE_TS_BASE;
1801 /* XXX: suppress the packet queue */
1802 static void flush_packet_queue(AVFormatContext *s)
1806 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1807 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1808 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1810 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1813 /*******************************************************/
1816 int av_find_default_stream_index(AVFormatContext *s)
1820 int best_stream = 0;
1821 int best_score = INT_MIN;
1823 if (s->nb_streams <= 0)
1825 for (i = 0; i < s->nb_streams; i++) {
1828 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1829 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1831 if (st->codecpar->width && st->codecpar->height)
1835 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1836 if (st->codecpar->sample_rate)
1839 if (st->codec_info_nb_frames)
1842 if (st->discard != AVDISCARD_ALL)
1845 if (score > best_score) {
1853 /** Flush the frame reader. */
1854 void ff_read_frame_flush(AVFormatContext *s)
1859 flush_packet_queue(s);
1861 /* Reset read state for each stream. */
1862 for (i = 0; i < s->nb_streams; i++) {
1866 av_parser_close(st->parser);
1869 st->last_IP_pts = AV_NOPTS_VALUE;
1870 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1871 if (st->first_dts == AV_NOPTS_VALUE)
1872 st->cur_dts = RELATIVE_TS_BASE;
1874 /* We set the current DTS to an unspecified origin. */
1875 st->cur_dts = AV_NOPTS_VALUE;
1877 st->probe_packets = MAX_PROBE_PACKETS;
1879 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1880 st->pts_buffer[j] = AV_NOPTS_VALUE;
1882 if (s->internal->inject_global_side_data)
1883 st->inject_global_side_data = 1;
1885 st->skip_samples = 0;
1889 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1893 for (i = 0; i < s->nb_streams; i++) {
1894 AVStream *st = s->streams[i];
1897 av_rescale(timestamp,
1898 st->time_base.den * (int64_t) ref_st->time_base.num,
1899 st->time_base.num * (int64_t) ref_st->time_base.den);
1903 void ff_reduce_index(AVFormatContext *s, int stream_index)
1905 AVStream *st = s->streams[stream_index];
1906 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1908 if ((unsigned) st->nb_index_entries >= max_entries) {
1910 for (i = 0; 2 * i < st->nb_index_entries; i++)
1911 st->index_entries[i] = st->index_entries[2 * i];
1912 st->nb_index_entries = i;
1916 int ff_add_index_entry(AVIndexEntry **index_entries,
1917 int *nb_index_entries,
1918 unsigned int *index_entries_allocated_size,
1919 int64_t pos, int64_t timestamp,
1920 int size, int distance, int flags)
1922 AVIndexEntry *entries, *ie;
1925 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1928 if (timestamp == AV_NOPTS_VALUE)
1929 return AVERROR(EINVAL);
1931 if (size < 0 || size > 0x3FFFFFFF)
1932 return AVERROR(EINVAL);
1934 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1935 timestamp -= RELATIVE_TS_BASE;
1937 entries = av_fast_realloc(*index_entries,
1938 index_entries_allocated_size,
1939 (*nb_index_entries + 1) *
1940 sizeof(AVIndexEntry));
1944 *index_entries = entries;
1946 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1947 timestamp, AVSEEK_FLAG_ANY);
1950 index = (*nb_index_entries)++;
1951 ie = &entries[index];
1952 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1954 ie = &entries[index];
1955 if (ie->timestamp != timestamp) {
1956 if (ie->timestamp <= timestamp)
1958 memmove(entries + index + 1, entries + index,
1959 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1960 (*nb_index_entries)++;
1961 } else if (ie->pos == pos && distance < ie->min_distance)
1962 // do not reduce the distance
1963 distance = ie->min_distance;
1967 ie->timestamp = timestamp;
1968 ie->min_distance = distance;
1975 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1976 int size, int distance, int flags)
1978 timestamp = wrap_timestamp(st, timestamp);
1979 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1980 &st->index_entries_allocated_size, pos,
1981 timestamp, size, distance, flags);
1984 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1985 int64_t wanted_timestamp, int flags)
1993 // Optimize appending index entries at the end.
1994 if (b && entries[b - 1].timestamp < wanted_timestamp)
2000 // Search for the next non-discarded packet.
2001 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2003 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2009 timestamp = entries[m].timestamp;
2010 if (timestamp >= wanted_timestamp)
2012 if (timestamp <= wanted_timestamp)
2015 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2017 if (!(flags & AVSEEK_FLAG_ANY))
2018 while (m >= 0 && m < nb_entries &&
2019 !(entries[m].flags & AVINDEX_KEYFRAME))
2020 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2022 if (m == nb_entries)
2027 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2030 int64_t pos_delta = 0;
2032 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2033 const char *proto = avio_find_protocol_name(s->filename);
2036 av_log(s, AV_LOG_INFO,
2037 "Protocol name not provided, cannot determine if input is local or "
2038 "a network protocol, buffers and access patterns cannot be configured "
2039 "optimally without knowing the protocol\n");
2042 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2045 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2046 AVStream *st1 = s->streams[ist1];
2047 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2048 AVStream *st2 = s->streams[ist2];
2054 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2055 AVIndexEntry *e1 = &st1->index_entries[i1];
2056 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2058 skip = FFMAX(skip, e1->size);
2059 for (; i2 < st2->nb_index_entries; i2++) {
2060 AVIndexEntry *e2 = &st2->index_entries[i2];
2061 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2062 if (e2_pts - e1_pts < time_tolerance)
2064 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2072 /* XXX This could be adjusted depending on protocol*/
2073 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2074 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2075 ffio_set_buf_size(s->pb, pos_delta);
2076 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2079 if (skip < (1<<23)) {
2080 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2084 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2086 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2087 wanted_timestamp, flags);
2090 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2091 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2093 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2094 if (stream_index >= 0)
2095 ts = wrap_timestamp(s->streams[stream_index], ts);
2099 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2100 int64_t target_ts, int flags)
2102 AVInputFormat *avif = s->iformat;
2103 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2104 int64_t ts_min, ts_max, ts;
2109 if (stream_index < 0)
2112 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2115 ts_min = AV_NOPTS_VALUE;
2116 pos_limit = -1; // GCC falsely says it may be uninitialized.
2118 st = s->streams[stream_index];
2119 if (st->index_entries) {
2122 /* FIXME: Whole function must be checked for non-keyframe entries in
2123 * index case, especially read_timestamp(). */
2124 index = av_index_search_timestamp(st, target_ts,
2125 flags | AVSEEK_FLAG_BACKWARD);
2126 index = FFMAX(index, 0);
2127 e = &st->index_entries[index];
2129 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2131 ts_min = e->timestamp;
2132 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2133 pos_min, av_ts2str(ts_min));
2135 av_assert1(index == 0);
2138 index = av_index_search_timestamp(st, target_ts,
2139 flags & ~AVSEEK_FLAG_BACKWARD);
2140 av_assert0(index < st->nb_index_entries);
2142 e = &st->index_entries[index];
2143 av_assert1(e->timestamp >= target_ts);
2145 ts_max = e->timestamp;
2146 pos_limit = pos_max - e->min_distance;
2147 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2148 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2152 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2153 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2158 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2161 ff_read_frame_flush(s);
2162 ff_update_cur_dts(s, st, ts);
2167 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2168 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2170 int64_t step = 1024;
2171 int64_t limit, ts_max;
2172 int64_t filesize = avio_size(s->pb);
2173 int64_t pos_max = filesize - 1;
2176 pos_max = FFMAX(0, (pos_max) - step);
2177 ts_max = ff_read_timestamp(s, stream_index,
2178 &pos_max, limit, read_timestamp);
2180 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2181 if (ts_max == AV_NOPTS_VALUE)
2185 int64_t tmp_pos = pos_max + 1;
2186 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2187 &tmp_pos, INT64_MAX, read_timestamp);
2188 if (tmp_ts == AV_NOPTS_VALUE)
2190 av_assert0(tmp_pos > pos_max);
2193 if (tmp_pos >= filesize)
2205 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2206 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2207 int64_t ts_min, int64_t ts_max,
2208 int flags, int64_t *ts_ret,
2209 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2210 int64_t *, int64_t))
2217 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2219 if (ts_min == AV_NOPTS_VALUE) {
2220 pos_min = s->internal->data_offset;
2221 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2222 if (ts_min == AV_NOPTS_VALUE)
2226 if (ts_min >= target_ts) {
2231 if (ts_max == AV_NOPTS_VALUE) {
2232 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2234 pos_limit = pos_max;
2237 if (ts_max <= target_ts) {
2242 av_assert0(ts_min < ts_max);
2245 while (pos_min < pos_limit) {
2246 av_log(s, AV_LOG_TRACE,
2247 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2248 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2249 av_assert0(pos_limit <= pos_max);
2251 if (no_change == 0) {
2252 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2253 // interpolate position (better than dichotomy)
2254 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2256 pos_min - approximate_keyframe_distance;
2257 } else if (no_change == 1) {
2258 // bisection if interpolation did not change min / max pos last time
2259 pos = (pos_min + pos_limit) >> 1;
2261 /* linear search if bisection failed, can only happen if there
2262 * are very few or no keyframes between min/max */
2267 else if (pos > pos_limit)
2271 // May pass pos_limit instead of -1.
2272 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2277 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2278 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2279 pos_min, pos, pos_max,
2280 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2281 pos_limit, start_pos, no_change);
2282 if (ts == AV_NOPTS_VALUE) {
2283 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2286 if (target_ts <= ts) {
2287 pos_limit = start_pos - 1;
2291 if (target_ts >= ts) {
2297 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2298 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2301 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2303 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2304 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2305 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2311 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2312 int64_t pos, int flags)
2314 int64_t pos_min, pos_max;
2316 pos_min = s->internal->data_offset;
2317 pos_max = avio_size(s->pb) - 1;
2321 else if (pos > pos_max)
2324 avio_seek(s->pb, pos, SEEK_SET);
2326 s->io_repositioned = 1;
2331 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2332 int64_t timestamp, int flags)
2339 st = s->streams[stream_index];
2341 index = av_index_search_timestamp(st, timestamp, flags);
2343 if (index < 0 && st->nb_index_entries &&
2344 timestamp < st->index_entries[0].timestamp)
2347 if (index < 0 || index == st->nb_index_entries - 1) {
2351 if (st->nb_index_entries) {
2352 av_assert0(st->index_entries);
2353 ie = &st->index_entries[st->nb_index_entries - 1];
2354 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2356 ff_update_cur_dts(s, st, ie->timestamp);
2358 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2364 read_status = av_read_frame(s, &pkt);
2365 } while (read_status == AVERROR(EAGAIN));
2366 if (read_status < 0)
2368 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2369 if (pkt.flags & AV_PKT_FLAG_KEY) {
2370 av_packet_unref(&pkt);
2373 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2374 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);
2375 av_packet_unref(&pkt);
2379 av_packet_unref(&pkt);
2381 index = av_index_search_timestamp(st, timestamp, flags);
2386 ff_read_frame_flush(s);
2387 if (s->iformat->read_seek)
2388 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2390 ie = &st->index_entries[index];
2391 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2393 ff_update_cur_dts(s, st, ie->timestamp);
2398 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2399 int64_t timestamp, int flags)
2404 if (flags & AVSEEK_FLAG_BYTE) {
2405 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2407 ff_read_frame_flush(s);
2408 return seek_frame_byte(s, stream_index, timestamp, flags);
2411 if (stream_index < 0) {
2412 stream_index = av_find_default_stream_index(s);
2413 if (stream_index < 0)
2416 st = s->streams[stream_index];
2417 /* timestamp for default must be expressed in AV_TIME_BASE units */
2418 timestamp = av_rescale(timestamp, st->time_base.den,
2419 AV_TIME_BASE * (int64_t) st->time_base.num);
2422 /* first, we try the format specific seek */
2423 if (s->iformat->read_seek) {
2424 ff_read_frame_flush(s);
2425 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2431 if (s->iformat->read_timestamp &&
2432 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2433 ff_read_frame_flush(s);
2434 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2435 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2436 ff_read_frame_flush(s);
2437 return seek_frame_generic(s, stream_index, timestamp, flags);
2442 int av_seek_frame(AVFormatContext *s, int stream_index,
2443 int64_t timestamp, int flags)
2447 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2448 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2449 if ((flags & AVSEEK_FLAG_BACKWARD))
2453 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2454 flags & ~AVSEEK_FLAG_BACKWARD);
2457 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2460 ret = avformat_queue_attached_pictures(s);
2465 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2466 int64_t ts, int64_t max_ts, int flags)
2468 if (min_ts > ts || max_ts < ts)
2470 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2471 return AVERROR(EINVAL);
2474 flags |= AVSEEK_FLAG_ANY;
2475 flags &= ~AVSEEK_FLAG_BACKWARD;
2477 if (s->iformat->read_seek2) {
2479 ff_read_frame_flush(s);
2481 if (stream_index == -1 && s->nb_streams == 1) {
2482 AVRational time_base = s->streams[0]->time_base;
2483 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2484 min_ts = av_rescale_rnd(min_ts, time_base.den,
2485 time_base.num * (int64_t)AV_TIME_BASE,
2486 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2487 max_ts = av_rescale_rnd(max_ts, time_base.den,
2488 time_base.num * (int64_t)AV_TIME_BASE,
2489 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2493 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2497 ret = avformat_queue_attached_pictures(s);
2501 if (s->iformat->read_timestamp) {
2502 // try to seek via read_timestamp()
2505 // Fall back on old API if new is not implemented but old is.
2506 // Note the old API has somewhat different semantics.
2507 if (s->iformat->read_seek || 1) {
2508 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2509 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2510 if (ret<0 && ts != min_ts && max_ts != ts) {
2511 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2513 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2518 // try some generic seek like seek_frame_generic() but with new ts semantics
2519 return -1; //unreachable
2522 int avformat_flush(AVFormatContext *s)
2524 ff_read_frame_flush(s);
2528 /*******************************************************/
2531 * Return TRUE if the stream has accurate duration in any stream.
2533 * @return TRUE if the stream has accurate duration for at least one component.
2535 static int has_duration(AVFormatContext *ic)
2540 for (i = 0; i < ic->nb_streams; i++) {
2541 st = ic->streams[i];
2542 if (st->duration != AV_NOPTS_VALUE)
2545 if (ic->duration != AV_NOPTS_VALUE)
2551 * Estimate the stream timings from the one of each components.
2553 * Also computes the global bitrate if possible.
2555 static void update_stream_timings(AVFormatContext *ic)
2557 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2558 int64_t duration, duration1, filesize;
2563 start_time = INT64_MAX;
2564 start_time_text = INT64_MAX;
2565 end_time = INT64_MIN;
2566 end_time_text = INT64_MIN;
2567 duration = INT64_MIN;
2568 for (i = 0; i < ic->nb_streams; i++) {
2569 st = ic->streams[i];
2570 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2571 start_time1 = av_rescale_q(st->start_time, st->time_base,
2573 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2574 if (start_time1 < start_time_text)
2575 start_time_text = start_time1;
2577 start_time = FFMIN(start_time, start_time1);
2578 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2580 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2581 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2582 end_time1 += start_time1;
2583 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2584 end_time_text = FFMAX(end_time_text, end_time1);
2586 end_time = FFMAX(end_time, end_time1);
2588 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2589 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2590 p->start_time = start_time1;
2591 if (p->end_time < end_time1)
2592 p->end_time = end_time1;
2595 if (st->duration != AV_NOPTS_VALUE) {
2596 duration1 = av_rescale_q(st->duration, st->time_base,
2598 duration = FFMAX(duration, duration1);
2601 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2602 start_time = start_time_text;
2603 else if (start_time > start_time_text)
2604 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2606 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2607 end_time = end_time_text;
2608 } else if (end_time < end_time_text) {
2609 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2612 if (start_time != INT64_MAX) {
2613 ic->start_time = start_time;
2614 if (end_time != INT64_MIN) {
2615 if (ic->nb_programs > 1) {
2616 for (i = 0; i < ic->nb_programs; i++) {
2617 p = ic->programs[i];
2618 if (p->start_time != AV_NOPTS_VALUE &&
2619 p->end_time > p->start_time &&
2620 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2621 duration = FFMAX(duration, p->end_time - p->start_time);
2623 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2624 duration = FFMAX(duration, end_time - start_time);
2628 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2629 ic->duration = duration;
2631 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2632 /* compute the bitrate */
2633 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2634 (double) ic->duration;
2635 if (bitrate >= 0 && bitrate <= INT64_MAX)
2636 ic->bit_rate = bitrate;
2640 static void fill_all_stream_timings(AVFormatContext *ic)
2645 update_stream_timings(ic);
2646 for (i = 0; i < ic->nb_streams; i++) {
2647 st = ic->streams[i];
2648 if (st->start_time == AV_NOPTS_VALUE) {
2649 if (ic->start_time != AV_NOPTS_VALUE)
2650 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2652 if (ic->duration != AV_NOPTS_VALUE)
2653 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2659 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2661 int64_t filesize, duration;
2662 int i, show_warning = 0;
2665 /* if bit_rate is already set, we believe it */
2666 if (ic->bit_rate <= 0) {
2667 int64_t bit_rate = 0;
2668 for (i = 0; i < ic->nb_streams; i++) {
2669 st = ic->streams[i];
2670 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2671 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2672 if (st->codecpar->bit_rate > 0) {
2673 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2677 bit_rate += st->codecpar->bit_rate;
2678 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2679 // If we have a videostream with packets but without a bitrate
2680 // then consider the sum not known
2685 ic->bit_rate = bit_rate;
2688 /* if duration is already set, we believe it */
2689 if (ic->duration == AV_NOPTS_VALUE &&
2690 ic->bit_rate != 0) {
2691 filesize = ic->pb ? avio_size(ic->pb) : 0;
2692 if (filesize > ic->internal->data_offset) {
2693 filesize -= ic->internal->data_offset;
2694 for (i = 0; i < ic->nb_streams; i++) {
2695 st = ic->streams[i];
2696 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2697 && st->duration == AV_NOPTS_VALUE) {
2698 duration = av_rescale(8 * filesize, st->time_base.den,
2700 (int64_t) st->time_base.num);
2701 st->duration = duration;
2708 av_log(ic, AV_LOG_WARNING,
2709 "Estimating duration from bitrate, this may be inaccurate\n");
2712 #define DURATION_MAX_READ_SIZE 250000LL
2713 #define DURATION_MAX_RETRY 6
2715 /* only usable for MPEG-PS streams */
2716 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2718 AVPacket pkt1, *pkt = &pkt1;
2720 int num, den, read_size, i, ret;
2721 int found_duration = 0;
2723 int64_t filesize, offset, duration;
2726 /* flush packet queue */
2727 flush_packet_queue(ic);
2729 for (i = 0; i < ic->nb_streams; i++) {
2730 st = ic->streams[i];
2731 if (st->start_time == AV_NOPTS_VALUE &&
2732 st->first_dts == AV_NOPTS_VALUE &&
2733 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2734 av_log(ic, AV_LOG_WARNING,
2735 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2738 av_parser_close(st->parser);
2743 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2744 /* estimate the end time (duration) */
2745 /* XXX: may need to support wrapping */
2746 filesize = ic->pb ? avio_size(ic->pb) : 0;
2748 is_end = found_duration;
2749 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2753 avio_seek(ic->pb, offset, SEEK_SET);
2756 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2760 ret = ff_read_packet(ic, pkt);
2761 } while (ret == AVERROR(EAGAIN));
2764 read_size += pkt->size;
2765 st = ic->streams[pkt->stream_index];
2766 if (pkt->pts != AV_NOPTS_VALUE &&
2767 (st->start_time != AV_NOPTS_VALUE ||
2768 st->first_dts != AV_NOPTS_VALUE)) {
2769 if (pkt->duration == 0) {
2770 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2772 pkt->duration = av_rescale_rnd(1,
2773 num * (int64_t) st->time_base.den,
2774 den * (int64_t) st->time_base.num,
2778 duration = pkt->pts + pkt->duration;
2780 if (st->start_time != AV_NOPTS_VALUE)
2781 duration -= st->start_time;
2783 duration -= st->first_dts;
2785 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2786 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2787 st->duration = duration;
2788 st->info->last_duration = duration;
2791 av_packet_unref(pkt);
2794 /* check if all audio/video streams have valid duration */
2797 for (i = 0; i < ic->nb_streams; i++) {
2798 st = ic->streams[i];
2799 switch (st->codecpar->codec_type) {
2800 case AVMEDIA_TYPE_VIDEO:
2801 case AVMEDIA_TYPE_AUDIO:
2802 if (st->duration == AV_NOPTS_VALUE)
2809 ++retry <= DURATION_MAX_RETRY);
2811 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2813 /* warn about audio/video streams which duration could not be estimated */
2814 for (i = 0; i < ic->nb_streams; i++) {
2815 st = ic->streams[i];
2816 if (st->duration == AV_NOPTS_VALUE) {
2817 switch (st->codecpar->codec_type) {
2818 case AVMEDIA_TYPE_VIDEO:
2819 case AVMEDIA_TYPE_AUDIO:
2820 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2821 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2823 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2827 fill_all_stream_timings(ic);
2829 avio_seek(ic->pb, old_offset, SEEK_SET);
2830 for (i = 0; i < ic->nb_streams; i++) {
2833 st = ic->streams[i];
2834 st->cur_dts = st->first_dts;
2835 st->last_IP_pts = AV_NOPTS_VALUE;
2836 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2837 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2838 st->pts_buffer[j] = AV_NOPTS_VALUE;
2842 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2846 /* get the file size, if possible */
2847 if (ic->iformat->flags & AVFMT_NOFILE) {
2850 file_size = avio_size(ic->pb);
2851 file_size = FFMAX(0, file_size);
2854 if ((!strcmp(ic->iformat->name, "mpeg") ||
2855 !strcmp(ic->iformat->name, "mpegts")) &&
2856 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2857 /* get accurate estimate from the PTSes */
2858 estimate_timings_from_pts(ic, old_offset);
2859 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2860 } else if (has_duration(ic)) {
2861 /* at least one component has timings - we use them for all
2863 fill_all_stream_timings(ic);
2864 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2866 /* less precise: use bitrate info */
2867 estimate_timings_from_bit_rate(ic);
2868 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2870 update_stream_timings(ic);
2874 AVStream av_unused *st;
2875 for (i = 0; i < ic->nb_streams; i++) {
2876 st = ic->streams[i];
2877 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2878 (double) st->start_time * av_q2d(st->time_base),
2879 (double) st->duration * av_q2d(st->time_base));
2881 av_log(ic, AV_LOG_TRACE,
2882 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2883 (double) ic->start_time / AV_TIME_BASE,
2884 (double) ic->duration / AV_TIME_BASE,
2885 (int64_t)ic->bit_rate / 1000);
2889 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2891 AVCodecContext *avctx = st->internal->avctx;
2893 #define FAIL(errmsg) do { \
2895 *errmsg_ptr = errmsg; \
2899 if ( avctx->codec_id == AV_CODEC_ID_NONE
2900 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2901 FAIL("unknown codec");
2902 switch (avctx->codec_type) {
2903 case AVMEDIA_TYPE_AUDIO:
2904 if (!avctx->frame_size && determinable_frame_size(avctx))
2905 FAIL("unspecified frame size");
2906 if (st->info->found_decoder >= 0 &&
2907 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2908 FAIL("unspecified sample format");
2909 if (!avctx->sample_rate)
2910 FAIL("unspecified sample rate");
2911 if (!avctx->channels)
2912 FAIL("unspecified number of channels");
2913 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2914 FAIL("no decodable DTS frames");
2916 case AVMEDIA_TYPE_VIDEO:
2918 FAIL("unspecified size");
2919 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2920 FAIL("unspecified pixel format");
2921 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2922 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2923 FAIL("no frame in rv30/40 and no sar");
2925 case AVMEDIA_TYPE_SUBTITLE:
2926 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2927 FAIL("unspecified size");
2929 case AVMEDIA_TYPE_DATA:
2930 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2936 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2937 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2938 AVDictionary **options)
2940 AVCodecContext *avctx = st->internal->avctx;
2941 const AVCodec *codec;
2942 int got_picture = 1, ret = 0;
2943 AVFrame *frame = av_frame_alloc();
2944 AVSubtitle subtitle;
2945 AVPacket pkt = *avpkt;
2946 int do_skip_frame = 0;
2947 enum AVDiscard skip_frame;
2950 return AVERROR(ENOMEM);
2952 if (!avcodec_is_open(avctx) &&
2953 st->info->found_decoder <= 0 &&
2954 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2955 AVDictionary *thread_opt = NULL;
2957 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2960 st->info->found_decoder = -st->codecpar->codec_id;
2965 /* Force thread count to 1 since the H.264 decoder will not extract
2966 * SPS and PPS to extradata during multi-threaded decoding. */
2967 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2968 if (s->codec_whitelist)
2969 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2970 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2972 av_dict_free(&thread_opt);
2974 st->info->found_decoder = -avctx->codec_id;
2977 st->info->found_decoder = 1;
2978 } else if (!st->info->found_decoder)
2979 st->info->found_decoder = 1;
2981 if (st->info->found_decoder < 0) {
2986 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2988 skip_frame = avctx->skip_frame;
2989 avctx->skip_frame = AVDISCARD_ALL;
2992 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2994 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2995 (!st->codec_info_nb_frames &&
2996 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2998 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2999 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3000 ret = avcodec_send_packet(avctx, &pkt);
3001 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3005 ret = avcodec_receive_frame(avctx, frame);
3008 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3010 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3011 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3012 &got_picture, &pkt);
3018 st->nb_decoded_frames++;
3023 if (!pkt.data && !got_picture)
3027 if (do_skip_frame) {
3028 avctx->skip_frame = skip_frame;
3031 av_frame_free(&frame);
3035 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3037 while (tags->id != AV_CODEC_ID_NONE) {
3045 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3048 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3049 if (tag == tags[i].tag)
3051 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3052 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3054 return AV_CODEC_ID_NONE;
3057 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3059 if (bps <= 0 || bps > 64)
3060 return AV_CODEC_ID_NONE;
3065 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3067 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3069 return AV_CODEC_ID_NONE;
3074 if (sflags & (1 << (bps - 1))) {
3077 return AV_CODEC_ID_PCM_S8;
3079 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3081 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3083 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3085 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3087 return AV_CODEC_ID_NONE;
3092 return AV_CODEC_ID_PCM_U8;
3094 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3096 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3098 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3100 return AV_CODEC_ID_NONE;
3106 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3109 if (!av_codec_get_tag2(tags, id, &tag))
3114 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3118 for (i = 0; tags && tags[i]; i++) {
3119 const AVCodecTag *codec_tags = tags[i];
3120 while (codec_tags->id != AV_CODEC_ID_NONE) {
3121 if (codec_tags->id == id) {
3122 *tag = codec_tags->tag;
3131 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3134 for (i = 0; tags && tags[i]; i++) {
3135 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3136 if (id != AV_CODEC_ID_NONE)
3139 return AV_CODEC_ID_NONE;
3142 static void compute_chapters_end(AVFormatContext *s)
3145 int64_t max_time = 0;
3147 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3148 max_time = s->duration +
3149 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3151 for (i = 0; i < s->nb_chapters; i++)
3152 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3153 AVChapter *ch = s->chapters[i];
3154 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3158 for (j = 0; j < s->nb_chapters; j++) {
3159 AVChapter *ch1 = s->chapters[j];
3160 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3162 if (j != i && next_start > ch->start && next_start < end)
3165 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3169 static int get_std_framerate(int i)
3172 return (i + 1) * 1001;
3176 return (i + 31) * 1001 * 12;
3180 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3184 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3187 /* Is the time base unreliable?
3188 * This is a heuristic to balance between quick acceptance of the values in
3189 * the headers vs. some extra checks.
3190 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3191 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3192 * And there are "variable" fps files this needs to detect as well. */
3193 static int tb_unreliable(AVCodecContext *c)
3195 if (c->time_base.den >= 101LL * c->time_base.num ||
3196 c->time_base.den < 5LL * c->time_base.num ||
3197 // c->codec_tag == AV_RL32("DIVX") ||
3198 // c->codec_tag == AV_RL32("XVID") ||
3199 c->codec_tag == AV_RL32("mp4v") ||
3200 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3201 c->codec_id == AV_CODEC_ID_GIF ||
3202 c->codec_id == AV_CODEC_ID_HEVC ||
3203 c->codec_id == AV_CODEC_ID_H264)
3208 int ff_alloc_extradata(AVCodecParameters *par, int size)
3212 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3213 par->extradata = NULL;
3214 par->extradata_size = 0;
3215 return AVERROR(EINVAL);
3217 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3218 if (par->extradata) {
3219 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3220 par->extradata_size = size;
3223 par->extradata_size = 0;
3224 ret = AVERROR(ENOMEM);
3229 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3231 int ret = ff_alloc_extradata(par, size);
3234 ret = avio_read(pb, par->extradata, size);
3236 av_freep(&par->extradata);
3237 par->extradata_size = 0;
3238 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3239 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3245 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3248 int64_t last = st->info->last_dts;
3250 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3251 && ts - (uint64_t)last < INT64_MAX) {
3252 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3253 int64_t duration = ts - last;
3255 if (!st->info->duration_error)
3256 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3257 if (!st->info->duration_error)
3258 return AVERROR(ENOMEM);
3260 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3261 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3262 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3263 if (st->info->duration_error[0][1][i] < 1e10) {
3264 int framerate = get_std_framerate(i);
3265 double sdts = dts*framerate/(1001*12);
3266 for (j= 0; j<2; j++) {
3267 int64_t ticks = llrint(sdts+j*0.5);
3268 double error= sdts - ticks + j*0.5;
3269 st->info->duration_error[j][0][i] += error;
3270 st->info->duration_error[j][1][i] += error*error;
3274 st->info->duration_count++;
3275 st->info->rfps_duration_sum += duration;
3277 if (st->info->duration_count % 10 == 0) {
3278 int n = st->info->duration_count;
3279 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3280 if (st->info->duration_error[0][1][i] < 1e10) {
3281 double a0 = st->info->duration_error[0][0][i] / n;
3282 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3283 double a1 = st->info->duration_error[1][0][i] / n;
3284 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3285 if (error0 > 0.04 && error1 > 0.04) {
3286 st->info->duration_error[0][1][i] = 2e10;
3287 st->info->duration_error[1][1][i] = 2e10;
3293 // ignore the first 4 values, they might have some random jitter
3294 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3295 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3297 if (ts != AV_NOPTS_VALUE)
3298 st->info->last_dts = ts;
3303 void ff_rfps_calculate(AVFormatContext *ic)
3307 for (i = 0; i < ic->nb_streams; i++) {
3308 AVStream *st = ic->streams[i];
3310 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3312 // the check for tb_unreliable() is not completely correct, since this is not about handling
3313 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3314 // ipmovie.c produces.
3315 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)
3316 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);
3317 if (st->info->duration_count>1 && !st->r_frame_rate.num
3318 && tb_unreliable(st->internal->avctx)) {
3320 double best_error= 0.01;
3321 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3323 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3326 if (st->info->codec_info_duration &&
3327 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3329 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3332 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3335 for (k= 0; k<2; k++) {
3336 int n = st->info->duration_count;
3337 double a= st->info->duration_error[k][0][j] / n;
3338 double error= st->info->duration_error[k][1][j]/n - a*a;
3340 if (error < best_error && best_error> 0.000000001) {
3342 num = get_std_framerate(j);
3345 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3348 // do not increase frame rate by more than 1 % in order to match a standard rate.
3349 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3350 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3352 if ( !st->avg_frame_rate.num
3353 && st->r_frame_rate.num && st->info->rfps_duration_sum
3354 && st->info->codec_info_duration <= 0
3355 && st->info->duration_count > 2
3356 && 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
3358 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3359 st->avg_frame_rate = st->r_frame_rate;
3362 av_freep(&st->info->duration_error);
3363 st->info->last_dts = AV_NOPTS_VALUE;
3364 st->info->duration_count = 0;
3365 st->info->rfps_duration_sum = 0;
3369 static int extract_extradata_check(AVStream *st)
3371 const AVBitStreamFilter *f;
3373 f = av_bsf_get_by_name("extract_extradata");
3378 const enum AVCodecID *ids;
3379 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3380 if (*ids == st->codecpar->codec_id)
3387 static int extract_extradata_init(AVStream *st)
3389 AVStreamInternal *i = st->internal;
3390 const AVBitStreamFilter *f;
3393 f = av_bsf_get_by_name("extract_extradata");
3397 /* check that the codec id is supported */
3398 ret = extract_extradata_check(st);
3402 i->extract_extradata.pkt = av_packet_alloc();
3403 if (!i->extract_extradata.pkt)
3404 return AVERROR(ENOMEM);
3406 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3410 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3415 i->extract_extradata.bsf->time_base_in = st->time_base;
3417 /* if init fails here, we assume extracting extradata is just not
3418 * supported for this codec, so we return success */
3419 ret = av_bsf_init(i->extract_extradata.bsf);
3421 av_bsf_free(&i->extract_extradata.bsf);
3426 i->extract_extradata.inited = 1;
3430 av_bsf_free(&i->extract_extradata.bsf);
3431 av_packet_free(&i->extract_extradata.pkt);
3435 static int extract_extradata(AVStream *st, AVPacket *pkt)
3437 AVStreamInternal *i = st->internal;
3441 if (!i->extract_extradata.inited) {
3442 ret = extract_extradata_init(st);
3447 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3450 pkt_ref = i->extract_extradata.pkt;
3451 ret = av_packet_ref(pkt_ref, pkt);
3455 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3457 av_packet_unref(pkt_ref);
3461 while (ret >= 0 && !i->avctx->extradata) {
3465 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3467 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3472 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3476 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3477 if (!i->avctx->extradata) {
3478 av_packet_unref(pkt_ref);
3479 return AVERROR(ENOMEM);
3481 memcpy(i->avctx->extradata, extradata, extradata_size);
3482 i->avctx->extradata_size = extradata_size;
3484 av_packet_unref(pkt_ref);
3490 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3492 int i, count = 0, ret = 0, j;
3495 AVCodecContext *avctx;
3496 AVPacket pkt1, *pkt;
3497 int64_t old_offset = avio_tell(ic->pb);
3498 // new streams might appear, no options for those
3499 int orig_nb_streams = ic->nb_streams;
3501 int64_t max_analyze_duration = ic->max_analyze_duration;
3502 int64_t max_stream_analyze_duration;
3503 int64_t max_subtitle_analyze_duration;
3504 int64_t probesize = ic->probesize;
3505 int eof_reached = 0;
3506 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3508 flush_codecs = probesize > 0;
3510 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3512 max_stream_analyze_duration = max_analyze_duration;
3513 max_subtitle_analyze_duration = max_analyze_duration;
3514 if (!max_analyze_duration) {
3515 max_stream_analyze_duration =
3516 max_analyze_duration = 5*AV_TIME_BASE;
3517 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3518 if (!strcmp(ic->iformat->name, "flv"))
3519 max_stream_analyze_duration = 90*AV_TIME_BASE;
3520 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3521 max_stream_analyze_duration = 7*AV_TIME_BASE;
3525 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3526 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3528 for (i = 0; i < ic->nb_streams; i++) {
3529 const AVCodec *codec;
3530 AVDictionary *thread_opt = NULL;
3531 st = ic->streams[i];
3532 avctx = st->internal->avctx;
3534 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3535 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3536 /* if (!st->time_base.num)
3538 if (!avctx->time_base.num)
3539 avctx->time_base = st->time_base;
3542 /* check if the caller has overridden the codec id */
3543 #if FF_API_LAVF_AVCTX
3544 FF_DISABLE_DEPRECATION_WARNINGS
3545 if (st->codec->codec_id != st->internal->orig_codec_id) {
3546 st->codecpar->codec_id = st->codec->codec_id;
3547 st->codecpar->codec_type = st->codec->codec_type;
3548 st->internal->orig_codec_id = st->codec->codec_id;
3550 FF_ENABLE_DEPRECATION_WARNINGS
3552 // only for the split stuff
3553 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3554 st->parser = av_parser_init(st->codecpar->codec_id);
3556 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3557 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3558 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3559 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3561 } else if (st->need_parsing) {
3562 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3563 "%s, packets or times may be invalid.\n",
3564 avcodec_get_name(st->codecpar->codec_id));
3568 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3569 st->internal->orig_codec_id = st->codecpar->codec_id;
3571 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3573 goto find_stream_info_err;
3574 if (st->request_probe <= 0)
3575 st->internal->avctx_inited = 1;
3577 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3579 /* Force thread count to 1 since the H.264 decoder will not extract
3580 * SPS and PPS to extradata during multi-threaded decoding. */
3581 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3583 if (ic->codec_whitelist)
3584 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3586 /* Ensure that subtitle_header is properly set. */
3587 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3588 && codec && !avctx->codec) {
3589 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3590 av_log(ic, AV_LOG_WARNING,
3591 "Failed to open codec in %s\n",__FUNCTION__);
3594 // Try to just open decoders, in case this is enough to get parameters.
3595 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3596 if (codec && !avctx->codec)
3597 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3598 av_log(ic, AV_LOG_WARNING,
3599 "Failed to open codec in %s\n",__FUNCTION__);
3602 av_dict_free(&thread_opt);
3605 for (i = 0; i < ic->nb_streams; i++) {
3606 #if FF_API_R_FRAME_RATE
3607 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3609 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3610 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3615 int analyzed_all_streams;
3616 if (ff_check_interrupt(&ic->interrupt_callback)) {
3618 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3622 /* check if one codec still needs to be handled */
3623 for (i = 0; i < ic->nb_streams; i++) {
3624 int fps_analyze_framecount = 20;
3626 st = ic->streams[i];
3627 if (!has_codec_parameters(st, NULL))
3629 /* If the timebase is coarse (like the usual millisecond precision
3630 * of mkv), we need to analyze more frames to reliably arrive at
3631 * the correct fps. */
3632 if (av_q2d(st->time_base) > 0.0005)
3633 fps_analyze_framecount *= 2;
3634 if (!tb_unreliable(st->internal->avctx))
3635 fps_analyze_framecount = 0;
3636 if (ic->fps_probe_size >= 0)
3637 fps_analyze_framecount = ic->fps_probe_size;
3638 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3639 fps_analyze_framecount = 0;
3640 /* variable fps and no guess at the real fps */
3641 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3642 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3643 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3644 st->info->codec_info_duration_fields/2 :
3645 st->info->duration_count;
3646 if (count < fps_analyze_framecount)
3649 if (!st->internal->avctx->extradata &&
3650 (!st->internal->extract_extradata.inited ||
3651 st->internal->extract_extradata.bsf) &&
3652 extract_extradata_check(st))
3654 if (st->first_dts == AV_NOPTS_VALUE &&
3655 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3656 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3657 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3658 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3661 analyzed_all_streams = 0;
3662 if (!missing_streams || !*missing_streams)
3663 if (i == ic->nb_streams) {
3664 analyzed_all_streams = 1;
3665 /* NOTE: If the format has no header, then we need to read some
3666 * packets to get most of the streams, so we cannot stop here. */
3667 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3668 /* If we found the info for all the codecs, we can stop. */
3670 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3675 /* We did not get all the codec info, but we read too much data. */
3676 if (read_size >= probesize) {
3678 av_log(ic, AV_LOG_DEBUG,
3679 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3680 for (i = 0; i < ic->nb_streams; i++)
3681 if (!ic->streams[i]->r_frame_rate.num &&
3682 ic->streams[i]->info->duration_count <= 1 &&
3683 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3684 strcmp(ic->iformat->name, "image2"))
3685 av_log(ic, AV_LOG_WARNING,
3686 "Stream #%d: not enough frames to estimate rate; "
3687 "consider increasing probesize\n", i);
3691 /* NOTE: A new stream can be added there if no header in file
3692 * (AVFMTCTX_NOHEADER). */
3693 ret = read_frame_internal(ic, &pkt1);
3694 if (ret == AVERROR(EAGAIN))
3705 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3706 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3707 &ic->internal->packet_buffer_end, 0);
3709 goto find_stream_info_err;
3712 st = ic->streams[pkt->stream_index];
3713 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3714 read_size += pkt->size;
3716 avctx = st->internal->avctx;
3717 if (!st->internal->avctx_inited) {
3718 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3720 goto find_stream_info_err;
3721 st->internal->avctx_inited = 1;
3724 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3725 /* check for non-increasing dts */
3726 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3727 st->info->fps_last_dts >= pkt->dts) {
3728 av_log(ic, AV_LOG_DEBUG,
3729 "Non-increasing DTS in stream %d: packet %d with DTS "
3730 "%"PRId64", packet %d with DTS %"PRId64"\n",
3731 st->index, st->info->fps_last_dts_idx,
3732 st->info->fps_last_dts, st->codec_info_nb_frames,
3734 st->info->fps_first_dts =
3735 st->info->fps_last_dts = AV_NOPTS_VALUE;
3737 /* Check for a discontinuity in dts. If the difference in dts
3738 * is more than 1000 times the average packet duration in the
3739 * sequence, we treat it as a discontinuity. */
3740 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3741 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3742 (pkt->dts - st->info->fps_last_dts) / 1000 >
3743 (st->info->fps_last_dts - st->info->fps_first_dts) /
3744 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3745 av_log(ic, AV_LOG_WARNING,
3746 "DTS discontinuity in stream %d: packet %d with DTS "
3747 "%"PRId64", packet %d with DTS %"PRId64"\n",
3748 st->index, st->info->fps_last_dts_idx,
3749 st->info->fps_last_dts, st->codec_info_nb_frames,
3751 st->info->fps_first_dts =
3752 st->info->fps_last_dts = AV_NOPTS_VALUE;
3755 /* update stored dts values */
3756 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3757 st->info->fps_first_dts = pkt->dts;
3758 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3760 st->info->fps_last_dts = pkt->dts;
3761 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3763 if (st->codec_info_nb_frames>1) {
3767 if (st->time_base.den > 0)
3768 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3769 if (st->avg_frame_rate.num > 0)
3770 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3773 && st->codec_info_nb_frames>30
3774 && st->info->fps_first_dts != AV_NOPTS_VALUE
3775 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3776 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3778 if (analyzed_all_streams) limit = max_analyze_duration;
3779 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3780 else limit = max_stream_analyze_duration;
3783 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3785 t, pkt->stream_index);
3786 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3787 av_packet_unref(pkt);
3790 if (pkt->duration) {
3791 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3792 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3794 st->info->codec_info_duration += pkt->duration;
3795 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3798 #if FF_API_R_FRAME_RATE
3799 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3800 ff_rfps_add_frame(ic, st, pkt->dts);
3802 if (!st->internal->avctx->extradata) {
3803 ret = extract_extradata(st, pkt);
3805 goto find_stream_info_err;
3808 /* If still no information, we try to open the codec and to
3809 * decompress the frame. We try to avoid that in most cases as
3810 * it takes longer and uses more memory. For MPEG-4, we need to
3811 * decompress for QuickTime.
3813 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3814 * least one frame of codec data, this makes sure the codec initializes
3815 * the channel configuration and does not only trust the values from
3817 try_decode_frame(ic, st, pkt,
3818 (options && i < orig_nb_streams) ? &options[i] : NULL);
3820 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3821 av_packet_unref(pkt);
3823 st->codec_info_nb_frames++;
3829 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3830 st = ic->streams[stream_index];
3831 avctx = st->internal->avctx;
3832 if (!has_codec_parameters(st, NULL)) {
3833 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3834 if (codec && !avctx->codec) {
3835 AVDictionary *opts = NULL;
3836 if (ic->codec_whitelist)
3837 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3838 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3839 av_log(ic, AV_LOG_WARNING,
3840 "Failed to open codec in %s\n",__FUNCTION__);
3841 av_dict_free(&opts);
3845 // EOF already reached while reading the stream above.
3846 // So continue with reoordering DTS with whatever delay we have.
3847 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3848 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3854 AVPacket empty_pkt = { 0 };
3856 av_init_packet(&empty_pkt);
3858 for (i = 0; i < ic->nb_streams; i++) {
3860 st = ic->streams[i];
3862 /* flush the decoders */
3863 if (st->info->found_decoder == 1) {
3865 err = try_decode_frame(ic, st, &empty_pkt,
3866 (options && i < orig_nb_streams)
3867 ? &options[i] : NULL);
3868 } while (err > 0 && !has_codec_parameters(st, NULL));
3871 av_log(ic, AV_LOG_INFO,
3872 "decoding for stream %d failed\n", st->index);
3878 // close codecs which were opened in try_decode_frame()
3879 for (i = 0; i < ic->nb_streams; i++) {
3880 st = ic->streams[i];
3881 avcodec_close(st->internal->avctx);
3884 ff_rfps_calculate(ic);
3886 for (i = 0; i < ic->nb_streams; i++) {
3887 st = ic->streams[i];
3888 avctx = st->internal->avctx;
3889 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3890 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3891 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3892 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3893 avctx->codec_tag= tag;
3896 /* estimate average framerate if not set by demuxer */
3897 if (st->info->codec_info_duration_fields &&
3898 !st->avg_frame_rate.num &&
3899 st->info->codec_info_duration) {
3901 double best_error = 0.01;
3902 AVRational codec_frame_rate = avctx->framerate;
3904 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3905 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3906 st->info->codec_info_duration < 0)
3908 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3909 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3910 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3912 /* Round guessed framerate to a "standard" framerate if it's
3913 * within 1% of the original estimate. */
3914 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3915 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3916 double error = fabs(av_q2d(st->avg_frame_rate) /
3917 av_q2d(std_fps) - 1);
3919 if (error < best_error) {
3921 best_fps = std_fps.num;
3924 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3925 error = fabs(av_q2d(codec_frame_rate) /
3926 av_q2d(std_fps) - 1);
3927 if (error < best_error) {
3929 best_fps = std_fps.num;
3934 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3935 best_fps, 12 * 1001, INT_MAX);
3938 if (!st->r_frame_rate.num) {
3939 if ( avctx->time_base.den * (int64_t) st->time_base.num
3940 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3941 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3942 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3944 st->r_frame_rate.num = st->time_base.den;
3945 st->r_frame_rate.den = st->time_base.num;
3948 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3949 AVRational hw_ratio = { avctx->height, avctx->width };
3950 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3953 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3954 if (!avctx->bits_per_coded_sample)
3955 avctx->bits_per_coded_sample =
3956 av_get_bits_per_sample(avctx->codec_id);
3957 // set stream disposition based on audio service type
3958 switch (avctx->audio_service_type) {
3959 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3960 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3962 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3963 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3965 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3966 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3968 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3969 st->disposition = AV_DISPOSITION_COMMENT;
3971 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3972 st->disposition = AV_DISPOSITION_KARAOKE;
3979 estimate_timings(ic, old_offset);
3981 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3983 if (ret >= 0 && ic->nb_streams)
3984 /* We could not have all the codec parameters before EOF. */
3986 for (i = 0; i < ic->nb_streams; i++) {
3988 st = ic->streams[i];
3990 /* if no packet was ever seen, update context now for has_codec_parameters */
3991 if (!st->internal->avctx_inited) {
3992 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3993 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3994 st->codecpar->format = st->internal->avctx->sample_fmt;
3995 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3997 goto find_stream_info_err;
3999 if (!has_codec_parameters(st, &errmsg)) {
4001 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4002 av_log(ic, AV_LOG_WARNING,
4003 "Could not find codec parameters for stream %d (%s): %s\n"
4004 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4011 compute_chapters_end(ic);
4013 /* update the stream parameters from the internal codec contexts */
4014 for (i = 0; i < ic->nb_streams; i++) {
4015 st = ic->streams[i];
4017 if (st->internal->avctx_inited) {
4018 int orig_w = st->codecpar->width;
4019 int orig_h = st->codecpar->height;
4020 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4022 goto find_stream_info_err;
4023 // The decoder might reduce the video size by the lowres factor.
4024 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
4025 st->codecpar->width = orig_w;
4026 st->codecpar->height = orig_h;
4030 #if FF_API_LAVF_AVCTX
4031 FF_DISABLE_DEPRECATION_WARNINGS
4032 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4034 goto find_stream_info_err;
4036 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4037 // by the lowres factor.
4038 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
4039 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
4040 st->codec->width = st->internal->avctx->width;
4041 st->codec->height = st->internal->avctx->height;
4044 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4045 st->codec->time_base = st->internal->avctx->time_base;
4046 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4048 st->codec->framerate = st->avg_frame_rate;
4050 if (st->internal->avctx->subtitle_header) {
4051 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4052 if (!st->codec->subtitle_header)
4053 goto find_stream_info_err;
4054 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4055 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4056 st->codec->subtitle_header_size);
4059 // Fields unavailable in AVCodecParameters
4060 st->codec->coded_width = st->internal->avctx->coded_width;
4061 st->codec->coded_height = st->internal->avctx->coded_height;
4062 st->codec->properties = st->internal->avctx->properties;
4063 FF_ENABLE_DEPRECATION_WARNINGS
4066 st->internal->avctx_inited = 0;
4069 find_stream_info_err:
4070 for (i = 0; i < ic->nb_streams; i++) {
4071 st = ic->streams[i];
4073 av_freep(&st->info->duration_error);
4074 av_freep(&ic->streams[i]->info);
4075 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4076 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4079 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4080 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4084 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4088 for (i = 0; i < ic->nb_programs; i++) {
4089 if (ic->programs[i] == last) {
4093 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4094 if (ic->programs[i]->stream_index[j] == s)
4095 return ic->programs[i];
4101 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4102 int wanted_stream_nb, int related_stream,
4103 AVCodec **decoder_ret, int flags)
4105 int i, nb_streams = ic->nb_streams;
4106 int ret = AVERROR_STREAM_NOT_FOUND;
4107 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4108 int count, multiframe, disposition;
4109 int64_t best_bitrate = -1;
4111 unsigned *program = NULL;
4112 const AVCodec *decoder = NULL, *best_decoder = NULL;
4114 if (related_stream >= 0 && wanted_stream_nb < 0) {
4115 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4117 program = p->stream_index;
4118 nb_streams = p->nb_stream_indexes;
4121 for (i = 0; i < nb_streams; i++) {
4122 int real_stream_index = program ? program[i] : i;
4123 AVStream *st = ic->streams[real_stream_index];
4124 AVCodecParameters *par = st->codecpar;
4125 if (par->codec_type != type)
4127 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4129 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4132 decoder = find_decoder(ic, st, par->codec_id);
4135 ret = AVERROR_DECODER_NOT_FOUND;
4139 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4140 count = st->codec_info_nb_frames;
4141 bitrate = par->bit_rate;
4142 multiframe = FFMIN(5, count);
4143 if ((best_disposition > disposition) ||
4144 (best_disposition == disposition && best_multiframe > multiframe) ||
4145 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4146 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4148 best_disposition = disposition;
4150 best_bitrate = bitrate;
4151 best_multiframe = multiframe;
4152 ret = real_stream_index;
4153 best_decoder = decoder;
4154 if (program && i == nb_streams - 1 && ret < 0) {
4156 nb_streams = ic->nb_streams;
4157 /* no related stream found, try again with everything */
4162 *decoder_ret = (AVCodec*)best_decoder;
4166 /*******************************************************/
4168 int av_read_play(AVFormatContext *s)
4170 if (s->iformat->read_play)
4171 return s->iformat->read_play(s);
4173 return avio_pause(s->pb, 0);
4174 return AVERROR(ENOSYS);
4177 int av_read_pause(AVFormatContext *s)
4179 if (s->iformat->read_pause)
4180 return s->iformat->read_pause(s);
4182 return avio_pause(s->pb, 1);
4183 return AVERROR(ENOSYS);
4186 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4191 dst->time_base = src->time_base;
4192 dst->nb_frames = src->nb_frames;
4193 dst->disposition = src->disposition;
4194 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4195 dst->avg_frame_rate = src->avg_frame_rate;
4196 dst->r_frame_rate = src->r_frame_rate;
4198 av_dict_free(&dst->metadata);
4199 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4203 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4207 /* Free existing side data*/
4208 for (i = 0; i < dst->nb_side_data; i++)
4209 av_free(dst->side_data[i].data);
4210 av_freep(&dst->side_data);
4211 dst->nb_side_data = 0;
4213 /* Copy side data if present */
4214 if (src->nb_side_data) {
4215 dst->side_data = av_mallocz_array(src->nb_side_data,
4216 sizeof(AVPacketSideData));
4217 if (!dst->side_data)
4218 return AVERROR(ENOMEM);
4219 dst->nb_side_data = src->nb_side_data;
4221 for (i = 0; i < src->nb_side_data; i++) {
4222 uint8_t *data = av_memdup(src->side_data[i].data,
4223 src->side_data[i].size);
4225 return AVERROR(ENOMEM);
4226 dst->side_data[i].type = src->side_data[i].type;
4227 dst->side_data[i].size = src->side_data[i].size;
4228 dst->side_data[i].data = data;
4232 av_freep(&dst->recommended_encoder_configuration);
4233 if (src->recommended_encoder_configuration) {
4234 const char *conf_str = src->recommended_encoder_configuration;
4235 dst->recommended_encoder_configuration = av_strdup(conf_str);
4236 if (!dst->recommended_encoder_configuration)
4237 return AVERROR(ENOMEM);
4243 static void free_stream(AVStream **pst)
4245 AVStream *st = *pst;
4251 for (i = 0; i < st->nb_side_data; i++)
4252 av_freep(&st->side_data[i].data);
4253 av_freep(&st->side_data);
4256 av_parser_close(st->parser);
4258 if (st->attached_pic.data)
4259 av_packet_unref(&st->attached_pic);
4262 avcodec_free_context(&st->internal->avctx);
4263 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4264 av_bsf_free(&st->internal->bsfcs[i]);
4265 av_freep(&st->internal->bsfcs);
4267 av_bsf_free(&st->internal->extract_extradata.bsf);
4268 av_packet_free(&st->internal->extract_extradata.pkt);
4270 av_freep(&st->internal);
4272 av_dict_free(&st->metadata);
4273 avcodec_parameters_free(&st->codecpar);
4274 av_freep(&st->probe_data.buf);
4275 av_freep(&st->index_entries);
4276 #if FF_API_LAVF_AVCTX
4277 FF_DISABLE_DEPRECATION_WARNINGS
4278 avcodec_free_context(&st->codec);
4279 FF_ENABLE_DEPRECATION_WARNINGS
4281 av_freep(&st->priv_data);
4283 av_freep(&st->info->duration_error);
4284 av_freep(&st->info);
4285 av_freep(&st->recommended_encoder_configuration);
4286 av_freep(&st->priv_pts);
4291 void ff_free_stream(AVFormatContext *s, AVStream *st)
4293 av_assert0(s->nb_streams>0);
4294 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4296 free_stream(&s->streams[ --s->nb_streams ]);
4299 void avformat_free_context(AVFormatContext *s)
4307 if (s->iformat && s->iformat->priv_class && s->priv_data)
4308 av_opt_free(s->priv_data);
4309 if (s->oformat && s->oformat->priv_class && s->priv_data)
4310 av_opt_free(s->priv_data);
4312 for (i = s->nb_streams - 1; i >= 0; i--)
4313 ff_free_stream(s, s->streams[i]);
4316 for (i = s->nb_programs - 1; i >= 0; i--) {
4317 av_dict_free(&s->programs[i]->metadata);
4318 av_freep(&s->programs[i]->stream_index);
4319 av_freep(&s->programs[i]);
4321 av_freep(&s->programs);
4322 av_freep(&s->priv_data);
4323 while (s->nb_chapters--) {
4324 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4325 av_freep(&s->chapters[s->nb_chapters]);
4327 av_freep(&s->chapters);
4328 av_dict_free(&s->metadata);
4329 av_dict_free(&s->internal->id3v2_meta);
4330 av_freep(&s->streams);
4331 flush_packet_queue(s);
4332 av_freep(&s->internal);
4336 void avformat_close_input(AVFormatContext **ps)
4347 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4348 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4351 flush_packet_queue(s);
4354 if (s->iformat->read_close)
4355 s->iformat->read_close(s);
4357 avformat_free_context(s);
4364 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4370 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4371 if (s->max_streams < INT_MAX/sizeof(*streams))
4372 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4375 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4378 s->streams = streams;
4380 st = av_mallocz(sizeof(AVStream));
4383 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4387 st->info->last_dts = AV_NOPTS_VALUE;
4389 #if FF_API_LAVF_AVCTX
4390 FF_DISABLE_DEPRECATION_WARNINGS
4391 st->codec = avcodec_alloc_context3(c);
4397 FF_ENABLE_DEPRECATION_WARNINGS
4400 st->internal = av_mallocz(sizeof(*st->internal));
4404 st->codecpar = avcodec_parameters_alloc();
4408 st->internal->avctx = avcodec_alloc_context3(NULL);
4409 if (!st->internal->avctx)
4413 #if FF_API_LAVF_AVCTX
4414 FF_DISABLE_DEPRECATION_WARNINGS
4415 /* no default bitrate if decoding */
4416 st->codec->bit_rate = 0;
4417 FF_ENABLE_DEPRECATION_WARNINGS
4420 /* default pts setting is MPEG-like */
4421 avpriv_set_pts_info(st, 33, 1, 90000);
4422 /* we set the current DTS to 0 so that formats without any timestamps
4423 * but durations get some timestamps, formats with some unknown
4424 * timestamps have their first few packets buffered and the
4425 * timestamps corrected before they are returned to the user */
4426 st->cur_dts = RELATIVE_TS_BASE;
4428 st->cur_dts = AV_NOPTS_VALUE;
4431 st->index = s->nb_streams;
4432 st->start_time = AV_NOPTS_VALUE;
4433 st->duration = AV_NOPTS_VALUE;
4434 st->first_dts = AV_NOPTS_VALUE;
4435 st->probe_packets = MAX_PROBE_PACKETS;
4436 st->pts_wrap_reference = AV_NOPTS_VALUE;
4437 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4439 st->last_IP_pts = AV_NOPTS_VALUE;
4440 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4441 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4442 st->pts_buffer[i] = AV_NOPTS_VALUE;
4444 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4446 #if FF_API_R_FRAME_RATE
4447 st->info->last_dts = AV_NOPTS_VALUE;
4449 st->info->fps_first_dts = AV_NOPTS_VALUE;
4450 st->info->fps_last_dts = AV_NOPTS_VALUE;
4452 st->inject_global_side_data = s->internal->inject_global_side_data;
4454 st->internal->need_context_update = 1;
4456 s->streams[s->nb_streams++] = st;
4463 AVProgram *av_new_program(AVFormatContext *ac, int id)
4465 AVProgram *program = NULL;
4468 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4470 for (i = 0; i < ac->nb_programs; i++)
4471 if (ac->programs[i]->id == id)
4472 program = ac->programs[i];
4475 program = av_mallocz(sizeof(AVProgram));
4478 dynarray_add(&ac->programs, &ac->nb_programs, program);
4479 program->discard = AVDISCARD_NONE;
4482 program->pts_wrap_reference = AV_NOPTS_VALUE;
4483 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4485 program->start_time =
4486 program->end_time = AV_NOPTS_VALUE;
4491 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4492 int64_t start, int64_t end, const char *title)
4494 AVChapter *chapter = NULL;
4497 if (end != AV_NOPTS_VALUE && start > end) {
4498 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4502 for (i = 0; i < s->nb_chapters; i++)
4503 if (s->chapters[i]->id == id)
4504 chapter = s->chapters[i];
4507 chapter = av_mallocz(sizeof(AVChapter));
4510 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4512 av_dict_set(&chapter->metadata, "title", title, 0);
4514 chapter->time_base = time_base;
4515 chapter->start = start;
4521 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4524 AVProgram *program = NULL;
4527 if (idx >= ac->nb_streams) {
4528 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4532 for (i = 0; i < ac->nb_programs; i++) {
4533 if (ac->programs[i]->id != progid)
4535 program = ac->programs[i];
4536 for (j = 0; j < program->nb_stream_indexes; j++)
4537 if (program->stream_index[j] == idx)
4540 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4543 program->stream_index = tmp;
4544 program->stream_index[program->nb_stream_indexes++] = idx;
4549 uint64_t ff_ntp_time(void)
4551 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4554 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4557 char *q, buf1[20], c;
4558 int nd, len, percentd_found;
4570 while (av_isdigit(*p))
4571 nd = nd * 10 + *p++ - '0';
4573 } while (av_isdigit(c));
4579 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4584 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4586 if ((q - buf + len) > buf_size - 1)
4588 memcpy(q, buf1, len);
4596 if ((q - buf) < buf_size - 1)
4600 if (!percentd_found)
4609 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4611 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4614 void av_url_split(char *proto, int proto_size,
4615 char *authorization, int authorization_size,
4616 char *hostname, int hostname_size,
4617 int *port_ptr, char *path, int path_size, const char *url)
4619 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4625 if (authorization_size > 0)
4626 authorization[0] = 0;
4627 if (hostname_size > 0)
4632 /* parse protocol */
4633 if ((p = strchr(url, ':'))) {
4634 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4641 /* no protocol means plain filename */
4642 av_strlcpy(path, url, path_size);
4646 /* separate path from hostname */
4647 ls = strchr(p, '/');
4648 ls2 = strchr(p, '?');
4652 ls = FFMIN(ls, ls2);
4654 av_strlcpy(path, ls, path_size);
4656 ls = &p[strlen(p)]; // XXX
4658 /* the rest is hostname, use that to parse auth/port */
4660 /* authorization (user[:pass]@hostname) */
4662 while ((at = strchr(p, '@')) && at < ls) {
4663 av_strlcpy(authorization, at2,
4664 FFMIN(authorization_size, at + 1 - at2));
4665 p = at + 1; /* skip '@' */
4668 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4670 av_strlcpy(hostname, p + 1,
4671 FFMIN(hostname_size, brk - p));
4672 if (brk[1] == ':' && port_ptr)
4673 *port_ptr = atoi(brk + 2);
4674 } else if ((col = strchr(p, ':')) && col < ls) {
4675 av_strlcpy(hostname, p,
4676 FFMIN(col + 1 - p, hostname_size));
4678 *port_ptr = atoi(col + 1);
4680 av_strlcpy(hostname, p,
4681 FFMIN(ls + 1 - p, hostname_size));
4685 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4688 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4691 'C', 'D', 'E', 'F' };
4692 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4695 'c', 'd', 'e', 'f' };
4696 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4698 for (i = 0; i < s; i++) {
4699 buff[i * 2] = hex_table[src[i] >> 4];
4700 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4706 int ff_hex_to_data(uint8_t *data, const char *p)
4713 p += strspn(p, SPACE_CHARS);
4716 c = av_toupper((unsigned char) *p++);
4717 if (c >= '0' && c <= '9')
4719 else if (c >= 'A' && c <= 'F')
4734 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4735 unsigned int pts_num, unsigned int pts_den)
4738 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4739 if (new_tb.num != pts_num)
4740 av_log(NULL, AV_LOG_DEBUG,
4741 "st:%d removing common factor %d from timebase\n",
4742 s->index, pts_num / new_tb.num);
4744 av_log(NULL, AV_LOG_WARNING,
4745 "st:%d has too large timebase, reducing\n", s->index);
4747 if (new_tb.num <= 0 || new_tb.den <= 0) {
4748 av_log(NULL, AV_LOG_ERROR,
4749 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4750 new_tb.num, new_tb.den,
4754 s->time_base = new_tb;
4755 #if FF_API_LAVF_AVCTX
4756 FF_DISABLE_DEPRECATION_WARNINGS
4757 av_codec_set_pkt_timebase(s->codec, new_tb);
4758 FF_ENABLE_DEPRECATION_WARNINGS
4760 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4761 s->pts_wrap_bits = pts_wrap_bits;
4764 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4767 const char *ptr = str;
4769 /* Parse key=value pairs. */
4772 char *dest = NULL, *dest_end;
4773 int key_len, dest_len = 0;
4775 /* Skip whitespace and potential commas. */
4776 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4783 if (!(ptr = strchr(key, '=')))
4786 key_len = ptr - key;
4788 callback_get_buf(context, key, key_len, &dest, &dest_len);
4789 dest_end = dest + dest_len - 1;
4793 while (*ptr && *ptr != '\"') {
4797 if (dest && dest < dest_end)
4801 if (dest && dest < dest_end)
4809 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4810 if (dest && dest < dest_end)
4818 int ff_find_stream_index(AVFormatContext *s, int id)
4821 for (i = 0; i < s->nb_streams; i++)
4822 if (s->streams[i]->id == id)
4827 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4831 unsigned int codec_tag;
4832 if (ofmt->query_codec)
4833 return ofmt->query_codec(codec_id, std_compliance);
4834 else if (ofmt->codec_tag)
4835 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4836 else if (codec_id == ofmt->video_codec ||
4837 codec_id == ofmt->audio_codec ||
4838 codec_id == ofmt->subtitle_codec ||
4839 codec_id == ofmt->data_codec)
4842 return AVERROR_PATCHWELCOME;
4845 int avformat_network_init(void)
4849 ff_network_inited_globally = 1;
4850 if ((ret = ff_network_init()) < 0)
4852 if ((ret = ff_tls_init()) < 0)
4858 int avformat_network_deinit(void)
4863 ff_network_inited_globally = 0;
4868 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4869 uint64_t channel_layout, int32_t sample_rate,
4870 int32_t width, int32_t height)
4876 return AVERROR(EINVAL);
4879 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4881 if (channel_layout) {
4883 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4887 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4889 if (width || height) {
4891 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4893 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4895 return AVERROR(ENOMEM);
4896 bytestream_put_le32(&data, flags);
4898 bytestream_put_le32(&data, channels);
4900 bytestream_put_le64(&data, channel_layout);
4902 bytestream_put_le32(&data, sample_rate);
4903 if (width || height) {
4904 bytestream_put_le32(&data, width);
4905 bytestream_put_le32(&data, height);
4910 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4912 AVRational undef = {0, 1};
4913 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4914 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4915 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4917 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4918 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4919 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4920 stream_sample_aspect_ratio = undef;
4922 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4923 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4924 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4925 frame_sample_aspect_ratio = undef;
4927 if (stream_sample_aspect_ratio.num)
4928 return stream_sample_aspect_ratio;
4930 return frame_sample_aspect_ratio;
4933 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4935 AVRational fr = st->r_frame_rate;
4936 AVRational codec_fr = st->internal->avctx->framerate;
4937 AVRational avg_fr = st->avg_frame_rate;
4939 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4940 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4945 if (st->internal->avctx->ticks_per_frame > 1) {
4946 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4947 (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
4954 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4957 if (*spec <= '9' && *spec >= '0') /* opt:index */
4958 return strtol(spec, NULL, 0) == st->index;
4959 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4960 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4961 enum AVMediaType type;
4965 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4966 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4967 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4968 case 'd': type = AVMEDIA_TYPE_DATA; break;
4969 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4970 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4971 default: av_assert0(0);
4973 #if FF_API_LAVF_AVCTX
4974 FF_DISABLE_DEPRECATION_WARNINGS
4975 if (type != st->codecpar->codec_type
4976 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4978 FF_ENABLE_DEPRECATION_WARNINGS
4980 if (type != st->codecpar->codec_type)
4983 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4985 if (*spec++ == ':') { /* possibly followed by :index */
4986 int i, index = strtol(spec, NULL, 0);
4987 for (i = 0; i < s->nb_streams; i++) {
4988 #if FF_API_LAVF_AVCTX
4989 FF_DISABLE_DEPRECATION_WARNINGS
4990 if ((s->streams[i]->codecpar->codec_type == type
4991 || s->streams[i]->codec->codec_type == type
4993 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4995 return i == st->index;
4996 FF_ENABLE_DEPRECATION_WARNINGS
4998 if ((s->streams[i]->codecpar->codec_type == type) &&
4999 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5001 return i == st->index;
5007 } else if (*spec == 'p' && *(spec + 1) == ':') {
5011 prog_id = strtol(spec, &endptr, 0);
5012 for (i = 0; i < s->nb_programs; i++) {
5013 if (s->programs[i]->id != prog_id)
5016 if (*endptr++ == ':') {
5017 int stream_idx = strtol(endptr, NULL, 0);
5018 return stream_idx >= 0 &&
5019 stream_idx < s->programs[i]->nb_stream_indexes &&
5020 st->index == s->programs[i]->stream_index[stream_idx];
5023 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5024 if (st->index == s->programs[i]->stream_index[j])
5028 } else if (*spec == '#' ||
5029 (*spec == 'i' && *(spec + 1) == ':')) {
5032 spec += 1 + (*spec == 'i');
5033 stream_id = strtol(spec, &endptr, 0);
5035 return stream_id == st->id;
5036 } else if (*spec == 'm' && *(spec + 1) == ':') {
5037 AVDictionaryEntry *tag;
5042 val = strchr(spec, ':');
5044 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5046 return AVERROR(ENOMEM);
5048 tag = av_dict_get(st->metadata, key, NULL, 0);
5050 if (!val || !strcmp(tag->value, val + 1))
5059 } else if (*spec == 'u') {
5060 AVCodecParameters *par = st->codecpar;
5061 #if FF_API_LAVF_AVCTX
5062 FF_DISABLE_DEPRECATION_WARNINGS
5063 AVCodecContext *codec = st->codec;
5064 FF_ENABLE_DEPRECATION_WARNINGS
5067 switch (par->codec_type) {
5068 case AVMEDIA_TYPE_AUDIO:
5069 val = par->sample_rate && par->channels;
5070 #if FF_API_LAVF_AVCTX
5071 val = val || (codec->sample_rate && codec->channels);
5073 if (par->format == AV_SAMPLE_FMT_NONE
5074 #if FF_API_LAVF_AVCTX
5075 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5080 case AVMEDIA_TYPE_VIDEO:
5081 val = par->width && par->height;
5082 #if FF_API_LAVF_AVCTX
5083 val = val || (codec->width && codec->height);
5085 if (par->format == AV_PIX_FMT_NONE
5086 #if FF_API_LAVF_AVCTX
5087 && codec->pix_fmt == AV_PIX_FMT_NONE
5092 case AVMEDIA_TYPE_UNKNOWN:
5099 #if FF_API_LAVF_AVCTX
5100 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5102 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5104 } else if (!*spec) /* empty specifier, matches everything */
5107 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5108 return AVERROR(EINVAL);
5111 int ff_generate_avci_extradata(AVStream *st)
5113 static const uint8_t avci100_1080p_extradata[] = {
5115 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5116 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5117 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5118 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5119 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5120 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5121 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5122 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5123 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5125 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5128 static const uint8_t avci100_1080i_extradata[] = {
5130 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5131 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5132 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5133 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5134 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5135 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5136 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5137 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5138 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5139 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5140 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5142 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5145 static const uint8_t avci50_1080p_extradata[] = {
5147 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5148 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5149 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5150 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5151 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5152 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5153 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5154 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5155 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5157 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5160 static const uint8_t avci50_1080i_extradata[] = {
5162 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5163 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5164 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5165 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5166 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5167 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5168 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5169 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5170 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5171 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5172 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5174 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5177 static const uint8_t avci100_720p_extradata[] = {
5179 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5180 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5181 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5182 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5183 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5184 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5185 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5186 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5187 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5188 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5190 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5193 static const uint8_t avci50_720p_extradata[] = {
5195 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5196 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5197 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5198 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5199 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5200 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5201 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5202 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5203 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5205 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5209 const uint8_t *data = NULL;
5212 if (st->codecpar->width == 1920) {
5213 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5214 data = avci100_1080p_extradata;
5215 size = sizeof(avci100_1080p_extradata);
5217 data = avci100_1080i_extradata;
5218 size = sizeof(avci100_1080i_extradata);
5220 } else if (st->codecpar->width == 1440) {
5221 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5222 data = avci50_1080p_extradata;
5223 size = sizeof(avci50_1080p_extradata);
5225 data = avci50_1080i_extradata;
5226 size = sizeof(avci50_1080i_extradata);
5228 } else if (st->codecpar->width == 1280) {
5229 data = avci100_720p_extradata;
5230 size = sizeof(avci100_720p_extradata);
5231 } else if (st->codecpar->width == 960) {
5232 data = avci50_720p_extradata;
5233 size = sizeof(avci50_720p_extradata);
5239 av_freep(&st->codecpar->extradata);
5240 if (ff_alloc_extradata(st->codecpar, size))
5241 return AVERROR(ENOMEM);
5242 memcpy(st->codecpar->extradata, data, size);
5247 uint8_t *av_stream_get_side_data(const AVStream *st,
5248 enum AVPacketSideDataType type, int *size)
5252 for (i = 0; i < st->nb_side_data; i++) {
5253 if (st->side_data[i].type == type) {
5255 *size = st->side_data[i].size;
5256 return st->side_data[i].data;
5262 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5263 uint8_t *data, size_t size)
5265 AVPacketSideData *sd, *tmp;
5268 for (i = 0; i < st->nb_side_data; i++) {
5269 sd = &st->side_data[i];
5271 if (sd->type == type) {
5272 av_freep(&sd->data);
5279 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5280 return AVERROR(ERANGE);
5282 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5284 return AVERROR(ENOMEM);
5287 st->side_data = tmp;
5290 sd = &st->side_data[st->nb_side_data - 1];
5298 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5302 uint8_t *data = av_malloc(size);
5307 ret = av_stream_add_side_data(st, type, data, size);
5316 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5319 const AVBitStreamFilter *bsf;
5321 AVCodecParameters *in_par;
5323 if (!(bsf = av_bsf_get_by_name(name))) {
5324 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5325 return AVERROR_BSF_NOT_FOUND;
5328 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5331 if (st->internal->nb_bsfcs) {
5332 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5333 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5335 in_par = st->codecpar;
5336 bsfc->time_base_in = st->time_base;
5339 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5344 if (args && bsfc->filter->priv_class) {
5345 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5346 const char * shorthand[2] = {NULL};
5349 shorthand[0] = opt->name;
5351 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5357 if ((ret = av_bsf_init(bsfc)) < 0) {
5362 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5367 av_log(NULL, AV_LOG_VERBOSE,
5368 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5369 name, args ? args : "");
5374 FF_DISABLE_DEPRECATION_WARNINGS
5375 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5376 AVBitStreamFilterContext *bsfc)
5380 AVPacket new_pkt = *pkt;
5381 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5382 &new_pkt.data, &new_pkt.size,
5383 pkt->data, pkt->size,
5384 pkt->flags & AV_PKT_FLAG_KEY);
5385 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5386 av_packet_unref(pkt);
5387 memset(pkt, 0, sizeof(*pkt));
5390 if(a == 0 && new_pkt.data != pkt->data) {
5391 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5393 memcpy(t, new_pkt.data, new_pkt.size);
5394 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5399 a = AVERROR(ENOMEM);
5403 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5404 av_buffer_default_free, NULL, 0);
5406 pkt->side_data = NULL;
5407 pkt->side_data_elems = 0;
5408 av_packet_unref(pkt);
5410 av_freep(&new_pkt.data);
5411 a = AVERROR(ENOMEM);
5415 av_log(codec, AV_LOG_ERROR,
5416 "Failed to open bitstream filter %s for stream %d with codec %s",
5417 bsfc->filter->name, pkt->stream_index,
5418 codec->codec ? codec->codec->name : "copy");
5428 FF_ENABLE_DEPRECATION_WARNINGS
5431 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5434 return AVERROR(EINVAL);
5436 if (!(s->oformat->flags & AVFMT_NOFILE))
5437 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5441 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5444 s->io_close(s, *pb);
5448 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5450 AVDictionaryEntry *entry;
5451 int64_t parsed_timestamp;
5453 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5454 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5455 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5458 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5465 int ff_standardize_creation_time(AVFormatContext *s)
5468 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5470 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5474 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5479 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5481 if (size != AVPALETTE_SIZE) {
5482 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5483 return AVERROR_INVALIDDATA;
5485 memcpy(palette, side_data, AVPALETTE_SIZE);
5489 if (ret == CONTAINS_PAL) {
5491 for (i = 0; i < AVPALETTE_COUNT; i++)
5492 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5499 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5504 ret = av_bprint_finalize(buf, &str);
5507 if (!av_bprint_is_complete(buf)) {
5509 return AVERROR(ENOMEM);
5512 par->extradata = str;
5513 /* Note: the string is NUL terminated (so extradata can be read as a
5514 * string), but the ending character is not accounted in the size (in
5515 * binary formats you are likely not supposed to mux that character). When
5516 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5518 par->extradata_size = buf->len;
5522 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5523 AVStream *ost, const AVStream *ist,
5524 enum AVTimebaseSource copy_tb)
5526 //TODO: use [io]st->internal->avctx
5527 const AVCodecContext *dec_ctx = ist->codec;
5528 AVCodecContext *enc_ctx = ost->codec;
5530 enc_ctx->time_base = ist->time_base;
5532 * Avi is a special case here because it supports variable fps but
5533 * having the fps and timebase differe significantly adds quite some
5536 if (!strcmp(ofmt->name, "avi")) {
5537 #if FF_API_R_FRAME_RATE
5538 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5539 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5540 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5541 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5542 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5543 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5544 enc_ctx->time_base.num = ist->r_frame_rate.den;
5545 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5546 enc_ctx->ticks_per_frame = 2;
5549 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5550 && av_q2d(ist->time_base) < 1.0/500
5551 || copy_tb == AVFMT_TBCF_DECODER) {
5552 enc_ctx->time_base = dec_ctx->time_base;
5553 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5554 enc_ctx->time_base.den *= 2;
5555 enc_ctx->ticks_per_frame = 2;
5557 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5558 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5559 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5560 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5561 && av_q2d(ist->time_base) < 1.0/500
5562 || copy_tb == AVFMT_TBCF_DECODER) {
5563 enc_ctx->time_base = dec_ctx->time_base;
5564 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5568 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5569 && dec_ctx->time_base.num < dec_ctx->time_base.den
5570 && dec_ctx->time_base.num > 0
5571 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5572 enc_ctx->time_base = dec_ctx->time_base;
5575 if (ost->avg_frame_rate.num)
5576 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5578 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5579 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5584 AVRational av_stream_get_codec_timebase(const AVStream *st)
5586 // See avformat_transfer_internal_stream_timing_info() TODO.
5587 #if FF_API_LAVF_AVCTX
5588 FF_DISABLE_DEPRECATION_WARNINGS
5589 return st->codec->time_base;
5590 FF_ENABLE_DEPRECATION_WARNINGS
5592 return st->internal->avctx->time_base;