2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/time.h"
36 #include "libavutil/time_internal.h"
37 #include "libavutil/timestamp.h"
39 #include "libavcodec/bytestream.h"
40 #include "libavcodec/internal.h"
41 #include "libavcodec/raw.h"
43 #include "audiointerleave.h"
45 #include "avio_internal.h"
55 #include "libavutil/ffversion.h"
56 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
60 * various utility functions for use within FFmpeg
63 unsigned avformat_version(void)
65 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
66 return LIBAVFORMAT_VERSION_INT;
69 const char *avformat_configuration(void)
71 return FFMPEG_CONFIGURATION;
74 const char *avformat_license(void)
76 #define LICENSE_PREFIX "libavformat license: "
77 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
80 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
82 static int is_relative(int64_t ts) {
83 return ts > (RELATIVE_TS_BASE - (1LL<<48));
87 * Wrap a given time stamp, if there is an indication for an overflow
90 * @param timestamp the time stamp to wrap
91 * @return resulting time stamp
93 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
95 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
96 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
97 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
98 timestamp < st->pts_wrap_reference)
99 return timestamp + (1ULL << st->pts_wrap_bits);
100 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
101 timestamp >= st->pts_wrap_reference)
102 return timestamp - (1ULL << st->pts_wrap_bits);
107 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
108 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
113 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
114 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
115 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
116 #if FF_API_OLD_OPEN_CALLBACKS
117 FF_DISABLE_DEPRECATION_WARNINGS
118 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
119 FF_ENABLE_DEPRECATION_WARNINGS
122 int64_t av_stream_get_end_pts(const AVStream *st)
125 return st->priv_pts->val;
127 return AV_NOPTS_VALUE;
130 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
135 void av_format_inject_global_side_data(AVFormatContext *s)
138 s->internal->inject_global_side_data = 1;
139 for (i = 0; i < s->nb_streams; i++) {
140 AVStream *st = s->streams[i];
141 st->inject_global_side_data = 1;
145 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
147 av_assert0(!dst->codec_whitelist &&
148 !dst->format_whitelist &&
149 !dst->protocol_whitelist &&
150 !dst->protocol_blacklist);
151 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
152 dst->format_whitelist = av_strdup(src->format_whitelist);
153 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
154 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
155 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
156 || (src-> format_whitelist && !dst-> format_whitelist)
157 || (src->protocol_whitelist && !dst->protocol_whitelist)
158 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
159 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
160 return AVERROR(ENOMEM);
165 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
167 #if FF_API_LAVF_AVCTX
168 FF_DISABLE_DEPRECATION_WARNINGS
169 if (st->codec->codec)
170 return st->codec->codec;
171 FF_ENABLE_DEPRECATION_WARNINGS
174 switch (st->codecpar->codec_type) {
175 case AVMEDIA_TYPE_VIDEO:
176 if (s->video_codec) return s->video_codec;
178 case AVMEDIA_TYPE_AUDIO:
179 if (s->audio_codec) return s->audio_codec;
181 case AVMEDIA_TYPE_SUBTITLE:
182 if (s->subtitle_codec) return s->subtitle_codec;
186 return avcodec_find_decoder(codec_id);
189 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
191 const AVCodec *codec;
193 #if CONFIG_H264_DECODER
194 /* Other parts of the code assume this decoder to be used for h264,
195 * so force it if possible. */
196 if (codec_id == AV_CODEC_ID_H264)
197 return avcodec_find_decoder_by_name("h264");
200 codec = find_decoder(s, st, codec_id);
204 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
205 const AVCodec *probe_codec = NULL;
206 while (probe_codec = av_codec_next(probe_codec)) {
207 if (probe_codec->id == codec_id &&
208 av_codec_is_decoder(probe_codec) &&
209 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
218 int av_format_get_probe_score(const AVFormatContext *s)
220 return s->probe_score;
223 /* an arbitrarily chosen "sane" max packet size -- 50M */
224 #define SANE_CHUNK_SIZE (50000000)
226 int ffio_limit(AVIOContext *s, int size)
228 if (s->maxsize>= 0) {
229 int64_t remaining= s->maxsize - avio_tell(s);
230 if (remaining < size) {
231 int64_t newsize = avio_size(s);
232 if (!s->maxsize || s->maxsize<newsize)
233 s->maxsize = newsize - !newsize;
234 remaining= s->maxsize - avio_tell(s);
235 remaining= FFMAX(remaining, 0);
238 if (s->maxsize>= 0 && remaining+1 < size) {
239 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
246 /* Read the data in sane-sized chunks and append to pkt.
247 * Return the number of bytes read or an error. */
248 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
250 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
251 int orig_size = pkt->size;
255 int prev_size = pkt->size;
258 /* When the caller requests a lot of data, limit it to the amount
259 * left in file or SANE_CHUNK_SIZE when it is not known. */
261 if (read_size > SANE_CHUNK_SIZE/10) {
262 read_size = ffio_limit(s, read_size);
263 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
265 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
268 ret = av_grow_packet(pkt, read_size);
272 ret = avio_read(s, pkt->data + prev_size, read_size);
273 if (ret != read_size) {
274 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
281 pkt->flags |= AV_PKT_FLAG_CORRUPT;
285 av_packet_unref(pkt);
286 return pkt->size > orig_size ? pkt->size - orig_size : ret;
289 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
294 pkt->pos = avio_tell(s);
296 return append_packet_chunked(s, pkt, size);
299 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
302 return av_get_packet(s, pkt, size);
303 return append_packet_chunked(s, pkt, size);
306 int av_filename_number_test(const char *filename)
310 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
313 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
316 static const struct {
319 enum AVMediaType type;
321 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
322 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
323 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
324 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
325 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
326 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
327 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
328 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
329 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
330 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
331 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
332 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
333 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
334 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
338 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
342 av_log(s, AV_LOG_DEBUG,
343 "Probe with size=%d, packets=%d detected %s with score=%d\n",
344 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
346 for (i = 0; fmt_id_type[i].name; i++) {
347 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
348 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
349 st->codecpar->sample_rate)
351 if (st->request_probe > score &&
352 st->codecpar->codec_id != fmt_id_type[i].id)
354 st->codecpar->codec_id = fmt_id_type[i].id;
355 st->codecpar->codec_type = fmt_id_type[i].type;
356 st->internal->need_context_update = 1;
357 #if FF_API_LAVF_AVCTX
358 FF_DISABLE_DEPRECATION_WARNINGS
359 st->codec->codec_type = st->codecpar->codec_type;
360 st->codec->codec_id = st->codecpar->codec_id;
361 FF_ENABLE_DEPRECATION_WARNINGS
370 /************************************************************/
371 /* input media file */
373 int av_demuxer_open(AVFormatContext *ic) {
376 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
377 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
378 return AVERROR(EINVAL);
381 if (ic->iformat->read_header) {
382 err = ic->iformat->read_header(ic);
387 if (ic->pb && !ic->internal->data_offset)
388 ic->internal->data_offset = avio_tell(ic->pb);
393 /* Open input file and probe the format if necessary. */
394 static int init_input(AVFormatContext *s, const char *filename,
395 AVDictionary **options)
398 AVProbeData pd = { filename, NULL, 0 };
399 int score = AVPROBE_SCORE_RETRY;
402 s->flags |= AVFMT_FLAG_CUSTOM_IO;
404 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
405 s, 0, s->format_probesize);
406 else if (s->iformat->flags & AVFMT_NOFILE)
407 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
408 "will be ignored with AVFMT_NOFILE format.\n");
412 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
413 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
416 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
421 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
422 s, 0, s->format_probesize);
425 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
426 AVPacketList **plast_pktl, int ref)
428 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
432 return AVERROR(ENOMEM);
435 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
444 (*plast_pktl)->next = pktl;
446 *packet_buffer = pktl;
448 /* Add the packet in the buffered packet list. */
453 int avformat_queue_attached_pictures(AVFormatContext *s)
456 for (i = 0; i < s->nb_streams; i++)
457 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
458 s->streams[i]->discard < AVDISCARD_ALL) {
459 if (s->streams[i]->attached_pic.size <= 0) {
460 av_log(s, AV_LOG_WARNING,
461 "Attached picture on stream %d has invalid size, "
466 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
467 &s->streams[i]->attached_pic,
468 &s->internal->raw_packet_buffer_end, 1);
475 static int update_stream_avctx(AVFormatContext *s)
478 for (i = 0; i < s->nb_streams; i++) {
479 AVStream *st = s->streams[i];
481 if (!st->internal->need_context_update)
484 /* close parser, because it depends on the codec */
485 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
486 av_parser_close(st->parser);
490 /* update internal codec context, for the parser */
491 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
495 #if FF_API_LAVF_AVCTX
496 FF_DISABLE_DEPRECATION_WARNINGS
497 /* update deprecated public codec context */
498 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
501 FF_ENABLE_DEPRECATION_WARNINGS
504 st->internal->need_context_update = 0;
510 int avformat_open_input(AVFormatContext **ps, const char *filename,
511 AVInputFormat *fmt, AVDictionary **options)
513 AVFormatContext *s = *ps;
515 AVDictionary *tmp = NULL;
516 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
518 if (!s && !(s = avformat_alloc_context()))
519 return AVERROR(ENOMEM);
521 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
522 return AVERROR(EINVAL);
528 av_dict_copy(&tmp, *options, 0);
530 if (s->pb) // must be before any goto fail
531 s->flags |= AVFMT_FLAG_CUSTOM_IO;
533 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
536 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
537 if ((ret = init_input(s, filename, &tmp)) < 0)
539 s->probe_score = ret;
541 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
542 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
543 if (!s->protocol_whitelist) {
544 ret = AVERROR(ENOMEM);
549 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
550 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
551 if (!s->protocol_blacklist) {
552 ret = AVERROR(ENOMEM);
557 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
558 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
559 ret = AVERROR(EINVAL);
563 avio_skip(s->pb, s->skip_initial_bytes);
565 /* Check filename in case an image number is expected. */
566 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
567 if (!av_filename_number_test(filename)) {
568 ret = AVERROR(EINVAL);
573 s->duration = s->start_time = AV_NOPTS_VALUE;
575 /* Allocate private data. */
576 if (s->iformat->priv_data_size > 0) {
577 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
578 ret = AVERROR(ENOMEM);
581 if (s->iformat->priv_class) {
582 *(const AVClass **) s->priv_data = s->iformat->priv_class;
583 av_opt_set_defaults(s->priv_data);
584 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
589 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
591 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
594 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
595 if ((ret = s->iformat->read_header(s)) < 0)
599 s->metadata = s->internal->id3v2_meta;
600 s->internal->id3v2_meta = NULL;
601 } else if (s->internal->id3v2_meta) {
602 int level = AV_LOG_WARNING;
603 if (s->error_recognition & AV_EF_COMPLIANT)
604 level = AV_LOG_ERROR;
605 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
606 av_dict_free(&s->internal->id3v2_meta);
607 if (s->error_recognition & AV_EF_EXPLODE)
608 return AVERROR_INVALIDDATA;
611 if (id3v2_extra_meta) {
612 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
613 !strcmp(s->iformat->name, "tta")) {
614 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
617 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
619 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
621 if ((ret = avformat_queue_attached_pictures(s)) < 0)
624 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
625 s->internal->data_offset = avio_tell(s->pb);
627 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
629 update_stream_avctx(s);
631 for (i = 0; i < s->nb_streams; i++)
632 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
635 av_dict_free(options);
642 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
644 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
646 avformat_free_context(s);
651 /*******************************************************/
653 static void force_codec_ids(AVFormatContext *s, AVStream *st)
655 switch (st->codecpar->codec_type) {
656 case AVMEDIA_TYPE_VIDEO:
657 if (s->video_codec_id)
658 st->codecpar->codec_id = s->video_codec_id;
660 case AVMEDIA_TYPE_AUDIO:
661 if (s->audio_codec_id)
662 st->codecpar->codec_id = s->audio_codec_id;
664 case AVMEDIA_TYPE_SUBTITLE:
665 if (s->subtitle_codec_id)
666 st->codecpar->codec_id = s->subtitle_codec_id;
668 case AVMEDIA_TYPE_DATA:
669 if (s->data_codec_id)
670 st->codecpar->codec_id = s->data_codec_id;
675 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
677 if (st->request_probe>0) {
678 AVProbeData *pd = &st->probe_data;
680 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
684 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
686 av_log(s, AV_LOG_WARNING,
687 "Failed to reallocate probe buffer for stream %d\n",
692 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
693 pd->buf_size += pkt->size;
694 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
697 st->probe_packets = 0;
699 av_log(s, AV_LOG_WARNING,
700 "nothing to probe for stream %d\n", st->index);
704 end= s->internal->raw_packet_buffer_remaining_size <= 0
705 || st->probe_packets<= 0;
707 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
708 int score = set_codec_from_probe_data(s, st, pd);
709 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
713 st->request_probe = -1;
714 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
715 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
717 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
719 force_codec_ids(s, st);
725 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
727 int64_t ref = pkt->dts;
728 int i, pts_wrap_behavior;
729 int64_t pts_wrap_reference;
730 AVProgram *first_program;
732 if (ref == AV_NOPTS_VALUE)
734 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
736 ref &= (1LL << st->pts_wrap_bits)-1;
738 // reference time stamp should be 60 s before first time stamp
739 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
740 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
741 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
742 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
743 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
745 first_program = av_find_program_from_stream(s, NULL, stream_index);
747 if (!first_program) {
748 int default_stream_index = av_find_default_stream_index(s);
749 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
750 for (i = 0; i < s->nb_streams; i++) {
751 if (av_find_program_from_stream(s, NULL, i))
753 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
754 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
758 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
759 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
763 AVProgram *program = first_program;
765 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
766 pts_wrap_reference = program->pts_wrap_reference;
767 pts_wrap_behavior = program->pts_wrap_behavior;
770 program = av_find_program_from_stream(s, program, stream_index);
773 // update every program with differing pts_wrap_reference
774 program = first_program;
776 if (program->pts_wrap_reference != pts_wrap_reference) {
777 for (i = 0; i<program->nb_stream_indexes; i++) {
778 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
779 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
782 program->pts_wrap_reference = pts_wrap_reference;
783 program->pts_wrap_behavior = pts_wrap_behavior;
785 program = av_find_program_from_stream(s, program, stream_index);
791 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
797 AVPacketList *pktl = s->internal->raw_packet_buffer;
801 st = s->streams[pkt->stream_index];
802 if (s->internal->raw_packet_buffer_remaining_size <= 0)
803 if ((err = probe_codec(s, st, NULL)) < 0)
805 if (st->request_probe <= 0) {
806 s->internal->raw_packet_buffer = pktl->next;
807 s->internal->raw_packet_buffer_remaining_size += pkt->size;
816 ret = s->iformat->read_packet(s, pkt);
818 /* Some demuxers return FFERROR_REDO when they consume
819 data and discard it (ignored streams, junk, extradata).
820 We must re-call the demuxer to get the real packet. */
821 if (ret == FFERROR_REDO)
823 if (!pktl || ret == AVERROR(EAGAIN))
825 for (i = 0; i < s->nb_streams; i++) {
827 if (st->probe_packets || st->request_probe > 0)
828 if ((err = probe_codec(s, st, NULL)) < 0)
830 av_assert0(st->request_probe <= 0);
836 AVPacket tmp = { 0 };
837 ret = av_packet_ref(&tmp, pkt);
843 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
844 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
845 av_log(s, AV_LOG_WARNING,
846 "Dropped corrupted packet (stream = %d)\n",
848 av_packet_unref(pkt);
852 if (pkt->stream_index >= (unsigned)s->nb_streams) {
853 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
857 st = s->streams[pkt->stream_index];
859 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
860 // correct first time stamps to negative values
861 if (!is_relative(st->first_dts))
862 st->first_dts = wrap_timestamp(st, st->first_dts);
863 if (!is_relative(st->start_time))
864 st->start_time = wrap_timestamp(st, st->start_time);
865 if (!is_relative(st->cur_dts))
866 st->cur_dts = wrap_timestamp(st, st->cur_dts);
869 pkt->dts = wrap_timestamp(st, pkt->dts);
870 pkt->pts = wrap_timestamp(st, pkt->pts);
872 force_codec_ids(s, st);
874 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
875 if (s->use_wallclock_as_timestamps)
876 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
878 if (!pktl && st->request_probe <= 0)
881 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
882 &s->internal->raw_packet_buffer_end, 0);
885 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
887 if ((err = probe_codec(s, st, pkt)) < 0)
893 /**********************************************************/
895 static int determinable_frame_size(AVCodecContext *avctx)
897 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
898 avctx->codec_id == AV_CODEC_ID_MP1 ||
899 avctx->codec_id == AV_CODEC_ID_MP2 ||
900 avctx->codec_id == AV_CODEC_ID_MP3/* ||
901 avctx->codec_id == AV_CODEC_ID_CELT*/)
907 * Return the frame duration in seconds. Return 0 if not available.
909 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
910 AVCodecParserContext *pc, AVPacket *pkt)
912 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
913 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
914 int frame_size, sample_rate;
916 #if FF_API_LAVF_AVCTX
917 FF_DISABLE_DEPRECATION_WARNINGS
918 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
919 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
920 FF_ENABLE_DEPRECATION_WARNINGS
925 switch (st->codecpar->codec_type) {
926 case AVMEDIA_TYPE_VIDEO:
927 if (st->r_frame_rate.num && !pc && s->iformat) {
928 *pnum = st->r_frame_rate.den;
929 *pden = st->r_frame_rate.num;
930 } else if (st->time_base.num * 1000LL > st->time_base.den) {
931 *pnum = st->time_base.num;
932 *pden = st->time_base.den;
933 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
934 av_assert0(st->internal->avctx->ticks_per_frame);
935 av_reduce(pnum, pden,
937 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
940 if (pc && pc->repeat_pict) {
941 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
942 av_reduce(pnum, pden,
943 (*pnum) * (1LL + pc->repeat_pict),
947 /* If this codec can be interlaced or progressive then we need
948 * a parser to compute duration of a packet. Thus if we have
949 * no parser in such case leave duration undefined. */
950 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
954 case AVMEDIA_TYPE_AUDIO:
955 if (st->internal->avctx_inited) {
956 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
957 sample_rate = st->internal->avctx->sample_rate;
959 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
960 sample_rate = st->codecpar->sample_rate;
962 if (frame_size <= 0 || sample_rate <= 0)
972 static int is_intra_only(enum AVCodecID id)
974 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
977 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
982 static int has_decode_delay_been_guessed(AVStream *st)
984 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
985 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
987 #if CONFIG_H264_DECODER
988 if (st->internal->avctx->has_b_frames &&
989 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
992 if (st->internal->avctx->has_b_frames<3)
993 return st->nb_decoded_frames >= 7;
994 else if (st->internal->avctx->has_b_frames<4)
995 return st->nb_decoded_frames >= 18;
997 return st->nb_decoded_frames >= 20;
1000 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1004 if (pktl == s->internal->packet_buffer_end)
1005 return s->internal->parse_queue;
1009 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1010 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1011 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1014 int delay = st->internal->avctx->has_b_frames;
1017 if (dts == AV_NOPTS_VALUE) {
1018 int64_t best_score = INT64_MAX;
1019 for (i = 0; i<delay; i++) {
1020 if (st->pts_reorder_error_count[i]) {
1021 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1022 if (score < best_score) {
1024 dts = pts_buffer[i];
1029 for (i = 0; i<delay; i++) {
1030 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1031 int64_t diff = FFABS(pts_buffer[i] - dts)
1032 + (uint64_t)st->pts_reorder_error[i];
1033 diff = FFMAX(diff, st->pts_reorder_error[i]);
1034 st->pts_reorder_error[i] = diff;
1035 st->pts_reorder_error_count[i]++;
1036 if (st->pts_reorder_error_count[i] > 250) {
1037 st->pts_reorder_error[i] >>= 1;
1038 st->pts_reorder_error_count[i] >>= 1;
1045 if (dts == AV_NOPTS_VALUE)
1046 dts = pts_buffer[0];
1052 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1053 * of the packets in a window.
1055 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1056 AVPacketList *pkt_buffer)
1058 AVStream *st = s->streams[stream_index];
1059 int delay = st->internal->avctx->has_b_frames;
1062 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1064 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1065 pts_buffer[i] = AV_NOPTS_VALUE;
1067 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1068 if (pkt_buffer->pkt.stream_index != stream_index)
1071 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1072 pts_buffer[0] = pkt_buffer->pkt.pts;
1073 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1074 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1076 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1081 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1082 int64_t dts, int64_t pts, AVPacket *pkt)
1084 AVStream *st = s->streams[stream_index];
1085 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1086 AVPacketList *pktl_it;
1090 if (st->first_dts != AV_NOPTS_VALUE ||
1091 dts == AV_NOPTS_VALUE ||
1092 st->cur_dts == AV_NOPTS_VALUE ||
1096 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1098 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1100 if (is_relative(pts))
1103 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1104 if (pktl_it->pkt.stream_index != stream_index)
1106 if (is_relative(pktl_it->pkt.pts))
1107 pktl_it->pkt.pts += shift;
1109 if (is_relative(pktl_it->pkt.dts))
1110 pktl_it->pkt.dts += shift;
1112 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1113 st->start_time = pktl_it->pkt.pts;
1114 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1115 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1119 if (has_decode_delay_been_guessed(st)) {
1120 update_dts_from_pts(s, stream_index, pktl);
1123 if (st->start_time == AV_NOPTS_VALUE) {
1124 st->start_time = pts;
1125 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1126 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1130 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1131 int stream_index, int duration)
1133 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1134 int64_t cur_dts = RELATIVE_TS_BASE;
1136 if (st->first_dts != AV_NOPTS_VALUE) {
1137 if (st->update_initial_durations_done)
1139 st->update_initial_durations_done = 1;
1140 cur_dts = st->first_dts;
1141 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1142 if (pktl->pkt.stream_index == stream_index) {
1143 if (pktl->pkt.pts != pktl->pkt.dts ||
1144 pktl->pkt.dts != AV_NOPTS_VALUE ||
1147 cur_dts -= duration;
1150 if (pktl && pktl->pkt.dts != st->first_dts) {
1151 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1152 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1156 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1159 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1160 st->first_dts = cur_dts;
1161 } else if (st->cur_dts != RELATIVE_TS_BASE)
1164 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1165 if (pktl->pkt.stream_index != stream_index)
1167 if ((pktl->pkt.pts == pktl->pkt.dts ||
1168 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1169 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1170 pktl->pkt.dts == st->first_dts ||
1171 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1172 !pktl->pkt.duration) {
1173 pktl->pkt.dts = cur_dts;
1174 if (!st->internal->avctx->has_b_frames)
1175 pktl->pkt.pts = cur_dts;
1176 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1177 pktl->pkt.duration = duration;
1180 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1183 st->cur_dts = cur_dts;
1186 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1187 AVCodecParserContext *pc, AVPacket *pkt,
1188 int64_t next_dts, int64_t next_pts)
1190 int num, den, presentation_delayed, delay, i;
1192 AVRational duration;
1193 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1194 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1196 if (s->flags & AVFMT_FLAG_NOFILLIN)
1199 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1200 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1201 if (st->last_dts_for_order_check <= pkt->dts) {
1204 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1205 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1207 st->last_dts_for_order_check);
1208 st->dts_misordered++;
1210 if (st->dts_ordered + st->dts_misordered > 250) {
1211 st->dts_ordered >>= 1;
1212 st->dts_misordered >>= 1;
1216 st->last_dts_for_order_check = pkt->dts;
1217 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1218 pkt->dts = AV_NOPTS_VALUE;
1221 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1222 pkt->dts = AV_NOPTS_VALUE;
1224 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1225 && !st->internal->avctx->has_b_frames)
1226 //FIXME Set low_delay = 0 when has_b_frames = 1
1227 st->internal->avctx->has_b_frames = 1;
1229 /* do we have a video B-frame ? */
1230 delay = st->internal->avctx->has_b_frames;
1231 presentation_delayed = 0;
1233 /* XXX: need has_b_frame, but cannot get it if the codec is
1234 * not initialized */
1236 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1237 presentation_delayed = 1;
1239 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1240 st->pts_wrap_bits < 63 &&
1241 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1242 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1243 pkt->dts -= 1LL << st->pts_wrap_bits;
1245 pkt->pts += 1LL << st->pts_wrap_bits;
1248 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1249 * We take the conservative approach and discard both.
1250 * Note: If this is misbehaving for an H.264 file, then possibly
1251 * presentation_delayed is not set correctly. */
1252 if (delay == 1 && pkt->dts == pkt->pts &&
1253 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1254 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1255 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1256 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1257 pkt->dts = AV_NOPTS_VALUE;
1260 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1261 if (pkt->duration == 0) {
1262 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1264 duration = (AVRational) {num, den};
1265 pkt->duration = av_rescale_rnd(1,
1266 num * (int64_t) st->time_base.den,
1267 den * (int64_t) st->time_base.num,
1272 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1273 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1275 /* Correct timestamps with byte offset if demuxers only have timestamps
1276 * on packet boundaries */
1277 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1278 /* this will estimate bitrate based on this frame's duration and size */
1279 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1280 if (pkt->pts != AV_NOPTS_VALUE)
1282 if (pkt->dts != AV_NOPTS_VALUE)
1286 /* This may be redundant, but it should not hurt. */
1287 if (pkt->dts != AV_NOPTS_VALUE &&
1288 pkt->pts != AV_NOPTS_VALUE &&
1289 pkt->pts > pkt->dts)
1290 presentation_delayed = 1;
1292 if (s->debug & FF_FDEBUG_TS)
1293 av_log(s, AV_LOG_TRACE,
1294 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1295 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1296 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1298 /* Interpolate PTS and DTS if they are not present. We skip H264
1299 * currently because delay and has_b_frames are not reliably set. */
1300 if ((delay == 0 || (delay == 1 && pc)) &&
1302 if (presentation_delayed) {
1303 /* DTS = decompression timestamp */
1304 /* PTS = presentation timestamp */
1305 if (pkt->dts == AV_NOPTS_VALUE)
1306 pkt->dts = st->last_IP_pts;
1307 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1308 if (pkt->dts == AV_NOPTS_VALUE)
1309 pkt->dts = st->cur_dts;
1311 /* This is tricky: the dts must be incremented by the duration
1312 * of the frame we are displaying, i.e. the last I- or P-frame. */
1313 if (st->last_IP_duration == 0)
1314 st->last_IP_duration = pkt->duration;
1315 if (pkt->dts != AV_NOPTS_VALUE)
1316 st->cur_dts = pkt->dts + st->last_IP_duration;
1317 if (pkt->dts != AV_NOPTS_VALUE &&
1318 pkt->pts == AV_NOPTS_VALUE &&
1319 st->last_IP_duration > 0 &&
1320 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1321 next_dts != next_pts &&
1322 next_pts != AV_NOPTS_VALUE)
1323 pkt->pts = next_dts;
1325 st->last_IP_duration = pkt->duration;
1326 st->last_IP_pts = pkt->pts;
1327 /* Cannot compute PTS if not present (we can compute it only
1328 * by knowing the future. */
1329 } else if (pkt->pts != AV_NOPTS_VALUE ||
1330 pkt->dts != AV_NOPTS_VALUE ||
1333 /* presentation is not delayed : PTS and DTS are the same */
1334 if (pkt->pts == AV_NOPTS_VALUE)
1335 pkt->pts = pkt->dts;
1336 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1338 if (pkt->pts == AV_NOPTS_VALUE)
1339 pkt->pts = st->cur_dts;
1340 pkt->dts = pkt->pts;
1341 if (pkt->pts != AV_NOPTS_VALUE)
1342 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1346 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1347 st->pts_buffer[0] = pkt->pts;
1348 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1349 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1351 if(has_decode_delay_been_guessed(st))
1352 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1354 // We skipped it above so we try here.
1356 // This should happen on the first packet
1357 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1358 if (pkt->dts > st->cur_dts)
1359 st->cur_dts = pkt->dts;
1361 if (s->debug & FF_FDEBUG_TS)
1362 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1363 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1366 if (is_intra_only(st->codecpar->codec_id))
1367 pkt->flags |= AV_PKT_FLAG_KEY;
1368 #if FF_API_CONVERGENCE_DURATION
1369 FF_DISABLE_DEPRECATION_WARNINGS
1371 pkt->convergence_duration = pc->convergence_duration;
1372 FF_ENABLE_DEPRECATION_WARNINGS
1376 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1379 AVPacketList *pktl = *pkt_buf;
1380 *pkt_buf = pktl->next;
1381 av_packet_unref(&pktl->pkt);
1384 *pkt_buf_end = NULL;
1388 * Parse a packet, add all split parts to parse_queue.
1390 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1392 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1394 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1395 AVStream *st = s->streams[stream_index];
1396 uint8_t *data = pkt ? pkt->data : NULL;
1397 int size = pkt ? pkt->size : 0;
1398 int ret = 0, got_output = 0;
1401 av_init_packet(&flush_pkt);
1404 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1405 // preserve 0-size sync packets
1406 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1409 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1411 int64_t next_pts = pkt->pts;
1412 int64_t next_dts = pkt->dts;
1414 av_init_packet(&out_pkt);
1415 len = av_parser_parse2(st->parser, st->internal->avctx,
1416 &out_pkt.data, &out_pkt.size, data, size,
1417 pkt->pts, pkt->dts, pkt->pos);
1419 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1421 /* increment read pointer */
1425 got_output = !!out_pkt.size;
1430 if (pkt->side_data) {
1431 out_pkt.side_data = pkt->side_data;
1432 out_pkt.side_data_elems = pkt->side_data_elems;
1433 pkt->side_data = NULL;
1434 pkt->side_data_elems = 0;
1437 /* set the duration */
1438 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1439 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1440 if (st->internal->avctx->sample_rate > 0) {
1442 av_rescale_q_rnd(st->parser->duration,
1443 (AVRational) { 1, st->internal->avctx->sample_rate },
1449 out_pkt.stream_index = st->index;
1450 out_pkt.pts = st->parser->pts;
1451 out_pkt.dts = st->parser->dts;
1452 out_pkt.pos = st->parser->pos;
1454 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1455 out_pkt.pos = st->parser->frame_offset;
1457 if (st->parser->key_frame == 1 ||
1458 (st->parser->key_frame == -1 &&
1459 st->parser->pict_type == AV_PICTURE_TYPE_I))
1460 out_pkt.flags |= AV_PKT_FLAG_KEY;
1462 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1463 out_pkt.flags |= AV_PKT_FLAG_KEY;
1465 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1467 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1468 &s->internal->parse_queue_end, 1);
1469 av_packet_unref(&out_pkt);
1474 /* end of the stream => close and free the parser */
1475 if (pkt == &flush_pkt) {
1476 av_parser_close(st->parser);
1481 av_packet_unref(pkt);
1485 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1486 AVPacketList **pkt_buffer_end,
1490 av_assert0(*pkt_buffer);
1493 *pkt_buffer = pktl->next;
1495 *pkt_buffer_end = NULL;
1500 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1502 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1505 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1507 int ret = 0, i, got_packet = 0;
1508 AVDictionary *metadata = NULL;
1510 av_init_packet(pkt);
1512 while (!got_packet && !s->internal->parse_queue) {
1516 /* read next packet */
1517 ret = ff_read_packet(s, &cur_pkt);
1519 if (ret == AVERROR(EAGAIN))
1521 /* flush the parsers */
1522 for (i = 0; i < s->nb_streams; i++) {
1524 if (st->parser && st->need_parsing)
1525 parse_packet(s, NULL, st->index);
1527 /* all remaining packets are now in parse_queue =>
1528 * really terminate parsing */
1532 st = s->streams[cur_pkt.stream_index];
1534 /* update context if required */
1535 if (st->internal->need_context_update) {
1536 if (avcodec_is_open(st->internal->avctx)) {
1537 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1538 avcodec_close(st->internal->avctx);
1539 st->info->found_decoder = 0;
1542 /* close parser, because it depends on the codec */
1543 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1544 av_parser_close(st->parser);
1548 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1552 #if FF_API_LAVF_AVCTX
1553 FF_DISABLE_DEPRECATION_WARNINGS
1554 /* update deprecated public codec context */
1555 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1558 FF_ENABLE_DEPRECATION_WARNINGS
1561 st->internal->need_context_update = 0;
1564 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1565 cur_pkt.dts != AV_NOPTS_VALUE &&
1566 cur_pkt.pts < cur_pkt.dts) {
1567 av_log(s, AV_LOG_WARNING,
1568 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1569 cur_pkt.stream_index,
1570 av_ts2str(cur_pkt.pts),
1571 av_ts2str(cur_pkt.dts),
1574 if (s->debug & FF_FDEBUG_TS)
1575 av_log(s, AV_LOG_DEBUG,
1576 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1577 cur_pkt.stream_index,
1578 av_ts2str(cur_pkt.pts),
1579 av_ts2str(cur_pkt.dts),
1580 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1582 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1583 st->parser = av_parser_init(st->codecpar->codec_id);
1585 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1586 "%s, packets or times may be invalid.\n",
1587 avcodec_get_name(st->codecpar->codec_id));
1588 /* no parser available: just output the raw packets */
1589 st->need_parsing = AVSTREAM_PARSE_NONE;
1590 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1591 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1592 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1593 st->parser->flags |= PARSER_FLAG_ONCE;
1594 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1595 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1598 if (!st->need_parsing || !st->parser) {
1599 /* no parsing needed: we just output the packet as is */
1601 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1602 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1603 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1604 ff_reduce_index(s, st->index);
1605 av_add_index_entry(st, pkt->pos, pkt->dts,
1606 0, 0, AVINDEX_KEYFRAME);
1609 } else if (st->discard < AVDISCARD_ALL) {
1610 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1612 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1613 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1614 st->codecpar->channels = st->internal->avctx->channels;
1615 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1616 st->codecpar->codec_id = st->internal->avctx->codec_id;
1619 av_packet_unref(&cur_pkt);
1621 if (pkt->flags & AV_PKT_FLAG_KEY)
1622 st->skip_to_keyframe = 0;
1623 if (st->skip_to_keyframe) {
1624 av_packet_unref(&cur_pkt);
1632 if (!got_packet && s->internal->parse_queue)
1633 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1636 AVStream *st = s->streams[pkt->stream_index];
1637 int discard_padding = 0;
1638 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1639 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1640 int64_t sample = ts_to_samples(st, pts);
1641 int duration = ts_to_samples(st, pkt->duration);
1642 int64_t end_sample = sample + duration;
1643 if (duration > 0 && end_sample >= st->first_discard_sample &&
1644 sample < st->last_discard_sample)
1645 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1647 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1648 st->skip_samples = st->start_skip_samples;
1649 if (st->skip_samples || discard_padding) {
1650 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1652 AV_WL32(p, st->skip_samples);
1653 AV_WL32(p + 4, discard_padding);
1654 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1656 st->skip_samples = 0;
1659 if (st->inject_global_side_data) {
1660 for (i = 0; i < st->nb_side_data; i++) {
1661 AVPacketSideData *src_sd = &st->side_data[i];
1664 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1667 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1669 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1673 memcpy(dst_data, src_sd->data, src_sd->size);
1675 st->inject_global_side_data = 0;
1678 #if FF_API_LAVF_MERGE_SD
1679 FF_DISABLE_DEPRECATION_WARNINGS
1680 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1681 av_packet_merge_side_data(pkt);
1682 FF_ENABLE_DEPRECATION_WARNINGS
1686 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1688 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1689 av_dict_copy(&s->metadata, metadata, 0);
1690 av_dict_free(&metadata);
1691 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1694 #if FF_API_LAVF_AVCTX
1695 update_stream_avctx(s);
1698 if (s->debug & FF_FDEBUG_TS)
1699 av_log(s, AV_LOG_DEBUG,
1700 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1701 "size=%d, duration=%"PRId64", flags=%d\n",
1703 av_ts2str(pkt->pts),
1704 av_ts2str(pkt->dts),
1705 pkt->size, pkt->duration, pkt->flags);
1710 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1712 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1718 ret = s->internal->packet_buffer
1719 ? read_from_packet_buffer(&s->internal->packet_buffer,
1720 &s->internal->packet_buffer_end, pkt)
1721 : read_frame_internal(s, pkt);
1728 AVPacketList *pktl = s->internal->packet_buffer;
1731 AVPacket *next_pkt = &pktl->pkt;
1733 if (next_pkt->dts != AV_NOPTS_VALUE) {
1734 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1735 // last dts seen for this stream. if any of packets following
1736 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1737 int64_t last_dts = next_pkt->dts;
1738 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1739 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1740 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1741 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1743 next_pkt->pts = pktl->pkt.dts;
1745 if (last_dts != AV_NOPTS_VALUE) {
1746 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1747 last_dts = pktl->pkt.dts;
1752 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1753 // Fixing the last reference frame had none pts issue (For MXF etc).
1754 // We only do this when
1756 // 2. we are not able to resolve a pts value for current packet.
1757 // 3. the packets for this stream at the end of the files had valid dts.
1758 next_pkt->pts = last_dts + next_pkt->duration;
1760 pktl = s->internal->packet_buffer;
1763 /* read packet from packet buffer, if there is data */
1764 st = s->streams[next_pkt->stream_index];
1765 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1766 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1767 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1768 &s->internal->packet_buffer_end, pkt);
1773 ret = read_frame_internal(s, pkt);
1775 if (pktl && ret != AVERROR(EAGAIN)) {
1782 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1783 &s->internal->packet_buffer_end, 1);
1784 av_packet_unref(pkt);
1791 st = s->streams[pkt->stream_index];
1792 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1793 ff_reduce_index(s, st->index);
1794 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1797 if (is_relative(pkt->dts))
1798 pkt->dts -= RELATIVE_TS_BASE;
1799 if (is_relative(pkt->pts))
1800 pkt->pts -= RELATIVE_TS_BASE;
1805 /* XXX: suppress the packet queue */
1806 static void flush_packet_queue(AVFormatContext *s)
1810 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1811 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1812 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1814 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1817 /*******************************************************/
1820 int av_find_default_stream_index(AVFormatContext *s)
1824 int best_stream = 0;
1825 int best_score = INT_MIN;
1827 if (s->nb_streams <= 0)
1829 for (i = 0; i < s->nb_streams; i++) {
1832 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1833 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1835 if (st->codecpar->width && st->codecpar->height)
1839 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1840 if (st->codecpar->sample_rate)
1843 if (st->codec_info_nb_frames)
1846 if (st->discard != AVDISCARD_ALL)
1849 if (score > best_score) {
1857 /** Flush the frame reader. */
1858 void ff_read_frame_flush(AVFormatContext *s)
1863 flush_packet_queue(s);
1865 /* Reset read state for each stream. */
1866 for (i = 0; i < s->nb_streams; i++) {
1870 av_parser_close(st->parser);
1873 st->last_IP_pts = AV_NOPTS_VALUE;
1874 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1875 if (st->first_dts == AV_NOPTS_VALUE)
1876 st->cur_dts = RELATIVE_TS_BASE;
1878 /* We set the current DTS to an unspecified origin. */
1879 st->cur_dts = AV_NOPTS_VALUE;
1881 st->probe_packets = MAX_PROBE_PACKETS;
1883 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1884 st->pts_buffer[j] = AV_NOPTS_VALUE;
1886 if (s->internal->inject_global_side_data)
1887 st->inject_global_side_data = 1;
1889 st->skip_samples = 0;
1893 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1897 for (i = 0; i < s->nb_streams; i++) {
1898 AVStream *st = s->streams[i];
1901 av_rescale(timestamp,
1902 st->time_base.den * (int64_t) ref_st->time_base.num,
1903 st->time_base.num * (int64_t) ref_st->time_base.den);
1907 void ff_reduce_index(AVFormatContext *s, int stream_index)
1909 AVStream *st = s->streams[stream_index];
1910 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1912 if ((unsigned) st->nb_index_entries >= max_entries) {
1914 for (i = 0; 2 * i < st->nb_index_entries; i++)
1915 st->index_entries[i] = st->index_entries[2 * i];
1916 st->nb_index_entries = i;
1920 int ff_add_index_entry(AVIndexEntry **index_entries,
1921 int *nb_index_entries,
1922 unsigned int *index_entries_allocated_size,
1923 int64_t pos, int64_t timestamp,
1924 int size, int distance, int flags)
1926 AVIndexEntry *entries, *ie;
1929 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1932 if (timestamp == AV_NOPTS_VALUE)
1933 return AVERROR(EINVAL);
1935 if (size < 0 || size > 0x3FFFFFFF)
1936 return AVERROR(EINVAL);
1938 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1939 timestamp -= RELATIVE_TS_BASE;
1941 entries = av_fast_realloc(*index_entries,
1942 index_entries_allocated_size,
1943 (*nb_index_entries + 1) *
1944 sizeof(AVIndexEntry));
1948 *index_entries = entries;
1950 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1951 timestamp, AVSEEK_FLAG_ANY);
1954 index = (*nb_index_entries)++;
1955 ie = &entries[index];
1956 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1958 ie = &entries[index];
1959 if (ie->timestamp != timestamp) {
1960 if (ie->timestamp <= timestamp)
1962 memmove(entries + index + 1, entries + index,
1963 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1964 (*nb_index_entries)++;
1965 } else if (ie->pos == pos && distance < ie->min_distance)
1966 // do not reduce the distance
1967 distance = ie->min_distance;
1971 ie->timestamp = timestamp;
1972 ie->min_distance = distance;
1979 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1980 int size, int distance, int flags)
1982 timestamp = wrap_timestamp(st, timestamp);
1983 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1984 &st->index_entries_allocated_size, pos,
1985 timestamp, size, distance, flags);
1988 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1989 int64_t wanted_timestamp, int flags)
1997 // Optimize appending index entries at the end.
1998 if (b && entries[b - 1].timestamp < wanted_timestamp)
2004 // Search for the next non-discarded packet.
2005 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2007 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2013 timestamp = entries[m].timestamp;
2014 if (timestamp >= wanted_timestamp)
2016 if (timestamp <= wanted_timestamp)
2019 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2021 if (!(flags & AVSEEK_FLAG_ANY))
2022 while (m >= 0 && m < nb_entries &&
2023 !(entries[m].flags & AVINDEX_KEYFRAME))
2024 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2026 if (m == nb_entries)
2031 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2034 int64_t pos_delta = 0;
2036 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2037 const char *proto = avio_find_protocol_name(s->filename);
2040 av_log(s, AV_LOG_INFO,
2041 "Protocol name not provided, cannot determine if input is local or "
2042 "a network protocol, buffers and access patterns cannot be configured "
2043 "optimally without knowing the protocol\n");
2046 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2049 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2050 AVStream *st1 = s->streams[ist1];
2051 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2052 AVStream *st2 = s->streams[ist2];
2058 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2059 AVIndexEntry *e1 = &st1->index_entries[i1];
2060 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2062 skip = FFMAX(skip, e1->size);
2063 for (; i2 < st2->nb_index_entries; i2++) {
2064 AVIndexEntry *e2 = &st2->index_entries[i2];
2065 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2066 if (e2_pts - e1_pts < time_tolerance)
2068 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2076 /* XXX This could be adjusted depending on protocol*/
2077 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2078 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2079 ffio_set_buf_size(s->pb, pos_delta);
2080 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2083 if (skip < (1<<23)) {
2084 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2088 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2090 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2091 wanted_timestamp, flags);
2094 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2095 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2097 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2098 if (stream_index >= 0)
2099 ts = wrap_timestamp(s->streams[stream_index], ts);
2103 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2104 int64_t target_ts, int flags)
2106 AVInputFormat *avif = s->iformat;
2107 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2108 int64_t ts_min, ts_max, ts;
2113 if (stream_index < 0)
2116 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2119 ts_min = AV_NOPTS_VALUE;
2120 pos_limit = -1; // GCC falsely says it may be uninitialized.
2122 st = s->streams[stream_index];
2123 if (st->index_entries) {
2126 /* FIXME: Whole function must be checked for non-keyframe entries in
2127 * index case, especially read_timestamp(). */
2128 index = av_index_search_timestamp(st, target_ts,
2129 flags | AVSEEK_FLAG_BACKWARD);
2130 index = FFMAX(index, 0);
2131 e = &st->index_entries[index];
2133 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2135 ts_min = e->timestamp;
2136 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2137 pos_min, av_ts2str(ts_min));
2139 av_assert1(index == 0);
2142 index = av_index_search_timestamp(st, target_ts,
2143 flags & ~AVSEEK_FLAG_BACKWARD);
2144 av_assert0(index < st->nb_index_entries);
2146 e = &st->index_entries[index];
2147 av_assert1(e->timestamp >= target_ts);
2149 ts_max = e->timestamp;
2150 pos_limit = pos_max - e->min_distance;
2151 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2152 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2156 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2157 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2162 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2165 ff_read_frame_flush(s);
2166 ff_update_cur_dts(s, st, ts);
2171 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2172 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2174 int64_t step = 1024;
2175 int64_t limit, ts_max;
2176 int64_t filesize = avio_size(s->pb);
2177 int64_t pos_max = filesize - 1;
2180 pos_max = FFMAX(0, (pos_max) - step);
2181 ts_max = ff_read_timestamp(s, stream_index,
2182 &pos_max, limit, read_timestamp);
2184 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2185 if (ts_max == AV_NOPTS_VALUE)
2189 int64_t tmp_pos = pos_max + 1;
2190 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2191 &tmp_pos, INT64_MAX, read_timestamp);
2192 if (tmp_ts == AV_NOPTS_VALUE)
2194 av_assert0(tmp_pos > pos_max);
2197 if (tmp_pos >= filesize)
2209 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2210 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2211 int64_t ts_min, int64_t ts_max,
2212 int flags, int64_t *ts_ret,
2213 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2214 int64_t *, int64_t))
2221 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2223 if (ts_min == AV_NOPTS_VALUE) {
2224 pos_min = s->internal->data_offset;
2225 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2226 if (ts_min == AV_NOPTS_VALUE)
2230 if (ts_min >= target_ts) {
2235 if (ts_max == AV_NOPTS_VALUE) {
2236 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2238 pos_limit = pos_max;
2241 if (ts_max <= target_ts) {
2246 av_assert0(ts_min < ts_max);
2249 while (pos_min < pos_limit) {
2250 av_log(s, AV_LOG_TRACE,
2251 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2252 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2253 av_assert0(pos_limit <= pos_max);
2255 if (no_change == 0) {
2256 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2257 // interpolate position (better than dichotomy)
2258 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2260 pos_min - approximate_keyframe_distance;
2261 } else if (no_change == 1) {
2262 // bisection if interpolation did not change min / max pos last time
2263 pos = (pos_min + pos_limit) >> 1;
2265 /* linear search if bisection failed, can only happen if there
2266 * are very few or no keyframes between min/max */
2271 else if (pos > pos_limit)
2275 // May pass pos_limit instead of -1.
2276 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2281 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2282 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2283 pos_min, pos, pos_max,
2284 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2285 pos_limit, start_pos, no_change);
2286 if (ts == AV_NOPTS_VALUE) {
2287 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2290 if (target_ts <= ts) {
2291 pos_limit = start_pos - 1;
2295 if (target_ts >= ts) {
2301 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2302 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2305 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2307 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2308 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2309 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2315 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2316 int64_t pos, int flags)
2318 int64_t pos_min, pos_max;
2320 pos_min = s->internal->data_offset;
2321 pos_max = avio_size(s->pb) - 1;
2325 else if (pos > pos_max)
2328 avio_seek(s->pb, pos, SEEK_SET);
2330 s->io_repositioned = 1;
2335 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2336 int64_t timestamp, int flags)
2343 st = s->streams[stream_index];
2345 index = av_index_search_timestamp(st, timestamp, flags);
2347 if (index < 0 && st->nb_index_entries &&
2348 timestamp < st->index_entries[0].timestamp)
2351 if (index < 0 || index == st->nb_index_entries - 1) {
2355 if (st->nb_index_entries) {
2356 av_assert0(st->index_entries);
2357 ie = &st->index_entries[st->nb_index_entries - 1];
2358 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2360 ff_update_cur_dts(s, st, ie->timestamp);
2362 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2368 read_status = av_read_frame(s, &pkt);
2369 } while (read_status == AVERROR(EAGAIN));
2370 if (read_status < 0)
2372 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2373 if (pkt.flags & AV_PKT_FLAG_KEY) {
2374 av_packet_unref(&pkt);
2377 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2378 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);
2379 av_packet_unref(&pkt);
2383 av_packet_unref(&pkt);
2385 index = av_index_search_timestamp(st, timestamp, flags);
2390 ff_read_frame_flush(s);
2391 if (s->iformat->read_seek)
2392 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2394 ie = &st->index_entries[index];
2395 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2397 ff_update_cur_dts(s, st, ie->timestamp);
2402 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2403 int64_t timestamp, int flags)
2408 if (flags & AVSEEK_FLAG_BYTE) {
2409 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2411 ff_read_frame_flush(s);
2412 return seek_frame_byte(s, stream_index, timestamp, flags);
2415 if (stream_index < 0) {
2416 stream_index = av_find_default_stream_index(s);
2417 if (stream_index < 0)
2420 st = s->streams[stream_index];
2421 /* timestamp for default must be expressed in AV_TIME_BASE units */
2422 timestamp = av_rescale(timestamp, st->time_base.den,
2423 AV_TIME_BASE * (int64_t) st->time_base.num);
2426 /* first, we try the format specific seek */
2427 if (s->iformat->read_seek) {
2428 ff_read_frame_flush(s);
2429 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2435 if (s->iformat->read_timestamp &&
2436 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2437 ff_read_frame_flush(s);
2438 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2439 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2440 ff_read_frame_flush(s);
2441 return seek_frame_generic(s, stream_index, timestamp, flags);
2446 int av_seek_frame(AVFormatContext *s, int stream_index,
2447 int64_t timestamp, int flags)
2451 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2452 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2453 if ((flags & AVSEEK_FLAG_BACKWARD))
2457 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2458 flags & ~AVSEEK_FLAG_BACKWARD);
2461 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2464 ret = avformat_queue_attached_pictures(s);
2469 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2470 int64_t ts, int64_t max_ts, int flags)
2472 if (min_ts > ts || max_ts < ts)
2474 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2475 return AVERROR(EINVAL);
2478 flags |= AVSEEK_FLAG_ANY;
2479 flags &= ~AVSEEK_FLAG_BACKWARD;
2481 if (s->iformat->read_seek2) {
2483 ff_read_frame_flush(s);
2485 if (stream_index == -1 && s->nb_streams == 1) {
2486 AVRational time_base = s->streams[0]->time_base;
2487 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2488 min_ts = av_rescale_rnd(min_ts, time_base.den,
2489 time_base.num * (int64_t)AV_TIME_BASE,
2490 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2491 max_ts = av_rescale_rnd(max_ts, time_base.den,
2492 time_base.num * (int64_t)AV_TIME_BASE,
2493 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2497 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2501 ret = avformat_queue_attached_pictures(s);
2505 if (s->iformat->read_timestamp) {
2506 // try to seek via read_timestamp()
2509 // Fall back on old API if new is not implemented but old is.
2510 // Note the old API has somewhat different semantics.
2511 if (s->iformat->read_seek || 1) {
2512 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2513 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2514 if (ret<0 && ts != min_ts && max_ts != ts) {
2515 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2517 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2522 // try some generic seek like seek_frame_generic() but with new ts semantics
2523 return -1; //unreachable
2526 int avformat_flush(AVFormatContext *s)
2528 ff_read_frame_flush(s);
2532 /*******************************************************/
2535 * Return TRUE if the stream has accurate duration in any stream.
2537 * @return TRUE if the stream has accurate duration for at least one component.
2539 static int has_duration(AVFormatContext *ic)
2544 for (i = 0; i < ic->nb_streams; i++) {
2545 st = ic->streams[i];
2546 if (st->duration != AV_NOPTS_VALUE)
2549 if (ic->duration != AV_NOPTS_VALUE)
2555 * Estimate the stream timings from the one of each components.
2557 * Also computes the global bitrate if possible.
2559 static void update_stream_timings(AVFormatContext *ic)
2561 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2562 int64_t duration, duration1, filesize;
2567 start_time = INT64_MAX;
2568 start_time_text = INT64_MAX;
2569 end_time = INT64_MIN;
2570 end_time_text = INT64_MIN;
2571 duration = INT64_MIN;
2572 for (i = 0; i < ic->nb_streams; i++) {
2573 st = ic->streams[i];
2574 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2575 start_time1 = av_rescale_q(st->start_time, st->time_base,
2577 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2578 if (start_time1 < start_time_text)
2579 start_time_text = start_time1;
2581 start_time = FFMIN(start_time, start_time1);
2582 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2584 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2585 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2586 end_time1 += start_time1;
2587 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2588 end_time_text = FFMAX(end_time_text, end_time1);
2590 end_time = FFMAX(end_time, end_time1);
2592 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2593 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2594 p->start_time = start_time1;
2595 if (p->end_time < end_time1)
2596 p->end_time = end_time1;
2599 if (st->duration != AV_NOPTS_VALUE) {
2600 duration1 = av_rescale_q(st->duration, st->time_base,
2602 duration = FFMAX(duration, duration1);
2605 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2606 start_time = start_time_text;
2607 else if (start_time > start_time_text)
2608 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2610 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2611 end_time = end_time_text;
2612 } else if (end_time < end_time_text) {
2613 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2616 if (start_time != INT64_MAX) {
2617 ic->start_time = start_time;
2618 if (end_time != INT64_MIN) {
2619 if (ic->nb_programs > 1) {
2620 for (i = 0; i < ic->nb_programs; i++) {
2621 p = ic->programs[i];
2622 if (p->start_time != AV_NOPTS_VALUE &&
2623 p->end_time > p->start_time &&
2624 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2625 duration = FFMAX(duration, p->end_time - p->start_time);
2627 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2628 duration = FFMAX(duration, end_time - start_time);
2632 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2633 ic->duration = duration;
2635 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2636 /* compute the bitrate */
2637 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2638 (double) ic->duration;
2639 if (bitrate >= 0 && bitrate <= INT64_MAX)
2640 ic->bit_rate = bitrate;
2644 static void fill_all_stream_timings(AVFormatContext *ic)
2649 update_stream_timings(ic);
2650 for (i = 0; i < ic->nb_streams; i++) {
2651 st = ic->streams[i];
2652 if (st->start_time == AV_NOPTS_VALUE) {
2653 if (ic->start_time != AV_NOPTS_VALUE)
2654 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2656 if (ic->duration != AV_NOPTS_VALUE)
2657 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2663 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2665 int64_t filesize, duration;
2666 int i, show_warning = 0;
2669 /* if bit_rate is already set, we believe it */
2670 if (ic->bit_rate <= 0) {
2671 int64_t bit_rate = 0;
2672 for (i = 0; i < ic->nb_streams; i++) {
2673 st = ic->streams[i];
2674 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2675 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2676 if (st->codecpar->bit_rate > 0) {
2677 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2681 bit_rate += st->codecpar->bit_rate;
2682 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2683 // If we have a videostream with packets but without a bitrate
2684 // then consider the sum not known
2689 ic->bit_rate = bit_rate;
2692 /* if duration is already set, we believe it */
2693 if (ic->duration == AV_NOPTS_VALUE &&
2694 ic->bit_rate != 0) {
2695 filesize = ic->pb ? avio_size(ic->pb) : 0;
2696 if (filesize > ic->internal->data_offset) {
2697 filesize -= ic->internal->data_offset;
2698 for (i = 0; i < ic->nb_streams; i++) {
2699 st = ic->streams[i];
2700 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2701 && st->duration == AV_NOPTS_VALUE) {
2702 duration = av_rescale(8 * filesize, st->time_base.den,
2704 (int64_t) st->time_base.num);
2705 st->duration = duration;
2712 av_log(ic, AV_LOG_WARNING,
2713 "Estimating duration from bitrate, this may be inaccurate\n");
2716 #define DURATION_MAX_READ_SIZE 250000LL
2717 #define DURATION_MAX_RETRY 6
2719 /* only usable for MPEG-PS streams */
2720 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2722 AVPacket pkt1, *pkt = &pkt1;
2724 int num, den, read_size, i, ret;
2725 int found_duration = 0;
2727 int64_t filesize, offset, duration;
2730 /* flush packet queue */
2731 flush_packet_queue(ic);
2733 for (i = 0; i < ic->nb_streams; i++) {
2734 st = ic->streams[i];
2735 if (st->start_time == AV_NOPTS_VALUE &&
2736 st->first_dts == AV_NOPTS_VALUE &&
2737 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2738 av_log(ic, AV_LOG_WARNING,
2739 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2742 av_parser_close(st->parser);
2747 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2748 /* estimate the end time (duration) */
2749 /* XXX: may need to support wrapping */
2750 filesize = ic->pb ? avio_size(ic->pb) : 0;
2752 is_end = found_duration;
2753 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2757 avio_seek(ic->pb, offset, SEEK_SET);
2760 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2764 ret = ff_read_packet(ic, pkt);
2765 } while (ret == AVERROR(EAGAIN));
2768 read_size += pkt->size;
2769 st = ic->streams[pkt->stream_index];
2770 if (pkt->pts != AV_NOPTS_VALUE &&
2771 (st->start_time != AV_NOPTS_VALUE ||
2772 st->first_dts != AV_NOPTS_VALUE)) {
2773 if (pkt->duration == 0) {
2774 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2776 pkt->duration = av_rescale_rnd(1,
2777 num * (int64_t) st->time_base.den,
2778 den * (int64_t) st->time_base.num,
2782 duration = pkt->pts + pkt->duration;
2784 if (st->start_time != AV_NOPTS_VALUE)
2785 duration -= st->start_time;
2787 duration -= st->first_dts;
2789 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2790 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2791 st->duration = duration;
2792 st->info->last_duration = duration;
2795 av_packet_unref(pkt);
2798 /* check if all audio/video streams have valid duration */
2801 for (i = 0; i < ic->nb_streams; i++) {
2802 st = ic->streams[i];
2803 switch (st->codecpar->codec_type) {
2804 case AVMEDIA_TYPE_VIDEO:
2805 case AVMEDIA_TYPE_AUDIO:
2806 if (st->duration == AV_NOPTS_VALUE)
2813 ++retry <= DURATION_MAX_RETRY);
2815 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2817 /* warn about audio/video streams which duration could not be estimated */
2818 for (i = 0; i < ic->nb_streams; i++) {
2819 st = ic->streams[i];
2820 if (st->duration == AV_NOPTS_VALUE) {
2821 switch (st->codecpar->codec_type) {
2822 case AVMEDIA_TYPE_VIDEO:
2823 case AVMEDIA_TYPE_AUDIO:
2824 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2825 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2827 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2831 fill_all_stream_timings(ic);
2833 avio_seek(ic->pb, old_offset, SEEK_SET);
2834 for (i = 0; i < ic->nb_streams; i++) {
2837 st = ic->streams[i];
2838 st->cur_dts = st->first_dts;
2839 st->last_IP_pts = AV_NOPTS_VALUE;
2840 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2841 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2842 st->pts_buffer[j] = AV_NOPTS_VALUE;
2846 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2850 /* get the file size, if possible */
2851 if (ic->iformat->flags & AVFMT_NOFILE) {
2854 file_size = avio_size(ic->pb);
2855 file_size = FFMAX(0, file_size);
2858 if ((!strcmp(ic->iformat->name, "mpeg") ||
2859 !strcmp(ic->iformat->name, "mpegts")) &&
2860 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2861 /* get accurate estimate from the PTSes */
2862 estimate_timings_from_pts(ic, old_offset);
2863 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2864 } else if (has_duration(ic)) {
2865 /* at least one component has timings - we use them for all
2867 fill_all_stream_timings(ic);
2868 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2870 /* less precise: use bitrate info */
2871 estimate_timings_from_bit_rate(ic);
2872 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2874 update_stream_timings(ic);
2878 AVStream av_unused *st;
2879 for (i = 0; i < ic->nb_streams; i++) {
2880 st = ic->streams[i];
2881 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2882 (double) st->start_time * av_q2d(st->time_base),
2883 (double) st->duration * av_q2d(st->time_base));
2885 av_log(ic, AV_LOG_TRACE,
2886 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2887 (double) ic->start_time / AV_TIME_BASE,
2888 (double) ic->duration / AV_TIME_BASE,
2889 (int64_t)ic->bit_rate / 1000);
2893 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2895 AVCodecContext *avctx = st->internal->avctx;
2897 #define FAIL(errmsg) do { \
2899 *errmsg_ptr = errmsg; \
2903 if ( avctx->codec_id == AV_CODEC_ID_NONE
2904 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2905 FAIL("unknown codec");
2906 switch (avctx->codec_type) {
2907 case AVMEDIA_TYPE_AUDIO:
2908 if (!avctx->frame_size && determinable_frame_size(avctx))
2909 FAIL("unspecified frame size");
2910 if (st->info->found_decoder >= 0 &&
2911 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2912 FAIL("unspecified sample format");
2913 if (!avctx->sample_rate)
2914 FAIL("unspecified sample rate");
2915 if (!avctx->channels)
2916 FAIL("unspecified number of channels");
2917 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2918 FAIL("no decodable DTS frames");
2920 case AVMEDIA_TYPE_VIDEO:
2922 FAIL("unspecified size");
2923 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2924 FAIL("unspecified pixel format");
2925 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2926 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2927 FAIL("no frame in rv30/40 and no sar");
2929 case AVMEDIA_TYPE_SUBTITLE:
2930 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2931 FAIL("unspecified size");
2933 case AVMEDIA_TYPE_DATA:
2934 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2940 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2941 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2942 AVDictionary **options)
2944 AVCodecContext *avctx = st->internal->avctx;
2945 const AVCodec *codec;
2946 int got_picture = 1, ret = 0;
2947 AVFrame *frame = av_frame_alloc();
2948 AVSubtitle subtitle;
2949 AVPacket pkt = *avpkt;
2950 int do_skip_frame = 0;
2951 enum AVDiscard skip_frame;
2954 return AVERROR(ENOMEM);
2956 if (!avcodec_is_open(avctx) &&
2957 st->info->found_decoder <= 0 &&
2958 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2959 AVDictionary *thread_opt = NULL;
2961 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2964 st->info->found_decoder = -st->codecpar->codec_id;
2969 /* Force thread count to 1 since the H.264 decoder will not extract
2970 * SPS and PPS to extradata during multi-threaded decoding. */
2971 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2972 if (s->codec_whitelist)
2973 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2974 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2976 av_dict_free(&thread_opt);
2978 st->info->found_decoder = -avctx->codec_id;
2981 st->info->found_decoder = 1;
2982 } else if (!st->info->found_decoder)
2983 st->info->found_decoder = 1;
2985 if (st->info->found_decoder < 0) {
2990 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2992 skip_frame = avctx->skip_frame;
2993 avctx->skip_frame = AVDISCARD_ALL;
2996 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2998 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2999 (!st->codec_info_nb_frames &&
3000 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3002 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3003 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3004 ret = avcodec_send_packet(avctx, &pkt);
3005 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3009 ret = avcodec_receive_frame(avctx, frame);
3012 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3014 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3015 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3016 &got_picture, &pkt);
3022 st->nb_decoded_frames++;
3027 if (!pkt.data && !got_picture)
3031 if (do_skip_frame) {
3032 avctx->skip_frame = skip_frame;
3035 av_frame_free(&frame);
3039 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3041 while (tags->id != AV_CODEC_ID_NONE) {
3049 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3052 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3053 if (tag == tags[i].tag)
3055 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3056 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3058 return AV_CODEC_ID_NONE;
3061 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3063 if (bps <= 0 || bps > 64)
3064 return AV_CODEC_ID_NONE;
3069 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3071 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3073 return AV_CODEC_ID_NONE;
3078 if (sflags & (1 << (bps - 1))) {
3081 return AV_CODEC_ID_PCM_S8;
3083 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3085 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3087 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3089 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3091 return AV_CODEC_ID_NONE;
3096 return AV_CODEC_ID_PCM_U8;
3098 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3100 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3102 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3104 return AV_CODEC_ID_NONE;
3110 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3113 if (!av_codec_get_tag2(tags, id, &tag))
3118 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3122 for (i = 0; tags && tags[i]; i++) {
3123 const AVCodecTag *codec_tags = tags[i];
3124 while (codec_tags->id != AV_CODEC_ID_NONE) {
3125 if (codec_tags->id == id) {
3126 *tag = codec_tags->tag;
3135 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3138 for (i = 0; tags && tags[i]; i++) {
3139 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3140 if (id != AV_CODEC_ID_NONE)
3143 return AV_CODEC_ID_NONE;
3146 static void compute_chapters_end(AVFormatContext *s)
3149 int64_t max_time = 0;
3151 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3152 max_time = s->duration +
3153 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3155 for (i = 0; i < s->nb_chapters; i++)
3156 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3157 AVChapter *ch = s->chapters[i];
3158 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3162 for (j = 0; j < s->nb_chapters; j++) {
3163 AVChapter *ch1 = s->chapters[j];
3164 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3166 if (j != i && next_start > ch->start && next_start < end)
3169 ch->end = (end == INT64_MAX) ? ch->start : end;
3173 static int get_std_framerate(int i)
3176 return (i + 1) * 1001;
3180 return (i + 31) * 1001 * 12;
3184 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3188 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3191 /* Is the time base unreliable?
3192 * This is a heuristic to balance between quick acceptance of the values in
3193 * the headers vs. some extra checks.
3194 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3195 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3196 * And there are "variable" fps files this needs to detect as well. */
3197 static int tb_unreliable(AVCodecContext *c)
3199 if (c->time_base.den >= 101LL * c->time_base.num ||
3200 c->time_base.den < 5LL * c->time_base.num ||
3201 // c->codec_tag == AV_RL32("DIVX") ||
3202 // c->codec_tag == AV_RL32("XVID") ||
3203 c->codec_tag == AV_RL32("mp4v") ||
3204 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3205 c->codec_id == AV_CODEC_ID_GIF ||
3206 c->codec_id == AV_CODEC_ID_HEVC ||
3207 c->codec_id == AV_CODEC_ID_H264)
3212 int ff_alloc_extradata(AVCodecParameters *par, int size)
3216 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3217 par->extradata = NULL;
3218 par->extradata_size = 0;
3219 return AVERROR(EINVAL);
3221 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3222 if (par->extradata) {
3223 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3224 par->extradata_size = size;
3227 par->extradata_size = 0;
3228 ret = AVERROR(ENOMEM);
3233 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3235 int ret = ff_alloc_extradata(par, size);
3238 ret = avio_read(pb, par->extradata, size);
3240 av_freep(&par->extradata);
3241 par->extradata_size = 0;
3242 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3243 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3249 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3252 int64_t last = st->info->last_dts;
3254 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3255 && ts - (uint64_t)last < INT64_MAX) {
3256 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3257 int64_t duration = ts - last;
3259 if (!st->info->duration_error)
3260 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3261 if (!st->info->duration_error)
3262 return AVERROR(ENOMEM);
3264 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3265 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3266 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3267 if (st->info->duration_error[0][1][i] < 1e10) {
3268 int framerate = get_std_framerate(i);
3269 double sdts = dts*framerate/(1001*12);
3270 for (j= 0; j<2; j++) {
3271 int64_t ticks = llrint(sdts+j*0.5);
3272 double error= sdts - ticks + j*0.5;
3273 st->info->duration_error[j][0][i] += error;
3274 st->info->duration_error[j][1][i] += error*error;
3278 st->info->duration_count++;
3279 st->info->rfps_duration_sum += duration;
3281 if (st->info->duration_count % 10 == 0) {
3282 int n = st->info->duration_count;
3283 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3284 if (st->info->duration_error[0][1][i] < 1e10) {
3285 double a0 = st->info->duration_error[0][0][i] / n;
3286 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3287 double a1 = st->info->duration_error[1][0][i] / n;
3288 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3289 if (error0 > 0.04 && error1 > 0.04) {
3290 st->info->duration_error[0][1][i] = 2e10;
3291 st->info->duration_error[1][1][i] = 2e10;
3297 // ignore the first 4 values, they might have some random jitter
3298 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3299 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3301 if (ts != AV_NOPTS_VALUE)
3302 st->info->last_dts = ts;
3307 void ff_rfps_calculate(AVFormatContext *ic)
3311 for (i = 0; i < ic->nb_streams; i++) {
3312 AVStream *st = ic->streams[i];
3314 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3316 // the check for tb_unreliable() is not completely correct, since this is not about handling
3317 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3318 // ipmovie.c produces.
3319 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)
3320 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);
3321 if (st->info->duration_count>1 && !st->r_frame_rate.num
3322 && tb_unreliable(st->internal->avctx)) {
3324 double best_error= 0.01;
3325 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3327 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3330 if (st->info->codec_info_duration &&
3331 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3333 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3336 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3339 for (k= 0; k<2; k++) {
3340 int n = st->info->duration_count;
3341 double a= st->info->duration_error[k][0][j] / n;
3342 double error= st->info->duration_error[k][1][j]/n - a*a;
3344 if (error < best_error && best_error> 0.000000001) {
3346 num = get_std_framerate(j);
3349 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3352 // do not increase frame rate by more than 1 % in order to match a standard rate.
3353 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3354 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3356 if ( !st->avg_frame_rate.num
3357 && st->r_frame_rate.num && st->info->rfps_duration_sum
3358 && st->info->codec_info_duration <= 0
3359 && st->info->duration_count > 2
3360 && 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
3362 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3363 st->avg_frame_rate = st->r_frame_rate;
3366 av_freep(&st->info->duration_error);
3367 st->info->last_dts = AV_NOPTS_VALUE;
3368 st->info->duration_count = 0;
3369 st->info->rfps_duration_sum = 0;
3373 static int extract_extradata_check(AVStream *st)
3375 const AVBitStreamFilter *f;
3377 f = av_bsf_get_by_name("extract_extradata");
3382 const enum AVCodecID *ids;
3383 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3384 if (*ids == st->codecpar->codec_id)
3391 static int extract_extradata_init(AVStream *st)
3393 AVStreamInternal *i = st->internal;
3394 const AVBitStreamFilter *f;
3397 f = av_bsf_get_by_name("extract_extradata");
3401 /* check that the codec id is supported */
3402 ret = extract_extradata_check(st);
3406 i->extract_extradata.pkt = av_packet_alloc();
3407 if (!i->extract_extradata.pkt)
3408 return AVERROR(ENOMEM);
3410 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3414 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3419 i->extract_extradata.bsf->time_base_in = st->time_base;
3421 /* if init fails here, we assume extracting extradata is just not
3422 * supported for this codec, so we return success */
3423 ret = av_bsf_init(i->extract_extradata.bsf);
3425 av_bsf_free(&i->extract_extradata.bsf);
3430 i->extract_extradata.inited = 1;
3434 av_bsf_free(&i->extract_extradata.bsf);
3435 av_packet_free(&i->extract_extradata.pkt);
3439 static int extract_extradata(AVStream *st, AVPacket *pkt)
3441 AVStreamInternal *i = st->internal;
3445 if (!i->extract_extradata.inited) {
3446 ret = extract_extradata_init(st);
3451 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3454 pkt_ref = i->extract_extradata.pkt;
3455 ret = av_packet_ref(pkt_ref, pkt);
3459 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3461 av_packet_unref(pkt_ref);
3465 while (ret >= 0 && !i->avctx->extradata) {
3469 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3471 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3476 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3480 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3481 if (!i->avctx->extradata) {
3482 av_packet_unref(pkt_ref);
3483 return AVERROR(ENOMEM);
3485 memcpy(i->avctx->extradata, extradata, extradata_size);
3486 i->avctx->extradata_size = extradata_size;
3488 av_packet_unref(pkt_ref);
3494 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3496 int i, count = 0, ret = 0, j;
3499 AVCodecContext *avctx;
3500 AVPacket pkt1, *pkt;
3501 int64_t old_offset = avio_tell(ic->pb);
3502 // new streams might appear, no options for those
3503 int orig_nb_streams = ic->nb_streams;
3505 int64_t max_analyze_duration = ic->max_analyze_duration;
3506 int64_t max_stream_analyze_duration;
3507 int64_t max_subtitle_analyze_duration;
3508 int64_t probesize = ic->probesize;
3509 int eof_reached = 0;
3510 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3512 flush_codecs = probesize > 0;
3514 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3516 max_stream_analyze_duration = max_analyze_duration;
3517 max_subtitle_analyze_duration = max_analyze_duration;
3518 if (!max_analyze_duration) {
3519 max_stream_analyze_duration =
3520 max_analyze_duration = 5*AV_TIME_BASE;
3521 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3522 if (!strcmp(ic->iformat->name, "flv"))
3523 max_stream_analyze_duration = 90*AV_TIME_BASE;
3524 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3525 max_stream_analyze_duration = 7*AV_TIME_BASE;
3529 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3530 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3532 for (i = 0; i < ic->nb_streams; i++) {
3533 const AVCodec *codec;
3534 AVDictionary *thread_opt = NULL;
3535 st = ic->streams[i];
3536 avctx = st->internal->avctx;
3538 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3539 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3540 /* if (!st->time_base.num)
3542 if (!avctx->time_base.num)
3543 avctx->time_base = st->time_base;
3546 /* check if the caller has overridden the codec id */
3547 #if FF_API_LAVF_AVCTX
3548 FF_DISABLE_DEPRECATION_WARNINGS
3549 if (st->codec->codec_id != st->internal->orig_codec_id) {
3550 st->codecpar->codec_id = st->codec->codec_id;
3551 st->codecpar->codec_type = st->codec->codec_type;
3552 st->internal->orig_codec_id = st->codec->codec_id;
3554 FF_ENABLE_DEPRECATION_WARNINGS