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
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/packet_internal.h"
41 #include "libavcodec/raw.h"
44 #include "avio_internal.h"
52 #include "libavutil/ffversion.h"
53 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
55 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
59 * various utility functions for use within FFmpeg
62 unsigned avformat_version(void)
64 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
65 return LIBAVFORMAT_VERSION_INT;
68 const char *avformat_configuration(void)
70 return FFMPEG_CONFIGURATION;
73 const char *avformat_license(void)
75 #define LICENSE_PREFIX "libavformat license: "
76 return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
79 int ff_lock_avformat(void)
81 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
84 int ff_unlock_avformat(void)
86 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
89 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
91 static int is_relative(int64_t ts) {
92 return ts > (RELATIVE_TS_BASE - (1LL<<48));
96 * Wrap a given time stamp, if there is an indication for an overflow
99 * @param timestamp the time stamp to wrap
100 * @return resulting time stamp
102 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
104 if (st->internal->pts_wrap_behavior != AV_PTS_WRAP_IGNORE && st->pts_wrap_bits < 64 &&
105 st->internal->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
106 if (st->internal->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
107 timestamp < st->internal->pts_wrap_reference)
108 return timestamp + (1ULL << st->pts_wrap_bits);
109 else if (st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
110 timestamp >= st->internal->pts_wrap_reference)
111 return timestamp - (1ULL << st->pts_wrap_bits);
116 #if FF_API_FORMAT_GET_SET
117 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
118 #if FF_API_LAVF_FFSERVER
119 FF_DISABLE_DEPRECATION_WARNINGS
120 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
121 FF_ENABLE_DEPRECATION_WARNINGS
123 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
124 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
125 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
126 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
127 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
128 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
129 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
130 #if FF_API_OLD_OPEN_CALLBACKS
131 FF_DISABLE_DEPRECATION_WARNINGS
132 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
133 FF_ENABLE_DEPRECATION_WARNINGS
137 int64_t av_stream_get_end_pts(const AVStream *st)
139 if (st->internal->priv_pts) {
140 return st->internal->priv_pts->val;
142 return AV_NOPTS_VALUE;
145 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
150 void av_format_inject_global_side_data(AVFormatContext *s)
153 s->internal->inject_global_side_data = 1;
154 for (i = 0; i < s->nb_streams; i++) {
155 AVStream *st = s->streams[i];
156 st->internal->inject_global_side_data = 1;
160 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
162 av_assert0(!dst->codec_whitelist &&
163 !dst->format_whitelist &&
164 !dst->protocol_whitelist &&
165 !dst->protocol_blacklist);
166 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
167 dst->format_whitelist = av_strdup(src->format_whitelist);
168 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
169 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
170 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
171 || (src-> format_whitelist && !dst-> format_whitelist)
172 || (src->protocol_whitelist && !dst->protocol_whitelist)
173 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
174 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
175 return AVERROR(ENOMEM);
180 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
182 #if FF_API_LAVF_AVCTX
183 FF_DISABLE_DEPRECATION_WARNINGS
184 if (st->codec->codec)
185 return st->codec->codec;
186 FF_ENABLE_DEPRECATION_WARNINGS
189 switch (st->codecpar->codec_type) {
190 case AVMEDIA_TYPE_VIDEO:
191 if (s->video_codec) return s->video_codec;
193 case AVMEDIA_TYPE_AUDIO:
194 if (s->audio_codec) return s->audio_codec;
196 case AVMEDIA_TYPE_SUBTITLE:
197 if (s->subtitle_codec) return s->subtitle_codec;
201 return avcodec_find_decoder(codec_id);
204 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
206 const AVCodec *codec;
208 #if CONFIG_H264_DECODER
209 /* Other parts of the code assume this decoder to be used for h264,
210 * so force it if possible. */
211 if (codec_id == AV_CODEC_ID_H264)
212 return avcodec_find_decoder_by_name("h264");
215 codec = find_decoder(s, st, codec_id);
219 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
220 const AVCodec *probe_codec = NULL;
222 while ((probe_codec = av_codec_iterate(&iter))) {
223 if (probe_codec->id == codec->id &&
224 av_codec_is_decoder(probe_codec) &&
225 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
234 #if FF_API_FORMAT_GET_SET
235 int av_format_get_probe_score(const AVFormatContext *s)
237 return s->probe_score;
241 /* an arbitrarily chosen "sane" max packet size -- 50M */
242 #define SANE_CHUNK_SIZE (50000000)
244 int ffio_limit(AVIOContext *s, int size)
246 if (s->maxsize>= 0) {
247 int64_t pos = avio_tell(s);
248 int64_t remaining= s->maxsize - pos;
249 if (remaining < size) {
250 int64_t newsize = avio_size(s);
251 if (!s->maxsize || s->maxsize<newsize)
252 s->maxsize = newsize - !newsize;
253 if (pos > s->maxsize && s->maxsize >= 0)
254 s->maxsize = AVERROR(EIO);
256 remaining = s->maxsize - pos;
259 if (s->maxsize >= 0 && remaining < size && size > 1) {
260 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG,
261 "Truncating packet of size %d to %"PRId64"\n",
262 size, remaining + !remaining);
263 size = remaining + !remaining;
269 /* Read the data in sane-sized chunks and append to pkt.
270 * Return the number of bytes read or an error. */
271 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
273 int orig_size = pkt->size;
277 int prev_size = pkt->size;
280 /* When the caller requests a lot of data, limit it to the amount
281 * left in file or SANE_CHUNK_SIZE when it is not known. */
283 if (read_size > SANE_CHUNK_SIZE/10) {
284 read_size = ffio_limit(s, read_size);
285 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
287 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
290 ret = av_grow_packet(pkt, read_size);
294 ret = avio_read(s, pkt->data + prev_size, read_size);
295 if (ret != read_size) {
296 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
303 pkt->flags |= AV_PKT_FLAG_CORRUPT;
306 av_packet_unref(pkt);
307 return pkt->size > orig_size ? pkt->size - orig_size : ret;
310 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
315 pkt->pos = avio_tell(s);
317 return append_packet_chunked(s, pkt, size);
320 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
323 return av_get_packet(s, pkt, size);
324 return append_packet_chunked(s, pkt, size);
327 int av_filename_number_test(const char *filename)
331 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
334 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
337 static const struct {
340 enum AVMediaType type;
342 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
343 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
344 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
345 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
346 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
347 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
348 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
349 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
350 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
351 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
352 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
353 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
354 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
355 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
356 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
360 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
364 av_log(s, AV_LOG_DEBUG,
365 "Probe with size=%d, packets=%d detected %s with score=%d\n",
366 pd->buf_size, s->max_probe_packets - st->probe_packets,
368 for (i = 0; fmt_id_type[i].name; i++) {
369 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
370 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
371 st->codecpar->sample_rate)
373 if (st->internal->request_probe > score &&
374 st->codecpar->codec_id != fmt_id_type[i].id)
376 st->codecpar->codec_id = fmt_id_type[i].id;
377 st->codecpar->codec_type = fmt_id_type[i].type;
378 st->internal->need_context_update = 1;
379 #if FF_API_LAVF_AVCTX
380 FF_DISABLE_DEPRECATION_WARNINGS
381 st->codec->codec_type = st->codecpar->codec_type;
382 st->codec->codec_id = st->codecpar->codec_id;
383 FF_ENABLE_DEPRECATION_WARNINGS
392 /************************************************************/
393 /* input media file */
395 int av_demuxer_open(AVFormatContext *ic) {
398 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
399 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
400 return AVERROR(EINVAL);
403 if (ic->iformat->read_header) {
404 err = ic->iformat->read_header(ic);
409 if (ic->pb && !ic->internal->data_offset)
410 ic->internal->data_offset = avio_tell(ic->pb);
415 /* Open input file and probe the format if necessary. */
416 static int init_input(AVFormatContext *s, const char *filename,
417 AVDictionary **options)
420 AVProbeData pd = { filename, NULL, 0 };
421 int score = AVPROBE_SCORE_RETRY;
424 s->flags |= AVFMT_FLAG_CUSTOM_IO;
426 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
427 s, 0, s->format_probesize);
428 else if (s->iformat->flags & AVFMT_NOFILE)
429 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
430 "will be ignored with AVFMT_NOFILE format.\n");
434 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
435 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
438 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
443 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
444 s, 0, s->format_probesize);
447 int avformat_queue_attached_pictures(AVFormatContext *s)
450 for (i = 0; i < s->nb_streams; i++)
451 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
452 s->streams[i]->discard < AVDISCARD_ALL) {
453 if (s->streams[i]->attached_pic.size <= 0) {
454 av_log(s, AV_LOG_WARNING,
455 "Attached picture on stream %d has invalid size, "
460 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
461 &s->internal->raw_packet_buffer_end,
462 &s->streams[i]->attached_pic,
470 static int update_stream_avctx(AVFormatContext *s)
473 for (i = 0; i < s->nb_streams; i++) {
474 AVStream *st = s->streams[i];
476 if (!st->internal->need_context_update)
479 /* close parser, because it depends on the codec */
480 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
481 av_parser_close(st->parser);
485 /* update internal codec context, for the parser */
486 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
490 #if FF_API_LAVF_AVCTX
491 FF_DISABLE_DEPRECATION_WARNINGS
492 /* update deprecated public codec context */
493 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
496 FF_ENABLE_DEPRECATION_WARNINGS
499 st->internal->need_context_update = 0;
505 int avformat_open_input(AVFormatContext **ps, const char *filename,
506 ff_const59 AVInputFormat *fmt, AVDictionary **options)
508 AVFormatContext *s = *ps;
510 AVDictionary *tmp = NULL;
511 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
513 if (!s && !(s = avformat_alloc_context()))
514 return AVERROR(ENOMEM);
516 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
517 return AVERROR(EINVAL);
523 av_dict_copy(&tmp, *options, 0);
525 if (s->pb) // must be before any goto fail
526 s->flags |= AVFMT_FLAG_CUSTOM_IO;
528 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
531 if (!(s->url = av_strdup(filename ? filename : ""))) {
532 ret = AVERROR(ENOMEM);
536 #if FF_API_FORMAT_FILENAME
537 FF_DISABLE_DEPRECATION_WARNINGS
538 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
539 FF_ENABLE_DEPRECATION_WARNINGS
541 if ((ret = init_input(s, filename, &tmp)) < 0)
543 s->probe_score = ret;
545 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
546 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
547 if (!s->protocol_whitelist) {
548 ret = AVERROR(ENOMEM);
553 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
554 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
555 if (!s->protocol_blacklist) {
556 ret = AVERROR(ENOMEM);
561 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
562 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
563 ret = AVERROR(EINVAL);
567 avio_skip(s->pb, s->skip_initial_bytes);
569 /* Check filename in case an image number is expected. */
570 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
571 if (!av_filename_number_test(filename)) {
572 ret = AVERROR(EINVAL);
577 s->duration = s->start_time = AV_NOPTS_VALUE;
579 /* Allocate private data. */
580 if (s->iformat->priv_data_size > 0) {
581 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
582 ret = AVERROR(ENOMEM);
585 if (s->iformat->priv_class) {
586 *(const AVClass **) s->priv_data = s->iformat->priv_class;
587 av_opt_set_defaults(s->priv_data);
588 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
593 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
595 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
598 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
599 if ((ret = s->iformat->read_header(s)) < 0)
603 s->metadata = s->internal->id3v2_meta;
604 s->internal->id3v2_meta = NULL;
605 } else if (s->internal->id3v2_meta) {
606 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
607 av_dict_free(&s->internal->id3v2_meta);
610 if (id3v2_extra_meta) {
611 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
612 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
613 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
615 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
617 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
620 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
622 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
624 if ((ret = avformat_queue_attached_pictures(s)) < 0)
627 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
628 s->internal->data_offset = avio_tell(s->pb);
630 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
632 update_stream_avctx(s);
634 for (i = 0; i < s->nb_streams; i++)
635 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
638 av_dict_free(options);
645 if (s->iformat->read_close)
646 s->iformat->read_close(s);
648 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
650 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
652 avformat_free_context(s);
657 /*******************************************************/
659 static void force_codec_ids(AVFormatContext *s, AVStream *st)
661 switch (st->codecpar->codec_type) {
662 case AVMEDIA_TYPE_VIDEO:
663 if (s->video_codec_id)
664 st->codecpar->codec_id = s->video_codec_id;
666 case AVMEDIA_TYPE_AUDIO:
667 if (s->audio_codec_id)
668 st->codecpar->codec_id = s->audio_codec_id;
670 case AVMEDIA_TYPE_SUBTITLE:
671 if (s->subtitle_codec_id)
672 st->codecpar->codec_id = s->subtitle_codec_id;
674 case AVMEDIA_TYPE_DATA:
675 if (s->data_codec_id)
676 st->codecpar->codec_id = s->data_codec_id;
681 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
683 if (st->internal->request_probe>0) {
684 AVProbeData *pd = &st->internal->probe_data;
686 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
690 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
692 av_log(s, AV_LOG_WARNING,
693 "Failed to reallocate probe buffer for stream %d\n",
698 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
699 pd->buf_size += pkt->size;
700 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
703 st->probe_packets = 0;
705 av_log(s, AV_LOG_WARNING,
706 "nothing to probe for stream %d\n", st->index);
710 end= s->internal->raw_packet_buffer_remaining_size <= 0
711 || st->probe_packets<= 0;
713 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
714 int score = set_codec_from_probe_data(s, st, pd);
715 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
719 st->internal->request_probe = -1;
720 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
721 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
723 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
725 force_codec_ids(s, st);
731 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
733 int64_t ref = pkt->dts;
734 int i, pts_wrap_behavior;
735 int64_t pts_wrap_reference;
736 AVProgram *first_program;
738 if (ref == AV_NOPTS_VALUE)
740 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
742 ref &= (1LL << st->pts_wrap_bits)-1;
744 // reference time stamp should be 60 s before first time stamp
745 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
746 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
747 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
748 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
749 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
751 first_program = av_find_program_from_stream(s, NULL, stream_index);
753 if (!first_program) {
754 int default_stream_index = av_find_default_stream_index(s);
755 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
756 for (i = 0; i < s->nb_streams; i++) {
757 if (av_find_program_from_stream(s, NULL, i))
759 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
760 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
764 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
765 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
769 AVProgram *program = first_program;
771 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
772 pts_wrap_reference = program->pts_wrap_reference;
773 pts_wrap_behavior = program->pts_wrap_behavior;
776 program = av_find_program_from_stream(s, program, stream_index);
779 // update every program with differing pts_wrap_reference
780 program = first_program;
782 if (program->pts_wrap_reference != pts_wrap_reference) {
783 for (i = 0; i<program->nb_stream_indexes; i++) {
784 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
785 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
788 program->pts_wrap_reference = pts_wrap_reference;
789 program->pts_wrap_behavior = pts_wrap_behavior;
791 program = av_find_program_from_stream(s, program, stream_index);
797 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
807 AVPacketList *pktl = s->internal->raw_packet_buffer;
808 const AVPacket *pkt1;
811 st = s->streams[pktl->pkt.stream_index];
812 if (s->internal->raw_packet_buffer_remaining_size <= 0)
813 if ((err = probe_codec(s, st, NULL)) < 0)
815 if (st->internal->request_probe <= 0) {
816 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
817 &s->internal->raw_packet_buffer_end, pkt);
818 s->internal->raw_packet_buffer_remaining_size += pkt->size;
823 ret = s->iformat->read_packet(s, pkt);
825 av_packet_unref(pkt);
827 /* Some demuxers return FFERROR_REDO when they consume
828 data and discard it (ignored streams, junk, extradata).
829 We must re-call the demuxer to get the real packet. */
830 if (ret == FFERROR_REDO)
832 if (!pktl || ret == AVERROR(EAGAIN))
834 for (i = 0; i < s->nb_streams; i++) {
836 if (st->probe_packets || st->internal->request_probe > 0)
837 if ((err = probe_codec(s, st, NULL)) < 0)
839 av_assert0(st->internal->request_probe <= 0);
844 err = av_packet_make_refcounted(pkt);
846 av_packet_unref(pkt);
850 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
851 av_log(s, AV_LOG_WARNING,
852 "Packet corrupt (stream = %d, dts = %s)",
853 pkt->stream_index, av_ts2str(pkt->dts));
854 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
855 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
856 av_packet_unref(pkt);
859 av_log(s, AV_LOG_WARNING, ".\n");
862 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
863 "Invalid stream index.\n");
865 st = s->streams[pkt->stream_index];
867 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
868 // correct first time stamps to negative values
869 if (!is_relative(st->first_dts))
870 st->first_dts = wrap_timestamp(st, st->first_dts);
871 if (!is_relative(st->start_time))
872 st->start_time = wrap_timestamp(st, st->start_time);
873 if (!is_relative(st->cur_dts))
874 st->cur_dts = wrap_timestamp(st, st->cur_dts);
877 pkt->dts = wrap_timestamp(st, pkt->dts);
878 pkt->pts = wrap_timestamp(st, pkt->pts);
880 force_codec_ids(s, st);
882 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
883 if (s->use_wallclock_as_timestamps)
884 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
886 if (!pktl && st->internal->request_probe <= 0)
889 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
890 &s->internal->raw_packet_buffer_end,
893 av_packet_unref(pkt);
896 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
897 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
899 if ((err = probe_codec(s, st, pkt1)) < 0)
905 /**********************************************************/
907 static int determinable_frame_size(AVCodecContext *avctx)
909 switch(avctx->codec_id) {
910 case AV_CODEC_ID_MP1:
911 case AV_CODEC_ID_MP2:
912 case AV_CODEC_ID_MP3:
913 case AV_CODEC_ID_CODEC2:
921 * Return the frame duration in seconds. Return 0 if not available.
923 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
924 AVCodecParserContext *pc, AVPacket *pkt)
926 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
927 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
928 int frame_size, sample_rate;
930 #if FF_API_LAVF_AVCTX
931 FF_DISABLE_DEPRECATION_WARNINGS
932 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
933 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
934 FF_ENABLE_DEPRECATION_WARNINGS
939 switch (st->codecpar->codec_type) {
940 case AVMEDIA_TYPE_VIDEO:
941 if (st->r_frame_rate.num && !pc && s->iformat) {
942 *pnum = st->r_frame_rate.den;
943 *pden = st->r_frame_rate.num;
944 } else if (st->time_base.num * 1000LL > st->time_base.den) {
945 *pnum = st->time_base.num;
946 *pden = st->time_base.den;
947 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
948 av_assert0(st->internal->avctx->ticks_per_frame);
949 av_reduce(pnum, pden,
951 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
954 if (pc && pc->repeat_pict) {
955 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
956 av_reduce(pnum, pden,
957 (*pnum) * (1LL + pc->repeat_pict),
961 /* If this codec can be interlaced or progressive then we need
962 * a parser to compute duration of a packet. Thus if we have
963 * no parser in such case leave duration undefined. */
964 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
968 case AVMEDIA_TYPE_AUDIO:
969 if (st->internal->avctx_inited) {
970 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
971 sample_rate = st->internal->avctx->sample_rate;
973 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
974 sample_rate = st->codecpar->sample_rate;
976 if (frame_size <= 0 || sample_rate <= 0)
986 int ff_is_intra_only(enum AVCodecID id)
988 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
991 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
992 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
997 static int has_decode_delay_been_guessed(AVStream *st)
999 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1000 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1002 #if CONFIG_H264_DECODER
1003 if (st->internal->avctx->has_b_frames &&
1004 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1007 if (st->internal->avctx->has_b_frames<3)
1008 return st->internal->nb_decoded_frames >= 7;
1009 else if (st->internal->avctx->has_b_frames<4)
1010 return st->internal->nb_decoded_frames >= 18;
1012 return st->internal->nb_decoded_frames >= 20;
1015 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1019 if (pktl == s->internal->packet_buffer_end)
1020 return s->internal->parse_queue;
1024 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1025 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1026 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1029 int delay = st->internal->avctx->has_b_frames;
1032 if (dts == AV_NOPTS_VALUE) {
1033 int64_t best_score = INT64_MAX;
1034 for (i = 0; i<delay; i++) {
1035 if (st->internal->pts_reorder_error_count[i]) {
1036 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1037 if (score < best_score) {
1039 dts = pts_buffer[i];
1044 for (i = 0; i<delay; i++) {
1045 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1046 int64_t diff = FFABS(pts_buffer[i] - dts)
1047 + (uint64_t)st->internal->pts_reorder_error[i];
1048 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1049 st->internal->pts_reorder_error[i] = diff;
1050 st->internal->pts_reorder_error_count[i]++;
1051 if (st->internal->pts_reorder_error_count[i] > 250) {
1052 st->internal->pts_reorder_error[i] >>= 1;
1053 st->internal->pts_reorder_error_count[i] >>= 1;
1060 if (dts == AV_NOPTS_VALUE)
1061 dts = pts_buffer[0];
1067 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1068 * of the packets in a window.
1070 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1071 AVPacketList *pkt_buffer)
1073 AVStream *st = s->streams[stream_index];
1074 int delay = st->internal->avctx->has_b_frames;
1077 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1079 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1080 pts_buffer[i] = AV_NOPTS_VALUE;
1082 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1083 if (pkt_buffer->pkt.stream_index != stream_index)
1086 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1087 pts_buffer[0] = pkt_buffer->pkt.pts;
1088 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1089 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1091 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1096 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1097 int64_t dts, int64_t pts, AVPacket *pkt)
1099 AVStream *st = s->streams[stream_index];
1100 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1101 AVPacketList *pktl_it;
1105 if (st->first_dts != AV_NOPTS_VALUE ||
1106 dts == AV_NOPTS_VALUE ||
1107 st->cur_dts == AV_NOPTS_VALUE ||
1108 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1109 dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1113 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1115 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1117 if (is_relative(pts))
1120 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1121 if (pktl_it->pkt.stream_index != stream_index)
1123 if (is_relative(pktl_it->pkt.pts))
1124 pktl_it->pkt.pts += shift;
1126 if (is_relative(pktl_it->pkt.dts))
1127 pktl_it->pkt.dts += shift;
1129 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1130 st->start_time = pktl_it->pkt.pts;
1131 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1132 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->internal->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1136 if (has_decode_delay_been_guessed(st)) {
1137 update_dts_from_pts(s, stream_index, pktl);
1140 if (st->start_time == AV_NOPTS_VALUE) {
1141 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1142 st->start_time = pts;
1144 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1145 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->internal->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1149 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1150 int stream_index, int64_t duration)
1152 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1153 int64_t cur_dts = RELATIVE_TS_BASE;
1155 if (st->first_dts != AV_NOPTS_VALUE) {
1156 if (st->internal->update_initial_durations_done)
1158 st->internal->update_initial_durations_done = 1;
1159 cur_dts = st->first_dts;
1160 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1161 if (pktl->pkt.stream_index == stream_index) {
1162 if (pktl->pkt.pts != pktl->pkt.dts ||
1163 pktl->pkt.dts != AV_NOPTS_VALUE ||
1166 cur_dts -= duration;
1169 if (pktl && pktl->pkt.dts != st->first_dts) {
1170 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1171 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1175 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1178 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1179 st->first_dts = cur_dts;
1180 } else if (st->cur_dts != RELATIVE_TS_BASE)
1183 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1184 if (pktl->pkt.stream_index != stream_index)
1186 if ((pktl->pkt.pts == pktl->pkt.dts ||
1187 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1188 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1189 pktl->pkt.dts == st->first_dts ||
1190 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1191 !pktl->pkt.duration) {
1192 pktl->pkt.dts = cur_dts;
1193 if (!st->internal->avctx->has_b_frames)
1194 pktl->pkt.pts = cur_dts;
1195 pktl->pkt.duration = duration;
1198 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1201 st->cur_dts = cur_dts;
1204 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1205 AVCodecParserContext *pc, AVPacket *pkt,
1206 int64_t next_dts, int64_t next_pts)
1208 int num, den, presentation_delayed, delay, i;
1210 AVRational duration;
1211 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1212 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1214 if (s->flags & AVFMT_FLAG_NOFILLIN)
1217 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1218 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1219 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1220 st->internal->dts_ordered++;
1222 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1223 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1225 st->internal->last_dts_for_order_check);
1226 st->internal->dts_misordered++;
1228 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1229 st->internal->dts_ordered >>= 1;
1230 st->internal->dts_misordered >>= 1;
1234 st->internal->last_dts_for_order_check = pkt->dts;
1235 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1236 pkt->dts = AV_NOPTS_VALUE;
1239 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1240 pkt->dts = AV_NOPTS_VALUE;
1242 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1243 && !st->internal->avctx->has_b_frames)
1244 //FIXME Set low_delay = 0 when has_b_frames = 1
1245 st->internal->avctx->has_b_frames = 1;
1247 /* do we have a video B-frame ? */
1248 delay = st->internal->avctx->has_b_frames;
1249 presentation_delayed = 0;
1251 /* XXX: need has_b_frame, but cannot get it if the codec is
1252 * not initialized */
1254 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1255 presentation_delayed = 1;
1257 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1258 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << (st->pts_wrap_bits - 1)) &&
1259 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1260 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1261 pkt->dts -= 1LL << st->pts_wrap_bits;
1263 pkt->pts += 1LL << st->pts_wrap_bits;
1266 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1267 * We take the conservative approach and discard both.
1268 * Note: If this is misbehaving for an H.264 file, then possibly
1269 * presentation_delayed is not set correctly. */
1270 if (delay == 1 && pkt->dts == pkt->pts &&
1271 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1272 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1273 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1274 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1275 pkt->dts = AV_NOPTS_VALUE;
1278 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1279 if (pkt->duration <= 0) {
1280 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1282 duration = (AVRational) {num, den};
1283 pkt->duration = av_rescale_rnd(1,
1284 num * (int64_t) st->time_base.den,
1285 den * (int64_t) st->time_base.num,
1290 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1291 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1293 /* Correct timestamps with byte offset if demuxers only have timestamps
1294 * on packet boundaries */
1295 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1296 /* this will estimate bitrate based on this frame's duration and size */
1297 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1298 if (pkt->pts != AV_NOPTS_VALUE)
1300 if (pkt->dts != AV_NOPTS_VALUE)
1304 /* This may be redundant, but it should not hurt. */
1305 if (pkt->dts != AV_NOPTS_VALUE &&
1306 pkt->pts != AV_NOPTS_VALUE &&
1307 pkt->pts > pkt->dts)
1308 presentation_delayed = 1;
1310 if (s->debug & FF_FDEBUG_TS)
1311 av_log(s, AV_LOG_DEBUG,
1312 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1313 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1314 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1316 /* Interpolate PTS and DTS if they are not present. We skip H264
1317 * currently because delay and has_b_frames are not reliably set. */
1318 if ((delay == 0 || (delay == 1 && pc)) &&
1320 if (presentation_delayed) {
1321 /* DTS = decompression timestamp */
1322 /* PTS = presentation timestamp */
1323 if (pkt->dts == AV_NOPTS_VALUE)
1324 pkt->dts = st->last_IP_pts;
1325 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1326 if (pkt->dts == AV_NOPTS_VALUE)
1327 pkt->dts = st->cur_dts;
1329 /* This is tricky: the dts must be incremented by the duration
1330 * of the frame we are displaying, i.e. the last I- or P-frame. */
1331 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1332 st->last_IP_duration = pkt->duration;
1333 if (pkt->dts != AV_NOPTS_VALUE)
1334 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1335 if (pkt->dts != AV_NOPTS_VALUE &&
1336 pkt->pts == AV_NOPTS_VALUE &&
1337 st->last_IP_duration > 0 &&
1338 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1339 next_dts != next_pts &&
1340 next_pts != AV_NOPTS_VALUE)
1341 pkt->pts = next_dts;
1343 if ((uint64_t)pkt->duration <= INT32_MAX)
1344 st->last_IP_duration = pkt->duration;
1345 st->last_IP_pts = pkt->pts;
1346 /* Cannot compute PTS if not present (we can compute it only
1347 * by knowing the future. */
1348 } else if (pkt->pts != AV_NOPTS_VALUE ||
1349 pkt->dts != AV_NOPTS_VALUE ||
1350 pkt->duration > 0 ) {
1352 /* presentation is not delayed : PTS and DTS are the same */
1353 if (pkt->pts == AV_NOPTS_VALUE)
1354 pkt->pts = pkt->dts;
1355 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1357 if (pkt->pts == AV_NOPTS_VALUE)
1358 pkt->pts = st->cur_dts;
1359 pkt->dts = pkt->pts;
1360 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1361 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1365 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1366 st->internal->pts_buffer[0] = pkt->pts;
1367 for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1368 FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1370 if(has_decode_delay_been_guessed(st))
1371 pkt->dts = select_from_pts_buffer(st, st->internal->pts_buffer, pkt->dts);
1373 // We skipped it above so we try here.
1375 // This should happen on the first packet
1376 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1377 if (pkt->dts > st->cur_dts)
1378 st->cur_dts = pkt->dts;
1380 if (s->debug & FF_FDEBUG_TS)
1381 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1382 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1385 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1386 pkt->flags |= AV_PKT_FLAG_KEY;
1387 #if FF_API_CONVERGENCE_DURATION
1388 FF_DISABLE_DEPRECATION_WARNINGS
1390 pkt->convergence_duration = pc->convergence_duration;
1391 FF_ENABLE_DEPRECATION_WARNINGS
1396 * Parse a packet, add all split parts to parse_queue.
1398 * @param pkt Packet to parse; must not be NULL.
1399 * @param flush Indicates whether to flush. If set, pkt must be blank.
1401 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1402 int stream_index, int flush)
1405 AVStream *st = s->streams[stream_index];
1406 uint8_t *data = pkt->data;
1407 int size = pkt->size;
1408 int ret = 0, got_output = flush;
1410 if (size || flush) {
1411 av_init_packet(&out_pkt);
1412 } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1413 // preserve 0-size sync packets
1414 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1417 while (size > 0 || (flush && got_output)) {
1419 int64_t next_pts = pkt->pts;
1420 int64_t next_dts = pkt->dts;
1422 len = av_parser_parse2(st->parser, st->internal->avctx,
1423 &out_pkt.data, &out_pkt.size, data, size,
1424 pkt->pts, pkt->dts, pkt->pos);
1426 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1428 /* increment read pointer */
1432 got_output = !!out_pkt.size;
1437 if (pkt->buf && out_pkt.data == pkt->data) {
1438 /* reference pkt->buf only when out_pkt.data is guaranteed to point
1439 * to data in it and not in the parser's internal buffer. */
1440 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1441 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1442 out_pkt.buf = av_buffer_ref(pkt->buf);
1444 ret = AVERROR(ENOMEM);
1448 ret = av_packet_make_refcounted(&out_pkt);
1453 if (pkt->side_data) {
1454 out_pkt.side_data = pkt->side_data;
1455 out_pkt.side_data_elems = pkt->side_data_elems;
1456 pkt->side_data = NULL;
1457 pkt->side_data_elems = 0;
1460 /* set the duration */
1461 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1462 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1463 if (st->internal->avctx->sample_rate > 0) {
1465 av_rescale_q_rnd(st->parser->duration,
1466 (AVRational) { 1, st->internal->avctx->sample_rate },
1472 out_pkt.stream_index = st->index;
1473 out_pkt.pts = st->parser->pts;
1474 out_pkt.dts = st->parser->dts;
1475 out_pkt.pos = st->parser->pos;
1476 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1478 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1479 out_pkt.pos = st->parser->frame_offset;
1481 if (st->parser->key_frame == 1 ||
1482 (st->parser->key_frame == -1 &&
1483 st->parser->pict_type == AV_PICTURE_TYPE_I))
1484 out_pkt.flags |= AV_PKT_FLAG_KEY;
1486 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1487 out_pkt.flags |= AV_PKT_FLAG_KEY;
1489 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1491 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1492 &s->internal->parse_queue_end,
1495 av_packet_unref(&out_pkt);
1500 /* end of the stream => close and free the parser */
1502 av_parser_close(st->parser);
1507 av_packet_unref(pkt);
1511 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1513 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1516 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1518 int ret, i, got_packet = 0;
1519 AVDictionary *metadata = NULL;
1521 while (!got_packet && !s->internal->parse_queue) {
1524 /* read next packet */
1525 ret = ff_read_packet(s, pkt);
1527 if (ret == AVERROR(EAGAIN))
1529 /* flush the parsers */
1530 for (i = 0; i < s->nb_streams; i++) {
1532 if (st->parser && st->need_parsing)
1533 parse_packet(s, pkt, st->index, 1);
1535 /* all remaining packets are now in parse_queue =>
1536 * really terminate parsing */
1540 st = s->streams[pkt->stream_index];
1542 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1544 /* update context if required */
1545 if (st->internal->need_context_update) {
1546 if (avcodec_is_open(st->internal->avctx)) {
1547 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1548 avcodec_close(st->internal->avctx);
1549 st->internal->info->found_decoder = 0;
1552 /* close parser, because it depends on the codec */
1553 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1554 av_parser_close(st->parser);
1558 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1560 av_packet_unref(pkt);
1564 #if FF_API_LAVF_AVCTX
1565 FF_DISABLE_DEPRECATION_WARNINGS
1566 /* update deprecated public codec context */
1567 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1569 av_packet_unref(pkt);
1572 FF_ENABLE_DEPRECATION_WARNINGS
1575 st->internal->need_context_update = 0;
1578 if (pkt->pts != AV_NOPTS_VALUE &&
1579 pkt->dts != AV_NOPTS_VALUE &&
1580 pkt->pts < pkt->dts) {
1581 av_log(s, AV_LOG_WARNING,
1582 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1584 av_ts2str(pkt->pts),
1585 av_ts2str(pkt->dts),
1588 if (s->debug & FF_FDEBUG_TS)
1589 av_log(s, AV_LOG_DEBUG,
1590 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1592 av_ts2str(pkt->pts),
1593 av_ts2str(pkt->dts),
1594 pkt->size, pkt->duration, pkt->flags);
1596 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1597 st->parser = av_parser_init(st->codecpar->codec_id);
1599 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1600 "%s, packets or times may be invalid.\n",
1601 avcodec_get_name(st->codecpar->codec_id));
1602 /* no parser available: just output the raw packets */
1603 st->need_parsing = AVSTREAM_PARSE_NONE;
1604 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1605 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1606 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1607 st->parser->flags |= PARSER_FLAG_ONCE;
1608 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1609 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1612 if (!st->need_parsing || !st->parser) {
1613 /* no parsing needed: we just output the packet as is */
1614 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1615 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1616 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1617 ff_reduce_index(s, st->index);
1618 av_add_index_entry(st, pkt->pos, pkt->dts,
1619 0, 0, AVINDEX_KEYFRAME);
1622 } else if (st->discard < AVDISCARD_ALL) {
1623 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1625 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1626 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1627 st->codecpar->channels = st->internal->avctx->channels;
1628 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1629 st->codecpar->codec_id = st->internal->avctx->codec_id;
1632 av_packet_unref(pkt);
1634 if (pkt->flags & AV_PKT_FLAG_KEY)
1635 st->internal->skip_to_keyframe = 0;
1636 if (st->internal->skip_to_keyframe) {
1637 av_packet_unref(pkt);
1642 if (!got_packet && s->internal->parse_queue)
1643 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1646 AVStream *st = s->streams[pkt->stream_index];
1647 int discard_padding = 0;
1648 if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1649 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1650 int64_t sample = ts_to_samples(st, pts);
1651 int duration = ts_to_samples(st, pkt->duration);
1652 int64_t end_sample = sample + duration;
1653 if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1654 sample < st->internal->last_discard_sample)
1655 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1657 if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1658 st->internal->skip_samples = st->internal->start_skip_samples;
1659 if (st->internal->skip_samples || discard_padding) {
1660 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1662 AV_WL32(p, st->internal->skip_samples);
1663 AV_WL32(p + 4, discard_padding);
1664 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1666 st->internal->skip_samples = 0;
1669 if (st->internal->inject_global_side_data) {
1670 for (i = 0; i < st->nb_side_data; i++) {
1671 AVPacketSideData *src_sd = &st->side_data[i];
1674 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1677 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1679 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1683 memcpy(dst_data, src_sd->data, src_sd->size);
1685 st->internal->inject_global_side_data = 0;
1689 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1691 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1692 av_dict_copy(&s->metadata, metadata, 0);
1693 av_dict_free(&metadata);
1694 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1697 #if FF_API_LAVF_AVCTX
1698 update_stream_avctx(s);
1701 if (s->debug & FF_FDEBUG_TS)
1702 av_log(s, AV_LOG_DEBUG,
1703 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1704 "size=%d, duration=%"PRId64", flags=%d\n",
1706 av_ts2str(pkt->pts),
1707 av_ts2str(pkt->dts),
1708 pkt->size, pkt->duration, pkt->flags);
1710 /* A demuxer might have returned EOF because of an IO error, let's
1711 * propagate this back to the user. */
1712 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1718 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1720 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1726 ret = s->internal->packet_buffer
1727 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1728 &s->internal->packet_buffer_end, pkt)
1729 : read_frame_internal(s, pkt);
1736 AVPacketList *pktl = s->internal->packet_buffer;
1739 AVPacket *next_pkt = &pktl->pkt;
1741 if (next_pkt->dts != AV_NOPTS_VALUE) {
1742 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1743 // last dts seen for this stream. if any of packets following
1744 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1745 int64_t last_dts = next_pkt->dts;
1746 av_assert2(wrap_bits <= 64);
1747 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1748 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1749 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1750 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1752 next_pkt->pts = pktl->pkt.dts;
1754 if (last_dts != AV_NOPTS_VALUE) {
1755 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1756 last_dts = pktl->pkt.dts;
1761 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1762 // Fixing the last reference frame had none pts issue (For MXF etc).
1763 // We only do this when
1765 // 2. we are not able to resolve a pts value for current packet.
1766 // 3. the packets for this stream at the end of the files had valid dts.
1767 next_pkt->pts = last_dts + next_pkt->duration;
1769 pktl = s->internal->packet_buffer;
1772 /* read packet from packet buffer, if there is data */
1773 st = s->streams[next_pkt->stream_index];
1774 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1775 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1776 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1777 &s->internal->packet_buffer_end, pkt);
1782 ret = read_frame_internal(s, pkt);
1784 if (pktl && ret != AVERROR(EAGAIN)) {
1791 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1792 &s->internal->packet_buffer_end,
1795 av_packet_unref(pkt);
1802 st = s->streams[pkt->stream_index];
1803 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1804 ff_reduce_index(s, st->index);
1805 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1808 if (is_relative(pkt->dts))
1809 pkt->dts -= RELATIVE_TS_BASE;
1810 if (is_relative(pkt->pts))
1811 pkt->pts -= RELATIVE_TS_BASE;
1816 /* XXX: suppress the packet queue */
1817 static void flush_packet_queue(AVFormatContext *s)
1821 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1822 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1823 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1825 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1828 /*******************************************************/
1831 int av_find_default_stream_index(AVFormatContext *s)
1835 int best_stream = 0;
1836 int best_score = INT_MIN;
1838 if (s->nb_streams <= 0)
1840 for (i = 0; i < s->nb_streams; i++) {
1843 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1844 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1846 if (st->codecpar->width && st->codecpar->height)
1850 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1851 if (st->codecpar->sample_rate)
1854 if (st->codec_info_nb_frames)
1857 if (st->discard != AVDISCARD_ALL)
1860 if (score > best_score) {
1868 /** Flush the frame reader. */
1869 void ff_read_frame_flush(AVFormatContext *s)
1874 flush_packet_queue(s);
1876 /* Reset read state for each stream. */
1877 for (i = 0; i < s->nb_streams; i++) {
1881 av_parser_close(st->parser);
1884 st->last_IP_pts = AV_NOPTS_VALUE;
1885 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1886 if (st->first_dts == AV_NOPTS_VALUE)
1887 st->cur_dts = RELATIVE_TS_BASE;
1889 /* We set the current DTS to an unspecified origin. */
1890 st->cur_dts = AV_NOPTS_VALUE;
1892 st->probe_packets = s->max_probe_packets;
1894 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1895 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1897 if (s->internal->inject_global_side_data)
1898 st->internal->inject_global_side_data = 1;
1900 st->internal->skip_samples = 0;
1904 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1908 for (i = 0; i < s->nb_streams; i++) {
1909 AVStream *st = s->streams[i];
1912 av_rescale(timestamp,
1913 st->time_base.den * (int64_t) ref_st->time_base.num,
1914 st->time_base.num * (int64_t) ref_st->time_base.den);
1918 void ff_reduce_index(AVFormatContext *s, int stream_index)
1920 AVStream *st = s->streams[stream_index];
1921 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1923 if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1925 for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1926 st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1927 st->internal->nb_index_entries = i;
1931 int ff_add_index_entry(AVIndexEntry **index_entries,
1932 int *nb_index_entries,
1933 unsigned int *index_entries_allocated_size,
1934 int64_t pos, int64_t timestamp,
1935 int size, int distance, int flags)
1937 AVIndexEntry *entries, *ie;
1940 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1943 if (timestamp == AV_NOPTS_VALUE)
1944 return AVERROR(EINVAL);
1946 if (size < 0 || size > 0x3FFFFFFF)
1947 return AVERROR(EINVAL);
1949 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1950 timestamp -= RELATIVE_TS_BASE;
1952 entries = av_fast_realloc(*index_entries,
1953 index_entries_allocated_size,
1954 (*nb_index_entries + 1) *
1955 sizeof(AVIndexEntry));
1959 *index_entries = entries;
1961 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1962 timestamp, AVSEEK_FLAG_ANY);
1965 index = (*nb_index_entries)++;
1966 ie = &entries[index];
1967 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1969 ie = &entries[index];
1970 if (ie->timestamp != timestamp) {
1971 if (ie->timestamp <= timestamp)
1973 memmove(entries + index + 1, entries + index,
1974 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1975 (*nb_index_entries)++;
1976 } else if (ie->pos == pos && distance < ie->min_distance)
1977 // do not reduce the distance
1978 distance = ie->min_distance;
1982 ie->timestamp = timestamp;
1983 ie->min_distance = distance;
1990 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1991 int size, int distance, int flags)
1993 timestamp = wrap_timestamp(st, timestamp);
1994 return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
1995 &st->internal->index_entries_allocated_size, pos,
1996 timestamp, size, distance, flags);
1999 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2000 int64_t wanted_timestamp, int flags)
2008 // Optimize appending index entries at the end.
2009 if (b && entries[b - 1].timestamp < wanted_timestamp)
2015 // Search for the next non-discarded packet.
2016 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2018 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2024 timestamp = entries[m].timestamp;
2025 if (timestamp >= wanted_timestamp)
2027 if (timestamp <= wanted_timestamp)
2030 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2032 if (!(flags & AVSEEK_FLAG_ANY))
2033 while (m >= 0 && m < nb_entries &&
2034 !(entries[m].flags & AVINDEX_KEYFRAME))
2035 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2037 if (m == nb_entries)
2042 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2045 int64_t pos_delta = 0;
2047 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2048 const char *proto = avio_find_protocol_name(s->url);
2050 av_assert0(time_tolerance >= 0);
2053 av_log(s, AV_LOG_INFO,
2054 "Protocol name not provided, cannot determine if input is local or "
2055 "a network protocol, buffers and access patterns cannot be configured "
2056 "optimally without knowing the protocol\n");
2059 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2062 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2063 AVStream *st1 = s->streams[ist1];
2064 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2065 AVStream *st2 = s->streams[ist2];
2071 for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2072 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2073 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2075 skip = FFMAX(skip, e1->size);
2076 for (; i2 < st2->internal->nb_index_entries; i2++) {
2077 AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2078 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2079 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2081 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2089 /* XXX This could be adjusted depending on protocol*/
2090 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2091 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2093 /* realloc the buffer and the original data will be retained */
2094 if (ffio_realloc_buf(s->pb, pos_delta)) {
2095 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2099 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2102 if (skip < (1<<23)) {
2103 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2107 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2109 return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2110 wanted_timestamp, flags);
2113 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2114 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2116 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2117 if (stream_index >= 0)
2118 ts = wrap_timestamp(s->streams[stream_index], ts);
2122 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2123 int64_t target_ts, int flags)
2125 const AVInputFormat *avif = s->iformat;
2126 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2127 int64_t ts_min, ts_max, ts;
2132 if (stream_index < 0)
2135 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2138 ts_min = AV_NOPTS_VALUE;
2139 pos_limit = -1; // GCC falsely says it may be uninitialized.
2141 st = s->streams[stream_index];
2142 if (st->internal->index_entries) {
2145 /* FIXME: Whole function must be checked for non-keyframe entries in
2146 * index case, especially read_timestamp(). */
2147 index = av_index_search_timestamp(st, target_ts,
2148 flags | AVSEEK_FLAG_BACKWARD);
2149 index = FFMAX(index, 0);
2150 e = &st->internal->index_entries[index];
2152 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2154 ts_min = e->timestamp;
2155 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2156 pos_min, av_ts2str(ts_min));
2158 av_assert1(index == 0);
2161 index = av_index_search_timestamp(st, target_ts,
2162 flags & ~AVSEEK_FLAG_BACKWARD);
2163 av_assert0(index < st->internal->nb_index_entries);
2165 e = &st->internal->index_entries[index];
2166 av_assert1(e->timestamp >= target_ts);
2168 ts_max = e->timestamp;
2169 pos_limit = pos_max - e->min_distance;
2170 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2171 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2175 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2176 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2181 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2184 ff_read_frame_flush(s);
2185 ff_update_cur_dts(s, st, ts);
2190 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2191 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2193 int64_t step = 1024;
2194 int64_t limit, ts_max;
2195 int64_t filesize = avio_size(s->pb);
2196 int64_t pos_max = filesize - 1;
2199 pos_max = FFMAX(0, (pos_max) - step);
2200 ts_max = ff_read_timestamp(s, stream_index,
2201 &pos_max, limit, read_timestamp);
2203 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2204 if (ts_max == AV_NOPTS_VALUE)
2208 int64_t tmp_pos = pos_max + 1;
2209 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2210 &tmp_pos, INT64_MAX, read_timestamp);
2211 if (tmp_ts == AV_NOPTS_VALUE)
2213 av_assert0(tmp_pos > pos_max);
2216 if (tmp_pos >= filesize)
2228 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2229 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2230 int64_t ts_min, int64_t ts_max,
2231 int flags, int64_t *ts_ret,
2232 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2233 int64_t *, int64_t))
2240 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2242 if (ts_min == AV_NOPTS_VALUE) {
2243 pos_min = s->internal->data_offset;
2244 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2245 if (ts_min == AV_NOPTS_VALUE)
2249 if (ts_min >= target_ts) {
2254 if (ts_max == AV_NOPTS_VALUE) {
2255 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2257 pos_limit = pos_max;
2260 if (ts_max <= target_ts) {
2265 av_assert0(ts_min < ts_max);
2268 while (pos_min < pos_limit) {
2269 av_log(s, AV_LOG_TRACE,
2270 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2271 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2272 av_assert0(pos_limit <= pos_max);
2274 if (no_change == 0) {
2275 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2276 // interpolate position (better than dichotomy)
2277 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2279 pos_min - approximate_keyframe_distance;
2280 } else if (no_change == 1) {
2281 // bisection if interpolation did not change min / max pos last time
2282 pos = (pos_min + pos_limit) >> 1;
2284 /* linear search if bisection failed, can only happen if there
2285 * are very few or no keyframes between min/max */
2290 else if (pos > pos_limit)
2294 // May pass pos_limit instead of -1.
2295 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2300 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2301 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2302 pos_min, pos, pos_max,
2303 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2304 pos_limit, start_pos, no_change);
2305 if (ts == AV_NOPTS_VALUE) {
2306 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2309 if (target_ts <= ts) {
2310 pos_limit = start_pos - 1;
2314 if (target_ts >= ts) {
2320 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2321 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2324 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2326 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2327 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2328 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2334 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2335 int64_t pos, int flags)
2337 int64_t pos_min, pos_max;
2339 pos_min = s->internal->data_offset;
2340 pos_max = avio_size(s->pb) - 1;
2344 else if (pos > pos_max)
2347 avio_seek(s->pb, pos, SEEK_SET);
2349 s->io_repositioned = 1;
2354 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2355 int64_t timestamp, int flags)
2362 st = s->streams[stream_index];
2364 index = av_index_search_timestamp(st, timestamp, flags);
2366 if (index < 0 && st->internal->nb_index_entries &&
2367 timestamp < st->internal->index_entries[0].timestamp)
2370 if (index < 0 || index == st->internal->nb_index_entries - 1) {
2374 if (st->internal->nb_index_entries) {
2375 av_assert0(st->internal->index_entries);
2376 ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2377 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2379 ff_update_cur_dts(s, st, ie->timestamp);
2381 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2387 read_status = av_read_frame(s, &pkt);
2388 } while (read_status == AVERROR(EAGAIN));
2389 if (read_status < 0)
2391 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2392 if (pkt.flags & AV_PKT_FLAG_KEY) {
2393 av_packet_unref(&pkt);
2396 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2397 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);
2398 av_packet_unref(&pkt);
2402 av_packet_unref(&pkt);
2404 index = av_index_search_timestamp(st, timestamp, flags);
2409 ff_read_frame_flush(s);
2410 if (s->iformat->read_seek)
2411 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2413 ie = &st->internal->index_entries[index];
2414 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2416 ff_update_cur_dts(s, st, ie->timestamp);
2421 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2422 int64_t timestamp, int flags)
2427 if (flags & AVSEEK_FLAG_BYTE) {
2428 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2430 ff_read_frame_flush(s);
2431 return seek_frame_byte(s, stream_index, timestamp, flags);
2434 if (stream_index < 0) {
2435 stream_index = av_find_default_stream_index(s);
2436 if (stream_index < 0)
2439 st = s->streams[stream_index];
2440 /* timestamp for default must be expressed in AV_TIME_BASE units */
2441 timestamp = av_rescale(timestamp, st->time_base.den,
2442 AV_TIME_BASE * (int64_t) st->time_base.num);
2445 /* first, we try the format specific seek */
2446 if (s->iformat->read_seek) {
2447 ff_read_frame_flush(s);
2448 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2454 if (s->iformat->read_timestamp &&
2455 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2456 ff_read_frame_flush(s);
2457 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2458 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2459 ff_read_frame_flush(s);
2460 return seek_frame_generic(s, stream_index, timestamp, flags);
2465 int av_seek_frame(AVFormatContext *s, int stream_index,
2466 int64_t timestamp, int flags)
2470 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2471 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2472 if ((flags & AVSEEK_FLAG_BACKWARD))
2476 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2477 flags & ~AVSEEK_FLAG_BACKWARD);
2480 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2483 ret = avformat_queue_attached_pictures(s);
2488 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2489 int64_t ts, int64_t max_ts, int flags)
2491 if (min_ts > ts || max_ts < ts)
2493 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2494 return AVERROR(EINVAL);
2497 flags |= AVSEEK_FLAG_ANY;
2498 flags &= ~AVSEEK_FLAG_BACKWARD;
2500 if (s->iformat->read_seek2) {
2502 ff_read_frame_flush(s);
2504 if (stream_index == -1 && s->nb_streams == 1) {
2505 AVRational time_base = s->streams[0]->time_base;
2506 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2507 min_ts = av_rescale_rnd(min_ts, time_base.den,
2508 time_base.num * (int64_t)AV_TIME_BASE,
2509 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2510 max_ts = av_rescale_rnd(max_ts, time_base.den,
2511 time_base.num * (int64_t)AV_TIME_BASE,
2512 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2516 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2520 ret = avformat_queue_attached_pictures(s);
2524 if (s->iformat->read_timestamp) {
2525 // try to seek via read_timestamp()
2528 // Fall back on old API if new is not implemented but old is.
2529 // Note the old API has somewhat different semantics.
2530 if (s->iformat->read_seek || 1) {
2531 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2532 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2533 if (ret<0 && ts != min_ts && max_ts != ts) {
2534 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2536 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2541 // try some generic seek like seek_frame_generic() but with new ts semantics
2542 return -1; //unreachable
2545 int avformat_flush(AVFormatContext *s)
2547 ff_read_frame_flush(s);
2551 /*******************************************************/
2554 * Return TRUE if the stream has accurate duration in any stream.
2556 * @return TRUE if the stream has accurate duration for at least one component.
2558 static int has_duration(AVFormatContext *ic)
2563 for (i = 0; i < ic->nb_streams; i++) {
2564 st = ic->streams[i];
2565 if (st->duration != AV_NOPTS_VALUE)
2568 if (ic->duration != AV_NOPTS_VALUE)
2574 * Estimate the stream timings from the one of each components.
2576 * Also computes the global bitrate if possible.
2578 static void update_stream_timings(AVFormatContext *ic)
2580 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2581 int64_t duration, duration1, duration_text, filesize;
2585 start_time = INT64_MAX;
2586 start_time_text = INT64_MAX;
2587 end_time = INT64_MIN;
2588 end_time_text = INT64_MIN;
2589 duration = INT64_MIN;
2590 duration_text = INT64_MIN;
2592 for (i = 0; i < ic->nb_streams; i++) {
2593 AVStream *st = ic->streams[i];
2594 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2595 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2596 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2597 start_time1 = av_rescale_q(st->start_time, st->time_base,
2600 start_time_text = FFMIN(start_time_text, start_time1);
2602 start_time = FFMIN(start_time, start_time1);
2603 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2605 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2606 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2607 end_time1 += start_time1;
2609 end_time_text = FFMAX(end_time_text, end_time1);
2611 end_time = FFMAX(end_time, end_time1);
2613 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2614 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2615 p->start_time = start_time1;
2616 if (p->end_time < end_time1)
2617 p->end_time = end_time1;
2620 if (st->duration != AV_NOPTS_VALUE) {
2621 duration1 = av_rescale_q(st->duration, st->time_base,
2624 duration_text = FFMAX(duration_text, duration1);
2626 duration = FFMAX(duration, duration1);
2629 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2630 start_time = start_time_text;
2631 else if (start_time > start_time_text)
2632 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2634 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2635 end_time = end_time_text;
2636 else if (end_time < end_time_text)
2637 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2639 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2640 duration = duration_text;
2641 else if (duration < duration_text)
2642 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2644 if (start_time != INT64_MAX) {
2645 ic->start_time = start_time;
2646 if (end_time != INT64_MIN) {
2647 if (ic->nb_programs > 1) {
2648 for (i = 0; i < ic->nb_programs; i++) {
2649 p = ic->programs[i];
2650 if (p->start_time != AV_NOPTS_VALUE &&
2651 p->end_time > p->start_time &&
2652 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2653 duration = FFMAX(duration, p->end_time - p->start_time);
2655 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2656 duration = FFMAX(duration, end_time - start_time);
2660 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2661 ic->duration = duration;
2663 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2664 /* compute the bitrate */
2665 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2666 (double) ic->duration;
2667 if (bitrate >= 0 && bitrate <= INT64_MAX)
2668 ic->bit_rate = bitrate;
2672 static void fill_all_stream_timings(AVFormatContext *ic)
2677 update_stream_timings(ic);
2678 for (i = 0; i < ic->nb_streams; i++) {
2679 st = ic->streams[i];
2680 if (st->start_time == AV_NOPTS_VALUE) {
2681 if (ic->start_time != AV_NOPTS_VALUE)
2682 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2684 if (ic->duration != AV_NOPTS_VALUE)
2685 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2691 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2693 int64_t filesize, duration;
2694 int i, show_warning = 0;
2697 /* if bit_rate is already set, we believe it */
2698 if (ic->bit_rate <= 0) {
2699 int64_t bit_rate = 0;
2700 for (i = 0; i < ic->nb_streams; i++) {
2701 st = ic->streams[i];
2702 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2703 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2704 if (st->codecpar->bit_rate > 0) {
2705 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2709 bit_rate += st->codecpar->bit_rate;
2710 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2711 // If we have a videostream with packets but without a bitrate
2712 // then consider the sum not known
2717 ic->bit_rate = bit_rate;
2720 /* if duration is already set, we believe it */
2721 if (ic->duration == AV_NOPTS_VALUE &&
2722 ic->bit_rate != 0) {
2723 filesize = ic->pb ? avio_size(ic->pb) : 0;
2724 if (filesize > ic->internal->data_offset) {
2725 filesize -= ic->internal->data_offset;
2726 for (i = 0; i < ic->nb_streams; i++) {
2727 st = ic->streams[i];
2728 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2729 && st->duration == AV_NOPTS_VALUE) {
2730 duration = av_rescale(filesize, 8LL * st->time_base.den,
2732 (int64_t) st->time_base.num);
2733 st->duration = duration;
2740 av_log(ic, AV_LOG_WARNING,
2741 "Estimating duration from bitrate, this may be inaccurate\n");
2744 #define DURATION_MAX_READ_SIZE 250000LL
2745 #define DURATION_MAX_RETRY 6
2747 /* only usable for MPEG-PS streams */
2748 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2750 AVPacket pkt1, *pkt = &pkt1;
2752 int num, den, read_size, i, ret;
2753 int found_duration = 0;
2755 int64_t filesize, offset, duration;
2758 /* flush packet queue */
2759 flush_packet_queue(ic);
2761 for (i = 0; i < ic->nb_streams; i++) {
2762 st = ic->streams[i];
2763 if (st->start_time == AV_NOPTS_VALUE &&
2764 st->first_dts == AV_NOPTS_VALUE &&
2765 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2766 av_log(ic, AV_LOG_WARNING,
2767 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2770 av_parser_close(st->parser);
2775 if (ic->skip_estimate_duration_from_pts) {
2776 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2777 goto skip_duration_calc;
2780 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2781 /* estimate the end time (duration) */
2782 /* XXX: may need to support wrapping */
2783 filesize = ic->pb ? avio_size(ic->pb) : 0;
2785 is_end = found_duration;
2786 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2790 avio_seek(ic->pb, offset, SEEK_SET);
2793 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2797 ret = ff_read_packet(ic, pkt);
2798 } while (ret == AVERROR(EAGAIN));
2801 read_size += pkt->size;
2802 st = ic->streams[pkt->stream_index];
2803 if (pkt->pts != AV_NOPTS_VALUE &&
2804 (st->start_time != AV_NOPTS_VALUE ||
2805 st->first_dts != AV_NOPTS_VALUE)) {
2806 if (pkt->duration == 0) {
2807 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2809 pkt->duration = av_rescale_rnd(1,
2810 num * (int64_t) st->time_base.den,
2811 den * (int64_t) st->time_base.num,
2815 duration = pkt->pts + pkt->duration;
2817 if (st->start_time != AV_NOPTS_VALUE)
2818 duration -= st->start_time;
2820 duration -= st->first_dts;
2822 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2823 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2824 st->duration = duration;
2825 st->internal->info->last_duration = duration;
2828 av_packet_unref(pkt);
2831 /* check if all audio/video streams have valid duration */
2834 for (i = 0; i < ic->nb_streams; i++) {
2835 st = ic->streams[i];
2836 switch (st->codecpar->codec_type) {
2837 case AVMEDIA_TYPE_VIDEO:
2838 case AVMEDIA_TYPE_AUDIO:
2839 if (st->duration == AV_NOPTS_VALUE)
2846 ++retry <= DURATION_MAX_RETRY);
2848 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2850 /* warn about audio/video streams which duration could not be estimated */
2851 for (i = 0; i < ic->nb_streams; i++) {
2852 st = ic->streams[i];
2853 if (st->duration == AV_NOPTS_VALUE) {
2854 switch (st->codecpar->codec_type) {
2855 case AVMEDIA_TYPE_VIDEO:
2856 case AVMEDIA_TYPE_AUDIO:
2857 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2858 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2860 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2865 fill_all_stream_timings(ic);
2867 avio_seek(ic->pb, old_offset, SEEK_SET);
2868 for (i = 0; i < ic->nb_streams; i++) {
2871 st = ic->streams[i];
2872 st->cur_dts = st->first_dts;
2873 st->last_IP_pts = AV_NOPTS_VALUE;
2874 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2875 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2876 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2880 /* 1:1 map to AVDurationEstimationMethod */
2881 static const char *const duration_name[] = {
2882 [AVFMT_DURATION_FROM_PTS] = "pts",
2883 [AVFMT_DURATION_FROM_STREAM] = "stream",
2884 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2887 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2889 return duration_name[method];
2892 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2896 /* get the file size, if possible */
2897 if (ic->iformat->flags & AVFMT_NOFILE) {
2900 file_size = avio_size(ic->pb);
2901 file_size = FFMAX(0, file_size);
2904 if ((!strcmp(ic->iformat->name, "mpeg") ||
2905 !strcmp(ic->iformat->name, "mpegts")) &&
2906 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2907 /* get accurate estimate from the PTSes */
2908 estimate_timings_from_pts(ic, old_offset);
2909 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2910 } else if (has_duration(ic)) {
2911 /* at least one component has timings - we use them for all
2913 fill_all_stream_timings(ic);
2914 /* nut demuxer estimate the duration from PTS */
2915 if(!strcmp(ic->iformat->name, "nut"))
2916 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2918 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2920 /* less precise: use bitrate info */
2921 estimate_timings_from_bit_rate(ic);
2922 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2924 update_stream_timings(ic);
2928 AVStream av_unused *st;
2929 for (i = 0; i < ic->nb_streams; i++) {
2930 st = ic->streams[i];
2931 if (st->time_base.den)
2932 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %s duration: %s\n", i,
2933 av_ts2timestr(st->start_time, &st->time_base),
2934 av_ts2timestr(st->duration, &st->time_base));
2936 av_log(ic, AV_LOG_TRACE,
2937 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2938 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2939 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2940 duration_estimate_name(ic->duration_estimation_method),
2941 (int64_t)ic->bit_rate / 1000);
2945 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2947 AVCodecContext *avctx = st->internal->avctx;
2949 #define FAIL(errmsg) do { \
2951 *errmsg_ptr = errmsg; \
2955 if ( avctx->codec_id == AV_CODEC_ID_NONE
2956 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2957 FAIL("unknown codec");
2958 switch (avctx->codec_type) {
2959 case AVMEDIA_TYPE_AUDIO:
2960 if (!avctx->frame_size && determinable_frame_size(avctx))
2961 FAIL("unspecified frame size");
2962 if (st->internal->info->found_decoder >= 0 &&
2963 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2964 FAIL("unspecified sample format");
2965 if (!avctx->sample_rate)
2966 FAIL("unspecified sample rate");
2967 if (!avctx->channels)
2968 FAIL("unspecified number of channels");
2969 if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2970 FAIL("no decodable DTS frames");
2972 case AVMEDIA_TYPE_VIDEO:
2974 FAIL("unspecified size");
2975 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2976 FAIL("unspecified pixel format");
2977 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2978 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2979 FAIL("no frame in rv30/40 and no sar");
2981 case AVMEDIA_TYPE_SUBTITLE:
2982 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2983 FAIL("unspecified size");
2985 case AVMEDIA_TYPE_DATA:
2986 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2992 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2993 static int try_decode_frame(AVFormatContext *s, AVStream *st,
2994 const AVPacket *avpkt, AVDictionary **options)
2996 AVCodecContext *avctx = st->internal->avctx;
2997 const AVCodec *codec;
2998 int got_picture = 1, ret = 0;
2999 AVFrame *frame = av_frame_alloc();
3000 AVSubtitle subtitle;
3001 AVPacket pkt = *avpkt;
3002 int do_skip_frame = 0;
3003 enum AVDiscard skip_frame;
3006 return AVERROR(ENOMEM);
3008 if (!avcodec_is_open(avctx) &&
3009 st->internal->info->found_decoder <= 0 &&
3010 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3011 AVDictionary *thread_opt = NULL;
3013 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3016 st->internal->info->found_decoder = -st->codecpar->codec_id;
3021 /* Force thread count to 1 since the H.264 decoder will not extract
3022 * SPS and PPS to extradata during multi-threaded decoding. */
3023 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3024 if (s->codec_whitelist)
3025 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3026 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3028 av_dict_free(&thread_opt);
3030 st->internal->info->found_decoder = -avctx->codec_id;
3033 st->internal->info->found_decoder = 1;
3034 } else if (!st->internal->info->found_decoder)
3035 st->internal->info->found_decoder = 1;
3037 if (st->internal->info->found_decoder < 0) {
3042 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3044 skip_frame = avctx->skip_frame;
3045 avctx->skip_frame = AVDISCARD_ALL;
3048 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3050 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3051 (!st->codec_info_nb_frames &&
3052 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3054 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3055 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3056 ret = avcodec_send_packet(avctx, &pkt);
3057 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3061 ret = avcodec_receive_frame(avctx, frame);
3064 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3066 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3067 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3068 &got_picture, &pkt);
3070 avsubtitle_free(&subtitle);
3076 st->internal->nb_decoded_frames++;
3081 if (!pkt.data && !got_picture)
3085 if (do_skip_frame) {
3086 avctx->skip_frame = skip_frame;
3089 av_frame_free(&frame);
3093 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3095 while (tags->id != AV_CODEC_ID_NONE) {
3103 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3106 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3107 if (tag == tags[i].tag)
3109 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3110 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3112 return AV_CODEC_ID_NONE;
3115 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3117 if (bps <= 0 || bps > 64)
3118 return AV_CODEC_ID_NONE;
3123 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3125 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3127 return AV_CODEC_ID_NONE;
3132 if (sflags & (1 << (bps - 1))) {
3135 return AV_CODEC_ID_PCM_S8;
3137 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3139 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3141 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3143 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3145 return AV_CODEC_ID_NONE;
3150 return AV_CODEC_ID_PCM_U8;
3152 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3154 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3156 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3158 return AV_CODEC_ID_NONE;
3164 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3167 if (!av_codec_get_tag2(tags, id, &tag))
3172 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3176 for (i = 0; tags && tags[i]; i++) {
3177 const AVCodecTag *codec_tags = tags[i];
3178 while (codec_tags->id != AV_CODEC_ID_NONE) {
3179 if (codec_tags->id == id) {
3180 *tag = codec_tags->tag;
3189 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3192 for (i = 0; tags && tags[i]; i++) {
3193 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3194 if (id != AV_CODEC_ID_NONE)
3197 return AV_CODEC_ID_NONE;
3200 static int chapter_start_cmp(const void *p1, const void *p2)
3202 AVChapter *ch1 = *(AVChapter**)p1;
3203 AVChapter *ch2 = *(AVChapter**)p2;
3204 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3207 return (ch1 > ch2) - (ch1 < ch2);
3210 static int compute_chapters_end(AVFormatContext *s)
3213 int64_t max_time = 0;
3214 AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3217 return AVERROR(ENOMEM);
3219 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3220 max_time = s->duration +
3221 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3223 for (i = 0; i < s->nb_chapters; i++)
3224 timetable[i] = s->chapters[i];
3225 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3227 for (i = 0; i < s->nb_chapters; i++)
3228 if (timetable[i]->end == AV_NOPTS_VALUE) {
3229 AVChapter *ch = timetable[i];
3230 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3234 if (i + 1 < s->nb_chapters) {
3235 AVChapter *ch1 = timetable[i + 1];
3236 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3238 if (next_start > ch->start && next_start < end)
3241 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3247 static int get_std_framerate(int i)
3250 return (i + 1) * 1001;
3254 return (i + 31) * 1001 * 12;
3258 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3262 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3265 /* Is the time base unreliable?
3266 * This is a heuristic to balance between quick acceptance of the values in
3267 * the headers vs. some extra checks.
3268 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3269 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3270 * And there are "variable" fps files this needs to detect as well. */
3271 static int tb_unreliable(AVCodecContext *c)
3273 if (c->time_base.den >= 101LL * c->time_base.num ||
3274 c->time_base.den < 5LL * c->time_base.num ||
3275 // c->codec_tag == AV_RL32("DIVX") ||
3276 // c->codec_tag == AV_RL32("XVID") ||
3277 c->codec_tag == AV_RL32("mp4v") ||
3278 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3279 c->codec_id == AV_CODEC_ID_GIF ||
3280 c->codec_id == AV_CODEC_ID_HEVC ||
3281 c->codec_id == AV_CODEC_ID_H264)
3286 int ff_alloc_extradata(AVCodecParameters *par, int size)
3288 av_freep(&par->extradata);
3289 par->extradata_size = 0;
3291 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3292 return AVERROR(EINVAL);
3294 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3295 if (!par->extradata)
3296 return AVERROR(ENOMEM);
3298 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3299 par->extradata_size = size;
3304 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3306 int ret = ff_alloc_extradata(par, size);
3309 ret = avio_read(pb, par->extradata, size);
3311 av_freep(&par->extradata);
3312 par->extradata_size = 0;
3313 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3314 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3320 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3323 int64_t last = st->internal->info->last_dts;
3325 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3326 && ts - (uint64_t)last < INT64_MAX) {
3327 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3328 int64_t duration = ts - last;
3330 if (!st->internal->info->duration_error)
3331 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3332 if (!st->internal->info->duration_error)
3333 return AVERROR(ENOMEM);
3335 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3336 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3337 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3338 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3339 int framerate = get_std_framerate(i);
3340 double sdts = dts*framerate/(1001*12);
3341 for (j= 0; j<2; j++) {
3342 int64_t ticks = llrint(sdts+j*0.5);
3343 double error= sdts - ticks + j*0.5;
3344 st->internal->info->duration_error[j][0][i] += error;
3345 st->internal->info->duration_error[j][1][i] += error*error;
3349 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3350 st->internal->info->duration_count++;
3351 st->internal->info->rfps_duration_sum += duration;
3354 if (st->internal->info->duration_count % 10 == 0) {
3355 int n = st->internal->info->duration_count;
3356 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3357 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3358 double a0 = st->internal->info->duration_error[0][0][i] / n;
3359 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3360 double a1 = st->internal->info->duration_error[1][0][i] / n;
3361 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3362 if (error0 > 0.04 && error1 > 0.04) {
3363 st->internal->info->duration_error[0][1][i] = 2e10;
3364 st->internal->info->duration_error[1][1][i] = 2e10;
3370 // ignore the first 4 values, they might have some random jitter
3371 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3372 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3374 if (ts != AV_NOPTS_VALUE)
3375 st->internal->info->last_dts = ts;
3380 void ff_rfps_calculate(AVFormatContext *ic)
3384 for (i = 0; i < ic->nb_streams; i++) {
3385 AVStream *st = ic->streams[i];
3387 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3389 // the check for tb_unreliable() is not completely correct, since this is not about handling
3390 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3391 // ipmovie.c produces.
3392 if (tb_unreliable(st->internal->avctx) && st->internal->info->duration_count > 15 && st->internal->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3393 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->internal->info->duration_gcd, INT_MAX);
3394 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3395 && tb_unreliable(st->internal->avctx)) {
3397 double best_error= 0.01;
3398 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3400 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3403 if (st->internal->info->codec_info_duration &&
3404 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3406 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3409 if (av_q2d(st->time_base) * st->internal->info->rfps_duration_sum / st->internal->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3412 for (k= 0; k<2; k++) {
3413 int n = st->internal->info->duration_count;
3414 double a= st->internal->info->duration_error[k][0][j] / n;
3415 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3417 if (error < best_error && best_error> 0.000000001) {
3419 num = get_std_framerate(j);
3422 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3425 // do not increase frame rate by more than 1 % in order to match a standard rate.
3426 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3427 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3429 if ( !st->avg_frame_rate.num
3430 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3431 && st->internal->info->codec_info_duration <= 0
3432 && st->internal->info->duration_count > 2
3433 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->internal->info->rfps_duration_sum / (double)st->internal->info->duration_count) <= 1.0
3435 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3436 st->avg_frame_rate = st->r_frame_rate;
3439 av_freep(&st->internal->info->duration_error);
3440 st->internal->info->last_dts = AV_NOPTS_VALUE;
3441 st->internal->info->duration_count = 0;
3442 st->internal->info->rfps_duration_sum = 0;
3446 static int extract_extradata_check(AVStream *st)
3448 const AVBitStreamFilter *f;
3450 f = av_bsf_get_by_name("extract_extradata");
3455 const enum AVCodecID *ids;
3456 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3457 if (*ids == st->codecpar->codec_id)
3464 static int extract_extradata_init(AVStream *st)
3466 AVStreamInternal *sti = st->internal;
3467 const AVBitStreamFilter *f;
3470 f = av_bsf_get_by_name("extract_extradata");
3474 /* check that the codec id is supported */
3475 ret = extract_extradata_check(st);
3479 sti->extract_extradata.pkt = av_packet_alloc();
3480 if (!sti->extract_extradata.pkt)
3481 return AVERROR(ENOMEM);
3483 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3487 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3492 sti->extract_extradata.bsf->time_base_in = st->time_base;
3494 ret = av_bsf_init(sti->extract_extradata.bsf);
3499 sti->extract_extradata.inited = 1;
3503 av_bsf_free(&sti->extract_extradata.bsf);
3504 av_packet_free(&sti->extract_extradata.pkt);
3508 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3510 AVStreamInternal *sti = st->internal;
3514 if (!sti->extract_extradata.inited) {
3515 ret = extract_extradata_init(st);
3520 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3523 pkt_ref = sti->extract_extradata.pkt;
3524 ret = av_packet_ref(pkt_ref, pkt);
3528 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3530 av_packet_unref(pkt_ref);
3534 while (ret >= 0 && !sti->avctx->extradata) {
3535 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3537 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3542 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3543 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3544 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3545 sti->avctx->extradata = side_data->data;
3546 sti->avctx->extradata_size = side_data->size;
3547 side_data->data = NULL;
3548 side_data->size = 0;
3552 av_packet_unref(pkt_ref);
3558 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3562 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3563 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3565 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3567 return AVERROR(ENOMEM);
3568 memcpy(dst_data, sd_src->data, sd_src->size);
3573 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3575 int i, count = 0, ret = 0, j;
3578 AVCodecContext *avctx;
3580 int64_t old_offset = avio_tell(ic->pb);
3581 // new streams might appear, no options for those
3582 int orig_nb_streams = ic->nb_streams;
3584 int64_t max_analyze_duration = ic->max_analyze_duration;
3585 int64_t max_stream_analyze_duration;
3586 int64_t max_subtitle_analyze_duration;
3587 int64_t probesize = ic->probesize;
3588 int eof_reached = 0;
3589 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3591 flush_codecs = probesize > 0;
3593 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3595 max_stream_analyze_duration = max_analyze_duration;
3596 max_subtitle_analyze_duration = max_analyze_duration;
3597 if (!max_analyze_duration) {
3598 max_stream_analyze_duration =
3599 max_analyze_duration = 5*AV_TIME_BASE;
3600 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3601 if (!strcmp(ic->iformat->name, "flv"))
3602 max_stream_analyze_duration = 90*AV_TIME_BASE;
3603 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3604 max_stream_analyze_duration = 7*AV_TIME_BASE;
3608 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3609 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3611 for (i = 0; i < ic->nb_streams; i++) {
3612 const AVCodec *codec;
3613 AVDictionary *thread_opt = NULL;
3614 st = ic->streams[i];
3615 avctx = st->internal->avctx;
3617 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3618 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3619 /* if (!st->time_base.num)
3621 if (!avctx->time_base.num)
3622 avctx->time_base = st->time_base;
3625 /* check if the caller has overridden the codec id */
3626 #if FF_API_LAVF_AVCTX
3627 FF_DISABLE_DEPRECATION_WARNINGS
3628 if (st->codec->codec_id != st->internal->orig_codec_id) {
3629 st->codecpar->codec_id = st->codec->codec_id;
3630 st->codecpar->codec_type = st->codec->codec_type;
3631 st->internal->orig_codec_id = st->codec->codec_id;
3633 FF_ENABLE_DEPRECATION_WARNINGS
3635 // only for the split stuff
3636 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3637 st->parser = av_parser_init(st->codecpar->codec_id);
3639 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3640 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3641 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3642 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3644 } else if (st->need_parsing) {
3645 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3646 "%s, packets or times may be invalid.\n",
3647 avcodec_get_name(st->codecpar->codec_id));
3651 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3652 st->internal->orig_codec_id = st->codecpar->codec_id;
3654 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3656 goto find_stream_info_err;
3657 if (st->internal->request_probe <= 0)
3658 st->internal->avctx_inited = 1;
3660 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3662 /* Force thread count to 1 since the H.264 decoder will not extract
3663 * SPS and PPS to extradata during multi-threaded decoding. */
3664 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3666 if (ic->codec_whitelist)
3667 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3669 /* Ensure that subtitle_header is properly set. */
3670 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3671 && codec && !avctx->codec) {
3672 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3673 av_log(ic, AV_LOG_WARNING,
3674 "Failed to open codec in %s\n",__FUNCTION__);
3677 // Try to just open decoders, in case this is enough to get parameters.
3678 if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0) {
3679 if (codec && !avctx->codec)
3680 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3681 av_log(ic, AV_LOG_WARNING,
3682 "Failed to open codec in %s\n",__FUNCTION__);
3685 av_dict_free(&thread_opt);
3688 for (i = 0; i < ic->nb_streams; i++) {
3689 #if FF_API_R_FRAME_RATE
3690 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3692 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3693 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3698 const AVPacket *pkt;
3699 int analyzed_all_streams;
3700 if (ff_check_interrupt(&ic->interrupt_callback)) {
3702 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3706 /* check if one codec still needs to be handled */
3707 for (i = 0; i < ic->nb_streams; i++) {
3708 int fps_analyze_framecount = 20;
3711 st = ic->streams[i];
3712 if (!has_codec_parameters(st, NULL))
3714 /* If the timebase is coarse (like the usual millisecond precision
3715 * of mkv), we need to analyze more frames to reliably arrive at
3716 * the correct fps. */
3717 if (av_q2d(st->time_base) > 0.0005)
3718 fps_analyze_framecount *= 2;
3719 if (!tb_unreliable(st->internal->avctx))
3720 fps_analyze_framecount = 0;
3721 if (ic->fps_probe_size >= 0)
3722 fps_analyze_framecount = ic->fps_probe_size;
3723 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3724 fps_analyze_framecount = 0;
3725 /* variable fps and no guess at the real fps */
3726 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3727 st->internal->info->codec_info_duration_fields/2 :
3728 st->internal->info->duration_count;
3729 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3730 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3731 if (count < fps_analyze_framecount)
3734 // Look at the first 3 frames if there is evidence of frame delay
3735 // but the decoder delay is not set.
3736 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3738 if (!st->internal->avctx->extradata &&
3739 (!st->internal->extract_extradata.inited ||
3740 st->internal->extract_extradata.bsf) &&
3741 extract_extradata_check(st))
3743 if (st->first_dts == AV_NOPTS_VALUE &&
3744 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3745 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3746 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3747 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3750 analyzed_all_streams = 0;
3751 if (!missing_streams || !*missing_streams)
3752 if (i == ic->nb_streams) {
3753 analyzed_all_streams = 1;
3754 /* NOTE: If the format has no header, then we need to read some
3755 * packets to get most of the streams, so we cannot stop here. */
3756 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3757 /* If we found the info for all the codecs, we can stop. */
3759 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3764 /* We did not get all the codec info, but we read too much data. */
3765 if (read_size >= probesize) {
3767 av_log(ic, AV_LOG_DEBUG,
3768 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3769 for (i = 0; i < ic->nb_streams; i++)
3770 if (!ic->streams[i]->r_frame_rate.num &&
3771 ic->streams[i]->internal->info->duration_count <= 1 &&
3772 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3773 strcmp(ic->iformat->name, "image2"))
3774 av_log(ic, AV_LOG_WARNING,
3775 "Stream #%d: not enough frames to estimate rate; "
3776 "consider increasing probesize\n", i);
3780 /* NOTE: A new stream can be added there if no header in file
3781 * (AVFMTCTX_NOHEADER). */
3782 ret = read_frame_internal(ic, &pkt1);
3783 if (ret == AVERROR(EAGAIN))
3792 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3793 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3794 &ic->internal->packet_buffer_end,
3797 goto unref_then_goto_end;
3799 pkt = &ic->internal->packet_buffer_end->pkt;
3804 st = ic->streams[pkt->stream_index];
3805 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3806 read_size += pkt->size;
3808 avctx = st->internal->avctx;
3809 if (!st->internal->avctx_inited) {
3810 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3812 goto unref_then_goto_end;
3813 st->internal->avctx_inited = 1;
3816 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3817 /* check for non-increasing dts */
3818 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3819 st->internal->info->fps_last_dts >= pkt->dts) {
3820 av_log(ic, AV_LOG_DEBUG,
3821 "Non-increasing DTS in stream %d: packet %d with DTS "
3822 "%"PRId64", packet %d with DTS %"PRId64"\n",
3823 st->index, st->internal->info->fps_last_dts_idx,
3824 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3826 st->internal->info->fps_first_dts =
3827 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3829 /* Check for a discontinuity in dts. If the difference in dts
3830 * is more than 1000 times the average packet duration in the
3831 * sequence, we treat it as a discontinuity. */
3832 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3833 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3834 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3835 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3836 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3837 av_log(ic, AV_LOG_WARNING,
3838 "DTS discontinuity in stream %d: packet %d with DTS "
3839 "%"PRId64", packet %d with DTS %"PRId64"\n",
3840 st->index, st->internal->info->fps_last_dts_idx,
3841 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3843 st->internal->info->fps_first_dts =
3844 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3847 /* update stored dts values */
3848 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3849 st->internal->info->fps_first_dts = pkt->dts;
3850 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3852 st->internal->info->fps_last_dts = pkt->dts;
3853 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3855 if (st->codec_info_nb_frames>1) {
3859 if (st->time_base.den > 0)
3860 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3861 if (st->avg_frame_rate.num > 0)
3862 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3865 && st->codec_info_nb_frames>30
3866 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3867 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE)
3868 t = FFMAX(t, av_rescale_q(st->internal->info->fps_last_dts - st->internal->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3870 if (analyzed_all_streams) limit = max_analyze_duration;
3871 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3872 else limit = max_stream_analyze_duration;
3875 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3877 t, pkt->stream_index);
3878 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3879 av_packet_unref(&pkt1);
3882 if (pkt->duration) {
3883 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3884 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3886 st->internal->info->codec_info_duration += pkt->duration;
3887 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3890 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3891 #if FF_API_R_FRAME_RATE
3892 ff_rfps_add_frame(ic, st, pkt->dts);
3894 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3895 st->internal->info->frame_delay_evidence = 1;
3897 if (!st->internal->avctx->extradata) {
3898 ret = extract_extradata(st, pkt);
3900 goto unref_then_goto_end;
3903 /* If still no information, we try to open the codec and to
3904 * decompress the frame. We try to avoid that in most cases as
3905 * it takes longer and uses more memory. For MPEG-4, we need to
3906 * decompress for QuickTime.
3908 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3909 * least one frame of codec data, this makes sure the codec initializes
3910 * the channel configuration and does not only trust the values from
3912 try_decode_frame(ic, st, pkt,
3913 (options && i < orig_nb_streams) ? &options[i] : NULL);
3915 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3916 av_packet_unref(&pkt1);
3918 st->codec_info_nb_frames++;
3924 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3925 st = ic->streams[stream_index];
3926 avctx = st->internal->avctx;
3927 if (!has_codec_parameters(st, NULL)) {
3928 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3929 if (codec && !avctx->codec) {
3930 AVDictionary *opts = NULL;
3931 if (ic->codec_whitelist)
3932 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3933 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3934 av_log(ic, AV_LOG_WARNING,
3935 "Failed to open codec in %s\n",__FUNCTION__);
3936 av_dict_free(&opts);
3940 // EOF already reached while reading the stream above.
3941 // So continue with reoordering DTS with whatever delay we have.
3942 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3943 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3949 AVPacket empty_pkt = { 0 };
3951 av_init_packet(&empty_pkt);
3953 for (i = 0; i < ic->nb_streams; i++) {
3955 st = ic->streams[i];
3957 /* flush the decoders */
3958 if (st->internal->info->found_decoder == 1) {
3960 err = try_decode_frame(ic, st, &empty_pkt,
3961 (options && i < orig_nb_streams)
3962 ? &options[i] : NULL);
3963 } while (err > 0 && !has_codec_parameters(st, NULL));
3966 av_log(ic, AV_LOG_INFO,
3967 "decoding for stream %d failed\n", st->index);
3973 ff_rfps_calculate(ic);
3975 for (i = 0; i < ic->nb_streams; i++) {
3976 st = ic->streams[i];
3977 avctx = st->internal->avctx;
3978 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3979 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3980 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3981 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3982 avctx->codec_tag= tag;
3985 /* estimate average framerate if not set by demuxer */
3986 if (st->internal->info->codec_info_duration_fields &&
3987 !st->avg_frame_rate.num &&
3988 st->internal->info->codec_info_duration) {
3990 double best_error = 0.01;
3991 AVRational codec_frame_rate = avctx->framerate;
3993 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3994 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3995 st->internal->info->codec_info_duration < 0)
3997 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3998 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3999 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4001 /* Round guessed framerate to a "standard" framerate if it's
4002 * within 1% of the original estimate. */
4003 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4004 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4005 double error = fabs(av_q2d(st->avg_frame_rate) /
4006 av_q2d(std_fps) - 1);
4008 if (error < best_error) {
4010 best_fps = std_fps.num;
4013 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4014 error = fabs(av_q2d(codec_frame_rate) /
4015 av_q2d(std_fps) - 1);
4016 if (error < best_error) {
4018 best_fps = std_fps.num;
4023 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4024 best_fps, 12 * 1001, INT_MAX);
4027 if (!st->r_frame_rate.num) {
4028 if ( avctx->time_base.den * (int64_t) st->time_base.num
4029 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4030 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4031 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4033 st->r_frame_rate.num = st->time_base.den;
4034 st->r_frame_rate.den = st->time_base.num;
4037 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4038 AVRational hw_ratio = { avctx->height, avctx->width };
4039 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4042 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4043 if (!avctx->bits_per_coded_sample)
4044 avctx->bits_per_coded_sample =
4045 av_get_bits_per_sample(avctx->codec_id);
4046 // set stream disposition based on audio service type
4047 switch (avctx->audio_service_type) {
4048 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4049 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4051 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4052 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4054 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4055 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4057 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4058 st->disposition = AV_DISPOSITION_COMMENT;
4060 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4061 st->disposition = AV_DISPOSITION_KARAOKE;
4068 estimate_timings(ic, old_offset);
4070 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4072 if (ret >= 0 && ic->nb_streams)
4073 /* We could not have all the codec parameters before EOF. */
4075 for (i = 0; i < ic->nb_streams; i++) {
4077 st = ic->streams[i];
4079 /* if no packet was ever seen, update context now for has_codec_parameters */
4080 if (!st->internal->avctx_inited) {
4081 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4082 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4083 st->codecpar->format = st->internal->avctx->sample_fmt;
4084 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4086 goto find_stream_info_err;
4088 if (!has_codec_parameters(st, &errmsg)) {
4090 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4091 av_log(ic, AV_LOG_WARNING,
4092 "Could not find codec parameters for stream %d (%s): %s\n"
4093 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4094 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4100 ret = compute_chapters_end(ic);
4102 goto find_stream_info_err;
4104 /* update the stream parameters from the internal codec contexts */
4105 for (i = 0; i < ic->nb_streams; i++) {
4106 st = ic->streams[i];
4108 if (st->internal->avctx_inited) {
4109 int orig_w = st->codecpar->width;
4110 int orig_h = st->codecpar->height;
4111 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4113 goto find_stream_info_err;
4114 ret = add_coded_side_data(st, st->internal->avctx);
4116 goto find_stream_info_err;
4118 // The decoder might reduce the video size by the lowres factor.
4119 if (st->internal->avctx->lowres && orig_w) {
4120 st->codecpar->width = orig_w;
4121 st->codecpar->height = orig_h;
4126 #if FF_API_LAVF_AVCTX
4127 FF_DISABLE_DEPRECATION_WARNINGS
4128 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4130 goto find_stream_info_err;
4133 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4134 // by the lowres factor.
4135 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4136 st->codec->lowres = st->internal->avctx->lowres;
4137 st->codec->width = st->internal->avctx->width;
4138 st->codec->height = st->internal->avctx->height;
4142 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4143 st->codec->time_base = st->internal->avctx->time_base;
4144 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4146 st->codec->framerate = st->avg_frame_rate;
4148 if (st->internal->avctx->subtitle_header) {
4149 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4150 if (!st->codec->subtitle_header)
4151 goto find_stream_info_err;
4152 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4153 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4154 st->codec->subtitle_header_size);
4157 // Fields unavailable in AVCodecParameters
4158 st->codec->coded_width = st->internal->avctx->coded_width;
4159 st->codec->coded_height = st->internal->avctx->coded_height;
4160 st->codec->properties = st->internal->avctx->properties;
4161 FF_ENABLE_DEPRECATION_WARNINGS
4164 st->internal->avctx_inited = 0;
4167 find_stream_info_err:
4168 for (i = 0; i < ic->nb_streams; i++) {
4169 st = ic->streams[i];
4170 if (st->internal->info)
4171 av_freep(&st->internal->info->duration_error);
4172 avcodec_close(ic->streams[i]->internal->avctx);
4173 av_freep(&ic->streams[i]->internal->info);
4174 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4175 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4178 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4179 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4182 unref_then_goto_end:
4183 av_packet_unref(&pkt1);
4184 goto find_stream_info_err;
4187 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4191 for (i = 0; i < ic->nb_programs; i++) {
4192 if (ic->programs[i] == last) {
4196 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4197 if (ic->programs[i]->stream_index[j] == s)
4198 return ic->programs[i];
4204 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4205 int wanted_stream_nb, int related_stream,
4206 AVCodec **decoder_ret, int flags)
4208 int i, nb_streams = ic->nb_streams;
4209 int ret = AVERROR_STREAM_NOT_FOUND;
4210 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4211 int count, multiframe, disposition;
4212 int64_t best_bitrate = -1;
4214 unsigned *program = NULL;
4215 const AVCodec *decoder = NULL, *best_decoder = NULL;
4217 if (related_stream >= 0 && wanted_stream_nb < 0) {
4218 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4220 program = p->stream_index;
4221 nb_streams = p->nb_stream_indexes;
4224 for (i = 0; i < nb_streams; i++) {
4225 int real_stream_index = program ? program[i] : i;
4226 AVStream *st = ic->streams[real_stream_index];
4227 AVCodecParameters *par = st->codecpar;
4228 if (par->codec_type != type)
4230 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4232 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4235 decoder = find_decoder(ic, st, par->codec_id);
4238 ret = AVERROR_DECODER_NOT_FOUND;
4242 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4243 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4244 count = st->codec_info_nb_frames;
4245 bitrate = par->bit_rate;
4246 multiframe = FFMIN(5, count);
4247 if ((best_disposition > disposition) ||
4248 (best_disposition == disposition && best_multiframe > multiframe) ||
4249 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4250 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4252 best_disposition = disposition;
4254 best_bitrate = bitrate;
4255 best_multiframe = multiframe;
4256 ret = real_stream_index;
4257 best_decoder = decoder;
4258 if (program && i == nb_streams - 1 && ret < 0) {
4260 nb_streams = ic->nb_streams;
4261 /* no related stream found, try again with everything */
4266 *decoder_ret = (AVCodec*)best_decoder;
4270 /*******************************************************/
4272 int av_read_play(AVFormatContext *s)
4274 if (s->iformat->read_play)
4275 return s->iformat->read_play(s);
4277 return avio_pause(s->pb, 0);
4278 return AVERROR(ENOSYS);
4281 int av_read_pause(AVFormatContext *s)
4283 if (s->iformat->read_pause)
4284 return s->iformat->read_pause(s);
4286 return avio_pause(s->pb, 1);
4287 return AVERROR(ENOSYS);
4290 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4295 dst->time_base = src->time_base;
4296 dst->nb_frames = src->nb_frames;
4297 dst->disposition = src->disposition;
4298 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4299 dst->avg_frame_rate = src->avg_frame_rate;
4300 dst->r_frame_rate = src->r_frame_rate;
4302 av_dict_free(&dst->metadata);
4303 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4307 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4311 /* Free existing side data*/
4312 for (i = 0; i < dst->nb_side_data; i++)
4313 av_free(dst->side_data[i].data);
4314 av_freep(&dst->side_data);
4315 dst->nb_side_data = 0;
4317 /* Copy side data if present */
4318 if (src->nb_side_data) {
4319 dst->side_data = av_mallocz_array(src->nb_side_data,
4320 sizeof(AVPacketSideData));
4321 if (!dst->side_data)
4322 return AVERROR(ENOMEM);
4323 dst->nb_side_data = src->nb_side_data;
4325 for (i = 0; i < src->nb_side_data; i++) {
4326 uint8_t *data = av_memdup(src->side_data[i].data,
4327 src->side_data[i].size);
4329 return AVERROR(ENOMEM);
4330 dst->side_data[i].type = src->side_data[i].type;
4331 dst->side_data[i].size = src->side_data[i].size;
4332 dst->side_data[i].data = data;
4336 #if FF_API_LAVF_FFSERVER
4337 FF_DISABLE_DEPRECATION_WARNINGS
4338 av_freep(&dst->recommended_encoder_configuration);
4339 if (src->recommended_encoder_configuration) {
4340 const char *conf_str = src->recommended_encoder_configuration;
4341 dst->recommended_encoder_configuration = av_strdup(conf_str);
4342 if (!dst->recommended_encoder_configuration)
4343 return AVERROR(ENOMEM);
4345 FF_ENABLE_DEPRECATION_WARNINGS
4351 static void free_stream(AVStream **pst)
4353 AVStream *st = *pst;
4359 for (i = 0; i < st->nb_side_data; i++)
4360 av_freep(&st->side_data[i].data);
4361 av_freep(&st->side_data);
4364 av_parser_close(st->parser);
4366 if (st->attached_pic.data)
4367 av_packet_unref(&st->attached_pic);
4370 avcodec_free_context(&st->internal->avctx);
4371 av_bsf_free(&st->internal->bsfc);
4372 av_freep(&st->internal->priv_pts);
4373 av_freep(&st->internal->index_entries);
4374 av_freep(&st->internal->probe_data.buf);
4376 av_bsf_free(&st->internal->extract_extradata.bsf);
4377 av_packet_free(&st->internal->extract_extradata.pkt);
4379 if (st->internal->info)
4380 av_freep(&st->internal->info->duration_error);
4381 av_freep(&st->internal->info);
4383 av_freep(&st->internal);
4385 av_dict_free(&st->metadata);
4386 avcodec_parameters_free(&st->codecpar);
4387 #if FF_API_LAVF_AVCTX
4388 FF_DISABLE_DEPRECATION_WARNINGS
4389 avcodec_free_context(&st->codec);
4390 FF_ENABLE_DEPRECATION_WARNINGS
4392 av_freep(&st->priv_data);
4393 #if FF_API_LAVF_FFSERVER
4394 FF_DISABLE_DEPRECATION_WARNINGS
4395 av_freep(&st->recommended_encoder_configuration);
4396 FF_ENABLE_DEPRECATION_WARNINGS
4402 void ff_free_stream(AVFormatContext *s, AVStream *st)
4404 av_assert0(s->nb_streams>0);
4405 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4407 free_stream(&s->streams[ --s->nb_streams ]);
4410 void avformat_free_context(AVFormatContext *s)
4417 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4418 s->oformat->deinit(s);
4421 if (s->iformat && s->iformat->priv_class && s->priv_data)
4422 av_opt_free(s->priv_data);
4423 if (s->oformat && s->oformat->priv_class && s->priv_data)
4424 av_opt_free(s->priv_data);
4426 for (i = 0; i < s->nb_streams; i++)
4427 free_stream(&s->streams[i]);
4430 for (i = 0; i < s->nb_programs; i++) {
4431 av_dict_free(&s->programs[i]->metadata);
4432 av_freep(&s->programs[i]->stream_index);
4433 av_freep(&s->programs[i]);
4437 av_freep(&s->programs);
4438 av_freep(&s->priv_data);
4439 while (s->nb_chapters--) {
4440 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4441 av_freep(&s->chapters[s->nb_chapters]);
4443 av_freep(&s->chapters);
4444 av_dict_free(&s->metadata);
4445 av_dict_free(&s->internal->id3v2_meta);
4446 av_freep(&s->streams);
4447 flush_packet_queue(s);
4448 av_freep(&s->internal);
4453 void avformat_close_input(AVFormatContext **ps)
4464 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4465 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4468 flush_packet_queue(s);
4471 if (s->iformat->read_close)
4472 s->iformat->read_close(s);
4474 avformat_free_context(s);
4481 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4487 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4488 if (s->max_streams < INT_MAX/sizeof(*streams))
4489 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);
4492 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4495 s->streams = streams;
4497 st = av_mallocz(sizeof(AVStream));
4501 #if FF_API_LAVF_AVCTX
4502 FF_DISABLE_DEPRECATION_WARNINGS
4503 st->codec = avcodec_alloc_context3(c);
4508 FF_ENABLE_DEPRECATION_WARNINGS
4511 st->internal = av_mallocz(sizeof(*st->internal));
4515 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4516 if (!st->internal->info)
4518 st->internal->info->last_dts = AV_NOPTS_VALUE;
4520 st->codecpar = avcodec_parameters_alloc();
4524 st->internal->avctx = avcodec_alloc_context3(NULL);
4525 if (!st->internal->avctx)
4529 #if FF_API_LAVF_AVCTX
4530 FF_DISABLE_DEPRECATION_WARNINGS
4531 /* no default bitrate if decoding */
4532 st->codec->bit_rate = 0;
4533 FF_ENABLE_DEPRECATION_WARNINGS
4536 /* default pts setting is MPEG-like */
4537 avpriv_set_pts_info(st, 33, 1, 90000);
4538 /* we set the current DTS to 0 so that formats without any timestamps
4539 * but durations get some timestamps, formats with some unknown
4540 * timestamps have their first few packets buffered and the
4541 * timestamps corrected before they are returned to the user */
4542 st->cur_dts = RELATIVE_TS_BASE;
4544 st->cur_dts = AV_NOPTS_VALUE;
4547 st->index = s->nb_streams;
4548 st->start_time = AV_NOPTS_VALUE;
4549 st->duration = AV_NOPTS_VALUE;
4550 st->first_dts = AV_NOPTS_VALUE;
4551 st->probe_packets = s->max_probe_packets;
4552 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4553 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4555 st->last_IP_pts = AV_NOPTS_VALUE;
4556 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4557 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4558 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4560 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4562 #if FF_API_R_FRAME_RATE
4563 st->internal->info->last_dts = AV_NOPTS_VALUE;
4565 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4566 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4568 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4570 st->internal->need_context_update = 1;
4572 s->streams[s->nb_streams++] = st;
4579 AVProgram *av_new_program(AVFormatContext *ac, int id)
4581 AVProgram *program = NULL;
4584 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4586 for (i = 0; i < ac->nb_programs; i++)
4587 if (ac->programs[i]->id == id)
4588 program = ac->programs[i];
4591 program = av_mallocz(sizeof(AVProgram));
4594 dynarray_add(&ac->programs, &ac->nb_programs, program);
4595 program->discard = AVDISCARD_NONE;
4596 program->pmt_version = -1;
4598 program->pts_wrap_reference = AV_NOPTS_VALUE;
4599 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4600 program->start_time =
4601 program->end_time = AV_NOPTS_VALUE;
4606 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4607 int64_t start, int64_t end, const char *title)
4609 AVChapter *chapter = NULL;
4612 if (end != AV_NOPTS_VALUE && start > end) {
4613 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4617 for (i = 0; i < s->nb_chapters; i++)
4618 if (s->chapters[i]->id == id)
4619 chapter = s->chapters[i];
4622 chapter = av_mallocz(sizeof(AVChapter));
4625 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4627 av_dict_set(&chapter->metadata, "title", title, 0);
4629 chapter->time_base = time_base;
4630 chapter->start = start;
4636 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4639 AVProgram *program = NULL;
4642 if (idx >= ac->nb_streams) {
4643 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4647 for (i = 0; i < ac->nb_programs; i++) {
4648 if (ac->programs[i]->id != progid)
4650 program = ac->programs[i];
4651 for (j = 0; j < program->nb_stream_indexes; j++)
4652 if (program->stream_index[j] == idx)
4655 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4658 program->stream_index = tmp;
4659 program->stream_index[program->nb_stream_indexes++] = idx;
4664 uint64_t ff_ntp_time(void)
4666 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4669 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4671 uint64_t ntp_ts, frac_part, sec;
4674 //current ntp time in seconds and micro seconds
4675 sec = ntp_time_us / 1000000;
4676 usec = ntp_time_us % 1000000;
4678 //encoding in ntp timestamp format
4679 frac_part = usec * 0xFFFFFFFFULL;
4680 frac_part /= 1000000;
4682 if (sec > 0xFFFFFFFFULL)
4683 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4686 ntp_ts |= frac_part;
4691 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4694 char *q, buf1[20], c;
4695 int nd, len, percentd_found;
4707 while (av_isdigit(*p)) {
4708 if (nd >= INT_MAX / 10 - 255)
4710 nd = nd * 10 + *p++ - '0';
4713 } while (av_isdigit(c));
4719 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4724 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4726 if ((q - buf + len) > buf_size - 1)
4728 memcpy(q, buf1, len);
4736 if ((q - buf) < buf_size - 1)
4740 if (!percentd_found)
4749 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4751 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4754 void av_url_split(char *proto, int proto_size,
4755 char *authorization, int authorization_size,
4756 char *hostname, int hostname_size,
4757 int *port_ptr, char *path, int path_size, const char *url)
4759 const char *p, *ls, *at, *at2, *col, *brk;
4765 if (authorization_size > 0)
4766 authorization[0] = 0;
4767 if (hostname_size > 0)
4772 /* parse protocol */
4773 if ((p = strchr(url, ':'))) {
4774 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4781 /* no protocol means plain filename */
4782 av_strlcpy(path, url, path_size);
4786 /* separate path from hostname */
4787 ls = p + strcspn(p, "/?#");
4788 av_strlcpy(path, ls, path_size);
4790 /* the rest is hostname, use that to parse auth/port */
4792 /* authorization (user[:pass]@hostname) */
4794 while ((at = strchr(p, '@')) && at < ls) {
4795 av_strlcpy(authorization, at2,
4796 FFMIN(authorization_size, at + 1 - at2));
4797 p = at + 1; /* skip '@' */
4800 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4802 av_strlcpy(hostname, p + 1,
4803 FFMIN(hostname_size, brk - p));
4804 if (brk[1] == ':' && port_ptr)
4805 *port_ptr = atoi(brk + 2);
4806 } else if ((col = strchr(p, ':')) && col < ls) {
4807 av_strlcpy(hostname, p,
4808 FFMIN(col + 1 - p, hostname_size));
4810 *port_ptr = atoi(col + 1);
4812 av_strlcpy(hostname, p,
4813 FFMIN(ls + 1 - p, hostname_size));
4817 int ff_mkdir_p(const char *path)
4820 char *temp = av_strdup(path);
4824 if (!path || !temp) {
4828 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4830 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4834 for ( ; *pos != '\0'; ++pos) {
4835 if (*pos == '/' || *pos == '\\') {
4838 ret = mkdir(temp, 0755);
4843 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4844 ret = mkdir(temp, 0755);
4851 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4854 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4857 'C', 'D', 'E', 'F' };
4858 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4861 'c', 'd', 'e', 'f' };
4862 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4864 for (i = 0; i < s; i++) {
4865 buff[i * 2] = hex_table[src[i] >> 4];
4866 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4872 int ff_hex_to_data(uint8_t *data, const char *p)
4879 p += strspn(p, SPACE_CHARS);
4882 c = av_toupper((unsigned char) *p++);
4883 if (c >= '0' && c <= '9')
4885 else if (c >= 'A' && c <= 'F')
4900 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4901 unsigned int pts_num, unsigned int pts_den)
4904 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4905 if (new_tb.num != pts_num)
4906 av_log(NULL, AV_LOG_DEBUG,
4907 "st:%d removing common factor %d from timebase\n",
4908 s->index, pts_num / new_tb.num);
4910 av_log(NULL, AV_LOG_WARNING,
4911 "st:%d has too large timebase, reducing\n", s->index);
4913 if (new_tb.num <= 0 || new_tb.den <= 0) {
4914 av_log(NULL, AV_LOG_ERROR,
4915 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4916 new_tb.num, new_tb.den,
4920 s->time_base = new_tb;
4921 #if FF_API_LAVF_AVCTX
4922 FF_DISABLE_DEPRECATION_WARNINGS
4923 s->codec->pkt_timebase = new_tb;
4924 FF_ENABLE_DEPRECATION_WARNINGS
4926 s->internal->avctx->pkt_timebase = new_tb;
4927 s->pts_wrap_bits = pts_wrap_bits;
4930 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4933 const char *ptr = str;
4935 /* Parse key=value pairs. */
4938 char *dest = NULL, *dest_end;
4939 int key_len, dest_len = 0;
4941 /* Skip whitespace and potential commas. */
4942 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4949 if (!(ptr = strchr(key, '=')))
4952 key_len = ptr - key;
4954 callback_get_buf(context, key, key_len, &dest, &dest_len);
4955 dest_end = dest + dest_len - 1;
4959 while (*ptr && *ptr != '\"') {
4963 if (dest && dest < dest_end)
4967 if (dest && dest < dest_end)
4975 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4976 if (dest && dest < dest_end)
4984 int ff_find_stream_index(AVFormatContext *s, int id)
4987 for (i = 0; i < s->nb_streams; i++)
4988 if (s->streams[i]->id == id)
4993 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4997 unsigned int codec_tag;
4998 if (ofmt->query_codec)
4999 return ofmt->query_codec(codec_id, std_compliance);
5000 else if (ofmt->codec_tag)
5001 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5002 else if (codec_id == ofmt->video_codec ||
5003 codec_id == ofmt->audio_codec ||
5004 codec_id == ofmt->subtitle_codec ||
5005 codec_id == ofmt->data_codec)
5008 return AVERROR_PATCHWELCOME;
5011 int avformat_network_init(void)
5015 if ((ret = ff_network_init()) < 0)
5017 if ((ret = ff_tls_init()) < 0)
5023 int avformat_network_deinit(void)
5032 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5033 uint64_t channel_layout, int32_t sample_rate,
5034 int32_t width, int32_t height)
5040 return AVERROR(EINVAL);
5043 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5045 if (channel_layout) {
5047 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5051 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5053 if (width || height) {
5055 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5057 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5059 return AVERROR(ENOMEM);
5060 bytestream_put_le32(&data, flags);
5062 bytestream_put_le32(&data, channels);
5064 bytestream_put_le64(&data, channel_layout);
5066 bytestream_put_le32(&data, sample_rate);
5067 if (width || height) {
5068 bytestream_put_le32(&data, width);
5069 bytestream_put_le32(&data, height);
5074 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5076 AVRational undef = {0, 1};
5077 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5078 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5079 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5081 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5082 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5083 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5084 stream_sample_aspect_ratio = undef;
5086 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5087 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5088 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5089 frame_sample_aspect_ratio = undef;
5091 if (stream_sample_aspect_ratio.num)
5092 return stream_sample_aspect_ratio;
5094 return frame_sample_aspect_ratio;
5097 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5099 AVRational fr = st->r_frame_rate;
5100 AVRational codec_fr = st->internal->avctx->framerate;
5101 AVRational avg_fr = st->avg_frame_rate;
5103 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5104 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5109 if (st->internal->avctx->ticks_per_frame > 1) {
5110 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5111 (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))
5119 * Matches a stream specifier (but ignores requested index).
5121 * @param indexptr set to point to the requested stream index if there is one
5123 * @return <0 on error
5124 * 0 if st is NOT a matching stream
5125 * >0 if st is a matching stream
5127 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5128 const char *spec, const char **indexptr, AVProgram **p)
5130 int match = 1; /* Stores if the specifier matches so far. */
5132 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5136 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5137 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5138 enum AVMediaType type;
5142 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5143 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5144 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5145 case 'd': type = AVMEDIA_TYPE_DATA; break;
5146 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5147 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5148 default: av_assert0(0);
5150 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5151 return AVERROR(EINVAL);
5153 #if FF_API_LAVF_AVCTX
5154 FF_DISABLE_DEPRECATION_WARNINGS
5155 if (type != st->codecpar->codec_type
5156 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5158 FF_ENABLE_DEPRECATION_WARNINGS
5160 if (type != st->codecpar->codec_type)
5163 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5165 } else if (*spec == 'p' && *(spec + 1) == ':') {
5170 prog_id = strtol(spec, &endptr, 0);
5171 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5172 if (spec == endptr || (*endptr && *endptr++ != ':'))
5173 return AVERROR(EINVAL);
5176 for (i = 0; i < s->nb_programs; i++) {
5177 if (s->programs[i]->id != prog_id)
5180 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5181 if (st->index == s->programs[i]->stream_index[j]) {
5184 *p = s->programs[i];
5193 } else if (*spec == '#' ||
5194 (*spec == 'i' && *(spec + 1) == ':')) {
5197 spec += 1 + (*spec == 'i');
5198 stream_id = strtol(spec, &endptr, 0);
5199 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5200 return AVERROR(EINVAL);
5201 return match && (stream_id == st->id);
5202 } else if (*spec == 'm' && *(spec + 1) == ':') {
5203 AVDictionaryEntry *tag;
5209 val = strchr(spec, ':');
5211 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5213 return AVERROR(ENOMEM);
5215 tag = av_dict_get(st->metadata, key, NULL, 0);
5217 if (!val || !strcmp(tag->value, val + 1))
5226 return match && ret;
5227 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5228 AVCodecParameters *par = st->codecpar;
5229 #if FF_API_LAVF_AVCTX
5230 FF_DISABLE_DEPRECATION_WARNINGS
5231 AVCodecContext *codec = st->codec;
5232 FF_ENABLE_DEPRECATION_WARNINGS
5235 switch (par->codec_type) {
5236 case AVMEDIA_TYPE_AUDIO:
5237 val = par->sample_rate && par->channels;
5238 #if FF_API_LAVF_AVCTX
5239 val = val || (codec->sample_rate && codec->channels);
5241 if (par->format == AV_SAMPLE_FMT_NONE
5242 #if FF_API_LAVF_AVCTX
5243 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5248 case AVMEDIA_TYPE_VIDEO:
5249 val = par->width && par->height;
5250 #if FF_API_LAVF_AVCTX
5251 val = val || (codec->width && codec->height);
5253 if (par->format == AV_PIX_FMT_NONE
5254 #if FF_API_LAVF_AVCTX
5255 && codec->pix_fmt == AV_PIX_FMT_NONE
5260 case AVMEDIA_TYPE_UNKNOWN:
5267 #if FF_API_LAVF_AVCTX
5268 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5270 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5273 return AVERROR(EINVAL);
5281 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5286 const char *indexptr = NULL;
5287 AVProgram *p = NULL;
5290 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5297 index = strtol(indexptr, &endptr, 0);
5298 if (*endptr) { /* We can't have anything after the requested index. */
5299 ret = AVERROR(EINVAL);
5303 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5304 if (spec == indexptr)
5305 return (index == st->index);
5307 /* If we requested a matching stream index, we have to ensure st is that. */
5308 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5309 for (int i = 0; i < nb_streams && index >= 0; i++) {
5310 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5311 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5314 if (ret > 0 && index-- == 0 && st == candidate)
5320 if (ret == AVERROR(EINVAL))
5321 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5325 int ff_generate_avci_extradata(AVStream *st)
5327 static const uint8_t avci100_1080p_extradata[] = {
5329 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5330 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5331 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5332 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5333 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5334 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5335 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5336 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5337 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5339 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5342 static const uint8_t avci100_1080i_extradata[] = {
5344 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5345 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5346 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5347 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5348 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5349 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5350 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5351 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5352 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5353 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5354 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5356 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5359 static const uint8_t avci50_1080p_extradata[] = {
5361 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5362 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5363 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5364 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5365 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5366 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5367 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5368 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5369 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5371 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5374 static const uint8_t avci50_1080i_extradata[] = {
5376 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5377 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5378 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5379 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5380 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5381 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5382 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5383 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5384 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5385 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5386 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5388 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5391 static const uint8_t avci100_720p_extradata[] = {
5393 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5394 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5395 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5396 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5397 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5398 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5399 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5400 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5401 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5402 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5404 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5407 static const uint8_t avci50_720p_extradata[] = {
5409 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5410 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5411 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5412 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5413 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5414 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5415 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5416 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5417 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5419 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5423 const uint8_t *data = NULL;
5426 if (st->codecpar->width == 1920) {
5427 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5428 data = avci100_1080p_extradata;
5429 size = sizeof(avci100_1080p_extradata);
5431 data = avci100_1080i_extradata;
5432 size = sizeof(avci100_1080i_extradata);
5434 } else if (st->codecpar->width == 1440) {
5435 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5436 data = avci50_1080p_extradata;
5437 size = sizeof(avci50_1080p_extradata);
5439 data = avci50_1080i_extradata;
5440 size = sizeof(avci50_1080i_extradata);
5442 } else if (st->codecpar->width == 1280) {
5443 data = avci100_720p_extradata;
5444 size = sizeof(avci100_720p_extradata);
5445 } else if (st->codecpar->width == 960) {
5446 data = avci50_720p_extradata;
5447 size = sizeof(avci50_720p_extradata);
5453 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5455 memcpy(st->codecpar->extradata, data, size);
5460 uint8_t *av_stream_get_side_data(const AVStream *st,
5461 enum AVPacketSideDataType type, int *size)
5465 for (i = 0; i < st->nb_side_data; i++) {
5466 if (st->side_data[i].type == type) {
5468 *size = st->side_data[i].size;
5469 return st->side_data[i].data;
5477 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5478 uint8_t *data, size_t size)
5480 AVPacketSideData *sd, *tmp;
5483 for (i = 0; i < st->nb_side_data; i++) {
5484 sd = &st->side_data[i];
5486 if (sd->type == type) {
5487 av_freep(&sd->data);
5494 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5495 return AVERROR(ERANGE);
5497 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5499 return AVERROR(ENOMEM);
5502 st->side_data = tmp;
5505 sd = &st->side_data[st->nb_side_data - 1];
5513 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5517 uint8_t *data = av_malloc(size);
5522 ret = av_stream_add_side_data(st, type, data, size);
5531 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5534 const AVBitStreamFilter *bsf;
5537 av_assert0(!st->internal->bsfc);
5539 if (!(bsf = av_bsf_get_by_name(name))) {
5540 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5541 return AVERROR_BSF_NOT_FOUND;
5544 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5547 bsfc->time_base_in = st->time_base;
5548 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5553 if (args && bsfc->filter->priv_class) {
5554 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5555 const char * shorthand[2] = {NULL};
5558 shorthand[0] = opt->name;
5560 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5566 if ((ret = av_bsf_init(bsfc)) < 0) {
5571 st->internal->bsfc = bsfc;
5573 av_log(NULL, AV_LOG_VERBOSE,
5574 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5575 name, args ? args : "");
5580 FF_DISABLE_DEPRECATION_WARNINGS
5581 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5582 AVBitStreamFilterContext *bsfc)
5586 AVPacket new_pkt = *pkt;
5587 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5588 &new_pkt.data, &new_pkt.size,
5589 pkt->data, pkt->size,
5590 pkt->flags & AV_PKT_FLAG_KEY);
5591 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5592 av_packet_unref(pkt);
5593 memset(pkt, 0, sizeof(*pkt));
5596 if(a == 0 && new_pkt.data != pkt->data) {
5597 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
5599 memcpy(t, new_pkt.data, new_pkt.size);
5600 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5605 a = AVERROR(ENOMEM);
5609 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5610 av_buffer_default_free, NULL, 0);
5612 pkt->side_data = NULL;
5613 pkt->side_data_elems = 0;
5614 av_packet_unref(pkt);
5616 av_freep(&new_pkt.data);
5617 a = AVERROR(ENOMEM);
5621 av_log(codec, AV_LOG_ERROR,
5622 "Failed to open bitstream filter %s for stream %d with codec %s",
5623 bsfc->filter->name, pkt->stream_index,
5624 codec->codec ? codec->codec->name : "copy");
5634 FF_ENABLE_DEPRECATION_WARNINGS
5637 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5640 return AVERROR(EINVAL);
5642 if (!(s->oformat->flags & AVFMT_NOFILE))
5643 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5647 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5650 s->io_close(s, *pb);
5654 int ff_is_http_proto(char *filename) {
5655 const char *proto = avio_find_protocol_name(filename);
5656 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5659 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5661 AVDictionaryEntry *entry;
5662 int64_t parsed_timestamp;
5664 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5665 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5666 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5669 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5676 int ff_standardize_creation_time(AVFormatContext *s)
5679 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5681 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5685 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5690 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5692 if (size != AVPALETTE_SIZE) {
5693 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5694 return AVERROR_INVALIDDATA;
5696 memcpy(palette, side_data, AVPALETTE_SIZE);
5700 if (ret == CONTAINS_PAL) {
5702 for (i = 0; i < AVPALETTE_COUNT; i++)
5703 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5710 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5715 ret = av_bprint_finalize(buf, &str);
5718 if (!av_bprint_is_complete(buf)) {
5720 return AVERROR(ENOMEM);
5723 par->extradata = str;
5724 /* Note: the string is NUL terminated (so extradata can be read as a
5725 * string), but the ending character is not accounted in the size (in
5726 * binary formats you are likely not supposed to mux that character). When
5727 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5729 par->extradata_size = buf->len;
5733 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5734 AVStream *ost, const AVStream *ist,
5735 enum AVTimebaseSource copy_tb)
5737 //TODO: use [io]st->internal->avctx
5738 const AVCodecContext *dec_ctx;
5739 AVCodecContext *enc_ctx;
5741 #if FF_API_LAVF_AVCTX
5742 FF_DISABLE_DEPRECATION_WARNINGS
5743 dec_ctx = ist->codec;
5744 enc_ctx = ost->codec;
5745 FF_ENABLE_DEPRECATION_WARNINGS
5747 dec_ctx = ist->internal->avctx;
5748 enc_ctx = ost->internal->avctx;
5751 enc_ctx->time_base = ist->time_base;
5753 * Avi is a special case here because it supports variable fps but
5754 * having the fps and timebase differe significantly adds quite some
5757 if (!strcmp(ofmt->name, "avi")) {
5758 #if FF_API_R_FRAME_RATE
5759 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5760 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5761 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5762 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5763 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5764 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5765 enc_ctx->time_base.num = ist->r_frame_rate.den;
5766 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5767 enc_ctx->ticks_per_frame = 2;
5770 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5771 && av_q2d(ist->time_base) < 1.0/500
5772 || copy_tb == AVFMT_TBCF_DECODER) {
5773 enc_ctx->time_base = dec_ctx->time_base;
5774 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5775 enc_ctx->time_base.den *= 2;
5776 enc_ctx->ticks_per_frame = 2;
5778 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5779 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5780 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5781 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5782 && av_q2d(ist->time_base) < 1.0/500
5783 || copy_tb == AVFMT_TBCF_DECODER) {
5784 enc_ctx->time_base = dec_ctx->time_base;
5785 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5789 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5790 && dec_ctx->time_base.num < dec_ctx->time_base.den
5791 && dec_ctx->time_base.num > 0
5792 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5793 enc_ctx->time_base = dec_ctx->time_base;
5796 if (ost->avg_frame_rate.num)
5797 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5799 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5800 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5805 AVRational av_stream_get_codec_timebase(const AVStream *st)
5807 // See avformat_transfer_internal_stream_timing_info() TODO.
5808 #if FF_API_LAVF_AVCTX
5809 FF_DISABLE_DEPRECATION_WARNINGS
5810 return st->codec->time_base;
5811 FF_ENABLE_DEPRECATION_WARNINGS
5813 return st->internal->avctx->time_base;
5817 void ff_format_set_url(AVFormatContext *s, char *url)
5822 #if FF_API_FORMAT_FILENAME
5823 FF_DISABLE_DEPRECATION_WARNINGS
5824 av_strlcpy(s->filename, url, sizeof(s->filename));
5825 FF_ENABLE_DEPRECATION_WARNINGS