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 if (!(s->url = av_strdup(filename ? filename : ""))) {
559 ret = AVERROR(ENOMEM);
563 #if FF_API_FORMAT_FILENAME
564 FF_DISABLE_DEPRECATION_WARNINGS
565 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
566 FF_ENABLE_DEPRECATION_WARNINGS
568 if ((ret = init_input(s, filename, &tmp)) < 0)
570 s->probe_score = ret;
572 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
573 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
574 if (!s->protocol_whitelist) {
575 ret = AVERROR(ENOMEM);
580 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
581 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
582 if (!s->protocol_blacklist) {
583 ret = AVERROR(ENOMEM);
588 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
589 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
590 ret = AVERROR(EINVAL);
594 avio_skip(s->pb, s->skip_initial_bytes);
596 /* Check filename in case an image number is expected. */
597 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
598 if (!av_filename_number_test(filename)) {
599 ret = AVERROR(EINVAL);
604 s->duration = s->start_time = AV_NOPTS_VALUE;
606 /* Allocate private data. */
607 if (s->iformat->priv_data_size > 0) {
608 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
609 ret = AVERROR(ENOMEM);
612 if (s->iformat->priv_class) {
613 *(const AVClass **) s->priv_data = s->iformat->priv_class;
614 av_opt_set_defaults(s->priv_data);
615 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
620 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
622 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
625 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
626 if ((ret = s->iformat->read_header(s)) < 0)
630 s->metadata = s->internal->id3v2_meta;
631 s->internal->id3v2_meta = NULL;
632 } else if (s->internal->id3v2_meta) {
633 int level = AV_LOG_WARNING;
634 if (s->error_recognition & AV_EF_COMPLIANT)
635 level = AV_LOG_ERROR;
636 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
637 av_dict_free(&s->internal->id3v2_meta);
638 if (s->error_recognition & AV_EF_EXPLODE)
639 return AVERROR_INVALIDDATA;
642 if (id3v2_extra_meta) {
643 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
644 !strcmp(s->iformat->name, "tta")) {
645 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
647 if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
649 if ((ret = ff_id3v2_parse_priv(s, &id3v2_extra_meta)) < 0)
652 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
654 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
656 if ((ret = avformat_queue_attached_pictures(s)) < 0)
659 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
660 s->internal->data_offset = avio_tell(s->pb);
662 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
664 update_stream_avctx(s);
666 for (i = 0; i < s->nb_streams; i++)
667 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
670 av_dict_free(options);
677 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
679 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
681 avformat_free_context(s);
686 /*******************************************************/
688 static void force_codec_ids(AVFormatContext *s, AVStream *st)
690 switch (st->codecpar->codec_type) {
691 case AVMEDIA_TYPE_VIDEO:
692 if (s->video_codec_id)
693 st->codecpar->codec_id = s->video_codec_id;
695 case AVMEDIA_TYPE_AUDIO:
696 if (s->audio_codec_id)
697 st->codecpar->codec_id = s->audio_codec_id;
699 case AVMEDIA_TYPE_SUBTITLE:
700 if (s->subtitle_codec_id)
701 st->codecpar->codec_id = s->subtitle_codec_id;
703 case AVMEDIA_TYPE_DATA:
704 if (s->data_codec_id)
705 st->codecpar->codec_id = s->data_codec_id;
710 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
712 if (st->request_probe>0) {
713 AVProbeData *pd = &st->probe_data;
715 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
719 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
721 av_log(s, AV_LOG_WARNING,
722 "Failed to reallocate probe buffer for stream %d\n",
727 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
728 pd->buf_size += pkt->size;
729 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
732 st->probe_packets = 0;
734 av_log(s, AV_LOG_WARNING,
735 "nothing to probe for stream %d\n", st->index);
739 end= s->internal->raw_packet_buffer_remaining_size <= 0
740 || st->probe_packets<= 0;
742 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
743 int score = set_codec_from_probe_data(s, st, pd);
744 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
748 st->request_probe = -1;
749 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
750 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
752 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
754 force_codec_ids(s, st);
760 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
762 int64_t ref = pkt->dts;
763 int i, pts_wrap_behavior;
764 int64_t pts_wrap_reference;
765 AVProgram *first_program;
767 if (ref == AV_NOPTS_VALUE)
769 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
771 ref &= (1LL << st->pts_wrap_bits)-1;
773 // reference time stamp should be 60 s before first time stamp
774 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
775 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
776 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
777 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
778 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
780 first_program = av_find_program_from_stream(s, NULL, stream_index);
782 if (!first_program) {
783 int default_stream_index = av_find_default_stream_index(s);
784 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
785 for (i = 0; i < s->nb_streams; i++) {
786 if (av_find_program_from_stream(s, NULL, i))
788 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
789 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
793 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
794 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
798 AVProgram *program = first_program;
800 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
801 pts_wrap_reference = program->pts_wrap_reference;
802 pts_wrap_behavior = program->pts_wrap_behavior;
805 program = av_find_program_from_stream(s, program, stream_index);
808 // update every program with differing pts_wrap_reference
809 program = first_program;
811 if (program->pts_wrap_reference != pts_wrap_reference) {
812 for (i = 0; i<program->nb_stream_indexes; i++) {
813 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
814 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
817 program->pts_wrap_reference = pts_wrap_reference;
818 program->pts_wrap_behavior = pts_wrap_behavior;
820 program = av_find_program_from_stream(s, program, stream_index);
826 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
832 AVPacketList *pktl = s->internal->raw_packet_buffer;
836 st = s->streams[pkt->stream_index];
837 if (s->internal->raw_packet_buffer_remaining_size <= 0)
838 if ((err = probe_codec(s, st, NULL)) < 0)
840 if (st->request_probe <= 0) {
841 s->internal->raw_packet_buffer = pktl->next;
842 s->internal->raw_packet_buffer_remaining_size += pkt->size;
851 ret = s->iformat->read_packet(s, pkt);
853 /* Some demuxers return FFERROR_REDO when they consume
854 data and discard it (ignored streams, junk, extradata).
855 We must re-call the demuxer to get the real packet. */
856 if (ret == FFERROR_REDO)
858 if (!pktl || ret == AVERROR(EAGAIN))
860 for (i = 0; i < s->nb_streams; i++) {
862 if (st->probe_packets || st->request_probe > 0)
863 if ((err = probe_codec(s, st, NULL)) < 0)
865 av_assert0(st->request_probe <= 0);
871 AVPacket tmp = { 0 };
872 ret = av_packet_ref(&tmp, pkt);
878 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
879 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
880 av_log(s, AV_LOG_WARNING,
881 "Dropped corrupted packet (stream = %d)\n",
883 av_packet_unref(pkt);
887 if (pkt->stream_index >= (unsigned)s->nb_streams) {
888 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
892 st = s->streams[pkt->stream_index];
894 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
895 // correct first time stamps to negative values
896 if (!is_relative(st->first_dts))
897 st->first_dts = wrap_timestamp(st, st->first_dts);
898 if (!is_relative(st->start_time))
899 st->start_time = wrap_timestamp(st, st->start_time);
900 if (!is_relative(st->cur_dts))
901 st->cur_dts = wrap_timestamp(st, st->cur_dts);
904 pkt->dts = wrap_timestamp(st, pkt->dts);
905 pkt->pts = wrap_timestamp(st, pkt->pts);
907 force_codec_ids(s, st);
909 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
910 if (s->use_wallclock_as_timestamps)
911 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
913 if (!pktl && st->request_probe <= 0)
916 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
917 &s->internal->raw_packet_buffer_end, 0);
920 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
922 if ((err = probe_codec(s, st, pkt)) < 0)
928 /**********************************************************/
930 static int determinable_frame_size(AVCodecContext *avctx)
932 switch(avctx->codec_id) {
933 case AV_CODEC_ID_MP1:
934 case AV_CODEC_ID_MP2:
935 case AV_CODEC_ID_MP3:
943 * Return the frame duration in seconds. Return 0 if not available.
945 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
946 AVCodecParserContext *pc, AVPacket *pkt)
948 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
949 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
950 int frame_size, sample_rate;
952 #if FF_API_LAVF_AVCTX
953 FF_DISABLE_DEPRECATION_WARNINGS
954 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
955 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
956 FF_ENABLE_DEPRECATION_WARNINGS
961 switch (st->codecpar->codec_type) {
962 case AVMEDIA_TYPE_VIDEO:
963 if (st->r_frame_rate.num && !pc && s->iformat) {
964 *pnum = st->r_frame_rate.den;
965 *pden = st->r_frame_rate.num;
966 } else if (st->time_base.num * 1000LL > st->time_base.den) {
967 *pnum = st->time_base.num;
968 *pden = st->time_base.den;
969 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
970 av_assert0(st->internal->avctx->ticks_per_frame);
971 av_reduce(pnum, pden,
973 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
976 if (pc && pc->repeat_pict) {
977 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
978 av_reduce(pnum, pden,
979 (*pnum) * (1LL + pc->repeat_pict),
983 /* If this codec can be interlaced or progressive then we need
984 * a parser to compute duration of a packet. Thus if we have
985 * no parser in such case leave duration undefined. */
986 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
990 case AVMEDIA_TYPE_AUDIO:
991 if (st->internal->avctx_inited) {
992 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
993 sample_rate = st->internal->avctx->sample_rate;
995 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
996 sample_rate = st->codecpar->sample_rate;
998 if (frame_size <= 0 || sample_rate <= 0)
1001 *pden = sample_rate;
1008 static int is_intra_only(enum AVCodecID id)
1010 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1013 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1018 static int has_decode_delay_been_guessed(AVStream *st)
1020 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1021 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1023 #if CONFIG_H264_DECODER
1024 if (st->internal->avctx->has_b_frames &&
1025 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1028 if (st->internal->avctx->has_b_frames<3)
1029 return st->nb_decoded_frames >= 7;
1030 else if (st->internal->avctx->has_b_frames<4)
1031 return st->nb_decoded_frames >= 18;
1033 return st->nb_decoded_frames >= 20;
1036 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1040 if (pktl == s->internal->packet_buffer_end)
1041 return s->internal->parse_queue;
1045 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1046 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1047 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1050 int delay = st->internal->avctx->has_b_frames;
1053 if (dts == AV_NOPTS_VALUE) {
1054 int64_t best_score = INT64_MAX;
1055 for (i = 0; i<delay; i++) {
1056 if (st->pts_reorder_error_count[i]) {
1057 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1058 if (score < best_score) {
1060 dts = pts_buffer[i];
1065 for (i = 0; i<delay; i++) {
1066 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1067 int64_t diff = FFABS(pts_buffer[i] - dts)
1068 + (uint64_t)st->pts_reorder_error[i];
1069 diff = FFMAX(diff, st->pts_reorder_error[i]);
1070 st->pts_reorder_error[i] = diff;
1071 st->pts_reorder_error_count[i]++;
1072 if (st->pts_reorder_error_count[i] > 250) {
1073 st->pts_reorder_error[i] >>= 1;
1074 st->pts_reorder_error_count[i] >>= 1;
1081 if (dts == AV_NOPTS_VALUE)
1082 dts = pts_buffer[0];
1088 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1089 * of the packets in a window.
1091 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1092 AVPacketList *pkt_buffer)
1094 AVStream *st = s->streams[stream_index];
1095 int delay = st->internal->avctx->has_b_frames;
1098 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1100 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1101 pts_buffer[i] = AV_NOPTS_VALUE;
1103 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1104 if (pkt_buffer->pkt.stream_index != stream_index)
1107 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1108 pts_buffer[0] = pkt_buffer->pkt.pts;
1109 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1110 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1112 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1117 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1118 int64_t dts, int64_t pts, AVPacket *pkt)
1120 AVStream *st = s->streams[stream_index];
1121 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1122 AVPacketList *pktl_it;
1126 if (st->first_dts != AV_NOPTS_VALUE ||
1127 dts == AV_NOPTS_VALUE ||
1128 st->cur_dts == AV_NOPTS_VALUE ||
1132 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1134 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1136 if (is_relative(pts))
1139 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1140 if (pktl_it->pkt.stream_index != stream_index)
1142 if (is_relative(pktl_it->pkt.pts))
1143 pktl_it->pkt.pts += shift;
1145 if (is_relative(pktl_it->pkt.dts))
1146 pktl_it->pkt.dts += shift;
1148 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1149 st->start_time = pktl_it->pkt.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 if (has_decode_delay_been_guessed(st)) {
1156 update_dts_from_pts(s, stream_index, pktl);
1159 if (st->start_time == AV_NOPTS_VALUE) {
1160 st->start_time = pts;
1161 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1162 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1166 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1167 int stream_index, int duration)
1169 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1170 int64_t cur_dts = RELATIVE_TS_BASE;
1172 if (st->first_dts != AV_NOPTS_VALUE) {
1173 if (st->update_initial_durations_done)
1175 st->update_initial_durations_done = 1;
1176 cur_dts = st->first_dts;
1177 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1178 if (pktl->pkt.stream_index == stream_index) {
1179 if (pktl->pkt.pts != pktl->pkt.dts ||
1180 pktl->pkt.dts != AV_NOPTS_VALUE ||
1183 cur_dts -= duration;
1186 if (pktl && pktl->pkt.dts != st->first_dts) {
1187 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1188 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1192 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1195 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1196 st->first_dts = cur_dts;
1197 } else if (st->cur_dts != RELATIVE_TS_BASE)
1200 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1201 if (pktl->pkt.stream_index != stream_index)
1203 if ((pktl->pkt.pts == pktl->pkt.dts ||
1204 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1205 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1206 pktl->pkt.dts == st->first_dts ||
1207 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1208 !pktl->pkt.duration) {
1209 pktl->pkt.dts = cur_dts;
1210 if (!st->internal->avctx->has_b_frames)
1211 pktl->pkt.pts = cur_dts;
1212 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1213 pktl->pkt.duration = duration;
1216 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1219 st->cur_dts = cur_dts;
1222 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1223 AVCodecParserContext *pc, AVPacket *pkt,
1224 int64_t next_dts, int64_t next_pts)
1226 int num, den, presentation_delayed, delay, i;
1228 AVRational duration;
1229 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1230 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1232 if (s->flags & AVFMT_FLAG_NOFILLIN)
1235 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1236 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1237 if (st->last_dts_for_order_check <= pkt->dts) {
1240 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1241 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1243 st->last_dts_for_order_check);
1244 st->dts_misordered++;
1246 if (st->dts_ordered + st->dts_misordered > 250) {
1247 st->dts_ordered >>= 1;
1248 st->dts_misordered >>= 1;
1252 st->last_dts_for_order_check = pkt->dts;
1253 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1254 pkt->dts = AV_NOPTS_VALUE;
1257 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1258 pkt->dts = AV_NOPTS_VALUE;
1260 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1261 && !st->internal->avctx->has_b_frames)
1262 //FIXME Set low_delay = 0 when has_b_frames = 1
1263 st->internal->avctx->has_b_frames = 1;
1265 /* do we have a video B-frame ? */
1266 delay = st->internal->avctx->has_b_frames;
1267 presentation_delayed = 0;
1269 /* XXX: need has_b_frame, but cannot get it if the codec is
1270 * not initialized */
1272 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1273 presentation_delayed = 1;
1275 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1276 st->pts_wrap_bits < 63 &&
1277 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1278 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1279 pkt->dts -= 1LL << st->pts_wrap_bits;
1281 pkt->pts += 1LL << st->pts_wrap_bits;
1284 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1285 * We take the conservative approach and discard both.
1286 * Note: If this is misbehaving for an H.264 file, then possibly
1287 * presentation_delayed is not set correctly. */
1288 if (delay == 1 && pkt->dts == pkt->pts &&
1289 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1290 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1291 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1292 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1293 pkt->dts = AV_NOPTS_VALUE;
1296 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1297 if (pkt->duration == 0) {
1298 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1300 duration = (AVRational) {num, den};
1301 pkt->duration = av_rescale_rnd(1,
1302 num * (int64_t) st->time_base.den,
1303 den * (int64_t) st->time_base.num,
1308 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1309 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1311 /* Correct timestamps with byte offset if demuxers only have timestamps
1312 * on packet boundaries */
1313 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1314 /* this will estimate bitrate based on this frame's duration and size */
1315 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1316 if (pkt->pts != AV_NOPTS_VALUE)
1318 if (pkt->dts != AV_NOPTS_VALUE)
1322 /* This may be redundant, but it should not hurt. */
1323 if (pkt->dts != AV_NOPTS_VALUE &&
1324 pkt->pts != AV_NOPTS_VALUE &&
1325 pkt->pts > pkt->dts)
1326 presentation_delayed = 1;
1328 if (s->debug & FF_FDEBUG_TS)
1329 av_log(s, AV_LOG_TRACE,
1330 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1331 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1332 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1334 /* Interpolate PTS and DTS if they are not present. We skip H264
1335 * currently because delay and has_b_frames are not reliably set. */
1336 if ((delay == 0 || (delay == 1 && pc)) &&
1338 if (presentation_delayed) {
1339 /* DTS = decompression timestamp */
1340 /* PTS = presentation timestamp */
1341 if (pkt->dts == AV_NOPTS_VALUE)
1342 pkt->dts = st->last_IP_pts;
1343 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1344 if (pkt->dts == AV_NOPTS_VALUE)
1345 pkt->dts = st->cur_dts;
1347 /* This is tricky: the dts must be incremented by the duration
1348 * of the frame we are displaying, i.e. the last I- or P-frame. */
1349 if (st->last_IP_duration == 0)
1350 st->last_IP_duration = pkt->duration;
1351 if (pkt->dts != AV_NOPTS_VALUE)
1352 st->cur_dts = pkt->dts + st->last_IP_duration;
1353 if (pkt->dts != AV_NOPTS_VALUE &&
1354 pkt->pts == AV_NOPTS_VALUE &&
1355 st->last_IP_duration > 0 &&
1356 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1357 next_dts != next_pts &&
1358 next_pts != AV_NOPTS_VALUE)
1359 pkt->pts = next_dts;
1361 st->last_IP_duration = pkt->duration;
1362 st->last_IP_pts = pkt->pts;
1363 /* Cannot compute PTS if not present (we can compute it only
1364 * by knowing the future. */
1365 } else if (pkt->pts != AV_NOPTS_VALUE ||
1366 pkt->dts != AV_NOPTS_VALUE ||
1369 /* presentation is not delayed : PTS and DTS are the same */
1370 if (pkt->pts == AV_NOPTS_VALUE)
1371 pkt->pts = pkt->dts;
1372 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1374 if (pkt->pts == AV_NOPTS_VALUE)
1375 pkt->pts = st->cur_dts;
1376 pkt->dts = pkt->pts;
1377 if (pkt->pts != AV_NOPTS_VALUE)
1378 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1382 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1383 st->pts_buffer[0] = pkt->pts;
1384 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1385 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1387 if(has_decode_delay_been_guessed(st))
1388 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1390 // We skipped it above so we try here.
1392 // This should happen on the first packet
1393 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1394 if (pkt->dts > st->cur_dts)
1395 st->cur_dts = pkt->dts;
1397 if (s->debug & FF_FDEBUG_TS)
1398 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1399 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1402 if (is_intra_only(st->codecpar->codec_id))
1403 pkt->flags |= AV_PKT_FLAG_KEY;
1404 #if FF_API_CONVERGENCE_DURATION
1405 FF_DISABLE_DEPRECATION_WARNINGS
1407 pkt->convergence_duration = pc->convergence_duration;
1408 FF_ENABLE_DEPRECATION_WARNINGS
1412 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1415 AVPacketList *pktl = *pkt_buf;
1416 *pkt_buf = pktl->next;
1417 av_packet_unref(&pktl->pkt);
1420 *pkt_buf_end = NULL;
1424 * Parse a packet, add all split parts to parse_queue.
1426 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1428 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1430 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1431 AVStream *st = s->streams[stream_index];
1432 uint8_t *data = pkt ? pkt->data : NULL;
1433 int size = pkt ? pkt->size : 0;
1434 int ret = 0, got_output = 0;
1437 av_init_packet(&flush_pkt);
1440 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1441 // preserve 0-size sync packets
1442 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1445 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1447 int64_t next_pts = pkt->pts;
1448 int64_t next_dts = pkt->dts;
1450 av_init_packet(&out_pkt);
1451 len = av_parser_parse2(st->parser, st->internal->avctx,
1452 &out_pkt.data, &out_pkt.size, data, size,
1453 pkt->pts, pkt->dts, pkt->pos);
1455 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1457 /* increment read pointer */
1461 got_output = !!out_pkt.size;
1466 if (pkt->side_data) {
1467 out_pkt.side_data = pkt->side_data;
1468 out_pkt.side_data_elems = pkt->side_data_elems;
1469 pkt->side_data = NULL;
1470 pkt->side_data_elems = 0;
1473 /* set the duration */
1474 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1475 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1476 if (st->internal->avctx->sample_rate > 0) {
1478 av_rescale_q_rnd(st->parser->duration,
1479 (AVRational) { 1, st->internal->avctx->sample_rate },
1485 out_pkt.stream_index = st->index;
1486 out_pkt.pts = st->parser->pts;
1487 out_pkt.dts = st->parser->dts;
1488 out_pkt.pos = st->parser->pos;
1489 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1491 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1492 out_pkt.pos = st->parser->frame_offset;
1494 if (st->parser->key_frame == 1 ||
1495 (st->parser->key_frame == -1 &&
1496 st->parser->pict_type == AV_PICTURE_TYPE_I))
1497 out_pkt.flags |= AV_PKT_FLAG_KEY;
1499 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1500 out_pkt.flags |= AV_PKT_FLAG_KEY;
1502 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1504 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1505 &s->internal->parse_queue_end, 1);
1506 av_packet_unref(&out_pkt);
1511 /* end of the stream => close and free the parser */
1512 if (pkt == &flush_pkt) {
1513 av_parser_close(st->parser);
1518 av_packet_unref(pkt);
1522 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1523 AVPacketList **pkt_buffer_end,
1527 av_assert0(*pkt_buffer);
1530 *pkt_buffer = pktl->next;
1532 *pkt_buffer_end = NULL;
1537 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1539 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1542 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1544 int ret = 0, i, got_packet = 0;
1545 AVDictionary *metadata = NULL;
1547 av_init_packet(pkt);
1549 while (!got_packet && !s->internal->parse_queue) {
1553 /* read next packet */
1554 ret = ff_read_packet(s, &cur_pkt);
1556 if (ret == AVERROR(EAGAIN))
1558 /* flush the parsers */
1559 for (i = 0; i < s->nb_streams; i++) {
1561 if (st->parser && st->need_parsing)
1562 parse_packet(s, NULL, st->index);
1564 /* all remaining packets are now in parse_queue =>
1565 * really terminate parsing */
1569 st = s->streams[cur_pkt.stream_index];
1571 /* update context if required */
1572 if (st->internal->need_context_update) {
1573 if (avcodec_is_open(st->internal->avctx)) {
1574 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1575 avcodec_close(st->internal->avctx);
1576 st->info->found_decoder = 0;
1579 /* close parser, because it depends on the codec */
1580 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1581 av_parser_close(st->parser);
1585 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1589 #if FF_API_LAVF_AVCTX
1590 FF_DISABLE_DEPRECATION_WARNINGS
1591 /* update deprecated public codec context */
1592 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1595 FF_ENABLE_DEPRECATION_WARNINGS
1598 st->internal->need_context_update = 0;
1601 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1602 cur_pkt.dts != AV_NOPTS_VALUE &&
1603 cur_pkt.pts < cur_pkt.dts) {
1604 av_log(s, AV_LOG_WARNING,
1605 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1606 cur_pkt.stream_index,
1607 av_ts2str(cur_pkt.pts),
1608 av_ts2str(cur_pkt.dts),
1611 if (s->debug & FF_FDEBUG_TS)
1612 av_log(s, AV_LOG_DEBUG,
1613 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1614 cur_pkt.stream_index,
1615 av_ts2str(cur_pkt.pts),
1616 av_ts2str(cur_pkt.dts),
1617 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1619 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1620 st->parser = av_parser_init(st->codecpar->codec_id);
1622 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1623 "%s, packets or times may be invalid.\n",
1624 avcodec_get_name(st->codecpar->codec_id));
1625 /* no parser available: just output the raw packets */
1626 st->need_parsing = AVSTREAM_PARSE_NONE;
1627 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1628 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1629 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1630 st->parser->flags |= PARSER_FLAG_ONCE;
1631 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1632 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1635 if (!st->need_parsing || !st->parser) {
1636 /* no parsing needed: we just output the packet as is */
1638 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1639 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1640 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1641 ff_reduce_index(s, st->index);
1642 av_add_index_entry(st, pkt->pos, pkt->dts,
1643 0, 0, AVINDEX_KEYFRAME);
1646 } else if (st->discard < AVDISCARD_ALL) {
1647 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1649 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1650 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1651 st->codecpar->channels = st->internal->avctx->channels;
1652 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1653 st->codecpar->codec_id = st->internal->avctx->codec_id;
1656 av_packet_unref(&cur_pkt);
1658 if (pkt->flags & AV_PKT_FLAG_KEY)
1659 st->skip_to_keyframe = 0;
1660 if (st->skip_to_keyframe) {
1661 av_packet_unref(&cur_pkt);
1669 if (!got_packet && s->internal->parse_queue)
1670 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1673 AVStream *st = s->streams[pkt->stream_index];
1674 int discard_padding = 0;
1675 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1676 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1677 int64_t sample = ts_to_samples(st, pts);
1678 int duration = ts_to_samples(st, pkt->duration);
1679 int64_t end_sample = sample + duration;
1680 if (duration > 0 && end_sample >= st->first_discard_sample &&
1681 sample < st->last_discard_sample)
1682 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1684 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1685 st->skip_samples = st->start_skip_samples;
1686 if (st->skip_samples || discard_padding) {
1687 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1689 AV_WL32(p, st->skip_samples);
1690 AV_WL32(p + 4, discard_padding);
1691 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1693 st->skip_samples = 0;
1696 if (st->inject_global_side_data) {
1697 for (i = 0; i < st->nb_side_data; i++) {
1698 AVPacketSideData *src_sd = &st->side_data[i];
1701 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1704 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1706 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1710 memcpy(dst_data, src_sd->data, src_sd->size);
1712 st->inject_global_side_data = 0;
1716 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1718 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1719 av_dict_copy(&s->metadata, metadata, 0);
1720 av_dict_free(&metadata);
1721 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1724 #if FF_API_LAVF_AVCTX
1725 update_stream_avctx(s);
1728 if (s->debug & FF_FDEBUG_TS)
1729 av_log(s, AV_LOG_DEBUG,
1730 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1731 "size=%d, duration=%"PRId64", flags=%d\n",
1733 av_ts2str(pkt->pts),
1734 av_ts2str(pkt->dts),
1735 pkt->size, pkt->duration, pkt->flags);
1740 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1742 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1748 ret = s->internal->packet_buffer
1749 ? read_from_packet_buffer(&s->internal->packet_buffer,
1750 &s->internal->packet_buffer_end, pkt)
1751 : read_frame_internal(s, pkt);
1758 AVPacketList *pktl = s->internal->packet_buffer;
1761 AVPacket *next_pkt = &pktl->pkt;
1763 if (next_pkt->dts != AV_NOPTS_VALUE) {
1764 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1765 // last dts seen for this stream. if any of packets following
1766 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1767 int64_t last_dts = next_pkt->dts;
1768 av_assert2(wrap_bits <= 64);
1769 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1770 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1771 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1772 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1774 next_pkt->pts = pktl->pkt.dts;
1776 if (last_dts != AV_NOPTS_VALUE) {
1777 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1778 last_dts = pktl->pkt.dts;
1783 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1784 // Fixing the last reference frame had none pts issue (For MXF etc).
1785 // We only do this when
1787 // 2. we are not able to resolve a pts value for current packet.
1788 // 3. the packets for this stream at the end of the files had valid dts.
1789 next_pkt->pts = last_dts + next_pkt->duration;
1791 pktl = s->internal->packet_buffer;
1794 /* read packet from packet buffer, if there is data */
1795 st = s->streams[next_pkt->stream_index];
1796 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1797 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1798 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1799 &s->internal->packet_buffer_end, pkt);
1804 ret = read_frame_internal(s, pkt);
1806 if (pktl && ret != AVERROR(EAGAIN)) {
1813 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1814 &s->internal->packet_buffer_end, 1);
1815 av_packet_unref(pkt);
1822 st = s->streams[pkt->stream_index];
1823 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1824 ff_reduce_index(s, st->index);
1825 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1828 if (is_relative(pkt->dts))
1829 pkt->dts -= RELATIVE_TS_BASE;
1830 if (is_relative(pkt->pts))
1831 pkt->pts -= RELATIVE_TS_BASE;
1836 /* XXX: suppress the packet queue */
1837 static void flush_packet_queue(AVFormatContext *s)
1841 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1842 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1843 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1845 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1848 /*******************************************************/
1851 int av_find_default_stream_index(AVFormatContext *s)
1855 int best_stream = 0;
1856 int best_score = INT_MIN;
1858 if (s->nb_streams <= 0)
1860 for (i = 0; i < s->nb_streams; i++) {
1863 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1864 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1866 if (st->codecpar->width && st->codecpar->height)
1870 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1871 if (st->codecpar->sample_rate)
1874 if (st->codec_info_nb_frames)
1877 if (st->discard != AVDISCARD_ALL)
1880 if (score > best_score) {
1888 /** Flush the frame reader. */
1889 void ff_read_frame_flush(AVFormatContext *s)
1894 flush_packet_queue(s);
1896 /* Reset read state for each stream. */
1897 for (i = 0; i < s->nb_streams; i++) {
1901 av_parser_close(st->parser);
1904 st->last_IP_pts = AV_NOPTS_VALUE;
1905 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1906 if (st->first_dts == AV_NOPTS_VALUE)
1907 st->cur_dts = RELATIVE_TS_BASE;
1909 /* We set the current DTS to an unspecified origin. */
1910 st->cur_dts = AV_NOPTS_VALUE;
1912 st->probe_packets = MAX_PROBE_PACKETS;
1914 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1915 st->pts_buffer[j] = AV_NOPTS_VALUE;
1917 if (s->internal->inject_global_side_data)
1918 st->inject_global_side_data = 1;
1920 st->skip_samples = 0;
1924 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1928 for (i = 0; i < s->nb_streams; i++) {
1929 AVStream *st = s->streams[i];
1932 av_rescale(timestamp,
1933 st->time_base.den * (int64_t) ref_st->time_base.num,
1934 st->time_base.num * (int64_t) ref_st->time_base.den);
1938 void ff_reduce_index(AVFormatContext *s, int stream_index)
1940 AVStream *st = s->streams[stream_index];
1941 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1943 if ((unsigned) st->nb_index_entries >= max_entries) {
1945 for (i = 0; 2 * i < st->nb_index_entries; i++)
1946 st->index_entries[i] = st->index_entries[2 * i];
1947 st->nb_index_entries = i;
1951 int ff_add_index_entry(AVIndexEntry **index_entries,
1952 int *nb_index_entries,
1953 unsigned int *index_entries_allocated_size,
1954 int64_t pos, int64_t timestamp,
1955 int size, int distance, int flags)
1957 AVIndexEntry *entries, *ie;
1960 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1963 if (timestamp == AV_NOPTS_VALUE)
1964 return AVERROR(EINVAL);
1966 if (size < 0 || size > 0x3FFFFFFF)
1967 return AVERROR(EINVAL);
1969 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1970 timestamp -= RELATIVE_TS_BASE;
1972 entries = av_fast_realloc(*index_entries,
1973 index_entries_allocated_size,
1974 (*nb_index_entries + 1) *
1975 sizeof(AVIndexEntry));
1979 *index_entries = entries;
1981 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1982 timestamp, AVSEEK_FLAG_ANY);
1985 index = (*nb_index_entries)++;
1986 ie = &entries[index];
1987 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1989 ie = &entries[index];
1990 if (ie->timestamp != timestamp) {
1991 if (ie->timestamp <= timestamp)
1993 memmove(entries + index + 1, entries + index,
1994 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1995 (*nb_index_entries)++;
1996 } else if (ie->pos == pos && distance < ie->min_distance)
1997 // do not reduce the distance
1998 distance = ie->min_distance;
2002 ie->timestamp = timestamp;
2003 ie->min_distance = distance;
2010 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2011 int size, int distance, int flags)
2013 timestamp = wrap_timestamp(st, timestamp);
2014 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2015 &st->index_entries_allocated_size, pos,
2016 timestamp, size, distance, flags);
2019 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2020 int64_t wanted_timestamp, int flags)
2028 // Optimize appending index entries at the end.
2029 if (b && entries[b - 1].timestamp < wanted_timestamp)
2035 // Search for the next non-discarded packet.
2036 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2038 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2044 timestamp = entries[m].timestamp;
2045 if (timestamp >= wanted_timestamp)
2047 if (timestamp <= wanted_timestamp)
2050 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2052 if (!(flags & AVSEEK_FLAG_ANY))
2053 while (m >= 0 && m < nb_entries &&
2054 !(entries[m].flags & AVINDEX_KEYFRAME))
2055 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2057 if (m == nb_entries)
2062 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2065 int64_t pos_delta = 0;
2067 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2068 const char *proto = avio_find_protocol_name(s->url);
2071 av_log(s, AV_LOG_INFO,
2072 "Protocol name not provided, cannot determine if input is local or "
2073 "a network protocol, buffers and access patterns cannot be configured "
2074 "optimally without knowing the protocol\n");
2077 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2080 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2081 AVStream *st1 = s->streams[ist1];
2082 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2083 AVStream *st2 = s->streams[ist2];
2089 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2090 AVIndexEntry *e1 = &st1->index_entries[i1];
2091 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2093 skip = FFMAX(skip, e1->size);
2094 for (; i2 < st2->nb_index_entries; i2++) {
2095 AVIndexEntry *e2 = &st2->index_entries[i2];
2096 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2097 if (e2_pts - e1_pts < time_tolerance)
2099 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2107 /* XXX This could be adjusted depending on protocol*/
2108 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2109 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2110 ffio_set_buf_size(s->pb, pos_delta);
2111 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2114 if (skip < (1<<23)) {
2115 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2119 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2121 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2122 wanted_timestamp, flags);
2125 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2126 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2128 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2129 if (stream_index >= 0)
2130 ts = wrap_timestamp(s->streams[stream_index], ts);
2134 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2135 int64_t target_ts, int flags)
2137 AVInputFormat *avif = s->iformat;
2138 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2139 int64_t ts_min, ts_max, ts;
2144 if (stream_index < 0)
2147 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2150 ts_min = AV_NOPTS_VALUE;
2151 pos_limit = -1; // GCC falsely says it may be uninitialized.
2153 st = s->streams[stream_index];
2154 if (st->index_entries) {
2157 /* FIXME: Whole function must be checked for non-keyframe entries in
2158 * index case, especially read_timestamp(). */
2159 index = av_index_search_timestamp(st, target_ts,
2160 flags | AVSEEK_FLAG_BACKWARD);
2161 index = FFMAX(index, 0);
2162 e = &st->index_entries[index];
2164 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2166 ts_min = e->timestamp;
2167 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2168 pos_min, av_ts2str(ts_min));
2170 av_assert1(index == 0);
2173 index = av_index_search_timestamp(st, target_ts,
2174 flags & ~AVSEEK_FLAG_BACKWARD);
2175 av_assert0(index < st->nb_index_entries);
2177 e = &st->index_entries[index];
2178 av_assert1(e->timestamp >= target_ts);
2180 ts_max = e->timestamp;
2181 pos_limit = pos_max - e->min_distance;
2182 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2183 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2187 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2188 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2193 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2196 ff_read_frame_flush(s);
2197 ff_update_cur_dts(s, st, ts);
2202 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2203 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2205 int64_t step = 1024;
2206 int64_t limit, ts_max;
2207 int64_t filesize = avio_size(s->pb);
2208 int64_t pos_max = filesize - 1;
2211 pos_max = FFMAX(0, (pos_max) - step);
2212 ts_max = ff_read_timestamp(s, stream_index,
2213 &pos_max, limit, read_timestamp);
2215 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2216 if (ts_max == AV_NOPTS_VALUE)
2220 int64_t tmp_pos = pos_max + 1;
2221 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2222 &tmp_pos, INT64_MAX, read_timestamp);
2223 if (tmp_ts == AV_NOPTS_VALUE)
2225 av_assert0(tmp_pos > pos_max);
2228 if (tmp_pos >= filesize)
2240 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2241 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2242 int64_t ts_min, int64_t ts_max,
2243 int flags, int64_t *ts_ret,
2244 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2245 int64_t *, int64_t))
2252 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2254 if (ts_min == AV_NOPTS_VALUE) {
2255 pos_min = s->internal->data_offset;
2256 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2257 if (ts_min == AV_NOPTS_VALUE)
2261 if (ts_min >= target_ts) {
2266 if (ts_max == AV_NOPTS_VALUE) {
2267 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2269 pos_limit = pos_max;
2272 if (ts_max <= target_ts) {
2277 av_assert0(ts_min < ts_max);
2280 while (pos_min < pos_limit) {
2281 av_log(s, AV_LOG_TRACE,
2282 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2283 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2284 av_assert0(pos_limit <= pos_max);
2286 if (no_change == 0) {
2287 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2288 // interpolate position (better than dichotomy)
2289 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2291 pos_min - approximate_keyframe_distance;
2292 } else if (no_change == 1) {
2293 // bisection if interpolation did not change min / max pos last time
2294 pos = (pos_min + pos_limit) >> 1;
2296 /* linear search if bisection failed, can only happen if there
2297 * are very few or no keyframes between min/max */
2302 else if (pos > pos_limit)
2306 // May pass pos_limit instead of -1.
2307 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2312 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2313 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2314 pos_min, pos, pos_max,
2315 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2316 pos_limit, start_pos, no_change);
2317 if (ts == AV_NOPTS_VALUE) {
2318 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2321 if (target_ts <= ts) {
2322 pos_limit = start_pos - 1;
2326 if (target_ts >= ts) {
2332 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2333 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2336 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2338 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2339 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2340 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2346 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2347 int64_t pos, int flags)
2349 int64_t pos_min, pos_max;
2351 pos_min = s->internal->data_offset;
2352 pos_max = avio_size(s->pb) - 1;
2356 else if (pos > pos_max)
2359 avio_seek(s->pb, pos, SEEK_SET);
2361 s->io_repositioned = 1;
2366 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2367 int64_t timestamp, int flags)
2374 st = s->streams[stream_index];
2376 index = av_index_search_timestamp(st, timestamp, flags);
2378 if (index < 0 && st->nb_index_entries &&
2379 timestamp < st->index_entries[0].timestamp)
2382 if (index < 0 || index == st->nb_index_entries - 1) {
2386 if (st->nb_index_entries) {
2387 av_assert0(st->index_entries);
2388 ie = &st->index_entries[st->nb_index_entries - 1];
2389 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2391 ff_update_cur_dts(s, st, ie->timestamp);
2393 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2399 read_status = av_read_frame(s, &pkt);
2400 } while (read_status == AVERROR(EAGAIN));
2401 if (read_status < 0)
2403 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2404 if (pkt.flags & AV_PKT_FLAG_KEY) {
2405 av_packet_unref(&pkt);
2408 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2409 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);
2410 av_packet_unref(&pkt);
2414 av_packet_unref(&pkt);
2416 index = av_index_search_timestamp(st, timestamp, flags);
2421 ff_read_frame_flush(s);
2422 if (s->iformat->read_seek)
2423 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2425 ie = &st->index_entries[index];
2426 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2428 ff_update_cur_dts(s, st, ie->timestamp);
2433 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2434 int64_t timestamp, int flags)
2439 if (flags & AVSEEK_FLAG_BYTE) {
2440 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2442 ff_read_frame_flush(s);
2443 return seek_frame_byte(s, stream_index, timestamp, flags);
2446 if (stream_index < 0) {
2447 stream_index = av_find_default_stream_index(s);
2448 if (stream_index < 0)
2451 st = s->streams[stream_index];
2452 /* timestamp for default must be expressed in AV_TIME_BASE units */
2453 timestamp = av_rescale(timestamp, st->time_base.den,
2454 AV_TIME_BASE * (int64_t) st->time_base.num);
2457 /* first, we try the format specific seek */
2458 if (s->iformat->read_seek) {
2459 ff_read_frame_flush(s);
2460 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2466 if (s->iformat->read_timestamp &&
2467 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2468 ff_read_frame_flush(s);
2469 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2470 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2471 ff_read_frame_flush(s);
2472 return seek_frame_generic(s, stream_index, timestamp, flags);
2477 int av_seek_frame(AVFormatContext *s, int stream_index,
2478 int64_t timestamp, int flags)
2482 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2483 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2484 if ((flags & AVSEEK_FLAG_BACKWARD))
2488 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2489 flags & ~AVSEEK_FLAG_BACKWARD);
2492 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2495 ret = avformat_queue_attached_pictures(s);
2500 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2501 int64_t ts, int64_t max_ts, int flags)
2503 if (min_ts > ts || max_ts < ts)
2505 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2506 return AVERROR(EINVAL);
2509 flags |= AVSEEK_FLAG_ANY;
2510 flags &= ~AVSEEK_FLAG_BACKWARD;
2512 if (s->iformat->read_seek2) {
2514 ff_read_frame_flush(s);
2516 if (stream_index == -1 && s->nb_streams == 1) {
2517 AVRational time_base = s->streams[0]->time_base;
2518 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2519 min_ts = av_rescale_rnd(min_ts, time_base.den,
2520 time_base.num * (int64_t)AV_TIME_BASE,
2521 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2522 max_ts = av_rescale_rnd(max_ts, time_base.den,
2523 time_base.num * (int64_t)AV_TIME_BASE,
2524 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2528 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2532 ret = avformat_queue_attached_pictures(s);
2536 if (s->iformat->read_timestamp) {
2537 // try to seek via read_timestamp()
2540 // Fall back on old API if new is not implemented but old is.
2541 // Note the old API has somewhat different semantics.
2542 if (s->iformat->read_seek || 1) {
2543 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2544 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2545 if (ret<0 && ts != min_ts && max_ts != ts) {
2546 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2548 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2553 // try some generic seek like seek_frame_generic() but with new ts semantics
2554 return -1; //unreachable
2557 int avformat_flush(AVFormatContext *s)
2559 ff_read_frame_flush(s);
2563 /*******************************************************/
2566 * Return TRUE if the stream has accurate duration in any stream.
2568 * @return TRUE if the stream has accurate duration for at least one component.
2570 static int has_duration(AVFormatContext *ic)
2575 for (i = 0; i < ic->nb_streams; i++) {
2576 st = ic->streams[i];
2577 if (st->duration != AV_NOPTS_VALUE)
2580 if (ic->duration != AV_NOPTS_VALUE)
2586 * Estimate the stream timings from the one of each components.
2588 * Also computes the global bitrate if possible.
2590 static void update_stream_timings(AVFormatContext *ic)
2592 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2593 int64_t duration, duration1, filesize;
2598 start_time = INT64_MAX;
2599 start_time_text = INT64_MAX;
2600 end_time = INT64_MIN;
2601 end_time_text = INT64_MIN;
2602 duration = INT64_MIN;
2603 for (i = 0; i < ic->nb_streams; i++) {
2604 st = ic->streams[i];
2605 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2606 start_time1 = av_rescale_q(st->start_time, st->time_base,
2608 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2609 if (start_time1 < start_time_text)
2610 start_time_text = start_time1;
2612 start_time = FFMIN(start_time, start_time1);
2613 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2615 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2616 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2617 end_time1 += start_time1;
2618 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2619 end_time_text = FFMAX(end_time_text, end_time1);
2621 end_time = FFMAX(end_time, end_time1);
2623 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2624 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2625 p->start_time = start_time1;
2626 if (p->end_time < end_time1)
2627 p->end_time = end_time1;
2630 if (st->duration != AV_NOPTS_VALUE) {
2631 duration1 = av_rescale_q(st->duration, st->time_base,
2633 duration = FFMAX(duration, duration1);
2636 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2637 start_time = start_time_text;
2638 else if (start_time > start_time_text)
2639 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2641 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2642 end_time = end_time_text;
2643 } else if (end_time < end_time_text) {
2644 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2647 if (start_time != INT64_MAX) {
2648 ic->start_time = start_time;
2649 if (end_time != INT64_MIN) {
2650 if (ic->nb_programs > 1) {
2651 for (i = 0; i < ic->nb_programs; i++) {
2652 p = ic->programs[i];
2653 if (p->start_time != AV_NOPTS_VALUE &&
2654 p->end_time > p->start_time &&
2655 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2656 duration = FFMAX(duration, p->end_time - p->start_time);
2658 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2659 duration = FFMAX(duration, end_time - start_time);
2663 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2664 ic->duration = duration;
2666 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2667 /* compute the bitrate */
2668 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2669 (double) ic->duration;
2670 if (bitrate >= 0 && bitrate <= INT64_MAX)
2671 ic->bit_rate = bitrate;
2675 static void fill_all_stream_timings(AVFormatContext *ic)
2680 update_stream_timings(ic);
2681 for (i = 0; i < ic->nb_streams; i++) {
2682 st = ic->streams[i];
2683 if (st->start_time == AV_NOPTS_VALUE) {
2684 if (ic->start_time != AV_NOPTS_VALUE)
2685 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2687 if (ic->duration != AV_NOPTS_VALUE)
2688 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2694 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2696 int64_t filesize, duration;
2697 int i, show_warning = 0;
2700 /* if bit_rate is already set, we believe it */
2701 if (ic->bit_rate <= 0) {
2702 int64_t bit_rate = 0;
2703 for (i = 0; i < ic->nb_streams; i++) {
2704 st = ic->streams[i];
2705 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2706 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2707 if (st->codecpar->bit_rate > 0) {
2708 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2712 bit_rate += st->codecpar->bit_rate;
2713 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2714 // If we have a videostream with packets but without a bitrate
2715 // then consider the sum not known
2720 ic->bit_rate = bit_rate;
2723 /* if duration is already set, we believe it */
2724 if (ic->duration == AV_NOPTS_VALUE &&
2725 ic->bit_rate != 0) {
2726 filesize = ic->pb ? avio_size(ic->pb) : 0;
2727 if (filesize > ic->internal->data_offset) {
2728 filesize -= ic->internal->data_offset;
2729 for (i = 0; i < ic->nb_streams; i++) {
2730 st = ic->streams[i];
2731 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2732 && st->duration == AV_NOPTS_VALUE) {
2733 duration = av_rescale(8 * filesize, st->time_base.den,
2735 (int64_t) st->time_base.num);
2736 st->duration = duration;
2743 av_log(ic, AV_LOG_WARNING,
2744 "Estimating duration from bitrate, this may be inaccurate\n");
2747 #define DURATION_MAX_READ_SIZE 250000LL
2748 #define DURATION_MAX_RETRY 6
2750 /* only usable for MPEG-PS streams */
2751 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2753 AVPacket pkt1, *pkt = &pkt1;
2755 int num, den, read_size, i, ret;
2756 int found_duration = 0;
2758 int64_t filesize, offset, duration;
2761 /* flush packet queue */
2762 flush_packet_queue(ic);
2764 for (i = 0; i < ic->nb_streams; i++) {
2765 st = ic->streams[i];
2766 if (st->start_time == AV_NOPTS_VALUE &&
2767 st->first_dts == AV_NOPTS_VALUE &&
2768 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2769 av_log(ic, AV_LOG_WARNING,
2770 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2773 av_parser_close(st->parser);
2778 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2779 /* estimate the end time (duration) */
2780 /* XXX: may need to support wrapping */
2781 filesize = ic->pb ? avio_size(ic->pb) : 0;
2783 is_end = found_duration;
2784 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2788 avio_seek(ic->pb, offset, SEEK_SET);
2791 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2795 ret = ff_read_packet(ic, pkt);
2796 } while (ret == AVERROR(EAGAIN));
2799 read_size += pkt->size;
2800 st = ic->streams[pkt->stream_index];
2801 if (pkt->pts != AV_NOPTS_VALUE &&
2802 (st->start_time != AV_NOPTS_VALUE ||
2803 st->first_dts != AV_NOPTS_VALUE)) {
2804 if (pkt->duration == 0) {
2805 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2807 pkt->duration = av_rescale_rnd(1,
2808 num * (int64_t) st->time_base.den,
2809 den * (int64_t) st->time_base.num,
2813 duration = pkt->pts + pkt->duration;
2815 if (st->start_time != AV_NOPTS_VALUE)
2816 duration -= st->start_time;
2818 duration -= st->first_dts;
2820 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2821 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2822 st->duration = duration;
2823 st->info->last_duration = duration;
2826 av_packet_unref(pkt);
2829 /* check if all audio/video streams have valid duration */
2832 for (i = 0; i < ic->nb_streams; i++) {
2833 st = ic->streams[i];
2834 switch (st->codecpar->codec_type) {
2835 case AVMEDIA_TYPE_VIDEO:
2836 case AVMEDIA_TYPE_AUDIO:
2837 if (st->duration == AV_NOPTS_VALUE)
2844 ++retry <= DURATION_MAX_RETRY);
2846 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2848 /* warn about audio/video streams which duration could not be estimated */
2849 for (i = 0; i < ic->nb_streams; i++) {
2850 st = ic->streams[i];
2851 if (st->duration == AV_NOPTS_VALUE) {
2852 switch (st->codecpar->codec_type) {
2853 case AVMEDIA_TYPE_VIDEO:
2854 case AVMEDIA_TYPE_AUDIO:
2855 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2856 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2858 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2862 fill_all_stream_timings(ic);
2864 avio_seek(ic->pb, old_offset, SEEK_SET);
2865 for (i = 0; i < ic->nb_streams; i++) {
2868 st = ic->streams[i];
2869 st->cur_dts = st->first_dts;
2870 st->last_IP_pts = AV_NOPTS_VALUE;
2871 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2872 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2873 st->pts_buffer[j] = AV_NOPTS_VALUE;
2877 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2881 /* get the file size, if possible */
2882 if (ic->iformat->flags & AVFMT_NOFILE) {
2885 file_size = avio_size(ic->pb);
2886 file_size = FFMAX(0, file_size);
2889 if ((!strcmp(ic->iformat->name, "mpeg") ||
2890 !strcmp(ic->iformat->name, "mpegts")) &&
2891 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2892 /* get accurate estimate from the PTSes */
2893 estimate_timings_from_pts(ic, old_offset);
2894 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2895 } else if (has_duration(ic)) {
2896 /* at least one component has timings - we use them for all
2898 fill_all_stream_timings(ic);
2899 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2901 /* less precise: use bitrate info */
2902 estimate_timings_from_bit_rate(ic);
2903 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2905 update_stream_timings(ic);
2909 AVStream av_unused *st;
2910 for (i = 0; i < ic->nb_streams; i++) {
2911 st = ic->streams[i];
2912 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2913 (double) st->start_time * av_q2d(st->time_base),
2914 (double) st->duration * av_q2d(st->time_base));
2916 av_log(ic, AV_LOG_TRACE,
2917 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2918 (double) ic->start_time / AV_TIME_BASE,
2919 (double) ic->duration / AV_TIME_BASE,
2920 (int64_t)ic->bit_rate / 1000);
2924 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2926 AVCodecContext *avctx = st->internal->avctx;
2928 #define FAIL(errmsg) do { \
2930 *errmsg_ptr = errmsg; \
2934 if ( avctx->codec_id == AV_CODEC_ID_NONE
2935 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2936 FAIL("unknown codec");
2937 switch (avctx->codec_type) {
2938 case AVMEDIA_TYPE_AUDIO:
2939 if (!avctx->frame_size && determinable_frame_size(avctx))
2940 FAIL("unspecified frame size");
2941 if (st->info->found_decoder >= 0 &&
2942 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2943 FAIL("unspecified sample format");
2944 if (!avctx->sample_rate)
2945 FAIL("unspecified sample rate");
2946 if (!avctx->channels)
2947 FAIL("unspecified number of channels");
2948 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2949 FAIL("no decodable DTS frames");
2951 case AVMEDIA_TYPE_VIDEO:
2953 FAIL("unspecified size");
2954 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2955 FAIL("unspecified pixel format");
2956 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2957 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2958 FAIL("no frame in rv30/40 and no sar");
2960 case AVMEDIA_TYPE_SUBTITLE:
2961 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2962 FAIL("unspecified size");
2964 case AVMEDIA_TYPE_DATA:
2965 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2971 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2972 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2973 AVDictionary **options)
2975 AVCodecContext *avctx = st->internal->avctx;
2976 const AVCodec *codec;
2977 int got_picture = 1, ret = 0;
2978 AVFrame *frame = av_frame_alloc();
2979 AVSubtitle subtitle;
2980 AVPacket pkt = *avpkt;
2981 int do_skip_frame = 0;
2982 enum AVDiscard skip_frame;
2985 return AVERROR(ENOMEM);
2987 if (!avcodec_is_open(avctx) &&
2988 st->info->found_decoder <= 0 &&
2989 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2990 AVDictionary *thread_opt = NULL;
2992 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2995 st->info->found_decoder = -st->codecpar->codec_id;
3000 /* Force thread count to 1 since the H.264 decoder will not extract
3001 * SPS and PPS to extradata during multi-threaded decoding. */
3002 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3003 if (s->codec_whitelist)
3004 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3005 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3007 av_dict_free(&thread_opt);
3009 st->info->found_decoder = -avctx->codec_id;
3012 st->info->found_decoder = 1;
3013 } else if (!st->info->found_decoder)
3014 st->info->found_decoder = 1;
3016 if (st->info->found_decoder < 0) {
3021 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3023 skip_frame = avctx->skip_frame;
3024 avctx->skip_frame = AVDISCARD_ALL;
3027 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3029 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3030 (!st->codec_info_nb_frames &&
3031 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3033 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3034 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3035 ret = avcodec_send_packet(avctx, &pkt);
3036 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3040 ret = avcodec_receive_frame(avctx, frame);
3043 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3045 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3046 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3047 &got_picture, &pkt);
3053 st->nb_decoded_frames++;
3058 if (!pkt.data && !got_picture)
3062 if (do_skip_frame) {
3063 avctx->skip_frame = skip_frame;
3066 av_frame_free(&frame);
3070 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3072 while (tags->id != AV_CODEC_ID_NONE) {
3080 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3083 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3084 if (tag == tags[i].tag)
3086 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3087 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3089 return AV_CODEC_ID_NONE;
3092 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3094 if (bps <= 0 || bps > 64)
3095 return AV_CODEC_ID_NONE;
3100 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3102 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3104 return AV_CODEC_ID_NONE;
3109 if (sflags & (1 << (bps - 1))) {
3112 return AV_CODEC_ID_PCM_S8;
3114 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3116 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3118 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3120 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3122 return AV_CODEC_ID_NONE;
3127 return AV_CODEC_ID_PCM_U8;
3129 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3131 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3133 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3135 return AV_CODEC_ID_NONE;
3141 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3144 if (!av_codec_get_tag2(tags, id, &tag))
3149 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3153 for (i = 0; tags && tags[i]; i++) {
3154 const AVCodecTag *codec_tags = tags[i];
3155 while (codec_tags->id != AV_CODEC_ID_NONE) {
3156 if (codec_tags->id == id) {
3157 *tag = codec_tags->tag;
3166 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3169 for (i = 0; tags && tags[i]; i++) {
3170 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3171 if (id != AV_CODEC_ID_NONE)
3174 return AV_CODEC_ID_NONE;
3177 static void compute_chapters_end(AVFormatContext *s)
3180 int64_t max_time = 0;
3182 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3183 max_time = s->duration +
3184 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3186 for (i = 0; i < s->nb_chapters; i++)
3187 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3188 AVChapter *ch = s->chapters[i];
3189 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3193 for (j = 0; j < s->nb_chapters; j++) {
3194 AVChapter *ch1 = s->chapters[j];
3195 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3197 if (j != i && next_start > ch->start && next_start < end)
3200 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3204 static int get_std_framerate(int i)
3207 return (i + 1) * 1001;
3211 return (i + 31) * 1001 * 12;
3215 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3219 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3222 /* Is the time base unreliable?
3223 * This is a heuristic to balance between quick acceptance of the values in
3224 * the headers vs. some extra checks.
3225 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3226 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3227 * And there are "variable" fps files this needs to detect as well. */
3228 static int tb_unreliable(AVCodecContext *c)
3230 if (c->time_base.den >= 101LL * c->time_base.num ||
3231 c->time_base.den < 5LL * c->time_base.num ||
3232 // c->codec_tag == AV_RL32("DIVX") ||
3233 // c->codec_tag == AV_RL32("XVID") ||
3234 c->codec_tag == AV_RL32("mp4v") ||
3235 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3236 c->codec_id == AV_CODEC_ID_GIF ||
3237 c->codec_id == AV_CODEC_ID_HEVC ||
3238 c->codec_id == AV_CODEC_ID_H264)
3243 int ff_alloc_extradata(AVCodecParameters *par, int size)
3247 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3248 par->extradata = NULL;
3249 par->extradata_size = 0;
3250 return AVERROR(EINVAL);
3252 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3253 if (par->extradata) {
3254 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3255 par->extradata_size = size;
3258 par->extradata_size = 0;
3259 ret = AVERROR(ENOMEM);
3264 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3266 int ret = ff_alloc_extradata(par, size);
3269 ret = avio_read(pb, par->extradata, size);
3271 av_freep(&par->extradata);
3272 par->extradata_size = 0;
3273 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3274 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3280 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3283 int64_t last = st->info->last_dts;
3285 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3286 && ts - (uint64_t)last < INT64_MAX) {
3287 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3288 int64_t duration = ts - last;
3290 if (!st->info->duration_error)
3291 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3292 if (!st->info->duration_error)
3293 return AVERROR(ENOMEM);
3295 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3296 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3297 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3298 if (st->info->duration_error[0][1][i] < 1e10) {
3299 int framerate = get_std_framerate(i);
3300 double sdts = dts*framerate/(1001*12);
3301 for (j= 0; j<2; j++) {
3302 int64_t ticks = llrint(sdts+j*0.5);
3303 double error= sdts - ticks + j*0.5;
3304 st->info->duration_error[j][0][i] += error;
3305 st->info->duration_error[j][1][i] += error*error;
3309 st->info->duration_count++;
3310 st->info->rfps_duration_sum += duration;
3312 if (st->info->duration_count % 10 == 0) {
3313 int n = st->info->duration_count;
3314 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3315 if (st->info->duration_error[0][1][i] < 1e10) {
3316 double a0 = st->info->duration_error[0][0][i] / n;
3317 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3318 double a1 = st->info->duration_error[1][0][i] / n;
3319 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3320 if (error0 > 0.04 && error1 > 0.04) {
3321 st->info->duration_error[0][1][i] = 2e10;
3322 st->info->duration_error[1][1][i] = 2e10;
3328 // ignore the first 4 values, they might have some random jitter
3329 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3330 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3332 if (ts != AV_NOPTS_VALUE)
3333 st->info->last_dts = ts;
3338 void ff_rfps_calculate(AVFormatContext *ic)
3342 for (i = 0; i < ic->nb_streams; i++) {
3343 AVStream *st = ic->streams[i];
3345 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3347 // the check for tb_unreliable() is not completely correct, since this is not about handling
3348 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3349 // ipmovie.c produces.
3350 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)
3351 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);
3352 if (st->info->duration_count>1 && !st->r_frame_rate.num
3353 && tb_unreliable(st->internal->avctx)) {
3355 double best_error= 0.01;
3356 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3358 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3361 if (st->info->codec_info_duration &&
3362 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3364 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3367 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3370 for (k= 0; k<2; k++) {
3371 int n = st->info->duration_count;
3372 double a= st->info->duration_error[k][0][j] / n;
3373 double error= st->info->duration_error[k][1][j]/n - a*a;
3375 if (error < best_error && best_error> 0.000000001) {
3377 num = get_std_framerate(j);
3380 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3383 // do not increase frame rate by more than 1 % in order to match a standard rate.
3384 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3385 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3387 if ( !st->avg_frame_rate.num
3388 && st->r_frame_rate.num && st->info->rfps_duration_sum
3389 && st->info->codec_info_duration <= 0
3390 && st->info->duration_count > 2
3391 && 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
3393 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3394 st->avg_frame_rate = st->r_frame_rate;
3397 av_freep(&st->info->duration_error);
3398 st->info->last_dts = AV_NOPTS_VALUE;
3399 st->info->duration_count = 0;
3400 st->info->rfps_duration_sum = 0;
3404 static int extract_extradata_check(AVStream *st)
3406 const AVBitStreamFilter *f;
3408 f = av_bsf_get_by_name("extract_extradata");
3413 const enum AVCodecID *ids;
3414 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3415 if (*ids == st->codecpar->codec_id)
3422 static int extract_extradata_init(AVStream *st)
3424 AVStreamInternal *i = st->internal;
3425 const AVBitStreamFilter *f;
3428 f = av_bsf_get_by_name("extract_extradata");
3432 /* check that the codec id is supported */
3433 ret = extract_extradata_check(st);
3437 i->extract_extradata.pkt = av_packet_alloc();
3438 if (!i->extract_extradata.pkt)
3439 return AVERROR(ENOMEM);
3441 ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3445 ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3450 i->extract_extradata.bsf->time_base_in = st->time_base;
3452 /* if init fails here, we assume extracting extradata is just not
3453 * supported for this codec, so we return success */
3454 ret = av_bsf_init(i->extract_extradata.bsf);
3456 av_bsf_free(&i->extract_extradata.bsf);
3461 i->extract_extradata.inited = 1;
3465 av_bsf_free(&i->extract_extradata.bsf);
3466 av_packet_free(&i->extract_extradata.pkt);
3470 static int extract_extradata(AVStream *st, AVPacket *pkt)
3472 AVStreamInternal *i = st->internal;
3476 if (!i->extract_extradata.inited) {
3477 ret = extract_extradata_init(st);
3482 if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3485 pkt_ref = i->extract_extradata.pkt;
3486 ret = av_packet_ref(pkt_ref, pkt);
3490 ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3492 av_packet_unref(pkt_ref);
3496 while (ret >= 0 && !i->avctx->extradata) {
3500 ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3502 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3507 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3511 i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3512 if (!i->avctx->extradata) {
3513 av_packet_unref(pkt_ref);
3514 return AVERROR(ENOMEM);
3516 memcpy(i->avctx->extradata, extradata, extradata_size);
3517 i->avctx->extradata_size = extradata_size;
3519 av_packet_unref(pkt_ref);
3525 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3527 int i, count = 0, ret = 0, j;
3530 AVCodecContext *avctx;
3531 AVPacket pkt1, *pkt;
3532 int64_t old_offset = avio_tell(ic->pb);
3533 // new streams might appear, no options for those
3534 int orig_nb_streams = ic->nb_streams;
3536 int64_t max_analyze_duration = ic->max_analyze_duration;
3537 int64_t max_stream_analyze_duration;
3538 int64_t max_subtitle_analyze_duration;
3539 int64_t probesize = ic->probesize;
3540 int eof_reached = 0;
3541 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3543 flush_codecs = probesize > 0;
3545 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3547 max_stream_analyze_duration = max_analyze_duration;
3548 max_subtitle_analyze_duration = max_analyze_duration;
3549 if (!max_analyze_duration) {
3550 max_stream_analyze_duration =
3551 max_analyze_duration = 5*AV_TIME_BASE;
3552 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3553 if (!strcmp(ic->iformat->name, "flv"))
3554 max_stream_analyze_duration = 90*AV_TIME_BASE;
3555 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3556 max_stream_analyze_duration = 7*AV_TIME_BASE;
3560 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3561 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3563 for (i = 0; i < ic->nb_streams; i++) {
3564 const AVCodec *codec;
3565 AVDictionary *thread_opt = NULL;
3566 st = ic->streams[i];
3567 avctx = st->internal->avctx;
3569 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3570 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3571 /* if (!st->time_base.num)
3573 if (!avctx->time_base.num)
3574 avctx->time_base = st->time_base;
3577 /* check if the caller has overridden the codec id */
3578 #if FF_API_LAVF_AVCTX
3579 FF_DISABLE_DEPRECATION_WARNINGS
3580 if (st->codec->codec_id != st->internal->orig_codec_id) {
3581 st->codecpar->codec_id = st->codec->codec_id;
3582 st->codecpar->codec_type = st->codec->codec_type;
3583 st->internal->orig_codec_id = st->codec->codec_id;
3585 FF_ENABLE_DEPRECATION_WARNINGS
3587 // only for the split stuff
3588 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3589 st->parser = av_parser_init(st->codecpar->codec_id);
3591 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3592 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3593 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3594 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3596 } else if (st->need_parsing) {
3597 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3598 "%s, packets or times may be invalid.\n",
3599 avcodec_get_name(st->codecpar->codec_id));
3603 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3604 st->internal->orig_codec_id = st->codecpar->codec_id;
3606 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3608 goto find_stream_info_err;
3609 if (st->request_probe <= 0)
3610 st->internal->avctx_inited = 1;
3612 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3614 /* Force thread count to 1 since the H.264 decoder will not extract
3615 * SPS and PPS to extradata during multi-threaded decoding. */
3616 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3618 if (ic->codec_whitelist)
3619 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3621 /* Ensure that subtitle_header is properly set. */
3622 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3623 && codec && !avctx->codec) {
3624 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3625 av_log(ic, AV_LOG_WARNING,
3626 "Failed to open codec in %s\n",__FUNCTION__);
3629 // Try to just open decoders, in case this is enough to get parameters.
3630 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3631 if (codec && !avctx->codec)
3632 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3633 av_log(ic, AV_LOG_WARNING,
3634 "Failed to open codec in %s\n",__FUNCTION__);
3637 av_dict_free(&thread_opt);
3640 for (i = 0; i < ic->nb_streams; i++) {
3641 #if FF_API_R_FRAME_RATE
3642 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3644 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3645 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3650 int analyzed_all_streams;
3651 if (ff_check_interrupt(&ic->interrupt_callback)) {
3653 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3657 /* check if one codec still needs to be handled */
3658 for (i = 0; i < ic->nb_streams; i++) {
3659 int fps_analyze_framecount = 20;
3662 st = ic->streams[i];
3663 if (!has_codec_parameters(st, NULL))
3665 /* If the timebase is coarse (like the usual millisecond precision
3666 * of mkv), we need to analyze more frames to reliably arrive at
3667 * the correct fps. */
3668 if (av_q2d(st->time_base) > 0.0005)
3669 fps_analyze_framecount *= 2;
3670 if (!tb_unreliable(st->internal->avctx))
3671 fps_analyze_framecount = 0;
3672 if (ic->fps_probe_size >= 0)
3673 fps_analyze_framecount = ic->fps_probe_size;
3674 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3675 fps_analyze_framecount = 0;
3676 /* variable fps and no guess at the real fps */
3677 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3678 st->info->codec_info_duration_fields/2 :
3679 st->info->duration_count;
3680 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3681 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3682 if (count < fps_analyze_framecount)
3685 // Look at the first 3 frames if there is evidence of frame delay
3686 // but the decoder delay is not set.
3687 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3689 if (!st->internal->avctx->extradata &&
3690 (!st->internal->extract_extradata.inited ||
3691 st->internal->extract_extradata.bsf) &&
3692 extract_extradata_check(st))
3694 if (st->first_dts == AV_NOPTS_VALUE &&
3695 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3696 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3697 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3698 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3701 analyzed_all_streams = 0;
3702 if (!missing_streams || !*missing_streams)
3703 if (i == ic->nb_streams) {
3704 analyzed_all_streams = 1;
3705 /* NOTE: If the format has no header, then we need to read some
3706 * packets to get most of the streams, so we cannot stop here. */
3707 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3708 /* If we found the info for all the codecs, we can stop. */
3710 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3715 /* We did not get all the codec info, but we read too much data. */
3716 if (read_size >= probesize) {
3718 av_log(ic, AV_LOG_DEBUG,
3719 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3720 for (i = 0; i < ic->nb_streams; i++)
3721 if (!ic->streams[i]->r_frame_rate.num &&
3722 ic->streams[i]->info->duration_count <= 1 &&
3723 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3724 strcmp(ic->iformat->name, "image2"))
3725 av_log(ic, AV_LOG_WARNING,
3726 "Stream #%d: not enough frames to estimate rate; "
3727 "consider increasing probesize\n", i);
3731 /* NOTE: A new stream can be added there if no header in file
3732 * (AVFMTCTX_NOHEADER). */
3733 ret = read_frame_internal(ic, &pkt1);
3734 if (ret == AVERROR(EAGAIN))
3745 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3746 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3747 &ic->internal->packet_buffer_end, 0);
3749 goto find_stream_info_err;
3752 st = ic->streams[pkt->stream_index];
3753 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3754 read_size += pkt->size;
3756 avctx = st->internal->avctx;
3757 if (!st->internal->avctx_inited) {
3758 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3760 goto find_stream_info_err;
3761 st->internal->avctx_inited = 1;
3764 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3765 /* check for non-increasing dts */
3766 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3767 st->info->fps_last_dts >= pkt->dts) {
3768 av_log(ic, AV_LOG_DEBUG,
3769 "Non-increasing DTS in stream %d: packet %d with DTS "
3770 "%"PRId64", packet %d with DTS %"PRId64"\n",
3771 st->index, st->info->fps_last_dts_idx,
3772 st->info->fps_last_dts, st->codec_info_nb_frames,
3774 st->info->fps_first_dts =
3775 st->info->fps_last_dts = AV_NOPTS_VALUE;
3777 /* Check for a discontinuity in dts. If the difference in dts
3778 * is more than 1000 times the average packet duration in the
3779 * sequence, we treat it as a discontinuity. */
3780 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3781 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3782 (pkt->dts - st->info->fps_last_dts) / 1000 >
3783 (st->info->fps_last_dts - st->info->fps_first_dts) /
3784 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3785 av_log(ic, AV_LOG_WARNING,
3786 "DTS discontinuity in stream %d: packet %d with DTS "
3787 "%"PRId64", packet %d with DTS %"PRId64"\n",
3788 st->index, st->info->fps_last_dts_idx,
3789 st->info->fps_last_dts, st->codec_info_nb_frames,
3791 st->info->fps_first_dts =
3792 st->info->fps_last_dts = AV_NOPTS_VALUE;
3795 /* update stored dts values */
3796 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3797 st->info->fps_first_dts = pkt->dts;
3798 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3800 st->info->fps_last_dts = pkt->dts;
3801 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3803 if (st->codec_info_nb_frames>1) {
3807 if (st->time_base.den > 0)
3808 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3809 if (st->avg_frame_rate.num > 0)
3810 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3813 && st->codec_info_nb_frames>30
3814 && st->info->fps_first_dts != AV_NOPTS_VALUE
3815 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3816 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3818 if (analyzed_all_streams) limit = max_analyze_duration;
3819 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3820 else limit = max_stream_analyze_duration;
3823 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3825 t, pkt->stream_index);
3826 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3827 av_packet_unref(pkt);
3830 if (pkt->duration) {
3831 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3832 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3834 st->info->codec_info_duration += pkt->duration;
3835 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3838 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3839 #if FF_API_R_FRAME_RATE
3840 ff_rfps_add_frame(ic, st, pkt->dts);
3842 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3843 st->info->frame_delay_evidence = 1;
3845 if (!st->internal->avctx->extradata) {
3846 ret = extract_extradata(st, pkt);
3848 goto find_stream_info_err;
3851 /* If still no information, we try to open the codec and to
3852 * decompress the frame. We try to avoid that in most cases as
3853 * it takes longer and uses more memory. For MPEG-4, we need to
3854 * decompress for QuickTime.
3856 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3857 * least one frame of codec data, this makes sure the codec initializes
3858 * the channel configuration and does not only trust the values from
3860 try_decode_frame(ic, st, pkt,
3861 (options && i < orig_nb_streams) ? &options[i] : NULL);
3863 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3864 av_packet_unref(pkt);
3866 st->codec_info_nb_frames++;
3872 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3873 st = ic->streams[stream_index];
3874 avctx = st->internal->avctx;
3875 if (!has_codec_parameters(st, NULL)) {
3876 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3877 if (codec && !avctx->codec) {
3878 AVDictionary *opts = NULL;
3879 if (ic->codec_whitelist)
3880 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3881 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3882 av_log(ic, AV_LOG_WARNING,
3883 "Failed to open codec in %s\n",__FUNCTION__);
3884 av_dict_free(&opts);
3888 // EOF already reached while reading the stream above.
3889 // So continue with reoordering DTS with whatever delay we have.
3890 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3891 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3897 AVPacket empty_pkt = { 0 };
3899 av_init_packet(&empty_pkt);
3901 for (i = 0; i < ic->nb_streams; i++) {
3903 st = ic->streams[i];
3905 /* flush the decoders */
3906 if (st->info->found_decoder == 1) {
3908 err = try_decode_frame(ic, st, &empty_pkt,
3909 (options && i < orig_nb_streams)
3910 ? &options[i] : NULL);
3911 } while (err > 0 && !has_codec_parameters(st, NULL));
3914 av_log(ic, AV_LOG_INFO,
3915 "decoding for stream %d failed\n", st->index);
3921 ff_rfps_calculate(ic);
3923 for (i = 0; i < ic->nb_streams; i++) {
3924 st = ic->streams[i];
3925 avctx = st->internal->avctx;
3926 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3927 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3928 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3929 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3930 avctx->codec_tag= tag;
3933 /* estimate average framerate if not set by demuxer */
3934 if (st->info->codec_info_duration_fields &&
3935 !st->avg_frame_rate.num &&
3936 st->info->codec_info_duration) {
3938 double best_error = 0.01;
3939 AVRational codec_frame_rate = avctx->framerate;
3941 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3942 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3943 st->info->codec_info_duration < 0)
3945 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3946 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3947 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3949 /* Round guessed framerate to a "standard" framerate if it's
3950 * within 1% of the original estimate. */
3951 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3952 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3953 double error = fabs(av_q2d(st->avg_frame_rate) /
3954 av_q2d(std_fps) - 1);
3956 if (error < best_error) {
3958 best_fps = std_fps.num;
3961 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3962 error = fabs(av_q2d(codec_frame_rate) /
3963 av_q2d(std_fps) - 1);
3964 if (error < best_error) {
3966 best_fps = std_fps.num;
3971 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3972 best_fps, 12 * 1001, INT_MAX);
3975 if (!st->r_frame_rate.num) {
3976 if ( avctx->time_base.den * (int64_t) st->time_base.num
3977 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3978 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
3979 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
3981 st->r_frame_rate.num = st->time_base.den;
3982 st->r_frame_rate.den = st->time_base.num;
3985 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3986 AVRational hw_ratio = { avctx->height, avctx->width };
3987 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3990 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3991 if (!avctx->bits_per_coded_sample)
3992 avctx->bits_per_coded_sample =
3993 av_get_bits_per_sample(avctx->codec_id);
3994 // set stream disposition based on audio service type
3995 switch (avctx->audio_service_type) {
3996 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3997 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3999 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4000 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4002 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4003 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4005 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4006 st->disposition = AV_DISPOSITION_COMMENT;
4008 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4009 st->disposition = AV_DISPOSITION_KARAOKE;
4016 estimate_timings(ic, old_offset);
4018 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4020 if (ret >= 0 && ic->nb_streams)
4021 /* We could not have all the codec parameters before EOF. */
4023 for (i = 0; i < ic->nb_streams; i++) {
4025 st = ic->streams[i];
4027 /* if no packet was ever seen, update context now for has_codec_parameters */
4028 if (!st->internal->avctx_inited) {
4029 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4030 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4031 st->codecpar->format = st->internal->avctx->sample_fmt;
4032 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4034 goto find_stream_info_err;
4036 if (!has_codec_parameters(st, &errmsg)) {
4038 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4039 av_log(ic, AV_LOG_WARNING,
4040 "Could not find codec parameters for stream %d (%s): %s\n"
4041 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4048 compute_chapters_end(ic);
4050 /* update the stream parameters from the internal codec contexts */
4051 for (i = 0; i < ic->nb_streams; i++) {
4052 st = ic->streams[i];
4054 if (st->internal->avctx_inited) {
4055 int orig_w = st->codecpar->width;
4056 int orig_h = st->codecpar->height;
4057 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4059 goto find_stream_info_err;
4061 // The decoder might reduce the video size by the lowres factor.
4062 if (st->internal->avctx->lowres && orig_w) {
4063 st->codecpar->width = orig_w;
4064 st->codecpar->height = orig_h;
4069 #if FF_API_LAVF_AVCTX
4070 FF_DISABLE_DEPRECATION_WARNINGS
4071 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4073 goto find_stream_info_err;
4076 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4077 // by the lowres factor.
4078 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4079 st->codec->lowres = st->internal->avctx->lowres;
4080 st->codec->width = st->internal->avctx->width;
4081 st->codec->height = st->internal->avctx->height;
4085 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4086 st->codec->time_base = st->internal->avctx->time_base;
4087 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4089 st->codec->framerate = st->avg_frame_rate;
4091 if (st->internal->avctx->subtitle_header) {
4092 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4093 if (!st->codec->subtitle_header)
4094 goto find_stream_info_err;
4095 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4096 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4097 st->codec->subtitle_header_size);
4100 // Fields unavailable in AVCodecParameters
4101 st->codec->coded_width = st->internal->avctx->coded_width;
4102 st->codec->coded_height = st->internal->avctx->coded_height;
4103 st->codec->properties = st->internal->avctx->properties;
4104 FF_ENABLE_DEPRECATION_WARNINGS
4107 st->internal->avctx_inited = 0;
4110 find_stream_info_err:
4111 for (i = 0; i < ic->nb_streams; i++) {
4112 st = ic->streams[i];
4114 av_freep(&st->info->duration_error);
4115 avcodec_close(ic->streams[i]->internal->avctx);
4116 av_freep(&ic->streams[i]->info);
4117 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4118 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4121 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4122 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4126 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4130 for (i = 0; i < ic->nb_programs; i++) {
4131 if (ic->programs[i] == last) {
4135 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4136 if (ic->programs[i]->stream_index[j] == s)
4137 return ic->programs[i];
4143 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4144 int wanted_stream_nb, int related_stream,
4145 AVCodec **decoder_ret, int flags)
4147 int i, nb_streams = ic->nb_streams;
4148 int ret = AVERROR_STREAM_NOT_FOUND;
4149 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4150 int count, multiframe, disposition;
4151 int64_t best_bitrate = -1;
4153 unsigned *program = NULL;
4154 const AVCodec *decoder = NULL, *best_decoder = NULL;
4156 if (related_stream >= 0 && wanted_stream_nb < 0) {
4157 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4159 program = p->stream_index;
4160 nb_streams = p->nb_stream_indexes;
4163 for (i = 0; i < nb_streams; i++) {
4164 int real_stream_index = program ? program[i] : i;
4165 AVStream *st = ic->streams[real_stream_index];
4166 AVCodecParameters *par = st->codecpar;
4167 if (par->codec_type != type)
4169 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4171 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4174 decoder = find_decoder(ic, st, par->codec_id);
4177 ret = AVERROR_DECODER_NOT_FOUND;
4181 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4182 count = st->codec_info_nb_frames;
4183 bitrate = par->bit_rate;
4184 multiframe = FFMIN(5, count);
4185 if ((best_disposition > disposition) ||
4186 (best_disposition == disposition && best_multiframe > multiframe) ||
4187 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4188 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4190 best_disposition = disposition;
4192 best_bitrate = bitrate;
4193 best_multiframe = multiframe;
4194 ret = real_stream_index;
4195 best_decoder = decoder;
4196 if (program && i == nb_streams - 1 && ret < 0) {
4198 nb_streams = ic->nb_streams;
4199 /* no related stream found, try again with everything */
4204 *decoder_ret = (AVCodec*)best_decoder;
4208 /*******************************************************/
4210 int av_read_play(AVFormatContext *s)
4212 if (s->iformat->read_play)
4213 return s->iformat->read_play(s);
4215 return avio_pause(s->pb, 0);
4216 return AVERROR(ENOSYS);
4219 int av_read_pause(AVFormatContext *s)
4221 if (s->iformat->read_pause)
4222 return s->iformat->read_pause(s);
4224 return avio_pause(s->pb, 1);
4225 return AVERROR(ENOSYS);
4228 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4233 dst->time_base = src->time_base;
4234 dst->nb_frames = src->nb_frames;
4235 dst->disposition = src->disposition;
4236 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4237 dst->avg_frame_rate = src->avg_frame_rate;
4238 dst->r_frame_rate = src->r_frame_rate;
4240 av_dict_free(&dst->metadata);
4241 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4245 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4249 /* Free existing side data*/
4250 for (i = 0; i < dst->nb_side_data; i++)
4251 av_free(dst->side_data[i].data);
4252 av_freep(&dst->side_data);
4253 dst->nb_side_data = 0;
4255 /* Copy side data if present */
4256 if (src->nb_side_data) {
4257 dst->side_data = av_mallocz_array(src->nb_side_data,
4258 sizeof(AVPacketSideData));
4259 if (!dst->side_data)
4260 return AVERROR(ENOMEM);
4261 dst->nb_side_data = src->nb_side_data;
4263 for (i = 0; i < src->nb_side_data; i++) {
4264 uint8_t *data = av_memdup(src->side_data[i].data,
4265 src->side_data[i].size);
4267 return AVERROR(ENOMEM);
4268 dst->side_data[i].type = src->side_data[i].type;
4269 dst->side_data[i].size = src->side_data[i].size;
4270 dst->side_data[i].data = data;
4274 #if FF_API_LAVF_FFSERVER
4275 FF_DISABLE_DEPRECATION_WARNINGS
4276 av_freep(&dst->recommended_encoder_configuration);
4277 if (src->recommended_encoder_configuration) {
4278 const char *conf_str = src->recommended_encoder_configuration;
4279 dst->recommended_encoder_configuration = av_strdup(conf_str);
4280 if (!dst->recommended_encoder_configuration)
4281 return AVERROR(ENOMEM);
4283 FF_ENABLE_DEPRECATION_WARNINGS
4289 static void free_stream(AVStream **pst)
4291 AVStream *st = *pst;
4297 for (i = 0; i < st->nb_side_data; i++)
4298 av_freep(&st->side_data[i].data);
4299 av_freep(&st->side_data);
4302 av_parser_close(st->parser);
4304 if (st->attached_pic.data)
4305 av_packet_unref(&st->attached_pic);
4308 avcodec_free_context(&st->internal->avctx);
4309 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4310 av_bsf_free(&st->internal->bsfcs[i]);
4311 av_freep(&st->internal->bsfcs);
4313 av_freep(&st->internal->priv_pts);
4314 av_bsf_free(&st->internal->extract_extradata.bsf);
4315 av_packet_free(&st->internal->extract_extradata.pkt);
4317 av_freep(&st->internal);
4319 av_dict_free(&st->metadata);
4320 avcodec_parameters_free(&st->codecpar);
4321 av_freep(&st->probe_data.buf);
4322 av_freep(&st->index_entries);
4323 #if FF_API_LAVF_AVCTX
4324 FF_DISABLE_DEPRECATION_WARNINGS
4325 avcodec_free_context(&st->codec);
4326 FF_ENABLE_DEPRECATION_WARNINGS
4328 av_freep(&st->priv_data);
4330 av_freep(&st->info->duration_error);
4331 av_freep(&st->info);
4332 #if FF_API_LAVF_FFSERVER
4333 FF_DISABLE_DEPRECATION_WARNINGS
4334 av_freep(&st->recommended_encoder_configuration);
4335 FF_ENABLE_DEPRECATION_WARNINGS
4341 void ff_free_stream(AVFormatContext *s, AVStream *st)
4343 av_assert0(s->nb_streams>0);
4344 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4346 free_stream(&s->streams[ --s->nb_streams ]);
4349 void avformat_free_context(AVFormatContext *s)
4357 if (s->iformat && s->iformat->priv_class && s->priv_data)
4358 av_opt_free(s->priv_data);
4359 if (s->oformat && s->oformat->priv_class && s->priv_data)
4360 av_opt_free(s->priv_data);
4362 for (i = s->nb_streams - 1; i >= 0; i--)
4363 ff_free_stream(s, s->streams[i]);
4366 for (i = s->nb_programs - 1; i >= 0; i--) {
4367 av_dict_free(&s->programs[i]->metadata);
4368 av_freep(&s->programs[i]->stream_index);
4369 av_freep(&s->programs[i]);
4371 av_freep(&s->programs);
4372 av_freep(&s->priv_data);
4373 while (s->nb_chapters--) {
4374 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4375 av_freep(&s->chapters[s->nb_chapters]);
4377 av_freep(&s->chapters);
4378 av_dict_free(&s->metadata);
4379 av_dict_free(&s->internal->id3v2_meta);
4380 av_freep(&s->streams);
4381 flush_packet_queue(s);
4382 av_freep(&s->internal);
4387 void avformat_close_input(AVFormatContext **ps)
4398 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4399 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4402 flush_packet_queue(s);
4405 if (s->iformat->read_close)
4406 s->iformat->read_close(s);
4408 avformat_free_context(s);
4415 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4421 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4422 if (s->max_streams < INT_MAX/sizeof(*streams))
4423 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);
4426 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4429 s->streams = streams;
4431 st = av_mallocz(sizeof(AVStream));
4434 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4438 st->info->last_dts = AV_NOPTS_VALUE;
4440 #if FF_API_LAVF_AVCTX
4441 FF_DISABLE_DEPRECATION_WARNINGS
4442 st->codec = avcodec_alloc_context3(c);
4448 FF_ENABLE_DEPRECATION_WARNINGS
4451 st->internal = av_mallocz(sizeof(*st->internal));
4455 st->codecpar = avcodec_parameters_alloc();
4459 st->internal->avctx = avcodec_alloc_context3(NULL);
4460 if (!st->internal->avctx)
4464 #if FF_API_LAVF_AVCTX
4465 FF_DISABLE_DEPRECATION_WARNINGS
4466 /* no default bitrate if decoding */
4467 st->codec->bit_rate = 0;
4468 FF_ENABLE_DEPRECATION_WARNINGS
4471 /* default pts setting is MPEG-like */
4472 avpriv_set_pts_info(st, 33, 1, 90000);
4473 /* we set the current DTS to 0 so that formats without any timestamps
4474 * but durations get some timestamps, formats with some unknown
4475 * timestamps have their first few packets buffered and the
4476 * timestamps corrected before they are returned to the user */
4477 st->cur_dts = RELATIVE_TS_BASE;
4479 st->cur_dts = AV_NOPTS_VALUE;
4482 st->index = s->nb_streams;
4483 st->start_time = AV_NOPTS_VALUE;
4484 st->duration = AV_NOPTS_VALUE;
4485 st->first_dts = AV_NOPTS_VALUE;
4486 st->probe_packets = MAX_PROBE_PACKETS;
4487 st->pts_wrap_reference = AV_NOPTS_VALUE;
4488 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4490 st->last_IP_pts = AV_NOPTS_VALUE;
4491 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4492 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4493 st->pts_buffer[i] = AV_NOPTS_VALUE;
4495 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4497 #if FF_API_R_FRAME_RATE
4498 st->info->last_dts = AV_NOPTS_VALUE;
4500 st->info->fps_first_dts = AV_NOPTS_VALUE;
4501 st->info->fps_last_dts = AV_NOPTS_VALUE;
4503 st->inject_global_side_data = s->internal->inject_global_side_data;
4505 st->internal->need_context_update = 1;
4507 s->streams[s->nb_streams++] = st;
4514 AVProgram *av_new_program(AVFormatContext *ac, int id)
4516 AVProgram *program = NULL;
4519 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4521 for (i = 0; i < ac->nb_programs; i++)
4522 if (ac->programs[i]->id == id)
4523 program = ac->programs[i];
4526 program = av_mallocz(sizeof(AVProgram));
4529 dynarray_add(&ac->programs, &ac->nb_programs, program);
4530 program->discard = AVDISCARD_NONE;
4533 program->pts_wrap_reference = AV_NOPTS_VALUE;
4534 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4536 program->start_time =
4537 program->end_time = AV_NOPTS_VALUE;
4542 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4543 int64_t start, int64_t end, const char *title)
4545 AVChapter *chapter = NULL;
4548 if (end != AV_NOPTS_VALUE && start > end) {
4549 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4553 for (i = 0; i < s->nb_chapters; i++)
4554 if (s->chapters[i]->id == id)
4555 chapter = s->chapters[i];
4558 chapter = av_mallocz(sizeof(AVChapter));
4561 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4563 av_dict_set(&chapter->metadata, "title", title, 0);
4565 chapter->time_base = time_base;
4566 chapter->start = start;
4572 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4575 AVProgram *program = NULL;
4578 if (idx >= ac->nb_streams) {
4579 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4583 for (i = 0; i < ac->nb_programs; i++) {
4584 if (ac->programs[i]->id != progid)
4586 program = ac->programs[i];
4587 for (j = 0; j < program->nb_stream_indexes; j++)
4588 if (program->stream_index[j] == idx)
4591 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4594 program->stream_index = tmp;
4595 program->stream_index[program->nb_stream_indexes++] = idx;
4600 uint64_t ff_ntp_time(void)
4602 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4605 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4608 char *q, buf1[20], c;
4609 int nd, len, percentd_found;
4621 while (av_isdigit(*p))
4622 nd = nd * 10 + *p++ - '0';
4624 } while (av_isdigit(c));
4630 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4635 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4637 if ((q - buf + len) > buf_size - 1)
4639 memcpy(q, buf1, len);
4647 if ((q - buf) < buf_size - 1)
4651 if (!percentd_found)
4660 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4662 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4665 void av_url_split(char *proto, int proto_size,
4666 char *authorization, int authorization_size,
4667 char *hostname, int hostname_size,
4668 int *port_ptr, char *path, int path_size, const char *url)
4670 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4676 if (authorization_size > 0)
4677 authorization[0] = 0;
4678 if (hostname_size > 0)
4683 /* parse protocol */
4684 if ((p = strchr(url, ':'))) {
4685 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4692 /* no protocol means plain filename */
4693 av_strlcpy(path, url, path_size);
4697 /* separate path from hostname */
4698 ls = strchr(p, '/');
4699 ls2 = strchr(p, '?');
4703 ls = FFMIN(ls, ls2);
4705 av_strlcpy(path, ls, path_size);
4707 ls = &p[strlen(p)]; // XXX
4709 /* the rest is hostname, use that to parse auth/port */
4711 /* authorization (user[:pass]@hostname) */
4713 while ((at = strchr(p, '@')) && at < ls) {
4714 av_strlcpy(authorization, at2,
4715 FFMIN(authorization_size, at + 1 - at2));
4716 p = at + 1; /* skip '@' */
4719 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4721 av_strlcpy(hostname, p + 1,
4722 FFMIN(hostname_size, brk - p));
4723 if (brk[1] == ':' && port_ptr)
4724 *port_ptr = atoi(brk + 2);
4725 } else if ((col = strchr(p, ':')) && col < ls) {
4726 av_strlcpy(hostname, p,
4727 FFMIN(col + 1 - p, hostname_size));
4729 *port_ptr = atoi(col + 1);
4731 av_strlcpy(hostname, p,
4732 FFMIN(ls + 1 - p, hostname_size));
4736 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4739 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4742 'C', 'D', 'E', 'F' };
4743 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4746 'c', 'd', 'e', 'f' };
4747 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4749 for (i = 0; i < s; i++) {
4750 buff[i * 2] = hex_table[src[i] >> 4];
4751 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4757 int ff_hex_to_data(uint8_t *data, const char *p)
4764 p += strspn(p, SPACE_CHARS);
4767 c = av_toupper((unsigned char) *p++);
4768 if (c >= '0' && c <= '9')
4770 else if (c >= 'A' && c <= 'F')
4785 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4786 unsigned int pts_num, unsigned int pts_den)
4789 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4790 if (new_tb.num != pts_num)
4791 av_log(NULL, AV_LOG_DEBUG,
4792 "st:%d removing common factor %d from timebase\n",
4793 s->index, pts_num / new_tb.num);
4795 av_log(NULL, AV_LOG_WARNING,
4796 "st:%d has too large timebase, reducing\n", s->index);
4798 if (new_tb.num <= 0 || new_tb.den <= 0) {
4799 av_log(NULL, AV_LOG_ERROR,
4800 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4801 new_tb.num, new_tb.den,
4805 s->time_base = new_tb;
4806 #if FF_API_LAVF_AVCTX
4807 FF_DISABLE_DEPRECATION_WARNINGS
4808 s->codec->pkt_timebase = new_tb;
4809 FF_ENABLE_DEPRECATION_WARNINGS
4811 s->internal->avctx->pkt_timebase = new_tb;
4812 s->pts_wrap_bits = pts_wrap_bits;
4815 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4818 const char *ptr = str;
4820 /* Parse key=value pairs. */
4823 char *dest = NULL, *dest_end;
4824 int key_len, dest_len = 0;
4826 /* Skip whitespace and potential commas. */
4827 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4834 if (!(ptr = strchr(key, '=')))
4837 key_len = ptr - key;
4839 callback_get_buf(context, key, key_len, &dest, &dest_len);
4840 dest_end = dest + dest_len - 1;
4844 while (*ptr && *ptr != '\"') {
4848 if (dest && dest < dest_end)
4852 if (dest && dest < dest_end)
4860 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4861 if (dest && dest < dest_end)
4869 int ff_find_stream_index(AVFormatContext *s, int id)
4872 for (i = 0; i < s->nb_streams; i++)
4873 if (s->streams[i]->id == id)
4878 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4882 unsigned int codec_tag;
4883 if (ofmt->query_codec)
4884 return ofmt->query_codec(codec_id, std_compliance);
4885 else if (ofmt->codec_tag)
4886 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4887 else if (codec_id == ofmt->video_codec ||
4888 codec_id == ofmt->audio_codec ||
4889 codec_id == ofmt->subtitle_codec ||
4890 codec_id == ofmt->data_codec)
4893 return AVERROR_PATCHWELCOME;
4896 int avformat_network_init(void)
4900 if ((ret = ff_network_init()) < 0)
4902 if ((ret = ff_tls_init()) < 0)
4908 int avformat_network_deinit(void)
4917 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4918 uint64_t channel_layout, int32_t sample_rate,
4919 int32_t width, int32_t height)
4925 return AVERROR(EINVAL);
4928 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4930 if (channel_layout) {
4932 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4936 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4938 if (width || height) {
4940 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4942 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4944 return AVERROR(ENOMEM);
4945 bytestream_put_le32(&data, flags);
4947 bytestream_put_le32(&data, channels);
4949 bytestream_put_le64(&data, channel_layout);
4951 bytestream_put_le32(&data, sample_rate);
4952 if (width || height) {
4953 bytestream_put_le32(&data, width);
4954 bytestream_put_le32(&data, height);
4959 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4961 AVRational undef = {0, 1};
4962 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4963 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4964 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4966 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4967 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4968 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4969 stream_sample_aspect_ratio = undef;
4971 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4972 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4973 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4974 frame_sample_aspect_ratio = undef;
4976 if (stream_sample_aspect_ratio.num)
4977 return stream_sample_aspect_ratio;
4979 return frame_sample_aspect_ratio;
4982 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4984 AVRational fr = st->r_frame_rate;
4985 AVRational codec_fr = st->internal->avctx->framerate;
4986 AVRational avg_fr = st->avg_frame_rate;
4988 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4989 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4994 if (st->internal->avctx->ticks_per_frame > 1) {
4995 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4996 (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))
5003 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5006 if (*spec <= '9' && *spec >= '0') /* opt:index */
5007 return strtol(spec, NULL, 0) == st->index;
5008 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5009 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5010 enum AVMediaType type;
5014 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5015 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5016 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5017 case 'd': type = AVMEDIA_TYPE_DATA; break;
5018 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5019 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5020 default: av_assert0(0);
5022 #if FF_API_LAVF_AVCTX
5023 FF_DISABLE_DEPRECATION_WARNINGS
5024 if (type != st->codecpar->codec_type
5025 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5027 FF_ENABLE_DEPRECATION_WARNINGS
5029 if (type != st->codecpar->codec_type)
5032 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5034 if (*spec++ == ':') { /* possibly followed by :index */
5035 int i, index = strtol(spec, NULL, 0);
5036 for (i = 0; i < s->nb_streams; i++) {
5037 #if FF_API_LAVF_AVCTX
5038 FF_DISABLE_DEPRECATION_WARNINGS
5039 if ((s->streams[i]->codecpar->codec_type == type
5040 || s->streams[i]->codec->codec_type == type
5042 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5044 return i == st->index;
5045 FF_ENABLE_DEPRECATION_WARNINGS
5047 if ((s->streams[i]->codecpar->codec_type == type) &&
5048 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5050 return i == st->index;
5056 } else if (*spec == 'p' && *(spec + 1) == ':') {
5060 prog_id = strtol(spec, &endptr, 0);
5061 for (i = 0; i < s->nb_programs; i++) {
5062 if (s->programs[i]->id != prog_id)
5065 if (*endptr++ == ':') {
5066 int stream_idx = strtol(endptr, NULL, 0);
5067 return stream_idx >= 0 &&
5068 stream_idx < s->programs[i]->nb_stream_indexes &&
5069 st->index == s->programs[i]->stream_index[stream_idx];
5072 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5073 if (st->index == s->programs[i]->stream_index[j])
5077 } else if (*spec == '#' ||
5078 (*spec == 'i' && *(spec + 1) == ':')) {
5081 spec += 1 + (*spec == 'i');
5082 stream_id = strtol(spec, &endptr, 0);
5084 return stream_id == st->id;
5085 } else if (*spec == 'm' && *(spec + 1) == ':') {
5086 AVDictionaryEntry *tag;
5091 val = strchr(spec, ':');
5093 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5095 return AVERROR(ENOMEM);
5097 tag = av_dict_get(st->metadata, key, NULL, 0);
5099 if (!val || !strcmp(tag->value, val + 1))
5108 } else if (*spec == 'u') {
5109 AVCodecParameters *par = st->codecpar;
5110 #if FF_API_LAVF_AVCTX
5111 FF_DISABLE_DEPRECATION_WARNINGS
5112 AVCodecContext *codec = st->codec;
5113 FF_ENABLE_DEPRECATION_WARNINGS
5116 switch (par->codec_type) {
5117 case AVMEDIA_TYPE_AUDIO:
5118 val = par->sample_rate && par->channels;
5119 #if FF_API_LAVF_AVCTX
5120 val = val || (codec->sample_rate && codec->channels);
5122 if (par->format == AV_SAMPLE_FMT_NONE
5123 #if FF_API_LAVF_AVCTX
5124 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5129 case AVMEDIA_TYPE_VIDEO:
5130 val = par->width && par->height;
5131 #if FF_API_LAVF_AVCTX
5132 val = val || (codec->width && codec->height);
5134 if (par->format == AV_PIX_FMT_NONE
5135 #if FF_API_LAVF_AVCTX
5136 && codec->pix_fmt == AV_PIX_FMT_NONE
5141 case AVMEDIA_TYPE_UNKNOWN:
5148 #if FF_API_LAVF_AVCTX
5149 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5151 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5153 } else if (!*spec) /* empty specifier, matches everything */
5156 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5157 return AVERROR(EINVAL);
5160 int ff_generate_avci_extradata(AVStream *st)
5162 static const uint8_t avci100_1080p_extradata[] = {
5164 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5165 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5166 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5167 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5168 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5169 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5170 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5171 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5172 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5174 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5177 static const uint8_t avci100_1080i_extradata[] = {
5179 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5180 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5181 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5182 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5183 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5184 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5185 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5186 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5187 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5188 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5189 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5191 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5194 static const uint8_t avci50_1080p_extradata[] = {
5196 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5197 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5198 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5199 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5200 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5201 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5202 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5203 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5204 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5206 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5209 static const uint8_t avci50_1080i_extradata[] = {
5211 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5212 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5213 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5214 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5215 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5216 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5217 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5218 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5219 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5220 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5221 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5223 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5226 static const uint8_t avci100_720p_extradata[] = {
5228 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5229 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5230 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5231 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5232 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5233 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5234 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5235 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5236 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5237 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5239 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5242 static const uint8_t avci50_720p_extradata[] = {
5244 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5245 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5246 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5247 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5248 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5249 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5250 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5251 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5252 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5254 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5258 const uint8_t *data = NULL;
5261 if (st->codecpar->width == 1920) {
5262 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5263 data = avci100_1080p_extradata;
5264 size = sizeof(avci100_1080p_extradata);
5266 data = avci100_1080i_extradata;
5267 size = sizeof(avci100_1080i_extradata);
5269 } else if (st->codecpar->width == 1440) {
5270 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5271 data = avci50_1080p_extradata;
5272 size = sizeof(avci50_1080p_extradata);
5274 data = avci50_1080i_extradata;
5275 size = sizeof(avci50_1080i_extradata);
5277 } else if (st->codecpar->width == 1280) {
5278 data = avci100_720p_extradata;
5279 size = sizeof(avci100_720p_extradata);
5280 } else if (st->codecpar->width == 960) {
5281 data = avci50_720p_extradata;
5282 size = sizeof(avci50_720p_extradata);
5288 av_freep(&st->codecpar->extradata);
5289 if (ff_alloc_extradata(st->codecpar, size))
5290 return AVERROR(ENOMEM);
5291 memcpy(st->codecpar->extradata, data, size);
5296 uint8_t *av_stream_get_side_data(const AVStream *st,
5297 enum AVPacketSideDataType type, int *size)
5301 for (i = 0; i < st->nb_side_data; i++) {
5302 if (st->side_data[i].type == type) {
5304 *size = st->side_data[i].size;
5305 return st->side_data[i].data;
5311 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5312 uint8_t *data, size_t size)
5314 AVPacketSideData *sd, *tmp;
5317 for (i = 0; i < st->nb_side_data; i++) {
5318 sd = &st->side_data[i];
5320 if (sd->type == type) {
5321 av_freep(&sd->data);
5328 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5329 return AVERROR(ERANGE);
5331 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5333 return AVERROR(ENOMEM);
5336 st->side_data = tmp;
5339 sd = &st->side_data[st->nb_side_data - 1];
5347 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5351 uint8_t *data = av_malloc(size);
5356 ret = av_stream_add_side_data(st, type, data, size);
5365 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5368 const AVBitStreamFilter *bsf;
5370 AVCodecParameters *in_par;
5372 if (!(bsf = av_bsf_get_by_name(name))) {
5373 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5374 return AVERROR_BSF_NOT_FOUND;
5377 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5380 if (st->internal->nb_bsfcs) {
5381 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5382 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5384 in_par = st->codecpar;
5385 bsfc->time_base_in = st->time_base;
5388 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5393 if (args && bsfc->filter->priv_class) {
5394 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5395 const char * shorthand[2] = {NULL};
5398 shorthand[0] = opt->name;
5400 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5406 if ((ret = av_bsf_init(bsfc)) < 0) {
5411 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5416 av_log(NULL, AV_LOG_VERBOSE,
5417 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5418 name, args ? args : "");
5423 FF_DISABLE_DEPRECATION_WARNINGS
5424 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5425 AVBitStreamFilterContext *bsfc)
5429 AVPacket new_pkt = *pkt;
5430 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5431 &new_pkt.data, &new_pkt.size,
5432 pkt->data, pkt->size,
5433 pkt->flags & AV_PKT_FLAG_KEY);
5434 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5435 av_packet_unref(pkt);
5436 memset(pkt, 0, sizeof(*pkt));
5439 if(a == 0 && new_pkt.data != pkt->data) {
5440 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
5442 memcpy(t, new_pkt.data, new_pkt.size);
5443 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5448 a = AVERROR(ENOMEM);
5452 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5453 av_buffer_default_free, NULL, 0);
5455 pkt->side_data = NULL;
5456 pkt->side_data_elems = 0;
5457 av_packet_unref(pkt);
5459 av_freep(&new_pkt.data);
5460 a = AVERROR(ENOMEM);
5464 av_log(codec, AV_LOG_ERROR,
5465 "Failed to open bitstream filter %s for stream %d with codec %s",
5466 bsfc->filter->name, pkt->stream_index,
5467 codec->codec ? codec->codec->name : "copy");
5477 FF_ENABLE_DEPRECATION_WARNINGS
5480 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5483 return AVERROR(EINVAL);
5485 if (!(s->oformat->flags & AVFMT_NOFILE))
5486 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5490 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5493 s->io_close(s, *pb);
5497 int ff_is_http_proto(char *filename) {
5498 const char *proto = avio_find_protocol_name(filename);
5499 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5502 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5504 AVDictionaryEntry *entry;
5505 int64_t parsed_timestamp;
5507 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5508 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5509 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5512 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5519 int ff_standardize_creation_time(AVFormatContext *s)
5522 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5524 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5528 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5533 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5535 if (size != AVPALETTE_SIZE) {
5536 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5537 return AVERROR_INVALIDDATA;
5539 memcpy(palette, side_data, AVPALETTE_SIZE);
5543 if (ret == CONTAINS_PAL) {
5545 for (i = 0; i < AVPALETTE_COUNT; i++)
5546 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5553 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5558 ret = av_bprint_finalize(buf, &str);
5561 if (!av_bprint_is_complete(buf)) {
5563 return AVERROR(ENOMEM);
5566 par->extradata = str;
5567 /* Note: the string is NUL terminated (so extradata can be read as a
5568 * string), but the ending character is not accounted in the size (in
5569 * binary formats you are likely not supposed to mux that character). When
5570 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5572 par->extradata_size = buf->len;
5576 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5577 AVStream *ost, const AVStream *ist,
5578 enum AVTimebaseSource copy_tb)
5580 //TODO: use [io]st->internal->avctx
5581 const AVCodecContext *dec_ctx = ist->codec;
5582 AVCodecContext *enc_ctx = ost->codec;
5584 enc_ctx->time_base = ist->time_base;
5586 * Avi is a special case here because it supports variable fps but
5587 * having the fps and timebase differe significantly adds quite some
5590 if (!strcmp(ofmt->name, "avi")) {
5591 #if FF_API_R_FRAME_RATE
5592 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5593 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5594 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5595 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5596 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5597 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5598 enc_ctx->time_base.num = ist->r_frame_rate.den;
5599 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5600 enc_ctx->ticks_per_frame = 2;
5603 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5604 && av_q2d(ist->time_base) < 1.0/500
5605 || copy_tb == AVFMT_TBCF_DECODER) {
5606 enc_ctx->time_base = dec_ctx->time_base;
5607 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5608 enc_ctx->time_base.den *= 2;
5609 enc_ctx->ticks_per_frame = 2;
5611 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5612 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5613 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5614 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5615 && av_q2d(ist->time_base) < 1.0/500
5616 || copy_tb == AVFMT_TBCF_DECODER) {
5617 enc_ctx->time_base = dec_ctx->time_base;
5618 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5622 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5623 && dec_ctx->time_base.num < dec_ctx->time_base.den
5624 && dec_ctx->time_base.num > 0
5625 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5626 enc_ctx->time_base = dec_ctx->time_base;
5629 if (ost->avg_frame_rate.num)
5630 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5632 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5633 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5638 AVRational av_stream_get_codec_timebase(const AVStream *st)
5640 // See avformat_transfer_internal_stream_timing_info() TODO.
5641 #if FF_API_LAVF_AVCTX
5642 FF_DISABLE_DEPRECATION_WARNINGS
5643 return st->codec->time_base;
5644 FF_ENABLE_DEPRECATION_WARNINGS
5646 return st->internal->avctx->time_base;
5650 void ff_format_set_url(AVFormatContext *s, char *url)
5655 #if FF_API_FORMAT_FILENAME
5656 FF_DISABLE_DEPRECATION_WARNINGS
5657 av_strlcpy(s->filename, url, sizeof(s->filename));
5658 FF_ENABLE_DEPRECATION_WARNINGS