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 if ((ret = init_input(s, filename, &tmp)) < 0)
538 s->probe_score = ret;
540 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
541 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
542 if (!s->protocol_whitelist) {
543 ret = AVERROR(ENOMEM);
548 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
549 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
550 if (!s->protocol_blacklist) {
551 ret = AVERROR(ENOMEM);
556 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
557 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
558 ret = AVERROR(EINVAL);
562 avio_skip(s->pb, s->skip_initial_bytes);
564 /* Check filename in case an image number is expected. */
565 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
566 if (!av_filename_number_test(filename)) {
567 ret = AVERROR(EINVAL);
572 s->duration = s->start_time = AV_NOPTS_VALUE;
573 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
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.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1169 !pktl->pkt.duration) {
1170 pktl->pkt.dts = cur_dts;
1171 if (!st->internal->avctx->has_b_frames)
1172 pktl->pkt.pts = cur_dts;
1173 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1174 pktl->pkt.duration = duration;
1177 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1180 st->cur_dts = cur_dts;
1183 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1184 AVCodecParserContext *pc, AVPacket *pkt,
1185 int64_t next_dts, int64_t next_pts)
1187 int num, den, presentation_delayed, delay, i;
1189 AVRational duration;
1190 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1191 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1193 if (s->flags & AVFMT_FLAG_NOFILLIN)
1196 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1197 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1198 if (st->last_dts_for_order_check <= pkt->dts) {
1201 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1202 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1204 st->last_dts_for_order_check);
1205 st->dts_misordered++;
1207 if (st->dts_ordered + st->dts_misordered > 250) {
1208 st->dts_ordered >>= 1;
1209 st->dts_misordered >>= 1;
1213 st->last_dts_for_order_check = pkt->dts;
1214 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1215 pkt->dts = AV_NOPTS_VALUE;
1218 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1219 pkt->dts = AV_NOPTS_VALUE;
1221 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1222 && !st->internal->avctx->has_b_frames)
1223 //FIXME Set low_delay = 0 when has_b_frames = 1
1224 st->internal->avctx->has_b_frames = 1;
1226 /* do we have a video B-frame ? */
1227 delay = st->internal->avctx->has_b_frames;
1228 presentation_delayed = 0;
1230 /* XXX: need has_b_frame, but cannot get it if the codec is
1231 * not initialized */
1233 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1234 presentation_delayed = 1;
1236 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1237 st->pts_wrap_bits < 63 &&
1238 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1239 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1240 pkt->dts -= 1LL << st->pts_wrap_bits;
1242 pkt->pts += 1LL << st->pts_wrap_bits;
1245 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1246 * We take the conservative approach and discard both.
1247 * Note: If this is misbehaving for an H.264 file, then possibly
1248 * presentation_delayed is not set correctly. */
1249 if (delay == 1 && pkt->dts == pkt->pts &&
1250 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1251 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1252 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1253 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1254 pkt->dts = AV_NOPTS_VALUE;
1257 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1258 if (pkt->duration == 0) {
1259 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1261 duration = (AVRational) {num, den};
1262 pkt->duration = av_rescale_rnd(1,
1263 num * (int64_t) st->time_base.den,
1264 den * (int64_t) st->time_base.num,
1269 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1270 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1272 /* Correct timestamps with byte offset if demuxers only have timestamps
1273 * on packet boundaries */
1274 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1275 /* this will estimate bitrate based on this frame's duration and size */
1276 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1277 if (pkt->pts != AV_NOPTS_VALUE)
1279 if (pkt->dts != AV_NOPTS_VALUE)
1283 /* This may be redundant, but it should not hurt. */
1284 if (pkt->dts != AV_NOPTS_VALUE &&
1285 pkt->pts != AV_NOPTS_VALUE &&
1286 pkt->pts > pkt->dts)
1287 presentation_delayed = 1;
1289 if (s->debug & FF_FDEBUG_TS)
1290 av_log(s, AV_LOG_TRACE,
1291 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1292 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1293 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1295 /* Interpolate PTS and DTS if they are not present. We skip H264
1296 * currently because delay and has_b_frames are not reliably set. */
1297 if ((delay == 0 || (delay == 1 && pc)) &&
1299 if (presentation_delayed) {
1300 /* DTS = decompression timestamp */
1301 /* PTS = presentation timestamp */
1302 if (pkt->dts == AV_NOPTS_VALUE)
1303 pkt->dts = st->last_IP_pts;
1304 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1305 if (pkt->dts == AV_NOPTS_VALUE)
1306 pkt->dts = st->cur_dts;
1308 /* This is tricky: the dts must be incremented by the duration
1309 * of the frame we are displaying, i.e. the last I- or P-frame. */
1310 if (st->last_IP_duration == 0)
1311 st->last_IP_duration = pkt->duration;
1312 if (pkt->dts != AV_NOPTS_VALUE)
1313 st->cur_dts = pkt->dts + st->last_IP_duration;
1314 if (pkt->dts != AV_NOPTS_VALUE &&
1315 pkt->pts == AV_NOPTS_VALUE &&
1316 st->last_IP_duration > 0 &&
1317 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1318 next_dts != next_pts &&
1319 next_pts != AV_NOPTS_VALUE)
1320 pkt->pts = next_dts;
1322 st->last_IP_duration = pkt->duration;
1323 st->last_IP_pts = pkt->pts;
1324 /* Cannot compute PTS if not present (we can compute it only
1325 * by knowing the future. */
1326 } else if (pkt->pts != AV_NOPTS_VALUE ||
1327 pkt->dts != AV_NOPTS_VALUE ||
1330 /* presentation is not delayed : PTS and DTS are the same */
1331 if (pkt->pts == AV_NOPTS_VALUE)
1332 pkt->pts = pkt->dts;
1333 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1335 if (pkt->pts == AV_NOPTS_VALUE)
1336 pkt->pts = st->cur_dts;
1337 pkt->dts = pkt->pts;
1338 if (pkt->pts != AV_NOPTS_VALUE)
1339 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1343 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1344 st->pts_buffer[0] = pkt->pts;
1345 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1346 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1348 if(has_decode_delay_been_guessed(st))
1349 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1351 // We skipped it above so we try here.
1353 // This should happen on the first packet
1354 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1355 if (pkt->dts > st->cur_dts)
1356 st->cur_dts = pkt->dts;
1358 if (s->debug & FF_FDEBUG_TS)
1359 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1360 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1363 if (is_intra_only(st->codecpar->codec_id))
1364 pkt->flags |= AV_PKT_FLAG_KEY;
1365 #if FF_API_CONVERGENCE_DURATION
1366 FF_DISABLE_DEPRECATION_WARNINGS
1368 pkt->convergence_duration = pc->convergence_duration;
1369 FF_ENABLE_DEPRECATION_WARNINGS
1373 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1376 AVPacketList *pktl = *pkt_buf;
1377 *pkt_buf = pktl->next;
1378 av_packet_unref(&pktl->pkt);
1381 *pkt_buf_end = NULL;
1385 * Parse a packet, add all split parts to parse_queue.
1387 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1389 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1391 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1392 AVStream *st = s->streams[stream_index];
1393 uint8_t *data = pkt ? pkt->data : NULL;
1394 int size = pkt ? pkt->size : 0;
1395 int ret = 0, got_output = 0;
1398 av_init_packet(&flush_pkt);
1401 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1402 // preserve 0-size sync packets
1403 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1406 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1408 int64_t next_pts = pkt->pts;
1409 int64_t next_dts = pkt->dts;
1411 av_init_packet(&out_pkt);
1412 len = av_parser_parse2(st->parser, st->internal->avctx,
1413 &out_pkt.data, &out_pkt.size, data, size,
1414 pkt->pts, pkt->dts, pkt->pos);
1416 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1418 /* increment read pointer */
1422 got_output = !!out_pkt.size;
1427 if (pkt->side_data) {
1428 out_pkt.side_data = pkt->side_data;
1429 out_pkt.side_data_elems = pkt->side_data_elems;
1430 pkt->side_data = NULL;
1431 pkt->side_data_elems = 0;
1434 /* set the duration */
1435 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1436 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1437 if (st->internal->avctx->sample_rate > 0) {
1439 av_rescale_q_rnd(st->parser->duration,
1440 (AVRational) { 1, st->internal->avctx->sample_rate },
1446 out_pkt.stream_index = st->index;
1447 out_pkt.pts = st->parser->pts;
1448 out_pkt.dts = st->parser->dts;
1449 out_pkt.pos = st->parser->pos;
1451 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1452 out_pkt.pos = st->parser->frame_offset;
1454 if (st->parser->key_frame == 1 ||
1455 (st->parser->key_frame == -1 &&
1456 st->parser->pict_type == AV_PICTURE_TYPE_I))
1457 out_pkt.flags |= AV_PKT_FLAG_KEY;
1459 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1460 out_pkt.flags |= AV_PKT_FLAG_KEY;
1462 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1464 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1465 &s->internal->parse_queue_end, 1);
1466 av_packet_unref(&out_pkt);
1471 /* end of the stream => close and free the parser */
1472 if (pkt == &flush_pkt) {
1473 av_parser_close(st->parser);
1478 av_packet_unref(pkt);
1482 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1483 AVPacketList **pkt_buffer_end,
1487 av_assert0(*pkt_buffer);
1490 *pkt_buffer = pktl->next;
1492 *pkt_buffer_end = NULL;
1497 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1499 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1502 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1504 int ret = 0, i, got_packet = 0;
1505 AVDictionary *metadata = NULL;
1507 av_init_packet(pkt);
1509 while (!got_packet && !s->internal->parse_queue) {
1513 /* read next packet */
1514 ret = ff_read_packet(s, &cur_pkt);
1516 if (ret == AVERROR(EAGAIN))
1518 /* flush the parsers */
1519 for (i = 0; i < s->nb_streams; i++) {
1521 if (st->parser && st->need_parsing)
1522 parse_packet(s, NULL, st->index);
1524 /* all remaining packets are now in parse_queue =>
1525 * really terminate parsing */
1529 st = s->streams[cur_pkt.stream_index];
1531 /* update context if required */
1532 if (st->internal->need_context_update) {
1533 if (avcodec_is_open(st->internal->avctx)) {
1534 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1535 avcodec_close(st->internal->avctx);
1536 st->info->found_decoder = 0;
1539 /* close parser, because it depends on the codec */
1540 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1541 av_parser_close(st->parser);
1545 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1549 #if FF_API_LAVF_AVCTX
1550 FF_DISABLE_DEPRECATION_WARNINGS
1551 /* update deprecated public codec context */
1552 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1555 FF_ENABLE_DEPRECATION_WARNINGS
1558 st->internal->need_context_update = 0;
1561 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1562 cur_pkt.dts != AV_NOPTS_VALUE &&
1563 cur_pkt.pts < cur_pkt.dts) {
1564 av_log(s, AV_LOG_WARNING,
1565 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1566 cur_pkt.stream_index,
1567 av_ts2str(cur_pkt.pts),
1568 av_ts2str(cur_pkt.dts),
1571 if (s->debug & FF_FDEBUG_TS)
1572 av_log(s, AV_LOG_DEBUG,
1573 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1574 cur_pkt.stream_index,
1575 av_ts2str(cur_pkt.pts),
1576 av_ts2str(cur_pkt.dts),
1577 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1579 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1580 st->parser = av_parser_init(st->codecpar->codec_id);
1582 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1583 "%s, packets or times may be invalid.\n",
1584 avcodec_get_name(st->codecpar->codec_id));
1585 /* no parser available: just output the raw packets */
1586 st->need_parsing = AVSTREAM_PARSE_NONE;
1587 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1588 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1589 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1590 st->parser->flags |= PARSER_FLAG_ONCE;
1591 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1592 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1595 if (!st->need_parsing || !st->parser) {
1596 /* no parsing needed: we just output the packet as is */
1598 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1599 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1600 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1601 ff_reduce_index(s, st->index);
1602 av_add_index_entry(st, pkt->pos, pkt->dts,
1603 0, 0, AVINDEX_KEYFRAME);
1606 } else if (st->discard < AVDISCARD_ALL) {
1607 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1609 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1610 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1611 st->codecpar->channels = st->internal->avctx->channels;
1612 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1613 st->codecpar->codec_id = st->internal->avctx->codec_id;
1616 av_packet_unref(&cur_pkt);
1618 if (pkt->flags & AV_PKT_FLAG_KEY)
1619 st->skip_to_keyframe = 0;
1620 if (st->skip_to_keyframe) {
1621 av_packet_unref(&cur_pkt);
1629 if (!got_packet && s->internal->parse_queue)
1630 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1633 AVStream *st = s->streams[pkt->stream_index];
1634 int discard_padding = 0;
1635 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1636 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1637 int64_t sample = ts_to_samples(st, pts);
1638 int duration = ts_to_samples(st, pkt->duration);
1639 int64_t end_sample = sample + duration;
1640 if (duration > 0 && end_sample >= st->first_discard_sample &&
1641 sample < st->last_discard_sample)
1642 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1644 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1645 st->skip_samples = st->start_skip_samples;
1646 if (st->skip_samples || discard_padding) {
1647 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1649 AV_WL32(p, st->skip_samples);
1650 AV_WL32(p + 4, discard_padding);
1651 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1653 st->skip_samples = 0;
1656 if (st->inject_global_side_data) {
1657 for (i = 0; i < st->nb_side_data; i++) {
1658 AVPacketSideData *src_sd = &st->side_data[i];
1661 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1664 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1666 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1670 memcpy(dst_data, src_sd->data, src_sd->size);
1672 st->inject_global_side_data = 0;
1675 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1676 av_packet_merge_side_data(pkt);
1679 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1681 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1682 av_dict_copy(&s->metadata, metadata, 0);
1683 av_dict_free(&metadata);
1684 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1687 #if FF_API_LAVF_AVCTX
1688 update_stream_avctx(s);
1691 if (s->debug & FF_FDEBUG_TS)
1692 av_log(s, AV_LOG_DEBUG,
1693 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1694 "size=%d, duration=%"PRId64", flags=%d\n",
1696 av_ts2str(pkt->pts),
1697 av_ts2str(pkt->dts),
1698 pkt->size, pkt->duration, pkt->flags);
1703 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1705 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1711 ret = s->internal->packet_buffer
1712 ? read_from_packet_buffer(&s->internal->packet_buffer,
1713 &s->internal->packet_buffer_end, pkt)
1714 : read_frame_internal(s, pkt);
1721 AVPacketList *pktl = s->internal->packet_buffer;
1724 AVPacket *next_pkt = &pktl->pkt;
1726 if (next_pkt->dts != AV_NOPTS_VALUE) {
1727 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1728 // last dts seen for this stream. if any of packets following
1729 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1730 int64_t last_dts = next_pkt->dts;
1731 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1732 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1733 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1734 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1736 next_pkt->pts = pktl->pkt.dts;
1738 if (last_dts != AV_NOPTS_VALUE) {
1739 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1740 last_dts = pktl->pkt.dts;
1745 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1746 // Fixing the last reference frame had none pts issue (For MXF etc).
1747 // We only do this when
1749 // 2. we are not able to resolve a pts value for current packet.
1750 // 3. the packets for this stream at the end of the files had valid dts.
1751 next_pkt->pts = last_dts + next_pkt->duration;
1753 pktl = s->internal->packet_buffer;
1756 /* read packet from packet buffer, if there is data */
1757 st = s->streams[next_pkt->stream_index];
1758 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1759 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1760 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1761 &s->internal->packet_buffer_end, pkt);
1766 ret = read_frame_internal(s, pkt);
1768 if (pktl && ret != AVERROR(EAGAIN)) {
1775 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1776 &s->internal->packet_buffer_end, 1);
1777 av_packet_unref(pkt);
1784 st = s->streams[pkt->stream_index];
1785 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1786 ff_reduce_index(s, st->index);
1787 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1790 if (is_relative(pkt->dts))
1791 pkt->dts -= RELATIVE_TS_BASE;
1792 if (is_relative(pkt->pts))
1793 pkt->pts -= RELATIVE_TS_BASE;
1798 /* XXX: suppress the packet queue */
1799 static void flush_packet_queue(AVFormatContext *s)
1803 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1804 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1805 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1807 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1810 /*******************************************************/
1813 int av_find_default_stream_index(AVFormatContext *s)
1817 int best_stream = 0;
1818 int best_score = INT_MIN;
1820 if (s->nb_streams <= 0)
1822 for (i = 0; i < s->nb_streams; i++) {
1825 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1826 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1828 if (st->codecpar->width && st->codecpar->height)
1832 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1833 if (st->codecpar->sample_rate)
1836 if (st->codec_info_nb_frames)
1839 if (st->discard != AVDISCARD_ALL)
1842 if (score > best_score) {
1850 /** Flush the frame reader. */
1851 void ff_read_frame_flush(AVFormatContext *s)
1856 flush_packet_queue(s);
1858 /* Reset read state for each stream. */
1859 for (i = 0; i < s->nb_streams; i++) {
1863 av_parser_close(st->parser);
1866 st->last_IP_pts = AV_NOPTS_VALUE;
1867 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1868 if (st->first_dts == AV_NOPTS_VALUE)
1869 st->cur_dts = RELATIVE_TS_BASE;
1871 /* We set the current DTS to an unspecified origin. */
1872 st->cur_dts = AV_NOPTS_VALUE;
1874 st->probe_packets = MAX_PROBE_PACKETS;
1876 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1877 st->pts_buffer[j] = AV_NOPTS_VALUE;
1879 if (s->internal->inject_global_side_data)
1880 st->inject_global_side_data = 1;
1882 st->skip_samples = 0;
1886 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1890 for (i = 0; i < s->nb_streams; i++) {
1891 AVStream *st = s->streams[i];
1894 av_rescale(timestamp,
1895 st->time_base.den * (int64_t) ref_st->time_base.num,
1896 st->time_base.num * (int64_t) ref_st->time_base.den);
1900 void ff_reduce_index(AVFormatContext *s, int stream_index)
1902 AVStream *st = s->streams[stream_index];
1903 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1905 if ((unsigned) st->nb_index_entries >= max_entries) {
1907 for (i = 0; 2 * i < st->nb_index_entries; i++)
1908 st->index_entries[i] = st->index_entries[2 * i];
1909 st->nb_index_entries = i;
1913 int ff_add_index_entry(AVIndexEntry **index_entries,
1914 int *nb_index_entries,
1915 unsigned int *index_entries_allocated_size,
1916 int64_t pos, int64_t timestamp,
1917 int size, int distance, int flags)
1919 AVIndexEntry *entries, *ie;
1922 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1925 if (timestamp == AV_NOPTS_VALUE)
1926 return AVERROR(EINVAL);
1928 if (size < 0 || size > 0x3FFFFFFF)
1929 return AVERROR(EINVAL);
1931 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1932 timestamp -= RELATIVE_TS_BASE;
1934 entries = av_fast_realloc(*index_entries,
1935 index_entries_allocated_size,
1936 (*nb_index_entries + 1) *
1937 sizeof(AVIndexEntry));
1941 *index_entries = entries;
1943 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1944 timestamp, AVSEEK_FLAG_ANY);
1947 index = (*nb_index_entries)++;
1948 ie = &entries[index];
1949 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1951 ie = &entries[index];
1952 if (ie->timestamp != timestamp) {
1953 if (ie->timestamp <= timestamp)
1955 memmove(entries + index + 1, entries + index,
1956 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1957 (*nb_index_entries)++;
1958 } else if (ie->pos == pos && distance < ie->min_distance)
1959 // do not reduce the distance
1960 distance = ie->min_distance;
1964 ie->timestamp = timestamp;
1965 ie->min_distance = distance;
1972 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1973 int size, int distance, int flags)
1975 timestamp = wrap_timestamp(st, timestamp);
1976 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1977 &st->index_entries_allocated_size, pos,
1978 timestamp, size, distance, flags);
1981 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1982 int64_t wanted_timestamp, int flags)
1990 // Optimize appending index entries at the end.
1991 if (b && entries[b - 1].timestamp < wanted_timestamp)
1997 // Search for the next non-discarded packet.
1998 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2000 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2006 timestamp = entries[m].timestamp;
2007 if (timestamp >= wanted_timestamp)
2009 if (timestamp <= wanted_timestamp)
2012 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2014 if (!(flags & AVSEEK_FLAG_ANY))
2015 while (m >= 0 && m < nb_entries &&
2016 !(entries[m].flags & AVINDEX_KEYFRAME))
2017 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2019 if (m == nb_entries)
2024 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2027 int64_t pos_delta = 0;
2029 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2030 const char *proto = avio_find_protocol_name(s->filename);
2033 av_log(s, AV_LOG_INFO,
2034 "Protocol name not provided, cannot determine if input is local or "
2035 "a network protocol, buffers and access patterns cannot be configured "
2036 "optimally without knowing the protocol\n");
2039 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2042 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2043 AVStream *st1 = s->streams[ist1];
2044 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2045 AVStream *st2 = s->streams[ist2];
2051 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2052 AVIndexEntry *e1 = &st1->index_entries[i1];
2053 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2055 skip = FFMAX(skip, e1->size);
2056 for (; i2 < st2->nb_index_entries; i2++) {
2057 AVIndexEntry *e2 = &st2->index_entries[i2];
2058 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2059 if (e2_pts - e1_pts < time_tolerance)
2061 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2069 /* XXX This could be adjusted depending on protocol*/
2070 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2071 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2072 ffio_set_buf_size(s->pb, pos_delta);
2073 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2076 if (skip < (1<<23)) {
2077 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2081 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2083 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2084 wanted_timestamp, flags);
2087 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2088 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2090 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2091 if (stream_index >= 0)
2092 ts = wrap_timestamp(s->streams[stream_index], ts);
2096 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2097 int64_t target_ts, int flags)
2099 AVInputFormat *avif = s->iformat;
2100 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2101 int64_t ts_min, ts_max, ts;
2106 if (stream_index < 0)
2109 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2112 ts_min = AV_NOPTS_VALUE;
2113 pos_limit = -1; // GCC falsely says it may be uninitialized.
2115 st = s->streams[stream_index];
2116 if (st->index_entries) {
2119 /* FIXME: Whole function must be checked for non-keyframe entries in
2120 * index case, especially read_timestamp(). */
2121 index = av_index_search_timestamp(st, target_ts,
2122 flags | AVSEEK_FLAG_BACKWARD);
2123 index = FFMAX(index, 0);
2124 e = &st->index_entries[index];
2126 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2128 ts_min = e->timestamp;
2129 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2130 pos_min, av_ts2str(ts_min));
2132 av_assert1(index == 0);
2135 index = av_index_search_timestamp(st, target_ts,
2136 flags & ~AVSEEK_FLAG_BACKWARD);
2137 av_assert0(index < st->nb_index_entries);
2139 e = &st->index_entries[index];
2140 av_assert1(e->timestamp >= target_ts);
2142 ts_max = e->timestamp;
2143 pos_limit = pos_max - e->min_distance;
2144 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2145 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2149 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2150 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2155 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2158 ff_read_frame_flush(s);
2159 ff_update_cur_dts(s, st, ts);
2164 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2165 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2167 int64_t step = 1024;
2168 int64_t limit, ts_max;
2169 int64_t filesize = avio_size(s->pb);
2170 int64_t pos_max = filesize - 1;
2173 pos_max = FFMAX(0, (pos_max) - step);
2174 ts_max = ff_read_timestamp(s, stream_index,
2175 &pos_max, limit, read_timestamp);
2177 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2178 if (ts_max == AV_NOPTS_VALUE)
2182 int64_t tmp_pos = pos_max + 1;
2183 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2184 &tmp_pos, INT64_MAX, read_timestamp);
2185 if (tmp_ts == AV_NOPTS_VALUE)
2187 av_assert0(tmp_pos > pos_max);
2190 if (tmp_pos >= filesize)
2202 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2203 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2204 int64_t ts_min, int64_t ts_max,
2205 int flags, int64_t *ts_ret,
2206 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2207 int64_t *, int64_t))
2214 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2216 if (ts_min == AV_NOPTS_VALUE) {
2217 pos_min = s->internal->data_offset;
2218 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2219 if (ts_min == AV_NOPTS_VALUE)
2223 if (ts_min >= target_ts) {
2228 if (ts_max == AV_NOPTS_VALUE) {
2229 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2231 pos_limit = pos_max;
2234 if (ts_max <= target_ts) {
2239 av_assert0(ts_min < ts_max);
2242 while (pos_min < pos_limit) {
2243 av_log(s, AV_LOG_TRACE,
2244 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2245 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2246 av_assert0(pos_limit <= pos_max);
2248 if (no_change == 0) {
2249 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2250 // interpolate position (better than dichotomy)
2251 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2253 pos_min - approximate_keyframe_distance;
2254 } else if (no_change == 1) {
2255 // bisection if interpolation did not change min / max pos last time
2256 pos = (pos_min + pos_limit) >> 1;
2258 /* linear search if bisection failed, can only happen if there
2259 * are very few or no keyframes between min/max */
2264 else if (pos > pos_limit)
2268 // May pass pos_limit instead of -1.
2269 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2274 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2275 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2276 pos_min, pos, pos_max,
2277 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2278 pos_limit, start_pos, no_change);
2279 if (ts == AV_NOPTS_VALUE) {
2280 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2283 if (target_ts <= ts) {
2284 pos_limit = start_pos - 1;
2288 if (target_ts >= ts) {
2294 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2295 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2298 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2300 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2301 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2302 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2308 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2309 int64_t pos, int flags)
2311 int64_t pos_min, pos_max;
2313 pos_min = s->internal->data_offset;
2314 pos_max = avio_size(s->pb) - 1;
2318 else if (pos > pos_max)
2321 avio_seek(s->pb, pos, SEEK_SET);
2323 s->io_repositioned = 1;
2328 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2329 int64_t timestamp, int flags)
2336 st = s->streams[stream_index];
2338 index = av_index_search_timestamp(st, timestamp, flags);
2340 if (index < 0 && st->nb_index_entries &&
2341 timestamp < st->index_entries[0].timestamp)
2344 if (index < 0 || index == st->nb_index_entries - 1) {
2348 if (st->nb_index_entries) {
2349 av_assert0(st->index_entries);
2350 ie = &st->index_entries[st->nb_index_entries - 1];
2351 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2353 ff_update_cur_dts(s, st, ie->timestamp);
2355 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2361 read_status = av_read_frame(s, &pkt);
2362 } while (read_status == AVERROR(EAGAIN));
2363 if (read_status < 0)
2365 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2366 if (pkt.flags & AV_PKT_FLAG_KEY) {
2367 av_packet_unref(&pkt);
2370 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2371 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);
2372 av_packet_unref(&pkt);
2376 av_packet_unref(&pkt);
2378 index = av_index_search_timestamp(st, timestamp, flags);
2383 ff_read_frame_flush(s);
2384 if (s->iformat->read_seek)
2385 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2387 ie = &st->index_entries[index];
2388 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2390 ff_update_cur_dts(s, st, ie->timestamp);
2395 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2396 int64_t timestamp, int flags)
2401 if (flags & AVSEEK_FLAG_BYTE) {
2402 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2404 ff_read_frame_flush(s);
2405 return seek_frame_byte(s, stream_index, timestamp, flags);
2408 if (stream_index < 0) {
2409 stream_index = av_find_default_stream_index(s);
2410 if (stream_index < 0)
2413 st = s->streams[stream_index];
2414 /* timestamp for default must be expressed in AV_TIME_BASE units */
2415 timestamp = av_rescale(timestamp, st->time_base.den,
2416 AV_TIME_BASE * (int64_t) st->time_base.num);
2419 /* first, we try the format specific seek */
2420 if (s->iformat->read_seek) {
2421 ff_read_frame_flush(s);
2422 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2428 if (s->iformat->read_timestamp &&
2429 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2430 ff_read_frame_flush(s);
2431 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2432 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2433 ff_read_frame_flush(s);
2434 return seek_frame_generic(s, stream_index, timestamp, flags);
2439 int av_seek_frame(AVFormatContext *s, int stream_index,
2440 int64_t timestamp, int flags)
2444 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2445 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2446 if ((flags & AVSEEK_FLAG_BACKWARD))
2450 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2451 flags & ~AVSEEK_FLAG_BACKWARD);
2454 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2457 ret = avformat_queue_attached_pictures(s);
2462 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2463 int64_t ts, int64_t max_ts, int flags)
2465 if (min_ts > ts || max_ts < ts)
2467 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2468 return AVERROR(EINVAL);
2471 flags |= AVSEEK_FLAG_ANY;
2472 flags &= ~AVSEEK_FLAG_BACKWARD;
2474 if (s->iformat->read_seek2) {
2476 ff_read_frame_flush(s);
2478 if (stream_index == -1 && s->nb_streams == 1) {
2479 AVRational time_base = s->streams[0]->time_base;
2480 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2481 min_ts = av_rescale_rnd(min_ts, time_base.den,
2482 time_base.num * (int64_t)AV_TIME_BASE,
2483 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2484 max_ts = av_rescale_rnd(max_ts, time_base.den,
2485 time_base.num * (int64_t)AV_TIME_BASE,
2486 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2490 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2494 ret = avformat_queue_attached_pictures(s);
2498 if (s->iformat->read_timestamp) {
2499 // try to seek via read_timestamp()
2502 // Fall back on old API if new is not implemented but old is.
2503 // Note the old API has somewhat different semantics.
2504 if (s->iformat->read_seek || 1) {
2505 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2506 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2507 if (ret<0 && ts != min_ts && max_ts != ts) {
2508 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2510 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2515 // try some generic seek like seek_frame_generic() but with new ts semantics
2516 return -1; //unreachable
2519 int avformat_flush(AVFormatContext *s)
2521 ff_read_frame_flush(s);
2525 /*******************************************************/
2528 * Return TRUE if the stream has accurate duration in any stream.
2530 * @return TRUE if the stream has accurate duration for at least one component.
2532 static int has_duration(AVFormatContext *ic)
2537 for (i = 0; i < ic->nb_streams; i++) {
2538 st = ic->streams[i];
2539 if (st->duration != AV_NOPTS_VALUE)
2542 if (ic->duration != AV_NOPTS_VALUE)
2548 * Estimate the stream timings from the one of each components.
2550 * Also computes the global bitrate if possible.
2552 static void update_stream_timings(AVFormatContext *ic)
2554 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2555 int64_t duration, duration1, filesize;
2560 start_time = INT64_MAX;
2561 start_time_text = INT64_MAX;
2562 end_time = INT64_MIN;
2563 end_time_text = INT64_MIN;
2564 duration = INT64_MIN;
2565 for (i = 0; i < ic->nb_streams; i++) {
2566 st = ic->streams[i];
2567 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2568 start_time1 = av_rescale_q(st->start_time, st->time_base,
2570 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2571 if (start_time1 < start_time_text)
2572 start_time_text = start_time1;
2574 start_time = FFMIN(start_time, start_time1);
2575 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2577 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2578 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2579 end_time1 += start_time1;
2580 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2581 end_time_text = FFMAX(end_time_text, end_time1);
2583 end_time = FFMAX(end_time, end_time1);
2585 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2586 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2587 p->start_time = start_time1;
2588 if (p->end_time < end_time1)
2589 p->end_time = end_time1;
2592 if (st->duration != AV_NOPTS_VALUE) {
2593 duration1 = av_rescale_q(st->duration, st->time_base,
2595 duration = FFMAX(duration, duration1);
2598 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2599 start_time = start_time_text;
2600 else if (start_time > start_time_text)
2601 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2603 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2604 end_time = end_time_text;
2605 } else if (end_time < end_time_text) {
2606 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2609 if (start_time != INT64_MAX) {
2610 ic->start_time = start_time;
2611 if (end_time != INT64_MIN) {
2612 if (ic->nb_programs > 1) {
2613 for (i = 0; i < ic->nb_programs; i++) {
2614 p = ic->programs[i];
2615 if (p->start_time != AV_NOPTS_VALUE &&
2616 p->end_time > p->start_time &&
2617 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2618 duration = FFMAX(duration, p->end_time - p->start_time);
2620 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2621 duration = FFMAX(duration, end_time - start_time);
2625 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2626 ic->duration = duration;
2628 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2629 /* compute the bitrate */
2630 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2631 (double) ic->duration;
2632 if (bitrate >= 0 && bitrate <= INT64_MAX)
2633 ic->bit_rate = bitrate;
2637 static void fill_all_stream_timings(AVFormatContext *ic)
2642 update_stream_timings(ic);
2643 for (i = 0; i < ic->nb_streams; i++) {
2644 st = ic->streams[i];
2645 if (st->start_time == AV_NOPTS_VALUE) {
2646 if (ic->start_time != AV_NOPTS_VALUE)
2647 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2649 if (ic->duration != AV_NOPTS_VALUE)
2650 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2656 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2658 int64_t filesize, duration;
2659 int i, show_warning = 0;
2662 /* if bit_rate is already set, we believe it */
2663 if (ic->bit_rate <= 0) {
2664 int64_t bit_rate = 0;
2665 for (i = 0; i < ic->nb_streams; i++) {
2666 st = ic->streams[i];
2667 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2668 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2669 if (st->codecpar->bit_rate > 0) {
2670 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2674 bit_rate += st->codecpar->bit_rate;
2675 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2676 // If we have a videostream with packets but without a bitrate
2677 // then consider the sum not known
2682 ic->bit_rate = bit_rate;
2685 /* if duration is already set, we believe it */
2686 if (ic->duration == AV_NOPTS_VALUE &&
2687 ic->bit_rate != 0) {
2688 filesize = ic->pb ? avio_size(ic->pb) : 0;
2689 if (filesize > ic->internal->data_offset) {
2690 filesize -= ic->internal->data_offset;
2691 for (i = 0; i < ic->nb_streams; i++) {
2692 st = ic->streams[i];
2693 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2694 && st->duration == AV_NOPTS_VALUE) {
2695 duration = av_rescale(8 * filesize, st->time_base.den,
2697 (int64_t) st->time_base.num);
2698 st->duration = duration;
2705 av_log(ic, AV_LOG_WARNING,
2706 "Estimating duration from bitrate, this may be inaccurate\n");
2709 #define DURATION_MAX_READ_SIZE 250000LL
2710 #define DURATION_MAX_RETRY 6
2712 /* only usable for MPEG-PS streams */
2713 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2715 AVPacket pkt1, *pkt = &pkt1;
2717 int num, den, read_size, i, ret;
2718 int found_duration = 0;
2720 int64_t filesize, offset, duration;
2723 /* flush packet queue */
2724 flush_packet_queue(ic);
2726 for (i = 0; i < ic->nb_streams; i++) {
2727 st = ic->streams[i];
2728 if (st->start_time == AV_NOPTS_VALUE &&
2729 st->first_dts == AV_NOPTS_VALUE &&
2730 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2731 av_log(ic, AV_LOG_WARNING,
2732 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2735 av_parser_close(st->parser);
2740 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2741 /* estimate the end time (duration) */
2742 /* XXX: may need to support wrapping */
2743 filesize = ic->pb ? avio_size(ic->pb) : 0;
2745 is_end = found_duration;
2746 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2750 avio_seek(ic->pb, offset, SEEK_SET);
2753 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2757 ret = ff_read_packet(ic, pkt);
2758 } while (ret == AVERROR(EAGAIN));
2761 read_size += pkt->size;
2762 st = ic->streams[pkt->stream_index];
2763 if (pkt->pts != AV_NOPTS_VALUE &&
2764 (st->start_time != AV_NOPTS_VALUE ||
2765 st->first_dts != AV_NOPTS_VALUE)) {
2766 if (pkt->duration == 0) {
2767 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2769 pkt->duration = av_rescale_rnd(1,
2770 num * (int64_t) st->time_base.den,
2771 den * (int64_t) st->time_base.num,
2775 duration = pkt->pts + pkt->duration;
2777 if (st->start_time != AV_NOPTS_VALUE)
2778 duration -= st->start_time;
2780 duration -= st->first_dts;
2782 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2783 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2784 st->duration = duration;
2785 st->info->last_duration = duration;
2788 av_packet_unref(pkt);
2791 /* check if all audio/video streams have valid duration */
2794 for (i = 0; i < ic->nb_streams; i++) {
2795 st = ic->streams[i];
2796 switch (st->codecpar->codec_type) {
2797 case AVMEDIA_TYPE_VIDEO:
2798 case AVMEDIA_TYPE_AUDIO:
2799 if (st->duration == AV_NOPTS_VALUE)
2806 ++retry <= DURATION_MAX_RETRY);
2808 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2810 /* warn about audio/video streams which duration could not be estimated */
2811 for (i = 0; i < ic->nb_streams; i++) {
2812 st = ic->streams[i];
2813 if (st->duration == AV_NOPTS_VALUE) {
2814 switch (st->codecpar->codec_type) {
2815 case AVMEDIA_TYPE_VIDEO:
2816 case AVMEDIA_TYPE_AUDIO:
2817 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2818 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2820 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2824 fill_all_stream_timings(ic);
2826 avio_seek(ic->pb, old_offset, SEEK_SET);
2827 for (i = 0; i < ic->nb_streams; i++) {
2830 st = ic->streams[i];
2831 st->cur_dts = st->first_dts;
2832 st->last_IP_pts = AV_NOPTS_VALUE;
2833 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2834 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2835 st->pts_buffer[j] = AV_NOPTS_VALUE;
2839 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2843 /* get the file size, if possible */
2844 if (ic->iformat->flags & AVFMT_NOFILE) {
2847 file_size = avio_size(ic->pb);
2848 file_size = FFMAX(0, file_size);
2851 if ((!strcmp(ic->iformat->name, "mpeg") ||
2852 !strcmp(ic->iformat->name, "mpegts")) &&
2853 file_size && ic->pb->seekable) {
2854 /* get accurate estimate from the PTSes */
2855 estimate_timings_from_pts(ic, old_offset);
2856 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2857 } else if (has_duration(ic)) {
2858 /* at least one component has timings - we use them for all
2860 fill_all_stream_timings(ic);
2861 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2863 /* less precise: use bitrate info */
2864 estimate_timings_from_bit_rate(ic);
2865 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2867 update_stream_timings(ic);
2871 AVStream av_unused *st;
2872 for (i = 0; i < ic->nb_streams; i++) {
2873 st = ic->streams[i];
2874 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2875 (double) st->start_time * av_q2d(st->time_base),
2876 (double) st->duration * av_q2d(st->time_base));
2878 av_log(ic, AV_LOG_TRACE,
2879 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2880 (double) ic->start_time / AV_TIME_BASE,
2881 (double) ic->duration / AV_TIME_BASE,
2882 (int64_t)ic->bit_rate / 1000);
2886 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2888 AVCodecContext *avctx = st->internal->avctx;
2890 #define FAIL(errmsg) do { \
2892 *errmsg_ptr = errmsg; \
2896 if ( avctx->codec_id == AV_CODEC_ID_NONE
2897 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2898 FAIL("unknown codec");
2899 switch (avctx->codec_type) {
2900 case AVMEDIA_TYPE_AUDIO:
2901 if (!avctx->frame_size && determinable_frame_size(avctx))
2902 FAIL("unspecified frame size");
2903 if (st->info->found_decoder >= 0 &&
2904 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2905 FAIL("unspecified sample format");
2906 if (!avctx->sample_rate)
2907 FAIL("unspecified sample rate");
2908 if (!avctx->channels)
2909 FAIL("unspecified number of channels");
2910 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2911 FAIL("no decodable DTS frames");
2913 case AVMEDIA_TYPE_VIDEO:
2915 FAIL("unspecified size");
2916 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2917 FAIL("unspecified pixel format");
2918 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2919 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2920 FAIL("no frame in rv30/40 and no sar");
2922 case AVMEDIA_TYPE_SUBTITLE:
2923 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2924 FAIL("unspecified size");
2926 case AVMEDIA_TYPE_DATA:
2927 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2933 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2934 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2935 AVDictionary **options)
2937 AVCodecContext *avctx = st->internal->avctx;
2938 const AVCodec *codec;
2939 int got_picture = 1, ret = 0;
2940 AVFrame *frame = av_frame_alloc();
2941 AVSubtitle subtitle;
2942 AVPacket pkt = *avpkt;
2943 int do_skip_frame = 0;
2944 enum AVDiscard skip_frame;
2947 return AVERROR(ENOMEM);
2949 if (!avcodec_is_open(avctx) &&
2950 st->info->found_decoder <= 0 &&
2951 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2952 AVDictionary *thread_opt = NULL;
2954 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2957 st->info->found_decoder = -st->codecpar->codec_id;
2962 /* Force thread count to 1 since the H.264 decoder will not extract
2963 * SPS and PPS to extradata during multi-threaded decoding. */
2964 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2965 if (s->codec_whitelist)
2966 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2967 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2969 av_dict_free(&thread_opt);
2971 st->info->found_decoder = -avctx->codec_id;
2974 st->info->found_decoder = 1;
2975 } else if (!st->info->found_decoder)
2976 st->info->found_decoder = 1;
2978 if (st->info->found_decoder < 0) {
2983 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2985 skip_frame = avctx->skip_frame;
2986 avctx->skip_frame = AVDISCARD_ALL;
2989 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2991 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2992 (!st->codec_info_nb_frames &&
2993 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2995 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2996 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2997 ret = avcodec_send_packet(avctx, &pkt);
2998 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3002 ret = avcodec_receive_frame(avctx, frame);
3005 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3007 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3008 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3009 &got_picture, &pkt);
3015 st->nb_decoded_frames++;
3020 if (!pkt.data && !got_picture)
3024 if (do_skip_frame) {
3025 avctx->skip_frame = skip_frame;
3028 av_frame_free(&frame);
3032 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3034 while (tags->id != AV_CODEC_ID_NONE) {
3042 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3045 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3046 if (tag == tags[i].tag)
3048 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3049 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3051 return AV_CODEC_ID_NONE;
3054 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3056 if (bps <= 0 || bps > 64)
3057 return AV_CODEC_ID_NONE;
3062 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3064 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3066 return AV_CODEC_ID_NONE;
3071 if (sflags & (1 << (bps - 1))) {
3074 return AV_CODEC_ID_PCM_S8;
3076 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3078 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3080 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3082 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3084 return AV_CODEC_ID_NONE;
3089 return AV_CODEC_ID_PCM_U8;
3091 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3093 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3095 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3097 return AV_CODEC_ID_NONE;
3103 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3106 if (!av_codec_get_tag2(tags, id, &tag))
3111 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3115 for (i = 0; tags && tags[i]; i++) {
3116 const AVCodecTag *codec_tags = tags[i];
3117 while (codec_tags->id != AV_CODEC_ID_NONE) {
3118 if (codec_tags->id == id) {
3119 *tag = codec_tags->tag;
3128 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3131 for (i = 0; tags && tags[i]; i++) {
3132 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3133 if (id != AV_CODEC_ID_NONE)
3136 return AV_CODEC_ID_NONE;
3139 static void compute_chapters_end(AVFormatContext *s)
3142 int64_t max_time = 0;
3144 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3145 max_time = s->duration +
3146 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3148 for (i = 0; i < s->nb_chapters; i++)
3149 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3150 AVChapter *ch = s->chapters[i];
3151 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3155 for (j = 0; j < s->nb_chapters; j++) {
3156 AVChapter *ch1 = s->chapters[j];
3157 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3159 if (j != i && next_start > ch->start && next_start < end)
3162 ch->end = (end == INT64_MAX) ? ch->start : end;
3166 static int get_std_framerate(int i)
3169 return (i + 1) * 1001;
3173 return (i + 31) * 1001 * 12;
3177 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3181 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3184 /* Is the time base unreliable?
3185 * This is a heuristic to balance between quick acceptance of the values in
3186 * the headers vs. some extra checks.
3187 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3188 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3189 * And there are "variable" fps files this needs to detect as well. */
3190 static int tb_unreliable(AVCodecContext *c)
3192 if (c->time_base.den >= 101LL * c->time_base.num ||
3193 c->time_base.den < 5LL * c->time_base.num ||
3194 // c->codec_tag == AV_RL32("DIVX") ||
3195 // c->codec_tag == AV_RL32("XVID") ||
3196 c->codec_tag == AV_RL32("mp4v") ||
3197 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3198 c->codec_id == AV_CODEC_ID_GIF ||
3199 c->codec_id == AV_CODEC_ID_HEVC ||
3200 c->codec_id == AV_CODEC_ID_H264)
3205 int ff_alloc_extradata(AVCodecParameters *par, int size)
3209 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3210 par->extradata = NULL;
3211 par->extradata_size = 0;
3212 return AVERROR(EINVAL);
3214 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3215 if (par->extradata) {
3216 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3217 par->extradata_size = size;
3220 par->extradata_size = 0;
3221 ret = AVERROR(ENOMEM);
3226 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3228 int ret = ff_alloc_extradata(par, size);
3231 ret = avio_read(pb, par->extradata, size);
3233 av_freep(&par->extradata);
3234 par->extradata_size = 0;
3235 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3236 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3242 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3245 int64_t last = st->info->last_dts;
3247 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3248 && ts - (uint64_t)last < INT64_MAX) {
3249 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3250 int64_t duration = ts - last;
3252 if (!st->info->duration_error)
3253 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3254 if (!st->info->duration_error)
3255 return AVERROR(ENOMEM);
3257 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3258 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3259 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3260 if (st->info->duration_error[0][1][i] < 1e10) {
3261 int framerate = get_std_framerate(i);
3262 double sdts = dts*framerate/(1001*12);
3263 for (j= 0; j<2; j++) {
3264 int64_t ticks = llrint(sdts+j*0.5);
3265 double error= sdts - ticks + j*0.5;
3266 st->info->duration_error[j][0][i] += error;
3267 st->info->duration_error[j][1][i] += error*error;
3271 st->info->duration_count++;
3272 st->info->rfps_duration_sum += duration;
3274 if (st->info->duration_count % 10 == 0) {
3275 int n = st->info->duration_count;
3276 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3277 if (st->info->duration_error[0][1][i] < 1e10) {
3278 double a0 = st->info->duration_error[0][0][i] / n;
3279 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3280 double a1 = st->info->duration_error[1][0][i] / n;
3281 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3282 if (error0 > 0.04 && error1 > 0.04) {
3283 st->info->duration_error[0][1][i] = 2e10;
3284 st->info->duration_error[1][1][i] = 2e10;
3290 // ignore the first 4 values, they might have some random jitter
3291 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3292 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3294 if (ts != AV_NOPTS_VALUE)
3295 st->info->last_dts = ts;
3300 void ff_rfps_calculate(AVFormatContext *ic)
3304 for (i = 0; i < ic->nb_streams; i++) {
3305 AVStream *st = ic->streams[i];
3307 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3309 // the check for tb_unreliable() is not completely correct, since this is not about handling
3310 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3311 // ipmovie.c produces.
3312 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)
3313 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);
3314 if (st->info->duration_count>1 && !st->r_frame_rate.num
3315 && tb_unreliable(st->internal->avctx)) {
3317 double best_error= 0.01;
3318 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3320 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3323 if (st->info->codec_info_duration &&
3324 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3326 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3329 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3332 for (k= 0; k<2; k++) {
3333 int n = st->info->duration_count;
3334 double a= st->info->duration_error[k][0][j] / n;
3335 double error= st->info->duration_error[k][1][j]/n - a*a;
3337 if (error < best_error && best_error> 0.000000001) {
3339 num = get_std_framerate(j);
3342 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3345 // do not increase frame rate by more than 1 % in order to match a standard rate.
3346 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3347 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3349 if ( !st->avg_frame_rate.num
3350 && st->r_frame_rate.num && st->info->rfps_duration_sum
3351 && st->info->codec_info_duration <= 0
3352 && st->info->duration_count > 2
3353 && 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
3355 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3356 st->avg_frame_rate = st->r_frame_rate;
3359 av_freep(&st->info->duration_error);
3360 st->info->last_dts = AV_NOPTS_VALUE;
3361 st->info->duration_count = 0;
3362 st->info->rfps_duration_sum = 0;
3366 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3368 int i, count = 0, ret = 0, j;
3371 AVCodecContext *avctx;
3372 AVPacket pkt1, *pkt;
3373 int64_t old_offset = avio_tell(ic->pb);
3374 // new streams might appear, no options for those
3375 int orig_nb_streams = ic->nb_streams;
3377 int64_t max_analyze_duration = ic->max_analyze_duration;
3378 int64_t max_stream_analyze_duration;
3379 int64_t max_subtitle_analyze_duration;
3380 int64_t probesize = ic->probesize;
3381 int eof_reached = 0;
3382 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3384 flush_codecs = probesize > 0;
3386 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3388 max_stream_analyze_duration = max_analyze_duration;
3389 max_subtitle_analyze_duration = max_analyze_duration;
3390 if (!max_analyze_duration) {
3391 max_stream_analyze_duration =
3392 max_analyze_duration = 5*AV_TIME_BASE;
3393 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3394 if (!strcmp(ic->iformat->name, "flv"))
3395 max_stream_analyze_duration = 90*AV_TIME_BASE;
3396 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3397 max_stream_analyze_duration = 7*AV_TIME_BASE;
3401 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3402 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3404 for (i = 0; i < ic->nb_streams; i++) {
3405 const AVCodec *codec;
3406 AVDictionary *thread_opt = NULL;
3407 st = ic->streams[i];
3408 avctx = st->internal->avctx;
3410 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3411 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3412 /* if (!st->time_base.num)
3414 if (!avctx->time_base.num)
3415 avctx->time_base = st->time_base;
3418 /* check if the caller has overridden the codec id */
3419 #if FF_API_LAVF_AVCTX
3420 FF_DISABLE_DEPRECATION_WARNINGS
3421 if (st->codec->codec_id != st->internal->orig_codec_id) {
3422 st->codecpar->codec_id = st->codec->codec_id;
3423 st->codecpar->codec_type = st->codec->codec_type;
3424 st->internal->orig_codec_id = st->codec->codec_id;
3426 FF_ENABLE_DEPRECATION_WARNINGS
3428 // only for the split stuff
3429 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3430 st->parser = av_parser_init(st->codecpar->codec_id);
3432 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3433 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3434 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3435 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3437 } else if (st->need_parsing) {
3438 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3439 "%s, packets or times may be invalid.\n",
3440 avcodec_get_name(st->codecpar->codec_id));
3444 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3445 st->internal->orig_codec_id = st->codecpar->codec_id;
3447 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3449 goto find_stream_info_err;
3450 if (st->request_probe <= 0)
3451 st->internal->avctx_inited = 1;
3453 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3455 /* Force thread count to 1 since the H.264 decoder will not extract
3456 * SPS and PPS to extradata during multi-threaded decoding. */
3457 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3459 if (ic->codec_whitelist)
3460 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3462 /* Ensure that subtitle_header is properly set. */
3463 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3464 && codec && !avctx->codec) {
3465 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3466 av_log(ic, AV_LOG_WARNING,
3467 "Failed to open codec in %s\n",__FUNCTION__);
3470 // Try to just open decoders, in case this is enough to get parameters.
3471 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3472 if (codec && !avctx->codec)
3473 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3474 av_log(ic, AV_LOG_WARNING,
3475 "Failed to open codec in %s\n",__FUNCTION__);
3478 av_dict_free(&thread_opt);
3481 for (i = 0; i < ic->nb_streams; i++) {
3482 #if FF_API_R_FRAME_RATE
3483 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3485 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3486 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3491 int analyzed_all_streams;
3492 if (ff_check_interrupt(&ic->interrupt_callback)) {
3494 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3498 /* check if one codec still needs to be handled */
3499 for (i = 0; i < ic->nb_streams; i++) {
3500 int fps_analyze_framecount = 20;
3502 st = ic->streams[i];
3503 if (!has_codec_parameters(st, NULL))
3505 /* If the timebase is coarse (like the usual millisecond precision
3506 * of mkv), we need to analyze more frames to reliably arrive at
3507 * the correct fps. */
3508 if (av_q2d(st->time_base) > 0.0005)
3509 fps_analyze_framecount *= 2;
3510 if (!tb_unreliable(st->internal->avctx))
3511 fps_analyze_framecount = 0;
3512 if (ic->fps_probe_size >= 0)
3513 fps_analyze_framecount = ic->fps_probe_size;
3514 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3515 fps_analyze_framecount = 0;
3516 /* variable fps and no guess at the real fps */
3517 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3518 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3519 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3520 st->info->codec_info_duration_fields/2 :
3521 st->info->duration_count;
3522 if (count < fps_analyze_framecount)
3525 if (st->parser && st->parser->parser->split &&
3526 !st->internal->avctx->extradata)
3528 if (st->first_dts == AV_NOPTS_VALUE &&
3529 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3530 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3531 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3532 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3535 analyzed_all_streams = 0;
3536 if (!missing_streams || !*missing_streams)
3537 if (i == ic->nb_streams) {
3538 analyzed_all_streams = 1;
3539 /* NOTE: If the format has no header, then we need to read some
3540 * packets to get most of the streams, so we cannot stop here. */
3541 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3542 /* If we found the info for all the codecs, we can stop. */
3544 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3549 /* We did not get all the codec info, but we read too much data. */
3550 if (read_size >= probesize) {
3552 av_log(ic, AV_LOG_DEBUG,
3553 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3554 for (i = 0; i < ic->nb_streams; i++)
3555 if (!ic->streams[i]->r_frame_rate.num &&
3556 ic->streams[i]->info->duration_count <= 1 &&
3557 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3558 strcmp(ic->iformat->name, "image2"))
3559 av_log(ic, AV_LOG_WARNING,
3560 "Stream #%d: not enough frames to estimate rate; "
3561 "consider increasing probesize\n", i);
3565 /* NOTE: A new stream can be added there if no header in file
3566 * (AVFMTCTX_NOHEADER). */
3567 ret = read_frame_internal(ic, &pkt1);
3568 if (ret == AVERROR(EAGAIN))
3579 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3580 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3581 &ic->internal->packet_buffer_end, 0);
3583 goto find_stream_info_err;
3586 st = ic->streams[pkt->stream_index];
3587 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3588 read_size += pkt->size;
3590 avctx = st->internal->avctx;
3591 if (!st->internal->avctx_inited) {
3592 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3594 goto find_stream_info_err;
3595 st->internal->avctx_inited = 1;
3598 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3599 /* check for non-increasing dts */
3600 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3601 st->info->fps_last_dts >= pkt->dts) {
3602 av_log(ic, AV_LOG_DEBUG,
3603 "Non-increasing DTS in stream %d: packet %d with DTS "
3604 "%"PRId64", packet %d with DTS %"PRId64"\n",
3605 st->index, st->info->fps_last_dts_idx,
3606 st->info->fps_last_dts, st->codec_info_nb_frames,
3608 st->info->fps_first_dts =
3609 st->info->fps_last_dts = AV_NOPTS_VALUE;
3611 /* Check for a discontinuity in dts. If the difference in dts
3612 * is more than 1000 times the average packet duration in the
3613 * sequence, we treat it as a discontinuity. */
3614 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3615 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3616 (pkt->dts - st->info->fps_last_dts) / 1000 >
3617 (st->info->fps_last_dts - st->info->fps_first_dts) /
3618 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3619 av_log(ic, AV_LOG_WARNING,
3620 "DTS discontinuity in stream %d: packet %d with DTS "
3621 "%"PRId64", packet %d with DTS %"PRId64"\n",
3622 st->index, st->info->fps_last_dts_idx,
3623 st->info->fps_last_dts, st->codec_info_nb_frames,
3625 st->info->fps_first_dts =
3626 st->info->fps_last_dts = AV_NOPTS_VALUE;
3629 /* update stored dts values */
3630 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3631 st->info->fps_first_dts = pkt->dts;
3632 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3634 st->info->fps_last_dts = pkt->dts;
3635 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3637 if (st->codec_info_nb_frames>1) {
3641 if (st->time_base.den > 0)
3642 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3643 if (st->avg_frame_rate.num > 0)
3644 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3647 && st->codec_info_nb_frames>30
3648 && st->info->fps_first_dts != AV_NOPTS_VALUE
3649 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3650 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3652 if (analyzed_all_streams) limit = max_analyze_duration;
3653 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3654 else limit = max_stream_analyze_duration;
3657 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3659 t, pkt->stream_index);
3660 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3661 av_packet_unref(pkt);
3664 if (pkt->duration) {
3665 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3666 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3668 st->info->codec_info_duration += pkt->duration;
3669 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3672 #if FF_API_R_FRAME_RATE
3673 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3674 ff_rfps_add_frame(ic, st, pkt->dts);
3676 if (st->parser && st->parser->parser->split && !avctx->extradata) {
3677 int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
3678 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3679 avctx->extradata_size = i;
3680 avctx->extradata = av_mallocz(avctx->extradata_size +
3681 AV_INPUT_BUFFER_PADDING_SIZE);
3682 if (!avctx->extradata)
3683 return AVERROR(ENOMEM);
3684 memcpy(avctx->extradata, pkt->data,
3685 avctx->extradata_size);
3689 /* If still no information, we try to open the codec and to
3690 * decompress the frame. We try to avoid that in most cases as
3691 * it takes longer and uses more memory. For MPEG-4, we need to
3692 * decompress for QuickTime.
3694 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3695 * least one frame of codec data, this makes sure the codec initializes
3696 * the channel configuration and does not only trust the values from
3698 try_decode_frame(ic, st, pkt,
3699 (options && i < orig_nb_streams) ? &options[i] : NULL);
3701 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3702 av_packet_unref(pkt);
3704 st->codec_info_nb_frames++;
3710 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3711 st = ic->streams[stream_index];
3712 avctx = st->internal->avctx;
3713 if (!has_codec_parameters(st, NULL)) {
3714 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3715 if (codec && !avctx->codec) {
3716 AVDictionary *opts = NULL;
3717 if (ic->codec_whitelist)
3718 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3719 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3720 av_log(ic, AV_LOG_WARNING,
3721 "Failed to open codec in %s\n",__FUNCTION__);
3722 av_dict_free(&opts);
3726 // EOF already reached while reading the stream above.
3727 // So continue with reoordering DTS with whatever delay we have.
3728 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3729 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3735 AVPacket empty_pkt = { 0 };
3737 av_init_packet(&empty_pkt);
3739 for (i = 0; i < ic->nb_streams; i++) {
3741 st = ic->streams[i];
3743 /* flush the decoders */
3744 if (st->info->found_decoder == 1) {
3746 err = try_decode_frame(ic, st, &empty_pkt,
3747 (options && i < orig_nb_streams)
3748 ? &options[i] : NULL);
3749 } while (err > 0 && !has_codec_parameters(st, NULL));
3752 av_log(ic, AV_LOG_INFO,
3753 "decoding for stream %d failed\n", st->index);
3759 // close codecs which were opened in try_decode_frame()
3760 for (i = 0; i < ic->nb_streams; i++) {
3761 st = ic->streams[i];
3762 avcodec_close(st->internal->avctx);
3765 ff_rfps_calculate(ic);
3767 for (i = 0; i < ic->nb_streams; i++) {
3768 st = ic->streams[i];
3769 avctx = st->internal->avctx;
3770 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3771 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3772 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3773 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3774 avctx->codec_tag= tag;
3777 /* estimate average framerate if not set by demuxer */
3778 if (st->info->codec_info_duration_fields &&
3779 !st->avg_frame_rate.num &&
3780 st->info->codec_info_duration) {
3782 double best_error = 0.01;
3784 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3785 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3786 st->info->codec_info_duration < 0)
3788 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3789 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3790 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3792 /* Round guessed framerate to a "standard" framerate if it's
3793 * within 1% of the original estimate. */
3794 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3795 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3796 double error = fabs(av_q2d(st->avg_frame_rate) /
3797 av_q2d(std_fps) - 1);
3799 if (error < best_error) {
3801 best_fps = std_fps.num;
3805 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3806 best_fps, 12 * 1001, INT_MAX);
3809 if (!st->r_frame_rate.num) {
3810 if ( avctx->time_base.den * (int64_t) st->time_base.num
3811 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3812 st->r_frame_rate.num = avctx->time_base.den;
3813 st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
3815 st->r_frame_rate.num = st->time_base.den;
3816 st->r_frame_rate.den = st->time_base.num;
3819 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3820 AVRational hw_ratio = { avctx->height, avctx->width };
3821 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3824 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3825 if (!avctx->bits_per_coded_sample)
3826 avctx->bits_per_coded_sample =
3827 av_get_bits_per_sample(avctx->codec_id);
3828 // set stream disposition based on audio service type
3829 switch (avctx->audio_service_type) {
3830 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3831 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3833 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3834 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3836 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3837 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3839 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3840 st->disposition = AV_DISPOSITION_COMMENT;
3842 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3843 st->disposition = AV_DISPOSITION_KARAOKE;
3850 estimate_timings(ic, old_offset);
3852 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3854 if (ret >= 0 && ic->nb_streams)
3855 /* We could not have all the codec parameters before EOF. */
3857 for (i = 0; i < ic->nb_streams; i++) {
3859 st = ic->streams[i];
3861 /* if no packet was ever seen, update context now for has_codec_parameters */
3862 if (!st->internal->avctx_inited) {
3863 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3864 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3865 st->codecpar->format = st->internal->avctx->sample_fmt;
3866 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3868 goto find_stream_info_err;
3870 if (!has_codec_parameters(st, &errmsg)) {
3872 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
3873 av_log(ic, AV_LOG_WARNING,
3874 "Could not find codec parameters for stream %d (%s): %s\n"
3875 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3882 compute_chapters_end(ic);
3884 /* update the stream parameters from the internal codec contexts */
3885 for (i = 0; i < ic->nb_streams; i++) {
3886 st = ic->streams[i];
3888 if (st->internal->avctx_inited) {
3889 int orig_w = st->codecpar->width;
3890 int orig_h = st->codecpar->height;
3891 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
3893 goto find_stream_info_err;
3894 // The decoder might reduce the video size by the lowres factor.
3895 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
3896 st->codecpar->width = orig_w;
3897 st->codecpar->height = orig_h;
3901 #if FF_API_LAVF_AVCTX
3902 FF_DISABLE_DEPRECATION_WARNINGS
3903 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
3905 goto find_stream_info_err;
3907 // The old API (AVStream.codec) "requires" the resolution to be adjusted
3908 // by the lowres factor.
3909 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
3910 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
3911 st->codec->width = st->internal->avctx->width;
3912 st->codec->height = st->internal->avctx->height;
3915 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
3916 st->codec->time_base = st->internal->avctx->time_base;
3917 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
3919 st->codec->framerate = st->avg_frame_rate;
3921 if (st->internal->avctx->subtitle_header) {
3922 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
3923 if (!st->codec->subtitle_header)
3924 goto find_stream_info_err;
3925 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
3926 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
3927 st->codec->subtitle_header_size);
3930 // Fields unavailable in AVCodecParameters
3931 st->codec->coded_width = st->internal->avctx->coded_width;
3932 st->codec->coded_height = st->internal->avctx->coded_height;
3933 st->codec->properties = st->internal->avctx->properties;
3934 FF_ENABLE_DEPRECATION_WARNINGS
3937 st->internal->avctx_inited = 0;
3940 find_stream_info_err:
3941 for (i = 0; i < ic->nb_streams; i++) {
3942 st = ic->streams[i];
3944 av_freep(&st->info->duration_error);
3945 av_freep(&ic->streams[i]->info);
3948 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3949 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3953 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3957 for (i = 0; i < ic->nb_programs; i++) {
3958 if (ic->programs[i] == last) {
3962 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3963 if (ic->programs[i]->stream_index[j] == s)
3964 return ic->programs[i];
3970 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3971 int wanted_stream_nb, int related_stream,
3972 AVCodec **decoder_ret, int flags)
3974 int i, nb_streams = ic->nb_streams;
3975 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3976 unsigned *program = NULL;
3977 const AVCodec *decoder = NULL, *best_decoder = NULL;
3979 if (related_stream >= 0 && wanted_stream_nb < 0) {
3980 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3982 program = p->stream_index;
3983 nb_streams = p->nb_stream_indexes;
3986 for (i = 0; i < nb_streams; i++) {
3987 int real_stream_index = program ? program[i] : i;
3988 AVStream *st = ic->streams[real_stream_index];
3989 AVCodecParameters *par = st->codecpar;
3990 if (par->codec_type != type)
3992 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3994 if (wanted_stream_nb != real_stream_index &&
3995 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3996 AV_DISPOSITION_VISUAL_IMPAIRED))
3998 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4001 decoder = find_decoder(ic, st, par->codec_id);
4004 ret = AVERROR_DECODER_NOT_FOUND;
4008 count = st->codec_info_nb_frames;
4009 bitrate = par->bit_rate;
4010 multiframe = FFMIN(5, count);
4011 if ((best_multiframe > multiframe) ||
4012 (best_multiframe == multiframe && best_bitrate > bitrate) ||
4013 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4016 best_bitrate = bitrate;
4017 best_multiframe = multiframe;
4018 ret = real_stream_index;
4019 best_decoder = decoder;
4020 if (program && i == nb_streams - 1 && ret < 0) {
4022 nb_streams = ic->nb_streams;
4023 /* no related stream found, try again with everything */
4028 *decoder_ret = (AVCodec*)best_decoder;
4032 /*******************************************************/
4034 int av_read_play(AVFormatContext *s)
4036 if (s->iformat->read_play)
4037 return s->iformat->read_play(s);
4039 return avio_pause(s->pb, 0);
4040 return AVERROR(ENOSYS);
4043 int av_read_pause(AVFormatContext *s)
4045 if (s->iformat->read_pause)
4046 return s->iformat->read_pause(s);
4048 return avio_pause(s->pb, 1);
4049 return AVERROR(ENOSYS);
4052 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4057 dst->time_base = src->time_base;
4058 dst->nb_frames = src->nb_frames;
4059 dst->disposition = src->disposition;
4060 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4061 dst->avg_frame_rate = src->avg_frame_rate;
4062 dst->r_frame_rate = src->r_frame_rate;
4064 av_dict_free(&dst->metadata);
4065 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4069 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4073 /* Free existing side data*/
4074 for (i = 0; i < dst->nb_side_data; i++)
4075 av_free(dst->side_data[i].data);
4076 av_freep(&dst->side_data);
4077 dst->nb_side_data = 0;
4079 /* Copy side data if present */
4080 if (src->nb_side_data) {
4081 dst->side_data = av_mallocz_array(src->nb_side_data,
4082 sizeof(AVPacketSideData));
4083 if (!dst->side_data)
4084 return AVERROR(ENOMEM);
4085 dst->nb_side_data = src->nb_side_data;
4087 for (i = 0; i < src->nb_side_data; i++) {
4088 uint8_t *data = av_memdup(src->side_data[i].data,
4089 src->side_data[i].size);
4091 return AVERROR(ENOMEM);
4092 dst->side_data[i].type = src->side_data[i].type;
4093 dst->side_data[i].size = src->side_data[i].size;
4094 dst->side_data[i].data = data;
4098 av_freep(&dst->recommended_encoder_configuration);
4099 if (src->recommended_encoder_configuration) {
4100 const char *conf_str = src->recommended_encoder_configuration;
4101 dst->recommended_encoder_configuration = av_strdup(conf_str);
4102 if (!dst->recommended_encoder_configuration)
4103 return AVERROR(ENOMEM);
4109 static void free_stream(AVStream **pst)
4111 AVStream *st = *pst;
4117 for (i = 0; i < st->nb_side_data; i++)
4118 av_freep(&st->side_data[i].data);
4119 av_freep(&st->side_data);
4122 av_parser_close(st->parser);
4124 if (st->attached_pic.data)
4125 av_packet_unref(&st->attached_pic);
4128 avcodec_free_context(&st->internal->avctx);
4129 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4130 av_bsf_free(&st->internal->bsfcs[i]);
4131 av_freep(&st->internal->bsfcs);
4134 av_freep(&st->internal);
4136 av_dict_free(&st->metadata);
4137 avcodec_parameters_free(&st->codecpar);
4138 av_freep(&st->probe_data.buf);
4139 av_freep(&st->index_entries);
4140 #if FF_API_LAVF_AVCTX
4141 FF_DISABLE_DEPRECATION_WARNINGS
4142 av_freep(&st->codec->extradata);
4143 av_freep(&st->codec->subtitle_header);
4144 av_freep(&st->codec);
4145 FF_ENABLE_DEPRECATION_WARNINGS
4147 av_freep(&st->priv_data);
4149 av_freep(&st->info->duration_error);
4150 av_freep(&st->info);
4151 av_freep(&st->recommended_encoder_configuration);
4152 av_freep(&st->priv_pts);
4157 void ff_free_stream(AVFormatContext *s, AVStream *st)
4159 av_assert0(s->nb_streams>0);
4160 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4162 free_stream(&s->streams[ --s->nb_streams ]);
4165 void avformat_free_context(AVFormatContext *s)
4173 if (s->iformat && s->iformat->priv_class && s->priv_data)
4174 av_opt_free(s->priv_data);
4175 if (s->oformat && s->oformat->priv_class && s->priv_data)
4176 av_opt_free(s->priv_data);
4178 for (i = s->nb_streams - 1; i >= 0; i--)
4179 ff_free_stream(s, s->streams[i]);
4182 for (i = s->nb_programs - 1; i >= 0; i--) {
4183 av_dict_free(&s->programs[i]->metadata);
4184 av_freep(&s->programs[i]->stream_index);
4185 av_freep(&s->programs[i]);
4187 av_freep(&s->programs);
4188 av_freep(&s->priv_data);
4189 while (s->nb_chapters--) {
4190 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4191 av_freep(&s->chapters[s->nb_chapters]);
4193 av_freep(&s->chapters);
4194 av_dict_free(&s->metadata);
4195 av_dict_free(&s->internal->id3v2_meta);
4196 av_freep(&s->streams);
4197 av_freep(&s->internal);
4198 flush_packet_queue(s);
4202 void avformat_close_input(AVFormatContext **ps)
4213 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4214 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4217 flush_packet_queue(s);
4220 if (s->iformat->read_close)
4221 s->iformat->read_close(s);
4223 avformat_free_context(s);
4230 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4236 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4237 if (s->max_streams < INT_MAX/sizeof(*streams))
4238 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4241 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4244 s->streams = streams;
4246 st = av_mallocz(sizeof(AVStream));
4249 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4253 st->info->last_dts = AV_NOPTS_VALUE;
4255 #if FF_API_LAVF_AVCTX
4256 FF_DISABLE_DEPRECATION_WARNINGS
4257 st->codec = avcodec_alloc_context3(c);
4263 FF_ENABLE_DEPRECATION_WARNINGS
4266 st->internal = av_mallocz(sizeof(*st->internal));
4270 st->codecpar = avcodec_parameters_alloc();
4274 st->internal->avctx = avcodec_alloc_context3(NULL);
4275 if (!st->internal->avctx)
4279 #if FF_API_LAVF_AVCTX
4280 FF_DISABLE_DEPRECATION_WARNINGS
4281 /* no default bitrate if decoding */
4282 st->codec->bit_rate = 0;
4283 FF_ENABLE_DEPRECATION_WARNINGS
4286 /* default pts setting is MPEG-like */
4287 avpriv_set_pts_info(st, 33, 1, 90000);
4288 /* we set the current DTS to 0 so that formats without any timestamps
4289 * but durations get some timestamps, formats with some unknown
4290 * timestamps have their first few packets buffered and the
4291 * timestamps corrected before they are returned to the user */
4292 st->cur_dts = RELATIVE_TS_BASE;
4294 st->cur_dts = AV_NOPTS_VALUE;
4297 st->index = s->nb_streams;
4298 st->start_time = AV_NOPTS_VALUE;
4299 st->duration = AV_NOPTS_VALUE;
4300 st->first_dts = AV_NOPTS_VALUE;
4301 st->probe_packets = MAX_PROBE_PACKETS;
4302 st->pts_wrap_reference = AV_NOPTS_VALUE;
4303 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4305 st->last_IP_pts = AV_NOPTS_VALUE;
4306 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4307 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4308 st->pts_buffer[i] = AV_NOPTS_VALUE;
4310 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4312 #if FF_API_R_FRAME_RATE
4313 st->info->last_dts = AV_NOPTS_VALUE;
4315 st->info->fps_first_dts = AV_NOPTS_VALUE;
4316 st->info->fps_last_dts = AV_NOPTS_VALUE;
4318 st->inject_global_side_data = s->internal->inject_global_side_data;
4320 st->internal->need_context_update = 1;
4322 s->streams[s->nb_streams++] = st;
4329 AVProgram *av_new_program(AVFormatContext *ac, int id)
4331 AVProgram *program = NULL;
4334 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4336 for (i = 0; i < ac->nb_programs; i++)
4337 if (ac->programs[i]->id == id)
4338 program = ac->programs[i];
4341 program = av_mallocz(sizeof(AVProgram));
4344 dynarray_add(&ac->programs, &ac->nb_programs, program);
4345 program->discard = AVDISCARD_NONE;
4348 program->pts_wrap_reference = AV_NOPTS_VALUE;
4349 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4351 program->start_time =
4352 program->end_time = AV_NOPTS_VALUE;
4357 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4358 int64_t start, int64_t end, const char *title)
4360 AVChapter *chapter = NULL;
4363 if (end != AV_NOPTS_VALUE && start > end) {
4364 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4368 for (i = 0; i < s->nb_chapters; i++)
4369 if (s->chapters[i]->id == id)
4370 chapter = s->chapters[i];
4373 chapter = av_mallocz(sizeof(AVChapter));
4376 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4378 av_dict_set(&chapter->metadata, "title", title, 0);
4380 chapter->time_base = time_base;
4381 chapter->start = start;
4387 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4390 AVProgram *program = NULL;
4393 if (idx >= ac->nb_streams) {
4394 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4398 for (i = 0; i < ac->nb_programs; i++) {
4399 if (ac->programs[i]->id != progid)
4401 program = ac->programs[i];
4402 for (j = 0; j < program->nb_stream_indexes; j++)
4403 if (program->stream_index[j] == idx)
4406 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4409 program->stream_index = tmp;
4410 program->stream_index[program->nb_stream_indexes++] = idx;
4415 uint64_t ff_ntp_time(void)
4417 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4420 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4423 char *q, buf1[20], c;
4424 int nd, len, percentd_found;
4436 while (av_isdigit(*p))
4437 nd = nd * 10 + *p++ - '0';
4439 } while (av_isdigit(c));
4445 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4450 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4452 if ((q - buf + len) > buf_size - 1)
4454 memcpy(q, buf1, len);
4462 if ((q - buf) < buf_size - 1)
4466 if (!percentd_found)
4475 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4477 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4480 void av_url_split(char *proto, int proto_size,
4481 char *authorization, int authorization_size,
4482 char *hostname, int hostname_size,
4483 int *port_ptr, char *path, int path_size, const char *url)
4485 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4491 if (authorization_size > 0)
4492 authorization[0] = 0;
4493 if (hostname_size > 0)
4498 /* parse protocol */
4499 if ((p = strchr(url, ':'))) {
4500 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4507 /* no protocol means plain filename */
4508 av_strlcpy(path, url, path_size);
4512 /* separate path from hostname */
4513 ls = strchr(p, '/');
4514 ls2 = strchr(p, '?');
4518 ls = FFMIN(ls, ls2);
4520 av_strlcpy(path, ls, path_size);
4522 ls = &p[strlen(p)]; // XXX
4524 /* the rest is hostname, use that to parse auth/port */
4526 /* authorization (user[:pass]@hostname) */
4528 while ((at = strchr(p, '@')) && at < ls) {
4529 av_strlcpy(authorization, at2,
4530 FFMIN(authorization_size, at + 1 - at2));
4531 p = at + 1; /* skip '@' */
4534 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4536 av_strlcpy(hostname, p + 1,
4537 FFMIN(hostname_size, brk - p));
4538 if (brk[1] == ':' && port_ptr)
4539 *port_ptr = atoi(brk + 2);
4540 } else if ((col = strchr(p, ':')) && col < ls) {
4541 av_strlcpy(hostname, p,
4542 FFMIN(col + 1 - p, hostname_size));
4544 *port_ptr = atoi(col + 1);
4546 av_strlcpy(hostname, p,
4547 FFMIN(ls + 1 - p, hostname_size));
4551 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4554 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4557 'C', 'D', 'E', 'F' };
4558 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4561 'c', 'd', 'e', 'f' };
4562 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4564 for (i = 0; i < s; i++) {
4565 buff[i * 2] = hex_table[src[i] >> 4];
4566 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4572 int ff_hex_to_data(uint8_t *data, const char *p)
4579 p += strspn(p, SPACE_CHARS);
4582 c = av_toupper((unsigned char) *p++);
4583 if (c >= '0' && c <= '9')
4585 else if (c >= 'A' && c <= 'F')
4600 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4601 unsigned int pts_num, unsigned int pts_den)
4604 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4605 if (new_tb.num != pts_num)
4606 av_log(NULL, AV_LOG_DEBUG,
4607 "st:%d removing common factor %d from timebase\n",
4608 s->index, pts_num / new_tb.num);
4610 av_log(NULL, AV_LOG_WARNING,
4611 "st:%d has too large timebase, reducing\n", s->index);
4613 if (new_tb.num <= 0 || new_tb.den <= 0) {
4614 av_log(NULL, AV_LOG_ERROR,
4615 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4616 new_tb.num, new_tb.den,
4620 s->time_base = new_tb;
4621 #if FF_API_LAVF_AVCTX
4622 FF_DISABLE_DEPRECATION_WARNINGS
4623 av_codec_set_pkt_timebase(s->codec, new_tb);
4624 FF_ENABLE_DEPRECATION_WARNINGS
4626 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4627 s->pts_wrap_bits = pts_wrap_bits;
4630 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4633 const char *ptr = str;
4635 /* Parse key=value pairs. */
4638 char *dest = NULL, *dest_end;
4639 int key_len, dest_len = 0;
4641 /* Skip whitespace and potential commas. */
4642 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4649 if (!(ptr = strchr(key, '=')))
4652 key_len = ptr - key;
4654 callback_get_buf(context, key, key_len, &dest, &dest_len);
4655 dest_end = dest + dest_len - 1;
4659 while (*ptr && *ptr != '\"') {
4663 if (dest && dest < dest_end)
4667 if (dest && dest < dest_end)
4675 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4676 if (dest && dest < dest_end)
4684 int ff_find_stream_index(AVFormatContext *s, int id)
4687 for (i = 0; i < s->nb_streams; i++)
4688 if (s->streams[i]->id == id)
4693 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4697 unsigned int codec_tag;
4698 if (ofmt->query_codec)
4699 return ofmt->query_codec(codec_id, std_compliance);
4700 else if (ofmt->codec_tag)
4701 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4702 else if (codec_id == ofmt->video_codec ||
4703 codec_id == ofmt->audio_codec ||
4704 codec_id == ofmt->subtitle_codec ||
4705 codec_id == ofmt->data_codec)
4708 return AVERROR_PATCHWELCOME;
4711 int avformat_network_init(void)
4715 ff_network_inited_globally = 1;
4716 if ((ret = ff_network_init()) < 0)
4718 if ((ret = ff_tls_init()) < 0)
4724 int avformat_network_deinit(void)
4729 ff_network_inited_globally = 0;
4734 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4735 uint64_t channel_layout, int32_t sample_rate,
4736 int32_t width, int32_t height)
4742 return AVERROR(EINVAL);
4745 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4747 if (channel_layout) {
4749 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4753 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4755 if (width || height) {
4757 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4759 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4761 return AVERROR(ENOMEM);
4762 bytestream_put_le32(&data, flags);
4764 bytestream_put_le32(&data, channels);
4766 bytestream_put_le64(&data, channel_layout);
4768 bytestream_put_le32(&data, sample_rate);
4769 if (width || height) {
4770 bytestream_put_le32(&data, width);
4771 bytestream_put_le32(&data, height);
4776 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4778 AVRational undef = {0, 1};
4779 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4780 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4781 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4783 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4784 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4785 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4786 stream_sample_aspect_ratio = undef;
4788 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4789 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4790 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4791 frame_sample_aspect_ratio = undef;
4793 if (stream_sample_aspect_ratio.num)
4794 return stream_sample_aspect_ratio;
4796 return frame_sample_aspect_ratio;
4799 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4801 AVRational fr = st->r_frame_rate;
4802 AVRational codec_fr = st->internal->avctx->framerate;
4803 AVRational avg_fr = st->avg_frame_rate;
4805 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4806 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4811 if (st->internal->avctx->ticks_per_frame > 1) {
4812 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4813 (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
4820 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4823 if (*spec <= '9' && *spec >= '0') /* opt:index */
4824 return strtol(spec, NULL, 0) == st->index;
4825 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4826 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4827 enum AVMediaType type;
4831 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4832 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4833 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4834 case 'd': type = AVMEDIA_TYPE_DATA; break;
4835 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4836 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4837 default: av_assert0(0);
4839 #if FF_API_LAVF_AVCTX
4840 FF_DISABLE_DEPRECATION_WARNINGS
4841 if (type != st->codecpar->codec_type
4842 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4844 FF_ENABLE_DEPRECATION_WARNINGS
4846 if (type != st->codecpar->codec_type)
4849 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4851 if (*spec++ == ':') { /* possibly followed by :index */
4852 int i, index = strtol(spec, NULL, 0);
4853 for (i = 0; i < s->nb_streams; i++) {
4854 #if FF_API_LAVF_AVCTX
4855 FF_DISABLE_DEPRECATION_WARNINGS
4856 if ((s->streams[i]->codecpar->codec_type == type
4857 || s->streams[i]->codec->codec_type == type
4859 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4861 return i == st->index;
4862 FF_ENABLE_DEPRECATION_WARNINGS
4864 if ((s->streams[i]->codecpar->codec_type == type) &&
4865 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4867 return i == st->index;
4873 } else if (*spec == 'p' && *(spec + 1) == ':') {
4877 prog_id = strtol(spec, &endptr, 0);
4878 for (i = 0; i < s->nb_programs; i++) {
4879 if (s->programs[i]->id != prog_id)
4882 if (*endptr++ == ':') {
4883 int stream_idx = strtol(endptr, NULL, 0);
4884 return stream_idx >= 0 &&
4885 stream_idx < s->programs[i]->nb_stream_indexes &&
4886 st->index == s->programs[i]->stream_index[stream_idx];
4889 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4890 if (st->index == s->programs[i]->stream_index[j])
4894 } else if (*spec == '#' ||
4895 (*spec == 'i' && *(spec + 1) == ':')) {
4898 spec += 1 + (*spec == 'i');
4899 stream_id = strtol(spec, &endptr, 0);
4901 return stream_id == st->id;
4902 } else if (*spec == 'm' && *(spec + 1) == ':') {
4903 AVDictionaryEntry *tag;
4908 val = strchr(spec, ':');
4910 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4912 return AVERROR(ENOMEM);
4914 tag = av_dict_get(st->metadata, key, NULL, 0);
4916 if (!val || !strcmp(tag->value, val + 1))
4925 } else if (*spec == 'u') {
4926 AVCodecParameters *par = st->codecpar;
4927 #if FF_API_LAVF_AVCTX
4928 FF_DISABLE_DEPRECATION_WARNINGS
4929 AVCodecContext *codec = st->codec;
4930 FF_ENABLE_DEPRECATION_WARNINGS
4933 switch (par->codec_type) {
4934 case AVMEDIA_TYPE_AUDIO:
4935 val = par->sample_rate && par->channels;
4936 #if FF_API_LAVF_AVCTX
4937 val = val || (codec->sample_rate && codec->channels);
4939 if (par->format == AV_SAMPLE_FMT_NONE
4940 #if FF_API_LAVF_AVCTX
4941 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
4946 case AVMEDIA_TYPE_VIDEO:
4947 val = par->width && par->height;
4948 #if FF_API_LAVF_AVCTX
4949 val = val || (codec->width && codec->height);
4951 if (par->format == AV_PIX_FMT_NONE
4952 #if FF_API_LAVF_AVCTX
4953 && codec->pix_fmt == AV_PIX_FMT_NONE
4958 case AVMEDIA_TYPE_UNKNOWN:
4965 #if FF_API_LAVF_AVCTX
4966 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
4968 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
4970 } else if (!*spec) /* empty specifier, matches everything */
4973 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4974 return AVERROR(EINVAL);
4977 int ff_generate_avci_extradata(AVStream *st)
4979 static const uint8_t avci100_1080p_extradata[] = {
4981 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4982 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4983 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4984 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4985 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4986 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4987 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4988 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4989 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4991 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4994 static const uint8_t avci100_1080i_extradata[] = {
4996 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4997 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4998 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4999 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5000 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5001 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5002 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5003 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5004 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5005 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5006 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5008 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5011 static const uint8_t avci50_1080p_extradata[] = {
5013 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5014 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5015 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5016 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5017 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5018 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5019 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5020 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5021 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5023 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5026 static const uint8_t avci50_1080i_extradata[] = {
5028 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5029 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5030 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5031 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5032 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5033 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5034 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5035 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5036 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5037 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5038 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5040 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5043 static const uint8_t avci100_720p_extradata[] = {
5045 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5046 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5047 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5048 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5049 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5050 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5051 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5052 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5053 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5054 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5056 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5059 static const uint8_t avci50_720p_extradata[] = {
5061 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5062 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5063 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5064 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5065 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5066 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5067 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5068 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5069 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5071 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5075 const uint8_t *data = NULL;
5078 if (st->codecpar->width == 1920) {
5079 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5080 data = avci100_1080p_extradata;
5081 size = sizeof(avci100_1080p_extradata);
5083 data = avci100_1080i_extradata;
5084 size = sizeof(avci100_1080i_extradata);
5086 } else if (st->codecpar->width == 1440) {
5087 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5088 data = avci50_1080p_extradata;
5089 size = sizeof(avci50_1080p_extradata);
5091 data = avci50_1080i_extradata;
5092 size = sizeof(avci50_1080i_extradata);
5094 } else if (st->codecpar->width == 1280) {
5095 data = avci100_720p_extradata;
5096 size = sizeof(avci100_720p_extradata);
5097 } else if (st->codecpar->width == 960) {
5098 data = avci50_720p_extradata;
5099 size = sizeof(avci50_720p_extradata);
5105 av_freep(&st->codecpar->extradata);
5106 if (ff_alloc_extradata(st->codecpar, size))
5107 return AVERROR(ENOMEM);
5108 memcpy(st->codecpar->extradata, data, size);
5113 #if FF_API_NOCONST_GET_SIDE_DATA
5114 uint8_t *av_stream_get_side_data(AVStream *st,
5115 enum AVPacketSideDataType type, int *size)
5117 uint8_t *av_stream_get_side_data(const AVStream *st,
5118 enum AVPacketSideDataType type, int *size)
5123 for (i = 0; i < st->nb_side_data; i++) {
5124 if (st->side_data[i].type == type) {
5126 *size = st->side_data[i].size;
5127 return st->side_data[i].data;
5133 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5134 uint8_t *data, size_t size)
5136 AVPacketSideData *sd, *tmp;
5139 for (i = 0; i < st->nb_side_data; i++) {
5140 sd = &st->side_data[i];
5142 if (sd->type == type) {
5143 av_freep(&sd->data);
5150 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5151 return AVERROR(ERANGE);
5153 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5155 return AVERROR(ENOMEM);
5158 st->side_data = tmp;
5161 sd = &st->side_data[st->nb_side_data - 1];
5169 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5173 uint8_t *data = av_malloc(size);
5178 ret = av_stream_add_side_data(st, type, data, size);
5187 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5190 const AVBitStreamFilter *bsf;
5192 AVCodecParameters *in_par;
5194 if (!(bsf = av_bsf_get_by_name(name))) {
5195 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5196 return AVERROR_BSF_NOT_FOUND;
5199 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5202 if (st->internal->nb_bsfcs) {
5203 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5204 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5206 in_par = st->codecpar;
5207 bsfc->time_base_in = st->time_base;
5210 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5215 if (args && bsfc->filter->priv_class) {
5216 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5217 const char * shorthand[2] = {NULL};
5220 shorthand[0] = opt->name;
5222 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5228 if ((ret = av_bsf_init(bsfc)) < 0) {
5233 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5238 av_log(NULL, AV_LOG_VERBOSE,
5239 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5240 name, args ? args : "");
5245 FF_DISABLE_DEPRECATION_WARNINGS
5246 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5247 AVBitStreamFilterContext *bsfc)
5251 AVPacket new_pkt = *pkt;
5252 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5253 &new_pkt.data, &new_pkt.size,
5254 pkt->data, pkt->size,
5255 pkt->flags & AV_PKT_FLAG_KEY);
5256 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5257 av_packet_unref(pkt);
5258 memset(pkt, 0, sizeof(*pkt));
5261 if(a == 0 && new_pkt.data != pkt->data) {
5262 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5264 memcpy(t, new_pkt.data, new_pkt.size);
5265 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5270 a = AVERROR(ENOMEM);
5274 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5275 av_buffer_default_free, NULL, 0);
5277 pkt->side_data = NULL;
5278 pkt->side_data_elems = 0;
5279 av_packet_unref(pkt);
5281 av_freep(&new_pkt.data);
5282 a = AVERROR(ENOMEM);
5286 av_log(codec, AV_LOG_ERROR,
5287 "Failed to open bitstream filter %s for stream %d with codec %s",
5288 bsfc->filter->name, pkt->stream_index,
5289 codec->codec ? codec->codec->name : "copy");
5299 FF_ENABLE_DEPRECATION_WARNINGS
5302 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5305 return AVERROR(EINVAL);
5307 if (!(s->oformat->flags & AVFMT_NOFILE))
5308 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5312 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5315 s->io_close(s, *pb);
5319 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5321 AVDictionaryEntry *entry;
5322 int64_t parsed_timestamp;
5324 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5325 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5326 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5329 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5336 int ff_standardize_creation_time(AVFormatContext *s)
5339 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5341 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5345 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5350 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5352 if (size != AVPALETTE_SIZE) {
5353 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5354 return AVERROR_INVALIDDATA;
5356 memcpy(palette, side_data, AVPALETTE_SIZE);
5360 if (ret == CONTAINS_PAL) {
5362 for (i = 0; i < AVPALETTE_COUNT; i++)
5363 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5370 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5375 ret = av_bprint_finalize(buf, &str);
5378 if (!av_bprint_is_complete(buf)) {
5380 return AVERROR(ENOMEM);
5383 par->extradata = str;
5384 /* Note: the string is NUL terminated (so extradata can be read as a
5385 * string), but the ending character is not accounted in the size (in
5386 * binary formats you are likely not supposed to mux that character). When
5387 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5389 par->extradata_size = buf->len;
5393 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5394 AVStream *ost, const AVStream *ist,
5395 enum AVTimebaseSource copy_tb)
5397 //TODO: use [io]st->internal->avctx
5398 const AVCodecContext *dec_ctx = ist->codec;
5399 AVCodecContext *enc_ctx = ost->codec;
5401 enc_ctx->time_base = ist->time_base;
5403 * Avi is a special case here because it supports variable fps but
5404 * having the fps and timebase differe significantly adds quite some
5407 if (!strcmp(ofmt->name, "avi")) {
5408 #if FF_API_R_FRAME_RATE
5409 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5410 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5411 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5412 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5413 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5414 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5415 enc_ctx->time_base.num = ist->r_frame_rate.den;
5416 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5417 enc_ctx->ticks_per_frame = 2;
5420 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5421 && av_q2d(ist->time_base) < 1.0/500
5422 || copy_tb == AVFMT_TBCF_DECODER) {
5423 enc_ctx->time_base = dec_ctx->time_base;
5424 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5425 enc_ctx->time_base.den *= 2;
5426 enc_ctx->ticks_per_frame = 2;
5428 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5429 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5430 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5431 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5432 && av_q2d(ist->time_base) < 1.0/500
5433 || copy_tb == AVFMT_TBCF_DECODER) {
5434 enc_ctx->time_base = dec_ctx->time_base;
5435 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5439 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5440 && dec_ctx->time_base.num < dec_ctx->time_base.den
5441 && dec_ctx->time_base.num > 0
5442 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5443 enc_ctx->time_base = dec_ctx->time_base;
5446 if (ost->avg_frame_rate.num)
5447 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5449 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5450 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5455 AVRational av_stream_get_codec_timebase(const AVStream *st)
5457 // See avformat_transfer_internal_stream_timing_info() TODO.
5458 #if FF_API_LAVF_AVCTX
5459 FF_DISABLE_DEPRECATION_WARNINGS
5460 return st->codec->time_base;
5461 FF_ENABLE_DEPRECATION_WARNINGS
5463 return st->internal->avctx->time_base;