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 int64_t av_stream_get_end_pts(const AVStream *st)
118 if (st->internal->priv_pts) {
119 return st->internal->priv_pts->val;
121 return AV_NOPTS_VALUE;
124 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
129 void av_format_inject_global_side_data(AVFormatContext *s)
132 s->internal->inject_global_side_data = 1;
133 for (i = 0; i < s->nb_streams; i++) {
134 AVStream *st = s->streams[i];
135 st->internal->inject_global_side_data = 1;
139 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
141 av_assert0(!dst->codec_whitelist &&
142 !dst->format_whitelist &&
143 !dst->protocol_whitelist &&
144 !dst->protocol_blacklist);
145 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
146 dst->format_whitelist = av_strdup(src->format_whitelist);
147 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
148 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
149 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
150 || (src-> format_whitelist && !dst-> format_whitelist)
151 || (src->protocol_whitelist && !dst->protocol_whitelist)
152 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
153 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
154 return AVERROR(ENOMEM);
159 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
161 #if FF_API_LAVF_AVCTX
162 FF_DISABLE_DEPRECATION_WARNINGS
163 if (st->codec->codec)
164 return st->codec->codec;
165 FF_ENABLE_DEPRECATION_WARNINGS
168 switch (st->codecpar->codec_type) {
169 case AVMEDIA_TYPE_VIDEO:
170 if (s->video_codec) return s->video_codec;
172 case AVMEDIA_TYPE_AUDIO:
173 if (s->audio_codec) return s->audio_codec;
175 case AVMEDIA_TYPE_SUBTITLE:
176 if (s->subtitle_codec) return s->subtitle_codec;
180 return avcodec_find_decoder(codec_id);
183 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
185 const AVCodec *codec;
187 #if CONFIG_H264_DECODER
188 /* Other parts of the code assume this decoder to be used for h264,
189 * so force it if possible. */
190 if (codec_id == AV_CODEC_ID_H264)
191 return avcodec_find_decoder_by_name("h264");
194 codec = find_decoder(s, st, codec_id);
198 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
199 const AVCodec *probe_codec = NULL;
201 while ((probe_codec = av_codec_iterate(&iter))) {
202 if (probe_codec->id == codec->id &&
203 av_codec_is_decoder(probe_codec) &&
204 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
213 /* an arbitrarily chosen "sane" max packet size -- 50M */
214 #define SANE_CHUNK_SIZE (50000000)
216 int ffio_limit(AVIOContext *s, int size)
218 if (s->maxsize>= 0) {
219 int64_t pos = avio_tell(s);
220 int64_t remaining= s->maxsize - pos;
221 if (remaining < size) {
222 int64_t newsize = avio_size(s);
223 if (!s->maxsize || s->maxsize<newsize)
224 s->maxsize = newsize - !newsize;
225 if (pos > s->maxsize && s->maxsize >= 0)
226 s->maxsize = AVERROR(EIO);
228 remaining = s->maxsize - pos;
231 if (s->maxsize >= 0 && remaining < size && size > 1) {
232 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG,
233 "Truncating packet of size %d to %"PRId64"\n",
234 size, remaining + !remaining);
235 size = remaining + !remaining;
241 /* Read the data in sane-sized chunks and append to pkt.
242 * Return the number of bytes read or an error. */
243 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
245 int orig_size = pkt->size;
249 int prev_size = pkt->size;
252 /* When the caller requests a lot of data, limit it to the amount
253 * left in file or SANE_CHUNK_SIZE when it is not known. */
255 if (read_size > SANE_CHUNK_SIZE/10) {
256 read_size = ffio_limit(s, read_size);
257 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
259 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
262 ret = av_grow_packet(pkt, read_size);
266 ret = avio_read(s, pkt->data + prev_size, read_size);
267 if (ret != read_size) {
268 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
275 pkt->flags |= AV_PKT_FLAG_CORRUPT;
278 av_packet_unref(pkt);
279 return pkt->size > orig_size ? pkt->size - orig_size : ret;
282 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
284 #if FF_API_INIT_PACKET
285 FF_DISABLE_DEPRECATION_WARNINGS
289 FF_ENABLE_DEPRECATION_WARNINGS
291 av_packet_unref(pkt);
293 pkt->pos = avio_tell(s);
295 return append_packet_chunked(s, pkt, size);
298 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
301 return av_get_packet(s, pkt, size);
302 return append_packet_chunked(s, pkt, size);
305 int av_filename_number_test(const char *filename)
309 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
312 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
315 static const struct {
318 enum AVMediaType type;
320 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
321 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
322 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
323 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
324 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
325 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
326 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
327 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
328 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
329 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
330 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
331 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
332 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
333 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
334 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
338 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
342 av_log(s, AV_LOG_DEBUG,
343 "Probe with size=%d, packets=%d detected %s with score=%d\n",
344 pd->buf_size, s->max_probe_packets - st->probe_packets,
346 for (i = 0; fmt_id_type[i].name; i++) {
347 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
348 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
349 st->codecpar->sample_rate)
351 if (st->internal->request_probe > score &&
352 st->codecpar->codec_id != fmt_id_type[i].id)
354 st->codecpar->codec_id = fmt_id_type[i].id;
355 st->codecpar->codec_type = fmt_id_type[i].type;
356 st->internal->need_context_update = 1;
357 #if FF_API_LAVF_AVCTX
358 FF_DISABLE_DEPRECATION_WARNINGS
359 st->codec->codec_type = st->codecpar->codec_type;
360 st->codec->codec_id = st->codecpar->codec_id;
361 FF_ENABLE_DEPRECATION_WARNINGS
370 /************************************************************/
371 /* input media file */
373 /* Open input file and probe the format if necessary. */
374 static int init_input(AVFormatContext *s, const char *filename,
375 AVDictionary **options)
378 AVProbeData pd = { filename, NULL, 0 };
379 int score = AVPROBE_SCORE_RETRY;
382 s->flags |= AVFMT_FLAG_CUSTOM_IO;
384 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
385 s, 0, s->format_probesize);
386 else if (s->iformat->flags & AVFMT_NOFILE)
387 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
388 "will be ignored with AVFMT_NOFILE format.\n");
392 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
393 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
396 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
401 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
402 s, 0, s->format_probesize);
405 int avformat_queue_attached_pictures(AVFormatContext *s)
408 for (i = 0; i < s->nb_streams; i++)
409 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
410 s->streams[i]->discard < AVDISCARD_ALL) {
411 if (s->streams[i]->attached_pic.size <= 0) {
412 av_log(s, AV_LOG_WARNING,
413 "Attached picture on stream %d has invalid size, "
418 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
419 &s->internal->raw_packet_buffer_end,
420 &s->streams[i]->attached_pic,
428 int ff_add_attached_pic(AVFormatContext *s, AVStream *st0, AVIOContext *pb,
429 AVBufferRef **buf, int size)
435 if (!st && !(st = avformat_new_stream(s, NULL)))
436 return AVERROR(ENOMEM);
437 pkt = &st->attached_pic;
440 av_packet_unref(pkt);
442 pkt->data = (*buf)->data;
443 pkt->size = (*buf)->size - AV_INPUT_BUFFER_PADDING_SIZE;
446 ret = av_get_packet(pb, pkt, size);
450 st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
451 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
453 pkt->stream_index = st->index;
454 pkt->flags |= AV_PKT_FLAG_KEY;
459 ff_free_stream(s, st);
463 static int update_stream_avctx(AVFormatContext *s)
466 for (i = 0; i < s->nb_streams; i++) {
467 AVStream *st = s->streams[i];
469 if (!st->internal->need_context_update)
472 /* close parser, because it depends on the codec */
473 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
474 av_parser_close(st->parser);
478 /* update internal codec context, for the parser */
479 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
483 #if FF_API_LAVF_AVCTX
484 FF_DISABLE_DEPRECATION_WARNINGS
485 /* update deprecated public codec context */
486 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
489 FF_ENABLE_DEPRECATION_WARNINGS
492 st->internal->need_context_update = 0;
498 int avformat_open_input(AVFormatContext **ps, const char *filename,
499 const AVInputFormat *fmt, AVDictionary **options)
501 AVFormatContext *s = *ps;
503 AVDictionary *tmp = NULL;
504 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
506 if (!s && !(s = avformat_alloc_context()))
507 return AVERROR(ENOMEM);
509 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
510 return AVERROR(EINVAL);
516 av_dict_copy(&tmp, *options, 0);
518 if (s->pb) // must be before any goto fail
519 s->flags |= AVFMT_FLAG_CUSTOM_IO;
521 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
524 if (!(s->url = av_strdup(filename ? filename : ""))) {
525 ret = AVERROR(ENOMEM);
529 if ((ret = init_input(s, filename, &tmp)) < 0)
531 s->probe_score = ret;
533 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
534 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
535 if (!s->protocol_whitelist) {
536 ret = AVERROR(ENOMEM);
541 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
542 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
543 if (!s->protocol_blacklist) {
544 ret = AVERROR(ENOMEM);
549 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
550 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
551 ret = AVERROR(EINVAL);
555 avio_skip(s->pb, s->skip_initial_bytes);
557 /* Check filename in case an image number is expected. */
558 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
559 if (!av_filename_number_test(filename)) {
560 ret = AVERROR(EINVAL);
565 s->duration = s->start_time = AV_NOPTS_VALUE;
567 /* Allocate private data. */
568 if (s->iformat->priv_data_size > 0) {
569 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
570 ret = AVERROR(ENOMEM);
573 if (s->iformat->priv_class) {
574 *(const AVClass **) s->priv_data = s->iformat->priv_class;
575 av_opt_set_defaults(s->priv_data);
576 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
581 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
583 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
585 if (s->iformat->read_header)
586 if ((ret = s->iformat->read_header(s)) < 0)
590 s->metadata = s->internal->id3v2_meta;
591 s->internal->id3v2_meta = NULL;
592 } else if (s->internal->id3v2_meta) {
593 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
594 av_dict_free(&s->internal->id3v2_meta);
597 if (id3v2_extra_meta) {
598 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
599 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
600 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
602 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
604 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
607 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
609 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
611 if ((ret = avformat_queue_attached_pictures(s)) < 0)
614 if (s->pb && !s->internal->data_offset)
615 s->internal->data_offset = avio_tell(s->pb);
617 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
619 update_stream_avctx(s);
621 for (i = 0; i < s->nb_streams; i++)
622 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
625 av_dict_free(options);
632 if (s->iformat->read_close)
633 s->iformat->read_close(s);
635 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
637 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
639 avformat_free_context(s);
644 /*******************************************************/
646 static void force_codec_ids(AVFormatContext *s, AVStream *st)
648 switch (st->codecpar->codec_type) {
649 case AVMEDIA_TYPE_VIDEO:
650 if (s->video_codec_id)
651 st->codecpar->codec_id = s->video_codec_id;
653 case AVMEDIA_TYPE_AUDIO:
654 if (s->audio_codec_id)
655 st->codecpar->codec_id = s->audio_codec_id;
657 case AVMEDIA_TYPE_SUBTITLE:
658 if (s->subtitle_codec_id)
659 st->codecpar->codec_id = s->subtitle_codec_id;
661 case AVMEDIA_TYPE_DATA:
662 if (s->data_codec_id)
663 st->codecpar->codec_id = s->data_codec_id;
668 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
670 if (st->internal->request_probe>0) {
671 AVProbeData *pd = &st->internal->probe_data;
673 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
677 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
679 av_log(s, AV_LOG_WARNING,
680 "Failed to reallocate probe buffer for stream %d\n",
685 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
686 pd->buf_size += pkt->size;
687 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
690 st->probe_packets = 0;
692 av_log(s, AV_LOG_WARNING,
693 "nothing to probe for stream %d\n", st->index);
697 end= s->internal->raw_packet_buffer_remaining_size <= 0
698 || st->probe_packets<= 0;
700 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
701 int score = set_codec_from_probe_data(s, st, pd);
702 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
706 st->internal->request_probe = -1;
707 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
708 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
710 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
712 force_codec_ids(s, st);
718 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
720 int64_t ref = pkt->dts;
721 int i, pts_wrap_behavior;
722 int64_t pts_wrap_reference;
723 AVProgram *first_program;
725 if (ref == AV_NOPTS_VALUE)
727 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
729 ref &= (1LL << st->pts_wrap_bits)-1;
731 // reference time stamp should be 60 s before first time stamp
732 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
733 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
734 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
735 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
736 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
738 first_program = av_find_program_from_stream(s, NULL, stream_index);
740 if (!first_program) {
741 int default_stream_index = av_find_default_stream_index(s);
742 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
743 for (i = 0; i < s->nb_streams; i++) {
744 if (av_find_program_from_stream(s, NULL, i))
746 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
747 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
751 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
752 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
756 AVProgram *program = first_program;
758 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
759 pts_wrap_reference = program->pts_wrap_reference;
760 pts_wrap_behavior = program->pts_wrap_behavior;
763 program = av_find_program_from_stream(s, program, stream_index);
766 // update every program with differing pts_wrap_reference
767 program = first_program;
769 if (program->pts_wrap_reference != pts_wrap_reference) {
770 for (i = 0; i<program->nb_stream_indexes; i++) {
771 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
772 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
775 program->pts_wrap_reference = pts_wrap_reference;
776 program->pts_wrap_behavior = pts_wrap_behavior;
778 program = av_find_program_from_stream(s, program, stream_index);
784 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
789 #if FF_API_INIT_PACKET
790 FF_DISABLE_DEPRECATION_WARNINGS
794 FF_ENABLE_DEPRECATION_WARNINGS
796 av_packet_unref(pkt);
800 PacketList *pktl = s->internal->raw_packet_buffer;
801 const AVPacket *pkt1;
804 st = s->streams[pktl->pkt.stream_index];
805 if (s->internal->raw_packet_buffer_remaining_size <= 0)
806 if ((err = probe_codec(s, st, NULL)) < 0)
808 if (st->internal->request_probe <= 0) {
809 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
810 &s->internal->raw_packet_buffer_end, pkt);
811 s->internal->raw_packet_buffer_remaining_size += pkt->size;
816 err = s->iformat->read_packet(s, pkt);
818 av_packet_unref(pkt);
820 /* Some demuxers return FFERROR_REDO when they consume
821 data and discard it (ignored streams, junk, extradata).
822 We must re-call the demuxer to get the real packet. */
823 if (err == FFERROR_REDO)
825 if (!pktl || err == AVERROR(EAGAIN))
827 for (i = 0; i < s->nb_streams; i++) {
829 if (st->probe_packets || st->internal->request_probe > 0)
830 if ((err = probe_codec(s, st, NULL)) < 0)
832 av_assert0(st->internal->request_probe <= 0);
837 err = av_packet_make_refcounted(pkt);
839 av_packet_unref(pkt);
843 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
844 av_log(s, AV_LOG_WARNING,
845 "Packet corrupt (stream = %d, dts = %s)",
846 pkt->stream_index, av_ts2str(pkt->dts));
847 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
848 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
849 av_packet_unref(pkt);
852 av_log(s, AV_LOG_WARNING, ".\n");
855 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
856 "Invalid stream index.\n");
858 st = s->streams[pkt->stream_index];
860 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
861 // correct first time stamps to negative values
862 if (!is_relative(st->first_dts))
863 st->first_dts = wrap_timestamp(st, st->first_dts);
864 if (!is_relative(st->start_time))
865 st->start_time = wrap_timestamp(st, st->start_time);
866 if (!is_relative(st->cur_dts))
867 st->cur_dts = wrap_timestamp(st, st->cur_dts);
870 pkt->dts = wrap_timestamp(st, pkt->dts);
871 pkt->pts = wrap_timestamp(st, pkt->pts);
873 force_codec_ids(s, st);
875 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
876 if (s->use_wallclock_as_timestamps)
877 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
879 if (!pktl && st->internal->request_probe <= 0)
882 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
883 &s->internal->raw_packet_buffer_end,
886 av_packet_unref(pkt);
889 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
890 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
892 if ((err = probe_codec(s, st, pkt1)) < 0)
898 /**********************************************************/
900 static int determinable_frame_size(AVCodecContext *avctx)
902 switch(avctx->codec_id) {
903 case AV_CODEC_ID_MP1:
904 case AV_CODEC_ID_MP2:
905 case AV_CODEC_ID_MP3:
906 case AV_CODEC_ID_CODEC2:
914 * Return the frame duration in seconds. Return 0 if not available.
916 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
917 AVCodecParserContext *pc, AVPacket *pkt)
919 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
920 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
921 int frame_size, sample_rate;
923 #if FF_API_LAVF_AVCTX
924 FF_DISABLE_DEPRECATION_WARNINGS
925 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
926 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
927 FF_ENABLE_DEPRECATION_WARNINGS
932 switch (st->codecpar->codec_type) {
933 case AVMEDIA_TYPE_VIDEO:
934 if (st->r_frame_rate.num && !pc && s->iformat) {
935 *pnum = st->r_frame_rate.den;
936 *pden = st->r_frame_rate.num;
937 } else if (st->time_base.num * 1000LL > st->time_base.den) {
938 *pnum = st->time_base.num;
939 *pden = st->time_base.den;
940 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
941 av_assert0(st->internal->avctx->ticks_per_frame);
942 av_reduce(pnum, pden,
944 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
947 if (pc && pc->repeat_pict) {
948 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
949 av_reduce(pnum, pden,
950 (*pnum) * (1LL + pc->repeat_pict),
954 /* If this codec can be interlaced or progressive then we need
955 * a parser to compute duration of a packet. Thus if we have
956 * no parser in such case leave duration undefined. */
957 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
961 case AVMEDIA_TYPE_AUDIO:
962 if (st->internal->avctx_inited) {
963 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
964 sample_rate = st->internal->avctx->sample_rate;
966 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
967 sample_rate = st->codecpar->sample_rate;
969 if (frame_size <= 0 || sample_rate <= 0)
979 int ff_is_intra_only(enum AVCodecID id)
981 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
984 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
985 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
990 static int has_decode_delay_been_guessed(AVStream *st)
992 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
993 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
995 #if CONFIG_H264_DECODER
996 if (st->internal->avctx->has_b_frames &&
997 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1000 if (st->internal->avctx->has_b_frames<3)
1001 return st->internal->nb_decoded_frames >= 7;
1002 else if (st->internal->avctx->has_b_frames<4)
1003 return st->internal->nb_decoded_frames >= 18;
1005 return st->internal->nb_decoded_frames >= 20;
1008 static PacketList *get_next_pkt(AVFormatContext *s, AVStream *st, PacketList *pktl)
1012 if (pktl == s->internal->packet_buffer_end)
1013 return s->internal->parse_queue;
1017 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1018 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1019 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1022 int delay = st->internal->avctx->has_b_frames;
1025 if (dts == AV_NOPTS_VALUE) {
1026 int64_t best_score = INT64_MAX;
1027 for (i = 0; i<delay; i++) {
1028 if (st->internal->pts_reorder_error_count[i]) {
1029 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1030 if (score < best_score) {
1032 dts = pts_buffer[i];
1037 for (i = 0; i<delay; i++) {
1038 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1039 int64_t diff = FFABS(pts_buffer[i] - dts)
1040 + (uint64_t)st->internal->pts_reorder_error[i];
1041 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1042 st->internal->pts_reorder_error[i] = diff;
1043 st->internal->pts_reorder_error_count[i]++;
1044 if (st->internal->pts_reorder_error_count[i] > 250) {
1045 st->internal->pts_reorder_error[i] >>= 1;
1046 st->internal->pts_reorder_error_count[i] >>= 1;
1053 if (dts == AV_NOPTS_VALUE)
1054 dts = pts_buffer[0];
1060 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1061 * of the packets in a window.
1063 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1064 PacketList *pkt_buffer)
1066 AVStream *st = s->streams[stream_index];
1067 int delay = st->internal->avctx->has_b_frames;
1070 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1072 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1073 pts_buffer[i] = AV_NOPTS_VALUE;
1075 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1076 if (pkt_buffer->pkt.stream_index != stream_index)
1079 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1080 pts_buffer[0] = pkt_buffer->pkt.pts;
1081 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1082 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1084 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1089 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1090 int64_t dts, int64_t pts, AVPacket *pkt)
1092 AVStream *st = s->streams[stream_index];
1093 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1094 PacketList *pktl_it;
1098 if (st->first_dts != AV_NOPTS_VALUE ||
1099 dts == AV_NOPTS_VALUE ||
1100 st->cur_dts == AV_NOPTS_VALUE ||
1101 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1102 dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1106 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1108 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1110 if (is_relative(pts))
1113 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1114 if (pktl_it->pkt.stream_index != stream_index)
1116 if (is_relative(pktl_it->pkt.pts))
1117 pktl_it->pkt.pts += shift;
1119 if (is_relative(pktl_it->pkt.dts))
1120 pktl_it->pkt.dts += shift;
1122 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1123 st->start_time = pktl_it->pkt.pts;
1124 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1125 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));
1129 if (has_decode_delay_been_guessed(st)) {
1130 update_dts_from_pts(s, stream_index, pktl);
1133 if (st->start_time == AV_NOPTS_VALUE) {
1134 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1135 st->start_time = pts;
1137 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1138 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));
1142 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1143 int stream_index, int64_t duration)
1145 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1146 int64_t cur_dts = RELATIVE_TS_BASE;
1148 if (st->first_dts != AV_NOPTS_VALUE) {
1149 if (st->internal->update_initial_durations_done)
1151 st->internal->update_initial_durations_done = 1;
1152 cur_dts = st->first_dts;
1153 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1154 if (pktl->pkt.stream_index == stream_index) {
1155 if (pktl->pkt.pts != pktl->pkt.dts ||
1156 pktl->pkt.dts != AV_NOPTS_VALUE ||
1159 cur_dts -= duration;
1162 if (pktl && pktl->pkt.dts != st->first_dts) {
1163 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1164 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1168 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1171 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1172 st->first_dts = cur_dts;
1173 } else if (st->cur_dts != RELATIVE_TS_BASE)
1176 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1177 if (pktl->pkt.stream_index != stream_index)
1179 if ((pktl->pkt.pts == pktl->pkt.dts ||
1180 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1181 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1182 pktl->pkt.dts == st->first_dts ||
1183 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1184 !pktl->pkt.duration) {
1185 pktl->pkt.dts = cur_dts;
1186 if (!st->internal->avctx->has_b_frames)
1187 pktl->pkt.pts = cur_dts;
1188 pktl->pkt.duration = duration;
1191 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1194 st->cur_dts = cur_dts;
1197 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1198 AVCodecParserContext *pc, AVPacket *pkt,
1199 int64_t next_dts, int64_t next_pts)
1201 int num, den, presentation_delayed, delay, i;
1203 AVRational duration;
1204 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1205 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1207 if (s->flags & AVFMT_FLAG_NOFILLIN)
1210 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1211 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1212 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1213 st->internal->dts_ordered++;
1215 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1216 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1218 st->internal->last_dts_for_order_check);
1219 st->internal->dts_misordered++;
1221 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1222 st->internal->dts_ordered >>= 1;
1223 st->internal->dts_misordered >>= 1;
1227 st->internal->last_dts_for_order_check = pkt->dts;
1228 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1229 pkt->dts = AV_NOPTS_VALUE;
1232 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1233 pkt->dts = AV_NOPTS_VALUE;
1235 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1236 && !st->internal->avctx->has_b_frames)
1237 //FIXME Set low_delay = 0 when has_b_frames = 1
1238 st->internal->avctx->has_b_frames = 1;
1240 /* do we have a video B-frame ? */
1241 delay = st->internal->avctx->has_b_frames;
1242 presentation_delayed = 0;
1244 /* XXX: need has_b_frame, but cannot get it if the codec is
1245 * not initialized */
1247 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1248 presentation_delayed = 1;
1250 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1251 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1252 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1253 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1254 pkt->dts -= 1LL << st->pts_wrap_bits;
1256 pkt->pts += 1LL << st->pts_wrap_bits;
1259 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1260 * We take the conservative approach and discard both.
1261 * Note: If this is misbehaving for an H.264 file, then possibly
1262 * presentation_delayed is not set correctly. */
1263 if (delay == 1 && pkt->dts == pkt->pts &&
1264 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1265 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1266 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1267 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1268 pkt->dts = AV_NOPTS_VALUE;
1271 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1272 if (pkt->duration <= 0) {
1273 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1275 duration = (AVRational) {num, den};
1276 pkt->duration = av_rescale_rnd(1,
1277 num * (int64_t) st->time_base.den,
1278 den * (int64_t) st->time_base.num,
1283 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1284 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1286 /* Correct timestamps with byte offset if demuxers only have timestamps
1287 * on packet boundaries */
1288 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1289 /* this will estimate bitrate based on this frame's duration and size */
1290 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1291 if (pkt->pts != AV_NOPTS_VALUE)
1293 if (pkt->dts != AV_NOPTS_VALUE)
1297 /* This may be redundant, but it should not hurt. */
1298 if (pkt->dts != AV_NOPTS_VALUE &&
1299 pkt->pts != AV_NOPTS_VALUE &&
1300 pkt->pts > pkt->dts)
1301 presentation_delayed = 1;
1303 if (s->debug & FF_FDEBUG_TS)
1304 av_log(s, AV_LOG_DEBUG,
1305 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1306 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1307 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1309 /* Interpolate PTS and DTS if they are not present. We skip H264
1310 * currently because delay and has_b_frames are not reliably set. */
1311 if ((delay == 0 || (delay == 1 && pc)) &&
1313 if (presentation_delayed) {
1314 /* DTS = decompression timestamp */
1315 /* PTS = presentation timestamp */
1316 if (pkt->dts == AV_NOPTS_VALUE)
1317 pkt->dts = st->last_IP_pts;
1318 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1319 if (pkt->dts == AV_NOPTS_VALUE)
1320 pkt->dts = st->cur_dts;
1322 /* This is tricky: the dts must be incremented by the duration
1323 * of the frame we are displaying, i.e. the last I- or P-frame. */
1324 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1325 st->last_IP_duration = pkt->duration;
1326 if (pkt->dts != AV_NOPTS_VALUE)
1327 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1328 if (pkt->dts != AV_NOPTS_VALUE &&
1329 pkt->pts == AV_NOPTS_VALUE &&
1330 st->last_IP_duration > 0 &&
1331 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1332 next_dts != next_pts &&
1333 next_pts != AV_NOPTS_VALUE)
1334 pkt->pts = next_dts;
1336 if ((uint64_t)pkt->duration <= INT32_MAX)
1337 st->last_IP_duration = pkt->duration;
1338 st->last_IP_pts = pkt->pts;
1339 /* Cannot compute PTS if not present (we can compute it only
1340 * by knowing the future. */
1341 } else if (pkt->pts != AV_NOPTS_VALUE ||
1342 pkt->dts != AV_NOPTS_VALUE ||
1343 pkt->duration > 0 ) {
1345 /* presentation is not delayed : PTS and DTS are the same */
1346 if (pkt->pts == AV_NOPTS_VALUE)
1347 pkt->pts = pkt->dts;
1348 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1350 if (pkt->pts == AV_NOPTS_VALUE)
1351 pkt->pts = st->cur_dts;
1352 pkt->dts = pkt->pts;
1353 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1354 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1358 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1359 st->internal->pts_buffer[0] = pkt->pts;
1360 for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1361 FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1363 if(has_decode_delay_been_guessed(st))
1364 pkt->dts = select_from_pts_buffer(st, st->internal->pts_buffer, pkt->dts);
1366 // We skipped it above so we try here.
1368 // This should happen on the first packet
1369 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1370 if (pkt->dts > st->cur_dts)
1371 st->cur_dts = pkt->dts;
1373 if (s->debug & FF_FDEBUG_TS)
1374 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1375 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1378 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1379 pkt->flags |= AV_PKT_FLAG_KEY;
1383 * Parse a packet, add all split parts to parse_queue.
1385 * @param pkt Packet to parse; must not be NULL.
1386 * @param flush Indicates whether to flush. If set, pkt must be blank.
1388 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1389 int stream_index, int flush)
1391 AVPacket *out_pkt = s->internal->parse_pkt;
1392 AVStream *st = s->streams[stream_index];
1393 uint8_t *data = pkt->data;
1394 int size = pkt->size;
1395 int ret = 0, got_output = flush;
1397 if (!size && !flush && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1398 // preserve 0-size sync packets
1399 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1402 while (size > 0 || (flush && got_output)) {
1404 int64_t next_pts = pkt->pts;
1405 int64_t next_dts = pkt->dts;
1407 len = av_parser_parse2(st->parser, st->internal->avctx,
1408 &out_pkt->data, &out_pkt->size, data, size,
1409 pkt->pts, pkt->dts, pkt->pos);
1411 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1413 /* increment read pointer */
1414 av_assert1(data || !len);
1415 data = len ? data + len : data;
1418 got_output = !!out_pkt->size;
1423 if (pkt->buf && out_pkt->data == pkt->data) {
1424 /* reference pkt->buf only when out_pkt->data is guaranteed to point
1425 * to data in it and not in the parser's internal buffer. */
1426 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1427 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1428 out_pkt->buf = av_buffer_ref(pkt->buf);
1429 if (!out_pkt->buf) {
1430 ret = AVERROR(ENOMEM);
1434 ret = av_packet_make_refcounted(out_pkt);
1439 if (pkt->side_data) {
1440 out_pkt->side_data = pkt->side_data;
1441 out_pkt->side_data_elems = pkt->side_data_elems;
1442 pkt->side_data = NULL;
1443 pkt->side_data_elems = 0;
1446 /* set the duration */
1447 out_pkt->duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1448 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1449 if (st->internal->avctx->sample_rate > 0) {
1451 av_rescale_q_rnd(st->parser->duration,
1452 (AVRational) { 1, st->internal->avctx->sample_rate },
1458 out_pkt->stream_index = st->index;
1459 out_pkt->pts = st->parser->pts;
1460 out_pkt->dts = st->parser->dts;
1461 out_pkt->pos = st->parser->pos;
1462 out_pkt->flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1464 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1465 out_pkt->pos = st->parser->frame_offset;
1467 if (st->parser->key_frame == 1 ||
1468 (st->parser->key_frame == -1 &&
1469 st->parser->pict_type == AV_PICTURE_TYPE_I))
1470 out_pkt->flags |= AV_PKT_FLAG_KEY;
1472 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1473 out_pkt->flags |= AV_PKT_FLAG_KEY;
1475 compute_pkt_fields(s, st, st->parser, out_pkt, next_dts, next_pts);
1477 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1478 &s->internal->parse_queue_end,
1484 /* end of the stream => close and free the parser */
1486 av_parser_close(st->parser);
1492 av_packet_unref(out_pkt);
1493 av_packet_unref(pkt);
1497 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1499 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1502 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1504 int ret, i, got_packet = 0;
1505 AVDictionary *metadata = NULL;
1507 while (!got_packet && !s->internal->parse_queue) {
1510 /* read next packet */
1511 ret = ff_read_packet(s, pkt);
1513 if (ret == AVERROR(EAGAIN))
1515 /* flush the parsers */
1516 for (i = 0; i < s->nb_streams; i++) {
1518 if (st->parser && st->need_parsing)
1519 parse_packet(s, pkt, st->index, 1);
1521 /* all remaining packets are now in parse_queue =>
1522 * really terminate parsing */
1526 st = s->streams[pkt->stream_index];
1528 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1530 /* update context if required */
1531 if (st->internal->need_context_update) {
1532 if (avcodec_is_open(st->internal->avctx)) {
1533 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1534 avcodec_close(st->internal->avctx);
1535 st->internal->info->found_decoder = 0;
1538 /* close parser, because it depends on the codec */
1539 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1540 av_parser_close(st->parser);
1544 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1546 av_packet_unref(pkt);
1550 #if FF_API_LAVF_AVCTX
1551 FF_DISABLE_DEPRECATION_WARNINGS
1552 /* update deprecated public codec context */
1553 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1555 av_packet_unref(pkt);
1558 FF_ENABLE_DEPRECATION_WARNINGS
1561 st->internal->need_context_update = 0;
1564 if (pkt->pts != AV_NOPTS_VALUE &&
1565 pkt->dts != AV_NOPTS_VALUE &&
1566 pkt->pts < pkt->dts) {
1567 av_log(s, AV_LOG_WARNING,
1568 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1570 av_ts2str(pkt->pts),
1571 av_ts2str(pkt->dts),
1574 if (s->debug & FF_FDEBUG_TS)
1575 av_log(s, AV_LOG_DEBUG,
1576 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1578 av_ts2str(pkt->pts),
1579 av_ts2str(pkt->dts),
1580 pkt->size, pkt->duration, pkt->flags);
1582 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1583 st->parser = av_parser_init(st->codecpar->codec_id);
1585 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1586 "%s, packets or times may be invalid.\n",
1587 avcodec_get_name(st->codecpar->codec_id));
1588 /* no parser available: just output the raw packets */
1589 st->need_parsing = AVSTREAM_PARSE_NONE;
1590 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1591 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1592 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1593 st->parser->flags |= PARSER_FLAG_ONCE;
1594 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1595 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1598 if (!st->need_parsing || !st->parser) {
1599 /* no parsing needed: we just output the packet as is */
1600 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1601 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1602 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1603 ff_reduce_index(s, st->index);
1604 av_add_index_entry(st, pkt->pos, pkt->dts,
1605 0, 0, AVINDEX_KEYFRAME);
1608 } else if (st->discard < AVDISCARD_ALL) {
1609 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1611 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1612 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1613 st->codecpar->channels = st->internal->avctx->channels;
1614 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1615 st->codecpar->codec_id = st->internal->avctx->codec_id;
1618 av_packet_unref(pkt);
1620 if (pkt->flags & AV_PKT_FLAG_KEY)
1621 st->internal->skip_to_keyframe = 0;
1622 if (st->internal->skip_to_keyframe) {
1623 av_packet_unref(pkt);
1628 if (!got_packet && s->internal->parse_queue)
1629 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1632 AVStream *st = s->streams[pkt->stream_index];
1633 int discard_padding = 0;
1634 if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1635 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1636 int64_t sample = ts_to_samples(st, pts);
1637 int duration = ts_to_samples(st, pkt->duration);
1638 int64_t end_sample = sample + duration;
1639 if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1640 sample < st->internal->last_discard_sample)
1641 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1643 if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1644 st->internal->skip_samples = st->internal->start_skip_samples;
1645 if (st->internal->skip_samples || discard_padding) {
1646 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1648 AV_WL32(p, st->internal->skip_samples);
1649 AV_WL32(p + 4, discard_padding);
1650 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1652 st->internal->skip_samples = 0;
1655 if (st->internal->inject_global_side_data) {
1656 for (i = 0; i < st->nb_side_data; i++) {
1657 AVPacketSideData *src_sd = &st->side_data[i];
1660 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1663 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1665 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1669 memcpy(dst_data, src_sd->data, src_sd->size);
1671 st->internal->inject_global_side_data = 0;
1675 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1677 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1678 av_dict_copy(&s->metadata, metadata, 0);
1679 av_dict_free(&metadata);
1680 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1683 #if FF_API_LAVF_AVCTX
1684 update_stream_avctx(s);
1687 if (s->debug & FF_FDEBUG_TS)
1688 av_log(s, AV_LOG_DEBUG,
1689 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1690 "size=%d, duration=%"PRId64", flags=%d\n",
1692 av_ts2str(pkt->pts),
1693 av_ts2str(pkt->dts),
1694 pkt->size, pkt->duration, pkt->flags);
1696 /* A demuxer might have returned EOF because of an IO error, let's
1697 * propagate this back to the user. */
1698 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1704 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1706 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1712 ret = s->internal->packet_buffer
1713 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1714 &s->internal->packet_buffer_end, pkt)
1715 : read_frame_internal(s, pkt);
1722 PacketList *pktl = s->internal->packet_buffer;
1725 AVPacket *next_pkt = &pktl->pkt;
1727 if (next_pkt->dts != AV_NOPTS_VALUE) {
1728 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1729 // last dts seen for this stream. if any of packets following
1730 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1731 int64_t last_dts = next_pkt->dts;
1732 av_assert2(wrap_bits <= 64);
1733 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1734 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1735 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1736 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1738 next_pkt->pts = pktl->pkt.dts;
1740 if (last_dts != AV_NOPTS_VALUE) {
1741 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1742 last_dts = pktl->pkt.dts;
1747 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1748 // Fixing the last reference frame had none pts issue (For MXF etc).
1749 // We only do this when
1751 // 2. we are not able to resolve a pts value for current packet.
1752 // 3. the packets for this stream at the end of the files had valid dts.
1753 next_pkt->pts = last_dts + next_pkt->duration;
1755 pktl = s->internal->packet_buffer;
1758 /* read packet from packet buffer, if there is data */
1759 st = s->streams[next_pkt->stream_index];
1760 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1761 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1762 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1763 &s->internal->packet_buffer_end, pkt);
1768 ret = read_frame_internal(s, pkt);
1770 if (pktl && ret != AVERROR(EAGAIN)) {
1777 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1778 &s->internal->packet_buffer_end,
1781 av_packet_unref(pkt);
1788 st = s->streams[pkt->stream_index];
1789 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1790 ff_reduce_index(s, st->index);
1791 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1794 if (is_relative(pkt->dts))
1795 pkt->dts -= RELATIVE_TS_BASE;
1796 if (is_relative(pkt->pts))
1797 pkt->pts -= RELATIVE_TS_BASE;
1802 /* XXX: suppress the packet queue */
1803 static void flush_packet_queue(AVFormatContext *s)
1807 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1808 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1809 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1811 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1814 /*******************************************************/
1817 int av_find_default_stream_index(AVFormatContext *s)
1821 int best_stream = 0;
1822 int best_score = INT_MIN;
1824 if (s->nb_streams <= 0)
1826 for (i = 0; i < s->nb_streams; i++) {
1829 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1830 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1832 if (st->codecpar->width && st->codecpar->height)
1836 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1837 if (st->codecpar->sample_rate)
1840 if (st->codec_info_nb_frames)
1843 if (st->discard != AVDISCARD_ALL)
1846 if (score > best_score) {
1854 /** Flush the frame reader. */
1855 void ff_read_frame_flush(AVFormatContext *s)
1860 flush_packet_queue(s);
1862 /* Reset read state for each stream. */
1863 for (i = 0; i < s->nb_streams; i++) {
1867 av_parser_close(st->parser);
1870 st->last_IP_pts = AV_NOPTS_VALUE;
1871 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1872 if (st->first_dts == AV_NOPTS_VALUE)
1873 st->cur_dts = RELATIVE_TS_BASE;
1875 /* We set the current DTS to an unspecified origin. */
1876 st->cur_dts = AV_NOPTS_VALUE;
1878 st->probe_packets = s->max_probe_packets;
1880 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1881 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1883 if (s->internal->inject_global_side_data)
1884 st->internal->inject_global_side_data = 1;
1886 st->internal->skip_samples = 0;
1890 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1894 for (i = 0; i < s->nb_streams; i++) {
1895 AVStream *st = s->streams[i];
1898 av_rescale(timestamp,
1899 st->time_base.den * (int64_t) ref_st->time_base.num,
1900 st->time_base.num * (int64_t) ref_st->time_base.den);
1904 void ff_reduce_index(AVFormatContext *s, int stream_index)
1906 AVStream *st = s->streams[stream_index];
1907 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1909 if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1911 for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1912 st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1913 st->internal->nb_index_entries = i;
1917 int ff_add_index_entry(AVIndexEntry **index_entries,
1918 int *nb_index_entries,
1919 unsigned int *index_entries_allocated_size,
1920 int64_t pos, int64_t timestamp,
1921 int size, int distance, int flags)
1923 AVIndexEntry *entries, *ie;
1926 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1929 if (timestamp == AV_NOPTS_VALUE)
1930 return AVERROR(EINVAL);
1932 if (size < 0 || size > 0x3FFFFFFF)
1933 return AVERROR(EINVAL);
1935 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1936 timestamp -= RELATIVE_TS_BASE;
1938 entries = av_fast_realloc(*index_entries,
1939 index_entries_allocated_size,
1940 (*nb_index_entries + 1) *
1941 sizeof(AVIndexEntry));
1945 *index_entries = entries;
1947 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1948 timestamp, AVSEEK_FLAG_ANY);
1951 index = (*nb_index_entries)++;
1952 ie = &entries[index];
1953 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1955 ie = &entries[index];
1956 if (ie->timestamp != timestamp) {
1957 if (ie->timestamp <= timestamp)
1959 memmove(entries + index + 1, entries + index,
1960 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1961 (*nb_index_entries)++;
1962 } else if (ie->pos == pos && distance < ie->min_distance)
1963 // do not reduce the distance
1964 distance = ie->min_distance;
1968 ie->timestamp = timestamp;
1969 ie->min_distance = distance;
1976 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1977 int size, int distance, int flags)
1979 timestamp = wrap_timestamp(st, timestamp);
1980 return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
1981 &st->internal->index_entries_allocated_size, pos,
1982 timestamp, size, distance, flags);
1985 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1986 int64_t wanted_timestamp, int flags)
1994 // Optimize appending index entries at the end.
1995 if (b && entries[b - 1].timestamp < wanted_timestamp)
2001 // Search for the next non-discarded packet.
2002 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2004 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2010 timestamp = entries[m].timestamp;
2011 if (timestamp >= wanted_timestamp)
2013 if (timestamp <= wanted_timestamp)
2016 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2018 if (!(flags & AVSEEK_FLAG_ANY))
2019 while (m >= 0 && m < nb_entries &&
2020 !(entries[m].flags & AVINDEX_KEYFRAME))
2021 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2023 if (m == nb_entries)
2028 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2031 int64_t pos_delta = 0;
2033 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2034 const char *proto = avio_find_protocol_name(s->url);
2036 av_assert0(time_tolerance >= 0);
2039 av_log(s, AV_LOG_INFO,
2040 "Protocol name not provided, cannot determine if input is local or "
2041 "a network protocol, buffers and access patterns cannot be configured "
2042 "optimally without knowing the protocol\n");
2045 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2048 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2049 AVStream *st1 = s->streams[ist1];
2050 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2051 AVStream *st2 = s->streams[ist2];
2057 for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2058 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2059 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2061 skip = FFMAX(skip, e1->size);
2062 for (; i2 < st2->internal->nb_index_entries; i2++) {
2063 AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2064 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2065 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2067 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2075 /* XXX This could be adjusted depending on protocol*/
2076 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2077 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2079 /* realloc the buffer and the original data will be retained */
2080 if (ffio_realloc_buf(s->pb, pos_delta)) {
2081 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2085 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2088 if (skip < (1<<23)) {
2089 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2093 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2095 return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2096 wanted_timestamp, flags);
2099 int avformat_index_get_entries_count(const AVStream *st)
2101 return st->internal->nb_index_entries;
2104 const AVIndexEntry *avformat_index_get_entry(const AVStream *st, int idx)
2106 if (idx < 0 || idx >= st->internal->nb_index_entries)
2109 return &st->internal->index_entries[idx];
2112 const AVIndexEntry *avformat_index_get_entry_from_timestamp(const AVStream *st,
2113 int64_t wanted_timestamp,
2116 int idx = ff_index_search_timestamp(st->internal->index_entries,
2117 st->internal->nb_index_entries,
2118 wanted_timestamp, flags);
2123 return &st->internal->index_entries[idx];
2126 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2127 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2129 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2130 if (stream_index >= 0)
2131 ts = wrap_timestamp(s->streams[stream_index], ts);
2135 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2136 int64_t target_ts, int flags)
2138 const AVInputFormat *avif = s->iformat;
2139 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2140 int64_t ts_min, ts_max, ts;
2145 if (stream_index < 0)
2148 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2151 ts_min = AV_NOPTS_VALUE;
2152 pos_limit = -1; // GCC falsely says it may be uninitialized.
2154 st = s->streams[stream_index];
2155 if (st->internal->index_entries) {
2158 /* FIXME: Whole function must be checked for non-keyframe entries in
2159 * index case, especially read_timestamp(). */
2160 index = av_index_search_timestamp(st, target_ts,
2161 flags | AVSEEK_FLAG_BACKWARD);
2162 index = FFMAX(index, 0);
2163 e = &st->internal->index_entries[index];
2165 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2167 ts_min = e->timestamp;
2168 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2169 pos_min, av_ts2str(ts_min));
2171 av_assert1(index == 0);
2174 index = av_index_search_timestamp(st, target_ts,
2175 flags & ~AVSEEK_FLAG_BACKWARD);
2176 av_assert0(index < st->internal->nb_index_entries);
2178 e = &st->internal->index_entries[index];
2179 av_assert1(e->timestamp >= target_ts);
2181 ts_max = e->timestamp;
2182 pos_limit = pos_max - e->min_distance;
2183 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2184 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2188 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2189 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2194 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2197 ff_read_frame_flush(s);
2198 ff_update_cur_dts(s, st, ts);
2203 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2204 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2206 int64_t step = 1024;
2207 int64_t limit, ts_max;
2208 int64_t filesize = avio_size(s->pb);
2209 int64_t pos_max = filesize - 1;
2212 pos_max = FFMAX(0, (pos_max) - step);
2213 ts_max = ff_read_timestamp(s, stream_index,
2214 &pos_max, limit, read_timestamp);
2216 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2217 if (ts_max == AV_NOPTS_VALUE)
2221 int64_t tmp_pos = pos_max + 1;
2222 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2223 &tmp_pos, INT64_MAX, read_timestamp);
2224 if (tmp_ts == AV_NOPTS_VALUE)
2226 av_assert0(tmp_pos > pos_max);
2229 if (tmp_pos >= filesize)
2241 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2242 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2243 int64_t ts_min, int64_t ts_max,
2244 int flags, int64_t *ts_ret,
2245 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2246 int64_t *, int64_t))
2253 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2255 if (ts_min == AV_NOPTS_VALUE) {
2256 pos_min = s->internal->data_offset;
2257 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2258 if (ts_min == AV_NOPTS_VALUE)
2262 if (ts_min >= target_ts) {
2267 if (ts_max == AV_NOPTS_VALUE) {
2268 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2270 pos_limit = pos_max;
2273 if (ts_max <= target_ts) {
2278 av_assert0(ts_min < ts_max);
2281 while (pos_min < pos_limit) {
2282 av_log(s, AV_LOG_TRACE,
2283 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2284 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2285 av_assert0(pos_limit <= pos_max);
2287 if (no_change == 0) {
2288 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2289 // interpolate position (better than dichotomy)
2290 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2292 pos_min - approximate_keyframe_distance;
2293 } else if (no_change == 1) {
2294 // bisection if interpolation did not change min / max pos last time
2295 pos = (pos_min + pos_limit) >> 1;
2297 /* linear search if bisection failed, can only happen if there
2298 * are very few or no keyframes between min/max */
2303 else if (pos > pos_limit)
2307 // May pass pos_limit instead of -1.
2308 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2313 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2314 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2315 pos_min, pos, pos_max,
2316 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2317 pos_limit, start_pos, no_change);
2318 if (ts == AV_NOPTS_VALUE) {
2319 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2322 if (target_ts <= ts) {
2323 pos_limit = start_pos - 1;
2327 if (target_ts >= ts) {
2333 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2334 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2337 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2339 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2340 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2341 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2347 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2348 int64_t pos, int flags)
2350 int64_t pos_min, pos_max;
2352 pos_min = s->internal->data_offset;
2353 pos_max = avio_size(s->pb) - 1;
2357 else if (pos > pos_max)
2360 avio_seek(s->pb, pos, SEEK_SET);
2362 s->io_repositioned = 1;
2367 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2368 int64_t timestamp, int flags)
2375 st = s->streams[stream_index];
2377 index = av_index_search_timestamp(st, timestamp, flags);
2379 if (index < 0 && st->internal->nb_index_entries &&
2380 timestamp < st->internal->index_entries[0].timestamp)
2383 if (index < 0 || index == st->internal->nb_index_entries - 1) {
2384 AVPacket *pkt = s->internal->pkt;
2387 if (st->internal->nb_index_entries) {
2388 av_assert0(st->internal->index_entries);
2389 ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2390 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2392 ff_update_cur_dts(s, st, ie->timestamp);
2394 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2397 av_packet_unref(pkt);
2401 read_status = av_read_frame(s, pkt);
2402 } while (read_status == AVERROR(EAGAIN));
2403 if (read_status < 0)
2405 if (stream_index == pkt->stream_index && pkt->dts > timestamp) {
2406 if (pkt->flags & AV_PKT_FLAG_KEY) {
2407 av_packet_unref(pkt);
2410 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2411 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);
2412 av_packet_unref(pkt);
2416 av_packet_unref(pkt);
2418 index = av_index_search_timestamp(st, timestamp, flags);
2423 ff_read_frame_flush(s);
2424 if (s->iformat->read_seek)
2425 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2427 ie = &st->internal->index_entries[index];
2428 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2430 ff_update_cur_dts(s, st, ie->timestamp);
2435 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2436 int64_t timestamp, int flags)
2441 if (flags & AVSEEK_FLAG_BYTE) {
2442 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2444 ff_read_frame_flush(s);
2445 return seek_frame_byte(s, stream_index, timestamp, flags);
2448 if (stream_index < 0) {
2449 stream_index = av_find_default_stream_index(s);
2450 if (stream_index < 0)
2453 st = s->streams[stream_index];
2454 /* timestamp for default must be expressed in AV_TIME_BASE units */
2455 timestamp = av_rescale(timestamp, st->time_base.den,
2456 AV_TIME_BASE * (int64_t) st->time_base.num);
2459 /* first, we try the format specific seek */
2460 if (s->iformat->read_seek) {
2461 ff_read_frame_flush(s);
2462 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2468 if (s->iformat->read_timestamp &&
2469 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2470 ff_read_frame_flush(s);
2471 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2472 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2473 ff_read_frame_flush(s);
2474 return seek_frame_generic(s, stream_index, timestamp, flags);
2479 int av_seek_frame(AVFormatContext *s, int stream_index,
2480 int64_t timestamp, int flags)
2484 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2485 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2486 if ((flags & AVSEEK_FLAG_BACKWARD))
2490 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2491 flags & ~AVSEEK_FLAG_BACKWARD);
2494 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2497 ret = avformat_queue_attached_pictures(s);
2502 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2503 int64_t ts, int64_t max_ts, int flags)
2505 if (min_ts > ts || max_ts < ts)
2507 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2508 return AVERROR(EINVAL);
2511 flags |= AVSEEK_FLAG_ANY;
2512 flags &= ~AVSEEK_FLAG_BACKWARD;
2514 if (s->iformat->read_seek2) {
2516 ff_read_frame_flush(s);
2518 if (stream_index == -1 && s->nb_streams == 1) {
2519 AVRational time_base = s->streams[0]->time_base;
2520 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2521 min_ts = av_rescale_rnd(min_ts, time_base.den,
2522 time_base.num * (int64_t)AV_TIME_BASE,
2523 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2524 max_ts = av_rescale_rnd(max_ts, time_base.den,
2525 time_base.num * (int64_t)AV_TIME_BASE,
2526 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2530 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2534 ret = avformat_queue_attached_pictures(s);
2538 if (s->iformat->read_timestamp) {
2539 // try to seek via read_timestamp()
2542 // Fall back on old API if new is not implemented but old is.
2543 // Note the old API has somewhat different semantics.
2544 if (s->iformat->read_seek || 1) {
2545 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2546 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2547 if (ret<0 && ts != min_ts && max_ts != ts) {
2548 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2550 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2555 // try some generic seek like seek_frame_generic() but with new ts semantics
2556 return -1; //unreachable
2559 int avformat_flush(AVFormatContext *s)
2561 ff_read_frame_flush(s);
2565 /*******************************************************/
2568 * Return TRUE if the stream has accurate duration in any stream.
2570 * @return TRUE if the stream has accurate duration for at least one component.
2572 static int has_duration(AVFormatContext *ic)
2577 for (i = 0; i < ic->nb_streams; i++) {
2578 st = ic->streams[i];
2579 if (st->duration != AV_NOPTS_VALUE)
2582 if (ic->duration != AV_NOPTS_VALUE)
2588 * Estimate the stream timings from the one of each components.
2590 * Also computes the global bitrate if possible.
2592 static void update_stream_timings(AVFormatContext *ic)
2594 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2595 int64_t duration, duration1, duration_text, filesize;
2599 start_time = INT64_MAX;
2600 start_time_text = INT64_MAX;
2601 end_time = INT64_MIN;
2602 end_time_text = INT64_MIN;
2603 duration = INT64_MIN;
2604 duration_text = INT64_MIN;
2606 for (i = 0; i < ic->nb_streams; i++) {
2607 AVStream *st = ic->streams[i];
2608 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2609 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2610 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2611 start_time1 = av_rescale_q(st->start_time, st->time_base,
2614 start_time_text = FFMIN(start_time_text, start_time1);
2616 start_time = FFMIN(start_time, start_time1);
2617 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2619 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2620 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2621 end_time1 += start_time1;
2623 end_time_text = FFMAX(end_time_text, end_time1);
2625 end_time = FFMAX(end_time, end_time1);
2627 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2628 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2629 p->start_time = start_time1;
2630 if (p->end_time < end_time1)
2631 p->end_time = end_time1;
2634 if (st->duration != AV_NOPTS_VALUE) {
2635 duration1 = av_rescale_q(st->duration, st->time_base,
2638 duration_text = FFMAX(duration_text, duration1);
2640 duration = FFMAX(duration, duration1);
2643 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2644 start_time = start_time_text;
2645 else if (start_time > start_time_text)
2646 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2648 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2649 end_time = end_time_text;
2650 else if (end_time < end_time_text)
2651 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2653 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2654 duration = duration_text;
2655 else if (duration < duration_text)
2656 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2658 if (start_time != INT64_MAX) {
2659 ic->start_time = start_time;
2660 if (end_time != INT64_MIN) {
2661 if (ic->nb_programs > 1) {
2662 for (i = 0; i < ic->nb_programs; i++) {
2663 p = ic->programs[i];
2664 if (p->start_time != AV_NOPTS_VALUE &&
2665 p->end_time > p->start_time &&
2666 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2667 duration = FFMAX(duration, p->end_time - p->start_time);
2669 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2670 duration = FFMAX(duration, end_time - start_time);
2674 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2675 ic->duration = duration;
2677 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2678 /* compute the bitrate */
2679 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2680 (double) ic->duration;
2681 if (bitrate >= 0 && bitrate <= INT64_MAX)
2682 ic->bit_rate = bitrate;
2686 static void fill_all_stream_timings(AVFormatContext *ic)
2691 update_stream_timings(ic);
2692 for (i = 0; i < ic->nb_streams; i++) {
2693 st = ic->streams[i];
2694 if (st->start_time == AV_NOPTS_VALUE) {
2695 if (ic->start_time != AV_NOPTS_VALUE)
2696 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2698 if (ic->duration != AV_NOPTS_VALUE)
2699 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2705 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2707 int64_t filesize, duration;
2708 int i, show_warning = 0;
2711 /* if bit_rate is already set, we believe it */
2712 if (ic->bit_rate <= 0) {
2713 int64_t bit_rate = 0;
2714 for (i = 0; i < ic->nb_streams; i++) {
2715 st = ic->streams[i];
2716 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2717 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2718 if (st->codecpar->bit_rate > 0) {
2719 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2723 bit_rate += st->codecpar->bit_rate;
2724 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2725 // If we have a videostream with packets but without a bitrate
2726 // then consider the sum not known
2731 ic->bit_rate = bit_rate;
2734 /* if duration is already set, we believe it */
2735 if (ic->duration == AV_NOPTS_VALUE &&
2736 ic->bit_rate != 0) {
2737 filesize = ic->pb ? avio_size(ic->pb) : 0;
2738 if (filesize > ic->internal->data_offset) {
2739 filesize -= ic->internal->data_offset;
2740 for (i = 0; i < ic->nb_streams; i++) {
2741 st = ic->streams[i];
2742 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2743 && st->duration == AV_NOPTS_VALUE) {
2744 duration = av_rescale(filesize, 8LL * st->time_base.den,
2746 (int64_t) st->time_base.num);
2747 st->duration = duration;
2754 av_log(ic, AV_LOG_WARNING,
2755 "Estimating duration from bitrate, this may be inaccurate\n");
2758 #define DURATION_MAX_READ_SIZE 250000LL
2759 #define DURATION_MAX_RETRY 6
2761 /* only usable for MPEG-PS streams */
2762 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2764 AVPacket *pkt = ic->internal->pkt;
2766 int num, den, read_size, i, ret;
2767 int found_duration = 0;
2769 int64_t filesize, offset, duration;
2772 /* flush packet queue */
2773 flush_packet_queue(ic);
2775 for (i = 0; i < ic->nb_streams; i++) {
2776 st = ic->streams[i];
2777 if (st->start_time == AV_NOPTS_VALUE &&
2778 st->first_dts == AV_NOPTS_VALUE &&
2779 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2780 av_log(ic, AV_LOG_WARNING,
2781 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2784 av_parser_close(st->parser);
2789 if (ic->skip_estimate_duration_from_pts) {
2790 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2791 goto skip_duration_calc;
2794 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2795 /* estimate the end time (duration) */
2796 /* XXX: may need to support wrapping */
2797 filesize = ic->pb ? avio_size(ic->pb) : 0;
2799 is_end = found_duration;
2800 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2804 avio_seek(ic->pb, offset, SEEK_SET);
2807 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2811 ret = ff_read_packet(ic, pkt);
2812 } while (ret == AVERROR(EAGAIN));
2815 read_size += pkt->size;
2816 st = ic->streams[pkt->stream_index];
2817 if (pkt->pts != AV_NOPTS_VALUE &&
2818 (st->start_time != AV_NOPTS_VALUE ||
2819 st->first_dts != AV_NOPTS_VALUE)) {
2820 if (pkt->duration == 0) {
2821 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2823 pkt->duration = av_rescale_rnd(1,
2824 num * (int64_t) st->time_base.den,
2825 den * (int64_t) st->time_base.num,
2829 duration = pkt->pts + pkt->duration;
2831 if (st->start_time != AV_NOPTS_VALUE)
2832 duration -= st->start_time;
2834 duration -= st->first_dts;
2836 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2837 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2838 st->duration = duration;
2839 st->internal->info->last_duration = duration;
2842 av_packet_unref(pkt);
2845 /* check if all audio/video streams have valid duration */
2848 for (i = 0; i < ic->nb_streams; i++) {
2849 st = ic->streams[i];
2850 switch (st->codecpar->codec_type) {
2851 case AVMEDIA_TYPE_VIDEO:
2852 case AVMEDIA_TYPE_AUDIO:
2853 if (st->duration == AV_NOPTS_VALUE)
2860 ++retry <= DURATION_MAX_RETRY);
2862 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2864 /* warn about audio/video streams which duration could not be estimated */
2865 for (i = 0; i < ic->nb_streams; i++) {
2866 st = ic->streams[i];
2867 if (st->duration == AV_NOPTS_VALUE) {
2868 switch (st->codecpar->codec_type) {
2869 case AVMEDIA_TYPE_VIDEO:
2870 case AVMEDIA_TYPE_AUDIO:
2871 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2872 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2874 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2879 fill_all_stream_timings(ic);
2881 avio_seek(ic->pb, old_offset, SEEK_SET);
2882 for (i = 0; i < ic->nb_streams; i++) {
2885 st = ic->streams[i];
2886 st->cur_dts = st->first_dts;
2887 st->last_IP_pts = AV_NOPTS_VALUE;
2888 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2889 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2890 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2894 /* 1:1 map to AVDurationEstimationMethod */
2895 static const char *const duration_name[] = {
2896 [AVFMT_DURATION_FROM_PTS] = "pts",
2897 [AVFMT_DURATION_FROM_STREAM] = "stream",
2898 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2901 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2903 return duration_name[method];
2906 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2910 /* get the file size, if possible */
2911 if (ic->iformat->flags & AVFMT_NOFILE) {
2914 file_size = avio_size(ic->pb);
2915 file_size = FFMAX(0, file_size);
2918 if ((!strcmp(ic->iformat->name, "mpeg") ||
2919 !strcmp(ic->iformat->name, "mpegts")) &&
2920 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2921 /* get accurate estimate from the PTSes */
2922 estimate_timings_from_pts(ic, old_offset);
2923 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2924 } else if (has_duration(ic)) {
2925 /* at least one component has timings - we use them for all
2927 fill_all_stream_timings(ic);
2928 /* nut demuxer estimate the duration from PTS */
2929 if(!strcmp(ic->iformat->name, "nut"))
2930 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2932 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2934 /* less precise: use bitrate info */
2935 estimate_timings_from_bit_rate(ic);
2936 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2938 update_stream_timings(ic);
2940 for (unsigned i = 0; i < ic->nb_streams; i++) {
2941 AVStream *st = ic->streams[i];
2942 if (st->time_base.den)
2943 av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
2944 av_ts2timestr(st->start_time, &st->time_base),
2945 av_ts2timestr(st->duration, &st->time_base));
2947 av_log(ic, AV_LOG_TRACE,
2948 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2949 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2950 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2951 duration_estimate_name(ic->duration_estimation_method),
2952 (int64_t)ic->bit_rate / 1000);
2955 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2957 AVCodecContext *avctx = st->internal->avctx;
2959 #define FAIL(errmsg) do { \
2961 *errmsg_ptr = errmsg; \
2965 if ( avctx->codec_id == AV_CODEC_ID_NONE
2966 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2967 FAIL("unknown codec");
2968 switch (avctx->codec_type) {
2969 case AVMEDIA_TYPE_AUDIO:
2970 if (!avctx->frame_size && determinable_frame_size(avctx))
2971 FAIL("unspecified frame size");
2972 if (st->internal->info->found_decoder >= 0 &&
2973 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2974 FAIL("unspecified sample format");
2975 if (!avctx->sample_rate)
2976 FAIL("unspecified sample rate");
2977 if (!avctx->channels)
2978 FAIL("unspecified number of channels");
2979 if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2980 FAIL("no decodable DTS frames");
2982 case AVMEDIA_TYPE_VIDEO:
2984 FAIL("unspecified size");
2985 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2986 FAIL("unspecified pixel format");
2987 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2988 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2989 FAIL("no frame in rv30/40 and no sar");
2991 case AVMEDIA_TYPE_SUBTITLE:
2992 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2993 FAIL("unspecified size");
2995 case AVMEDIA_TYPE_DATA:
2996 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3002 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3003 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3004 const AVPacket *avpkt, AVDictionary **options)
3006 AVCodecContext *avctx = st->internal->avctx;
3007 const AVCodec *codec;
3008 int got_picture = 1, ret = 0;
3009 AVFrame *frame = av_frame_alloc();
3010 AVSubtitle subtitle;
3011 AVPacket pkt = *avpkt;
3012 int do_skip_frame = 0;
3013 enum AVDiscard skip_frame;
3016 return AVERROR(ENOMEM);
3018 if (!avcodec_is_open(avctx) &&
3019 st->internal->info->found_decoder <= 0 &&
3020 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3021 AVDictionary *thread_opt = NULL;
3023 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3026 st->internal->info->found_decoder = -st->codecpar->codec_id;
3031 /* Force thread count to 1 since the H.264 decoder will not extract
3032 * SPS and PPS to extradata during multi-threaded decoding. */
3033 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3034 /* Force lowres to 0. The decoder might reduce the video size by the
3035 * lowres factor, and we don't want that propagated to the stream's
3037 av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
3038 if (s->codec_whitelist)
3039 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3040 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3042 av_dict_free(&thread_opt);
3044 st->internal->info->found_decoder = -avctx->codec_id;
3047 st->internal->info->found_decoder = 1;
3048 } else if (!st->internal->info->found_decoder)
3049 st->internal->info->found_decoder = 1;
3051 if (st->internal->info->found_decoder < 0) {
3056 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3058 skip_frame = avctx->skip_frame;
3059 avctx->skip_frame = AVDISCARD_ALL;
3062 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3064 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3065 (!st->codec_info_nb_frames &&
3066 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3068 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3069 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3070 ret = avcodec_send_packet(avctx, &pkt);
3071 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3075 ret = avcodec_receive_frame(avctx, frame);
3078 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3080 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3081 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3082 &got_picture, &pkt);
3084 avsubtitle_free(&subtitle);
3090 st->internal->nb_decoded_frames++;
3095 if (!pkt.data && !got_picture)
3099 if (do_skip_frame) {
3100 avctx->skip_frame = skip_frame;
3103 av_frame_free(&frame);
3107 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3109 while (tags->id != AV_CODEC_ID_NONE) {
3117 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3120 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3121 if (tag == tags[i].tag)
3123 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3124 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3126 return AV_CODEC_ID_NONE;
3129 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3131 if (bps <= 0 || bps > 64)
3132 return AV_CODEC_ID_NONE;
3137 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3139 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3141 return AV_CODEC_ID_NONE;
3146 if (sflags & (1 << (bps - 1))) {
3149 return AV_CODEC_ID_PCM_S8;
3151 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3153 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3155 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3157 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3159 return AV_CODEC_ID_NONE;
3164 return AV_CODEC_ID_PCM_U8;
3166 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3168 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3170 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3172 return AV_CODEC_ID_NONE;
3178 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3181 if (!av_codec_get_tag2(tags, id, &tag))
3186 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3190 for (i = 0; tags && tags[i]; i++) {
3191 const AVCodecTag *codec_tags = tags[i];
3192 while (codec_tags->id != AV_CODEC_ID_NONE) {
3193 if (codec_tags->id == id) {
3194 *tag = codec_tags->tag;
3203 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3206 for (i = 0; tags && tags[i]; i++) {
3207 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3208 if (id != AV_CODEC_ID_NONE)
3211 return AV_CODEC_ID_NONE;
3214 static int chapter_start_cmp(const void *p1, const void *p2)
3216 AVChapter *ch1 = *(AVChapter**)p1;
3217 AVChapter *ch2 = *(AVChapter**)p2;
3218 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3221 return (ch1 > ch2) - (ch1 < ch2);
3224 static int compute_chapters_end(AVFormatContext *s)
3227 int64_t max_time = 0;
3228 AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3231 return AVERROR(ENOMEM);
3233 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3234 max_time = s->duration +
3235 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3237 for (i = 0; i < s->nb_chapters; i++)
3238 timetable[i] = s->chapters[i];
3239 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3241 for (i = 0; i < s->nb_chapters; i++)
3242 if (timetable[i]->end == AV_NOPTS_VALUE) {
3243 AVChapter *ch = timetable[i];
3244 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3248 if (i + 1 < s->nb_chapters) {
3249 AVChapter *ch1 = timetable[i + 1];
3250 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3252 if (next_start > ch->start && next_start < end)
3255 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3261 static int get_std_framerate(int i)
3264 return (i + 1) * 1001;
3268 return (i + 31) * 1001 * 12;
3272 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3276 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3279 /* Is the time base unreliable?
3280 * This is a heuristic to balance between quick acceptance of the values in
3281 * the headers vs. some extra checks.
3282 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3283 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3284 * And there are "variable" fps files this needs to detect as well. */
3285 static int tb_unreliable(AVCodecContext *c)
3287 if (c->time_base.den >= 101LL * c->time_base.num ||
3288 c->time_base.den < 5LL * c->time_base.num ||
3289 // c->codec_tag == AV_RL32("DIVX") ||
3290 // c->codec_tag == AV_RL32("XVID") ||
3291 c->codec_tag == AV_RL32("mp4v") ||
3292 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3293 c->codec_id == AV_CODEC_ID_GIF ||
3294 c->codec_id == AV_CODEC_ID_HEVC ||
3295 c->codec_id == AV_CODEC_ID_H264)
3300 int ff_alloc_extradata(AVCodecParameters *par, int size)
3302 av_freep(&par->extradata);
3303 par->extradata_size = 0;
3305 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3306 return AVERROR(EINVAL);
3308 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3309 if (!par->extradata)
3310 return AVERROR(ENOMEM);
3312 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3313 par->extradata_size = size;
3318 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3320 int ret = ff_alloc_extradata(par, size);
3323 ret = avio_read(pb, par->extradata, size);
3325 av_freep(&par->extradata);
3326 par->extradata_size = 0;
3327 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3328 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3334 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3337 int64_t last = st->internal->info->last_dts;
3339 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3340 && ts - (uint64_t)last < INT64_MAX) {
3341 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3342 int64_t duration = ts - last;
3344 if (!st->internal->info->duration_error)
3345 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3346 if (!st->internal->info->duration_error)
3347 return AVERROR(ENOMEM);
3349 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3350 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3351 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3352 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3353 int framerate = get_std_framerate(i);
3354 double sdts = dts*framerate/(1001*12);
3355 for (j= 0; j<2; j++) {
3356 int64_t ticks = llrint(sdts+j*0.5);
3357 double error= sdts - ticks + j*0.5;
3358 st->internal->info->duration_error[j][0][i] += error;
3359 st->internal->info->duration_error[j][1][i] += error*error;
3363 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3364 st->internal->info->duration_count++;
3365 st->internal->info->rfps_duration_sum += duration;
3368 if (st->internal->info->duration_count % 10 == 0) {
3369 int n = st->internal->info->duration_count;
3370 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3371 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3372 double a0 = st->internal->info->duration_error[0][0][i] / n;
3373 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3374 double a1 = st->internal->info->duration_error[1][0][i] / n;
3375 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3376 if (error0 > 0.04 && error1 > 0.04) {
3377 st->internal->info->duration_error[0][1][i] = 2e10;
3378 st->internal->info->duration_error[1][1][i] = 2e10;
3384 // ignore the first 4 values, they might have some random jitter
3385 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3386 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3388 if (ts != AV_NOPTS_VALUE)
3389 st->internal->info->last_dts = ts;
3394 void ff_rfps_calculate(AVFormatContext *ic)
3398 for (i = 0; i < ic->nb_streams; i++) {
3399 AVStream *st = ic->streams[i];
3401 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3403 // the check for tb_unreliable() is not completely correct, since this is not about handling
3404 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3405 // ipmovie.c produces.
3406 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 &&
3407 st->internal->info->duration_gcd < INT64_MAX / st->time_base.num)
3408 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);
3409 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3410 && tb_unreliable(st->internal->avctx)) {
3412 double best_error= 0.01;
3413 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3415 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3418 if (st->internal->info->codec_info_duration &&
3419 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3421 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3424 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))
3427 for (k= 0; k<2; k++) {
3428 int n = st->internal->info->duration_count;
3429 double a= st->internal->info->duration_error[k][0][j] / n;
3430 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3432 if (error < best_error && best_error> 0.000000001) {
3434 num = get_std_framerate(j);
3437 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3440 // do not increase frame rate by more than 1 % in order to match a standard rate.
3441 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3442 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3444 if ( !st->avg_frame_rate.num
3445 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3446 && st->internal->info->codec_info_duration <= 0
3447 && st->internal->info->duration_count > 2
3448 && 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
3450 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3451 st->avg_frame_rate = st->r_frame_rate;
3454 av_freep(&st->internal->info->duration_error);
3455 st->internal->info->last_dts = AV_NOPTS_VALUE;
3456 st->internal->info->duration_count = 0;
3457 st->internal->info->rfps_duration_sum = 0;
3461 static int extract_extradata_check(AVStream *st)
3463 const AVBitStreamFilter *f;
3465 f = av_bsf_get_by_name("extract_extradata");
3470 const enum AVCodecID *ids;
3471 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3472 if (*ids == st->codecpar->codec_id)
3479 static int extract_extradata_init(AVStream *st)
3481 AVStreamInternal *sti = st->internal;
3482 const AVBitStreamFilter *f;
3485 f = av_bsf_get_by_name("extract_extradata");
3489 /* check that the codec id is supported */
3490 ret = extract_extradata_check(st);
3494 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3498 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3503 sti->extract_extradata.bsf->time_base_in = st->time_base;
3505 ret = av_bsf_init(sti->extract_extradata.bsf);
3510 sti->extract_extradata.inited = 1;
3514 av_bsf_free(&sti->extract_extradata.bsf);
3518 static int extract_extradata(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
3520 AVStreamInternal *sti = st->internal;
3521 AVPacket *pkt_ref = s->internal->parse_pkt;
3524 if (!sti->extract_extradata.inited) {
3525 ret = extract_extradata_init(st);
3530 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3533 ret = av_packet_ref(pkt_ref, pkt);
3537 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3539 av_packet_unref(pkt_ref);
3543 while (ret >= 0 && !sti->avctx->extradata) {
3544 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3546 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3551 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3552 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3553 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3554 sti->avctx->extradata = side_data->data;
3555 sti->avctx->extradata_size = side_data->size;
3556 side_data->data = NULL;
3557 side_data->size = 0;
3561 av_packet_unref(pkt_ref);
3567 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3571 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3572 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3574 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3576 return AVERROR(ENOMEM);
3577 memcpy(dst_data, sd_src->data, sd_src->size);
3582 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3584 int i, count = 0, ret = 0, j;
3587 AVCodecContext *avctx;
3588 AVPacket *pkt1 = ic->internal->pkt;
3589 int64_t old_offset = avio_tell(ic->pb);
3590 // new streams might appear, no options for those
3591 int orig_nb_streams = ic->nb_streams;
3593 int64_t max_analyze_duration = ic->max_analyze_duration;
3594 int64_t max_stream_analyze_duration;
3595 int64_t max_subtitle_analyze_duration;
3596 int64_t probesize = ic->probesize;
3597 int eof_reached = 0;
3598 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3600 flush_codecs = probesize > 0;
3602 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3604 max_stream_analyze_duration = max_analyze_duration;
3605 max_subtitle_analyze_duration = max_analyze_duration;
3606 if (!max_analyze_duration) {
3607 max_stream_analyze_duration =
3608 max_analyze_duration = 5*AV_TIME_BASE;
3609 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3610 if (!strcmp(ic->iformat->name, "flv"))
3611 max_stream_analyze_duration = 90*AV_TIME_BASE;
3612 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3613 max_stream_analyze_duration = 7*AV_TIME_BASE;
3617 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3618 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3620 for (i = 0; i < ic->nb_streams; i++) {
3621 const AVCodec *codec;
3622 AVDictionary *thread_opt = NULL;
3623 st = ic->streams[i];
3624 avctx = st->internal->avctx;
3626 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3627 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3628 /* if (!st->time_base.num)
3630 if (!avctx->time_base.num)
3631 avctx->time_base = st->time_base;
3634 /* check if the caller has overridden the codec id */
3635 #if FF_API_LAVF_AVCTX
3636 FF_DISABLE_DEPRECATION_WARNINGS
3637 if (st->codec->codec_id != st->internal->orig_codec_id) {
3638 st->codecpar->codec_id = st->codec->codec_id;
3639 st->codecpar->codec_type = st->codec->codec_type;
3640 st->internal->orig_codec_id = st->codec->codec_id;
3642 FF_ENABLE_DEPRECATION_WARNINGS
3644 // only for the split stuff
3645 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3646 st->parser = av_parser_init(st->codecpar->codec_id);
3648 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3649 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3650 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3651 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3653 } else if (st->need_parsing) {
3654 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3655 "%s, packets or times may be invalid.\n",
3656 avcodec_get_name(st->codecpar->codec_id));
3660 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3661 st->internal->orig_codec_id = st->codecpar->codec_id;
3663 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3665 goto find_stream_info_err;
3666 if (st->internal->request_probe <= 0)
3667 st->internal->avctx_inited = 1;
3669 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3671 /* Force thread count to 1 since the H.264 decoder will not extract
3672 * SPS and PPS to extradata during multi-threaded decoding. */
3673 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3674 /* Force lowres to 0. The decoder might reduce the video size by the
3675 * lowres factor, and we don't want that propagated to the stream's
3677 av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
3679 if (ic->codec_whitelist)
3680 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3682 // Try to just open decoders, in case this is enough to get parameters.
3683 // Also ensure that subtitle_header is properly set.
3684 if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0 ||
3685 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3686 if (codec && !avctx->codec)
3687 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3688 av_log(ic, AV_LOG_WARNING,
3689 "Failed to open codec in %s\n",__FUNCTION__);
3692 av_dict_free(&thread_opt);
3695 for (i = 0; i < ic->nb_streams; i++) {
3696 #if FF_API_R_FRAME_RATE
3697 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3699 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3700 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3705 const AVPacket *pkt;
3706 int analyzed_all_streams;
3707 if (ff_check_interrupt(&ic->interrupt_callback)) {
3709 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3713 /* check if one codec still needs to be handled */
3714 for (i = 0; i < ic->nb_streams; i++) {
3715 int fps_analyze_framecount = 20;
3718 st = ic->streams[i];
3719 if (!has_codec_parameters(st, NULL))
3721 /* If the timebase is coarse (like the usual millisecond precision
3722 * of mkv), we need to analyze more frames to reliably arrive at
3723 * the correct fps. */
3724 if (av_q2d(st->time_base) > 0.0005)
3725 fps_analyze_framecount *= 2;
3726 if (!tb_unreliable(st->internal->avctx))
3727 fps_analyze_framecount = 0;
3728 if (ic->fps_probe_size >= 0)
3729 fps_analyze_framecount = ic->fps_probe_size;
3730 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3731 fps_analyze_framecount = 0;
3732 /* variable fps and no guess at the real fps */
3733 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3734 st->internal->info->codec_info_duration_fields/2 :
3735 st->internal->info->duration_count;
3736 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3737 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3738 if (count < fps_analyze_framecount)
3741 // Look at the first 3 frames if there is evidence of frame delay
3742 // but the decoder delay is not set.
3743 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3745 if (!st->internal->avctx->extradata &&
3746 (!st->internal->extract_extradata.inited ||
3747 st->internal->extract_extradata.bsf) &&
3748 extract_extradata_check(st))
3750 if (st->first_dts == AV_NOPTS_VALUE &&
3751 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3752 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3753 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3754 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3757 analyzed_all_streams = 0;
3758 if (!missing_streams || !*missing_streams)
3759 if (i == ic->nb_streams) {
3760 analyzed_all_streams = 1;
3761 /* NOTE: If the format has no header, then we need to read some
3762 * packets to get most of the streams, so we cannot stop here. */
3763 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3764 /* If we found the info for all the codecs, we can stop. */
3766 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3771 /* We did not get all the codec info, but we read too much data. */
3772 if (read_size >= probesize) {
3774 av_log(ic, AV_LOG_DEBUG,
3775 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3776 for (i = 0; i < ic->nb_streams; i++)
3777 if (!ic->streams[i]->r_frame_rate.num &&
3778 ic->streams[i]->internal->info->duration_count <= 1 &&
3779 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3780 strcmp(ic->iformat->name, "image2"))
3781 av_log(ic, AV_LOG_WARNING,
3782 "Stream #%d: not enough frames to estimate rate; "
3783 "consider increasing probesize\n", i);
3787 /* NOTE: A new stream can be added there if no header in file
3788 * (AVFMTCTX_NOHEADER). */
3789 ret = read_frame_internal(ic, pkt1);
3790 if (ret == AVERROR(EAGAIN))
3799 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3800 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3801 &ic->internal->packet_buffer_end,
3804 goto unref_then_goto_end;
3806 pkt = &ic->internal->packet_buffer_end->pkt;
3811 st = ic->streams[pkt->stream_index];
3812 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3813 read_size += pkt->size;
3815 avctx = st->internal->avctx;
3816 if (!st->internal->avctx_inited) {
3817 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3819 goto unref_then_goto_end;
3820 st->internal->avctx_inited = 1;
3823 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3824 /* check for non-increasing dts */
3825 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3826 st->internal->info->fps_last_dts >= pkt->dts) {
3827 av_log(ic, AV_LOG_DEBUG,
3828 "Non-increasing DTS in stream %d: packet %d with DTS "
3829 "%"PRId64", packet %d with DTS %"PRId64"\n",
3830 st->index, st->internal->info->fps_last_dts_idx,
3831 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3833 st->internal->info->fps_first_dts =
3834 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3836 /* Check for a discontinuity in dts. If the difference in dts
3837 * is more than 1000 times the average packet duration in the
3838 * sequence, we treat it as a discontinuity. */
3839 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3840 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3841 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3842 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3843 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3844 av_log(ic, AV_LOG_WARNING,
3845 "DTS discontinuity in stream %d: packet %d with DTS "
3846 "%"PRId64", packet %d with DTS %"PRId64"\n",
3847 st->index, st->internal->info->fps_last_dts_idx,
3848 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3850 st->internal->info->fps_first_dts =
3851 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3854 /* update stored dts values */
3855 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3856 st->internal->info->fps_first_dts = pkt->dts;
3857 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3859 st->internal->info->fps_last_dts = pkt->dts;
3860 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3862 if (st->codec_info_nb_frames>1) {
3866 if (st->time_base.den > 0)
3867 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3868 if (st->avg_frame_rate.num > 0)
3869 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3872 && st->codec_info_nb_frames>30
3873 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3874 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE) {
3875 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3876 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3879 if (analyzed_all_streams) limit = max_analyze_duration;
3880 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3881 else limit = max_stream_analyze_duration;
3884 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3886 t, pkt->stream_index);
3887 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3888 av_packet_unref(pkt1);
3891 if (pkt->duration) {
3892 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3893 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3895 st->internal->info->codec_info_duration += pkt->duration;
3896 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3899 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3900 #if FF_API_R_FRAME_RATE
3901 ff_rfps_add_frame(ic, st, pkt->dts);
3903 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3904 st->internal->info->frame_delay_evidence = 1;
3906 if (!st->internal->avctx->extradata) {
3907 ret = extract_extradata(ic, st, pkt);
3909 goto unref_then_goto_end;
3912 /* If still no information, we try to open the codec and to
3913 * decompress the frame. We try to avoid that in most cases as
3914 * it takes longer and uses more memory. For MPEG-4, we need to
3915 * decompress for QuickTime.
3917 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3918 * least one frame of codec data, this makes sure the codec initializes
3919 * the channel configuration and does not only trust the values from
3921 try_decode_frame(ic, st, pkt,
3922 (options && i < orig_nb_streams) ? &options[i] : NULL);
3924 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3925 av_packet_unref(pkt1);
3927 st->codec_info_nb_frames++;
3933 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3934 st = ic->streams[stream_index];
3935 avctx = st->internal->avctx;
3936 if (!has_codec_parameters(st, NULL)) {
3937 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3938 if (codec && !avctx->codec) {
3939 AVDictionary *opts = NULL;
3940 if (ic->codec_whitelist)
3941 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3942 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3943 av_log(ic, AV_LOG_WARNING,
3944 "Failed to open codec in %s\n",__FUNCTION__);
3945 av_dict_free(&opts);
3949 // EOF already reached while reading the stream above.
3950 // So continue with reoordering DTS with whatever delay we have.
3951 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3952 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3958 AVPacket *empty_pkt = ic->internal->pkt;
3960 av_packet_unref(empty_pkt);
3962 for (i = 0; i < ic->nb_streams; i++) {
3964 st = ic->streams[i];
3966 /* flush the decoders */
3967 if (st->internal->info->found_decoder == 1) {
3969 err = try_decode_frame(ic, st, empty_pkt,
3970 (options && i < orig_nb_streams)
3971 ? &options[i] : NULL);
3972 } while (err > 0 && !has_codec_parameters(st, NULL));
3975 av_log(ic, AV_LOG_INFO,
3976 "decoding for stream %d failed\n", st->index);
3982 ff_rfps_calculate(ic);
3984 for (i = 0; i < ic->nb_streams; i++) {
3985 st = ic->streams[i];
3986 avctx = st->internal->avctx;
3987 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3988 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3989 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3990 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3991 avctx->codec_tag= tag;
3994 /* estimate average framerate if not set by demuxer */
3995 if (st->internal->info->codec_info_duration_fields &&
3996 !st->avg_frame_rate.num &&
3997 st->internal->info->codec_info_duration) {
3999 double best_error = 0.01;
4000 AVRational codec_frame_rate = avctx->framerate;
4002 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4003 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4004 st->internal->info->codec_info_duration < 0)
4006 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4007 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4008 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4010 /* Round guessed framerate to a "standard" framerate if it's
4011 * within 1% of the original estimate. */
4012 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4013 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4014 double error = fabs(av_q2d(st->avg_frame_rate) /
4015 av_q2d(std_fps) - 1);
4017 if (error < best_error) {
4019 best_fps = std_fps.num;
4022 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4023 error = fabs(av_q2d(codec_frame_rate) /
4024 av_q2d(std_fps) - 1);
4025 if (error < best_error) {
4027 best_fps = std_fps.num;
4032 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4033 best_fps, 12 * 1001, INT_MAX);
4036 if (!st->r_frame_rate.num) {
4037 if ( avctx->time_base.den * (int64_t) st->time_base.num
4038 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4039 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4040 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4042 st->r_frame_rate.num = st->time_base.den;
4043 st->r_frame_rate.den = st->time_base.num;
4046 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4047 AVRational hw_ratio = { avctx->height, avctx->width };
4048 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4051 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4052 if (!avctx->bits_per_coded_sample)
4053 avctx->bits_per_coded_sample =
4054 av_get_bits_per_sample(avctx->codec_id);
4055 // set stream disposition based on audio service type
4056 switch (avctx->audio_service_type) {
4057 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4058 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4060 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4061 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4063 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4064 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4066 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4067 st->disposition = AV_DISPOSITION_COMMENT;
4069 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4070 st->disposition = AV_DISPOSITION_KARAOKE;
4077 estimate_timings(ic, old_offset);
4079 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4081 if (ret >= 0 && ic->nb_streams)
4082 /* We could not have all the codec parameters before EOF. */
4084 for (i = 0; i < ic->nb_streams; i++) {
4086 st = ic->streams[i];
4088 /* if no packet was ever seen, update context now for has_codec_parameters */
4089 if (!st->internal->avctx_inited) {
4090 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4091 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4092 st->codecpar->format = st->internal->avctx->sample_fmt;
4093 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4095 goto find_stream_info_err;
4097 if (!has_codec_parameters(st, &errmsg)) {
4099 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4100 av_log(ic, AV_LOG_WARNING,
4101 "Could not find codec parameters for stream %d (%s): %s\n"
4102 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4103 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4109 ret = compute_chapters_end(ic);
4111 goto find_stream_info_err;
4113 /* update the stream parameters from the internal codec contexts */
4114 for (i = 0; i < ic->nb_streams; i++) {
4115 st = ic->streams[i];
4117 if (st->internal->avctx_inited) {
4118 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4120 goto find_stream_info_err;
4121 ret = add_coded_side_data(st, st->internal->avctx);
4123 goto find_stream_info_err;
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;
4132 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4133 // by the lowres factor.
4134 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4135 st->codec->lowres = st->internal->avctx->lowres;
4136 st->codec->width = st->internal->avctx->width;
4137 st->codec->height = st->internal->avctx->height;
4140 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4141 st->codec->time_base = st->internal->avctx->time_base;
4142 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4144 st->codec->framerate = st->avg_frame_rate;
4146 if (st->internal->avctx->subtitle_header) {
4147 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4148 if (!st->codec->subtitle_header)
4149 goto find_stream_info_err;
4150 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4151 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4152 st->codec->subtitle_header_size);
4155 // Fields unavailable in AVCodecParameters
4156 st->codec->coded_width = st->internal->avctx->coded_width;
4157 st->codec->coded_height = st->internal->avctx->coded_height;
4158 st->codec->properties = st->internal->avctx->properties;
4159 FF_ENABLE_DEPRECATION_WARNINGS
4162 st->internal->avctx_inited = 0;
4165 find_stream_info_err:
4166 for (i = 0; i < ic->nb_streams; i++) {
4167 st = ic->streams[i];
4168 if (st->internal->info)
4169 av_freep(&st->internal->info->duration_error);
4170 avcodec_close(ic->streams[i]->internal->avctx);
4171 av_freep(&ic->streams[i]->internal->info);
4172 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4175 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4176 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4179 unref_then_goto_end:
4180 av_packet_unref(pkt1);
4181 goto find_stream_info_err;
4184 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4188 for (i = 0; i < ic->nb_programs; i++) {
4189 if (ic->programs[i] == last) {
4193 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4194 if (ic->programs[i]->stream_index[j] == s)
4195 return ic->programs[i];
4201 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4202 int wanted_stream_nb, int related_stream,
4203 AVCodec **decoder_ret, int flags)
4205 int i, nb_streams = ic->nb_streams;
4206 int ret = AVERROR_STREAM_NOT_FOUND;
4207 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4208 int count, multiframe, disposition;
4209 int64_t best_bitrate = -1;
4211 unsigned *program = NULL;
4212 const AVCodec *decoder = NULL, *best_decoder = NULL;
4214 if (related_stream >= 0 && wanted_stream_nb < 0) {
4215 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4217 program = p->stream_index;
4218 nb_streams = p->nb_stream_indexes;
4221 for (i = 0; i < nb_streams; i++) {
4222 int real_stream_index = program ? program[i] : i;
4223 AVStream *st = ic->streams[real_stream_index];
4224 AVCodecParameters *par = st->codecpar;
4225 if (par->codec_type != type)
4227 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4229 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4232 decoder = find_decoder(ic, st, par->codec_id);
4235 ret = AVERROR_DECODER_NOT_FOUND;
4239 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4240 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4241 count = st->codec_info_nb_frames;
4242 bitrate = par->bit_rate;
4243 multiframe = FFMIN(5, count);
4244 if ((best_disposition > disposition) ||
4245 (best_disposition == disposition && best_multiframe > multiframe) ||
4246 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4247 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4249 best_disposition = disposition;
4251 best_bitrate = bitrate;
4252 best_multiframe = multiframe;
4253 ret = real_stream_index;
4254 best_decoder = decoder;
4255 if (program && i == nb_streams - 1 && ret < 0) {
4257 nb_streams = ic->nb_streams;
4258 /* no related stream found, try again with everything */
4263 *decoder_ret = (AVCodec*)best_decoder;
4267 /*******************************************************/
4269 int av_read_play(AVFormatContext *s)
4271 if (s->iformat->read_play)
4272 return s->iformat->read_play(s);
4274 return avio_pause(s->pb, 0);
4275 return AVERROR(ENOSYS);
4278 int av_read_pause(AVFormatContext *s)
4280 if (s->iformat->read_pause)
4281 return s->iformat->read_pause(s);
4283 return avio_pause(s->pb, 1);
4284 return AVERROR(ENOSYS);
4287 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4292 dst->time_base = src->time_base;
4293 dst->nb_frames = src->nb_frames;
4294 dst->disposition = src->disposition;
4295 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4296 dst->avg_frame_rate = src->avg_frame_rate;
4297 dst->r_frame_rate = src->r_frame_rate;
4299 av_dict_free(&dst->metadata);
4300 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4304 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4308 /* Free existing side data*/
4309 for (i = 0; i < dst->nb_side_data; i++)
4310 av_free(dst->side_data[i].data);
4311 av_freep(&dst->side_data);
4312 dst->nb_side_data = 0;
4314 /* Copy side data if present */
4315 if (src->nb_side_data) {
4316 dst->side_data = av_mallocz_array(src->nb_side_data,
4317 sizeof(AVPacketSideData));
4318 if (!dst->side_data)
4319 return AVERROR(ENOMEM);
4320 dst->nb_side_data = src->nb_side_data;
4322 for (i = 0; i < src->nb_side_data; i++) {
4323 uint8_t *data = av_memdup(src->side_data[i].data,
4324 src->side_data[i].size);
4326 return AVERROR(ENOMEM);
4327 dst->side_data[i].type = src->side_data[i].type;
4328 dst->side_data[i].size = src->side_data[i].size;
4329 dst->side_data[i].data = data;
4336 static void free_stream(AVStream **pst)
4338 AVStream *st = *pst;
4344 for (i = 0; i < st->nb_side_data; i++)
4345 av_freep(&st->side_data[i].data);
4346 av_freep(&st->side_data);
4349 av_parser_close(st->parser);
4351 if (st->attached_pic.data)
4352 av_packet_unref(&st->attached_pic);
4355 avcodec_free_context(&st->internal->avctx);
4356 av_bsf_free(&st->internal->bsfc);
4357 av_freep(&st->internal->priv_pts);
4358 av_freep(&st->internal->index_entries);
4359 av_freep(&st->internal->probe_data.buf);
4361 av_bsf_free(&st->internal->extract_extradata.bsf);
4363 if (st->internal->info)
4364 av_freep(&st->internal->info->duration_error);
4365 av_freep(&st->internal->info);
4367 av_freep(&st->internal);
4369 av_dict_free(&st->metadata);
4370 avcodec_parameters_free(&st->codecpar);
4371 #if FF_API_LAVF_AVCTX
4372 FF_DISABLE_DEPRECATION_WARNINGS
4373 avcodec_free_context(&st->codec);
4374 FF_ENABLE_DEPRECATION_WARNINGS
4376 av_freep(&st->priv_data);
4381 void ff_free_stream(AVFormatContext *s, AVStream *st)
4383 av_assert0(s->nb_streams>0);
4384 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4386 free_stream(&s->streams[ --s->nb_streams ]);
4389 void avformat_free_context(AVFormatContext *s)
4396 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4397 s->oformat->deinit(s);
4400 if (s->iformat && s->iformat->priv_class && s->priv_data)
4401 av_opt_free(s->priv_data);
4402 if (s->oformat && s->oformat->priv_class && s->priv_data)
4403 av_opt_free(s->priv_data);
4405 for (i = 0; i < s->nb_streams; i++)
4406 free_stream(&s->streams[i]);
4409 for (i = 0; i < s->nb_programs; i++) {
4410 av_dict_free(&s->programs[i]->metadata);
4411 av_freep(&s->programs[i]->stream_index);
4412 av_freep(&s->programs[i]);
4416 av_freep(&s->programs);
4417 av_freep(&s->priv_data);
4418 while (s->nb_chapters--) {
4419 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4420 av_freep(&s->chapters[s->nb_chapters]);
4422 av_freep(&s->chapters);
4423 av_dict_free(&s->metadata);
4424 av_dict_free(&s->internal->id3v2_meta);
4425 av_packet_free(&s->internal->pkt);
4426 av_packet_free(&s->internal->parse_pkt);
4427 av_freep(&s->streams);
4428 flush_packet_queue(s);
4429 av_freep(&s->internal);
4434 void avformat_close_input(AVFormatContext **ps)
4445 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4446 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4449 flush_packet_queue(s);
4452 if (s->iformat->read_close)
4453 s->iformat->read_close(s);
4455 avformat_free_context(s);
4462 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4468 if (s->nb_streams >= s->max_streams) {
4469 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
4470 " (%d), see the documentation if you wish to increase it\n",
4474 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4477 s->streams = streams;
4479 st = av_mallocz(sizeof(AVStream));
4483 #if FF_API_LAVF_AVCTX
4484 FF_DISABLE_DEPRECATION_WARNINGS
4485 st->codec = avcodec_alloc_context3(c);
4490 FF_ENABLE_DEPRECATION_WARNINGS
4493 st->internal = av_mallocz(sizeof(*st->internal));
4497 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4498 if (!st->internal->info)
4500 st->internal->info->last_dts = AV_NOPTS_VALUE;
4502 st->codecpar = avcodec_parameters_alloc();
4506 st->internal->avctx = avcodec_alloc_context3(NULL);
4507 if (!st->internal->avctx)
4511 #if FF_API_LAVF_AVCTX
4512 FF_DISABLE_DEPRECATION_WARNINGS
4513 /* no default bitrate if decoding */
4514 st->codec->bit_rate = 0;
4515 FF_ENABLE_DEPRECATION_WARNINGS
4518 /* default pts setting is MPEG-like */
4519 avpriv_set_pts_info(st, 33, 1, 90000);
4520 /* we set the current DTS to 0 so that formats without any timestamps
4521 * but durations get some timestamps, formats with some unknown
4522 * timestamps have their first few packets buffered and the
4523 * timestamps corrected before they are returned to the user */
4524 st->cur_dts = RELATIVE_TS_BASE;
4526 st->cur_dts = AV_NOPTS_VALUE;
4529 st->index = s->nb_streams;
4530 st->start_time = AV_NOPTS_VALUE;
4531 st->duration = AV_NOPTS_VALUE;
4532 st->first_dts = AV_NOPTS_VALUE;
4533 st->probe_packets = s->max_probe_packets;
4534 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4535 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4537 st->last_IP_pts = AV_NOPTS_VALUE;
4538 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4539 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4540 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4542 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4544 #if FF_API_R_FRAME_RATE
4545 st->internal->info->last_dts = AV_NOPTS_VALUE;
4547 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4548 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4550 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4552 st->internal->need_context_update = 1;
4554 s->streams[s->nb_streams++] = st;
4561 AVProgram *av_new_program(AVFormatContext *ac, int id)
4563 AVProgram *program = NULL;
4566 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4568 for (i = 0; i < ac->nb_programs; i++)
4569 if (ac->programs[i]->id == id)
4570 program = ac->programs[i];
4573 program = av_mallocz(sizeof(AVProgram));
4576 ret = av_dynarray_add_nofree(&ac->programs, &ac->nb_programs, program);
4581 program->discard = AVDISCARD_NONE;
4582 program->pmt_version = -1;
4584 program->pts_wrap_reference = AV_NOPTS_VALUE;
4585 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4586 program->start_time =
4587 program->end_time = AV_NOPTS_VALUE;
4592 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
4593 int64_t start, int64_t end, const char *title)
4595 AVChapter *chapter = NULL;
4598 if (end != AV_NOPTS_VALUE && start > end) {
4599 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4603 if (!s->nb_chapters) {
4604 s->internal->chapter_ids_monotonic = 1;
4605 } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4606 s->internal->chapter_ids_monotonic = 0;
4607 for (i = 0; i < s->nb_chapters; i++)
4608 if (s->chapters[i]->id == id)
4609 chapter = s->chapters[i];
4613 chapter = av_mallocz(sizeof(AVChapter));
4616 ret = av_dynarray_add_nofree(&s->chapters, &s->nb_chapters, chapter);
4622 av_dict_set(&chapter->metadata, "title", title, 0);
4624 chapter->time_base = time_base;
4625 chapter->start = start;
4631 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4634 AVProgram *program = NULL;
4637 if (idx >= ac->nb_streams) {
4638 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4642 for (i = 0; i < ac->nb_programs; i++) {
4643 if (ac->programs[i]->id != progid)
4645 program = ac->programs[i];
4646 for (j = 0; j < program->nb_stream_indexes; j++)
4647 if (program->stream_index[j] == idx)
4650 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4653 program->stream_index = tmp;
4654 program->stream_index[program->nb_stream_indexes++] = idx;
4659 uint64_t ff_ntp_time(void)
4661 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4664 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4666 uint64_t ntp_ts, frac_part, sec;
4669 //current ntp time in seconds and micro seconds
4670 sec = ntp_time_us / 1000000;
4671 usec = ntp_time_us % 1000000;
4673 //encoding in ntp timestamp format
4674 frac_part = usec * 0xFFFFFFFFULL;
4675 frac_part /= 1000000;
4677 if (sec > 0xFFFFFFFFULL)
4678 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4681 ntp_ts |= frac_part;
4686 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
4688 uint64_t sec = ntp_ts >> 32;
4689 uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
4690 uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
4692 return (sec * 1000000) + usec;
4695 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4698 char *q, buf1[20], c;
4699 int nd, len, percentd_found;
4711 while (av_isdigit(*p)) {
4712 if (nd >= INT_MAX / 10 - 255)
4714 nd = nd * 10 + *p++ - '0';
4717 } while (av_isdigit(c));
4723 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4728 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4730 if ((q - buf + len) > buf_size - 1)
4732 memcpy(q, buf1, len);
4740 if ((q - buf) < buf_size - 1)
4744 if (!percentd_found)
4753 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4755 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4758 void av_url_split(char *proto, int proto_size,
4759 char *authorization, int authorization_size,
4760 char *hostname, int hostname_size,
4761 int *port_ptr, char *path, int path_size, const char *url)
4763 const char *p, *ls, *at, *at2, *col, *brk;
4769 if (authorization_size > 0)
4770 authorization[0] = 0;
4771 if (hostname_size > 0)
4776 /* parse protocol */
4777 if ((p = strchr(url, ':'))) {
4778 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4785 /* no protocol means plain filename */
4786 av_strlcpy(path, url, path_size);
4790 /* separate path from hostname */
4791 ls = p + strcspn(p, "/?#");
4792 av_strlcpy(path, ls, path_size);
4794 /* the rest is hostname, use that to parse auth/port */
4796 /* authorization (user[:pass]@hostname) */
4798 while ((at = strchr(p, '@')) && at < ls) {
4799 av_strlcpy(authorization, at2,
4800 FFMIN(authorization_size, at + 1 - at2));
4801 p = at + 1; /* skip '@' */
4804 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4806 av_strlcpy(hostname, p + 1,
4807 FFMIN(hostname_size, brk - p));
4808 if (brk[1] == ':' && port_ptr)
4809 *port_ptr = atoi(brk + 2);
4810 } else if ((col = strchr(p, ':')) && col < ls) {
4811 av_strlcpy(hostname, p,
4812 FFMIN(col + 1 - p, hostname_size));
4814 *port_ptr = atoi(col + 1);
4816 av_strlcpy(hostname, p,
4817 FFMIN(ls + 1 - p, hostname_size));
4821 int ff_mkdir_p(const char *path)
4824 char *temp = av_strdup(path);
4828 if (!path || !temp) {
4832 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4834 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4838 for ( ; *pos != '\0'; ++pos) {
4839 if (*pos == '/' || *pos == '\\') {
4842 ret = mkdir(temp, 0755);
4847 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4848 ret = mkdir(temp, 0755);
4855 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4858 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4861 'C', 'D', 'E', 'F' };
4862 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4865 'c', 'd', 'e', 'f' };
4866 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4868 for (i = 0; i < s; i++) {
4869 buff[i * 2] = hex_table[src[i] >> 4];
4870 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4876 int ff_hex_to_data(uint8_t *data, const char *p)
4883 p += strspn(p, SPACE_CHARS);
4886 c = av_toupper((unsigned char) *p++);
4887 if (c >= '0' && c <= '9')
4889 else if (c >= 'A' && c <= 'F')
4904 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4905 unsigned int pts_num, unsigned int pts_den)
4908 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4909 if (new_tb.num != pts_num)
4910 av_log(NULL, AV_LOG_DEBUG,
4911 "st:%d removing common factor %d from timebase\n",
4912 s->index, pts_num / new_tb.num);
4914 av_log(NULL, AV_LOG_WARNING,
4915 "st:%d has too large timebase, reducing\n", s->index);
4917 if (new_tb.num <= 0 || new_tb.den <= 0) {
4918 av_log(NULL, AV_LOG_ERROR,
4919 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4920 new_tb.num, new_tb.den,
4924 s->time_base = new_tb;
4925 #if FF_API_LAVF_AVCTX
4926 FF_DISABLE_DEPRECATION_WARNINGS
4927 s->codec->pkt_timebase = new_tb;
4928 FF_ENABLE_DEPRECATION_WARNINGS
4930 s->internal->avctx->pkt_timebase = new_tb;
4931 s->pts_wrap_bits = pts_wrap_bits;
4934 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4937 const char *ptr = str;
4939 /* Parse key=value pairs. */
4942 char *dest = NULL, *dest_end;
4943 int key_len, dest_len = 0;
4945 /* Skip whitespace and potential commas. */
4946 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4953 if (!(ptr = strchr(key, '=')))
4956 key_len = ptr - key;
4958 callback_get_buf(context, key, key_len, &dest, &dest_len);
4959 dest_end = dest + dest_len - 1;
4963 while (*ptr && *ptr != '\"') {
4967 if (dest && dest < dest_end)
4971 if (dest && dest < dest_end)
4979 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4980 if (dest && dest < dest_end)
4988 int ff_find_stream_index(AVFormatContext *s, int id)
4991 for (i = 0; i < s->nb_streams; i++)
4992 if (s->streams[i]->id == id)
4997 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5001 unsigned int codec_tag;
5002 if (ofmt->query_codec)
5003 return ofmt->query_codec(codec_id, std_compliance);
5004 else if (ofmt->codec_tag)
5005 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5006 else if (codec_id == ofmt->video_codec ||
5007 codec_id == ofmt->audio_codec ||
5008 codec_id == ofmt->subtitle_codec ||
5009 codec_id == ofmt->data_codec)
5012 return AVERROR_PATCHWELCOME;
5015 int avformat_network_init(void)
5019 if ((ret = ff_network_init()) < 0)
5021 if ((ret = ff_tls_init()) < 0)
5027 int avformat_network_deinit(void)
5036 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5037 uint64_t channel_layout, int32_t sample_rate,
5038 int32_t width, int32_t height)
5044 return AVERROR(EINVAL);
5047 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5049 if (channel_layout) {
5051 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5055 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5057 if (width || height) {
5059 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5061 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5063 return AVERROR(ENOMEM);
5064 bytestream_put_le32(&data, flags);
5066 bytestream_put_le32(&data, channels);
5068 bytestream_put_le64(&data, channel_layout);
5070 bytestream_put_le32(&data, sample_rate);
5071 if (width || height) {
5072 bytestream_put_le32(&data, width);
5073 bytestream_put_le32(&data, height);
5078 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5080 AVRational undef = {0, 1};
5081 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5082 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5083 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5085 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5086 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5087 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5088 stream_sample_aspect_ratio = undef;
5090 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5091 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5092 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5093 frame_sample_aspect_ratio = undef;
5095 if (stream_sample_aspect_ratio.num)
5096 return stream_sample_aspect_ratio;
5098 return frame_sample_aspect_ratio;
5101 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5103 AVRational fr = st->r_frame_rate;
5104 AVRational codec_fr = st->internal->avctx->framerate;
5105 AVRational avg_fr = st->avg_frame_rate;
5107 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5108 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5113 if (st->internal->avctx->ticks_per_frame > 1) {
5114 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5115 (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))
5123 * Matches a stream specifier (but ignores requested index).
5125 * @param indexptr set to point to the requested stream index if there is one
5127 * @return <0 on error
5128 * 0 if st is NOT a matching stream
5129 * >0 if st is a matching stream
5131 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5132 const char *spec, const char **indexptr, AVProgram **p)
5134 int match = 1; /* Stores if the specifier matches so far. */
5136 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5140 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5141 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5142 enum AVMediaType type;
5146 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5147 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5148 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5149 case 'd': type = AVMEDIA_TYPE_DATA; break;
5150 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5151 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5152 default: av_assert0(0);
5154 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5155 return AVERROR(EINVAL);
5157 #if FF_API_LAVF_AVCTX
5158 FF_DISABLE_DEPRECATION_WARNINGS
5159 if (type != st->codecpar->codec_type
5160 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5162 FF_ENABLE_DEPRECATION_WARNINGS
5164 if (type != st->codecpar->codec_type)
5167 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5169 } else if (*spec == 'p' && *(spec + 1) == ':') {
5174 prog_id = strtol(spec, &endptr, 0);
5175 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5176 if (spec == endptr || (*endptr && *endptr++ != ':'))
5177 return AVERROR(EINVAL);
5180 for (i = 0; i < s->nb_programs; i++) {
5181 if (s->programs[i]->id != prog_id)
5184 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5185 if (st->index == s->programs[i]->stream_index[j]) {
5188 *p = s->programs[i];
5197 } else if (*spec == '#' ||
5198 (*spec == 'i' && *(spec + 1) == ':')) {
5201 spec += 1 + (*spec == 'i');
5202 stream_id = strtol(spec, &endptr, 0);
5203 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5204 return AVERROR(EINVAL);
5205 return match && (stream_id == st->id);
5206 } else if (*spec == 'm' && *(spec + 1) == ':') {
5207 AVDictionaryEntry *tag;
5213 val = strchr(spec, ':');
5215 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5217 return AVERROR(ENOMEM);
5219 tag = av_dict_get(st->metadata, key, NULL, 0);
5221 if (!val || !strcmp(tag->value, val + 1))
5230 return match && ret;
5231 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5232 AVCodecParameters *par = st->codecpar;
5233 #if FF_API_LAVF_AVCTX
5234 FF_DISABLE_DEPRECATION_WARNINGS
5235 AVCodecContext *codec = st->codec;
5236 FF_ENABLE_DEPRECATION_WARNINGS
5239 switch (par->codec_type) {
5240 case AVMEDIA_TYPE_AUDIO:
5241 val = par->sample_rate && par->channels;
5242 #if FF_API_LAVF_AVCTX
5243 val = val || (codec->sample_rate && codec->channels);
5245 if (par->format == AV_SAMPLE_FMT_NONE
5246 #if FF_API_LAVF_AVCTX
5247 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5252 case AVMEDIA_TYPE_VIDEO:
5253 val = par->width && par->height;
5254 #if FF_API_LAVF_AVCTX
5255 val = val || (codec->width && codec->height);
5257 if (par->format == AV_PIX_FMT_NONE
5258 #if FF_API_LAVF_AVCTX
5259 && codec->pix_fmt == AV_PIX_FMT_NONE
5264 case AVMEDIA_TYPE_UNKNOWN:
5271 #if FF_API_LAVF_AVCTX
5272 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5274 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5277 return AVERROR(EINVAL);
5285 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5290 const char *indexptr = NULL;
5291 AVProgram *p = NULL;
5294 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5301 index = strtol(indexptr, &endptr, 0);
5302 if (*endptr) { /* We can't have anything after the requested index. */
5303 ret = AVERROR(EINVAL);
5307 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5308 if (spec == indexptr)
5309 return (index == st->index);
5311 /* If we requested a matching stream index, we have to ensure st is that. */
5312 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5313 for (int i = 0; i < nb_streams && index >= 0; i++) {
5314 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5315 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5318 if (ret > 0 && index-- == 0 && st == candidate)
5324 if (ret == AVERROR(EINVAL))
5325 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5329 int ff_generate_avci_extradata(AVStream *st)
5331 static const uint8_t avci100_1080p_extradata[] = {
5333 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5334 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5335 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5336 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5337 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5338 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5339 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5340 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5341 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5343 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5346 static const uint8_t avci100_1080i_extradata[] = {
5348 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5349 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5350 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5351 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5352 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5353 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5354 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5355 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5356 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5357 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5358 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5360 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5363 static const uint8_t avci50_1080p_extradata[] = {
5365 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5366 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5367 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5368 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5369 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5370 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5371 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5372 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5373 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5375 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5378 static const uint8_t avci50_1080i_extradata[] = {
5380 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5381 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5382 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5383 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5384 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5385 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5386 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5387 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5388 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5389 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5390 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5392 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5395 static const uint8_t avci100_720p_extradata[] = {
5397 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5398 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5399 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5400 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5401 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5402 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5403 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5404 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5405 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5406 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5408 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5411 static const uint8_t avci50_720p_extradata[] = {
5413 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5414 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5415 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5416 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5417 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5418 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5419 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5420 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5421 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5423 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5427 const uint8_t *data = NULL;
5430 if (st->codecpar->width == 1920) {
5431 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5432 data = avci100_1080p_extradata;
5433 size = sizeof(avci100_1080p_extradata);
5435 data = avci100_1080i_extradata;
5436 size = sizeof(avci100_1080i_extradata);
5438 } else if (st->codecpar->width == 1440) {
5439 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5440 data = avci50_1080p_extradata;
5441 size = sizeof(avci50_1080p_extradata);
5443 data = avci50_1080i_extradata;
5444 size = sizeof(avci50_1080i_extradata);
5446 } else if (st->codecpar->width == 1280) {
5447 data = avci100_720p_extradata;
5448 size = sizeof(avci100_720p_extradata);
5449 } else if (st->codecpar->width == 960) {
5450 data = avci50_720p_extradata;
5451 size = sizeof(avci50_720p_extradata);
5457 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5459 memcpy(st->codecpar->extradata, data, size);
5464 uint8_t *av_stream_get_side_data(const AVStream *st,
5465 enum AVPacketSideDataType type, size_t *size)
5469 for (i = 0; i < st->nb_side_data; i++) {
5470 if (st->side_data[i].type == type) {
5472 *size = st->side_data[i].size;
5473 return st->side_data[i].data;
5481 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5482 uint8_t *data, size_t size)
5484 AVPacketSideData *sd, *tmp;
5487 for (i = 0; i < st->nb_side_data; i++) {
5488 sd = &st->side_data[i];
5490 if (sd->type == type) {
5491 av_freep(&sd->data);
5498 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5499 return AVERROR(ERANGE);
5501 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5503 return AVERROR(ENOMEM);
5506 st->side_data = tmp;
5509 sd = &st->side_data[st->nb_side_data - 1];
5517 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5521 uint8_t *data = av_malloc(size);
5526 ret = av_stream_add_side_data(st, type, data, size);
5535 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5538 const AVBitStreamFilter *bsf;
5541 av_assert0(!st->internal->bsfc);
5543 if (!(bsf = av_bsf_get_by_name(name))) {
5544 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5545 return AVERROR_BSF_NOT_FOUND;
5548 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5551 bsfc->time_base_in = st->time_base;
5552 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5557 if (args && bsfc->filter->priv_class) {
5558 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5559 const char * shorthand[2] = {NULL};
5562 shorthand[0] = opt->name;
5564 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5570 if ((ret = av_bsf_init(bsfc)) < 0) {
5575 st->internal->bsfc = bsfc;
5577 av_log(NULL, AV_LOG_VERBOSE,
5578 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5579 name, args ? args : "");
5583 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5586 return AVERROR(EINVAL);
5588 if (!(s->oformat->flags & AVFMT_NOFILE))
5589 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5593 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5596 s->io_close(s, *pb);
5600 int ff_is_http_proto(char *filename) {
5601 const char *proto = avio_find_protocol_name(filename);
5602 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5605 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5607 AVDictionaryEntry *entry;
5608 int64_t parsed_timestamp;
5610 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5611 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5612 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5615 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5622 int ff_standardize_creation_time(AVFormatContext *s)
5625 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5627 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5631 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5636 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5638 if (size != AVPALETTE_SIZE) {
5639 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5640 return AVERROR_INVALIDDATA;
5642 memcpy(palette, side_data, AVPALETTE_SIZE);
5646 if (ret == CONTAINS_PAL) {
5648 for (i = 0; i < AVPALETTE_COUNT; i++)
5649 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5656 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5661 ret = av_bprint_finalize(buf, &str);
5664 if (!av_bprint_is_complete(buf)) {
5666 return AVERROR(ENOMEM);
5669 par->extradata = str;
5670 /* Note: the string is NUL terminated (so extradata can be read as a
5671 * string), but the ending character is not accounted in the size (in
5672 * binary formats you are likely not supposed to mux that character). When
5673 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5675 par->extradata_size = buf->len;
5679 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5680 AVStream *ost, const AVStream *ist,
5681 enum AVTimebaseSource copy_tb)
5683 //TODO: use [io]st->internal->avctx
5684 const AVCodecContext *dec_ctx;
5685 AVCodecContext *enc_ctx;
5687 #if FF_API_LAVF_AVCTX
5688 FF_DISABLE_DEPRECATION_WARNINGS
5689 dec_ctx = ist->codec;
5690 enc_ctx = ost->codec;
5691 FF_ENABLE_DEPRECATION_WARNINGS
5693 dec_ctx = ist->internal->avctx;
5694 enc_ctx = ost->internal->avctx;
5697 enc_ctx->time_base = ist->time_base;
5699 * Avi is a special case here because it supports variable fps but
5700 * having the fps and timebase differe significantly adds quite some
5703 if (!strcmp(ofmt->name, "avi")) {
5704 #if FF_API_R_FRAME_RATE
5705 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5706 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5707 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5708 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5709 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5710 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5711 enc_ctx->time_base.num = ist->r_frame_rate.den;
5712 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5713 enc_ctx->ticks_per_frame = 2;
5716 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5717 && av_q2d(ist->time_base) < 1.0/500
5718 || copy_tb == AVFMT_TBCF_DECODER) {
5719 enc_ctx->time_base = dec_ctx->time_base;
5720 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5721 enc_ctx->time_base.den *= 2;
5722 enc_ctx->ticks_per_frame = 2;
5724 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5725 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5726 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5727 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5728 && av_q2d(ist->time_base) < 1.0/500
5729 || copy_tb == AVFMT_TBCF_DECODER) {
5730 enc_ctx->time_base = dec_ctx->time_base;
5731 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5735 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5736 && dec_ctx->time_base.num < dec_ctx->time_base.den
5737 && dec_ctx->time_base.num > 0
5738 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5739 enc_ctx->time_base = dec_ctx->time_base;
5742 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5743 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5748 AVRational av_stream_get_codec_timebase(const AVStream *st)
5750 // See avformat_transfer_internal_stream_timing_info() TODO.
5751 #if FF_API_LAVF_AVCTX
5752 FF_DISABLE_DEPRECATION_WARNINGS
5753 return st->codec->time_base;
5754 FF_ENABLE_DEPRECATION_WARNINGS
5756 return st->internal->avctx->time_base;
5760 void ff_format_set_url(AVFormatContext *s, char *url)