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 int orig_size = pkt->size;
275 int prev_size = pkt->size;
278 /* When the caller requests a lot of data, limit it to the amount
279 * left in file or SANE_CHUNK_SIZE when it is not known. */
281 if (read_size > SANE_CHUNK_SIZE/10) {
282 read_size = ffio_limit(s, read_size);
283 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
285 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
288 ret = av_grow_packet(pkt, read_size);
292 ret = avio_read(s, pkt->data + prev_size, read_size);
293 if (ret != read_size) {
294 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
301 pkt->flags |= AV_PKT_FLAG_CORRUPT;
304 av_packet_unref(pkt);
305 return pkt->size > orig_size ? pkt->size - orig_size : ret;
308 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
313 pkt->pos = avio_tell(s);
315 return append_packet_chunked(s, pkt, size);
318 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
321 return av_get_packet(s, pkt, size);
322 return append_packet_chunked(s, pkt, size);
325 int av_filename_number_test(const char *filename)
329 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
332 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
335 static const struct {
338 enum AVMediaType type;
340 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
341 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
342 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
343 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
344 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
345 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
346 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
347 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
348 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
349 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
350 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
351 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
352 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
353 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
354 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
358 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
362 av_log(s, AV_LOG_DEBUG,
363 "Probe with size=%d, packets=%d detected %s with score=%d\n",
364 pd->buf_size, s->max_probe_packets - st->probe_packets,
366 for (i = 0; fmt_id_type[i].name; i++) {
367 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
368 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
369 st->codecpar->sample_rate)
371 if (st->request_probe > score &&
372 st->codecpar->codec_id != fmt_id_type[i].id)
374 st->codecpar->codec_id = fmt_id_type[i].id;
375 st->codecpar->codec_type = fmt_id_type[i].type;
376 st->internal->need_context_update = 1;
377 #if FF_API_LAVF_AVCTX
378 FF_DISABLE_DEPRECATION_WARNINGS
379 st->codec->codec_type = st->codecpar->codec_type;
380 st->codec->codec_id = st->codecpar->codec_id;
381 FF_ENABLE_DEPRECATION_WARNINGS
390 /************************************************************/
391 /* input media file */
393 int av_demuxer_open(AVFormatContext *ic) {
396 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
397 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
398 return AVERROR(EINVAL);
401 if (ic->iformat->read_header) {
402 err = ic->iformat->read_header(ic);
407 if (ic->pb && !ic->internal->data_offset)
408 ic->internal->data_offset = avio_tell(ic->pb);
413 /* Open input file and probe the format if necessary. */
414 static int init_input(AVFormatContext *s, const char *filename,
415 AVDictionary **options)
418 AVProbeData pd = { filename, NULL, 0 };
419 int score = AVPROBE_SCORE_RETRY;
422 s->flags |= AVFMT_FLAG_CUSTOM_IO;
424 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
425 s, 0, s->format_probesize);
426 else if (s->iformat->flags & AVFMT_NOFILE)
427 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
428 "will be ignored with AVFMT_NOFILE format.\n");
432 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
433 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
436 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
441 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
442 s, 0, s->format_probesize);
445 int ff_packet_list_put(AVPacketList **packet_buffer,
446 AVPacketList **plast_pktl,
447 AVPacket *pkt, int flags)
449 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
453 return AVERROR(ENOMEM);
455 if (flags & FF_PACKETLIST_FLAG_REF_PACKET) {
456 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
461 ret = av_packet_make_refcounted(pkt);
466 av_packet_move_ref(&pktl->pkt, pkt);
470 (*plast_pktl)->next = pktl;
472 *packet_buffer = pktl;
474 /* Add the packet in the buffered packet list. */
479 int avformat_queue_attached_pictures(AVFormatContext *s)
482 for (i = 0; i < s->nb_streams; i++)
483 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
484 s->streams[i]->discard < AVDISCARD_ALL) {
485 if (s->streams[i]->attached_pic.size <= 0) {
486 av_log(s, AV_LOG_WARNING,
487 "Attached picture on stream %d has invalid size, "
492 ret = ff_packet_list_put(&s->internal->raw_packet_buffer,
493 &s->internal->raw_packet_buffer_end,
494 &s->streams[i]->attached_pic,
495 FF_PACKETLIST_FLAG_REF_PACKET);
502 static int update_stream_avctx(AVFormatContext *s)
505 for (i = 0; i < s->nb_streams; i++) {
506 AVStream *st = s->streams[i];
508 if (!st->internal->need_context_update)
511 /* close parser, because it depends on the codec */
512 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
513 av_parser_close(st->parser);
517 /* update internal codec context, for the parser */
518 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
522 #if FF_API_LAVF_AVCTX
523 FF_DISABLE_DEPRECATION_WARNINGS
524 /* update deprecated public codec context */
525 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
528 FF_ENABLE_DEPRECATION_WARNINGS
531 st->internal->need_context_update = 0;
537 int avformat_open_input(AVFormatContext **ps, const char *filename,
538 ff_const59 AVInputFormat *fmt, AVDictionary **options)
540 AVFormatContext *s = *ps;
542 AVDictionary *tmp = NULL;
543 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
545 if (!s && !(s = avformat_alloc_context()))
546 return AVERROR(ENOMEM);
548 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
549 return AVERROR(EINVAL);
555 av_dict_copy(&tmp, *options, 0);
557 if (s->pb) // must be before any goto fail
558 s->flags |= AVFMT_FLAG_CUSTOM_IO;
560 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
563 if (!(s->url = av_strdup(filename ? filename : ""))) {
564 ret = AVERROR(ENOMEM);
568 #if FF_API_FORMAT_FILENAME
569 FF_DISABLE_DEPRECATION_WARNINGS
570 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
571 FF_ENABLE_DEPRECATION_WARNINGS
573 if ((ret = init_input(s, filename, &tmp)) < 0)
575 s->probe_score = ret;
577 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
578 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
579 if (!s->protocol_whitelist) {
580 ret = AVERROR(ENOMEM);
585 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
586 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
587 if (!s->protocol_blacklist) {
588 ret = AVERROR(ENOMEM);
593 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
594 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
595 ret = AVERROR(EINVAL);
599 avio_skip(s->pb, s->skip_initial_bytes);
601 /* Check filename in case an image number is expected. */
602 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
603 if (!av_filename_number_test(filename)) {
604 ret = AVERROR(EINVAL);
609 s->duration = s->start_time = AV_NOPTS_VALUE;
611 /* Allocate private data. */
612 if (s->iformat->priv_data_size > 0) {
613 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
614 ret = AVERROR(ENOMEM);
617 if (s->iformat->priv_class) {
618 *(const AVClass **) s->priv_data = s->iformat->priv_class;
619 av_opt_set_defaults(s->priv_data);
620 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
625 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
627 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
630 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
631 if ((ret = s->iformat->read_header(s)) < 0)
635 s->metadata = s->internal->id3v2_meta;
636 s->internal->id3v2_meta = NULL;
637 } else if (s->internal->id3v2_meta) {
638 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
639 av_dict_free(&s->internal->id3v2_meta);
642 if (id3v2_extra_meta) {
643 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
644 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
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 if (s->iformat->read_close)
678 s->iformat->read_close(s);
680 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
682 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
684 avformat_free_context(s);
689 /*******************************************************/
691 static void force_codec_ids(AVFormatContext *s, AVStream *st)
693 switch (st->codecpar->codec_type) {
694 case AVMEDIA_TYPE_VIDEO:
695 if (s->video_codec_id)
696 st->codecpar->codec_id = s->video_codec_id;
698 case AVMEDIA_TYPE_AUDIO:
699 if (s->audio_codec_id)
700 st->codecpar->codec_id = s->audio_codec_id;
702 case AVMEDIA_TYPE_SUBTITLE:
703 if (s->subtitle_codec_id)
704 st->codecpar->codec_id = s->subtitle_codec_id;
706 case AVMEDIA_TYPE_DATA:
707 if (s->data_codec_id)
708 st->codecpar->codec_id = s->data_codec_id;
713 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
715 if (st->request_probe>0) {
716 AVProbeData *pd = &st->probe_data;
718 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
722 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
724 av_log(s, AV_LOG_WARNING,
725 "Failed to reallocate probe buffer for stream %d\n",
730 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
731 pd->buf_size += pkt->size;
732 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
735 st->probe_packets = 0;
737 av_log(s, AV_LOG_WARNING,
738 "nothing to probe for stream %d\n", st->index);
742 end= s->internal->raw_packet_buffer_remaining_size <= 0
743 || st->probe_packets<= 0;
745 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
746 int score = set_codec_from_probe_data(s, st, pd);
747 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
751 st->request_probe = -1;
752 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
753 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
755 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
757 force_codec_ids(s, st);
763 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
765 int64_t ref = pkt->dts;
766 int i, pts_wrap_behavior;
767 int64_t pts_wrap_reference;
768 AVProgram *first_program;
770 if (ref == AV_NOPTS_VALUE)
772 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
774 ref &= (1LL << st->pts_wrap_bits)-1;
776 // reference time stamp should be 60 s before first time stamp
777 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
778 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
779 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
780 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
781 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
783 first_program = av_find_program_from_stream(s, NULL, stream_index);
785 if (!first_program) {
786 int default_stream_index = av_find_default_stream_index(s);
787 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
788 for (i = 0; i < s->nb_streams; i++) {
789 if (av_find_program_from_stream(s, NULL, i))
791 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
792 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
796 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
797 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
801 AVProgram *program = first_program;
803 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
804 pts_wrap_reference = program->pts_wrap_reference;
805 pts_wrap_behavior = program->pts_wrap_behavior;
808 program = av_find_program_from_stream(s, program, stream_index);
811 // update every program with differing pts_wrap_reference
812 program = first_program;
814 if (program->pts_wrap_reference != pts_wrap_reference) {
815 for (i = 0; i<program->nb_stream_indexes; i++) {
816 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
817 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
820 program->pts_wrap_reference = pts_wrap_reference;
821 program->pts_wrap_behavior = pts_wrap_behavior;
823 program = av_find_program_from_stream(s, program, stream_index);
829 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
839 AVPacketList *pktl = s->internal->raw_packet_buffer;
840 const AVPacket *pkt1;
843 st = s->streams[pktl->pkt.stream_index];
844 if (s->internal->raw_packet_buffer_remaining_size <= 0)
845 if ((err = probe_codec(s, st, NULL)) < 0)
847 if (st->request_probe <= 0) {
848 ff_packet_list_get(&s->internal->raw_packet_buffer,
849 &s->internal->raw_packet_buffer_end, pkt);
850 s->internal->raw_packet_buffer_remaining_size += pkt->size;
855 ret = s->iformat->read_packet(s, pkt);
857 av_packet_unref(pkt);
859 /* Some demuxers return FFERROR_REDO when they consume
860 data and discard it (ignored streams, junk, extradata).
861 We must re-call the demuxer to get the real packet. */
862 if (ret == FFERROR_REDO)
864 if (!pktl || ret == AVERROR(EAGAIN))
866 for (i = 0; i < s->nb_streams; i++) {
868 if (st->probe_packets || st->request_probe > 0)
869 if ((err = probe_codec(s, st, NULL)) < 0)
871 av_assert0(st->request_probe <= 0);
876 err = av_packet_make_refcounted(pkt);
878 av_packet_unref(pkt);
882 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
883 av_log(s, AV_LOG_WARNING,
884 "Packet corrupt (stream = %d, dts = %s)",
885 pkt->stream_index, av_ts2str(pkt->dts));
886 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
887 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
888 av_packet_unref(pkt);
891 av_log(s, AV_LOG_WARNING, ".\n");
894 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
895 "Invalid stream index.\n");
897 st = s->streams[pkt->stream_index];
899 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
900 // correct first time stamps to negative values
901 if (!is_relative(st->first_dts))
902 st->first_dts = wrap_timestamp(st, st->first_dts);
903 if (!is_relative(st->start_time))
904 st->start_time = wrap_timestamp(st, st->start_time);
905 if (!is_relative(st->cur_dts))
906 st->cur_dts = wrap_timestamp(st, st->cur_dts);
909 pkt->dts = wrap_timestamp(st, pkt->dts);
910 pkt->pts = wrap_timestamp(st, pkt->pts);
912 force_codec_ids(s, st);
914 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
915 if (s->use_wallclock_as_timestamps)
916 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
918 if (!pktl && st->request_probe <= 0)
921 err = ff_packet_list_put(&s->internal->raw_packet_buffer,
922 &s->internal->raw_packet_buffer_end,
925 av_packet_unref(pkt);
928 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
929 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
931 if ((err = probe_codec(s, st, pkt1)) < 0)
937 /**********************************************************/
939 static int determinable_frame_size(AVCodecContext *avctx)
941 switch(avctx->codec_id) {
942 case AV_CODEC_ID_MP1:
943 case AV_CODEC_ID_MP2:
944 case AV_CODEC_ID_MP3:
945 case AV_CODEC_ID_CODEC2:
953 * Return the frame duration in seconds. Return 0 if not available.
955 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
956 AVCodecParserContext *pc, AVPacket *pkt)
958 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
959 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
960 int frame_size, sample_rate;
962 #if FF_API_LAVF_AVCTX
963 FF_DISABLE_DEPRECATION_WARNINGS
964 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
965 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
966 FF_ENABLE_DEPRECATION_WARNINGS
971 switch (st->codecpar->codec_type) {
972 case AVMEDIA_TYPE_VIDEO:
973 if (st->r_frame_rate.num && !pc && s->iformat) {
974 *pnum = st->r_frame_rate.den;
975 *pden = st->r_frame_rate.num;
976 } else if (st->time_base.num * 1000LL > st->time_base.den) {
977 *pnum = st->time_base.num;
978 *pden = st->time_base.den;
979 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
980 av_assert0(st->internal->avctx->ticks_per_frame);
981 av_reduce(pnum, pden,
983 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
986 if (pc && pc->repeat_pict) {
987 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
988 av_reduce(pnum, pden,
989 (*pnum) * (1LL + pc->repeat_pict),
993 /* If this codec can be interlaced or progressive then we need
994 * a parser to compute duration of a packet. Thus if we have
995 * no parser in such case leave duration undefined. */
996 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
1000 case AVMEDIA_TYPE_AUDIO:
1001 if (st->internal->avctx_inited) {
1002 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
1003 sample_rate = st->internal->avctx->sample_rate;
1005 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
1006 sample_rate = st->codecpar->sample_rate;
1008 if (frame_size <= 0 || sample_rate <= 0)
1011 *pden = sample_rate;
1018 static int is_intra_only(enum AVCodecID id)
1020 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1023 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1024 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1029 static int has_decode_delay_been_guessed(AVStream *st)
1031 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1032 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1034 #if CONFIG_H264_DECODER
1035 if (st->internal->avctx->has_b_frames &&
1036 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1039 if (st->internal->avctx->has_b_frames<3)
1040 return st->nb_decoded_frames >= 7;
1041 else if (st->internal->avctx->has_b_frames<4)
1042 return st->nb_decoded_frames >= 18;
1044 return st->nb_decoded_frames >= 20;
1047 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1051 if (pktl == s->internal->packet_buffer_end)
1052 return s->internal->parse_queue;
1056 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1057 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1058 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1061 int delay = st->internal->avctx->has_b_frames;
1064 if (dts == AV_NOPTS_VALUE) {
1065 int64_t best_score = INT64_MAX;
1066 for (i = 0; i<delay; i++) {
1067 if (st->pts_reorder_error_count[i]) {
1068 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1069 if (score < best_score) {
1071 dts = pts_buffer[i];
1076 for (i = 0; i<delay; i++) {
1077 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1078 int64_t diff = FFABS(pts_buffer[i] - dts)
1079 + (uint64_t)st->pts_reorder_error[i];
1080 diff = FFMAX(diff, st->pts_reorder_error[i]);
1081 st->pts_reorder_error[i] = diff;
1082 st->pts_reorder_error_count[i]++;
1083 if (st->pts_reorder_error_count[i] > 250) {
1084 st->pts_reorder_error[i] >>= 1;
1085 st->pts_reorder_error_count[i] >>= 1;
1092 if (dts == AV_NOPTS_VALUE)
1093 dts = pts_buffer[0];
1099 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1100 * of the packets in a window.
1102 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1103 AVPacketList *pkt_buffer)
1105 AVStream *st = s->streams[stream_index];
1106 int delay = st->internal->avctx->has_b_frames;
1109 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1111 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1112 pts_buffer[i] = AV_NOPTS_VALUE;
1114 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1115 if (pkt_buffer->pkt.stream_index != stream_index)
1118 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1119 pts_buffer[0] = pkt_buffer->pkt.pts;
1120 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1121 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1123 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1128 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1129 int64_t dts, int64_t pts, AVPacket *pkt)
1131 AVStream *st = s->streams[stream_index];
1132 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1133 AVPacketList *pktl_it;
1137 if (st->first_dts != AV_NOPTS_VALUE ||
1138 dts == AV_NOPTS_VALUE ||
1139 st->cur_dts == AV_NOPTS_VALUE ||
1140 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1144 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1146 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1148 if (is_relative(pts))
1151 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1152 if (pktl_it->pkt.stream_index != stream_index)
1154 if (is_relative(pktl_it->pkt.pts))
1155 pktl_it->pkt.pts += shift;
1157 if (is_relative(pktl_it->pkt.dts))
1158 pktl_it->pkt.dts += shift;
1160 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1161 st->start_time = pktl_it->pkt.pts;
1162 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1163 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1167 if (has_decode_delay_been_guessed(st)) {
1168 update_dts_from_pts(s, stream_index, pktl);
1171 if (st->start_time == AV_NOPTS_VALUE) {
1172 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1173 st->start_time = pts;
1175 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1176 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1180 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1181 int stream_index, int duration)
1183 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1184 int64_t cur_dts = RELATIVE_TS_BASE;
1186 if (st->first_dts != AV_NOPTS_VALUE) {
1187 if (st->update_initial_durations_done)
1189 st->update_initial_durations_done = 1;
1190 cur_dts = st->first_dts;
1191 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1192 if (pktl->pkt.stream_index == stream_index) {
1193 if (pktl->pkt.pts != pktl->pkt.dts ||
1194 pktl->pkt.dts != AV_NOPTS_VALUE ||
1197 cur_dts -= duration;
1200 if (pktl && pktl->pkt.dts != st->first_dts) {
1201 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1202 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1206 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1209 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1210 st->first_dts = cur_dts;
1211 } else if (st->cur_dts != RELATIVE_TS_BASE)
1214 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1215 if (pktl->pkt.stream_index != stream_index)
1217 if ((pktl->pkt.pts == pktl->pkt.dts ||
1218 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1219 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1220 pktl->pkt.dts == st->first_dts ||
1221 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1222 !pktl->pkt.duration) {
1223 pktl->pkt.dts = cur_dts;
1224 if (!st->internal->avctx->has_b_frames)
1225 pktl->pkt.pts = cur_dts;
1226 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1227 pktl->pkt.duration = duration;
1230 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1233 st->cur_dts = cur_dts;
1236 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1237 AVCodecParserContext *pc, AVPacket *pkt,
1238 int64_t next_dts, int64_t next_pts)
1240 int num, den, presentation_delayed, delay, i;
1242 AVRational duration;
1243 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1244 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1246 if (s->flags & AVFMT_FLAG_NOFILLIN)
1249 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1250 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1251 if (st->last_dts_for_order_check <= pkt->dts) {
1254 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1255 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1257 st->last_dts_for_order_check);
1258 st->dts_misordered++;
1260 if (st->dts_ordered + st->dts_misordered > 250) {
1261 st->dts_ordered >>= 1;
1262 st->dts_misordered >>= 1;
1266 st->last_dts_for_order_check = pkt->dts;
1267 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1268 pkt->dts = AV_NOPTS_VALUE;
1271 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1272 pkt->dts = AV_NOPTS_VALUE;
1274 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1275 && !st->internal->avctx->has_b_frames)
1276 //FIXME Set low_delay = 0 when has_b_frames = 1
1277 st->internal->avctx->has_b_frames = 1;
1279 /* do we have a video B-frame ? */
1280 delay = st->internal->avctx->has_b_frames;
1281 presentation_delayed = 0;
1283 /* XXX: need has_b_frame, but cannot get it if the codec is
1284 * not initialized */
1286 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1287 presentation_delayed = 1;
1289 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1290 st->pts_wrap_bits < 63 &&
1291 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1292 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1293 pkt->dts -= 1LL << st->pts_wrap_bits;
1295 pkt->pts += 1LL << st->pts_wrap_bits;
1298 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1299 * We take the conservative approach and discard both.
1300 * Note: If this is misbehaving for an H.264 file, then possibly
1301 * presentation_delayed is not set correctly. */
1302 if (delay == 1 && pkt->dts == pkt->pts &&
1303 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1304 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1305 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1306 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1307 pkt->dts = AV_NOPTS_VALUE;
1310 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1311 if (pkt->duration <= 0) {
1312 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1314 duration = (AVRational) {num, den};
1315 pkt->duration = av_rescale_rnd(1,
1316 num * (int64_t) st->time_base.den,
1317 den * (int64_t) st->time_base.num,
1322 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1323 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1325 /* Correct timestamps with byte offset if demuxers only have timestamps
1326 * on packet boundaries */
1327 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1328 /* this will estimate bitrate based on this frame's duration and size */
1329 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1330 if (pkt->pts != AV_NOPTS_VALUE)
1332 if (pkt->dts != AV_NOPTS_VALUE)
1336 /* This may be redundant, but it should not hurt. */
1337 if (pkt->dts != AV_NOPTS_VALUE &&
1338 pkt->pts != AV_NOPTS_VALUE &&
1339 pkt->pts > pkt->dts)
1340 presentation_delayed = 1;
1342 if (s->debug & FF_FDEBUG_TS)
1343 av_log(s, AV_LOG_DEBUG,
1344 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1345 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1346 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1348 /* Interpolate PTS and DTS if they are not present. We skip H264
1349 * currently because delay and has_b_frames are not reliably set. */
1350 if ((delay == 0 || (delay == 1 && pc)) &&
1352 if (presentation_delayed) {
1353 /* DTS = decompression timestamp */
1354 /* PTS = presentation timestamp */
1355 if (pkt->dts == AV_NOPTS_VALUE)
1356 pkt->dts = st->last_IP_pts;
1357 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1358 if (pkt->dts == AV_NOPTS_VALUE)
1359 pkt->dts = st->cur_dts;
1361 /* This is tricky: the dts must be incremented by the duration
1362 * of the frame we are displaying, i.e. the last I- or P-frame. */
1363 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1364 st->last_IP_duration = pkt->duration;
1365 if (pkt->dts != AV_NOPTS_VALUE)
1366 st->cur_dts = pkt->dts + st->last_IP_duration;
1367 if (pkt->dts != AV_NOPTS_VALUE &&
1368 pkt->pts == AV_NOPTS_VALUE &&
1369 st->last_IP_duration > 0 &&
1370 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1371 next_dts != next_pts &&
1372 next_pts != AV_NOPTS_VALUE)
1373 pkt->pts = next_dts;
1375 if ((uint64_t)pkt->duration <= INT32_MAX)
1376 st->last_IP_duration = pkt->duration;
1377 st->last_IP_pts = pkt->pts;
1378 /* Cannot compute PTS if not present (we can compute it only
1379 * by knowing the future. */
1380 } else if (pkt->pts != AV_NOPTS_VALUE ||
1381 pkt->dts != AV_NOPTS_VALUE ||
1382 pkt->duration > 0 ) {
1384 /* presentation is not delayed : PTS and DTS are the same */
1385 if (pkt->pts == AV_NOPTS_VALUE)
1386 pkt->pts = pkt->dts;
1387 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1389 if (pkt->pts == AV_NOPTS_VALUE)
1390 pkt->pts = st->cur_dts;
1391 pkt->dts = pkt->pts;
1392 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1393 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1397 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1398 st->pts_buffer[0] = pkt->pts;
1399 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1400 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1402 if(has_decode_delay_been_guessed(st))
1403 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1405 // We skipped it above so we try here.
1407 // This should happen on the first packet
1408 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1409 if (pkt->dts > st->cur_dts)
1410 st->cur_dts = pkt->dts;
1412 if (s->debug & FF_FDEBUG_TS)
1413 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1414 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1417 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || is_intra_only(st->codecpar->codec_id))
1418 pkt->flags |= AV_PKT_FLAG_KEY;
1419 #if FF_API_CONVERGENCE_DURATION
1420 FF_DISABLE_DEPRECATION_WARNINGS
1422 pkt->convergence_duration = pc->convergence_duration;
1423 FF_ENABLE_DEPRECATION_WARNINGS
1427 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1429 AVPacketList *tmp = *pkt_buf;
1432 AVPacketList *pktl = tmp;
1434 av_packet_unref(&pktl->pkt);
1438 *pkt_buf_end = NULL;
1442 * Parse a packet, add all split parts to parse_queue.
1444 * @param pkt Packet to parse; must not be NULL.
1445 * @param flush Indicates whether to flush. If set, pkt must be blank.
1447 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1448 int stream_index, int flush)
1451 AVStream *st = s->streams[stream_index];
1452 uint8_t *data = pkt->data;
1453 int size = pkt->size;
1454 int ret = 0, got_output = flush;
1456 if (size || flush) {
1457 av_init_packet(&out_pkt);
1458 } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1459 // preserve 0-size sync packets
1460 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1463 while (size > 0 || (flush && got_output)) {
1465 int64_t next_pts = pkt->pts;
1466 int64_t next_dts = pkt->dts;
1468 len = av_parser_parse2(st->parser, st->internal->avctx,
1469 &out_pkt.data, &out_pkt.size, data, size,
1470 pkt->pts, pkt->dts, pkt->pos);
1472 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1474 /* increment read pointer */
1478 got_output = !!out_pkt.size;
1483 if (pkt->buf && out_pkt.data == pkt->data) {
1484 /* reference pkt->buf only when out_pkt.data is guaranteed to point
1485 * to data in it and not in the parser's internal buffer. */
1486 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1487 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1488 out_pkt.buf = av_buffer_ref(pkt->buf);
1490 ret = AVERROR(ENOMEM);
1494 ret = av_packet_make_refcounted(&out_pkt);
1499 if (pkt->side_data) {
1500 out_pkt.side_data = pkt->side_data;
1501 out_pkt.side_data_elems = pkt->side_data_elems;
1502 pkt->side_data = NULL;
1503 pkt->side_data_elems = 0;
1506 /* set the duration */
1507 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1508 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1509 if (st->internal->avctx->sample_rate > 0) {
1511 av_rescale_q_rnd(st->parser->duration,
1512 (AVRational) { 1, st->internal->avctx->sample_rate },
1518 out_pkt.stream_index = st->index;
1519 out_pkt.pts = st->parser->pts;
1520 out_pkt.dts = st->parser->dts;
1521 out_pkt.pos = st->parser->pos;
1522 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1524 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1525 out_pkt.pos = st->parser->frame_offset;
1527 if (st->parser->key_frame == 1 ||
1528 (st->parser->key_frame == -1 &&
1529 st->parser->pict_type == AV_PICTURE_TYPE_I))
1530 out_pkt.flags |= AV_PKT_FLAG_KEY;
1532 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1533 out_pkt.flags |= AV_PKT_FLAG_KEY;
1535 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1537 ret = ff_packet_list_put(&s->internal->parse_queue,
1538 &s->internal->parse_queue_end,
1541 av_packet_unref(&out_pkt);
1546 /* end of the stream => close and free the parser */
1548 av_parser_close(st->parser);
1553 av_packet_unref(pkt);
1557 int ff_packet_list_get(AVPacketList **pkt_buffer,
1558 AVPacketList **pkt_buffer_end,
1562 av_assert0(*pkt_buffer);
1565 *pkt_buffer = pktl->next;
1567 *pkt_buffer_end = NULL;
1572 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1574 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1577 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1579 int ret, i, got_packet = 0;
1580 AVDictionary *metadata = NULL;
1582 while (!got_packet && !s->internal->parse_queue) {
1585 /* read next packet */
1586 ret = ff_read_packet(s, pkt);
1588 if (ret == AVERROR(EAGAIN))
1590 /* flush the parsers */
1591 for (i = 0; i < s->nb_streams; i++) {
1593 if (st->parser && st->need_parsing)
1594 parse_packet(s, pkt, st->index, 1);
1596 /* all remaining packets are now in parse_queue =>
1597 * really terminate parsing */
1601 st = s->streams[pkt->stream_index];
1603 /* update context if required */
1604 if (st->internal->need_context_update) {
1605 if (avcodec_is_open(st->internal->avctx)) {
1606 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1607 avcodec_close(st->internal->avctx);
1608 st->info->found_decoder = 0;
1611 /* close parser, because it depends on the codec */
1612 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1613 av_parser_close(st->parser);
1617 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1619 av_packet_unref(pkt);
1623 #if FF_API_LAVF_AVCTX
1624 FF_DISABLE_DEPRECATION_WARNINGS
1625 /* update deprecated public codec context */
1626 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1628 av_packet_unref(pkt);
1631 FF_ENABLE_DEPRECATION_WARNINGS
1634 st->internal->need_context_update = 0;
1637 if (pkt->pts != AV_NOPTS_VALUE &&
1638 pkt->dts != AV_NOPTS_VALUE &&
1639 pkt->pts < pkt->dts) {
1640 av_log(s, AV_LOG_WARNING,
1641 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1643 av_ts2str(pkt->pts),
1644 av_ts2str(pkt->dts),
1647 if (s->debug & FF_FDEBUG_TS)
1648 av_log(s, AV_LOG_DEBUG,
1649 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1651 av_ts2str(pkt->pts),
1652 av_ts2str(pkt->dts),
1653 pkt->size, pkt->duration, pkt->flags);
1655 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1656 st->parser = av_parser_init(st->codecpar->codec_id);
1658 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1659 "%s, packets or times may be invalid.\n",
1660 avcodec_get_name(st->codecpar->codec_id));
1661 /* no parser available: just output the raw packets */
1662 st->need_parsing = AVSTREAM_PARSE_NONE;
1663 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1664 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1665 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1666 st->parser->flags |= PARSER_FLAG_ONCE;
1667 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1668 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1671 if (!st->need_parsing || !st->parser) {
1672 /* no parsing needed: we just output the packet as is */
1673 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1674 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1675 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1676 ff_reduce_index(s, st->index);
1677 av_add_index_entry(st, pkt->pos, pkt->dts,
1678 0, 0, AVINDEX_KEYFRAME);
1681 } else if (st->discard < AVDISCARD_ALL) {
1682 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1684 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1685 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1686 st->codecpar->channels = st->internal->avctx->channels;
1687 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1688 st->codecpar->codec_id = st->internal->avctx->codec_id;
1691 av_packet_unref(pkt);
1693 if (pkt->flags & AV_PKT_FLAG_KEY)
1694 st->skip_to_keyframe = 0;
1695 if (st->skip_to_keyframe) {
1696 av_packet_unref(pkt);
1701 if (!got_packet && s->internal->parse_queue)
1702 ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1705 AVStream *st = s->streams[pkt->stream_index];
1706 int discard_padding = 0;
1707 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1708 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1709 int64_t sample = ts_to_samples(st, pts);
1710 int duration = ts_to_samples(st, pkt->duration);
1711 int64_t end_sample = sample + duration;
1712 if (duration > 0 && end_sample >= st->first_discard_sample &&
1713 sample < st->last_discard_sample)
1714 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1716 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1717 st->skip_samples = st->start_skip_samples;
1718 if (st->skip_samples || discard_padding) {
1719 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1721 AV_WL32(p, st->skip_samples);
1722 AV_WL32(p + 4, discard_padding);
1723 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1725 st->skip_samples = 0;
1728 if (st->inject_global_side_data) {
1729 for (i = 0; i < st->nb_side_data; i++) {
1730 AVPacketSideData *src_sd = &st->side_data[i];
1733 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1736 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1738 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1742 memcpy(dst_data, src_sd->data, src_sd->size);
1744 st->inject_global_side_data = 0;
1748 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1750 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1751 av_dict_copy(&s->metadata, metadata, 0);
1752 av_dict_free(&metadata);
1753 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1756 #if FF_API_LAVF_AVCTX
1757 update_stream_avctx(s);
1760 if (s->debug & FF_FDEBUG_TS)
1761 av_log(s, AV_LOG_DEBUG,
1762 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1763 "size=%d, duration=%"PRId64", flags=%d\n",
1765 av_ts2str(pkt->pts),
1766 av_ts2str(pkt->dts),
1767 pkt->size, pkt->duration, pkt->flags);
1769 /* A demuxer might have returned EOF because of an IO error, let's
1770 * propagate this back to the user. */
1771 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1777 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1779 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1785 ret = s->internal->packet_buffer
1786 ? ff_packet_list_get(&s->internal->packet_buffer,
1787 &s->internal->packet_buffer_end, pkt)
1788 : read_frame_internal(s, pkt);
1795 AVPacketList *pktl = s->internal->packet_buffer;
1798 AVPacket *next_pkt = &pktl->pkt;
1800 if (next_pkt->dts != AV_NOPTS_VALUE) {
1801 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1802 // last dts seen for this stream. if any of packets following
1803 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1804 int64_t last_dts = next_pkt->dts;
1805 av_assert2(wrap_bits <= 64);
1806 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1807 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1808 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1809 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1811 next_pkt->pts = pktl->pkt.dts;
1813 if (last_dts != AV_NOPTS_VALUE) {
1814 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1815 last_dts = pktl->pkt.dts;
1820 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1821 // Fixing the last reference frame had none pts issue (For MXF etc).
1822 // We only do this when
1824 // 2. we are not able to resolve a pts value for current packet.
1825 // 3. the packets for this stream at the end of the files had valid dts.
1826 next_pkt->pts = last_dts + next_pkt->duration;
1828 pktl = s->internal->packet_buffer;
1831 /* read packet from packet buffer, if there is data */
1832 st = s->streams[next_pkt->stream_index];
1833 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1834 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1835 ret = ff_packet_list_get(&s->internal->packet_buffer,
1836 &s->internal->packet_buffer_end, pkt);
1841 ret = read_frame_internal(s, pkt);
1843 if (pktl && ret != AVERROR(EAGAIN)) {
1850 ret = ff_packet_list_put(&s->internal->packet_buffer,
1851 &s->internal->packet_buffer_end,
1854 av_packet_unref(pkt);
1861 st = s->streams[pkt->stream_index];
1862 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1863 ff_reduce_index(s, st->index);
1864 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1867 if (is_relative(pkt->dts))
1868 pkt->dts -= RELATIVE_TS_BASE;
1869 if (is_relative(pkt->pts))
1870 pkt->pts -= RELATIVE_TS_BASE;
1875 /* XXX: suppress the packet queue */
1876 static void flush_packet_queue(AVFormatContext *s)
1880 ff_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1881 ff_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1882 ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1884 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1887 /*******************************************************/
1890 int av_find_default_stream_index(AVFormatContext *s)
1894 int best_stream = 0;
1895 int best_score = INT_MIN;
1897 if (s->nb_streams <= 0)
1899 for (i = 0; i < s->nb_streams; i++) {
1902 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1903 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1905 if (st->codecpar->width && st->codecpar->height)
1909 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1910 if (st->codecpar->sample_rate)
1913 if (st->codec_info_nb_frames)
1916 if (st->discard != AVDISCARD_ALL)
1919 if (score > best_score) {
1927 /** Flush the frame reader. */
1928 void ff_read_frame_flush(AVFormatContext *s)
1933 flush_packet_queue(s);
1935 /* Reset read state for each stream. */
1936 for (i = 0; i < s->nb_streams; i++) {
1940 av_parser_close(st->parser);
1943 st->last_IP_pts = AV_NOPTS_VALUE;
1944 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1945 if (st->first_dts == AV_NOPTS_VALUE)
1946 st->cur_dts = RELATIVE_TS_BASE;
1948 /* We set the current DTS to an unspecified origin. */
1949 st->cur_dts = AV_NOPTS_VALUE;
1951 st->probe_packets = s->max_probe_packets;
1953 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1954 st->pts_buffer[j] = AV_NOPTS_VALUE;
1956 if (s->internal->inject_global_side_data)
1957 st->inject_global_side_data = 1;
1959 st->skip_samples = 0;
1963 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1967 for (i = 0; i < s->nb_streams; i++) {
1968 AVStream *st = s->streams[i];
1971 av_rescale(timestamp,
1972 st->time_base.den * (int64_t) ref_st->time_base.num,
1973 st->time_base.num * (int64_t) ref_st->time_base.den);
1977 void ff_reduce_index(AVFormatContext *s, int stream_index)
1979 AVStream *st = s->streams[stream_index];
1980 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1982 if ((unsigned) st->nb_index_entries >= max_entries) {
1984 for (i = 0; 2 * i < st->nb_index_entries; i++)
1985 st->index_entries[i] = st->index_entries[2 * i];
1986 st->nb_index_entries = i;
1990 int ff_add_index_entry(AVIndexEntry **index_entries,
1991 int *nb_index_entries,
1992 unsigned int *index_entries_allocated_size,
1993 int64_t pos, int64_t timestamp,
1994 int size, int distance, int flags)
1996 AVIndexEntry *entries, *ie;
1999 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
2002 if (timestamp == AV_NOPTS_VALUE)
2003 return AVERROR(EINVAL);
2005 if (size < 0 || size > 0x3FFFFFFF)
2006 return AVERROR(EINVAL);
2008 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
2009 timestamp -= RELATIVE_TS_BASE;
2011 entries = av_fast_realloc(*index_entries,
2012 index_entries_allocated_size,
2013 (*nb_index_entries + 1) *
2014 sizeof(AVIndexEntry));
2018 *index_entries = entries;
2020 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2021 timestamp, AVSEEK_FLAG_ANY);
2024 index = (*nb_index_entries)++;
2025 ie = &entries[index];
2026 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2028 ie = &entries[index];
2029 if (ie->timestamp != timestamp) {
2030 if (ie->timestamp <= timestamp)
2032 memmove(entries + index + 1, entries + index,
2033 sizeof(AVIndexEntry) * (*nb_index_entries - index));
2034 (*nb_index_entries)++;
2035 } else if (ie->pos == pos && distance < ie->min_distance)
2036 // do not reduce the distance
2037 distance = ie->min_distance;
2041 ie->timestamp = timestamp;
2042 ie->min_distance = distance;
2049 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2050 int size, int distance, int flags)
2052 timestamp = wrap_timestamp(st, timestamp);
2053 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2054 &st->index_entries_allocated_size, pos,
2055 timestamp, size, distance, flags);
2058 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2059 int64_t wanted_timestamp, int flags)
2067 // Optimize appending index entries at the end.
2068 if (b && entries[b - 1].timestamp < wanted_timestamp)
2074 // Search for the next non-discarded packet.
2075 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2077 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2083 timestamp = entries[m].timestamp;
2084 if (timestamp >= wanted_timestamp)
2086 if (timestamp <= wanted_timestamp)
2089 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2091 if (!(flags & AVSEEK_FLAG_ANY))
2092 while (m >= 0 && m < nb_entries &&
2093 !(entries[m].flags & AVINDEX_KEYFRAME))
2094 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2096 if (m == nb_entries)
2101 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2104 int64_t pos_delta = 0;
2106 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2107 const char *proto = avio_find_protocol_name(s->url);
2109 av_assert0(time_tolerance >= 0);
2112 av_log(s, AV_LOG_INFO,
2113 "Protocol name not provided, cannot determine if input is local or "
2114 "a network protocol, buffers and access patterns cannot be configured "
2115 "optimally without knowing the protocol\n");
2118 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2121 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2122 AVStream *st1 = s->streams[ist1];
2123 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2124 AVStream *st2 = s->streams[ist2];
2130 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2131 AVIndexEntry *e1 = &st1->index_entries[i1];
2132 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2134 skip = FFMAX(skip, e1->size);
2135 for (; i2 < st2->nb_index_entries; i2++) {
2136 AVIndexEntry *e2 = &st2->index_entries[i2];
2137 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2138 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2140 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2148 /* XXX This could be adjusted depending on protocol*/
2149 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2150 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2152 /* realloc the buffer and the original data will be retained */
2153 if (ffio_realloc_buf(s->pb, pos_delta)) {
2154 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2158 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2161 if (skip < (1<<23)) {
2162 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2166 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2168 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2169 wanted_timestamp, flags);
2172 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2173 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2175 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2176 if (stream_index >= 0)
2177 ts = wrap_timestamp(s->streams[stream_index], ts);
2181 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2182 int64_t target_ts, int flags)
2184 const AVInputFormat *avif = s->iformat;
2185 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2186 int64_t ts_min, ts_max, ts;
2191 if (stream_index < 0)
2194 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2197 ts_min = AV_NOPTS_VALUE;
2198 pos_limit = -1; // GCC falsely says it may be uninitialized.
2200 st = s->streams[stream_index];
2201 if (st->index_entries) {
2204 /* FIXME: Whole function must be checked for non-keyframe entries in
2205 * index case, especially read_timestamp(). */
2206 index = av_index_search_timestamp(st, target_ts,
2207 flags | AVSEEK_FLAG_BACKWARD);
2208 index = FFMAX(index, 0);
2209 e = &st->index_entries[index];
2211 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2213 ts_min = e->timestamp;
2214 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2215 pos_min, av_ts2str(ts_min));
2217 av_assert1(index == 0);
2220 index = av_index_search_timestamp(st, target_ts,
2221 flags & ~AVSEEK_FLAG_BACKWARD);
2222 av_assert0(index < st->nb_index_entries);
2224 e = &st->index_entries[index];
2225 av_assert1(e->timestamp >= target_ts);
2227 ts_max = e->timestamp;
2228 pos_limit = pos_max - e->min_distance;
2229 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2230 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2234 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2235 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2240 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2243 ff_read_frame_flush(s);
2244 ff_update_cur_dts(s, st, ts);
2249 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2250 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2252 int64_t step = 1024;
2253 int64_t limit, ts_max;
2254 int64_t filesize = avio_size(s->pb);
2255 int64_t pos_max = filesize - 1;
2258 pos_max = FFMAX(0, (pos_max) - step);
2259 ts_max = ff_read_timestamp(s, stream_index,
2260 &pos_max, limit, read_timestamp);
2262 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2263 if (ts_max == AV_NOPTS_VALUE)
2267 int64_t tmp_pos = pos_max + 1;
2268 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2269 &tmp_pos, INT64_MAX, read_timestamp);
2270 if (tmp_ts == AV_NOPTS_VALUE)
2272 av_assert0(tmp_pos > pos_max);
2275 if (tmp_pos >= filesize)
2287 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2288 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2289 int64_t ts_min, int64_t ts_max,
2290 int flags, int64_t *ts_ret,
2291 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2292 int64_t *, int64_t))
2299 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2301 if (ts_min == AV_NOPTS_VALUE) {
2302 pos_min = s->internal->data_offset;
2303 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2304 if (ts_min == AV_NOPTS_VALUE)
2308 if (ts_min >= target_ts) {
2313 if (ts_max == AV_NOPTS_VALUE) {
2314 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2316 pos_limit = pos_max;
2319 if (ts_max <= target_ts) {
2324 av_assert0(ts_min < ts_max);
2327 while (pos_min < pos_limit) {
2328 av_log(s, AV_LOG_TRACE,
2329 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2330 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2331 av_assert0(pos_limit <= pos_max);
2333 if (no_change == 0) {
2334 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2335 // interpolate position (better than dichotomy)
2336 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2338 pos_min - approximate_keyframe_distance;
2339 } else if (no_change == 1) {
2340 // bisection if interpolation did not change min / max pos last time
2341 pos = (pos_min + pos_limit) >> 1;
2343 /* linear search if bisection failed, can only happen if there
2344 * are very few or no keyframes between min/max */
2349 else if (pos > pos_limit)
2353 // May pass pos_limit instead of -1.
2354 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2359 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2360 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2361 pos_min, pos, pos_max,
2362 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2363 pos_limit, start_pos, no_change);
2364 if (ts == AV_NOPTS_VALUE) {
2365 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2368 if (target_ts <= ts) {
2369 pos_limit = start_pos - 1;
2373 if (target_ts >= ts) {
2379 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2380 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2383 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2385 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2386 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2387 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2393 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2394 int64_t pos, int flags)
2396 int64_t pos_min, pos_max;
2398 pos_min = s->internal->data_offset;
2399 pos_max = avio_size(s->pb) - 1;
2403 else if (pos > pos_max)
2406 avio_seek(s->pb, pos, SEEK_SET);
2408 s->io_repositioned = 1;
2413 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2414 int64_t timestamp, int flags)
2421 st = s->streams[stream_index];
2423 index = av_index_search_timestamp(st, timestamp, flags);
2425 if (index < 0 && st->nb_index_entries &&
2426 timestamp < st->index_entries[0].timestamp)
2429 if (index < 0 || index == st->nb_index_entries - 1) {
2433 if (st->nb_index_entries) {
2434 av_assert0(st->index_entries);
2435 ie = &st->index_entries[st->nb_index_entries - 1];
2436 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2438 ff_update_cur_dts(s, st, ie->timestamp);
2440 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2446 read_status = av_read_frame(s, &pkt);
2447 } while (read_status == AVERROR(EAGAIN));
2448 if (read_status < 0)
2450 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2451 if (pkt.flags & AV_PKT_FLAG_KEY) {
2452 av_packet_unref(&pkt);
2455 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2456 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);
2457 av_packet_unref(&pkt);
2461 av_packet_unref(&pkt);
2463 index = av_index_search_timestamp(st, timestamp, flags);
2468 ff_read_frame_flush(s);
2469 if (s->iformat->read_seek)
2470 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2472 ie = &st->index_entries[index];
2473 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2475 ff_update_cur_dts(s, st, ie->timestamp);
2480 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2481 int64_t timestamp, int flags)
2486 if (flags & AVSEEK_FLAG_BYTE) {
2487 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2489 ff_read_frame_flush(s);
2490 return seek_frame_byte(s, stream_index, timestamp, flags);
2493 if (stream_index < 0) {
2494 stream_index = av_find_default_stream_index(s);
2495 if (stream_index < 0)
2498 st = s->streams[stream_index];
2499 /* timestamp for default must be expressed in AV_TIME_BASE units */
2500 timestamp = av_rescale(timestamp, st->time_base.den,
2501 AV_TIME_BASE * (int64_t) st->time_base.num);
2504 /* first, we try the format specific seek */
2505 if (s->iformat->read_seek) {
2506 ff_read_frame_flush(s);
2507 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2513 if (s->iformat->read_timestamp &&
2514 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2515 ff_read_frame_flush(s);
2516 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2517 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2518 ff_read_frame_flush(s);
2519 return seek_frame_generic(s, stream_index, timestamp, flags);
2524 int av_seek_frame(AVFormatContext *s, int stream_index,
2525 int64_t timestamp, int flags)
2529 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2530 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2531 if ((flags & AVSEEK_FLAG_BACKWARD))
2535 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2536 flags & ~AVSEEK_FLAG_BACKWARD);
2539 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2542 ret = avformat_queue_attached_pictures(s);
2547 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2548 int64_t ts, int64_t max_ts, int flags)
2550 if (min_ts > ts || max_ts < ts)
2552 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2553 return AVERROR(EINVAL);
2556 flags |= AVSEEK_FLAG_ANY;
2557 flags &= ~AVSEEK_FLAG_BACKWARD;
2559 if (s->iformat->read_seek2) {
2561 ff_read_frame_flush(s);
2563 if (stream_index == -1 && s->nb_streams == 1) {
2564 AVRational time_base = s->streams[0]->time_base;
2565 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2566 min_ts = av_rescale_rnd(min_ts, time_base.den,
2567 time_base.num * (int64_t)AV_TIME_BASE,
2568 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2569 max_ts = av_rescale_rnd(max_ts, time_base.den,
2570 time_base.num * (int64_t)AV_TIME_BASE,
2571 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2575 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2579 ret = avformat_queue_attached_pictures(s);
2583 if (s->iformat->read_timestamp) {
2584 // try to seek via read_timestamp()
2587 // Fall back on old API if new is not implemented but old is.
2588 // Note the old API has somewhat different semantics.
2589 if (s->iformat->read_seek || 1) {
2590 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2591 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2592 if (ret<0 && ts != min_ts && max_ts != ts) {
2593 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2595 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2600 // try some generic seek like seek_frame_generic() but with new ts semantics
2601 return -1; //unreachable
2604 int avformat_flush(AVFormatContext *s)
2606 ff_read_frame_flush(s);
2610 /*******************************************************/
2613 * Return TRUE if the stream has accurate duration in any stream.
2615 * @return TRUE if the stream has accurate duration for at least one component.
2617 static int has_duration(AVFormatContext *ic)
2622 for (i = 0; i < ic->nb_streams; i++) {
2623 st = ic->streams[i];
2624 if (st->duration != AV_NOPTS_VALUE)
2627 if (ic->duration != AV_NOPTS_VALUE)
2633 * Estimate the stream timings from the one of each components.
2635 * Also computes the global bitrate if possible.
2637 static void update_stream_timings(AVFormatContext *ic)
2639 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2640 int64_t duration, duration1, duration_text, filesize;
2644 start_time = INT64_MAX;
2645 start_time_text = INT64_MAX;
2646 end_time = INT64_MIN;
2647 end_time_text = INT64_MIN;
2648 duration = INT64_MIN;
2649 duration_text = INT64_MIN;
2651 for (i = 0; i < ic->nb_streams; i++) {
2652 AVStream *st = ic->streams[i];
2653 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2654 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2655 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2656 start_time1 = av_rescale_q(st->start_time, st->time_base,
2659 start_time_text = FFMIN(start_time_text, start_time1);
2661 start_time = FFMIN(start_time, start_time1);
2662 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2664 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2665 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2666 end_time1 += start_time1;
2668 end_time_text = FFMAX(end_time_text, end_time1);
2670 end_time = FFMAX(end_time, end_time1);
2672 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2673 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2674 p->start_time = start_time1;
2675 if (p->end_time < end_time1)
2676 p->end_time = end_time1;
2679 if (st->duration != AV_NOPTS_VALUE) {
2680 duration1 = av_rescale_q(st->duration, st->time_base,
2683 duration_text = FFMAX(duration_text, duration1);
2685 duration = FFMAX(duration, duration1);
2688 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2689 start_time = start_time_text;
2690 else if (start_time > start_time_text)
2691 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2693 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2694 end_time = end_time_text;
2695 else if (end_time < end_time_text)
2696 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2698 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2699 duration = duration_text;
2700 else if (duration < duration_text)
2701 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2703 if (start_time != INT64_MAX) {
2704 ic->start_time = start_time;
2705 if (end_time != INT64_MIN) {
2706 if (ic->nb_programs > 1) {
2707 for (i = 0; i < ic->nb_programs; i++) {
2708 p = ic->programs[i];
2709 if (p->start_time != AV_NOPTS_VALUE &&
2710 p->end_time > p->start_time &&
2711 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2712 duration = FFMAX(duration, p->end_time - p->start_time);
2714 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2715 duration = FFMAX(duration, end_time - start_time);
2719 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2720 ic->duration = duration;
2722 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2723 /* compute the bitrate */
2724 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2725 (double) ic->duration;
2726 if (bitrate >= 0 && bitrate <= INT64_MAX)
2727 ic->bit_rate = bitrate;
2731 static void fill_all_stream_timings(AVFormatContext *ic)
2736 update_stream_timings(ic);
2737 for (i = 0; i < ic->nb_streams; i++) {
2738 st = ic->streams[i];
2739 if (st->start_time == AV_NOPTS_VALUE) {
2740 if (ic->start_time != AV_NOPTS_VALUE)
2741 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2743 if (ic->duration != AV_NOPTS_VALUE)
2744 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2750 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2752 int64_t filesize, duration;
2753 int i, show_warning = 0;
2756 /* if bit_rate is already set, we believe it */
2757 if (ic->bit_rate <= 0) {
2758 int64_t bit_rate = 0;
2759 for (i = 0; i < ic->nb_streams; i++) {
2760 st = ic->streams[i];
2761 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2762 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2763 if (st->codecpar->bit_rate > 0) {
2764 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2768 bit_rate += st->codecpar->bit_rate;
2769 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2770 // If we have a videostream with packets but without a bitrate
2771 // then consider the sum not known
2776 ic->bit_rate = bit_rate;
2779 /* if duration is already set, we believe it */
2780 if (ic->duration == AV_NOPTS_VALUE &&
2781 ic->bit_rate != 0) {
2782 filesize = ic->pb ? avio_size(ic->pb) : 0;
2783 if (filesize > ic->internal->data_offset) {
2784 filesize -= ic->internal->data_offset;
2785 for (i = 0; i < ic->nb_streams; i++) {
2786 st = ic->streams[i];
2787 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2788 && st->duration == AV_NOPTS_VALUE) {
2789 duration = av_rescale(8 * filesize, st->time_base.den,
2791 (int64_t) st->time_base.num);
2792 st->duration = duration;
2799 av_log(ic, AV_LOG_WARNING,
2800 "Estimating duration from bitrate, this may be inaccurate\n");
2803 #define DURATION_MAX_READ_SIZE 250000LL
2804 #define DURATION_MAX_RETRY 6
2806 /* only usable for MPEG-PS streams */
2807 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2809 AVPacket pkt1, *pkt = &pkt1;
2811 int num, den, read_size, i, ret;
2812 int found_duration = 0;
2814 int64_t filesize, offset, duration;
2817 /* flush packet queue */
2818 flush_packet_queue(ic);
2820 for (i = 0; i < ic->nb_streams; i++) {
2821 st = ic->streams[i];
2822 if (st->start_time == AV_NOPTS_VALUE &&
2823 st->first_dts == AV_NOPTS_VALUE &&
2824 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2825 av_log(ic, AV_LOG_WARNING,
2826 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2829 av_parser_close(st->parser);
2834 if (ic->skip_estimate_duration_from_pts) {
2835 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2836 goto skip_duration_calc;
2839 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2840 /* estimate the end time (duration) */
2841 /* XXX: may need to support wrapping */
2842 filesize = ic->pb ? avio_size(ic->pb) : 0;
2844 is_end = found_duration;
2845 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2849 avio_seek(ic->pb, offset, SEEK_SET);
2852 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2856 ret = ff_read_packet(ic, pkt);
2857 } while (ret == AVERROR(EAGAIN));
2860 read_size += pkt->size;
2861 st = ic->streams[pkt->stream_index];
2862 if (pkt->pts != AV_NOPTS_VALUE &&
2863 (st->start_time != AV_NOPTS_VALUE ||
2864 st->first_dts != AV_NOPTS_VALUE)) {
2865 if (pkt->duration == 0) {
2866 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2868 pkt->duration = av_rescale_rnd(1,
2869 num * (int64_t) st->time_base.den,
2870 den * (int64_t) st->time_base.num,
2874 duration = pkt->pts + pkt->duration;
2876 if (st->start_time != AV_NOPTS_VALUE)
2877 duration -= st->start_time;
2879 duration -= st->first_dts;
2881 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2882 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2883 st->duration = duration;
2884 st->info->last_duration = duration;
2887 av_packet_unref(pkt);
2890 /* check if all audio/video streams have valid duration */
2893 for (i = 0; i < ic->nb_streams; i++) {
2894 st = ic->streams[i];
2895 switch (st->codecpar->codec_type) {
2896 case AVMEDIA_TYPE_VIDEO:
2897 case AVMEDIA_TYPE_AUDIO:
2898 if (st->duration == AV_NOPTS_VALUE)
2905 ++retry <= DURATION_MAX_RETRY);
2907 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2909 /* warn about audio/video streams which duration could not be estimated */
2910 for (i = 0; i < ic->nb_streams; i++) {
2911 st = ic->streams[i];
2912 if (st->duration == AV_NOPTS_VALUE) {
2913 switch (st->codecpar->codec_type) {
2914 case AVMEDIA_TYPE_VIDEO:
2915 case AVMEDIA_TYPE_AUDIO:
2916 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2917 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2919 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2924 fill_all_stream_timings(ic);
2926 avio_seek(ic->pb, old_offset, SEEK_SET);
2927 for (i = 0; i < ic->nb_streams; i++) {
2930 st = ic->streams[i];
2931 st->cur_dts = st->first_dts;
2932 st->last_IP_pts = AV_NOPTS_VALUE;
2933 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2934 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2935 st->pts_buffer[j] = AV_NOPTS_VALUE;
2939 /* 1:1 map to AVDurationEstimationMethod */
2940 static const char *duration_name[] = {
2941 [AVFMT_DURATION_FROM_PTS] = "pts",
2942 [AVFMT_DURATION_FROM_STREAM] = "stream",
2943 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2946 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2948 return duration_name[method];
2951 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2955 /* get the file size, if possible */
2956 if (ic->iformat->flags & AVFMT_NOFILE) {
2959 file_size = avio_size(ic->pb);
2960 file_size = FFMAX(0, file_size);
2963 if ((!strcmp(ic->iformat->name, "mpeg") ||
2964 !strcmp(ic->iformat->name, "mpegts")) &&
2965 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2966 /* get accurate estimate from the PTSes */
2967 estimate_timings_from_pts(ic, old_offset);
2968 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2969 } else if (has_duration(ic)) {
2970 /* at least one component has timings - we use them for all
2972 fill_all_stream_timings(ic);
2973 /* nut demuxer estimate the duration from PTS */
2974 if(!strcmp(ic->iformat->name, "nut"))
2975 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2977 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2979 /* less precise: use bitrate info */
2980 estimate_timings_from_bit_rate(ic);
2981 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2983 update_stream_timings(ic);
2987 AVStream av_unused *st;
2988 for (i = 0; i < ic->nb_streams; i++) {
2989 st = ic->streams[i];
2990 if (st->time_base.den)
2991 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2992 (double) st->start_time * av_q2d(st->time_base),
2993 (double) st->duration * av_q2d(st->time_base));
2995 av_log(ic, AV_LOG_TRACE,
2996 "format: start_time: %0.3f duration: %0.3f (estimate from %s) bitrate=%"PRId64" kb/s\n",
2997 (double) ic->start_time / AV_TIME_BASE,
2998 (double) ic->duration / AV_TIME_BASE,
2999 duration_estimate_name(ic->duration_estimation_method),
3000 (int64_t)ic->bit_rate / 1000);
3004 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
3006 AVCodecContext *avctx = st->internal->avctx;
3008 #define FAIL(errmsg) do { \
3010 *errmsg_ptr = errmsg; \
3014 if ( avctx->codec_id == AV_CODEC_ID_NONE
3015 && avctx->codec_type != AVMEDIA_TYPE_DATA)
3016 FAIL("unknown codec");
3017 switch (avctx->codec_type) {
3018 case AVMEDIA_TYPE_AUDIO:
3019 if (!avctx->frame_size && determinable_frame_size(avctx))
3020 FAIL("unspecified frame size");
3021 if (st->info->found_decoder >= 0 &&
3022 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3023 FAIL("unspecified sample format");
3024 if (!avctx->sample_rate)
3025 FAIL("unspecified sample rate");
3026 if (!avctx->channels)
3027 FAIL("unspecified number of channels");
3028 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3029 FAIL("no decodable DTS frames");
3031 case AVMEDIA_TYPE_VIDEO:
3033 FAIL("unspecified size");
3034 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3035 FAIL("unspecified pixel format");
3036 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3037 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3038 FAIL("no frame in rv30/40 and no sar");
3040 case AVMEDIA_TYPE_SUBTITLE:
3041 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3042 FAIL("unspecified size");
3044 case AVMEDIA_TYPE_DATA:
3045 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3051 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3052 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3053 const AVPacket *avpkt, AVDictionary **options)
3055 AVCodecContext *avctx = st->internal->avctx;
3056 const AVCodec *codec;
3057 int got_picture = 1, ret = 0;
3058 AVFrame *frame = av_frame_alloc();
3059 AVSubtitle subtitle;
3060 AVPacket pkt = *avpkt;
3061 int do_skip_frame = 0;
3062 enum AVDiscard skip_frame;
3065 return AVERROR(ENOMEM);
3067 if (!avcodec_is_open(avctx) &&
3068 st->info->found_decoder <= 0 &&
3069 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3070 AVDictionary *thread_opt = NULL;
3072 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3075 st->info->found_decoder = -st->codecpar->codec_id;
3080 /* Force thread count to 1 since the H.264 decoder will not extract
3081 * SPS and PPS to extradata during multi-threaded decoding. */
3082 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3083 if (s->codec_whitelist)
3084 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3085 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3087 av_dict_free(&thread_opt);
3089 st->info->found_decoder = -avctx->codec_id;
3092 st->info->found_decoder = 1;
3093 } else if (!st->info->found_decoder)
3094 st->info->found_decoder = 1;
3096 if (st->info->found_decoder < 0) {
3101 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3103 skip_frame = avctx->skip_frame;
3104 avctx->skip_frame = AVDISCARD_ALL;
3107 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3109 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3110 (!st->codec_info_nb_frames &&
3111 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3113 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3114 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3115 ret = avcodec_send_packet(avctx, &pkt);
3116 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3120 ret = avcodec_receive_frame(avctx, frame);
3123 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3125 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3126 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3127 &got_picture, &pkt);
3133 st->nb_decoded_frames++;
3138 if (!pkt.data && !got_picture)
3142 if (do_skip_frame) {
3143 avctx->skip_frame = skip_frame;
3146 av_frame_free(&frame);
3150 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3152 while (tags->id != AV_CODEC_ID_NONE) {
3160 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3163 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3164 if (tag == tags[i].tag)
3166 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3167 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3169 return AV_CODEC_ID_NONE;
3172 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3174 if (bps <= 0 || bps > 64)
3175 return AV_CODEC_ID_NONE;
3180 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3182 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3184 return AV_CODEC_ID_NONE;
3189 if (sflags & (1 << (bps - 1))) {
3192 return AV_CODEC_ID_PCM_S8;
3194 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3196 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3198 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3200 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3202 return AV_CODEC_ID_NONE;
3207 return AV_CODEC_ID_PCM_U8;
3209 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3211 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3213 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3215 return AV_CODEC_ID_NONE;
3221 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3224 if (!av_codec_get_tag2(tags, id, &tag))
3229 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3233 for (i = 0; tags && tags[i]; i++) {
3234 const AVCodecTag *codec_tags = tags[i];
3235 while (codec_tags->id != AV_CODEC_ID_NONE) {
3236 if (codec_tags->id == id) {
3237 *tag = codec_tags->tag;
3246 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3249 for (i = 0; tags && tags[i]; i++) {
3250 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3251 if (id != AV_CODEC_ID_NONE)
3254 return AV_CODEC_ID_NONE;
3257 static void compute_chapters_end(AVFormatContext *s)
3260 int64_t max_time = 0;
3262 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3263 max_time = s->duration +
3264 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3266 for (i = 0; i < s->nb_chapters; i++)
3267 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3268 AVChapter *ch = s->chapters[i];
3269 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3273 for (j = 0; j < s->nb_chapters; j++) {
3274 AVChapter *ch1 = s->chapters[j];
3275 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3277 if (j != i && next_start > ch->start && next_start < end)
3280 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3284 static int get_std_framerate(int i)
3287 return (i + 1) * 1001;
3291 return (i + 31) * 1001 * 12;
3295 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3299 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3302 /* Is the time base unreliable?
3303 * This is a heuristic to balance between quick acceptance of the values in
3304 * the headers vs. some extra checks.
3305 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3306 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3307 * And there are "variable" fps files this needs to detect as well. */
3308 static int tb_unreliable(AVCodecContext *c)
3310 if (c->time_base.den >= 101LL * c->time_base.num ||
3311 c->time_base.den < 5LL * c->time_base.num ||
3312 // c->codec_tag == AV_RL32("DIVX") ||
3313 // c->codec_tag == AV_RL32("XVID") ||
3314 c->codec_tag == AV_RL32("mp4v") ||
3315 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3316 c->codec_id == AV_CODEC_ID_GIF ||
3317 c->codec_id == AV_CODEC_ID_HEVC ||
3318 c->codec_id == AV_CODEC_ID_H264)
3323 int ff_alloc_extradata(AVCodecParameters *par, int size)
3325 av_freep(&par->extradata);
3326 par->extradata_size = 0;
3328 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3329 return AVERROR(EINVAL);
3331 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3332 if (!par->extradata)
3333 return AVERROR(ENOMEM);
3335 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3336 par->extradata_size = size;
3341 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3343 int ret = ff_alloc_extradata(par, size);
3346 ret = avio_read(pb, par->extradata, size);
3348 av_freep(&par->extradata);
3349 par->extradata_size = 0;
3350 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3351 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3357 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3360 int64_t last = st->info->last_dts;
3362 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3363 && ts - (uint64_t)last < INT64_MAX) {
3364 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3365 int64_t duration = ts - last;
3367 if (!st->info->duration_error)
3368 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3369 if (!st->info->duration_error)
3370 return AVERROR(ENOMEM);
3372 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3373 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3374 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3375 if (st->info->duration_error[0][1][i] < 1e10) {
3376 int framerate = get_std_framerate(i);
3377 double sdts = dts*framerate/(1001*12);
3378 for (j= 0; j<2; j++) {
3379 int64_t ticks = llrint(sdts+j*0.5);
3380 double error= sdts - ticks + j*0.5;
3381 st->info->duration_error[j][0][i] += error;
3382 st->info->duration_error[j][1][i] += error*error;
3386 if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3387 st->info->duration_count++;
3388 st->info->rfps_duration_sum += duration;
3391 if (st->info->duration_count % 10 == 0) {
3392 int n = st->info->duration_count;
3393 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3394 if (st->info->duration_error[0][1][i] < 1e10) {
3395 double a0 = st->info->duration_error[0][0][i] / n;
3396 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3397 double a1 = st->info->duration_error[1][0][i] / n;
3398 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3399 if (error0 > 0.04 && error1 > 0.04) {
3400 st->info->duration_error[0][1][i] = 2e10;
3401 st->info->duration_error[1][1][i] = 2e10;
3407 // ignore the first 4 values, they might have some random jitter
3408 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3409 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3411 if (ts != AV_NOPTS_VALUE)
3412 st->info->last_dts = ts;
3417 void ff_rfps_calculate(AVFormatContext *ic)
3421 for (i = 0; i < ic->nb_streams; i++) {
3422 AVStream *st = ic->streams[i];
3424 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3426 // the check for tb_unreliable() is not completely correct, since this is not about handling
3427 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3428 // ipmovie.c produces.
3429 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)
3430 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);
3431 if (st->info->duration_count>1 && !st->r_frame_rate.num
3432 && tb_unreliable(st->internal->avctx)) {
3434 double best_error= 0.01;
3435 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3437 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3440 if (st->info->codec_info_duration &&
3441 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3443 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3446 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3449 for (k= 0; k<2; k++) {
3450 int n = st->info->duration_count;
3451 double a= st->info->duration_error[k][0][j] / n;
3452 double error= st->info->duration_error[k][1][j]/n - a*a;
3454 if (error < best_error && best_error> 0.000000001) {
3456 num = get_std_framerate(j);
3459 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3462 // do not increase frame rate by more than 1 % in order to match a standard rate.
3463 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3464 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3466 if ( !st->avg_frame_rate.num
3467 && st->r_frame_rate.num && st->info->rfps_duration_sum
3468 && st->info->codec_info_duration <= 0
3469 && st->info->duration_count > 2
3470 && 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
3472 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3473 st->avg_frame_rate = st->r_frame_rate;
3476 av_freep(&st->info->duration_error);
3477 st->info->last_dts = AV_NOPTS_VALUE;
3478 st->info->duration_count = 0;
3479 st->info->rfps_duration_sum = 0;
3483 static int extract_extradata_check(AVStream *st)
3485 const AVBitStreamFilter *f;
3487 f = av_bsf_get_by_name("extract_extradata");
3492 const enum AVCodecID *ids;
3493 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3494 if (*ids == st->codecpar->codec_id)
3501 static int extract_extradata_init(AVStream *st)
3503 AVStreamInternal *sti = st->internal;
3504 const AVBitStreamFilter *f;
3507 f = av_bsf_get_by_name("extract_extradata");
3511 /* check that the codec id is supported */
3512 ret = extract_extradata_check(st);
3516 sti->extract_extradata.pkt = av_packet_alloc();
3517 if (!sti->extract_extradata.pkt)
3518 return AVERROR(ENOMEM);
3520 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3524 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3529 sti->extract_extradata.bsf->time_base_in = st->time_base;
3531 ret = av_bsf_init(sti->extract_extradata.bsf);
3536 sti->extract_extradata.inited = 1;
3540 av_bsf_free(&sti->extract_extradata.bsf);
3541 av_packet_free(&sti->extract_extradata.pkt);
3545 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3547 AVStreamInternal *sti = st->internal;
3551 if (!sti->extract_extradata.inited) {
3552 ret = extract_extradata_init(st);
3557 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3560 pkt_ref = sti->extract_extradata.pkt;
3561 ret = av_packet_ref(pkt_ref, pkt);
3565 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3567 av_packet_unref(pkt_ref);
3571 while (ret >= 0 && !sti->avctx->extradata) {
3575 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3577 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3582 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3586 av_assert0(!sti->avctx->extradata);
3587 if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3588 sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3589 if (!sti->avctx->extradata) {
3590 av_packet_unref(pkt_ref);
3591 return AVERROR(ENOMEM);
3593 memcpy(sti->avctx->extradata, extradata, extradata_size);
3594 sti->avctx->extradata_size = extradata_size;
3596 av_packet_unref(pkt_ref);
3602 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3606 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3607 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3609 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3611 return AVERROR(ENOMEM);
3612 memcpy(dst_data, sd_src->data, sd_src->size);
3617 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3619 int i, count = 0, ret = 0, j;
3622 AVCodecContext *avctx;
3624 int64_t old_offset = avio_tell(ic->pb);
3625 // new streams might appear, no options for those
3626 int orig_nb_streams = ic->nb_streams;
3628 int64_t max_analyze_duration = ic->max_analyze_duration;
3629 int64_t max_stream_analyze_duration;
3630 int64_t max_subtitle_analyze_duration;
3631 int64_t probesize = ic->probesize;
3632 int eof_reached = 0;
3633 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3635 flush_codecs = probesize > 0;
3637 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3639 max_stream_analyze_duration = max_analyze_duration;
3640 max_subtitle_analyze_duration = max_analyze_duration;
3641 if (!max_analyze_duration) {
3642 max_stream_analyze_duration =
3643 max_analyze_duration = 5*AV_TIME_BASE;
3644 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3645 if (!strcmp(ic->iformat->name, "flv"))
3646 max_stream_analyze_duration = 90*AV_TIME_BASE;
3647 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3648 max_stream_analyze_duration = 7*AV_TIME_BASE;
3652 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3653 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3655 for (i = 0; i < ic->nb_streams; i++) {
3656 const AVCodec *codec;
3657 AVDictionary *thread_opt = NULL;
3658 st = ic->streams[i];
3659 avctx = st->internal->avctx;
3661 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3662 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3663 /* if (!st->time_base.num)
3665 if (!avctx->time_base.num)
3666 avctx->time_base = st->time_base;
3669 /* check if the caller has overridden the codec id */
3670 #if FF_API_LAVF_AVCTX
3671 FF_DISABLE_DEPRECATION_WARNINGS
3672 if (st->codec->codec_id != st->internal->orig_codec_id) {
3673 st->codecpar->codec_id = st->codec->codec_id;
3674 st->codecpar->codec_type = st->codec->codec_type;
3675 st->internal->orig_codec_id = st->codec->codec_id;
3677 FF_ENABLE_DEPRECATION_WARNINGS
3679 // only for the split stuff
3680 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3681 st->parser = av_parser_init(st->codecpar->codec_id);
3683 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3684 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3685 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3686 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3688 } else if (st->need_parsing) {
3689 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3690 "%s, packets or times may be invalid.\n",
3691 avcodec_get_name(st->codecpar->codec_id));
3695 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3696 st->internal->orig_codec_id = st->codecpar->codec_id;
3698 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3700 goto find_stream_info_err;
3701 if (st->request_probe <= 0)
3702 st->internal->avctx_inited = 1;
3704 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3706 /* Force thread count to 1 since the H.264 decoder will not extract
3707 * SPS and PPS to extradata during multi-threaded decoding. */
3708 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3710 if (ic->codec_whitelist)
3711 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3713 /* Ensure that subtitle_header is properly set. */
3714 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3715 && codec && !avctx->codec) {
3716 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3717 av_log(ic, AV_LOG_WARNING,
3718 "Failed to open codec in %s\n",__FUNCTION__);
3721 // Try to just open decoders, in case this is enough to get parameters.
3722 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3723 if (codec && !avctx->codec)
3724 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3725 av_log(ic, AV_LOG_WARNING,
3726 "Failed to open codec in %s\n",__FUNCTION__);
3729 av_dict_free(&thread_opt);
3732 for (i = 0; i < ic->nb_streams; i++) {
3733 #if FF_API_R_FRAME_RATE
3734 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3736 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3737 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3742 const AVPacket *pkt;
3743 int analyzed_all_streams;
3744 if (ff_check_interrupt(&ic->interrupt_callback)) {
3746 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3750 /* check if one codec still needs to be handled */
3751 for (i = 0; i < ic->nb_streams; i++) {
3752 int fps_analyze_framecount = 20;
3755 st = ic->streams[i];
3756 if (!has_codec_parameters(st, NULL))
3758 /* If the timebase is coarse (like the usual millisecond precision
3759 * of mkv), we need to analyze more frames to reliably arrive at
3760 * the correct fps. */
3761 if (av_q2d(st->time_base) > 0.0005)
3762 fps_analyze_framecount *= 2;
3763 if (!tb_unreliable(st->internal->avctx))
3764 fps_analyze_framecount = 0;
3765 if (ic->fps_probe_size >= 0)
3766 fps_analyze_framecount = ic->fps_probe_size;
3767 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3768 fps_analyze_framecount = 0;
3769 /* variable fps and no guess at the real fps */
3770 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3771 st->info->codec_info_duration_fields/2 :
3772 st->info->duration_count;
3773 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3774 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3775 if (count < fps_analyze_framecount)
3778 // Look at the first 3 frames if there is evidence of frame delay
3779 // but the decoder delay is not set.
3780 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3782 if (!st->internal->avctx->extradata &&
3783 (!st->internal->extract_extradata.inited ||
3784 st->internal->extract_extradata.bsf) &&
3785 extract_extradata_check(st))
3787 if (st->first_dts == AV_NOPTS_VALUE &&
3788 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3789 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3790 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3791 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3794 analyzed_all_streams = 0;
3795 if (!missing_streams || !*missing_streams)
3796 if (i == ic->nb_streams) {
3797 analyzed_all_streams = 1;
3798 /* NOTE: If the format has no header, then we need to read some
3799 * packets to get most of the streams, so we cannot stop here. */
3800 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3801 /* If we found the info for all the codecs, we can stop. */
3803 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3808 /* We did not get all the codec info, but we read too much data. */
3809 if (read_size >= probesize) {
3811 av_log(ic, AV_LOG_DEBUG,
3812 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3813 for (i = 0; i < ic->nb_streams; i++)
3814 if (!ic->streams[i]->r_frame_rate.num &&
3815 ic->streams[i]->info->duration_count <= 1 &&
3816 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3817 strcmp(ic->iformat->name, "image2"))
3818 av_log(ic, AV_LOG_WARNING,
3819 "Stream #%d: not enough frames to estimate rate; "
3820 "consider increasing probesize\n", i);
3824 /* NOTE: A new stream can be added there if no header in file
3825 * (AVFMTCTX_NOHEADER). */
3826 ret = read_frame_internal(ic, &pkt1);
3827 if (ret == AVERROR(EAGAIN))
3836 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3837 ret = ff_packet_list_put(&ic->internal->packet_buffer,
3838 &ic->internal->packet_buffer_end,
3841 goto unref_then_goto_end;
3843 pkt = &ic->internal->packet_buffer_end->pkt;
3848 st = ic->streams[pkt->stream_index];
3849 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3850 read_size += pkt->size;
3852 avctx = st->internal->avctx;
3853 if (!st->internal->avctx_inited) {
3854 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3856 goto unref_then_goto_end;
3857 st->internal->avctx_inited = 1;
3860 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3861 /* check for non-increasing dts */
3862 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3863 st->info->fps_last_dts >= pkt->dts) {
3864 av_log(ic, AV_LOG_DEBUG,
3865 "Non-increasing DTS in stream %d: packet %d with DTS "
3866 "%"PRId64", packet %d with DTS %"PRId64"\n",
3867 st->index, st->info->fps_last_dts_idx,
3868 st->info->fps_last_dts, st->codec_info_nb_frames,
3870 st->info->fps_first_dts =
3871 st->info->fps_last_dts = AV_NOPTS_VALUE;
3873 /* Check for a discontinuity in dts. If the difference in dts
3874 * is more than 1000 times the average packet duration in the
3875 * sequence, we treat it as a discontinuity. */
3876 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3877 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3878 (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3879 (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3880 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3881 av_log(ic, AV_LOG_WARNING,
3882 "DTS discontinuity in stream %d: packet %d with DTS "
3883 "%"PRId64", packet %d with DTS %"PRId64"\n",
3884 st->index, st->info->fps_last_dts_idx,
3885 st->info->fps_last_dts, st->codec_info_nb_frames,
3887 st->info->fps_first_dts =
3888 st->info->fps_last_dts = AV_NOPTS_VALUE;
3891 /* update stored dts values */
3892 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3893 st->info->fps_first_dts = pkt->dts;
3894 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3896 st->info->fps_last_dts = pkt->dts;
3897 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3899 if (st->codec_info_nb_frames>1) {
3903 if (st->time_base.den > 0)
3904 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3905 if (st->avg_frame_rate.num > 0)
3906 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3909 && st->codec_info_nb_frames>30
3910 && st->info->fps_first_dts != AV_NOPTS_VALUE
3911 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3912 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3914 if (analyzed_all_streams) limit = max_analyze_duration;
3915 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3916 else limit = max_stream_analyze_duration;
3919 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3921 t, pkt->stream_index);
3922 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3923 av_packet_unref(&pkt1);
3926 if (pkt->duration) {
3927 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3928 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3930 st->info->codec_info_duration += pkt->duration;
3931 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3934 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3935 #if FF_API_R_FRAME_RATE
3936 ff_rfps_add_frame(ic, st, pkt->dts);
3938 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3939 st->info->frame_delay_evidence = 1;
3941 if (!st->internal->avctx->extradata) {
3942 ret = extract_extradata(st, pkt);
3944 goto unref_then_goto_end;
3947 /* If still no information, we try to open the codec and to
3948 * decompress the frame. We try to avoid that in most cases as
3949 * it takes longer and uses more memory. For MPEG-4, we need to
3950 * decompress for QuickTime.
3952 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3953 * least one frame of codec data, this makes sure the codec initializes
3954 * the channel configuration and does not only trust the values from
3956 try_decode_frame(ic, st, pkt,
3957 (options && i < orig_nb_streams) ? &options[i] : NULL);
3959 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3960 av_packet_unref(&pkt1);
3962 st->codec_info_nb_frames++;
3968 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3969 st = ic->streams[stream_index];
3970 avctx = st->internal->avctx;
3971 if (!has_codec_parameters(st, NULL)) {
3972 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3973 if (codec && !avctx->codec) {
3974 AVDictionary *opts = NULL;
3975 if (ic->codec_whitelist)
3976 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3977 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3978 av_log(ic, AV_LOG_WARNING,
3979 "Failed to open codec in %s\n",__FUNCTION__);
3980 av_dict_free(&opts);
3984 // EOF already reached while reading the stream above.
3985 // So continue with reoordering DTS with whatever delay we have.
3986 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3987 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3993 AVPacket empty_pkt = { 0 };
3995 av_init_packet(&empty_pkt);
3997 for (i = 0; i < ic->nb_streams; i++) {
3999 st = ic->streams[i];
4001 /* flush the decoders */
4002 if (st->info->found_decoder == 1) {
4004 err = try_decode_frame(ic, st, &empty_pkt,
4005 (options && i < orig_nb_streams)
4006 ? &options[i] : NULL);
4007 } while (err > 0 && !has_codec_parameters(st, NULL));
4010 av_log(ic, AV_LOG_INFO,
4011 "decoding for stream %d failed\n", st->index);
4017 ff_rfps_calculate(ic);
4019 for (i = 0; i < ic->nb_streams; i++) {
4020 st = ic->streams[i];
4021 avctx = st->internal->avctx;
4022 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4023 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4024 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4025 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4026 avctx->codec_tag= tag;
4029 /* estimate average framerate if not set by demuxer */
4030 if (st->info->codec_info_duration_fields &&
4031 !st->avg_frame_rate.num &&
4032 st->info->codec_info_duration) {
4034 double best_error = 0.01;
4035 AVRational codec_frame_rate = avctx->framerate;
4037 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4038 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4039 st->info->codec_info_duration < 0)
4041 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4042 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4043 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4045 /* Round guessed framerate to a "standard" framerate if it's
4046 * within 1% of the original estimate. */
4047 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4048 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4049 double error = fabs(av_q2d(st->avg_frame_rate) /
4050 av_q2d(std_fps) - 1);
4052 if (error < best_error) {
4054 best_fps = std_fps.num;
4057 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4058 error = fabs(av_q2d(codec_frame_rate) /
4059 av_q2d(std_fps) - 1);
4060 if (error < best_error) {
4062 best_fps = std_fps.num;
4067 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4068 best_fps, 12 * 1001, INT_MAX);
4071 if (!st->r_frame_rate.num) {
4072 if ( avctx->time_base.den * (int64_t) st->time_base.num
4073 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4074 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4075 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4077 st->r_frame_rate.num = st->time_base.den;
4078 st->r_frame_rate.den = st->time_base.num;
4081 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4082 AVRational hw_ratio = { avctx->height, avctx->width };
4083 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4086 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4087 if (!avctx->bits_per_coded_sample)
4088 avctx->bits_per_coded_sample =
4089 av_get_bits_per_sample(avctx->codec_id);
4090 // set stream disposition based on audio service type
4091 switch (avctx->audio_service_type) {
4092 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4093 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4095 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4096 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4098 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4099 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4101 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4102 st->disposition = AV_DISPOSITION_COMMENT;
4104 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4105 st->disposition = AV_DISPOSITION_KARAOKE;
4112 estimate_timings(ic, old_offset);
4114 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4116 if (ret >= 0 && ic->nb_streams)
4117 /* We could not have all the codec parameters before EOF. */
4119 for (i = 0; i < ic->nb_streams; i++) {
4121 st = ic->streams[i];
4123 /* if no packet was ever seen, update context now for has_codec_parameters */
4124 if (!st->internal->avctx_inited) {
4125 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4126 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4127 st->codecpar->format = st->internal->avctx->sample_fmt;
4128 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4130 goto find_stream_info_err;
4132 if (!has_codec_parameters(st, &errmsg)) {
4134 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4135 av_log(ic, AV_LOG_WARNING,
4136 "Could not find codec parameters for stream %d (%s): %s\n"
4137 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4144 compute_chapters_end(ic);
4146 /* update the stream parameters from the internal codec contexts */
4147 for (i = 0; i < ic->nb_streams; i++) {
4148 st = ic->streams[i];
4150 if (st->internal->avctx_inited) {
4151 int orig_w = st->codecpar->width;
4152 int orig_h = st->codecpar->height;
4153 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4155 goto find_stream_info_err;
4156 ret = add_coded_side_data(st, st->internal->avctx);
4158 goto find_stream_info_err;
4160 // The decoder might reduce the video size by the lowres factor.
4161 if (st->internal->avctx->lowres && orig_w) {
4162 st->codecpar->width = orig_w;
4163 st->codecpar->height = orig_h;
4168 #if FF_API_LAVF_AVCTX
4169 FF_DISABLE_DEPRECATION_WARNINGS
4170 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4172 goto find_stream_info_err;
4175 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4176 // by the lowres factor.
4177 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4178 st->codec->lowres = st->internal->avctx->lowres;
4179 st->codec->width = st->internal->avctx->width;
4180 st->codec->height = st->internal->avctx->height;
4184 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4185 st->codec->time_base = st->internal->avctx->time_base;
4186 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4188 st->codec->framerate = st->avg_frame_rate;
4190 if (st->internal->avctx->subtitle_header) {
4191 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4192 if (!st->codec->subtitle_header)
4193 goto find_stream_info_err;
4194 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4195 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4196 st->codec->subtitle_header_size);
4199 // Fields unavailable in AVCodecParameters
4200 st->codec->coded_width = st->internal->avctx->coded_width;
4201 st->codec->coded_height = st->internal->avctx->coded_height;
4202 st->codec->properties = st->internal->avctx->properties;
4203 FF_ENABLE_DEPRECATION_WARNINGS
4206 st->internal->avctx_inited = 0;
4209 find_stream_info_err:
4210 for (i = 0; i < ic->nb_streams; i++) {
4211 st = ic->streams[i];
4213 av_freep(&st->info->duration_error);
4214 avcodec_close(ic->streams[i]->internal->avctx);
4215 av_freep(&ic->streams[i]->info);
4216 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4217 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4220 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4221 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4224 unref_then_goto_end:
4225 av_packet_unref(&pkt1);
4226 goto find_stream_info_err;
4229 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4233 for (i = 0; i < ic->nb_programs; i++) {
4234 if (ic->programs[i] == last) {
4238 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4239 if (ic->programs[i]->stream_index[j] == s)
4240 return ic->programs[i];
4246 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4247 int wanted_stream_nb, int related_stream,
4248 AVCodec **decoder_ret, int flags)
4250 int i, nb_streams = ic->nb_streams;
4251 int ret = AVERROR_STREAM_NOT_FOUND;
4252 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4253 int count, multiframe, disposition;
4254 int64_t best_bitrate = -1;
4256 unsigned *program = NULL;
4257 const AVCodec *decoder = NULL, *best_decoder = NULL;
4259 if (related_stream >= 0 && wanted_stream_nb < 0) {
4260 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4262 program = p->stream_index;
4263 nb_streams = p->nb_stream_indexes;
4266 for (i = 0; i < nb_streams; i++) {
4267 int real_stream_index = program ? program[i] : i;
4268 AVStream *st = ic->streams[real_stream_index];
4269 AVCodecParameters *par = st->codecpar;
4270 if (par->codec_type != type)
4272 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4274 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4277 decoder = find_decoder(ic, st, par->codec_id);
4280 ret = AVERROR_DECODER_NOT_FOUND;
4284 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4285 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4286 count = st->codec_info_nb_frames;
4287 bitrate = par->bit_rate;
4288 multiframe = FFMIN(5, count);
4289 if ((best_disposition > disposition) ||
4290 (best_disposition == disposition && best_multiframe > multiframe) ||
4291 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4292 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4294 best_disposition = disposition;
4296 best_bitrate = bitrate;
4297 best_multiframe = multiframe;
4298 ret = real_stream_index;
4299 best_decoder = decoder;
4300 if (program && i == nb_streams - 1 && ret < 0) {
4302 nb_streams = ic->nb_streams;
4303 /* no related stream found, try again with everything */
4308 *decoder_ret = (AVCodec*)best_decoder;
4312 /*******************************************************/
4314 int av_read_play(AVFormatContext *s)
4316 if (s->iformat->read_play)
4317 return s->iformat->read_play(s);
4319 return avio_pause(s->pb, 0);
4320 return AVERROR(ENOSYS);
4323 int av_read_pause(AVFormatContext *s)
4325 if (s->iformat->read_pause)
4326 return s->iformat->read_pause(s);
4328 return avio_pause(s->pb, 1);
4329 return AVERROR(ENOSYS);
4332 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4337 dst->time_base = src->time_base;
4338 dst->nb_frames = src->nb_frames;
4339 dst->disposition = src->disposition;
4340 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4341 dst->avg_frame_rate = src->avg_frame_rate;
4342 dst->r_frame_rate = src->r_frame_rate;
4344 av_dict_free(&dst->metadata);
4345 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4349 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4353 /* Free existing side data*/
4354 for (i = 0; i < dst->nb_side_data; i++)
4355 av_free(dst->side_data[i].data);
4356 av_freep(&dst->side_data);
4357 dst->nb_side_data = 0;
4359 /* Copy side data if present */
4360 if (src->nb_side_data) {
4361 dst->side_data = av_mallocz_array(src->nb_side_data,
4362 sizeof(AVPacketSideData));
4363 if (!dst->side_data)
4364 return AVERROR(ENOMEM);
4365 dst->nb_side_data = src->nb_side_data;
4367 for (i = 0; i < src->nb_side_data; i++) {
4368 uint8_t *data = av_memdup(src->side_data[i].data,
4369 src->side_data[i].size);
4371 return AVERROR(ENOMEM);
4372 dst->side_data[i].type = src->side_data[i].type;
4373 dst->side_data[i].size = src->side_data[i].size;
4374 dst->side_data[i].data = data;
4378 #if FF_API_LAVF_FFSERVER
4379 FF_DISABLE_DEPRECATION_WARNINGS
4380 av_freep(&dst->recommended_encoder_configuration);
4381 if (src->recommended_encoder_configuration) {
4382 const char *conf_str = src->recommended_encoder_configuration;
4383 dst->recommended_encoder_configuration = av_strdup(conf_str);
4384 if (!dst->recommended_encoder_configuration)
4385 return AVERROR(ENOMEM);
4387 FF_ENABLE_DEPRECATION_WARNINGS
4393 static void free_stream(AVStream **pst)
4395 AVStream *st = *pst;
4401 for (i = 0; i < st->nb_side_data; i++)
4402 av_freep(&st->side_data[i].data);
4403 av_freep(&st->side_data);
4406 av_parser_close(st->parser);
4408 if (st->attached_pic.data)
4409 av_packet_unref(&st->attached_pic);
4412 avcodec_free_context(&st->internal->avctx);
4413 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4414 av_bsf_free(&st->internal->bsfcs[i]);
4415 av_freep(&st->internal->bsfcs);
4417 av_freep(&st->internal->priv_pts);
4418 av_bsf_free(&st->internal->extract_extradata.bsf);
4419 av_packet_free(&st->internal->extract_extradata.pkt);
4421 av_freep(&st->internal);
4423 av_dict_free(&st->metadata);
4424 avcodec_parameters_free(&st->codecpar);
4425 av_freep(&st->probe_data.buf);
4426 av_freep(&st->index_entries);
4427 #if FF_API_LAVF_AVCTX
4428 FF_DISABLE_DEPRECATION_WARNINGS
4429 avcodec_free_context(&st->codec);
4430 FF_ENABLE_DEPRECATION_WARNINGS
4432 av_freep(&st->priv_data);
4434 av_freep(&st->info->duration_error);
4435 av_freep(&st->info);
4436 #if FF_API_LAVF_FFSERVER
4437 FF_DISABLE_DEPRECATION_WARNINGS
4438 av_freep(&st->recommended_encoder_configuration);
4439 FF_ENABLE_DEPRECATION_WARNINGS
4445 void ff_free_stream(AVFormatContext *s, AVStream *st)
4447 av_assert0(s->nb_streams>0);
4448 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4450 free_stream(&s->streams[ --s->nb_streams ]);
4453 void avformat_free_context(AVFormatContext *s)
4460 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4461 s->oformat->deinit(s);
4464 if (s->iformat && s->iformat->priv_class && s->priv_data)
4465 av_opt_free(s->priv_data);
4466 if (s->oformat && s->oformat->priv_class && s->priv_data)
4467 av_opt_free(s->priv_data);
4469 for (i = 0; i < s->nb_streams; i++)
4470 free_stream(&s->streams[i]);
4473 for (i = 0; i < s->nb_programs; i++) {
4474 av_dict_free(&s->programs[i]->metadata);
4475 av_freep(&s->programs[i]->stream_index);
4476 av_freep(&s->programs[i]);
4480 av_freep(&s->programs);
4481 av_freep(&s->priv_data);
4482 while (s->nb_chapters--) {
4483 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4484 av_freep(&s->chapters[s->nb_chapters]);
4486 av_freep(&s->chapters);
4487 av_dict_free(&s->metadata);
4488 av_dict_free(&s->internal->id3v2_meta);
4489 av_freep(&s->streams);
4490 flush_packet_queue(s);
4491 av_freep(&s->internal);
4496 void avformat_close_input(AVFormatContext **ps)
4507 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4508 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4511 flush_packet_queue(s);
4514 if (s->iformat->read_close)
4515 s->iformat->read_close(s);
4517 avformat_free_context(s);
4524 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4530 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4531 if (s->max_streams < INT_MAX/sizeof(*streams))
4532 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);
4535 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4538 s->streams = streams;
4540 st = av_mallocz(sizeof(AVStream));
4543 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4547 st->info->last_dts = AV_NOPTS_VALUE;
4549 #if FF_API_LAVF_AVCTX
4550 FF_DISABLE_DEPRECATION_WARNINGS
4551 st->codec = avcodec_alloc_context3(c);
4557 FF_ENABLE_DEPRECATION_WARNINGS
4560 st->internal = av_mallocz(sizeof(*st->internal));
4564 st->codecpar = avcodec_parameters_alloc();
4568 st->internal->avctx = avcodec_alloc_context3(NULL);
4569 if (!st->internal->avctx)
4573 #if FF_API_LAVF_AVCTX
4574 FF_DISABLE_DEPRECATION_WARNINGS
4575 /* no default bitrate if decoding */
4576 st->codec->bit_rate = 0;
4577 FF_ENABLE_DEPRECATION_WARNINGS
4580 /* default pts setting is MPEG-like */
4581 avpriv_set_pts_info(st, 33, 1, 90000);
4582 /* we set the current DTS to 0 so that formats without any timestamps
4583 * but durations get some timestamps, formats with some unknown
4584 * timestamps have their first few packets buffered and the
4585 * timestamps corrected before they are returned to the user */
4586 st->cur_dts = RELATIVE_TS_BASE;
4588 st->cur_dts = AV_NOPTS_VALUE;
4591 st->index = s->nb_streams;
4592 st->start_time = AV_NOPTS_VALUE;
4593 st->duration = AV_NOPTS_VALUE;
4594 st->first_dts = AV_NOPTS_VALUE;
4595 st->probe_packets = s->max_probe_packets;
4596 st->pts_wrap_reference = AV_NOPTS_VALUE;
4597 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4599 st->last_IP_pts = AV_NOPTS_VALUE;
4600 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4601 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4602 st->pts_buffer[i] = AV_NOPTS_VALUE;
4604 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4606 #if FF_API_R_FRAME_RATE
4607 st->info->last_dts = AV_NOPTS_VALUE;
4609 st->info->fps_first_dts = AV_NOPTS_VALUE;
4610 st->info->fps_last_dts = AV_NOPTS_VALUE;
4612 st->inject_global_side_data = s->internal->inject_global_side_data;
4614 st->internal->need_context_update = 1;
4616 s->streams[s->nb_streams++] = st;
4623 AVProgram *av_new_program(AVFormatContext *ac, int id)
4625 AVProgram *program = NULL;
4628 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4630 for (i = 0; i < ac->nb_programs; i++)
4631 if (ac->programs[i]->id == id)
4632 program = ac->programs[i];
4635 program = av_mallocz(sizeof(AVProgram));
4638 dynarray_add(&ac->programs, &ac->nb_programs, program);
4639 program->discard = AVDISCARD_NONE;
4640 program->pmt_version = -1;
4643 program->pts_wrap_reference = AV_NOPTS_VALUE;
4644 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4646 program->start_time =
4647 program->end_time = AV_NOPTS_VALUE;
4652 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4653 int64_t start, int64_t end, const char *title)
4655 AVChapter *chapter = NULL;
4658 if (end != AV_NOPTS_VALUE && start > end) {
4659 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4663 for (i = 0; i < s->nb_chapters; i++)
4664 if (s->chapters[i]->id == id)
4665 chapter = s->chapters[i];
4668 chapter = av_mallocz(sizeof(AVChapter));
4671 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4673 av_dict_set(&chapter->metadata, "title", title, 0);
4675 chapter->time_base = time_base;
4676 chapter->start = start;
4682 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4685 AVProgram *program = NULL;
4688 if (idx >= ac->nb_streams) {
4689 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4693 for (i = 0; i < ac->nb_programs; i++) {
4694 if (ac->programs[i]->id != progid)
4696 program = ac->programs[i];
4697 for (j = 0; j < program->nb_stream_indexes; j++)
4698 if (program->stream_index[j] == idx)
4701 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4704 program->stream_index = tmp;
4705 program->stream_index[program->nb_stream_indexes++] = idx;
4710 uint64_t ff_ntp_time(void)
4712 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4715 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4717 uint64_t ntp_ts, frac_part, sec;
4720 //current ntp time in seconds and micro seconds
4721 sec = ntp_time_us / 1000000;
4722 usec = ntp_time_us % 1000000;
4724 //encoding in ntp timestamp format
4725 frac_part = usec * 0xFFFFFFFFULL;
4726 frac_part /= 1000000;
4728 if (sec > 0xFFFFFFFFULL)
4729 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4732 ntp_ts |= frac_part;
4737 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4740 char *q, buf1[20], c;
4741 int nd, len, percentd_found;
4753 while (av_isdigit(*p))
4754 nd = nd * 10 + *p++ - '0';
4756 } while (av_isdigit(c));
4762 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4767 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4769 if ((q - buf + len) > buf_size - 1)
4771 memcpy(q, buf1, len);
4779 if ((q - buf) < buf_size - 1)
4783 if (!percentd_found)
4792 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4794 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4797 void av_url_split(char *proto, int proto_size,
4798 char *authorization, int authorization_size,
4799 char *hostname, int hostname_size,
4800 int *port_ptr, char *path, int path_size, const char *url)
4802 const char *p, *ls, *at, *at2, *col, *brk;
4808 if (authorization_size > 0)
4809 authorization[0] = 0;
4810 if (hostname_size > 0)
4815 /* parse protocol */
4816 if ((p = strchr(url, ':'))) {
4817 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4824 /* no protocol means plain filename */
4825 av_strlcpy(path, url, path_size);
4829 /* separate path from hostname */
4830 ls = p + strcspn(p, "/?#");
4831 av_strlcpy(path, ls, path_size);
4833 /* the rest is hostname, use that to parse auth/port */
4835 /* authorization (user[:pass]@hostname) */
4837 while ((at = strchr(p, '@')) && at < ls) {
4838 av_strlcpy(authorization, at2,
4839 FFMIN(authorization_size, at + 1 - at2));
4840 p = at + 1; /* skip '@' */
4843 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4845 av_strlcpy(hostname, p + 1,
4846 FFMIN(hostname_size, brk - p));
4847 if (brk[1] == ':' && port_ptr)
4848 *port_ptr = atoi(brk + 2);
4849 } else if ((col = strchr(p, ':')) && col < ls) {
4850 av_strlcpy(hostname, p,
4851 FFMIN(col + 1 - p, hostname_size));
4853 *port_ptr = atoi(col + 1);
4855 av_strlcpy(hostname, p,
4856 FFMIN(ls + 1 - p, hostname_size));
4860 int ff_mkdir_p(const char *path)
4863 char *temp = av_strdup(path);
4867 if (!path || !temp) {
4871 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4873 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4877 for ( ; *pos != '\0'; ++pos) {
4878 if (*pos == '/' || *pos == '\\') {
4881 ret = mkdir(temp, 0755);
4886 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4887 ret = mkdir(temp, 0755);
4894 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4897 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4900 'C', 'D', 'E', 'F' };
4901 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4904 'c', 'd', 'e', 'f' };
4905 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4907 for (i = 0; i < s; i++) {
4908 buff[i * 2] = hex_table[src[i] >> 4];
4909 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4915 int ff_hex_to_data(uint8_t *data, const char *p)
4922 p += strspn(p, SPACE_CHARS);
4925 c = av_toupper((unsigned char) *p++);
4926 if (c >= '0' && c <= '9')
4928 else if (c >= 'A' && c <= 'F')
4943 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4944 unsigned int pts_num, unsigned int pts_den)
4947 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4948 if (new_tb.num != pts_num)
4949 av_log(NULL, AV_LOG_DEBUG,
4950 "st:%d removing common factor %d from timebase\n",
4951 s->index, pts_num / new_tb.num);
4953 av_log(NULL, AV_LOG_WARNING,
4954 "st:%d has too large timebase, reducing\n", s->index);
4956 if (new_tb.num <= 0 || new_tb.den <= 0) {
4957 av_log(NULL, AV_LOG_ERROR,
4958 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4959 new_tb.num, new_tb.den,
4963 s->time_base = new_tb;
4964 #if FF_API_LAVF_AVCTX
4965 FF_DISABLE_DEPRECATION_WARNINGS
4966 s->codec->pkt_timebase = new_tb;
4967 FF_ENABLE_DEPRECATION_WARNINGS
4969 s->internal->avctx->pkt_timebase = new_tb;
4970 s->pts_wrap_bits = pts_wrap_bits;
4973 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4976 const char *ptr = str;
4978 /* Parse key=value pairs. */
4981 char *dest = NULL, *dest_end;
4982 int key_len, dest_len = 0;
4984 /* Skip whitespace and potential commas. */
4985 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4992 if (!(ptr = strchr(key, '=')))
4995 key_len = ptr - key;
4997 callback_get_buf(context, key, key_len, &dest, &dest_len);
4998 dest_end = dest + dest_len - 1;
5002 while (*ptr && *ptr != '\"') {
5006 if (dest && dest < dest_end)
5010 if (dest && dest < dest_end)
5018 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5019 if (dest && dest < dest_end)
5027 int ff_find_stream_index(AVFormatContext *s, int id)
5030 for (i = 0; i < s->nb_streams; i++)
5031 if (s->streams[i]->id == id)
5036 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5040 unsigned int codec_tag;
5041 if (ofmt->query_codec)
5042 return ofmt->query_codec(codec_id, std_compliance);
5043 else if (ofmt->codec_tag)
5044 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5045 else if (codec_id == ofmt->video_codec ||
5046 codec_id == ofmt->audio_codec ||
5047 codec_id == ofmt->subtitle_codec ||
5048 codec_id == ofmt->data_codec)
5051 return AVERROR_PATCHWELCOME;
5054 int avformat_network_init(void)
5058 if ((ret = ff_network_init()) < 0)
5060 if ((ret = ff_tls_init()) < 0)
5066 int avformat_network_deinit(void)
5075 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5076 uint64_t channel_layout, int32_t sample_rate,
5077 int32_t width, int32_t height)
5083 return AVERROR(EINVAL);
5086 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5088 if (channel_layout) {
5090 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5094 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5096 if (width || height) {
5098 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5100 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5102 return AVERROR(ENOMEM);
5103 bytestream_put_le32(&data, flags);
5105 bytestream_put_le32(&data, channels);
5107 bytestream_put_le64(&data, channel_layout);
5109 bytestream_put_le32(&data, sample_rate);
5110 if (width || height) {
5111 bytestream_put_le32(&data, width);
5112 bytestream_put_le32(&data, height);
5117 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5119 AVRational undef = {0, 1};
5120 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5121 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5122 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5124 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5125 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5126 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5127 stream_sample_aspect_ratio = undef;
5129 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5130 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5131 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5132 frame_sample_aspect_ratio = undef;
5134 if (stream_sample_aspect_ratio.num)
5135 return stream_sample_aspect_ratio;
5137 return frame_sample_aspect_ratio;
5140 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5142 AVRational fr = st->r_frame_rate;
5143 AVRational codec_fr = st->internal->avctx->framerate;
5144 AVRational avg_fr = st->avg_frame_rate;
5146 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5147 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5152 if (st->internal->avctx->ticks_per_frame > 1) {
5153 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5154 (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))
5162 * Matches a stream specifier (but ignores requested index).
5164 * @param indexptr set to point to the requested stream index if there is one
5166 * @return <0 on error
5167 * 0 if st is NOT a matching stream
5168 * >0 if st is a matching stream
5170 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5171 const char *spec, const char **indexptr, AVProgram **p)
5173 int match = 1; /* Stores if the specifier matches so far. */
5175 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5179 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5180 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5181 enum AVMediaType type;
5185 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5186 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5187 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5188 case 'd': type = AVMEDIA_TYPE_DATA; break;
5189 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5190 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5191 default: av_assert0(0);
5193 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5194 return AVERROR(EINVAL);
5196 #if FF_API_LAVF_AVCTX
5197 FF_DISABLE_DEPRECATION_WARNINGS
5198 if (type != st->codecpar->codec_type
5199 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5201 FF_ENABLE_DEPRECATION_WARNINGS
5203 if (type != st->codecpar->codec_type)
5206 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5208 } else if (*spec == 'p' && *(spec + 1) == ':') {
5213 prog_id = strtol(spec, &endptr, 0);
5214 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5215 if (spec == endptr || (*endptr && *endptr++ != ':'))
5216 return AVERROR(EINVAL);
5219 for (i = 0; i < s->nb_programs; i++) {
5220 if (s->programs[i]->id != prog_id)
5223 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5224 if (st->index == s->programs[i]->stream_index[j]) {
5227 *p = s->programs[i];
5236 } else if (*spec == '#' ||
5237 (*spec == 'i' && *(spec + 1) == ':')) {
5240 spec += 1 + (*spec == 'i');
5241 stream_id = strtol(spec, &endptr, 0);
5242 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5243 return AVERROR(EINVAL);
5244 return match && (stream_id == st->id);
5245 } else if (*spec == 'm' && *(spec + 1) == ':') {
5246 AVDictionaryEntry *tag;
5252 val = strchr(spec, ':');
5254 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5256 return AVERROR(ENOMEM);
5258 tag = av_dict_get(st->metadata, key, NULL, 0);
5260 if (!val || !strcmp(tag->value, val + 1))
5269 return match && ret;
5270 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5271 AVCodecParameters *par = st->codecpar;
5272 #if FF_API_LAVF_AVCTX
5273 FF_DISABLE_DEPRECATION_WARNINGS
5274 AVCodecContext *codec = st->codec;
5275 FF_ENABLE_DEPRECATION_WARNINGS
5278 switch (par->codec_type) {
5279 case AVMEDIA_TYPE_AUDIO:
5280 val = par->sample_rate && par->channels;
5281 #if FF_API_LAVF_AVCTX
5282 val = val || (codec->sample_rate && codec->channels);
5284 if (par->format == AV_SAMPLE_FMT_NONE
5285 #if FF_API_LAVF_AVCTX
5286 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5291 case AVMEDIA_TYPE_VIDEO:
5292 val = par->width && par->height;
5293 #if FF_API_LAVF_AVCTX
5294 val = val || (codec->width && codec->height);
5296 if (par->format == AV_PIX_FMT_NONE
5297 #if FF_API_LAVF_AVCTX
5298 && codec->pix_fmt == AV_PIX_FMT_NONE
5303 case AVMEDIA_TYPE_UNKNOWN:
5310 #if FF_API_LAVF_AVCTX
5311 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5313 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5316 return AVERROR(EINVAL);
5324 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5329 const char *indexptr = NULL;
5330 AVProgram *p = NULL;
5333 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5340 index = strtol(indexptr, &endptr, 0);
5341 if (*endptr) { /* We can't have anything after the requested index. */
5342 ret = AVERROR(EINVAL);
5346 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5347 if (spec == indexptr)
5348 return (index == st->index);
5350 /* If we requested a matching stream index, we have to ensure st is that. */
5351 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5352 for (int i = 0; i < nb_streams && index >= 0; i++) {
5353 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5354 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5357 if (ret > 0 && index-- == 0 && st == candidate)
5363 if (ret == AVERROR(EINVAL))
5364 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5368 int ff_generate_avci_extradata(AVStream *st)
5370 static const uint8_t avci100_1080p_extradata[] = {
5372 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5373 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5374 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5375 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5376 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5377 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5378 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5379 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5380 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5382 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5385 static const uint8_t avci100_1080i_extradata[] = {
5387 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5388 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5389 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5390 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5391 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5392 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5393 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5394 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5395 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5396 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5397 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5399 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5402 static const uint8_t avci50_1080p_extradata[] = {
5404 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5405 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5406 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5407 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5408 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5409 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5410 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5411 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5412 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5414 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5417 static const uint8_t avci50_1080i_extradata[] = {
5419 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5420 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5421 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5422 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5423 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5424 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5425 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5426 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5427 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5428 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5429 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5431 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5434 static const uint8_t avci100_720p_extradata[] = {
5436 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5437 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5438 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5439 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5440 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5441 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5442 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5443 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5444 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5445 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5447 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5450 static const uint8_t avci50_720p_extradata[] = {
5452 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5453 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5454 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5455 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5456 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5457 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5458 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5459 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5460 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5462 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5466 const uint8_t *data = NULL;
5469 if (st->codecpar->width == 1920) {
5470 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5471 data = avci100_1080p_extradata;
5472 size = sizeof(avci100_1080p_extradata);
5474 data = avci100_1080i_extradata;
5475 size = sizeof(avci100_1080i_extradata);
5477 } else if (st->codecpar->width == 1440) {
5478 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5479 data = avci50_1080p_extradata;
5480 size = sizeof(avci50_1080p_extradata);
5482 data = avci50_1080i_extradata;
5483 size = sizeof(avci50_1080i_extradata);
5485 } else if (st->codecpar->width == 1280) {
5486 data = avci100_720p_extradata;
5487 size = sizeof(avci100_720p_extradata);
5488 } else if (st->codecpar->width == 960) {
5489 data = avci50_720p_extradata;
5490 size = sizeof(avci50_720p_extradata);
5496 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5498 memcpy(st->codecpar->extradata, data, size);
5503 uint8_t *av_stream_get_side_data(const AVStream *st,
5504 enum AVPacketSideDataType type, int *size)
5508 for (i = 0; i < st->nb_side_data; i++) {
5509 if (st->side_data[i].type == type) {
5511 *size = st->side_data[i].size;
5512 return st->side_data[i].data;
5518 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5519 uint8_t *data, size_t size)
5521 AVPacketSideData *sd, *tmp;
5524 for (i = 0; i < st->nb_side_data; i++) {
5525 sd = &st->side_data[i];
5527 if (sd->type == type) {
5528 av_freep(&sd->data);
5535 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5536 return AVERROR(ERANGE);
5538 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5540 return AVERROR(ENOMEM);
5543 st->side_data = tmp;
5546 sd = &st->side_data[st->nb_side_data - 1];
5554 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5558 uint8_t *data = av_malloc(size);
5563 ret = av_stream_add_side_data(st, type, data, size);
5572 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5575 const AVBitStreamFilter *bsf;
5577 AVCodecParameters *in_par;
5579 if (!(bsf = av_bsf_get_by_name(name))) {
5580 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5581 return AVERROR_BSF_NOT_FOUND;
5584 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5587 if (st->internal->nb_bsfcs) {
5588 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5589 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5591 in_par = st->codecpar;
5592 bsfc->time_base_in = st->time_base;
5595 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5600 if (args && bsfc->filter->priv_class) {
5601 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5602 const char * shorthand[2] = {NULL};
5605 shorthand[0] = opt->name;
5607 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5613 if ((ret = av_bsf_init(bsfc)) < 0) {
5618 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5623 av_log(NULL, AV_LOG_VERBOSE,
5624 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5625 name, args ? args : "");
5630 FF_DISABLE_DEPRECATION_WARNINGS
5631 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5632 AVBitStreamFilterContext *bsfc)
5636 AVPacket new_pkt = *pkt;
5637 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5638 &new_pkt.data, &new_pkt.size,
5639 pkt->data, pkt->size,
5640 pkt->flags & AV_PKT_FLAG_KEY);
5641 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5642 av_packet_unref(pkt);
5643 memset(pkt, 0, sizeof(*pkt));
5646 if(a == 0 && new_pkt.data != pkt->data) {
5647 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
5649 memcpy(t, new_pkt.data, new_pkt.size);
5650 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5655 a = AVERROR(ENOMEM);
5659 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5660 av_buffer_default_free, NULL, 0);
5662 pkt->side_data = NULL;
5663 pkt->side_data_elems = 0;
5664 av_packet_unref(pkt);
5666 av_freep(&new_pkt.data);
5667 a = AVERROR(ENOMEM);
5671 av_log(codec, AV_LOG_ERROR,
5672 "Failed to open bitstream filter %s for stream %d with codec %s",
5673 bsfc->filter->name, pkt->stream_index,
5674 codec->codec ? codec->codec->name : "copy");
5684 FF_ENABLE_DEPRECATION_WARNINGS
5687 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5690 return AVERROR(EINVAL);
5692 if (!(s->oformat->flags & AVFMT_NOFILE))
5693 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5697 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5700 s->io_close(s, *pb);
5704 int ff_is_http_proto(char *filename) {
5705 const char *proto = avio_find_protocol_name(filename);
5706 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5709 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5711 AVDictionaryEntry *entry;
5712 int64_t parsed_timestamp;
5714 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5715 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5716 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5719 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5726 int ff_standardize_creation_time(AVFormatContext *s)
5729 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5731 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5735 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5740 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5742 if (size != AVPALETTE_SIZE) {
5743 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5744 return AVERROR_INVALIDDATA;
5746 memcpy(palette, side_data, AVPALETTE_SIZE);
5750 if (ret == CONTAINS_PAL) {
5752 for (i = 0; i < AVPALETTE_COUNT; i++)
5753 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5760 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5765 ret = av_bprint_finalize(buf, &str);
5768 if (!av_bprint_is_complete(buf)) {
5770 return AVERROR(ENOMEM);
5773 par->extradata = str;
5774 /* Note: the string is NUL terminated (so extradata can be read as a
5775 * string), but the ending character is not accounted in the size (in
5776 * binary formats you are likely not supposed to mux that character). When
5777 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5779 par->extradata_size = buf->len;
5783 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5784 AVStream *ost, const AVStream *ist,
5785 enum AVTimebaseSource copy_tb)
5787 //TODO: use [io]st->internal->avctx
5788 const AVCodecContext *dec_ctx = ist->codec;
5789 AVCodecContext *enc_ctx = ost->codec;
5791 enc_ctx->time_base = ist->time_base;
5793 * Avi is a special case here because it supports variable fps but
5794 * having the fps and timebase differe significantly adds quite some
5797 if (!strcmp(ofmt->name, "avi")) {
5798 #if FF_API_R_FRAME_RATE
5799 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5800 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5801 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5802 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5803 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5804 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5805 enc_ctx->time_base.num = ist->r_frame_rate.den;
5806 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5807 enc_ctx->ticks_per_frame = 2;
5810 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5811 && av_q2d(ist->time_base) < 1.0/500
5812 || copy_tb == AVFMT_TBCF_DECODER) {
5813 enc_ctx->time_base = dec_ctx->time_base;
5814 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5815 enc_ctx->time_base.den *= 2;
5816 enc_ctx->ticks_per_frame = 2;
5818 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5819 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5820 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5821 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5822 && av_q2d(ist->time_base) < 1.0/500
5823 || copy_tb == AVFMT_TBCF_DECODER) {
5824 enc_ctx->time_base = dec_ctx->time_base;
5825 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5829 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5830 && dec_ctx->time_base.num < dec_ctx->time_base.den
5831 && dec_ctx->time_base.num > 0
5832 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5833 enc_ctx->time_base = dec_ctx->time_base;
5836 if (ost->avg_frame_rate.num)
5837 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5839 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5840 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5845 AVRational av_stream_get_codec_timebase(const AVStream *st)
5847 // See avformat_transfer_internal_stream_timing_info() TODO.
5848 #if FF_API_LAVF_AVCTX
5849 FF_DISABLE_DEPRECATION_WARNINGS
5850 return st->codec->time_base;
5851 FF_ENABLE_DEPRECATION_WARNINGS
5853 return st->internal->avctx->time_base;
5857 void ff_format_set_url(AVFormatContext *s, char *url)
5862 #if FF_API_FORMAT_FILENAME
5863 FF_DISABLE_DEPRECATION_WARNINGS
5864 av_strlcpy(s->filename, url, sizeof(s->filename));
5865 FF_ENABLE_DEPRECATION_WARNINGS