2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/thread.h"
36 #include "libavutil/time.h"
37 #include "libavutil/time_internal.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
56 #include "libavutil/ffversion.h"
57 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
59 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
63 * various utility functions for use within FFmpeg
66 unsigned avformat_version(void)
68 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
69 return LIBAVFORMAT_VERSION_INT;
72 const char *avformat_configuration(void)
74 return FFMPEG_CONFIGURATION;
77 const char *avformat_license(void)
79 #define LICENSE_PREFIX "libavformat license: "
80 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
83 int ff_lock_avformat(void)
85 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
88 int ff_unlock_avformat(void)
90 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
93 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
95 static int is_relative(int64_t ts) {
96 return ts > (RELATIVE_TS_BASE - (1LL<<48));
100 * Wrap a given time stamp, if there is an indication for an overflow
103 * @param timestamp the time stamp to wrap
104 * @return resulting time stamp
106 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
108 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
109 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
110 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
111 timestamp < st->pts_wrap_reference)
112 return timestamp + (1ULL << st->pts_wrap_bits);
113 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
114 timestamp >= st->pts_wrap_reference)
115 return timestamp - (1ULL << st->pts_wrap_bits);
120 #if FF_API_FORMAT_GET_SET
121 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
122 #if FF_API_LAVF_FFSERVER
123 FF_DISABLE_DEPRECATION_WARNINGS
124 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
125 FF_ENABLE_DEPRECATION_WARNINGS
127 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
128 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
129 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
130 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
131 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
132 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
133 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
134 #if FF_API_OLD_OPEN_CALLBACKS
135 FF_DISABLE_DEPRECATION_WARNINGS
136 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
137 FF_ENABLE_DEPRECATION_WARNINGS
141 int64_t av_stream_get_end_pts(const AVStream *st)
143 if (st->internal->priv_pts) {
144 return st->internal->priv_pts->val;
146 return AV_NOPTS_VALUE;
149 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
154 void av_format_inject_global_side_data(AVFormatContext *s)
157 s->internal->inject_global_side_data = 1;
158 for (i = 0; i < s->nb_streams; i++) {
159 AVStream *st = s->streams[i];
160 st->inject_global_side_data = 1;
164 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
166 av_assert0(!dst->codec_whitelist &&
167 !dst->format_whitelist &&
168 !dst->protocol_whitelist &&
169 !dst->protocol_blacklist);
170 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
171 dst->format_whitelist = av_strdup(src->format_whitelist);
172 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
173 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
174 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
175 || (src-> format_whitelist && !dst-> format_whitelist)
176 || (src->protocol_whitelist && !dst->protocol_whitelist)
177 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
178 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
179 return AVERROR(ENOMEM);
184 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
186 #if FF_API_LAVF_AVCTX
187 FF_DISABLE_DEPRECATION_WARNINGS
188 if (st->codec->codec)
189 return st->codec->codec;
190 FF_ENABLE_DEPRECATION_WARNINGS
193 switch (st->codecpar->codec_type) {
194 case AVMEDIA_TYPE_VIDEO:
195 if (s->video_codec) return s->video_codec;
197 case AVMEDIA_TYPE_AUDIO:
198 if (s->audio_codec) return s->audio_codec;
200 case AVMEDIA_TYPE_SUBTITLE:
201 if (s->subtitle_codec) return s->subtitle_codec;
205 return avcodec_find_decoder(codec_id);
208 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
210 const AVCodec *codec;
212 #if CONFIG_H264_DECODER
213 /* Other parts of the code assume this decoder to be used for h264,
214 * so force it if possible. */
215 if (codec_id == AV_CODEC_ID_H264)
216 return avcodec_find_decoder_by_name("h264");
219 codec = find_decoder(s, st, codec_id);
223 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
224 const AVCodec *probe_codec = NULL;
225 while (probe_codec = av_codec_next(probe_codec)) {
226 if (probe_codec->id == codec_id &&
227 av_codec_is_decoder(probe_codec) &&
228 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
237 #if FF_API_FORMAT_GET_SET
238 int av_format_get_probe_score(const AVFormatContext *s)
240 return s->probe_score;
244 /* an arbitrarily chosen "sane" max packet size -- 50M */
245 #define SANE_CHUNK_SIZE (50000000)
247 int ffio_limit(AVIOContext *s, int size)
249 if (s->maxsize>= 0) {
250 int64_t remaining= s->maxsize - avio_tell(s);
251 if (remaining < size) {
252 int64_t newsize = avio_size(s);
253 if (!s->maxsize || s->maxsize<newsize)
254 s->maxsize = newsize - !newsize;
255 remaining= s->maxsize - avio_tell(s);
256 remaining= FFMAX(remaining, 0);
259 if (s->maxsize>= 0 && remaining+1 < size) {
260 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
267 /* Read the data in sane-sized chunks and append to pkt.
268 * Return the number of bytes read or an error. */
269 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
271 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
272 int orig_size = pkt->size;
276 int prev_size = pkt->size;
279 /* When the caller requests a lot of data, limit it to the amount
280 * left in file or SANE_CHUNK_SIZE when it is not known. */
282 if (read_size > SANE_CHUNK_SIZE/10) {
283 read_size = ffio_limit(s, read_size);
284 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
286 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
289 ret = av_grow_packet(pkt, read_size);
293 ret = avio_read(s, pkt->data + prev_size, read_size);
294 if (ret != read_size) {
295 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
302 pkt->flags |= AV_PKT_FLAG_CORRUPT;
306 av_packet_unref(pkt);
307 return pkt->size > orig_size ? pkt->size - orig_size : ret;
310 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
315 pkt->pos = avio_tell(s);
317 return append_packet_chunked(s, pkt, size);
320 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
323 return av_get_packet(s, pkt, size);
324 return append_packet_chunked(s, pkt, size);
327 int av_filename_number_test(const char *filename)
331 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
334 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
337 static const struct {
340 enum AVMediaType type;
342 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
343 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
344 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
345 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
346 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
347 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
348 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
349 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
350 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
351 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
352 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
353 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
354 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
355 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
356 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
360 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
364 av_log(s, AV_LOG_DEBUG,
365 "Probe with size=%d, packets=%d detected %s with score=%d\n",
366 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
368 for (i = 0; fmt_id_type[i].name; i++) {
369 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
370 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
371 st->codecpar->sample_rate)
373 if (st->request_probe > score &&
374 st->codecpar->codec_id != fmt_id_type[i].id)
376 st->codecpar->codec_id = fmt_id_type[i].id;
377 st->codecpar->codec_type = fmt_id_type[i].type;
378 st->internal->need_context_update = 1;
379 #if FF_API_LAVF_AVCTX
380 FF_DISABLE_DEPRECATION_WARNINGS
381 st->codec->codec_type = st->codecpar->codec_type;
382 st->codec->codec_id = st->codecpar->codec_id;
383 FF_ENABLE_DEPRECATION_WARNINGS
392 /************************************************************/
393 /* input media file */
395 int av_demuxer_open(AVFormatContext *ic) {
398 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
399 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
400 return AVERROR(EINVAL);
403 if (ic->iformat->read_header) {
404 err = ic->iformat->read_header(ic);
409 if (ic->pb && !ic->internal->data_offset)
410 ic->internal->data_offset = avio_tell(ic->pb);
415 /* Open input file and probe the format if necessary. */
416 static int init_input(AVFormatContext *s, const char *filename,
417 AVDictionary **options)
420 AVProbeData pd = { filename, NULL, 0 };
421 int score = AVPROBE_SCORE_RETRY;
424 s->flags |= AVFMT_FLAG_CUSTOM_IO;
426 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
427 s, 0, s->format_probesize);
428 else if (s->iformat->flags & AVFMT_NOFILE)
429 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
430 "will be ignored with AVFMT_NOFILE format.\n");
434 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
435 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
438 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
443 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
444 s, 0, s->format_probesize);
447 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
448 AVPacketList **plast_pktl, int ref)
450 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
454 return AVERROR(ENOMEM);
457 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
466 (*plast_pktl)->next = pktl;
468 *packet_buffer = pktl;
470 /* Add the packet in the buffered packet list. */
475 int avformat_queue_attached_pictures(AVFormatContext *s)
478 for (i = 0; i < s->nb_streams; i++)
479 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
480 s->streams[i]->discard < AVDISCARD_ALL) {
481 if (s->streams[i]->attached_pic.size <= 0) {
482 av_log(s, AV_LOG_WARNING,
483 "Attached picture on stream %d has invalid size, "
488 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
489 &s->streams[i]->attached_pic,
490 &s->internal->raw_packet_buffer_end, 1);
497 static int update_stream_avctx(AVFormatContext *s)
500 for (i = 0; i < s->nb_streams; i++) {
501 AVStream *st = s->streams[i];
503 if (!st->internal->need_context_update)
506 /* close parser, because it depends on the codec */
507 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
508 av_parser_close(st->parser);
512 /* update internal codec context, for the parser */
513 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
517 #if FF_API_LAVF_AVCTX
518 FF_DISABLE_DEPRECATION_WARNINGS
519 /* update deprecated public codec context */
520 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
523 FF_ENABLE_DEPRECATION_WARNINGS
526 st->internal->need_context_update = 0;
532 int avformat_open_input(AVFormatContext **ps, const char *filename,
533 AVInputFormat *fmt, AVDictionary **options)
535 AVFormatContext *s = *ps;
537 AVDictionary *tmp = NULL;
538 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
540 if (!s && !(s = avformat_alloc_context()))
541 return AVERROR(ENOMEM);
543 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
544 return AVERROR(EINVAL);
550 av_dict_copy(&tmp, *options, 0);
552 if (s->pb) // must be before any goto fail
553 s->flags |= AVFMT_FLAG_CUSTOM_IO;
555 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
558 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
559 if ((ret = init_input(s, filename, &tmp)) < 0)
561 s->probe_score = ret;
563 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
564 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
565 if (!s->protocol_whitelist) {
566 ret = AVERROR(ENOMEM);
571 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
572 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
573 if (!s->protocol_blacklist) {
574 ret = AVERROR(ENOMEM);
579 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
580 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
581 ret = AVERROR(EINVAL);
585 avio_skip(s->pb, s->skip_initial_bytes);
587 /* Check filename in case an image number is expected. */
588 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
589 if (!av_filename_number_test(filename)) {
590 ret = AVERROR(EINVAL);
595 s->duration = s->start_time = AV_NOPTS_VALUE;
597 /* Allocate private data. */
598 if (s->iformat->priv_data_size > 0) {
599 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
600 ret = AVERROR(ENOMEM);
603 if (s->iformat->priv_class) {
604 *(const AVClass **) s->priv_data = s->iformat->priv_class;
605 av_opt_set_defaults(s->priv_data);
606 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
611 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
613 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
616 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
617 if ((ret = s->iformat->read_header(s)) < 0)
621 s->metadata = s->internal->id3v2_meta;
622 s->internal->id3v2_meta = NULL;
623 } else if (s->internal->id3v2_meta) {
624 int level = AV_LOG_WARNING;
625 if (s->error_recognition & AV_EF_COMPLIANT)
626 level = AV_LOG_ERROR;
627 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
628 av_dict_free(&s->internal->id3v2_meta);
629 if (s->error_recognition & AV_EF_EXPLODE)
630 return AVERROR_INVALIDDATA;
633 if (id3v2_extra_meta) {
634 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
635 !strcmp(s->iformat->name, "tta")) {
636 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
638 if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
641 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
643 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
645 if ((ret = avformat_queue_attached_pictures(s)) < 0)
648 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
649 s->internal->data_offset = avio_tell(s->pb);
651 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
653 update_stream_avctx(s);
655 for (i = 0; i < s->nb_streams; i++)
656 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
659 av_dict_free(options);
666 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
668 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
670 avformat_free_context(s);
675 /*******************************************************/
677 static void force_codec_ids(AVFormatContext *s, AVStream *st)
679 switch (st->codecpar->codec_type) {
680 case AVMEDIA_TYPE_VIDEO:
681 if (s->video_codec_id)
682 st->codecpar->codec_id = s->video_codec_id;
684 case AVMEDIA_TYPE_AUDIO:
685 if (s->audio_codec_id)
686 st->codecpar->codec_id = s->audio_codec_id;
688 case AVMEDIA_TYPE_SUBTITLE:
689 if (s->subtitle_codec_id)
690 st->codecpar->codec_id = s->subtitle_codec_id;
692 case AVMEDIA_TYPE_DATA:
693 if (s->data_codec_id)
694 st->codecpar->codec_id = s->data_codec_id;
699 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
701 if (st->request_probe>0) {
702 AVProbeData *pd = &st->probe_data;
704 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
708 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
710 av_log(s, AV_LOG_WARNING,
711 "Failed to reallocate probe buffer for stream %d\n",
716 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
717 pd->buf_size += pkt->size;
718 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
721 st->probe_packets = 0;
723 av_log(s, AV_LOG_WARNING,
724 "nothing to probe for stream %d\n", st->index);
728 end= s->internal->raw_packet_buffer_remaining_size <= 0
729 || st->probe_packets<= 0;
731 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
732 int score = set_codec_from_probe_data(s, st, pd);
733 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
737 st->request_probe = -1;
738 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
739 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
741 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
743 force_codec_ids(s, st);
749 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
751 int64_t ref = pkt->dts;
752 int i, pts_wrap_behavior;
753 int64_t pts_wrap_reference;
754 AVProgram *first_program;
756 if (ref == AV_NOPTS_VALUE)
758 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
760 ref &= (1LL << st->pts_wrap_bits)-1;
762 // reference time stamp should be 60 s before first time stamp
763 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
764 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
765 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
766 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
767 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
769 first_program = av_find_program_from_stream(s, NULL, stream_index);
771 if (!first_program) {
772 int default_stream_index = av_find_default_stream_index(s);
773 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
774 for (i = 0; i < s->nb_streams; i++) {
775 if (av_find_program_from_stream(s, NULL, i))
777 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
778 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
782 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
783 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
787 AVProgram *program = first_program;
789 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
790 pts_wrap_reference = program->pts_wrap_reference;
791 pts_wrap_behavior = program->pts_wrap_behavior;
794 program = av_find_program_from_stream(s, program, stream_index);
797 // update every program with differing pts_wrap_reference
798 program = first_program;
800 if (program->pts_wrap_reference != pts_wrap_reference) {
801 for (i = 0; i<program->nb_stream_indexes; i++) {
802 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
803 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
806 program->pts_wrap_reference = pts_wrap_reference;
807 program->pts_wrap_behavior = pts_wrap_behavior;
809 program = av_find_program_from_stream(s, program, stream_index);
815 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
821 AVPacketList *pktl = s->internal->raw_packet_buffer;
825 st = s->streams[pkt->stream_index];
826 if (s->internal->raw_packet_buffer_remaining_size <= 0)
827 if ((err = probe_codec(s, st, NULL)) < 0)
829 if (st->request_probe <= 0) {
830 s->internal->raw_packet_buffer = pktl->next;
831 s->internal->raw_packet_buffer_remaining_size += pkt->size;
840 ret = s->iformat->read_packet(s, pkt);
842 /* Some demuxers return FFERROR_REDO when they consume
843 data and discard it (ignored streams, junk, extradata).
844 We must re-call the demuxer to get the real packet. */
845 if (ret == FFERROR_REDO)
847 if (!pktl || ret == AVERROR(EAGAIN))
849 for (i = 0; i < s->nb_streams; i++) {
851 if (st->probe_packets || st->request_probe > 0)
852 if ((err = probe_codec(s, st, NULL)) < 0)
854 av_assert0(st->request_probe <= 0);
860 AVPacket tmp = { 0 };
861 ret = av_packet_ref(&tmp, pkt);
867 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
868 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
869 av_log(s, AV_LOG_WARNING,
870 "Dropped corrupted packet (stream = %d)\n",
872 av_packet_unref(pkt);
876 if (pkt->stream_index >= (unsigned)s->nb_streams) {
877 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
881 st = s->streams[pkt->stream_index];
883 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
884 // correct first time stamps to negative values
885 if (!is_relative(st->first_dts))
886 st->first_dts = wrap_timestamp(st, st->first_dts);
887 if (!is_relative(st->start_time))
888 st->start_time = wrap_timestamp(st, st->start_time);
889 if (!is_relative(st->cur_dts))
890 st->cur_dts = wrap_timestamp(st, st->cur_dts);
893 pkt->dts = wrap_timestamp(st, pkt->dts);
894 pkt->pts = wrap_timestamp(st, pkt->pts);
896 force_codec_ids(s, st);
898 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
899 if (s->use_wallclock_as_timestamps)
900 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
902 if (!pktl && st->request_probe <= 0)
905 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
906 &s->internal->raw_packet_buffer_end, 0);
909 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
911 if ((err = probe_codec(s, st, pkt)) < 0)
917 /**********************************************************/
919 static int determinable_frame_size(AVCodecContext *avctx)
921 switch(avctx->codec_id) {
922 case AV_CODEC_ID_MP1:
923 case AV_CODEC_ID_MP2:
924 case AV_CODEC_ID_MP3:
932 * Return the frame duration in seconds. Return 0 if not available.
934 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
935 AVCodecParserContext *pc, AVPacket *pkt)
937 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
938 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
939 int frame_size, sample_rate;
941 #if FF_API_LAVF_AVCTX
942 FF_DISABLE_DEPRECATION_WARNINGS
943 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
944 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
945 FF_ENABLE_DEPRECATION_WARNINGS
950 switch (st->codecpar->codec_type) {
951 case AVMEDIA_TYPE_VIDEO:
952 if (st->r_frame_rate.num && !pc && s->iformat) {
953 *pnum = st->r_frame_rate.den;
954 *pden = st->r_frame_rate.num;
955 } else if (st->time_base.num * 1000LL > st->time_base.den) {
956 *pnum = st->time_base.num;
957 *pden = st->time_base.den;
958 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
959 av_assert0(st->internal->avctx->ticks_per_frame);
960 av_reduce(pnum, pden,
962 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
965 if (pc && pc->repeat_pict) {
966 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
967 av_reduce(pnum, pden,
968 (*pnum) * (1LL + pc->repeat_pict),
972 /* If this codec can be interlaced or progressive then we need
973 * a parser to compute duration of a packet. Thus if we have
974 * no parser in such case leave duration undefined. */
975 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
979 case AVMEDIA_TYPE_AUDIO:
980 if (st->internal->avctx_inited) {
981 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
982 sample_rate = st->internal->avctx->sample_rate;
984 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
985 sample_rate = st->codecpar->sample_rate;
987 if (frame_size <= 0 || sample_rate <= 0)
997 static int is_intra_only(enum AVCodecID id)
999 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1002 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1007 static int has_decode_delay_been_guessed(AVStream *st)
1009 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1010 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1012 #if CONFIG_H264_DECODER
1013 if (st->internal->avctx->has_b_frames &&
1014 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1017 if (st->internal->avctx->has_b_frames<3)
1018 return st->nb_decoded_frames >= 7;
1019 else if (st->internal->avctx->has_b_frames<4)
1020 return st->nb_decoded_frames >= 18;
1022 return st->nb_decoded_frames >= 20;
1025 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1029 if (pktl == s->internal->packet_buffer_end)
1030 return s->internal->parse_queue;
1034 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1035 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1036 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1039 int delay = st->internal->avctx->has_b_frames;
1042 if (dts == AV_NOPTS_VALUE) {
1043 int64_t best_score = INT64_MAX;
1044 for (i = 0; i<delay; i++) {
1045 if (st->pts_reorder_error_count[i]) {
1046 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1047 if (score < best_score) {
1049 dts = pts_buffer[i];
1054 for (i = 0; i<delay; i++) {
1055 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1056 int64_t diff = FFABS(pts_buffer[i] - dts)
1057 + (uint64_t)st->pts_reorder_error[i];
1058 diff = FFMAX(diff, st->pts_reorder_error[i]);
1059 st->pts_reorder_error[i] = diff;
1060 st->pts_reorder_error_count[i]++;
1061 if (st->pts_reorder_error_count[i] > 250) {
1062 st->pts_reorder_error[i] >>= 1;
1063 st->pts_reorder_error_count[i] >>= 1;
1070 if (dts == AV_NOPTS_VALUE)
1071 dts = pts_buffer[0];
1077 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1078 * of the packets in a window.
1080 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1081 AVPacketList *pkt_buffer)
1083 AVStream *st = s->streams[stream_index];
1084 int delay = st->internal->avctx->has_b_frames;
1087 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1089 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1090 pts_buffer[i] = AV_NOPTS_VALUE;
1092 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1093 if (pkt_buffer->pkt.stream_index != stream_index)
1096 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1097 pts_buffer[0] = pkt_buffer->pkt.pts;
1098 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1099 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1101 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1106 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1107 int64_t dts, int64_t pts, AVPacket *pkt)
1109 AVStream *st = s->streams[stream_index];
1110 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1111 AVPacketList *pktl_it;
1115 if (st->first_dts != AV_NOPTS_VALUE ||
1116 dts == AV_NOPTS_VALUE ||
1117 st->cur_dts == AV_NOPTS_VALUE ||
1121 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1123 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1125 if (is_relative(pts))
1128 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1129 if (pktl_it->pkt.stream_index != stream_index)
1131 if (is_relative(pktl_it->pkt.pts))
1132 pktl_it->pkt.pts += shift;
1134 if (is_relative(pktl_it->pkt.dts))
1135 pktl_it->pkt.dts += shift;
1137 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1138 st->start_time = pktl_it->pkt.pts;
1139 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1140 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1144 if (has_decode_delay_been_guessed(st)) {
1145 update_dts_from_pts(s, stream_index, pktl);
1148 if (st->start_time == AV_NOPTS_VALUE) {
1149 st->start_time = pts;
1150 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1151 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1155 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1156 int stream_index, int duration)
1158 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1159 int64_t cur_dts = RELATIVE_TS_BASE;
1161 if (st->first_dts != AV_NOPTS_VALUE) {
1162 if (st->update_initial_durations_done)
1164 st->update_initial_durations_done = 1;
1165 cur_dts = st->first_dts;
1166 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1167 if (pktl->pkt.stream_index == stream_index) {
1168 if (pktl->pkt.pts != pktl->pkt.dts ||
1169 pktl->pkt.dts != AV_NOPTS_VALUE ||
1172 cur_dts -= duration;
1175 if (pktl && pktl->pkt.dts != st->first_dts) {
1176 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1177 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1181 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1184 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1185 st->first_dts = cur_dts;
1186 } else if (st->cur_dts != RELATIVE_TS_BASE)
1189 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1190 if (pktl->pkt.stream_index != stream_index)
1192 if ((pktl->pkt.pts == pktl->pkt.dts ||
1193 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1194 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1195 pktl->pkt.dts == st->first_dts ||
1196 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1197 !pktl->pkt.duration) {
1198 pktl->pkt.dts = cur_dts;
1199 if (!st->internal->avctx->has_b_frames)
1200 pktl->pkt.pts = cur_dts;
1201 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1202 pktl->pkt.duration = duration;
1205 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1208 st->cur_dts = cur_dts;
1211 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1212 AVCodecParserContext *pc, AVPacket *pkt,
1213 int64_t next_dts, int64_t next_pts)
1215 int num, den, presentation_delayed, delay, i;
1217 AVRational duration;
1218 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1219 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1221 if (s->flags & AVFMT_FLAG_NOFILLIN)
1224 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1225 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1226 if (st->last_dts_for_order_check <= pkt->dts) {
1229 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1230 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1232 st->last_dts_for_order_check);
1233 st->dts_misordered++;
1235 if (st->dts_ordered + st->dts_misordered > 250) {
1236 st->dts_ordered >>= 1;
1237 st->dts_misordered >>= 1;
1241 st->last_dts_for_order_check = pkt->dts;
1242 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1243 pkt->dts = AV_NOPTS_VALUE;
1246 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1247 pkt->dts = AV_NOPTS_VALUE;
1249 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1250 && !st->internal->avctx->has_b_frames)
1251 //FIXME Set low_delay = 0 when has_b_frames = 1
1252 st->internal->avctx->has_b_frames = 1;
1254 /* do we have a video B-frame ? */
1255 delay = st->internal->avctx->has_b_frames;
1256 presentation_delayed = 0;
1258 /* XXX: need has_b_frame, but cannot get it if the codec is
1259 * not initialized */
1261 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1262 presentation_delayed = 1;
1264 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1265 st->pts_wrap_bits < 63 &&
1266 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1267 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1268 pkt->dts -= 1LL << st->pts_wrap_bits;
1270 pkt->pts += 1LL << st->pts_wrap_bits;
1273 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1274 * We take the conservative approach and discard both.
1275 * Note: If this is misbehaving for an H.264 file, then possibly
1276 * presentation_delayed is not set correctly. */
1277 if (delay == 1 && pkt->dts == pkt->pts &&
1278 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1279 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1280 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1281 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1282 pkt->dts = AV_NOPTS_VALUE;
1285 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1286 if (pkt->duration == 0) {
1287 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1289 duration = (AVRational) {num, den};
1290 pkt->duration = av_rescale_rnd(1,
1291 num * (int64_t) st->time_base.den,
1292 den * (int64_t) st->time_base.num,
1297 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1298 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1300 /* Correct timestamps with byte offset if demuxers only have timestamps
1301 * on packet boundaries */
1302 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1303 /* this will estimate bitrate based on this frame's duration and size */
1304 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1305 if (pkt->pts != AV_NOPTS_VALUE)
1307 if (pkt->dts != AV_NOPTS_VALUE)
1311 /* This may be redundant, but it should not hurt. */
1312 if (pkt->dts != AV_NOPTS_VALUE &&
1313 pkt->pts != AV_NOPTS_VALUE &&
1314 pkt->pts > pkt->dts)
1315 presentation_delayed = 1;
1317 if (s->debug & FF_FDEBUG_TS)
1318 av_log(s, AV_LOG_TRACE,
1319 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1320 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1321 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1323 /* Interpolate PTS and DTS if they are not present. We skip H264
1324 * currently because delay and has_b_frames are not reliably set. */
1325 if ((delay == 0 || (delay == 1 && pc)) &&
1327 if (presentation_delayed) {
1328 /* DTS = decompression timestamp */
1329 /* PTS = presentation timestamp */
1330 if (pkt->dts == AV_NOPTS_VALUE)
1331 pkt->dts = st->last_IP_pts;
1332 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1333 if (pkt->dts == AV_NOPTS_VALUE)
1334 pkt->dts = st->cur_dts;
1336 /* This is tricky: the dts must be incremented by the duration
1337 * of the frame we are displaying, i.e. the last I- or P-frame. */
1338 if (st->last_IP_duration == 0)
1339 st->last_IP_duration = pkt->duration;
1340 if (pkt->dts != AV_NOPTS_VALUE)
1341 st->cur_dts = pkt->dts + st->last_IP_duration;
1342 if (pkt->dts != AV_NOPTS_VALUE &&
1343 pkt->pts == AV_NOPTS_VALUE &&
1344 st->last_IP_duration > 0 &&
1345 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1346 next_dts != next_pts &&
1347 next_pts != AV_NOPTS_VALUE)
1348 pkt->pts = next_dts;
1350 st->last_IP_duration = pkt->duration;
1351 st->last_IP_pts = pkt->pts;
1352 /* Cannot compute PTS if not present (we can compute it only
1353 * by knowing the future. */
1354 } else if (pkt->pts != AV_NOPTS_VALUE ||
1355 pkt->dts != AV_NOPTS_VALUE ||
1358 /* presentation is not delayed : PTS and DTS are the same */
1359 if (pkt->pts == AV_NOPTS_VALUE)
1360 pkt->pts = pkt->dts;
1361 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1363 if (pkt->pts == AV_NOPTS_VALUE)
1364 pkt->pts = st->cur_dts;
1365 pkt->dts = pkt->pts;
1366 if (pkt->pts != AV_NOPTS_VALUE)
1367 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1371 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1372 st->pts_buffer[0] = pkt->pts;
1373 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1374 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1376 if(has_decode_delay_been_guessed(st))
1377 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1379 // We skipped it above so we try here.
1381 // This should happen on the first packet
1382 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1383 if (pkt->dts > st->cur_dts)
1384 st->cur_dts = pkt->dts;
1386 if (s->debug & FF_FDEBUG_TS)
1387 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1388 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1391 if (is_intra_only(st->codecpar->codec_id))
1392 pkt->flags |= AV_PKT_FLAG_KEY;
1393 #if FF_API_CONVERGENCE_DURATION
1394 FF_DISABLE_DEPRECATION_WARNINGS
1396 pkt->convergence_duration = pc->convergence_duration;
1397 FF_ENABLE_DEPRECATION_WARNINGS
1401 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1404 AVPacketList *pktl = *pkt_buf;
1405 *pkt_buf = pktl->next;
1406 av_packet_unref(&pktl->pkt);
1409 *pkt_buf_end = NULL;
1413 * Parse a packet, add all split parts to parse_queue.
1415 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1417 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1419 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1420 AVStream *st = s->streams[stream_index];
1421 uint8_t *data = pkt ? pkt->data : NULL;
1422 int size = pkt ? pkt->size : 0;
1423 int ret = 0, got_output = 0;
1426 av_init_packet(&flush_pkt);
1429 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1430 // preserve 0-size sync packets
1431 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1434 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1436 int64_t next_pts = pkt->pts;
1437 int64_t next_dts = pkt->dts;
1439 av_init_packet(&out_pkt);
1440 len = av_parser_parse2(st->parser, st->internal->avctx,
1441 &out_pkt.data, &out_pkt.size, data, size,
1442 pkt->pts, pkt->dts, pkt->pos);
1444 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1446 /* increment read pointer */
1450 got_output = !!out_pkt.size;
1455 if (pkt->side_data) {
1456 out_pkt.side_data = pkt->side_data;
1457 out_pkt.side_data_elems = pkt->side_data_elems;
1458 pkt->side_data = NULL;
1459 pkt->side_data_elems = 0;
1462 /* set the duration */
1463 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1464 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1465 if (st->internal->avctx->sample_rate > 0) {
1467 av_rescale_q_rnd(st->parser->duration,
1468 (AVRational) { 1, st->internal->avctx->sample_rate },
1474 out_pkt.stream_index = st->index;
1475 out_pkt.pts = st->parser->pts;
1476 out_pkt.dts = st->parser->dts;
1477 out_pkt.pos = st->parser->pos;
1478 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1480 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1481 out_pkt.pos = st->parser->frame_offset;
1483 if (st->parser->key_frame == 1 ||
1484 (st->parser->key_frame == -1 &&
1485 st->parser->pict_type == AV_PICTURE_TYPE_I))
1486 out_pkt.flags |= AV_PKT_FLAG_KEY;
1488 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1489 out_pkt.flags |= AV_PKT_FLAG_KEY;
1491 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1493 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1494 &s->internal->parse_queue_end, 1);
1495 av_packet_unref(&out_pkt);
1500 /* end of the stream => close and free the parser */
1501 if (pkt == &flush_pkt) {
1502 av_parser_close(st->parser);
1507 av_packet_unref(pkt);
1511 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1512 AVPacketList **pkt_buffer_end,
1516 av_assert0(*pkt_buffer);
1519 *pkt_buffer = pktl->next;
1521 *pkt_buffer_end = NULL;
1526 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1528 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1531 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1533 int ret = 0, i, got_packet = 0;
1534 AVDictionary *metadata = NULL;
1536 av_init_packet(pkt);
1538 while (!got_packet && !s->internal->parse_queue) {
1542 /* read next packet */
1543 ret = ff_read_packet(s, &cur_pkt);
1545 if (ret == AVERROR(EAGAIN))
1547 /* flush the parsers */
1548 for (i = 0; i < s->nb_streams; i++) {
1550 if (st->parser && st->need_parsing)
1551 parse_packet(s, NULL, st->index);
1553 /* all remaining packets are now in parse_queue =>
1554 * really terminate parsing */
1558 st = s->streams[cur_pkt.stream_index];
1560 /* update context if required */
1561 if (st->internal->need_context_update) {
1562 if (avcodec_is_open(st->internal->avctx)) {
1563 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1564 avcodec_close(st->internal->avctx);
1565 st->info->found_decoder = 0;
1568 /* close parser, because it depends on the codec */
1569 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1570 av_parser_close(st->parser);
1574 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1578 #if FF_API_LAVF_AVCTX
1579 FF_DISABLE_DEPRECATION_WARNINGS
1580 /* update deprecated public codec context */
1581 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1584 FF_ENABLE_DEPRECATION_WARNINGS
1587 st->internal->need_context_update = 0;
1590 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1591 cur_pkt.dts != AV_NOPTS_VALUE &&
1592 cur_pkt.pts < cur_pkt.dts) {
1593 av_log(s, AV_LOG_WARNING,
1594 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1595 cur_pkt.stream_index,
1596 av_ts2str(cur_pkt.pts),
1597 av_ts2str(cur_pkt.dts),
1600 if (s->debug & FF_FDEBUG_TS)
1601 av_log(s, AV_LOG_DEBUG,
1602 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1603 cur_pkt.stream_index,
1604 av_ts2str(cur_pkt.pts),
1605 av_ts2str(cur_pkt.dts),
1606 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1608 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1609 st->parser = av_parser_init(st->codecpar->codec_id);
1611 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1612 "%s, packets or times may be invalid.\n",
1613 avcodec_get_name(st->codecpar->codec_id));
1614 /* no parser available: just output the raw packets */
1615 st->need_parsing = AVSTREAM_PARSE_NONE;
1616 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1617 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1618 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1619 st->parser->flags |= PARSER_FLAG_ONCE;
1620 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1621 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1624 if (!st->need_parsing || !st->parser) {
1625 /* no parsing needed: we just output the packet as is */
1627 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1628 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1629 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1630 ff_reduce_index(s, st->index);
1631 av_add_index_entry(st, pkt->pos, pkt->dts,
1632 0, 0, AVINDEX_KEYFRAME);
1635 } else if (st->discard < AVDISCARD_ALL) {
1636 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1638 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1639 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1640 st->codecpar->channels = st->internal->avctx->channels;
1641 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1642 st->codecpar->codec_id = st->internal->avctx->codec_id;
1645 av_packet_unref(&cur_pkt);
1647 if (pkt->flags & AV_PKT_FLAG_KEY)
1648 st->skip_to_keyframe = 0;
1649 if (st->skip_to_keyframe) {
1650 av_packet_unref(&cur_pkt);
1658 if (!got_packet && s->internal->parse_queue)
1659 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1662 AVStream *st = s->streams[pkt->stream_index];
1663 int discard_padding = 0;
1664 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1665 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1666 int64_t sample = ts_to_samples(st, pts);
1667 int duration = ts_to_samples(st, pkt->duration);
1668 int64_t end_sample = sample + duration;
1669 if (duration > 0 && end_sample >= st->first_discard_sample &&
1670 sample < st->last_discard_sample)
1671 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1673 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1674 st->skip_samples = st->start_skip_samples;
1675 if (st->skip_samples || discard_padding) {
1676 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1678 AV_WL32(p, st->skip_samples);
1679 AV_WL32(p + 4, discard_padding);
1680 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1682 st->skip_samples = 0;
1685 if (st->inject_global_side_data) {
1686 for (i = 0; i < st->nb_side_data; i++) {
1687 AVPacketSideData *src_sd = &st->side_data[i];
1690 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1693 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1695 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1699 memcpy(dst_data, src_sd->data, src_sd->size);
1701 st->inject_global_side_data = 0;
1705 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1707 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1708 av_dict_copy(&s->metadata, metadata, 0);
1709 av_dict_free(&metadata);
1710 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1713 #if FF_API_LAVF_AVCTX
1714 update_stream_avctx(s);
1717 if (s->debug & FF_FDEBUG_TS)
1718 av_log(s, AV_LOG_DEBUG,
1719 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1720 "size=%d, duration=%"PRId64", flags=%d\n",
1722 av_ts2str(pkt->pts),
1723 av_ts2str(pkt->dts),
1724 pkt->size, pkt->duration, pkt->flags);
1729 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1731 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1737 ret = s->internal->packet_buffer
1738 ? read_from_packet_buffer(&s->internal->packet_buffer,
1739 &s->internal->packet_buffer_end, pkt)
1740 : read_frame_internal(s, pkt);
1747 AVPacketList *pktl = s->internal->packet_buffer;
1750 AVPacket *next_pkt = &pktl->pkt;
1752 if (next_pkt->dts != AV_NOPTS_VALUE) {
1753 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1754 // last dts seen for this stream. if any of packets following
1755 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1756 int64_t last_dts = next_pkt->dts;
1757 av_assert2(wrap_bits <= 64);
1758 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1759 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1760 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1761 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1763 next_pkt->pts = pktl->pkt.dts;
1765 if (last_dts != AV_NOPTS_VALUE) {
1766 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1767 last_dts = pktl->pkt.dts;
1772 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1773 // Fixing the last reference frame had none pts issue (For MXF etc).
1774 // We only do this when
1776 // 2. we are not able to resolve a pts value for current packet.
1777 // 3. the packets for this stream at the end of the files had valid dts.
1778 next_pkt->pts = last_dts + next_pkt->duration;
1780 pktl = s->internal->packet_buffer;
1783 /* read packet from packet buffer, if there is data */
1784 st = s->streams[next_pkt->stream_index];
1785 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1786 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1787 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1788 &s->internal->packet_buffer_end, pkt);
1793 ret = read_frame_internal(s, pkt);
1795 if (pktl && ret != AVERROR(EAGAIN)) {
1802 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1803 &s->internal->packet_buffer_end, 1);
1804 av_packet_unref(pkt);
1811 st = s->streams[pkt->stream_index];
1812 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1813 ff_reduce_index(s, st->index);
1814 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1817 if (is_relative(pkt->dts))
1818 pkt->dts -= RELATIVE_TS_BASE;
1819 if (is_relative(pkt->pts))
1820 pkt->pts -= RELATIVE_TS_BASE;
1825 /* XXX: suppress the packet queue */
1826 static void flush_packet_queue(AVFormatContext *s)
1830 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1831 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1832 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1834 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1837 /*******************************************************/
1840 int av_find_default_stream_index(AVFormatContext *s)
1844 int best_stream = 0;
1845 int best_score = INT_MIN;
1847 if (s->nb_streams <= 0)
1849 for (i = 0; i < s->nb_streams; i++) {
1852 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1853 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1855 if (st->codecpar->width && st->codecpar->height)
1859 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1860 if (st->codecpar->sample_rate)
1863 if (st->codec_info_nb_frames)
1866 if (st->discard != AVDISCARD_ALL)
1869 if (score > best_score) {
1877 /** Flush the frame reader. */
1878 void ff_read_frame_flush(AVFormatContext *s)
1883 flush_packet_queue(s);
1885 /* Reset read state for each stream. */
1886 for (i = 0; i < s->nb_streams; i++) {
1890 av_parser_close(st->parser);
1893 st->last_IP_pts = AV_NOPTS_VALUE;
1894 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1895 if (st->first_dts == AV_NOPTS_VALUE)
1896 st->cur_dts = RELATIVE_TS_BASE;
1898 /* We set the current DTS to an unspecified origin. */
1899 st->cur_dts = AV_NOPTS_VALUE;
1901 st->probe_packets = MAX_PROBE_PACKETS;
1903 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1904 st->pts_buffer[j] = AV_NOPTS_VALUE;
1906 if (s->internal->inject_global_side_data)
1907 st->inject_global_side_data = 1;
1909 st->skip_samples = 0;
1913 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1917 for (i = 0; i < s->nb_streams; i++) {
1918 AVStream *st = s->streams[i];
1921 av_rescale(timestamp,
1922 st->time_base.den * (int64_t) ref_st->time_base.num,
1923 st->time_base.num * (int64_t) ref_st->time_base.den);
1927 void ff_reduce_index(AVFormatContext *s, int stream_index)
1929 AVStream *st = s->streams[stream_index];
1930 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1932 if ((unsigned) st->nb_index_entries >= max_entries) {
1934 for (i = 0; 2 * i < st->nb_index_entries; i++)
1935 st->index_entries[i] = st->index_entries[2 * i];
1936 st->nb_index_entries = i;
1940 int ff_add_index_entry(AVIndexEntry **index_entries,
1941 int *nb_index_entries,
1942 unsigned int *index_entries_allocated_size,
1943 int64_t pos, int64_t timestamp,
1944 int size, int distance, int flags)
1946 AVIndexEntry *entries, *ie;
1949 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1952 if (timestamp == AV_NOPTS_VALUE)
1953 return AVERROR(EINVAL);
1955 if (size < 0 || size > 0x3FFFFFFF)
1956 return AVERROR(EINVAL);
1958 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1959 timestamp -= RELATIVE_TS_BASE;
1961 entries = av_fast_realloc(*index_entries,
1962 index_entries_allocated_size,
1963 (*nb_index_entries + 1) *
1964 sizeof(AVIndexEntry));
1968 *index_entries = entries;
1970 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1971 timestamp, AVSEEK_FLAG_ANY);
1974 index = (*nb_index_entries)++;
1975 ie = &entries[index];
1976 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1978 ie = &entries[index];
1979 if (ie->timestamp != timestamp) {
1980 if (ie->timestamp <= timestamp)
1982 memmove(entries + index + 1, entries + index,
1983 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1984 (*nb_index_entries)++;
1985 } else if (ie->pos == pos && distance < ie->min_distance)
1986 // do not reduce the distance
1987 distance = ie->min_distance;
1991 ie->timestamp = timestamp;
1992 ie->min_distance = distance;
1999 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2000 int size, int distance, int flags)
2002 timestamp = wrap_timestamp(st, timestamp);
2003 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2004 &st->index_entries_allocated_size, pos,
2005 timestamp, size, distance, flags);
2008 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2009 int64_t wanted_timestamp, int flags)
2017 // Optimize appending index entries at the end.
2018 if (b && entries[b - 1].timestamp < wanted_timestamp)
2024 // Search for the next non-discarded packet.
2025 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2027 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2033 timestamp = entries[m].timestamp;
2034 if (timestamp >= wanted_timestamp)
2036 if (timestamp <= wanted_timestamp)
2039 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2041 if (!(flags & AVSEEK_FLAG_ANY))
2042 while (m >= 0 && m < nb_entries &&
2043 !(entries[m].flags & AVINDEX_KEYFRAME))
2044 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2046 if (m == nb_entries)
2051 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2054 int64_t pos_delta = 0;
2056 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2057 const char *proto = avio_find_protocol_name(s->filename);
2060 av_log(s, AV_LOG_INFO,
2061 "Protocol name not provided, cannot determine if input is local or "
2062 "a network protocol, buffers and access patterns cannot be configured "
2063 "optimally without knowing the protocol\n");
2066 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2069 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2070 AVStream *st1 = s->streams[ist1];
2071 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2072 AVStream *st2 = s->streams[ist2];
2078 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2079 AVIndexEntry *e1 = &st1->index_entries[i1];
2080 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2082 skip = FFMAX(skip, e1->size);
2083 for (; i2 < st2->nb_index_entries; i2++) {
2084 AVIndexEntry *e2 = &st2->index_entries[i2];
2085 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2086 if (e2_pts - e1_pts < time_tolerance)
2088 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2096 /* XXX This could be adjusted depending on protocol*/
2097 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2098 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2099 ffio_set_buf_size(s->pb, pos_delta);
2100 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2103 if (skip < (1<<23)) {
2104 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2108 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2110 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2111 wanted_timestamp, flags);
2114 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2115 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2117 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2118 if (stream_index >= 0)
2119 ts = wrap_timestamp(s->streams[stream_index], ts);
2123 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2124 int64_t target_ts, int flags)
2126 AVInputFormat *avif = s->iformat;
2127 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2128 int64_t ts_min, ts_max, ts;
2133 if (stream_index < 0)
2136 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2139 ts_min = AV_NOPTS_VALUE;
2140 pos_limit = -1; // GCC falsely says it may be uninitialized.
2142 st = s->streams[stream_index];
2143 if (st->index_entries) {
2146 /* FIXME: Whole function must be checked for non-keyframe entries in
2147 * index case, especially read_timestamp(). */
2148 index = av_index_search_timestamp(st, target_ts,
2149 flags | AVSEEK_FLAG_BACKWARD);
2150 index = FFMAX(index, 0);
2151 e = &st->index_entries[index];
2153 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2155 ts_min = e->timestamp;
2156 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2157 pos_min, av_ts2str(ts_min));
2159 av_assert1(index == 0);
2162 index = av_index_search_timestamp(st, target_ts,
2163 flags & ~AVSEEK_FLAG_BACKWARD);
2164 av_assert0(index < st->nb_index_entries);
2166 e = &st->index_entries[index];
2167 av_assert1(e->timestamp >= target_ts);
2169 ts_max = e->timestamp;
2170 pos_limit = pos_max - e->min_distance;
2171 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2172 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2176 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2177 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2182 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2185 ff_read_frame_flush(s);
2186 ff_update_cur_dts(s, st, ts);
2191 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2192 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2194 int64_t step = 1024;
2195 int64_t limit, ts_max;
2196 int64_t filesize = avio_size(s->pb);
2197 int64_t pos_max = filesize - 1;
2200 pos_max = FFMAX(0, (pos_max) - step);
2201 ts_max = ff_read_timestamp(s, stream_index,
2202 &pos_max, limit, read_timestamp);
2204 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2205 if (ts_max == AV_NOPTS_VALUE)
2209 int64_t tmp_pos = pos_max + 1;
2210 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2211 &tmp_pos, INT64_MAX, read_timestamp);
2212 if (tmp_ts == AV_NOPTS_VALUE)
2214 av_assert0(tmp_pos > pos_max);
2217 if (tmp_pos >= filesize)
2229 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2230 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2231 int64_t ts_min, int64_t ts_max,
2232 int flags, int64_t *ts_ret,
2233 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2234 int64_t *, int64_t))
2241 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2243 if (ts_min == AV_NOPTS_VALUE) {
2244 pos_min = s->internal->data_offset;
2245 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2246 if (ts_min == AV_NOPTS_VALUE)
2250 if (ts_min >= target_ts) {
2255 if (ts_max == AV_NOPTS_VALUE) {
2256 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2258 pos_limit = pos_max;
2261 if (ts_max <= target_ts) {
2266 av_assert0(ts_min < ts_max);
2269 while (pos_min < pos_limit) {
2270 av_log(s, AV_LOG_TRACE,
2271 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2272 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2273 av_assert0(pos_limit <= pos_max);
2275 if (no_change == 0) {
2276 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2277 // interpolate position (better than dichotomy)
2278 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2280 pos_min - approximate_keyframe_distance;
2281 } else if (no_change == 1) {
2282 // bisection if interpolation did not change min / max pos last time
2283 pos = (pos_min + pos_limit) >> 1;
2285 /* linear search if bisection failed, can only happen if there
2286 * are very few or no keyframes between min/max */
2291 else if (pos > pos_limit)
2295 // May pass pos_limit instead of -1.
2296 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2301 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2302 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2303 pos_min, pos, pos_max,
2304 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2305 pos_limit, start_pos, no_change);
2306 if (ts == AV_NOPTS_VALUE) {
2307 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2310 if (target_ts <= ts) {
2311 pos_limit = start_pos - 1;
2315 if (target_ts >= ts) {
2321 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2322 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2325 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2327 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2328 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2329 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2335 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2336 int64_t pos, int flags)
2338 int64_t pos_min, pos_max;
2340 pos_min = s->internal->data_offset;
2341 pos_max = avio_size(s->pb) - 1;
2345 else if (pos > pos_max)
2348 avio_seek(s->pb, pos, SEEK_SET);
2350 s->io_repositioned = 1;
2355 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2356 int64_t timestamp, int flags)
2363 st = s->streams[stream_index];
2365 index = av_index_search_timestamp(st, timestamp, flags);
2367 if (index < 0 && st->nb_index_entries &&
2368 timestamp < st->index_entries[0].timestamp)
2371 if (index < 0 || index == st->nb_index_entries - 1) {
2375 if (st->nb_index_entries) {
2376 av_assert0(st->index_entries);
2377 ie = &st->index_entries[st->nb_index_entries - 1];
2378 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2380 ff_update_cur_dts(s, st, ie->timestamp);
2382 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2388 read_status = av_read_frame(s, &pkt);
2389 } while (read_status == AVERROR(EAGAIN));
2390 if (read_status < 0)
2392 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2393 if (pkt.flags & AV_PKT_FLAG_KEY) {
2394 av_packet_unref(&pkt);
2397 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2398 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);
2399 av_packet_unref(&pkt);
2403 av_packet_unref(&pkt);
2405 index = av_index_search_timestamp(st, timestamp, flags);
2410 ff_read_frame_flush(s);
2411 if (s->iformat->read_seek)
2412 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2414 ie = &st->index_entries[index];
2415 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2417 ff_update_cur_dts(s, st, ie->timestamp);
2422 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2423 int64_t timestamp, int flags)
2428 if (flags & AVSEEK_FLAG_BYTE) {
2429 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2431 ff_read_frame_flush(s);
2432 return seek_frame_byte(s, stream_index, timestamp, flags);
2435 if (stream_index < 0) {
2436 stream_index = av_find_default_stream_index(s);
2437 if (stream_index < 0)
2440 st = s->streams[stream_index];
2441 /* timestamp for default must be expressed in AV_TIME_BASE units */
2442 timestamp = av_rescale(timestamp, st->time_base.den,
2443 AV_TIME_BASE * (int64_t) st->time_base.num);
2446 /* first, we try the format specific seek */
2447 if (s->iformat->read_seek) {
2448 ff_read_frame_flush(s);
2449 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2455 if (s->iformat->read_timestamp &&
2456 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2457 ff_read_frame_flush(s);
2458 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2459 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2460 ff_read_frame_flush(s);
2461 return seek_frame_generic(s, stream_index, timestamp, flags);
2466 int av_seek_frame(AVFormatContext *s, int stream_index,
2467 int64_t timestamp, int flags)
2471 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2472 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2473 if ((flags & AVSEEK_FLAG_BACKWARD))
2477 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2478 flags & ~AVSEEK_FLAG_BACKWARD);
2481 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2484 ret = avformat_queue_attached_pictures(s);
2489 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2490 int64_t ts, int64_t max_ts, int flags)
2492 if (min_ts > ts || max_ts < ts)
2494 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2495 return AVERROR(EINVAL);
2498 flags |= AVSEEK_FLAG_ANY;
2499 flags &= ~AVSEEK_FLAG_BACKWARD;
2501 if (s->iformat->read_seek2) {
2503 ff_read_frame_flush(s);
2505 if (stream_index == -1 && s->nb_streams == 1) {
2506 AVRational time_base = s->streams[0]->time_base;
2507 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2508 min_ts = av_rescale_rnd(min_ts, time_base.den,
2509 time_base.num * (int64_t)AV_TIME_BASE,
2510 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2511 max_ts = av_rescale_rnd(max_ts, time_base.den,
2512 time_base.num * (int64_t)AV_TIME_BASE,
2513 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2517 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2521 ret = avformat_queue_attached_pictures(s);
2525 if (s->iformat->read_timestamp) {
2526 // try to seek via read_timestamp()
2529 // Fall back on old API if new is not implemented but old is.
2530 // Note the old API has somewhat different semantics.
2531 if (s->iformat->read_seek || 1) {
2532 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2533 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2534 if (ret<0 && ts != min_ts && max_ts != ts) {
2535 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2537 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2542 // try some generic seek like seek_frame_generic() but with new ts semantics
2543 return -1; //unreachable
2546 int avformat_flush(AVFormatContext *s)
2548 ff_read_frame_flush(s);
2552 /*******************************************************/
2555 * Return TRUE if the stream has accurate duration in any stream.
2557 * @return TRUE if the stream has accurate duration for at least one component.
2559 static int has_duration(AVFormatContext *ic)
2564 for (i = 0; i < ic->nb_streams; i++) {
2565 st = ic->streams[i];
2566 if (st->duration != AV_NOPTS_VALUE)
2569 if (ic->duration != AV_NOPTS_VALUE)
2575 * Estimate the stream timings from the one of each components.
2577 * Also computes the global bitrate if possible.
2579 static void update_stream_timings(AVFormatContext *ic)
2581 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2582 int64_t duration, duration1, filesize;
2587 start_time = INT64_MAX;
2588 start_time_text = INT64_MAX;
2589 end_time = INT64_MIN;
2590 end_time_text = INT64_MIN;
2591 duration = INT64_MIN;
2592 for (i = 0; i < ic->nb_streams; i++) {
2593 st = ic->streams[i];
2594 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2595 start_time1 = av_rescale_q(st->start_time, st->time_base,
2597 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2598 if (start_time1 < start_time_text)
2599 start_time_text = start_time1;
2601 start_time = FFMIN(start_time, start_time1);
2602 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2604 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2605 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2606 end_time1 += start_time1;
2607 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2608 end_time_text = FFMAX(end_time_text, end_time1);
2610 end_time = FFMAX(end_time, end_time1);
2612 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2613 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2614 p->start_time = start_time1;
2615 if (p->end_time < end_time1)
2616 p->end_time = end_time1;
2619 if (st->duration != AV_NOPTS_VALUE) {
2620 duration1 = av_rescale_q(st->duration, st->time_base,
2622 duration = FFMAX(duration, duration1);
2625 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2626 start_time = start_time_text;
2627 else if (start_time > start_time_text)
2628 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2630 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2631 end_time = end_time_text;
2632 } else if (end_time < end_time_text) {
2633 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2636 if (start_time != INT64_MAX) {
2637 ic->start_time = start_time;
2638 if (end_time != INT64_MIN) {
2639 if (ic->nb_programs > 1) {
2640 for (i = 0; i < ic->nb_programs; i++) {
2641 p = ic->programs[i];
2642 if (p->start_time != AV_NOPTS_VALUE &&
2643 p->end_time > p->start_time &&
2644 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2645 duration = FFMAX(duration, p->end_time - p->start_time);
2647 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2648 duration = FFMAX(duration, end_time - start_time);
2652 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2653 ic->duration = duration;
2655 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2656 /* compute the bitrate */
2657 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2658 (double) ic->duration;
2659 if (bitrate >= 0 && bitrate <= INT64_MAX)
2660 ic->bit_rate = bitrate;
2664 static void fill_all_stream_timings(AVFormatContext *ic)
2669 update_stream_timings(ic);
2670 for (i = 0; i < ic->nb_streams; i++) {
2671 st = ic->streams[i];
2672 if (st->start_time == AV_NOPTS_VALUE) {
2673 if (ic->start_time != AV_NOPTS_VALUE)
2674 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2676 if (ic->duration != AV_NOPTS_VALUE)
2677 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2683 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2685 int64_t filesize, duration;
2686 int i, show_warning = 0;
2689 /* if bit_rate is already set, we believe it */
2690 if (ic->bit_rate <= 0) {
2691 int64_t bit_rate = 0;
2692 for (i = 0; i < ic->nb_streams; i++) {
2693 st = ic->streams[i];
2694 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2695 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2696 if (st->codecpar->bit_rate > 0) {
2697 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2701 bit_rate += st->codecpar->bit_rate;
2702 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2703 // If we have a videostream with packets but without a bitrate
2704 // then consider the sum not known
2709 ic->bit_rate = bit_rate;
2712 /* if duration is already set, we believe it */
2713 if (ic->duration == AV_NOPTS_VALUE &&
2714 ic->bit_rate != 0) {
2715 filesize = ic->pb ? avio_size(ic->pb) : 0;
2716 if (filesize > ic->internal->data_offset) {
2717 filesize -= ic->internal->data_offset;
2718 for (i = 0; i < ic->nb_streams; i++) {
2719 st = ic->streams[i];
2720 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2721 && st->duration == AV_NOPTS_VALUE) {
2722 duration = av_rescale(8 * filesize, st->time_base.den,
2724 (int64_t) st->time_base.num);
2725 st->duration = duration;
2732 av_log(ic, AV_LOG_WARNING,
2733 "Estimating duration from bitrate, this may be inaccurate\n");
2736 #define DURATION_MAX_READ_SIZE 250000LL
2737 #define DURATION_MAX_RETRY 6
2739 /* only usable for MPEG-PS streams */
2740 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2742 AVPacket pkt1, *pkt = &pkt1;
2744 int num, den, read_size, i, ret;
2745 int found_duration = 0;
2747 int64_t filesize, offset, duration;
2750 /* flush packet queue */
2751 flush_packet_queue(ic);
2753 for (i = 0; i < ic->nb_streams; i++) {
2754 st = ic->streams[i];
2755 if (st->start_time == AV_NOPTS_VALUE &&
2756 st->first_dts == AV_NOPTS_VALUE &&
2757 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2758 av_log(ic, AV_LOG_WARNING,
2759 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2762 av_parser_close(st->parser);
2767 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2768 /* estimate the end time (duration) */
2769 /* XXX: may need to support wrapping */
2770 filesize = ic->pb ? avio_size(ic->pb) : 0;
2772 is_end = found_duration;
2773 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2777 avio_seek(ic->pb, offset, SEEK_SET);
2780 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2784 ret = ff_read_packet(ic, pkt);
2785 } while (ret == AVERROR(EAGAIN));
2788 read_size += pkt->size;
2789 st = ic->streams[pkt->stream_index];
2790 if (pkt->pts != AV_NOPTS_VALUE &&
2791 (st->start_time != AV_NOPTS_VALUE ||
2792 st->first_dts != AV_NOPTS_VALUE)) {
2793 if (pkt->duration == 0) {
2794 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2796 pkt->duration = av_rescale_rnd(1,
2797 num * (int64_t) st->time_base.den,
2798 den * (int64_t) st->time_base.num,
2802 duration = pkt->pts + pkt->duration;
2804 if (st->start_time != AV_NOPTS_VALUE)
2805 duration -= st->start_time;
2807 duration -= st->first_dts;
2809 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2810 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2811 st->duration = duration;
2812 st->info->last_duration = duration;
2815 av_packet_unref(pkt);
2818 /* check if all audio/video streams have valid duration */
2821 for (i = 0; i < ic->nb_streams; i++) {
2822 st = ic->streams[i];
2823 switch (st->codecpar->codec_type) {
2824 case AVMEDIA_TYPE_VIDEO:
2825 case AVMEDIA_TYPE_AUDIO:
2826 if (st->duration == AV_NOPTS_VALUE)
2833 ++retry <= DURATION_MAX_RETRY);
2835 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2837 /* warn about audio/video streams which duration could not be estimated */
2838 for (i = 0; i < ic->nb_streams; i++) {
2839 st = ic->streams[i];
2840 if (st->duration == AV_NOPTS_VALUE) {
2841 switch (st->codecpar->codec_type) {
2842 case AVMEDIA_TYPE_VIDEO:
2843 case AVMEDIA_TYPE_AUDIO:
2844 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2845 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2847 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2851 fill_all_stream_timings(ic);
2853 avio_seek(ic->pb, old_offset, SEEK_SET);
2854 for (i = 0; i < ic->nb_streams; i++) {
2857 st = ic->streams[i];
2858 st->cur_dts = st->first_dts;
2859 st->last_IP_pts = AV_NOPTS_VALUE;
2860 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2861 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2862 st->pts_buffer[j] = AV_NOPTS_VALUE;
2866 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2870 /* get the file size, if possible */
2871 if (ic->iformat->flags & AVFMT_NOFILE) {
2874 file_size = avio_size(ic->pb);
2875 file_size = FFMAX(0, file_size);
2878 if ((!strcmp(ic->iformat->name, "mpeg") ||
2879 !strcmp(ic->iformat->name, "mpegts")) &&
2880 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2881 /* get accurate estimate from the PTSes */
2882 estimate_timings_from_pts(ic, old_offset);
2883 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2884 } else if (has_duration(ic)) {
2885 /* at least one component has timings - we use them for all
2887 fill_all_stream_timings(ic);
2888 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2890 /* less precise: use bitrate info */
2891 estimate_timings_from_bit_rate(ic);
2892 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2894 update_stream_timings(ic);
2898 AVStream av_unused *st;
2899 for (i = 0; i < ic->nb_streams; i++) {
2900 st = ic->streams[i];
2901 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2902 (double) st->start_time * av_q2d(st->time_base),
2903 (double) st->duration * av_q2d(st->time_base));
2905 av_log(ic, AV_LOG_TRACE,
2906 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2907 (double) ic->start_time / AV_TIME_BASE,
2908 (double) ic->duration / AV_TIME_BASE,
2909 (int64_t)ic->bit_rate / 1000);
2913 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2915 AVCodecContext *avctx = st->internal->avctx;
2917 #define FAIL(errmsg) do { \
2919 *errmsg_ptr = errmsg; \
2923 if ( avctx->codec_id == AV_CODEC_ID_NONE
2924 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2925 FAIL("unknown codec");
2926 switch (avctx->codec_type) {
2927 case AVMEDIA_TYPE_AUDIO:
2928 if (!avctx->frame_size && determinable_frame_size(avctx))
2929 FAIL("unspecified frame size");
2930 if (st->info->found_decoder >= 0 &&
2931 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2932 FAIL("unspecified sample format");
2933 if (!avctx->sample_rate)
2934 FAIL("unspecified sample rate");
2935 if (!avctx->channels)
2936 FAIL("unspecified number of channels");
2937 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2938 FAIL("no decodable DTS frames");
2940 case AVMEDIA_TYPE_VIDEO:
2942 FAIL("unspecified size");
2943 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2944 FAIL("unspecified pixel format");
2945 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2946 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2947 FAIL("no frame in rv30/40 and no sar");
2949 case AVMEDIA_TYPE_SUBTITLE:
2950 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2951 FAIL("unspecified size");
2953 case AVMEDIA_TYPE_DATA:
2954 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2960 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2961 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2962 AVDictionary **options)
2964 AVCodecContext *avctx = st->internal->avctx;
2965 const AVCodec *codec;
2966 int got_picture = 1, ret = 0;
2967 AVFrame *frame = av_frame_alloc();
2968 AVSubtitle subtitle;
2969 AVPacket pkt = *avpkt;
2970 int do_skip_frame = 0;
2971 enum AVDiscard skip_frame;
2974 return AVERROR(ENOMEM);
2976 if (!avcodec_is_open(avctx) &&
2977 st->info->found_decoder <= 0 &&
2978 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2979 AVDictionary *thread_opt = NULL;
2981 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2984 st->info->found_decoder = -st->codecpar->codec_id;
2989 /* Force thread count to 1 since the H.264 decoder will not extract
2990 * SPS and PPS to extradata during multi-threaded decoding. */
2991 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2992 if (s->codec_whitelist)
2993 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2994 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2996 av_dict_free(&thread_opt);
2998 st->info->found_decoder = -avctx->codec_id;
3001 st->info->found_decoder = 1;
3002 } else if (!st->info->found_decoder)
3003 st->info->found_decoder = 1;
3005 if (st->info->found_decoder < 0) {
3010 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3012 skip_frame = avctx->skip_frame;
3013 avctx->skip_frame = AVDISCARD_ALL;
3016 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3018 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3019 (!st->codec_info_nb_frames &&
3020 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3022 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3023 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3024 ret = avcodec_send_packet(avctx, &pkt);
3025 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3029 ret = avcodec_receive_frame(avctx, frame);
3032 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3034 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3035 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3036 &got_picture, &pkt);
3042 st->nb_decoded_frames++;
3047 if (!pkt.data && !got_picture)
3051 if (do_skip_frame) {
3052 avctx->skip_frame = skip_frame;
3055 av_frame_free(&frame);
3059 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3061 while (tags->id != AV_CODEC_ID_NONE) {
3069 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3072 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3073 if (tag == tags[i].tag)
3075 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3076 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3078 return AV_CODEC_ID_NONE;
3081 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3083 if (bps <= 0 || bps > 64)
3084 return AV_CODEC_ID_NONE;
3089 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3091 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3093 return AV_CODEC_ID_NONE;
3098 if (sflags & (1 << (bps - 1))) {
3101 return AV_CODEC_ID_PCM_S8;
3103 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3105 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3107 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3109 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3111 return AV_CODEC_ID_NONE;
3116 return AV_CODEC_ID_PCM_U8;
3118 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3120 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3122 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3124 return AV_CODEC_ID_NONE;
3130 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3133 if (!av_codec_get_tag2(tags, id, &tag))
3138 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3142 for (i = 0; tags && tags[i]; i++) {
3143 const AVCodecTag *codec_tags = tags[i];
3144 while (codec_tags->id != AV_CODEC_ID_NONE) {
3145 if (codec_tags->id == id) {
3146 *tag = codec_tags->tag;
3155 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3158 for (i = 0; tags && tags[i]; i++) {
3159 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3160 if (id != AV_CODEC_ID_NONE)
3163 return AV_CODEC_ID_NONE;
3166 static void compute_chapters_end(AVFormatContext *s)
3169 int64_t max_time = 0;
3171 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3172 max_time = s->duration +
3173 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3175 for (i = 0; i < s->nb_chapters; i++)
3176 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3177 AVChapter *ch = s->chapters[i];
3178 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3182 for (j = 0; j < s->nb_chapters; j++) {
3183 AVChapter *ch1 = s->chapters[j];
3184 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3186 if (j != i && next_start > ch->start && next_start < end)
3189 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3193 static int get_std_framerate(int i)
3196 return (i + 1) * 1001;
3200 return (i + 31) * 1001 * 12;
3204 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3208 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3211 /* Is the time base unreliable?
3212 * This is a heuristic to balance between quick acceptance of the values in
3213 * the headers vs. some extra checks.
3214 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3215 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3216 * And there are "variable" fps files this needs to detect as well. */
3217 static int tb_unreliable(AVCodecContext *c)
3219 if (c->time_base.den >= 101LL * c->time_base.num ||
3220 c->time_base.den < 5LL * c->time_base.num ||
3221 // c->codec_tag == AV_RL32("DIVX") ||
3222 // c->codec_tag == AV_RL32("XVID") ||
3223 c->codec_tag == AV_RL32("mp4v") ||
3224 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3225 c->codec_id == AV_CODEC_ID_GIF ||
3226 c->codec_id == AV_CODEC_ID_HEVC ||
3227 c->codec_id == AV_CODEC_ID_H264)
3232 int ff_alloc_extradata(AVCodecParameters *par, int size)
3236 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3237 par->extradata = NULL;
3238 par->extradata_size = 0;
3239 return AVERROR(EINVAL);
3241 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3242 if (par->extradata) {
3243 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3244 par->extradata_size = size;
3247 par->extradata_size = 0;
3248 ret = AVERROR(ENOMEM);
3253 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3255 int ret = ff_alloc_extradata(par, size);
3258 ret = avio_read(pb, par->extradata, size);
3260 av_freep(&par->extradata);
3261 par->extradata_size = 0;
3262 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3263 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3269 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3272 int64_t last = st->info->last_dts;
3274 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3275 && ts - (uint64_t)last < INT64_MAX) {
3276 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3277 int64_t duration = ts - last;
3279 if (!st->info->duration_error)
3280 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3281 if (!st->info->duration_error)
3282 return AVERROR(ENOMEM);
3284 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3285 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3286 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3287 if (st->info->duration_error[0][1][i] < 1e10) {
3288 int framerate = get_std_framerate(i);
3289 double sdts = dts*framerate/(1001*12);
3290 for (j= 0; j<2; j++) {
3291 int64_t ticks = llrint(sdts+j*0.5);
3292 double error= sdts - ticks + j*0.5;
3293 st->info->duration_error[j][0][i] += error;
3294 st->info->duration_error[j][1][i] += error*error;
3298 st->info->duration_count++;
3299 st->info->rfps_duration_sum += duration;
3301 if (st->info->duration_count % 10 == 0) {
3302 int n = st->info->duration_count;
3303 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3304 if (st->info->duration_error[0][1][i] < 1e10) {
3305 double a0 = st->info->duration_error[0][0][i] / n;
3306 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3307 double a1 = st->info->duration_error[1][0][i] / n;
3308 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3309 if (error0 > 0.04 && error1 > 0.04) {
3310 st->info->duration_error[0][1][i] = 2e10;
3311 st->info->duration_error[1][1][i] = 2e10;
3317 // ignore the first 4 values, they might have some random jitter
3318 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3319 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3321 if (ts != AV_NOPTS_VALUE)
3322 st->info->last_dts = ts;
3327 void ff_rfps_calculate(AVFormatContext *ic)
3331 for (i = 0; i < ic->nb_streams; i++) {
3332 AVStream *st = ic->streams[i];
3334 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3336 // the check for tb_unreliable() is not completely correct, since this is not about handling
3337 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3338 // ipmovie.c produces.
3339 if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3340 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3341 if (st->info->duration_count>1 && !st->r_frame_rate.num
3342 && tb_unreliable(st->internal->avctx)) {
3344 double best_error= 0.01;
3345 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3347 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3350 if (st->info->codec_info_duration &&
3351 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3353 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3356 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3359 for (k= 0; k<2; k++) {
3360 int n = st->info->duration_count;
3361 double a= st->info->duration_error[k][0][j] / n;
3362 double error= st->info->duration_error[k][1][j]/n - a*a;
3364 if (error < best_error && best_error> 0.000000001) {
3366 num = get_std_framerate(j);
3369 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3372 // do not increase frame rate by more than 1 % in order to match a standard rate.
3373 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3374 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3376 if ( !st->avg_frame_rate.num
3377 && st->r_frame_rate.num && st->info->rfps_duration_sum
3378 && st->info->codec_info_duration <= 0
3379 && st->info->duration_count > 2
3380 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3382 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3383 st->avg_frame_rate = st->r_frame_rate;
3386 av_freep(&st->info->duration_error);
3387 st->info->last_dts = AV_NOPTS_VALUE;
3388 st->info->duration_count = 0;
3389 st->info->rfps_duration_sum = 0;
3393 static int extract_extradata_check(AVStream *st)
3395 const AVBitStreamFilter *f;
3397 f = av_bsf_get_by_name("extract_extradata");
3402 const enum AVCodecID *ids;
3403 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3404 if (*ids == st->codecpar->codec_id)
3411 static int extract_extradata_init(AVStream *st)
3413 AVStreamInternal *i = st->internal;
3414 const AVBitStreamFilter *f;
3417 f = av_bsf_get_by_name("extract_extradata");
3421 /* check that the codec id is supported */
3422 ret = extract_extradata_check(st);
3426 i->extract_extradata.pkt = av_packet_alloc();
3427 if (!i->extract_extradata.pkt)
3428 return AVERROR(ENOMEM);
3430 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3434 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3439 i->extract_extradata.bsf->time_base_in = st->time_base;
3441 /* if init fails here, we assume extracting extradata is just not
3442 * supported for this codec, so we return success */
3443 ret = av_bsf_init(i->extract_extradata.bsf);
3445 av_bsf_free(&i->extract_extradata.bsf);
3450 i->extract_extradata.inited = 1;
3454 av_bsf_free(&i->extract_extradata.bsf);
3455 av_packet_free(&i->extract_extradata.pkt);
3459 static int extract_extradata(AVStream *st, AVPacket *pkt)
3461 AVStreamInternal *i = st->internal;
3465 if (!i->extract_extradata.inited) {
3466 ret = extract_extradata_init(st);
3471 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3474 pkt_ref = i->extract_extradata.pkt;
3475 ret = av_packet_ref(pkt_ref, pkt);
3479 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3481 av_packet_unref(pkt_ref);
3485 while (ret >= 0 && !i->avctx->extradata) {
3489 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3491 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3496 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3500 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3501 if (!i->avctx->extradata) {
3502 av_packet_unref(pkt_ref);
3503 return AVERROR(ENOMEM);
3505 memcpy(i->avctx->extradata, extradata, extradata_size);
3506 i->avctx->extradata_size = extradata_size;
3508 av_packet_unref(pkt_ref);
3514 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3516 int i, count = 0, ret = 0, j;
3519 AVCodecContext *avctx;
3520 AVPacket pkt1, *pkt;
3521 int64_t old_offset = avio_tell(ic->pb);
3522 // new streams might appear, no options for those
3523 int orig_nb_streams = ic->nb_streams;
3525 int64_t max_analyze_duration = ic->max_analyze_duration;
3526 int64_t max_stream_analyze_duration;
3527 int64_t max_subtitle_analyze_duration;
3528 int64_t probesize = ic->probesize;
3529 int eof_reached = 0;
3530 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3532 flush_codecs = probesize > 0;
3534 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3536 max_stream_analyze_duration = max_analyze_duration;
3537 max_subtitle_analyze_duration = max_analyze_duration;
3538 if (!max_analyze_duration) {
3539 max_stream_analyze_duration =
3540 max_analyze_duration = 5*AV_TIME_BASE;
3541 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3542 if (!strcmp(ic->iformat->name, "flv"))
3543 max_stream_analyze_duration = 90*AV_TIME_BASE;
3544 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3545 max_stream_analyze_duration = 7*AV_TIME_BASE;
3549 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3550 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3552 for (i = 0; i < ic->nb_streams; i++) {
3553 const AVCodec *codec;
3554 AVDictionary *thread_opt = NULL;
3555 st = ic->streams[i];
3556 avctx = st->internal->avctx;
3558 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3559 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3560 /* if (!st->time_base.num)
3562 if (!avctx->time_base.num)
3563 avctx->time_base = st->time_base;
3566 /* check if the caller has overridden the codec id */
3567 #if FF_API_LAVF_AVCTX
3568 FF_DISABLE_DEPRECATION_WARNINGS
3569 if (st->codec->codec_id != st->internal->orig_codec_id) {
3570 st->codecpar->codec_id = st->codec->codec_id;
3571 st->codecpar->codec_type = st->codec->codec_type;
3572 st->internal->orig_codec_id = st->codec->codec_id;
3574 FF_ENABLE_DEPRECATION_WARNINGS
3576 // only for the split stuff
3577 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3578 st->parser = av_parser_init(st->codecpar->codec_id);
3580 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3581 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3582 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3583 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3585 } else if (st->need_parsing) {
3586 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3587 "%s, packets or times may be invalid.\n",
3588 avcodec_get_name(st->codecpar->codec_id));
3592 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3593 st->internal->orig_codec_id = st->codecpar->codec_id;
3595 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3597 goto find_stream_info_err;
3598 if (st->request_probe <= 0)
3599 st->internal->avctx_inited = 1;
3601 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3603 /* Force thread count to 1 since the H.264 decoder will not extract
3604 * SPS and PPS to extradata during multi-threaded decoding. */
3605 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3607 if (ic->codec_whitelist)
3608 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3610 /* Ensure that subtitle_header is properly set. */
3611 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3612 && codec && !avctx->codec) {
3613 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3614 av_log(ic, AV_LOG_WARNING,
3615 "Failed to open codec in %s\n",__FUNCTION__);
3618 // Try to just open decoders, in case this is enough to get parameters.
3619 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3620 if (codec && !avctx->codec)
3621 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3622 av_log(ic, AV_LOG_WARNING,
3623 "Failed to open codec in %s\n",__FUNCTION__);
3626 av_dict_free(&thread_opt);
3629 for (i = 0; i < ic->nb_streams; i++) {
3630 #if FF_API_R_FRAME_RATE
3631 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3633 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3634 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3639 int analyzed_all_streams;
3640 if (ff_check_interrupt(&ic->interrupt_callback)) {
3642 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3646 /* check if one codec still needs to be handled */
3647 for (i = 0; i < ic->nb_streams; i++) {
3648 int fps_analyze_framecount = 20;
3651 st = ic->streams[i];
3652 if (!has_codec_parameters(st, NULL))
3654 /* If the timebase is coarse (like the usual millisecond precision
3655 * of mkv), we need to analyze more frames to reliably arrive at
3656 * the correct fps. */
3657 if (av_q2d(st->time_base) > 0.0005)
3658 fps_analyze_framecount *= 2;
3659 if (!tb_unreliable(st->internal->avctx))
3660 fps_analyze_framecount = 0;
3661 if (ic->fps_probe_size >= 0)
3662 fps_analyze_framecount = ic->fps_probe_size;
3663 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3664 fps_analyze_framecount = 0;
3665 /* variable fps and no guess at the real fps */
3666 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3667 st->info->codec_info_duration_fields/2 :
3668 st->info->duration_count;
3669 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3670 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3671 if (count < fps_analyze_framecount)
3674 // Look at the first 3 frames if there is evidence of frame delay
3675 // but the decoder delay is not set.
3676 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3678 if (!st->internal->avctx->extradata &&
3679 (!st->internal->extract_extradata.inited ||
3680 st->internal->extract_extradata.bsf) &&
3681 extract_extradata_check(st))
3683 if (st->first_dts == AV_NOPTS_VALUE &&
3684 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3685 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3686 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3687 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3690 analyzed_all_streams = 0;
3691 if (!missing_streams || !*missing_streams)
3692 if (i == ic->nb_streams) {
3693 analyzed_all_streams = 1;
3694 /* NOTE: If the format has no header, then we need to read some
3695 * packets to get most of the streams, so we cannot stop here. */
3696 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3697 /* If we found the info for all the codecs, we can stop. */
3699 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3704 /* We did not get all the codec info, but we read too much data. */
3705 if (read_size >= probesize) {
3707 av_log(ic, AV_LOG_DEBUG,
3708 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3709 for (i = 0; i < ic->nb_streams; i++)
3710 if (!ic->streams[i]->r_frame_rate.num &&
3711 ic->streams[i]->info->duration_count <= 1 &&
3712 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3713 strcmp(ic->iformat->name, "image2"))
3714 av_log(ic, AV_LOG_WARNING,
3715 "Stream #%d: not enough frames to estimate rate; "
3716 "consider increasing probesize\n", i);
3720 /* NOTE: A new stream can be added there if no header in file
3721 * (AVFMTCTX_NOHEADER). */
3722 ret = read_frame_internal(ic, &pkt1);
3723 if (ret == AVERROR(EAGAIN))
3734 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3735 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3736 &ic->internal->packet_buffer_end, 0);
3738 goto find_stream_info_err;
3741 st = ic->streams[pkt->stream_index];
3742 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3743 read_size += pkt->size;
3745 avctx = st->internal->avctx;
3746 if (!st->internal->avctx_inited) {
3747 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3749 goto find_stream_info_err;
3750 st->internal->avctx_inited = 1;
3753 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3754 /* check for non-increasing dts */
3755 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3756 st->info->fps_last_dts >= pkt->dts) {
3757 av_log(ic, AV_LOG_DEBUG,
3758 "Non-increasing DTS in stream %d: packet %d with DTS "
3759 "%"PRId64", packet %d with DTS %"PRId64"\n",
3760 st->index, st->info->fps_last_dts_idx,
3761 st->info->fps_last_dts, st->codec_info_nb_frames,
3763 st->info->fps_first_dts =
3764 st->info->fps_last_dts = AV_NOPTS_VALUE;
3766 /* Check for a discontinuity in dts. If the difference in dts
3767 * is more than 1000 times the average packet duration in the
3768 * sequence, we treat it as a discontinuity. */
3769 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3770 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3771 (pkt->dts - st->info->fps_last_dts) / 1000 >
3772 (st->info->fps_last_dts - st->info->fps_first_dts) /
3773 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3774 av_log(ic, AV_LOG_WARNING,
3775 "DTS discontinuity in stream %d: packet %d with DTS "
3776 "%"PRId64", packet %d with DTS %"PRId64"\n",
3777 st->index, st->info->fps_last_dts_idx,
3778 st->info->fps_last_dts, st->codec_info_nb_frames,
3780 st->info->fps_first_dts =
3781 st->info->fps_last_dts = AV_NOPTS_VALUE;
3784 /* update stored dts values */
3785 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3786 st->info->fps_first_dts = pkt->dts;
3787 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3789 st->info->fps_last_dts = pkt->dts;
3790 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3792 if (st->codec_info_nb_frames>1) {
3796 if (st->time_base.den > 0)
3797 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3798 if (st->avg_frame_rate.num > 0)
3799 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3802 && st->codec_info_nb_frames>30
3803 && st->info->fps_first_dts != AV_NOPTS_VALUE
3804 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3805 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3807 if (analyzed_all_streams) limit = max_analyze_duration;
3808 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3809 else limit = max_stream_analyze_duration;
3812 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3814 t, pkt->stream_index);
3815 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3816 av_packet_unref(pkt);
3819 if (pkt->duration) {
3820 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3821 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3823 st->info->codec_info_duration += pkt->duration;
3824 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3827 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3828 #if FF_API_R_FRAME_RATE
3829 ff_rfps_add_frame(ic, st, pkt->dts);
3831 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3832 st->info->frame_delay_evidence = 1;
3834 if (!st->internal->avctx->extradata) {
3835 ret = extract_extradata(st, pkt);
3837 goto find_stream_info_err;
3840 /* If still no information, we try to open the codec and to
3841 * decompress the frame. We try to avoid that in most cases as
3842 * it takes longer and uses more memory. For MPEG-4, we need to
3843 * decompress for QuickTime.
3845 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3846 * least one frame of codec data, this makes sure the codec initializes
3847 * the channel configuration and does not only trust the values from
3849 try_decode_frame(ic, st, pkt,
3850 (options && i < orig_nb_streams) ? &options[i] : NULL);
3852 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3853 av_packet_unref(pkt);
3855 st->codec_info_nb_frames++;
3861 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3862 st = ic->streams[stream_index];
3863 avctx = st->internal->avctx;
3864 if (!has_codec_parameters(st, NULL)) {
3865 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3866 if (codec && !avctx->codec) {
3867 AVDictionary *opts = NULL;
3868 if (ic->codec_whitelist)
3869 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3870 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3871 av_log(ic, AV_LOG_WARNING,
3872 "Failed to open codec in %s\n",__FUNCTION__);
3873 av_dict_free(&opts);
3877 // EOF already reached while reading the stream above.
3878 // So continue with reoordering DTS with whatever delay we have.
3879 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3880 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3886 AVPacket empty_pkt = { 0 };
3888 av_init_packet(&empty_pkt);
3890 for (i = 0; i < ic->nb_streams; i++) {
3892 st = ic->streams[i];
3894 /* flush the decoders */
3895 if (st->info->found_decoder == 1) {
3897 err = try_decode_frame(ic, st, &empty_pkt,
3898 (options && i < orig_nb_streams)
3899 ? &options[i] : NULL);
3900 } while (err > 0 && !has_codec_parameters(st, NULL));
3903 av_log(ic, AV_LOG_INFO,
3904 "decoding for stream %d failed\n", st->index);
3910 ff_rfps_calculate(ic);
3912 for (i = 0; i < ic->nb_streams; i++) {
3913 st = ic->streams[i];
3914 avctx = st->internal->avctx;
3915 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3916 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3917 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3918 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3919 avctx->codec_tag= tag;
3922 /* estimate average framerate if not set by demuxer */
3923 if (st->info->codec_info_duration_fields &&
3924 !st->avg_frame_rate.num &&
3925 st->info->codec_info_duration) {
3927 double best_error = 0.01;
3928 AVRational codec_frame_rate = avctx->framerate;
3930 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3931 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3932 st->info->codec_info_duration < 0)
3934 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3935 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3936 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3938 /* Round guessed framerate to a "standard" framerate if it's
3939 * within 1% of the original estimate. */
3940 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3941 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3942 double error = fabs(av_q2d(st->avg_frame_rate) /
3943 av_q2d(std_fps) - 1);
3945 if (error < best_error) {
3947 best_fps = std_fps.num;
3950 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3951 error = fabs(av_q2d(codec_frame_rate) /
3952 av_q2d(std_fps) - 1);
3953 if (error < best_error) {
3955 best_fps = std_fps.num;
3960 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3961 best_fps, 12 * 1001, INT_MAX);
3964 if (!st->r_frame_rate.num) {
3965 if ( avctx->time_base.den * (int64_t) st->time_base.num
3966 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3967 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3968 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3970 st->r_frame_rate.num = st->time_base.den;
3971 st->r_frame_rate.den = st->time_base.num;
3974 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3975 AVRational hw_ratio = { avctx->height, avctx->width };
3976 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3979 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3980 if (!avctx->bits_per_coded_sample)
3981 avctx->bits_per_coded_sample =
3982 av_get_bits_per_sample(avctx->codec_id);
3983 // set stream disposition based on audio service type
3984 switch (avctx->audio_service_type) {
3985 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3986 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3988 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3989 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3991 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3992 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3994 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3995 st->disposition = AV_DISPOSITION_COMMENT;
3997 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3998 st->disposition = AV_DISPOSITION_KARAOKE;
4005 estimate_timings(ic, old_offset);
4007 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4009 if (ret >= 0 && ic->nb_streams)
4010 /* We could not have all the codec parameters before EOF. */
4012 for (i = 0; i < ic->nb_streams; i++) {
4014 st = ic->streams[i];
4016 /* if no packet was ever seen, update context now for has_codec_parameters */
4017 if (!st->internal->avctx_inited) {
4018 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4019 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4020 st->codecpar->format = st->internal->avctx->sample_fmt;
4021 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4023 goto find_stream_info_err;
4025 if (!has_codec_parameters(st, &errmsg)) {
4027 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4028 av_log(ic, AV_LOG_WARNING,
4029 "Could not find codec parameters for stream %d (%s): %s\n"
4030 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4037 compute_chapters_end(ic);
4039 /* update the stream parameters from the internal codec contexts */
4040 for (i = 0; i < ic->nb_streams; i++) {
4041 st = ic->streams[i];
4043 if (st->internal->avctx_inited) {
4044 int orig_w = st->codecpar->width;
4045 int orig_h = st->codecpar->height;
4046 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4048 goto find_stream_info_err;
4050 // The decoder might reduce the video size by the lowres factor.
4051 if (st->internal->avctx->lowres && orig_w) {
4052 st->codecpar->width = orig_w;
4053 st->codecpar->height = orig_h;
4058 #if FF_API_LAVF_AVCTX
4059 FF_DISABLE_DEPRECATION_WARNINGS
4060 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4062 goto find_stream_info_err;
4065 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4066 // by the lowres factor.
4067 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4068 st->codec->lowres = st->internal->avctx->lowres;
4069 st->codec->width = st->internal->avctx->width;
4070 st->codec->height = st->internal->avctx->height;
4074 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4075 st->codec->time_base = st->internal->avctx->time_base;
4076 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4078 st->codec->framerate = st->avg_frame_rate;
4080 if (st->internal->avctx->subtitle_header) {
4081 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4082 if (!st->codec->subtitle_header)
4083 goto find_stream_info_err;
4084 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4085 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4086 st->codec->subtitle_header_size);
4089 // Fields unavailable in AVCodecParameters
4090 st->codec->coded_width = st->internal->avctx->coded_width;
4091 st->codec->coded_height = st->internal->avctx->coded_height;
4092 st->codec->properties = st->internal->avctx->properties;
4093 FF_ENABLE_DEPRECATION_WARNINGS
4096 st->internal->avctx_inited = 0;
4099 find_stream_info_err:
4100 for (i = 0; i < ic->nb_streams; i++) {
4101 st = ic->streams[i];
4103 av_freep(&st->info->duration_error);
4104 avcodec_close(ic->streams[i]->internal->avctx);
4105 av_freep(&ic->streams[i]->info);
4106 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4107 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4110 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4111 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4115 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4119 for (i = 0; i < ic->nb_programs; i++) {
4120 if (ic->programs[i] == last) {
4124 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4125 if (ic->programs[i]->stream_index[j] == s)
4126 return ic->programs[i];
4132 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4133 int wanted_stream_nb, int related_stream,
4134 AVCodec **decoder_ret, int flags)
4136 int i, nb_streams = ic->nb_streams;
4137 int ret = AVERROR_STREAM_NOT_FOUND;
4138 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4139 int count, multiframe, disposition;
4140 int64_t best_bitrate = -1;
4142 unsigned *program = NULL;
4143 const AVCodec *decoder = NULL, *best_decoder = NULL;
4145 if (related_stream >= 0 && wanted_stream_nb < 0) {
4146 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4148 program = p->stream_index;
4149 nb_streams = p->nb_stream_indexes;
4152 for (i = 0; i < nb_streams; i++) {
4153 int real_stream_index = program ? program[i] : i;
4154 AVStream *st = ic->streams[real_stream_index];
4155 AVCodecParameters *par = st->codecpar;
4156 if (par->codec_type != type)
4158 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4160 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4163 decoder = find_decoder(ic, st, par->codec_id);
4166 ret = AVERROR_DECODER_NOT_FOUND;
4170 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4171 count = st->codec_info_nb_frames;
4172 bitrate = par->bit_rate;
4173 multiframe = FFMIN(5, count);
4174 if ((best_disposition > disposition) ||
4175 (best_disposition == disposition && best_multiframe > multiframe) ||
4176 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4177 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4179 best_disposition = disposition;
4181 best_bitrate = bitrate;
4182 best_multiframe = multiframe;
4183 ret = real_stream_index;
4184 best_decoder = decoder;
4185 if (program && i == nb_streams - 1 && ret < 0) {
4187 nb_streams = ic->nb_streams;
4188 /* no related stream found, try again with everything */
4193 *decoder_ret = (AVCodec*)best_decoder;
4197 /*******************************************************/
4199 int av_read_play(AVFormatContext *s)
4201 if (s->iformat->read_play)
4202 return s->iformat->read_play(s);
4204 return avio_pause(s->pb, 0);
4205 return AVERROR(ENOSYS);
4208 int av_read_pause(AVFormatContext *s)
4210 if (s->iformat->read_pause)
4211 return s->iformat->read_pause(s);
4213 return avio_pause(s->pb, 1);
4214 return AVERROR(ENOSYS);
4217 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4222 dst->time_base = src->time_base;
4223 dst->nb_frames = src->nb_frames;
4224 dst->disposition = src->disposition;
4225 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4226 dst->avg_frame_rate = src->avg_frame_rate;
4227 dst->r_frame_rate = src->r_frame_rate;
4229 av_dict_free(&dst->metadata);
4230 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4234 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4238 /* Free existing side data*/
4239 for (i = 0; i < dst->nb_side_data; i++)
4240 av_free(dst->side_data[i].data);
4241 av_freep(&dst->side_data);
4242 dst->nb_side_data = 0;
4244 /* Copy side data if present */
4245 if (src->nb_side_data) {
4246 dst->side_data = av_mallocz_array(src->nb_side_data,
4247 sizeof(AVPacketSideData));
4248 if (!dst->side_data)
4249 return AVERROR(ENOMEM);
4250 dst->nb_side_data = src->nb_side_data;
4252 for (i = 0; i < src->nb_side_data; i++) {
4253 uint8_t *data = av_memdup(src->side_data[i].data,
4254 src->side_data[i].size);
4256 return AVERROR(ENOMEM);
4257 dst->side_data[i].type = src->side_data[i].type;
4258 dst->side_data[i].size = src->side_data[i].size;
4259 dst->side_data[i].data = data;
4263 #if FF_API_LAVF_FFSERVER
4264 FF_DISABLE_DEPRECATION_WARNINGS
4265 av_freep(&dst->recommended_encoder_configuration);
4266 if (src->recommended_encoder_configuration) {
4267 const char *conf_str = src->recommended_encoder_configuration;
4268 dst->recommended_encoder_configuration = av_strdup(conf_str);
4269 if (!dst->recommended_encoder_configuration)
4270 return AVERROR(ENOMEM);
4272 FF_ENABLE_DEPRECATION_WARNINGS
4278 static void free_stream(AVStream **pst)
4280 AVStream *st = *pst;
4286 for (i = 0; i < st->nb_side_data; i++)
4287 av_freep(&st->side_data[i].data);
4288 av_freep(&st->side_data);
4291 av_parser_close(st->parser);
4293 if (st->attached_pic.data)
4294 av_packet_unref(&st->attached_pic);
4297 avcodec_free_context(&st->internal->avctx);
4298 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4299 av_bsf_free(&st->internal->bsfcs[i]);
4300 av_freep(&st->internal->bsfcs);
4302 av_freep(&st->internal->priv_pts);
4303 av_bsf_free(&st->internal->extract_extradata.bsf);
4304 av_packet_free(&st->internal->extract_extradata.pkt);
4306 av_freep(&st->internal);
4308 av_dict_free(&st->metadata);
4309 avcodec_parameters_free(&st->codecpar);
4310 av_freep(&st->probe_data.buf);
4311 av_freep(&st->index_entries);
4312 #if FF_API_LAVF_AVCTX
4313 FF_DISABLE_DEPRECATION_WARNINGS
4314 avcodec_free_context(&st->codec);
4315 FF_ENABLE_DEPRECATION_WARNINGS
4317 av_freep(&st->priv_data);
4319 av_freep(&st->info->duration_error);
4320 av_freep(&st->info);
4321 #if FF_API_LAVF_FFSERVER
4322 FF_DISABLE_DEPRECATION_WARNINGS
4323 av_freep(&st->recommended_encoder_configuration);
4324 FF_ENABLE_DEPRECATION_WARNINGS
4330 void ff_free_stream(AVFormatContext *s, AVStream *st)
4332 av_assert0(s->nb_streams>0);
4333 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4335 free_stream(&s->streams[ --s->nb_streams ]);
4338 void avformat_free_context(AVFormatContext *s)
4346 if (s->iformat && s->iformat->priv_class && s->priv_data)
4347 av_opt_free(s->priv_data);
4348 if (s->oformat && s->oformat->priv_class && s->priv_data)
4349 av_opt_free(s->priv_data);
4351 for (i = s->nb_streams - 1; i >= 0; i--)
4352 ff_free_stream(s, s->streams[i]);
4355 for (i = s->nb_programs - 1; i >= 0; i--) {
4356 av_dict_free(&s->programs[i]->metadata);
4357 av_freep(&s->programs[i]->stream_index);
4358 av_freep(&s->programs[i]);
4360 av_freep(&s->programs);
4361 av_freep(&s->priv_data);
4362 while (s->nb_chapters--) {
4363 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4364 av_freep(&s->chapters[s->nb_chapters]);
4366 av_freep(&s->chapters);
4367 av_dict_free(&s->metadata);
4368 av_dict_free(&s->internal->id3v2_meta);
4369 av_freep(&s->streams);
4370 flush_packet_queue(s);
4371 av_freep(&s->internal);
4375 void avformat_close_input(AVFormatContext **ps)
4386 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4387 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4390 flush_packet_queue(s);
4393 if (s->iformat->read_close)
4394 s->iformat->read_close(s);
4396 avformat_free_context(s);
4403 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4409 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4410 if (s->max_streams < INT_MAX/sizeof(*streams))
4411 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4414 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4417 s->streams = streams;
4419 st = av_mallocz(sizeof(AVStream));
4422 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4426 st->info->last_dts = AV_NOPTS_VALUE;
4428 #if FF_API_LAVF_AVCTX
4429 FF_DISABLE_DEPRECATION_WARNINGS
4430 st->codec = avcodec_alloc_context3(c);
4436 FF_ENABLE_DEPRECATION_WARNINGS
4439 st->internal = av_mallocz(sizeof(*st->internal));
4443 st->codecpar = avcodec_parameters_alloc();
4447 st->internal->avctx = avcodec_alloc_context3(NULL);
4448 if (!st->internal->avctx)
4452 #if FF_API_LAVF_AVCTX
4453 FF_DISABLE_DEPRECATION_WARNINGS
4454 /* no default bitrate if decoding */
4455 st->codec->bit_rate = 0;
4456 FF_ENABLE_DEPRECATION_WARNINGS
4459 /* default pts setting is MPEG-like */
4460 avpriv_set_pts_info(st, 33, 1, 90000);
4461 /* we set the current DTS to 0 so that formats without any timestamps
4462 * but durations get some timestamps, formats with some unknown
4463 * timestamps have their first few packets buffered and the
4464 * timestamps corrected before they are returned to the user */
4465 st->cur_dts = RELATIVE_TS_BASE;
4467 st->cur_dts = AV_NOPTS_VALUE;
4470 st->index = s->nb_streams;
4471 st->start_time = AV_NOPTS_VALUE;
4472 st->duration = AV_NOPTS_VALUE;
4473 st->first_dts = AV_NOPTS_VALUE;
4474 st->probe_packets = MAX_PROBE_PACKETS;
4475 st->pts_wrap_reference = AV_NOPTS_VALUE;
4476 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4478 st->last_IP_pts = AV_NOPTS_VALUE;
4479 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4480 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4481 st->pts_buffer[i] = AV_NOPTS_VALUE;
4483 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4485 #if FF_API_R_FRAME_RATE
4486 st->info->last_dts = AV_NOPTS_VALUE;
4488 st->info->fps_first_dts = AV_NOPTS_VALUE;
4489 st->info->fps_last_dts = AV_NOPTS_VALUE;
4491 st->inject_global_side_data = s->internal->inject_global_side_data;
4493 st->internal->need_context_update = 1;
4495 s->streams[s->nb_streams++] = st;
4502 AVProgram *av_new_program(AVFormatContext *ac, int id)
4504 AVProgram *program = NULL;
4507 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4509 for (i = 0; i < ac->nb_programs; i++)
4510 if (ac->programs[i]->id == id)
4511 program = ac->programs[i];
4514 program = av_mallocz(sizeof(AVProgram));
4517 dynarray_add(&ac->programs, &ac->nb_programs, program);
4518 program->discard = AVDISCARD_NONE;
4521 program->pts_wrap_reference = AV_NOPTS_VALUE;
4522 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4524 program->start_time =
4525 program->end_time = AV_NOPTS_VALUE;
4530 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4531 int64_t start, int64_t end, const char *title)
4533 AVChapter *chapter = NULL;
4536 if (end != AV_NOPTS_VALUE && start > end) {
4537 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4541 for (i = 0; i < s->nb_chapters; i++)
4542 if (s->chapters[i]->id == id)
4543 chapter = s->chapters[i];
4546 chapter = av_mallocz(sizeof(AVChapter));
4549 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4551 av_dict_set(&chapter->metadata, "title", title, 0);
4553 chapter->time_base = time_base;
4554 chapter->start = start;
4560 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4563 AVProgram *program = NULL;
4566 if (idx >= ac->nb_streams) {
4567 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4571 for (i = 0; i < ac->nb_programs; i++) {
4572 if (ac->programs[i]->id != progid)
4574 program = ac->programs[i];
4575 for (j = 0; j < program->nb_stream_indexes; j++)
4576 if (program->stream_index[j] == idx)
4579 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4582 program->stream_index = tmp;
4583 program->stream_index[program->nb_stream_indexes++] = idx;
4588 uint64_t ff_ntp_time(void)
4590 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4593 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4596 char *q, buf1[20], c;
4597 int nd, len, percentd_found;
4609 while (av_isdigit(*p))
4610 nd = nd * 10 + *p++ - '0';
4612 } while (av_isdigit(c));
4618 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4623 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4625 if ((q - buf + len) > buf_size - 1)
4627 memcpy(q, buf1, len);
4635 if ((q - buf) < buf_size - 1)
4639 if (!percentd_found)
4648 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4650 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4653 void av_url_split(char *proto, int proto_size,
4654 char *authorization, int authorization_size,
4655 char *hostname, int hostname_size,
4656 int *port_ptr, char *path, int path_size, const char *url)
4658 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4664 if (authorization_size > 0)
4665 authorization[0] = 0;
4666 if (hostname_size > 0)
4671 /* parse protocol */
4672 if ((p = strchr(url, ':'))) {
4673 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4680 /* no protocol means plain filename */
4681 av_strlcpy(path, url, path_size);
4685 /* separate path from hostname */
4686 ls = strchr(p, '/');
4687 ls2 = strchr(p, '?');
4691 ls = FFMIN(ls, ls2);
4693 av_strlcpy(path, ls, path_size);
4695 ls = &p[strlen(p)]; // XXX
4697 /* the rest is hostname, use that to parse auth/port */
4699 /* authorization (user[:pass]@hostname) */
4701 while ((at = strchr(p, '@')) && at < ls) {
4702 av_strlcpy(authorization, at2,
4703 FFMIN(authorization_size, at + 1 - at2));
4704 p = at + 1; /* skip '@' */
4707 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4709 av_strlcpy(hostname, p + 1,
4710 FFMIN(hostname_size, brk - p));
4711 if (brk[1] == ':' && port_ptr)
4712 *port_ptr = atoi(brk + 2);
4713 } else if ((col = strchr(p, ':')) && col < ls) {
4714 av_strlcpy(hostname, p,
4715 FFMIN(col + 1 - p, hostname_size));
4717 *port_ptr = atoi(col + 1);
4719 av_strlcpy(hostname, p,
4720 FFMIN(ls + 1 - p, hostname_size));
4724 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4727 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4730 'C', 'D', 'E', 'F' };
4731 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4734 'c', 'd', 'e', 'f' };
4735 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4737 for (i = 0; i < s; i++) {
4738 buff[i * 2] = hex_table[src[i] >> 4];
4739 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4745 int ff_hex_to_data(uint8_t *data, const char *p)
4752 p += strspn(p, SPACE_CHARS);
4755 c = av_toupper((unsigned char) *p++);
4756 if (c >= '0' && c <= '9')
4758 else if (c >= 'A' && c <= 'F')
4773 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4774 unsigned int pts_num, unsigned int pts_den)
4777 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4778 if (new_tb.num != pts_num)
4779 av_log(NULL, AV_LOG_DEBUG,
4780 "st:%d removing common factor %d from timebase\n",
4781 s->index, pts_num / new_tb.num);
4783 av_log(NULL, AV_LOG_WARNING,
4784 "st:%d has too large timebase, reducing\n", s->index);
4786 if (new_tb.num <= 0 || new_tb.den <= 0) {
4787 av_log(NULL, AV_LOG_ERROR,
4788 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4789 new_tb.num, new_tb.den,
4793 s->time_base = new_tb;
4794 #if FF_API_LAVF_AVCTX
4795 FF_DISABLE_DEPRECATION_WARNINGS
4796 s->codec->pkt_timebase = new_tb;
4797 FF_ENABLE_DEPRECATION_WARNINGS
4799 s->internal->avctx->pkt_timebase = new_tb;
4800 s->pts_wrap_bits = pts_wrap_bits;
4803 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4806 const char *ptr = str;
4808 /* Parse key=value pairs. */
4811 char *dest = NULL, *dest_end;
4812 int key_len, dest_len = 0;
4814 /* Skip whitespace and potential commas. */
4815 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4822 if (!(ptr = strchr(key, '=')))
4825 key_len = ptr - key;
4827 callback_get_buf(context, key, key_len, &dest, &dest_len);
4828 dest_end = dest + dest_len - 1;
4832 while (*ptr && *ptr != '\"') {
4836 if (dest && dest < dest_end)
4840 if (dest && dest < dest_end)
4848 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4849 if (dest && dest < dest_end)
4857 int ff_find_stream_index(AVFormatContext *s, int id)
4860 for (i = 0; i < s->nb_streams; i++)
4861 if (s->streams[i]->id == id)
4866 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4870 unsigned int codec_tag;
4871 if (ofmt->query_codec)
4872 return ofmt->query_codec(codec_id, std_compliance);
4873 else if (ofmt->codec_tag)
4874 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4875 else if (codec_id == ofmt->video_codec ||
4876 codec_id == ofmt->audio_codec ||
4877 codec_id == ofmt->subtitle_codec ||
4878 codec_id == ofmt->data_codec)
4881 return AVERROR_PATCHWELCOME;
4884 int avformat_network_init(void)
4888 ff_network_inited_globally = 1;
4889 if ((ret = ff_network_init()) < 0)
4891 if ((ret = ff_tls_init()) < 0)
4897 int avformat_network_deinit(void)
4902 ff_network_inited_globally = 0;
4907 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4908 uint64_t channel_layout, int32_t sample_rate,
4909 int32_t width, int32_t height)
4915 return AVERROR(EINVAL);
4918 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4920 if (channel_layout) {
4922 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4926 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4928 if (width || height) {
4930 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4932 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4934 return AVERROR(ENOMEM);
4935 bytestream_put_le32(&data, flags);
4937 bytestream_put_le32(&data, channels);
4939 bytestream_put_le64(&data, channel_layout);
4941 bytestream_put_le32(&data, sample_rate);
4942 if (width || height) {
4943 bytestream_put_le32(&data, width);
4944 bytestream_put_le32(&data, height);
4949 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4951 AVRational undef = {0, 1};
4952 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4953 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4954 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4956 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4957 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4958 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4959 stream_sample_aspect_ratio = undef;
4961 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4962 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4963 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4964 frame_sample_aspect_ratio = undef;
4966 if (stream_sample_aspect_ratio.num)
4967 return stream_sample_aspect_ratio;
4969 return frame_sample_aspect_ratio;
4972 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4974 AVRational fr = st->r_frame_rate;
4975 AVRational codec_fr = st->internal->avctx->framerate;
4976 AVRational avg_fr = st->avg_frame_rate;
4978 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4979 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4984 if (st->internal->avctx->ticks_per_frame > 1) {
4985 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4986 (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))
4993 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4996 if (*spec <= '9' && *spec >= '0') /* opt:index */
4997 return strtol(spec, NULL, 0) == st->index;
4998 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4999 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5000 enum AVMediaType type;
5004 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5005 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5006 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5007 case 'd': type = AVMEDIA_TYPE_DATA; break;
5008 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5009 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5010 default: av_assert0(0);
5012 #if FF_API_LAVF_AVCTX
5013 FF_DISABLE_DEPRECATION_WARNINGS
5014 if (type != st->codecpar->codec_type
5015 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5017 FF_ENABLE_DEPRECATION_WARNINGS
5019 if (type != st->codecpar->codec_type)
5022 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5024 if (*spec++ == ':') { /* possibly followed by :index */
5025 int i, index = strtol(spec, NULL, 0);
5026 for (i = 0; i < s->nb_streams; i++) {
5027 #if FF_API_LAVF_AVCTX
5028 FF_DISABLE_DEPRECATION_WARNINGS
5029 if ((s->streams[i]->codecpar->codec_type == type
5030 || s->streams[i]->codec->codec_type == type
5032 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5034 return i == st->index;
5035 FF_ENABLE_DEPRECATION_WARNINGS
5037 if ((s->streams[i]->codecpar->codec_type == type) &&
5038 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5040 return i == st->index;
5046 } else if (*spec == 'p' && *(spec + 1) == ':') {
5050 prog_id = strtol(spec, &endptr, 0);
5051 for (i = 0; i < s->nb_programs; i++) {
5052 if (s->programs[i]->id != prog_id)
5055 if (*endptr++ == ':') {
5056 int stream_idx = strtol(endptr, NULL, 0);
5057 return stream_idx >= 0 &&
5058 stream_idx < s->programs[i]->nb_stream_indexes &&
5059 st->index == s->programs[i]->stream_index[stream_idx];
5062 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5063 if (st->index == s->programs[i]->stream_index[j])
5067 } else if (*spec == '#' ||
5068 (*spec == 'i' && *(spec + 1) == ':')) {
5071 spec += 1 + (*spec == 'i');
5072 stream_id = strtol(spec, &endptr, 0);
5074 return stream_id == st->id;
5075 } else if (*spec == 'm' && *(spec + 1) == ':') {
5076 AVDictionaryEntry *tag;
5081 val = strchr(spec, ':');
5083 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5085 return AVERROR(ENOMEM);
5087 tag = av_dict_get(st->metadata, key, NULL, 0);
5089 if (!val || !strcmp(tag->value, val + 1))
5098 } else if (*spec == 'u') {
5099 AVCodecParameters *par = st->codecpar;
5100 #if FF_API_LAVF_AVCTX
5101 FF_DISABLE_DEPRECATION_WARNINGS
5102 AVCodecContext *codec = st->codec;
5103 FF_ENABLE_DEPRECATION_WARNINGS
5106 switch (par->codec_type) {
5107 case AVMEDIA_TYPE_AUDIO:
5108 val = par->sample_rate && par->channels;
5109 #if FF_API_LAVF_AVCTX
5110 val = val || (codec->sample_rate && codec->channels);
5112 if (par->format == AV_SAMPLE_FMT_NONE
5113 #if FF_API_LAVF_AVCTX
5114 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5119 case AVMEDIA_TYPE_VIDEO:
5120 val = par->width && par->height;
5121 #if FF_API_LAVF_AVCTX
5122 val = val || (codec->width && codec->height);
5124 if (par->format == AV_PIX_FMT_NONE
5125 #if FF_API_LAVF_AVCTX
5126 && codec->pix_fmt == AV_PIX_FMT_NONE
5131 case AVMEDIA_TYPE_UNKNOWN:
5138 #if FF_API_LAVF_AVCTX
5139 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5141 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5143 } else if (!*spec) /* empty specifier, matches everything */
5146 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5147 return AVERROR(EINVAL);
5150 int ff_generate_avci_extradata(AVStream *st)
5152 static const uint8_t avci100_1080p_extradata[] = {
5154 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5155 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5156 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5157 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5158 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5159 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5160 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5161 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5162 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5164 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5167 static const uint8_t avci100_1080i_extradata[] = {
5169 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5170 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5171 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5172 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5173 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5174 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5175 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5176 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5177 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5178 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5179 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5181 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5184 static const uint8_t avci50_1080p_extradata[] = {
5186 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5187 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5188 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5189 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5190 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5191 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5192 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5193 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5194 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5196 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5199 static const uint8_t avci50_1080i_extradata[] = {
5201 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5202 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5203 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5204 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5205 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5206 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5207 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5208 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5209 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5210 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5211 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5213 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5216 static const uint8_t avci100_720p_extradata[] = {
5218 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5219 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5220 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5221 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5222 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5223 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5224 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5225 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5226 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5227 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5229 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5232 static const uint8_t avci50_720p_extradata[] = {
5234 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5235 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5236 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5237 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5238 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5239 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5240 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5241 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5242 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5244 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5248 const uint8_t *data = NULL;
5251 if (st->codecpar->width == 1920) {
5252 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5253 data = avci100_1080p_extradata;
5254 size = sizeof(avci100_1080p_extradata);
5256 data = avci100_1080i_extradata;
5257 size = sizeof(avci100_1080i_extradata);
5259 } else if (st->codecpar->width == 1440) {
5260 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5261 data = avci50_1080p_extradata;
5262 size = sizeof(avci50_1080p_extradata);
5264 data = avci50_1080i_extradata;
5265 size = sizeof(avci50_1080i_extradata);
5267 } else if (st->codecpar->width == 1280) {
5268 data = avci100_720p_extradata;
5269 size = sizeof(avci100_720p_extradata);
5270 } else if (st->codecpar->width == 960) {
5271 data = avci50_720p_extradata;
5272 size = sizeof(avci50_720p_extradata);
5278 av_freep(&st->codecpar->extradata);
5279 if (ff_alloc_extradata(st->codecpar, size))
5280 return AVERROR(ENOMEM);
5281 memcpy(st->codecpar->extradata, data, size);
5286 uint8_t *av_stream_get_side_data(const AVStream *st,
5287 enum AVPacketSideDataType type, int *size)
5291 for (i = 0; i < st->nb_side_data; i++) {
5292 if (st->side_data[i].type == type) {
5294 *size = st->side_data[i].size;
5295 return st->side_data[i].data;
5301 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5302 uint8_t *data, size_t size)
5304 AVPacketSideData *sd, *tmp;
5307 for (i = 0; i < st->nb_side_data; i++) {
5308 sd = &st->side_data[i];
5310 if (sd->type == type) {
5311 av_freep(&sd->data);
5318 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5319 return AVERROR(ERANGE);
5321 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5323 return AVERROR(ENOMEM);
5326 st->side_data = tmp;
5329 sd = &st->side_data[st->nb_side_data - 1];
5337 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5341 uint8_t *data = av_malloc(size);
5346 ret = av_stream_add_side_data(st, type, data, size);
5355 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5358 const AVBitStreamFilter *bsf;
5360 AVCodecParameters *in_par;
5362 if (!(bsf = av_bsf_get_by_name(name))) {
5363 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5364 return AVERROR_BSF_NOT_FOUND;
5367 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5370 if (st->internal->nb_bsfcs) {
5371 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5372 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5374 in_par = st->codecpar;
5375 bsfc->time_base_in = st->time_base;
5378 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5383 if (args && bsfc->filter->priv_class) {
5384 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5385 const char * shorthand[2] = {NULL};
5388 shorthand[0] = opt->name;
5390 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5396 if ((ret = av_bsf_init(bsfc)) < 0) {
5401 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5406 av_log(NULL, AV_LOG_VERBOSE,
5407 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5408 name, args ? args : "");
5413 FF_DISABLE_DEPRECATION_WARNINGS
5414 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5415 AVBitStreamFilterContext *bsfc)
5419 AVPacket new_pkt = *pkt;
5420 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5421 &new_pkt.data, &new_pkt.size,
5422 pkt->data, pkt->size,
5423 pkt->flags & AV_PKT_FLAG_KEY);
5424 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5425 av_packet_unref(pkt);
5426 memset(pkt, 0, sizeof(*pkt));
5429 if(a == 0 && new_pkt.data != pkt->data) {
5430 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5432 memcpy(t, new_pkt.data, new_pkt.size);
5433 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5438 a = AVERROR(ENOMEM);
5442 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5443 av_buffer_default_free, NULL, 0);
5445 pkt->side_data = NULL;
5446 pkt->side_data_elems = 0;
5447 av_packet_unref(pkt);
5449 av_freep(&new_pkt.data);
5450 a = AVERROR(ENOMEM);
5454 av_log(codec, AV_LOG_ERROR,
5455 "Failed to open bitstream filter %s for stream %d with codec %s",
5456 bsfc->filter->name, pkt->stream_index,
5457 codec->codec ? codec->codec->name : "copy");
5467 FF_ENABLE_DEPRECATION_WARNINGS
5470 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5473 return AVERROR(EINVAL);
5475 if (!(s->oformat->flags & AVFMT_NOFILE))
5476 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5480 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5483 s->io_close(s, *pb);
5487 int ff_is_http_proto(char *filename) {
5488 const char *proto = avio_find_protocol_name(filename);
5489 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5492 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5494 AVDictionaryEntry *entry;
5495 int64_t parsed_timestamp;
5497 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5498 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5499 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5502 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5509 int ff_standardize_creation_time(AVFormatContext *s)
5512 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5514 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5518 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5523 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5525 if (size != AVPALETTE_SIZE) {
5526 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5527 return AVERROR_INVALIDDATA;
5529 memcpy(palette, side_data, AVPALETTE_SIZE);
5533 if (ret == CONTAINS_PAL) {
5535 for (i = 0; i < AVPALETTE_COUNT; i++)
5536 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5543 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5548 ret = av_bprint_finalize(buf, &str);
5551 if (!av_bprint_is_complete(buf)) {
5553 return AVERROR(ENOMEM);
5556 par->extradata = str;
5557 /* Note: the string is NUL terminated (so extradata can be read as a
5558 * string), but the ending character is not accounted in the size (in
5559 * binary formats you are likely not supposed to mux that character). When
5560 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5562 par->extradata_size = buf->len;
5566 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5567 AVStream *ost, const AVStream *ist,
5568 enum AVTimebaseSource copy_tb)
5570 //TODO: use [io]st->internal->avctx
5571 const AVCodecContext *dec_ctx = ist->codec;
5572 AVCodecContext *enc_ctx = ost->codec;
5574 enc_ctx->time_base = ist->time_base;
5576 * Avi is a special case here because it supports variable fps but
5577 * having the fps and timebase differe significantly adds quite some
5580 if (!strcmp(ofmt->name, "avi")) {
5581 #if FF_API_R_FRAME_RATE
5582 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5583 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5584 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5585 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5586 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5587 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5588 enc_ctx->time_base.num = ist->r_frame_rate.den;
5589 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5590 enc_ctx->ticks_per_frame = 2;
5593 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5594 && av_q2d(ist->time_base) < 1.0/500
5595 || copy_tb == AVFMT_TBCF_DECODER) {
5596 enc_ctx->time_base = dec_ctx->time_base;
5597 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5598 enc_ctx->time_base.den *= 2;
5599 enc_ctx->ticks_per_frame = 2;
5601 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5602 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5603 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5604 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5605 && av_q2d(ist->time_base) < 1.0/500
5606 || copy_tb == AVFMT_TBCF_DECODER) {
5607 enc_ctx->time_base = dec_ctx->time_base;
5608 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5612 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5613 && dec_ctx->time_base.num < dec_ctx->time_base.den
5614 && dec_ctx->time_base.num > 0
5615 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5616 enc_ctx->time_base = dec_ctx->time_base;
5619 if (ost->avg_frame_rate.num)
5620 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5622 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5623 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5628 AVRational av_stream_get_codec_timebase(const AVStream *st)
5630 // See avformat_transfer_internal_stream_timing_info() TODO.
5631 #if FF_API_LAVF_AVCTX
5632 FF_DISABLE_DEPRECATION_WARNINGS
5633 return st->codec->time_base;
5634 FF_ENABLE_DEPRECATION_WARNINGS
5636 return st->internal->avctx->time_base;