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 int level = AV_LOG_WARNING;
639 if (s->error_recognition & AV_EF_COMPLIANT)
640 level = AV_LOG_ERROR;
641 av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
642 av_dict_free(&s->internal->id3v2_meta);
643 if (s->error_recognition & AV_EF_EXPLODE)
644 return AVERROR_INVALIDDATA;
647 if (id3v2_extra_meta) {
648 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
649 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
650 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
652 if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
654 if ((ret = ff_id3v2_parse_priv(s, &id3v2_extra_meta)) < 0)
657 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
659 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
661 if ((ret = avformat_queue_attached_pictures(s)) < 0)
664 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
665 s->internal->data_offset = avio_tell(s->pb);
667 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
669 update_stream_avctx(s);
671 for (i = 0; i < s->nb_streams; i++)
672 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
675 av_dict_free(options);
682 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
684 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
686 avformat_free_context(s);
691 /*******************************************************/
693 static void force_codec_ids(AVFormatContext *s, AVStream *st)
695 switch (st->codecpar->codec_type) {
696 case AVMEDIA_TYPE_VIDEO:
697 if (s->video_codec_id)
698 st->codecpar->codec_id = s->video_codec_id;
700 case AVMEDIA_TYPE_AUDIO:
701 if (s->audio_codec_id)
702 st->codecpar->codec_id = s->audio_codec_id;
704 case AVMEDIA_TYPE_SUBTITLE:
705 if (s->subtitle_codec_id)
706 st->codecpar->codec_id = s->subtitle_codec_id;
708 case AVMEDIA_TYPE_DATA:
709 if (s->data_codec_id)
710 st->codecpar->codec_id = s->data_codec_id;
715 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
717 if (st->request_probe>0) {
718 AVProbeData *pd = &st->probe_data;
720 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
724 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
726 av_log(s, AV_LOG_WARNING,
727 "Failed to reallocate probe buffer for stream %d\n",
732 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
733 pd->buf_size += pkt->size;
734 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
737 st->probe_packets = 0;
739 av_log(s, AV_LOG_WARNING,
740 "nothing to probe for stream %d\n", st->index);
744 end= s->internal->raw_packet_buffer_remaining_size <= 0
745 || st->probe_packets<= 0;
747 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
748 int score = set_codec_from_probe_data(s, st, pd);
749 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
753 st->request_probe = -1;
754 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
755 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
757 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
759 force_codec_ids(s, st);
765 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
767 int64_t ref = pkt->dts;
768 int i, pts_wrap_behavior;
769 int64_t pts_wrap_reference;
770 AVProgram *first_program;
772 if (ref == AV_NOPTS_VALUE)
774 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
776 ref &= (1LL << st->pts_wrap_bits)-1;
778 // reference time stamp should be 60 s before first time stamp
779 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
780 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
781 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
782 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
783 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
785 first_program = av_find_program_from_stream(s, NULL, stream_index);
787 if (!first_program) {
788 int default_stream_index = av_find_default_stream_index(s);
789 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
790 for (i = 0; i < s->nb_streams; i++) {
791 if (av_find_program_from_stream(s, NULL, i))
793 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
794 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
798 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
799 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
803 AVProgram *program = first_program;
805 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
806 pts_wrap_reference = program->pts_wrap_reference;
807 pts_wrap_behavior = program->pts_wrap_behavior;
810 program = av_find_program_from_stream(s, program, stream_index);
813 // update every program with differing pts_wrap_reference
814 program = first_program;
816 if (program->pts_wrap_reference != pts_wrap_reference) {
817 for (i = 0; i<program->nb_stream_indexes; i++) {
818 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
819 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
822 program->pts_wrap_reference = pts_wrap_reference;
823 program->pts_wrap_behavior = pts_wrap_behavior;
825 program = av_find_program_from_stream(s, program, stream_index);
831 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
841 AVPacketList *pktl = s->internal->raw_packet_buffer;
842 const AVPacket *pkt1;
845 st = s->streams[pktl->pkt.stream_index];
846 if (s->internal->raw_packet_buffer_remaining_size <= 0)
847 if ((err = probe_codec(s, st, NULL)) < 0)
849 if (st->request_probe <= 0) {
850 ff_packet_list_get(&s->internal->raw_packet_buffer,
851 &s->internal->raw_packet_buffer_end, pkt);
852 s->internal->raw_packet_buffer_remaining_size += pkt->size;
857 ret = s->iformat->read_packet(s, pkt);
859 av_packet_unref(pkt);
861 /* Some demuxers return FFERROR_REDO when they consume
862 data and discard it (ignored streams, junk, extradata).
863 We must re-call the demuxer to get the real packet. */
864 if (ret == FFERROR_REDO)
866 if (!pktl || ret == AVERROR(EAGAIN))
868 for (i = 0; i < s->nb_streams; i++) {
870 if (st->probe_packets || st->request_probe > 0)
871 if ((err = probe_codec(s, st, NULL)) < 0)
873 av_assert0(st->request_probe <= 0);
878 err = av_packet_make_refcounted(pkt);
880 av_packet_unref(pkt);
884 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
885 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
886 av_log(s, AV_LOG_WARNING,
887 "Dropped corrupted packet (stream = %d)\n",
889 av_packet_unref(pkt);
893 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
894 "Invalid stream index.\n");
896 st = s->streams[pkt->stream_index];
898 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
899 // correct first time stamps to negative values
900 if (!is_relative(st->first_dts))
901 st->first_dts = wrap_timestamp(st, st->first_dts);
902 if (!is_relative(st->start_time))
903 st->start_time = wrap_timestamp(st, st->start_time);
904 if (!is_relative(st->cur_dts))
905 st->cur_dts = wrap_timestamp(st, st->cur_dts);
908 pkt->dts = wrap_timestamp(st, pkt->dts);
909 pkt->pts = wrap_timestamp(st, pkt->pts);
911 force_codec_ids(s, st);
913 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
914 if (s->use_wallclock_as_timestamps)
915 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
917 if (!pktl && st->request_probe <= 0)
920 err = ff_packet_list_put(&s->internal->raw_packet_buffer,
921 &s->internal->raw_packet_buffer_end,
924 av_packet_unref(pkt);
927 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
928 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
930 if ((err = probe_codec(s, st, pkt1)) < 0)
936 /**********************************************************/
938 static int determinable_frame_size(AVCodecContext *avctx)
940 switch(avctx->codec_id) {
941 case AV_CODEC_ID_MP1:
942 case AV_CODEC_ID_MP2:
943 case AV_CODEC_ID_MP3:
944 case AV_CODEC_ID_CODEC2:
952 * Return the frame duration in seconds. Return 0 if not available.
954 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
955 AVCodecParserContext *pc, AVPacket *pkt)
957 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
958 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
959 int frame_size, sample_rate;
961 #if FF_API_LAVF_AVCTX
962 FF_DISABLE_DEPRECATION_WARNINGS
963 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
964 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
965 FF_ENABLE_DEPRECATION_WARNINGS
970 switch (st->codecpar->codec_type) {
971 case AVMEDIA_TYPE_VIDEO:
972 if (st->r_frame_rate.num && !pc && s->iformat) {
973 *pnum = st->r_frame_rate.den;
974 *pden = st->r_frame_rate.num;
975 } else if (st->time_base.num * 1000LL > st->time_base.den) {
976 *pnum = st->time_base.num;
977 *pden = st->time_base.den;
978 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
979 av_assert0(st->internal->avctx->ticks_per_frame);
980 av_reduce(pnum, pden,
982 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
985 if (pc && pc->repeat_pict) {
986 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
987 av_reduce(pnum, pden,
988 (*pnum) * (1LL + pc->repeat_pict),
992 /* If this codec can be interlaced or progressive then we need
993 * a parser to compute duration of a packet. Thus if we have
994 * no parser in such case leave duration undefined. */
995 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
999 case AVMEDIA_TYPE_AUDIO:
1000 if (st->internal->avctx_inited) {
1001 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
1002 sample_rate = st->internal->avctx->sample_rate;
1004 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
1005 sample_rate = st->codecpar->sample_rate;
1007 if (frame_size <= 0 || sample_rate <= 0)
1010 *pden = sample_rate;
1017 static int is_intra_only(enum AVCodecID id)
1019 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1022 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1023 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1028 static int has_decode_delay_been_guessed(AVStream *st)
1030 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1031 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1033 #if CONFIG_H264_DECODER
1034 if (st->internal->avctx->has_b_frames &&
1035 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1038 if (st->internal->avctx->has_b_frames<3)
1039 return st->nb_decoded_frames >= 7;
1040 else if (st->internal->avctx->has_b_frames<4)
1041 return st->nb_decoded_frames >= 18;
1043 return st->nb_decoded_frames >= 20;
1046 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1050 if (pktl == s->internal->packet_buffer_end)
1051 return s->internal->parse_queue;
1055 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1056 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1057 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1060 int delay = st->internal->avctx->has_b_frames;
1063 if (dts == AV_NOPTS_VALUE) {
1064 int64_t best_score = INT64_MAX;
1065 for (i = 0; i<delay; i++) {
1066 if (st->pts_reorder_error_count[i]) {
1067 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1068 if (score < best_score) {
1070 dts = pts_buffer[i];
1075 for (i = 0; i<delay; i++) {
1076 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1077 int64_t diff = FFABS(pts_buffer[i] - dts)
1078 + (uint64_t)st->pts_reorder_error[i];
1079 diff = FFMAX(diff, st->pts_reorder_error[i]);
1080 st->pts_reorder_error[i] = diff;
1081 st->pts_reorder_error_count[i]++;
1082 if (st->pts_reorder_error_count[i] > 250) {
1083 st->pts_reorder_error[i] >>= 1;
1084 st->pts_reorder_error_count[i] >>= 1;
1091 if (dts == AV_NOPTS_VALUE)
1092 dts = pts_buffer[0];
1098 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1099 * of the packets in a window.
1101 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1102 AVPacketList *pkt_buffer)
1104 AVStream *st = s->streams[stream_index];
1105 int delay = st->internal->avctx->has_b_frames;
1108 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1110 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1111 pts_buffer[i] = AV_NOPTS_VALUE;
1113 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1114 if (pkt_buffer->pkt.stream_index != stream_index)
1117 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1118 pts_buffer[0] = pkt_buffer->pkt.pts;
1119 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1120 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1122 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1127 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1128 int64_t dts, int64_t pts, AVPacket *pkt)
1130 AVStream *st = s->streams[stream_index];
1131 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1132 AVPacketList *pktl_it;
1136 if (st->first_dts != AV_NOPTS_VALUE ||
1137 dts == AV_NOPTS_VALUE ||
1138 st->cur_dts == AV_NOPTS_VALUE ||
1139 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1143 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1145 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1147 if (is_relative(pts))
1150 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1151 if (pktl_it->pkt.stream_index != stream_index)
1153 if (is_relative(pktl_it->pkt.pts))
1154 pktl_it->pkt.pts += shift;
1156 if (is_relative(pktl_it->pkt.dts))
1157 pktl_it->pkt.dts += shift;
1159 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1160 st->start_time = pktl_it->pkt.pts;
1161 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1162 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1166 if (has_decode_delay_been_guessed(st)) {
1167 update_dts_from_pts(s, stream_index, pktl);
1170 if (st->start_time == AV_NOPTS_VALUE) {
1171 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1172 st->start_time = pts;
1174 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1175 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1179 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1180 int stream_index, int duration)
1182 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1183 int64_t cur_dts = RELATIVE_TS_BASE;
1185 if (st->first_dts != AV_NOPTS_VALUE) {
1186 if (st->update_initial_durations_done)
1188 st->update_initial_durations_done = 1;
1189 cur_dts = st->first_dts;
1190 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1191 if (pktl->pkt.stream_index == stream_index) {
1192 if (pktl->pkt.pts != pktl->pkt.dts ||
1193 pktl->pkt.dts != AV_NOPTS_VALUE ||
1196 cur_dts -= duration;
1199 if (pktl && pktl->pkt.dts != st->first_dts) {
1200 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1201 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1205 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1208 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1209 st->first_dts = cur_dts;
1210 } else if (st->cur_dts != RELATIVE_TS_BASE)
1213 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1214 if (pktl->pkt.stream_index != stream_index)
1216 if ((pktl->pkt.pts == pktl->pkt.dts ||
1217 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1218 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1219 pktl->pkt.dts == st->first_dts ||
1220 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1221 !pktl->pkt.duration) {
1222 pktl->pkt.dts = cur_dts;
1223 if (!st->internal->avctx->has_b_frames)
1224 pktl->pkt.pts = cur_dts;
1225 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1226 pktl->pkt.duration = duration;
1229 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1232 st->cur_dts = cur_dts;
1235 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1236 AVCodecParserContext *pc, AVPacket *pkt,
1237 int64_t next_dts, int64_t next_pts)
1239 int num, den, presentation_delayed, delay, i;
1241 AVRational duration;
1242 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1243 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1245 if (s->flags & AVFMT_FLAG_NOFILLIN)
1248 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1249 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1250 if (st->last_dts_for_order_check <= pkt->dts) {
1253 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1254 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1256 st->last_dts_for_order_check);
1257 st->dts_misordered++;
1259 if (st->dts_ordered + st->dts_misordered > 250) {
1260 st->dts_ordered >>= 1;
1261 st->dts_misordered >>= 1;
1265 st->last_dts_for_order_check = pkt->dts;
1266 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1267 pkt->dts = AV_NOPTS_VALUE;
1270 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1271 pkt->dts = AV_NOPTS_VALUE;
1273 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1274 && !st->internal->avctx->has_b_frames)
1275 //FIXME Set low_delay = 0 when has_b_frames = 1
1276 st->internal->avctx->has_b_frames = 1;
1278 /* do we have a video B-frame ? */
1279 delay = st->internal->avctx->has_b_frames;
1280 presentation_delayed = 0;
1282 /* XXX: need has_b_frame, but cannot get it if the codec is
1283 * not initialized */
1285 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1286 presentation_delayed = 1;
1288 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1289 st->pts_wrap_bits < 63 &&
1290 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1291 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1292 pkt->dts -= 1LL << st->pts_wrap_bits;
1294 pkt->pts += 1LL << st->pts_wrap_bits;
1297 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1298 * We take the conservative approach and discard both.
1299 * Note: If this is misbehaving for an H.264 file, then possibly
1300 * presentation_delayed is not set correctly. */
1301 if (delay == 1 && pkt->dts == pkt->pts &&
1302 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1303 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1304 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1305 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1306 pkt->dts = AV_NOPTS_VALUE;
1309 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1310 if (pkt->duration <= 0) {
1311 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1313 duration = (AVRational) {num, den};
1314 pkt->duration = av_rescale_rnd(1,
1315 num * (int64_t) st->time_base.den,
1316 den * (int64_t) st->time_base.num,
1321 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1322 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1324 /* Correct timestamps with byte offset if demuxers only have timestamps
1325 * on packet boundaries */
1326 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1327 /* this will estimate bitrate based on this frame's duration and size */
1328 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1329 if (pkt->pts != AV_NOPTS_VALUE)
1331 if (pkt->dts != AV_NOPTS_VALUE)
1335 /* This may be redundant, but it should not hurt. */
1336 if (pkt->dts != AV_NOPTS_VALUE &&
1337 pkt->pts != AV_NOPTS_VALUE &&
1338 pkt->pts > pkt->dts)
1339 presentation_delayed = 1;
1341 if (s->debug & FF_FDEBUG_TS)
1342 av_log(s, AV_LOG_DEBUG,
1343 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1344 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1345 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1347 /* Interpolate PTS and DTS if they are not present. We skip H264
1348 * currently because delay and has_b_frames are not reliably set. */
1349 if ((delay == 0 || (delay == 1 && pc)) &&
1351 if (presentation_delayed) {
1352 /* DTS = decompression timestamp */
1353 /* PTS = presentation timestamp */
1354 if (pkt->dts == AV_NOPTS_VALUE)
1355 pkt->dts = st->last_IP_pts;
1356 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1357 if (pkt->dts == AV_NOPTS_VALUE)
1358 pkt->dts = st->cur_dts;
1360 /* This is tricky: the dts must be incremented by the duration
1361 * of the frame we are displaying, i.e. the last I- or P-frame. */
1362 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1363 st->last_IP_duration = pkt->duration;
1364 if (pkt->dts != AV_NOPTS_VALUE)
1365 st->cur_dts = pkt->dts + st->last_IP_duration;
1366 if (pkt->dts != AV_NOPTS_VALUE &&
1367 pkt->pts == AV_NOPTS_VALUE &&
1368 st->last_IP_duration > 0 &&
1369 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1370 next_dts != next_pts &&
1371 next_pts != AV_NOPTS_VALUE)
1372 pkt->pts = next_dts;
1374 if ((uint64_t)pkt->duration <= INT32_MAX)
1375 st->last_IP_duration = pkt->duration;
1376 st->last_IP_pts = pkt->pts;
1377 /* Cannot compute PTS if not present (we can compute it only
1378 * by knowing the future. */
1379 } else if (pkt->pts != AV_NOPTS_VALUE ||
1380 pkt->dts != AV_NOPTS_VALUE ||
1381 pkt->duration > 0 ) {
1383 /* presentation is not delayed : PTS and DTS are the same */
1384 if (pkt->pts == AV_NOPTS_VALUE)
1385 pkt->pts = pkt->dts;
1386 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1388 if (pkt->pts == AV_NOPTS_VALUE)
1389 pkt->pts = st->cur_dts;
1390 pkt->dts = pkt->pts;
1391 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1392 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1396 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1397 st->pts_buffer[0] = pkt->pts;
1398 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1399 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1401 if(has_decode_delay_been_guessed(st))
1402 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1404 // We skipped it above so we try here.
1406 // This should happen on the first packet
1407 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1408 if (pkt->dts > st->cur_dts)
1409 st->cur_dts = pkt->dts;
1411 if (s->debug & FF_FDEBUG_TS)
1412 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1413 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1416 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || is_intra_only(st->codecpar->codec_id))
1417 pkt->flags |= AV_PKT_FLAG_KEY;
1418 #if FF_API_CONVERGENCE_DURATION
1419 FF_DISABLE_DEPRECATION_WARNINGS
1421 pkt->convergence_duration = pc->convergence_duration;
1422 FF_ENABLE_DEPRECATION_WARNINGS
1426 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1428 AVPacketList *tmp = *pkt_buf;
1431 AVPacketList *pktl = tmp;
1433 av_packet_unref(&pktl->pkt);
1437 *pkt_buf_end = NULL;
1441 * Parse a packet, add all split parts to parse_queue.
1443 * @param pkt Packet to parse; must not be NULL.
1444 * @param flush Indicates whether to flush. If set, pkt must be blank.
1446 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1447 int stream_index, int flush)
1450 AVStream *st = s->streams[stream_index];
1451 uint8_t *data = pkt->data;
1452 int size = pkt->size;
1453 int ret = 0, got_output = flush;
1455 if (size || flush) {
1456 av_init_packet(&out_pkt);
1457 } else if (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1458 // preserve 0-size sync packets
1459 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1462 while (size > 0 || (flush && got_output)) {
1464 int64_t next_pts = pkt->pts;
1465 int64_t next_dts = pkt->dts;
1467 len = av_parser_parse2(st->parser, st->internal->avctx,
1468 &out_pkt.data, &out_pkt.size, data, size,
1469 pkt->pts, pkt->dts, pkt->pos);
1471 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1473 /* increment read pointer */
1477 got_output = !!out_pkt.size;
1482 if (pkt->buf && out_pkt.data == pkt->data) {
1483 /* reference pkt->buf only when out_pkt.data is guaranteed to point
1484 * to data in it and not in the parser's internal buffer. */
1485 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1486 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1487 out_pkt.buf = av_buffer_ref(pkt->buf);
1489 ret = AVERROR(ENOMEM);
1493 ret = av_packet_make_refcounted(&out_pkt);
1498 if (pkt->side_data) {
1499 out_pkt.side_data = pkt->side_data;
1500 out_pkt.side_data_elems = pkt->side_data_elems;
1501 pkt->side_data = NULL;
1502 pkt->side_data_elems = 0;
1505 /* set the duration */
1506 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1507 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1508 if (st->internal->avctx->sample_rate > 0) {
1510 av_rescale_q_rnd(st->parser->duration,
1511 (AVRational) { 1, st->internal->avctx->sample_rate },
1517 out_pkt.stream_index = st->index;
1518 out_pkt.pts = st->parser->pts;
1519 out_pkt.dts = st->parser->dts;
1520 out_pkt.pos = st->parser->pos;
1521 out_pkt.flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1523 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1524 out_pkt.pos = st->parser->frame_offset;
1526 if (st->parser->key_frame == 1 ||
1527 (st->parser->key_frame == -1 &&
1528 st->parser->pict_type == AV_PICTURE_TYPE_I))
1529 out_pkt.flags |= AV_PKT_FLAG_KEY;
1531 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1532 out_pkt.flags |= AV_PKT_FLAG_KEY;
1534 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1536 ret = ff_packet_list_put(&s->internal->parse_queue,
1537 &s->internal->parse_queue_end,
1540 av_packet_unref(&out_pkt);
1545 /* end of the stream => close and free the parser */
1547 av_parser_close(st->parser);
1552 av_packet_unref(pkt);
1556 int ff_packet_list_get(AVPacketList **pkt_buffer,
1557 AVPacketList **pkt_buffer_end,
1561 av_assert0(*pkt_buffer);
1564 *pkt_buffer = pktl->next;
1566 *pkt_buffer_end = NULL;
1571 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1573 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1576 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1578 int ret, i, got_packet = 0;
1579 AVDictionary *metadata = NULL;
1581 while (!got_packet && !s->internal->parse_queue) {
1584 /* read next packet */
1585 ret = ff_read_packet(s, pkt);
1587 if (ret == AVERROR(EAGAIN))
1589 /* flush the parsers */
1590 for (i = 0; i < s->nb_streams; i++) {
1592 if (st->parser && st->need_parsing)
1593 parse_packet(s, pkt, st->index, 1);
1595 /* all remaining packets are now in parse_queue =>
1596 * really terminate parsing */
1600 st = s->streams[pkt->stream_index];
1602 /* update context if required */
1603 if (st->internal->need_context_update) {
1604 if (avcodec_is_open(st->internal->avctx)) {
1605 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1606 avcodec_close(st->internal->avctx);
1607 st->info->found_decoder = 0;
1610 /* close parser, because it depends on the codec */
1611 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1612 av_parser_close(st->parser);
1616 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1618 av_packet_unref(pkt);
1622 #if FF_API_LAVF_AVCTX
1623 FF_DISABLE_DEPRECATION_WARNINGS
1624 /* update deprecated public codec context */
1625 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1627 av_packet_unref(pkt);
1630 FF_ENABLE_DEPRECATION_WARNINGS
1633 st->internal->need_context_update = 0;
1636 if (pkt->pts != AV_NOPTS_VALUE &&
1637 pkt->dts != AV_NOPTS_VALUE &&
1638 pkt->pts < pkt->dts) {
1639 av_log(s, AV_LOG_WARNING,
1640 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1642 av_ts2str(pkt->pts),
1643 av_ts2str(pkt->dts),
1646 if (s->debug & FF_FDEBUG_TS)
1647 av_log(s, AV_LOG_DEBUG,
1648 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1650 av_ts2str(pkt->pts),
1651 av_ts2str(pkt->dts),
1652 pkt->size, pkt->duration, pkt->flags);
1654 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1655 st->parser = av_parser_init(st->codecpar->codec_id);
1657 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1658 "%s, packets or times may be invalid.\n",
1659 avcodec_get_name(st->codecpar->codec_id));
1660 /* no parser available: just output the raw packets */
1661 st->need_parsing = AVSTREAM_PARSE_NONE;
1662 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1663 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1664 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1665 st->parser->flags |= PARSER_FLAG_ONCE;
1666 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1667 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1670 if (!st->need_parsing || !st->parser) {
1671 /* no parsing needed: we just output the packet as is */
1672 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1673 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1674 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1675 ff_reduce_index(s, st->index);
1676 av_add_index_entry(st, pkt->pos, pkt->dts,
1677 0, 0, AVINDEX_KEYFRAME);
1680 } else if (st->discard < AVDISCARD_ALL) {
1681 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1683 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1684 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1685 st->codecpar->channels = st->internal->avctx->channels;
1686 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1687 st->codecpar->codec_id = st->internal->avctx->codec_id;
1690 av_packet_unref(pkt);
1692 if (pkt->flags & AV_PKT_FLAG_KEY)
1693 st->skip_to_keyframe = 0;
1694 if (st->skip_to_keyframe) {
1695 av_packet_unref(pkt);
1700 if (!got_packet && s->internal->parse_queue)
1701 ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1704 AVStream *st = s->streams[pkt->stream_index];
1705 int discard_padding = 0;
1706 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1707 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1708 int64_t sample = ts_to_samples(st, pts);
1709 int duration = ts_to_samples(st, pkt->duration);
1710 int64_t end_sample = sample + duration;
1711 if (duration > 0 && end_sample >= st->first_discard_sample &&
1712 sample < st->last_discard_sample)
1713 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1715 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1716 st->skip_samples = st->start_skip_samples;
1717 if (st->skip_samples || discard_padding) {
1718 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1720 AV_WL32(p, st->skip_samples);
1721 AV_WL32(p + 4, discard_padding);
1722 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1724 st->skip_samples = 0;
1727 if (st->inject_global_side_data) {
1728 for (i = 0; i < st->nb_side_data; i++) {
1729 AVPacketSideData *src_sd = &st->side_data[i];
1732 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1735 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1737 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1741 memcpy(dst_data, src_sd->data, src_sd->size);
1743 st->inject_global_side_data = 0;
1747 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1749 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1750 av_dict_copy(&s->metadata, metadata, 0);
1751 av_dict_free(&metadata);
1752 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1755 #if FF_API_LAVF_AVCTX
1756 update_stream_avctx(s);
1759 if (s->debug & FF_FDEBUG_TS)
1760 av_log(s, AV_LOG_DEBUG,
1761 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1762 "size=%d, duration=%"PRId64", flags=%d\n",
1764 av_ts2str(pkt->pts),
1765 av_ts2str(pkt->dts),
1766 pkt->size, pkt->duration, pkt->flags);
1768 /* A demuxer might have returned EOF because of an IO error, let's
1769 * propagate this back to the user. */
1770 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1776 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1778 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1784 ret = s->internal->packet_buffer
1785 ? ff_packet_list_get(&s->internal->packet_buffer,
1786 &s->internal->packet_buffer_end, pkt)
1787 : read_frame_internal(s, pkt);
1794 AVPacketList *pktl = s->internal->packet_buffer;
1797 AVPacket *next_pkt = &pktl->pkt;
1799 if (next_pkt->dts != AV_NOPTS_VALUE) {
1800 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1801 // last dts seen for this stream. if any of packets following
1802 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1803 int64_t last_dts = next_pkt->dts;
1804 av_assert2(wrap_bits <= 64);
1805 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1806 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1807 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1808 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1810 next_pkt->pts = pktl->pkt.dts;
1812 if (last_dts != AV_NOPTS_VALUE) {
1813 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1814 last_dts = pktl->pkt.dts;
1819 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1820 // Fixing the last reference frame had none pts issue (For MXF etc).
1821 // We only do this when
1823 // 2. we are not able to resolve a pts value for current packet.
1824 // 3. the packets for this stream at the end of the files had valid dts.
1825 next_pkt->pts = last_dts + next_pkt->duration;
1827 pktl = s->internal->packet_buffer;
1830 /* read packet from packet buffer, if there is data */
1831 st = s->streams[next_pkt->stream_index];
1832 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1833 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1834 ret = ff_packet_list_get(&s->internal->packet_buffer,
1835 &s->internal->packet_buffer_end, pkt);
1840 ret = read_frame_internal(s, pkt);
1842 if (pktl && ret != AVERROR(EAGAIN)) {
1849 ret = ff_packet_list_put(&s->internal->packet_buffer,
1850 &s->internal->packet_buffer_end,
1853 av_packet_unref(pkt);
1860 st = s->streams[pkt->stream_index];
1861 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1862 ff_reduce_index(s, st->index);
1863 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1866 if (is_relative(pkt->dts))
1867 pkt->dts -= RELATIVE_TS_BASE;
1868 if (is_relative(pkt->pts))
1869 pkt->pts -= RELATIVE_TS_BASE;
1874 /* XXX: suppress the packet queue */
1875 static void flush_packet_queue(AVFormatContext *s)
1879 ff_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1880 ff_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1881 ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1883 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1886 /*******************************************************/
1889 int av_find_default_stream_index(AVFormatContext *s)
1893 int best_stream = 0;
1894 int best_score = INT_MIN;
1896 if (s->nb_streams <= 0)
1898 for (i = 0; i < s->nb_streams; i++) {
1901 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1902 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1904 if (st->codecpar->width && st->codecpar->height)
1908 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1909 if (st->codecpar->sample_rate)
1912 if (st->codec_info_nb_frames)
1915 if (st->discard != AVDISCARD_ALL)
1918 if (score > best_score) {
1926 /** Flush the frame reader. */
1927 void ff_read_frame_flush(AVFormatContext *s)
1932 flush_packet_queue(s);
1934 /* Reset read state for each stream. */
1935 for (i = 0; i < s->nb_streams; i++) {
1939 av_parser_close(st->parser);
1942 st->last_IP_pts = AV_NOPTS_VALUE;
1943 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1944 if (st->first_dts == AV_NOPTS_VALUE)
1945 st->cur_dts = RELATIVE_TS_BASE;
1947 /* We set the current DTS to an unspecified origin. */
1948 st->cur_dts = AV_NOPTS_VALUE;
1950 st->probe_packets = s->max_probe_packets;
1952 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1953 st->pts_buffer[j] = AV_NOPTS_VALUE;
1955 if (s->internal->inject_global_side_data)
1956 st->inject_global_side_data = 1;
1958 st->skip_samples = 0;
1962 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1966 for (i = 0; i < s->nb_streams; i++) {
1967 AVStream *st = s->streams[i];
1970 av_rescale(timestamp,
1971 st->time_base.den * (int64_t) ref_st->time_base.num,
1972 st->time_base.num * (int64_t) ref_st->time_base.den);
1976 void ff_reduce_index(AVFormatContext *s, int stream_index)
1978 AVStream *st = s->streams[stream_index];
1979 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1981 if ((unsigned) st->nb_index_entries >= max_entries) {
1983 for (i = 0; 2 * i < st->nb_index_entries; i++)
1984 st->index_entries[i] = st->index_entries[2 * i];
1985 st->nb_index_entries = i;
1989 int ff_add_index_entry(AVIndexEntry **index_entries,
1990 int *nb_index_entries,
1991 unsigned int *index_entries_allocated_size,
1992 int64_t pos, int64_t timestamp,
1993 int size, int distance, int flags)
1995 AVIndexEntry *entries, *ie;
1998 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
2001 if (timestamp == AV_NOPTS_VALUE)
2002 return AVERROR(EINVAL);
2004 if (size < 0 || size > 0x3FFFFFFF)
2005 return AVERROR(EINVAL);
2007 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
2008 timestamp -= RELATIVE_TS_BASE;
2010 entries = av_fast_realloc(*index_entries,
2011 index_entries_allocated_size,
2012 (*nb_index_entries + 1) *
2013 sizeof(AVIndexEntry));
2017 *index_entries = entries;
2019 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2020 timestamp, AVSEEK_FLAG_ANY);
2023 index = (*nb_index_entries)++;
2024 ie = &entries[index];
2025 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2027 ie = &entries[index];
2028 if (ie->timestamp != timestamp) {
2029 if (ie->timestamp <= timestamp)
2031 memmove(entries + index + 1, entries + index,
2032 sizeof(AVIndexEntry) * (*nb_index_entries - index));
2033 (*nb_index_entries)++;
2034 } else if (ie->pos == pos && distance < ie->min_distance)
2035 // do not reduce the distance
2036 distance = ie->min_distance;
2040 ie->timestamp = timestamp;
2041 ie->min_distance = distance;
2048 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2049 int size, int distance, int flags)
2051 timestamp = wrap_timestamp(st, timestamp);
2052 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2053 &st->index_entries_allocated_size, pos,
2054 timestamp, size, distance, flags);
2057 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2058 int64_t wanted_timestamp, int flags)
2066 // Optimize appending index entries at the end.
2067 if (b && entries[b - 1].timestamp < wanted_timestamp)
2073 // Search for the next non-discarded packet.
2074 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2076 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2082 timestamp = entries[m].timestamp;
2083 if (timestamp >= wanted_timestamp)
2085 if (timestamp <= wanted_timestamp)
2088 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2090 if (!(flags & AVSEEK_FLAG_ANY))
2091 while (m >= 0 && m < nb_entries &&
2092 !(entries[m].flags & AVINDEX_KEYFRAME))
2093 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2095 if (m == nb_entries)
2100 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2103 int64_t pos_delta = 0;
2105 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2106 const char *proto = avio_find_protocol_name(s->url);
2109 av_log(s, AV_LOG_INFO,
2110 "Protocol name not provided, cannot determine if input is local or "
2111 "a network protocol, buffers and access patterns cannot be configured "
2112 "optimally without knowing the protocol\n");
2115 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2118 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2119 AVStream *st1 = s->streams[ist1];
2120 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2121 AVStream *st2 = s->streams[ist2];
2127 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2128 AVIndexEntry *e1 = &st1->index_entries[i1];
2129 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2131 skip = FFMAX(skip, e1->size);
2132 for (; i2 < st2->nb_index_entries; i2++) {
2133 AVIndexEntry *e2 = &st2->index_entries[i2];
2134 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2135 if (e2_pts - e1_pts < time_tolerance)
2137 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2145 /* XXX This could be adjusted depending on protocol*/
2146 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2147 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2149 /* realloc the buffer and the original data will be retained */
2150 if (ffio_realloc_buf(s->pb, pos_delta)) {
2151 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2155 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2158 if (skip < (1<<23)) {
2159 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2163 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2165 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2166 wanted_timestamp, flags);
2169 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2170 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2172 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2173 if (stream_index >= 0)
2174 ts = wrap_timestamp(s->streams[stream_index], ts);
2178 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2179 int64_t target_ts, int flags)
2181 const AVInputFormat *avif = s->iformat;
2182 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2183 int64_t ts_min, ts_max, ts;
2188 if (stream_index < 0)
2191 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2194 ts_min = AV_NOPTS_VALUE;
2195 pos_limit = -1; // GCC falsely says it may be uninitialized.
2197 st = s->streams[stream_index];
2198 if (st->index_entries) {
2201 /* FIXME: Whole function must be checked for non-keyframe entries in
2202 * index case, especially read_timestamp(). */
2203 index = av_index_search_timestamp(st, target_ts,
2204 flags | AVSEEK_FLAG_BACKWARD);
2205 index = FFMAX(index, 0);
2206 e = &st->index_entries[index];
2208 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2210 ts_min = e->timestamp;
2211 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2212 pos_min, av_ts2str(ts_min));
2214 av_assert1(index == 0);
2217 index = av_index_search_timestamp(st, target_ts,
2218 flags & ~AVSEEK_FLAG_BACKWARD);
2219 av_assert0(index < st->nb_index_entries);
2221 e = &st->index_entries[index];
2222 av_assert1(e->timestamp >= target_ts);
2224 ts_max = e->timestamp;
2225 pos_limit = pos_max - e->min_distance;
2226 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2227 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2231 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2232 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2237 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2240 ff_read_frame_flush(s);
2241 ff_update_cur_dts(s, st, ts);
2246 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2247 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2249 int64_t step = 1024;
2250 int64_t limit, ts_max;
2251 int64_t filesize = avio_size(s->pb);
2252 int64_t pos_max = filesize - 1;
2255 pos_max = FFMAX(0, (pos_max) - step);
2256 ts_max = ff_read_timestamp(s, stream_index,
2257 &pos_max, limit, read_timestamp);
2259 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2260 if (ts_max == AV_NOPTS_VALUE)
2264 int64_t tmp_pos = pos_max + 1;
2265 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2266 &tmp_pos, INT64_MAX, read_timestamp);
2267 if (tmp_ts == AV_NOPTS_VALUE)
2269 av_assert0(tmp_pos > pos_max);
2272 if (tmp_pos >= filesize)
2284 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2285 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2286 int64_t ts_min, int64_t ts_max,
2287 int flags, int64_t *ts_ret,
2288 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2289 int64_t *, int64_t))
2296 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2298 if (ts_min == AV_NOPTS_VALUE) {
2299 pos_min = s->internal->data_offset;
2300 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2301 if (ts_min == AV_NOPTS_VALUE)
2305 if (ts_min >= target_ts) {
2310 if (ts_max == AV_NOPTS_VALUE) {
2311 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2313 pos_limit = pos_max;
2316 if (ts_max <= target_ts) {
2321 av_assert0(ts_min < ts_max);
2324 while (pos_min < pos_limit) {
2325 av_log(s, AV_LOG_TRACE,
2326 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2327 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2328 av_assert0(pos_limit <= pos_max);
2330 if (no_change == 0) {
2331 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2332 // interpolate position (better than dichotomy)
2333 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2335 pos_min - approximate_keyframe_distance;
2336 } else if (no_change == 1) {
2337 // bisection if interpolation did not change min / max pos last time
2338 pos = (pos_min + pos_limit) >> 1;
2340 /* linear search if bisection failed, can only happen if there
2341 * are very few or no keyframes between min/max */
2346 else if (pos > pos_limit)
2350 // May pass pos_limit instead of -1.
2351 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2356 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2357 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2358 pos_min, pos, pos_max,
2359 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2360 pos_limit, start_pos, no_change);
2361 if (ts == AV_NOPTS_VALUE) {
2362 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2365 if (target_ts <= ts) {
2366 pos_limit = start_pos - 1;
2370 if (target_ts >= ts) {
2376 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2377 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2380 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2382 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2383 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2384 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2390 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2391 int64_t pos, int flags)
2393 int64_t pos_min, pos_max;
2395 pos_min = s->internal->data_offset;
2396 pos_max = avio_size(s->pb) - 1;
2400 else if (pos > pos_max)
2403 avio_seek(s->pb, pos, SEEK_SET);
2405 s->io_repositioned = 1;
2410 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2411 int64_t timestamp, int flags)
2418 st = s->streams[stream_index];
2420 index = av_index_search_timestamp(st, timestamp, flags);
2422 if (index < 0 && st->nb_index_entries &&
2423 timestamp < st->index_entries[0].timestamp)
2426 if (index < 0 || index == st->nb_index_entries - 1) {
2430 if (st->nb_index_entries) {
2431 av_assert0(st->index_entries);
2432 ie = &st->index_entries[st->nb_index_entries - 1];
2433 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2435 ff_update_cur_dts(s, st, ie->timestamp);
2437 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2443 read_status = av_read_frame(s, &pkt);
2444 } while (read_status == AVERROR(EAGAIN));
2445 if (read_status < 0)
2447 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2448 if (pkt.flags & AV_PKT_FLAG_KEY) {
2449 av_packet_unref(&pkt);
2452 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2453 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);
2454 av_packet_unref(&pkt);
2458 av_packet_unref(&pkt);
2460 index = av_index_search_timestamp(st, timestamp, flags);
2465 ff_read_frame_flush(s);
2466 if (s->iformat->read_seek)
2467 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2469 ie = &st->index_entries[index];
2470 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2472 ff_update_cur_dts(s, st, ie->timestamp);
2477 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2478 int64_t timestamp, int flags)
2483 if (flags & AVSEEK_FLAG_BYTE) {
2484 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2486 ff_read_frame_flush(s);
2487 return seek_frame_byte(s, stream_index, timestamp, flags);
2490 if (stream_index < 0) {
2491 stream_index = av_find_default_stream_index(s);
2492 if (stream_index < 0)
2495 st = s->streams[stream_index];
2496 /* timestamp for default must be expressed in AV_TIME_BASE units */
2497 timestamp = av_rescale(timestamp, st->time_base.den,
2498 AV_TIME_BASE * (int64_t) st->time_base.num);
2501 /* first, we try the format specific seek */
2502 if (s->iformat->read_seek) {
2503 ff_read_frame_flush(s);
2504 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2510 if (s->iformat->read_timestamp &&
2511 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2512 ff_read_frame_flush(s);
2513 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2514 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2515 ff_read_frame_flush(s);
2516 return seek_frame_generic(s, stream_index, timestamp, flags);
2521 int av_seek_frame(AVFormatContext *s, int stream_index,
2522 int64_t timestamp, int flags)
2526 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2527 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2528 if ((flags & AVSEEK_FLAG_BACKWARD))
2532 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2533 flags & ~AVSEEK_FLAG_BACKWARD);
2536 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2539 ret = avformat_queue_attached_pictures(s);
2544 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2545 int64_t ts, int64_t max_ts, int flags)
2547 if (min_ts > ts || max_ts < ts)
2549 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2550 return AVERROR(EINVAL);
2553 flags |= AVSEEK_FLAG_ANY;
2554 flags &= ~AVSEEK_FLAG_BACKWARD;
2556 if (s->iformat->read_seek2) {
2558 ff_read_frame_flush(s);
2560 if (stream_index == -1 && s->nb_streams == 1) {
2561 AVRational time_base = s->streams[0]->time_base;
2562 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2563 min_ts = av_rescale_rnd(min_ts, time_base.den,
2564 time_base.num * (int64_t)AV_TIME_BASE,
2565 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2566 max_ts = av_rescale_rnd(max_ts, time_base.den,
2567 time_base.num * (int64_t)AV_TIME_BASE,
2568 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2572 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2576 ret = avformat_queue_attached_pictures(s);
2580 if (s->iformat->read_timestamp) {
2581 // try to seek via read_timestamp()
2584 // Fall back on old API if new is not implemented but old is.
2585 // Note the old API has somewhat different semantics.
2586 if (s->iformat->read_seek || 1) {
2587 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2588 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2589 if (ret<0 && ts != min_ts && max_ts != ts) {
2590 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2592 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2597 // try some generic seek like seek_frame_generic() but with new ts semantics
2598 return -1; //unreachable
2601 int avformat_flush(AVFormatContext *s)
2603 ff_read_frame_flush(s);
2607 /*******************************************************/
2610 * Return TRUE if the stream has accurate duration in any stream.
2612 * @return TRUE if the stream has accurate duration for at least one component.
2614 static int has_duration(AVFormatContext *ic)
2619 for (i = 0; i < ic->nb_streams; i++) {
2620 st = ic->streams[i];
2621 if (st->duration != AV_NOPTS_VALUE)
2624 if (ic->duration != AV_NOPTS_VALUE)
2630 * Estimate the stream timings from the one of each components.
2632 * Also computes the global bitrate if possible.
2634 static void update_stream_timings(AVFormatContext *ic)
2636 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2637 int64_t duration, duration1, duration_text, filesize;
2641 start_time = INT64_MAX;
2642 start_time_text = INT64_MAX;
2643 end_time = INT64_MIN;
2644 end_time_text = INT64_MIN;
2645 duration = INT64_MIN;
2646 duration_text = INT64_MIN;
2648 for (i = 0; i < ic->nb_streams; i++) {
2649 AVStream *st = ic->streams[i];
2650 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2651 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2652 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2653 start_time1 = av_rescale_q(st->start_time, st->time_base,
2656 start_time_text = FFMIN(start_time_text, start_time1);
2658 start_time = FFMIN(start_time, start_time1);
2659 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2661 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2662 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2663 end_time1 += start_time1;
2665 end_time_text = FFMAX(end_time_text, end_time1);
2667 end_time = FFMAX(end_time, end_time1);
2669 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2670 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2671 p->start_time = start_time1;
2672 if (p->end_time < end_time1)
2673 p->end_time = end_time1;
2676 if (st->duration != AV_NOPTS_VALUE) {
2677 duration1 = av_rescale_q(st->duration, st->time_base,
2680 duration_text = FFMAX(duration_text, duration1);
2682 duration = FFMAX(duration, duration1);
2685 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2686 start_time = start_time_text;
2687 else if (start_time > start_time_text)
2688 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2690 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2691 end_time = end_time_text;
2692 else if (end_time < end_time_text)
2693 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2695 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2696 duration = duration_text;
2697 else if (duration < duration_text)
2698 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2700 if (start_time != INT64_MAX) {
2701 ic->start_time = start_time;
2702 if (end_time != INT64_MIN) {
2703 if (ic->nb_programs > 1) {
2704 for (i = 0; i < ic->nb_programs; i++) {
2705 p = ic->programs[i];
2706 if (p->start_time != AV_NOPTS_VALUE &&
2707 p->end_time > p->start_time &&
2708 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2709 duration = FFMAX(duration, p->end_time - p->start_time);
2711 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2712 duration = FFMAX(duration, end_time - start_time);
2716 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2717 ic->duration = duration;
2719 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2720 /* compute the bitrate */
2721 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2722 (double) ic->duration;
2723 if (bitrate >= 0 && bitrate <= INT64_MAX)
2724 ic->bit_rate = bitrate;
2728 static void fill_all_stream_timings(AVFormatContext *ic)
2733 update_stream_timings(ic);
2734 for (i = 0; i < ic->nb_streams; i++) {
2735 st = ic->streams[i];
2736 if (st->start_time == AV_NOPTS_VALUE) {
2737 if (ic->start_time != AV_NOPTS_VALUE)
2738 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2740 if (ic->duration != AV_NOPTS_VALUE)
2741 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2747 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2749 int64_t filesize, duration;
2750 int i, show_warning = 0;
2753 /* if bit_rate is already set, we believe it */
2754 if (ic->bit_rate <= 0) {
2755 int64_t bit_rate = 0;
2756 for (i = 0; i < ic->nb_streams; i++) {
2757 st = ic->streams[i];
2758 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2759 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2760 if (st->codecpar->bit_rate > 0) {
2761 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2765 bit_rate += st->codecpar->bit_rate;
2766 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2767 // If we have a videostream with packets but without a bitrate
2768 // then consider the sum not known
2773 ic->bit_rate = bit_rate;
2776 /* if duration is already set, we believe it */
2777 if (ic->duration == AV_NOPTS_VALUE &&
2778 ic->bit_rate != 0) {
2779 filesize = ic->pb ? avio_size(ic->pb) : 0;
2780 if (filesize > ic->internal->data_offset) {
2781 filesize -= ic->internal->data_offset;
2782 for (i = 0; i < ic->nb_streams; i++) {
2783 st = ic->streams[i];
2784 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2785 && st->duration == AV_NOPTS_VALUE) {
2786 duration = av_rescale(8 * filesize, st->time_base.den,
2788 (int64_t) st->time_base.num);
2789 st->duration = duration;
2796 av_log(ic, AV_LOG_WARNING,
2797 "Estimating duration from bitrate, this may be inaccurate\n");
2800 #define DURATION_MAX_READ_SIZE 250000LL
2801 #define DURATION_MAX_RETRY 6
2803 /* only usable for MPEG-PS streams */
2804 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2806 AVPacket pkt1, *pkt = &pkt1;
2808 int num, den, read_size, i, ret;
2809 int found_duration = 0;
2811 int64_t filesize, offset, duration;
2814 /* flush packet queue */
2815 flush_packet_queue(ic);
2817 for (i = 0; i < ic->nb_streams; i++) {
2818 st = ic->streams[i];
2819 if (st->start_time == AV_NOPTS_VALUE &&
2820 st->first_dts == AV_NOPTS_VALUE &&
2821 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2822 av_log(ic, AV_LOG_WARNING,
2823 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2826 av_parser_close(st->parser);
2831 if (ic->skip_estimate_duration_from_pts) {
2832 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2833 goto skip_duration_calc;
2836 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2837 /* estimate the end time (duration) */
2838 /* XXX: may need to support wrapping */
2839 filesize = ic->pb ? avio_size(ic->pb) : 0;
2841 is_end = found_duration;
2842 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2846 avio_seek(ic->pb, offset, SEEK_SET);
2849 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2853 ret = ff_read_packet(ic, pkt);
2854 } while (ret == AVERROR(EAGAIN));
2857 read_size += pkt->size;
2858 st = ic->streams[pkt->stream_index];
2859 if (pkt->pts != AV_NOPTS_VALUE &&
2860 (st->start_time != AV_NOPTS_VALUE ||
2861 st->first_dts != AV_NOPTS_VALUE)) {
2862 if (pkt->duration == 0) {
2863 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2865 pkt->duration = av_rescale_rnd(1,
2866 num * (int64_t) st->time_base.den,
2867 den * (int64_t) st->time_base.num,
2871 duration = pkt->pts + pkt->duration;
2873 if (st->start_time != AV_NOPTS_VALUE)
2874 duration -= st->start_time;
2876 duration -= st->first_dts;
2878 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2879 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2880 st->duration = duration;
2881 st->info->last_duration = duration;
2884 av_packet_unref(pkt);
2887 /* check if all audio/video streams have valid duration */
2890 for (i = 0; i < ic->nb_streams; i++) {
2891 st = ic->streams[i];
2892 switch (st->codecpar->codec_type) {
2893 case AVMEDIA_TYPE_VIDEO:
2894 case AVMEDIA_TYPE_AUDIO:
2895 if (st->duration == AV_NOPTS_VALUE)
2902 ++retry <= DURATION_MAX_RETRY);
2904 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2906 /* warn about audio/video streams which duration could not be estimated */
2907 for (i = 0; i < ic->nb_streams; i++) {
2908 st = ic->streams[i];
2909 if (st->duration == AV_NOPTS_VALUE) {
2910 switch (st->codecpar->codec_type) {
2911 case AVMEDIA_TYPE_VIDEO:
2912 case AVMEDIA_TYPE_AUDIO:
2913 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2914 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2916 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2921 fill_all_stream_timings(ic);
2923 avio_seek(ic->pb, old_offset, SEEK_SET);
2924 for (i = 0; i < ic->nb_streams; i++) {
2927 st = ic->streams[i];
2928 st->cur_dts = st->first_dts;
2929 st->last_IP_pts = AV_NOPTS_VALUE;
2930 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2931 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2932 st->pts_buffer[j] = AV_NOPTS_VALUE;
2936 /* 1:1 map to AVDurationEstimationMethod */
2937 static const char *duration_name[] = {
2938 [AVFMT_DURATION_FROM_PTS] = "pts",
2939 [AVFMT_DURATION_FROM_STREAM] = "stream",
2940 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2943 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2945 return duration_name[method];
2948 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2952 /* get the file size, if possible */
2953 if (ic->iformat->flags & AVFMT_NOFILE) {
2956 file_size = avio_size(ic->pb);
2957 file_size = FFMAX(0, file_size);
2960 if ((!strcmp(ic->iformat->name, "mpeg") ||
2961 !strcmp(ic->iformat->name, "mpegts")) &&
2962 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2963 /* get accurate estimate from the PTSes */
2964 estimate_timings_from_pts(ic, old_offset);
2965 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2966 } else if (has_duration(ic)) {
2967 /* at least one component has timings - we use them for all
2969 fill_all_stream_timings(ic);
2970 /* nut demuxer estimate the duration from PTS */
2971 if(!strcmp(ic->iformat->name, "nut"))
2972 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2974 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2976 /* less precise: use bitrate info */
2977 estimate_timings_from_bit_rate(ic);
2978 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2980 update_stream_timings(ic);
2984 AVStream av_unused *st;
2985 for (i = 0; i < ic->nb_streams; i++) {
2986 st = ic->streams[i];
2987 if (st->time_base.den)
2988 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2989 (double) st->start_time * av_q2d(st->time_base),
2990 (double) st->duration * av_q2d(st->time_base));
2992 av_log(ic, AV_LOG_TRACE,
2993 "format: start_time: %0.3f duration: %0.3f (estimate from %s) bitrate=%"PRId64" kb/s\n",
2994 (double) ic->start_time / AV_TIME_BASE,
2995 (double) ic->duration / AV_TIME_BASE,
2996 duration_estimate_name(ic->duration_estimation_method),
2997 (int64_t)ic->bit_rate / 1000);
3001 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
3003 AVCodecContext *avctx = st->internal->avctx;
3005 #define FAIL(errmsg) do { \
3007 *errmsg_ptr = errmsg; \
3011 if ( avctx->codec_id == AV_CODEC_ID_NONE
3012 && avctx->codec_type != AVMEDIA_TYPE_DATA)
3013 FAIL("unknown codec");
3014 switch (avctx->codec_type) {
3015 case AVMEDIA_TYPE_AUDIO:
3016 if (!avctx->frame_size && determinable_frame_size(avctx))
3017 FAIL("unspecified frame size");
3018 if (st->info->found_decoder >= 0 &&
3019 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3020 FAIL("unspecified sample format");
3021 if (!avctx->sample_rate)
3022 FAIL("unspecified sample rate");
3023 if (!avctx->channels)
3024 FAIL("unspecified number of channels");
3025 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3026 FAIL("no decodable DTS frames");
3028 case AVMEDIA_TYPE_VIDEO:
3030 FAIL("unspecified size");
3031 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3032 FAIL("unspecified pixel format");
3033 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3034 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3035 FAIL("no frame in rv30/40 and no sar");
3037 case AVMEDIA_TYPE_SUBTITLE:
3038 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3039 FAIL("unspecified size");
3041 case AVMEDIA_TYPE_DATA:
3042 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3048 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3049 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3050 const AVPacket *avpkt, AVDictionary **options)
3052 AVCodecContext *avctx = st->internal->avctx;
3053 const AVCodec *codec;
3054 int got_picture = 1, ret = 0;
3055 AVFrame *frame = av_frame_alloc();
3056 AVSubtitle subtitle;
3057 AVPacket pkt = *avpkt;
3058 int do_skip_frame = 0;
3059 enum AVDiscard skip_frame;
3062 return AVERROR(ENOMEM);
3064 if (!avcodec_is_open(avctx) &&
3065 st->info->found_decoder <= 0 &&
3066 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3067 AVDictionary *thread_opt = NULL;
3069 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3072 st->info->found_decoder = -st->codecpar->codec_id;
3077 /* Force thread count to 1 since the H.264 decoder will not extract
3078 * SPS and PPS to extradata during multi-threaded decoding. */
3079 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3080 if (s->codec_whitelist)
3081 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3082 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3084 av_dict_free(&thread_opt);
3086 st->info->found_decoder = -avctx->codec_id;
3089 st->info->found_decoder = 1;
3090 } else if (!st->info->found_decoder)
3091 st->info->found_decoder = 1;
3093 if (st->info->found_decoder < 0) {
3098 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3100 skip_frame = avctx->skip_frame;
3101 avctx->skip_frame = AVDISCARD_ALL;
3104 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3106 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3107 (!st->codec_info_nb_frames &&
3108 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3110 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3111 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3112 ret = avcodec_send_packet(avctx, &pkt);
3113 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3117 ret = avcodec_receive_frame(avctx, frame);
3120 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3122 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3123 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3124 &got_picture, &pkt);
3130 st->nb_decoded_frames++;
3135 if (!pkt.data && !got_picture)
3139 if (do_skip_frame) {
3140 avctx->skip_frame = skip_frame;
3143 av_frame_free(&frame);
3147 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3149 while (tags->id != AV_CODEC_ID_NONE) {
3157 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3160 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3161 if (tag == tags[i].tag)
3163 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3164 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3166 return AV_CODEC_ID_NONE;
3169 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3171 if (bps <= 0 || bps > 64)
3172 return AV_CODEC_ID_NONE;
3177 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3179 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3181 return AV_CODEC_ID_NONE;
3186 if (sflags & (1 << (bps - 1))) {
3189 return AV_CODEC_ID_PCM_S8;
3191 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3193 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3195 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3197 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3199 return AV_CODEC_ID_NONE;
3204 return AV_CODEC_ID_PCM_U8;
3206 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3208 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3210 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3212 return AV_CODEC_ID_NONE;
3218 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3221 if (!av_codec_get_tag2(tags, id, &tag))
3226 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3230 for (i = 0; tags && tags[i]; i++) {
3231 const AVCodecTag *codec_tags = tags[i];
3232 while (codec_tags->id != AV_CODEC_ID_NONE) {
3233 if (codec_tags->id == id) {
3234 *tag = codec_tags->tag;
3243 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3246 for (i = 0; tags && tags[i]; i++) {
3247 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3248 if (id != AV_CODEC_ID_NONE)
3251 return AV_CODEC_ID_NONE;
3254 static void compute_chapters_end(AVFormatContext *s)
3257 int64_t max_time = 0;
3259 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3260 max_time = s->duration +
3261 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3263 for (i = 0; i < s->nb_chapters; i++)
3264 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3265 AVChapter *ch = s->chapters[i];
3266 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3270 for (j = 0; j < s->nb_chapters; j++) {
3271 AVChapter *ch1 = s->chapters[j];
3272 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3274 if (j != i && next_start > ch->start && next_start < end)
3277 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3281 static int get_std_framerate(int i)
3284 return (i + 1) * 1001;
3288 return (i + 31) * 1001 * 12;
3292 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3296 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3299 /* Is the time base unreliable?
3300 * This is a heuristic to balance between quick acceptance of the values in
3301 * the headers vs. some extra checks.
3302 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3303 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3304 * And there are "variable" fps files this needs to detect as well. */
3305 static int tb_unreliable(AVCodecContext *c)
3307 if (c->time_base.den >= 101LL * c->time_base.num ||
3308 c->time_base.den < 5LL * c->time_base.num ||
3309 // c->codec_tag == AV_RL32("DIVX") ||
3310 // c->codec_tag == AV_RL32("XVID") ||
3311 c->codec_tag == AV_RL32("mp4v") ||
3312 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3313 c->codec_id == AV_CODEC_ID_GIF ||
3314 c->codec_id == AV_CODEC_ID_HEVC ||
3315 c->codec_id == AV_CODEC_ID_H264)
3320 int ff_alloc_extradata(AVCodecParameters *par, int size)
3322 av_freep(&par->extradata);
3323 par->extradata_size = 0;
3325 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3326 return AVERROR(EINVAL);
3328 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3329 if (!par->extradata)
3330 return AVERROR(ENOMEM);
3332 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3333 par->extradata_size = size;
3338 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3340 int ret = ff_alloc_extradata(par, size);
3343 ret = avio_read(pb, par->extradata, size);
3345 av_freep(&par->extradata);
3346 par->extradata_size = 0;
3347 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3348 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3354 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3357 int64_t last = st->info->last_dts;
3359 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3360 && ts - (uint64_t)last < INT64_MAX) {
3361 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3362 int64_t duration = ts - last;
3364 if (!st->info->duration_error)
3365 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3366 if (!st->info->duration_error)
3367 return AVERROR(ENOMEM);
3369 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3370 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3371 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3372 if (st->info->duration_error[0][1][i] < 1e10) {
3373 int framerate = get_std_framerate(i);
3374 double sdts = dts*framerate/(1001*12);
3375 for (j= 0; j<2; j++) {
3376 int64_t ticks = llrint(sdts+j*0.5);
3377 double error= sdts - ticks + j*0.5;
3378 st->info->duration_error[j][0][i] += error;
3379 st->info->duration_error[j][1][i] += error*error;
3383 if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3384 st->info->duration_count++;
3385 st->info->rfps_duration_sum += duration;
3388 if (st->info->duration_count % 10 == 0) {
3389 int n = st->info->duration_count;
3390 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3391 if (st->info->duration_error[0][1][i] < 1e10) {
3392 double a0 = st->info->duration_error[0][0][i] / n;
3393 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3394 double a1 = st->info->duration_error[1][0][i] / n;
3395 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3396 if (error0 > 0.04 && error1 > 0.04) {
3397 st->info->duration_error[0][1][i] = 2e10;
3398 st->info->duration_error[1][1][i] = 2e10;
3404 // ignore the first 4 values, they might have some random jitter
3405 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3406 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3408 if (ts != AV_NOPTS_VALUE)
3409 st->info->last_dts = ts;
3414 void ff_rfps_calculate(AVFormatContext *ic)
3418 for (i = 0; i < ic->nb_streams; i++) {
3419 AVStream *st = ic->streams[i];
3421 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3423 // the check for tb_unreliable() is not completely correct, since this is not about handling
3424 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3425 // ipmovie.c produces.
3426 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)
3427 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);
3428 if (st->info->duration_count>1 && !st->r_frame_rate.num
3429 && tb_unreliable(st->internal->avctx)) {
3431 double best_error= 0.01;
3432 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3434 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3437 if (st->info->codec_info_duration &&
3438 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3440 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3443 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3446 for (k= 0; k<2; k++) {
3447 int n = st->info->duration_count;
3448 double a= st->info->duration_error[k][0][j] / n;
3449 double error= st->info->duration_error[k][1][j]/n - a*a;
3451 if (error < best_error && best_error> 0.000000001) {
3453 num = get_std_framerate(j);
3456 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3459 // do not increase frame rate by more than 1 % in order to match a standard rate.
3460 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3461 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3463 if ( !st->avg_frame_rate.num
3464 && st->r_frame_rate.num && st->info->rfps_duration_sum
3465 && st->info->codec_info_duration <= 0
3466 && st->info->duration_count > 2
3467 && 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
3469 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3470 st->avg_frame_rate = st->r_frame_rate;
3473 av_freep(&st->info->duration_error);
3474 st->info->last_dts = AV_NOPTS_VALUE;
3475 st->info->duration_count = 0;
3476 st->info->rfps_duration_sum = 0;
3480 static int extract_extradata_check(AVStream *st)
3482 const AVBitStreamFilter *f;
3484 f = av_bsf_get_by_name("extract_extradata");
3489 const enum AVCodecID *ids;
3490 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3491 if (*ids == st->codecpar->codec_id)
3498 static int extract_extradata_init(AVStream *st)
3500 AVStreamInternal *sti = st->internal;
3501 const AVBitStreamFilter *f;
3504 f = av_bsf_get_by_name("extract_extradata");
3508 /* check that the codec id is supported */
3509 ret = extract_extradata_check(st);
3513 sti->extract_extradata.pkt = av_packet_alloc();
3514 if (!sti->extract_extradata.pkt)
3515 return AVERROR(ENOMEM);
3517 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3521 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3526 sti->extract_extradata.bsf->time_base_in = st->time_base;
3528 ret = av_bsf_init(sti->extract_extradata.bsf);
3533 sti->extract_extradata.inited = 1;
3537 av_bsf_free(&sti->extract_extradata.bsf);
3538 av_packet_free(&sti->extract_extradata.pkt);
3542 static int extract_extradata(AVStream *st, const AVPacket *pkt)
3544 AVStreamInternal *sti = st->internal;
3548 if (!sti->extract_extradata.inited) {
3549 ret = extract_extradata_init(st);
3554 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3557 pkt_ref = sti->extract_extradata.pkt;
3558 ret = av_packet_ref(pkt_ref, pkt);
3562 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3564 av_packet_unref(pkt_ref);
3568 while (ret >= 0 && !sti->avctx->extradata) {
3572 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3574 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3579 extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3583 av_assert0(!sti->avctx->extradata);
3584 if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3585 sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3586 if (!sti->avctx->extradata) {
3587 av_packet_unref(pkt_ref);
3588 return AVERROR(ENOMEM);
3590 memcpy(sti->avctx->extradata, extradata, extradata_size);
3591 sti->avctx->extradata_size = extradata_size;
3593 av_packet_unref(pkt_ref);
3599 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3601 int i, count = 0, ret = 0, j;
3604 AVCodecContext *avctx;
3606 int64_t old_offset = avio_tell(ic->pb);
3607 // new streams might appear, no options for those
3608 int orig_nb_streams = ic->nb_streams;
3610 int64_t max_analyze_duration = ic->max_analyze_duration;
3611 int64_t max_stream_analyze_duration;
3612 int64_t max_subtitle_analyze_duration;
3613 int64_t probesize = ic->probesize;
3614 int eof_reached = 0;
3615 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3617 flush_codecs = probesize > 0;
3619 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3621 max_stream_analyze_duration = max_analyze_duration;
3622 max_subtitle_analyze_duration = max_analyze_duration;
3623 if (!max_analyze_duration) {
3624 max_stream_analyze_duration =
3625 max_analyze_duration = 5*AV_TIME_BASE;
3626 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3627 if (!strcmp(ic->iformat->name, "flv"))
3628 max_stream_analyze_duration = 90*AV_TIME_BASE;
3629 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3630 max_stream_analyze_duration = 7*AV_TIME_BASE;
3634 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3635 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3637 for (i = 0; i < ic->nb_streams; i++) {
3638 const AVCodec *codec;
3639 AVDictionary *thread_opt = NULL;
3640 st = ic->streams[i];
3641 avctx = st->internal->avctx;
3643 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3644 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3645 /* if (!st->time_base.num)
3647 if (!avctx->time_base.num)
3648 avctx->time_base = st->time_base;
3651 /* check if the caller has overridden the codec id */
3652 #if FF_API_LAVF_AVCTX
3653 FF_DISABLE_DEPRECATION_WARNINGS
3654 if (st->codec->codec_id != st->internal->orig_codec_id) {
3655 st->codecpar->codec_id = st->codec->codec_id;
3656 st->codecpar->codec_type = st->codec->codec_type;
3657 st->internal->orig_codec_id = st->codec->codec_id;
3659 FF_ENABLE_DEPRECATION_WARNINGS
3661 // only for the split stuff
3662 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3663 st->parser = av_parser_init(st->codecpar->codec_id);
3665 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3666 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3667 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3668 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3670 } else if (st->need_parsing) {
3671 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3672 "%s, packets or times may be invalid.\n",
3673 avcodec_get_name(st->codecpar->codec_id));
3677 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3678 st->internal->orig_codec_id = st->codecpar->codec_id;
3680 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3682 goto find_stream_info_err;
3683 if (st->request_probe <= 0)
3684 st->internal->avctx_inited = 1;
3686 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3688 /* Force thread count to 1 since the H.264 decoder will not extract
3689 * SPS and PPS to extradata during multi-threaded decoding. */
3690 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3692 if (ic->codec_whitelist)
3693 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3695 /* Ensure that subtitle_header is properly set. */
3696 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3697 && codec && !avctx->codec) {
3698 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3699 av_log(ic, AV_LOG_WARNING,
3700 "Failed to open codec in %s\n",__FUNCTION__);
3703 // Try to just open decoders, in case this is enough to get parameters.
3704 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3705 if (codec && !avctx->codec)
3706 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3707 av_log(ic, AV_LOG_WARNING,
3708 "Failed to open codec in %s\n",__FUNCTION__);
3711 av_dict_free(&thread_opt);
3714 for (i = 0; i < ic->nb_streams; i++) {
3715 #if FF_API_R_FRAME_RATE
3716 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3718 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3719 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3724 const AVPacket *pkt;
3725 int analyzed_all_streams;
3726 if (ff_check_interrupt(&ic->interrupt_callback)) {
3728 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3732 /* check if one codec still needs to be handled */
3733 for (i = 0; i < ic->nb_streams; i++) {
3734 int fps_analyze_framecount = 20;
3737 st = ic->streams[i];
3738 if (!has_codec_parameters(st, NULL))
3740 /* If the timebase is coarse (like the usual millisecond precision
3741 * of mkv), we need to analyze more frames to reliably arrive at
3742 * the correct fps. */
3743 if (av_q2d(st->time_base) > 0.0005)
3744 fps_analyze_framecount *= 2;
3745 if (!tb_unreliable(st->internal->avctx))
3746 fps_analyze_framecount = 0;
3747 if (ic->fps_probe_size >= 0)
3748 fps_analyze_framecount = ic->fps_probe_size;
3749 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3750 fps_analyze_framecount = 0;
3751 /* variable fps and no guess at the real fps */
3752 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3753 st->info->codec_info_duration_fields/2 :
3754 st->info->duration_count;
3755 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3756 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3757 if (count < fps_analyze_framecount)
3760 // Look at the first 3 frames if there is evidence of frame delay
3761 // but the decoder delay is not set.
3762 if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3764 if (!st->internal->avctx->extradata &&
3765 (!st->internal->extract_extradata.inited ||
3766 st->internal->extract_extradata.bsf) &&
3767 extract_extradata_check(st))
3769 if (st->first_dts == AV_NOPTS_VALUE &&
3770 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3771 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3772 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3773 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3776 analyzed_all_streams = 0;
3777 if (!missing_streams || !*missing_streams)
3778 if (i == ic->nb_streams) {
3779 analyzed_all_streams = 1;
3780 /* NOTE: If the format has no header, then we need to read some
3781 * packets to get most of the streams, so we cannot stop here. */
3782 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3783 /* If we found the info for all the codecs, we can stop. */
3785 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3790 /* We did not get all the codec info, but we read too much data. */
3791 if (read_size >= probesize) {
3793 av_log(ic, AV_LOG_DEBUG,
3794 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3795 for (i = 0; i < ic->nb_streams; i++)
3796 if (!ic->streams[i]->r_frame_rate.num &&
3797 ic->streams[i]->info->duration_count <= 1 &&
3798 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3799 strcmp(ic->iformat->name, "image2"))
3800 av_log(ic, AV_LOG_WARNING,
3801 "Stream #%d: not enough frames to estimate rate; "
3802 "consider increasing probesize\n", i);
3806 /* NOTE: A new stream can be added there if no header in file
3807 * (AVFMTCTX_NOHEADER). */
3808 ret = read_frame_internal(ic, &pkt1);
3809 if (ret == AVERROR(EAGAIN))
3818 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3819 ret = ff_packet_list_put(&ic->internal->packet_buffer,
3820 &ic->internal->packet_buffer_end,
3823 goto unref_then_goto_end;
3825 pkt = &ic->internal->packet_buffer_end->pkt;
3830 st = ic->streams[pkt->stream_index];
3831 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3832 read_size += pkt->size;
3834 avctx = st->internal->avctx;
3835 if (!st->internal->avctx_inited) {
3836 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3838 goto unref_then_goto_end;
3839 st->internal->avctx_inited = 1;
3842 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3843 /* check for non-increasing dts */
3844 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3845 st->info->fps_last_dts >= pkt->dts) {
3846 av_log(ic, AV_LOG_DEBUG,
3847 "Non-increasing DTS in stream %d: packet %d with DTS "
3848 "%"PRId64", packet %d with DTS %"PRId64"\n",
3849 st->index, st->info->fps_last_dts_idx,
3850 st->info->fps_last_dts, st->codec_info_nb_frames,
3852 st->info->fps_first_dts =
3853 st->info->fps_last_dts = AV_NOPTS_VALUE;
3855 /* Check for a discontinuity in dts. If the difference in dts
3856 * is more than 1000 times the average packet duration in the
3857 * sequence, we treat it as a discontinuity. */
3858 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3859 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3860 (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3861 (st->info->fps_last_dts - (uint64_t)st->info->fps_first_dts) /
3862 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3863 av_log(ic, AV_LOG_WARNING,
3864 "DTS discontinuity in stream %d: packet %d with DTS "
3865 "%"PRId64", packet %d with DTS %"PRId64"\n",
3866 st->index, st->info->fps_last_dts_idx,
3867 st->info->fps_last_dts, st->codec_info_nb_frames,
3869 st->info->fps_first_dts =
3870 st->info->fps_last_dts = AV_NOPTS_VALUE;
3873 /* update stored dts values */
3874 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3875 st->info->fps_first_dts = pkt->dts;
3876 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3878 st->info->fps_last_dts = pkt->dts;
3879 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3881 if (st->codec_info_nb_frames>1) {
3885 if (st->time_base.den > 0)
3886 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3887 if (st->avg_frame_rate.num > 0)
3888 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3891 && st->codec_info_nb_frames>30
3892 && st->info->fps_first_dts != AV_NOPTS_VALUE
3893 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3894 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3896 if (analyzed_all_streams) limit = max_analyze_duration;
3897 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3898 else limit = max_stream_analyze_duration;
3901 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3903 t, pkt->stream_index);
3904 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3905 av_packet_unref(&pkt1);
3908 if (pkt->duration) {
3909 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3910 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3912 st->info->codec_info_duration += pkt->duration;
3913 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3916 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3917 #if FF_API_R_FRAME_RATE
3918 ff_rfps_add_frame(ic, st, pkt->dts);
3920 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3921 st->info->frame_delay_evidence = 1;
3923 if (!st->internal->avctx->extradata) {
3924 ret = extract_extradata(st, pkt);
3926 goto unref_then_goto_end;
3929 /* If still no information, we try to open the codec and to
3930 * decompress the frame. We try to avoid that in most cases as
3931 * it takes longer and uses more memory. For MPEG-4, we need to
3932 * decompress for QuickTime.
3934 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3935 * least one frame of codec data, this makes sure the codec initializes
3936 * the channel configuration and does not only trust the values from
3938 try_decode_frame(ic, st, pkt,
3939 (options && i < orig_nb_streams) ? &options[i] : NULL);
3941 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3942 av_packet_unref(&pkt1);
3944 st->codec_info_nb_frames++;
3950 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3951 st = ic->streams[stream_index];
3952 avctx = st->internal->avctx;
3953 if (!has_codec_parameters(st, NULL)) {
3954 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3955 if (codec && !avctx->codec) {
3956 AVDictionary *opts = NULL;
3957 if (ic->codec_whitelist)
3958 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3959 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3960 av_log(ic, AV_LOG_WARNING,
3961 "Failed to open codec in %s\n",__FUNCTION__);
3962 av_dict_free(&opts);
3966 // EOF already reached while reading the stream above.
3967 // So continue with reoordering DTS with whatever delay we have.
3968 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3969 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3975 AVPacket empty_pkt = { 0 };
3977 av_init_packet(&empty_pkt);
3979 for (i = 0; i < ic->nb_streams; i++) {
3981 st = ic->streams[i];
3983 /* flush the decoders */
3984 if (st->info->found_decoder == 1) {
3986 err = try_decode_frame(ic, st, &empty_pkt,
3987 (options && i < orig_nb_streams)
3988 ? &options[i] : NULL);
3989 } while (err > 0 && !has_codec_parameters(st, NULL));
3992 av_log(ic, AV_LOG_INFO,
3993 "decoding for stream %d failed\n", st->index);
3999 ff_rfps_calculate(ic);
4001 for (i = 0; i < ic->nb_streams; i++) {
4002 st = ic->streams[i];
4003 avctx = st->internal->avctx;
4004 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4005 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4006 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4007 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4008 avctx->codec_tag= tag;
4011 /* estimate average framerate if not set by demuxer */
4012 if (st->info->codec_info_duration_fields &&
4013 !st->avg_frame_rate.num &&
4014 st->info->codec_info_duration) {
4016 double best_error = 0.01;
4017 AVRational codec_frame_rate = avctx->framerate;
4019 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4020 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4021 st->info->codec_info_duration < 0)
4023 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4024 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4025 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4027 /* Round guessed framerate to a "standard" framerate if it's
4028 * within 1% of the original estimate. */
4029 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4030 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4031 double error = fabs(av_q2d(st->avg_frame_rate) /
4032 av_q2d(std_fps) - 1);
4034 if (error < best_error) {
4036 best_fps = std_fps.num;
4039 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4040 error = fabs(av_q2d(codec_frame_rate) /
4041 av_q2d(std_fps) - 1);
4042 if (error < best_error) {
4044 best_fps = std_fps.num;
4049 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4050 best_fps, 12 * 1001, INT_MAX);
4053 if (!st->r_frame_rate.num) {
4054 if ( avctx->time_base.den * (int64_t) st->time_base.num
4055 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
4056 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4057 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4059 st->r_frame_rate.num = st->time_base.den;
4060 st->r_frame_rate.den = st->time_base.num;
4063 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4064 AVRational hw_ratio = { avctx->height, avctx->width };
4065 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4068 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4069 if (!avctx->bits_per_coded_sample)
4070 avctx->bits_per_coded_sample =
4071 av_get_bits_per_sample(avctx->codec_id);
4072 // set stream disposition based on audio service type
4073 switch (avctx->audio_service_type) {
4074 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4075 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4077 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4078 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4080 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4081 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4083 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4084 st->disposition = AV_DISPOSITION_COMMENT;
4086 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4087 st->disposition = AV_DISPOSITION_KARAOKE;
4094 estimate_timings(ic, old_offset);
4096 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4098 if (ret >= 0 && ic->nb_streams)
4099 /* We could not have all the codec parameters before EOF. */
4101 for (i = 0; i < ic->nb_streams; i++) {
4103 st = ic->streams[i];
4105 /* if no packet was ever seen, update context now for has_codec_parameters */
4106 if (!st->internal->avctx_inited) {
4107 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4108 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4109 st->codecpar->format = st->internal->avctx->sample_fmt;
4110 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4112 goto find_stream_info_err;
4114 if (!has_codec_parameters(st, &errmsg)) {
4116 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4117 av_log(ic, AV_LOG_WARNING,
4118 "Could not find codec parameters for stream %d (%s): %s\n"
4119 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4126 compute_chapters_end(ic);
4128 /* update the stream parameters from the internal codec contexts */
4129 for (i = 0; i < ic->nb_streams; i++) {
4130 st = ic->streams[i];
4132 if (st->internal->avctx_inited) {
4133 int orig_w = st->codecpar->width;
4134 int orig_h = st->codecpar->height;
4135 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4137 goto find_stream_info_err;
4139 // The decoder might reduce the video size by the lowres factor.
4140 if (st->internal->avctx->lowres && orig_w) {
4141 st->codecpar->width = orig_w;
4142 st->codecpar->height = orig_h;
4147 #if FF_API_LAVF_AVCTX
4148 FF_DISABLE_DEPRECATION_WARNINGS
4149 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4151 goto find_stream_info_err;
4154 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4155 // by the lowres factor.
4156 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4157 st->codec->lowres = st->internal->avctx->lowres;
4158 st->codec->width = st->internal->avctx->width;
4159 st->codec->height = st->internal->avctx->height;
4163 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4164 st->codec->time_base = st->internal->avctx->time_base;
4165 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4167 st->codec->framerate = st->avg_frame_rate;
4169 if (st->internal->avctx->subtitle_header) {
4170 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4171 if (!st->codec->subtitle_header)
4172 goto find_stream_info_err;
4173 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4174 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4175 st->codec->subtitle_header_size);
4178 // Fields unavailable in AVCodecParameters
4179 st->codec->coded_width = st->internal->avctx->coded_width;
4180 st->codec->coded_height = st->internal->avctx->coded_height;
4181 st->codec->properties = st->internal->avctx->properties;
4182 FF_ENABLE_DEPRECATION_WARNINGS
4185 st->internal->avctx_inited = 0;
4188 find_stream_info_err:
4189 for (i = 0; i < ic->nb_streams; i++) {
4190 st = ic->streams[i];
4192 av_freep(&st->info->duration_error);
4193 avcodec_close(ic->streams[i]->internal->avctx);
4194 av_freep(&ic->streams[i]->info);
4195 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4196 av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4199 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4200 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4203 unref_then_goto_end:
4204 av_packet_unref(&pkt1);
4205 goto find_stream_info_err;
4208 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4212 for (i = 0; i < ic->nb_programs; i++) {
4213 if (ic->programs[i] == last) {
4217 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4218 if (ic->programs[i]->stream_index[j] == s)
4219 return ic->programs[i];
4225 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4226 int wanted_stream_nb, int related_stream,
4227 AVCodec **decoder_ret, int flags)
4229 int i, nb_streams = ic->nb_streams;
4230 int ret = AVERROR_STREAM_NOT_FOUND;
4231 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4232 int count, multiframe, disposition;
4233 int64_t best_bitrate = -1;
4235 unsigned *program = NULL;
4236 const AVCodec *decoder = NULL, *best_decoder = NULL;
4238 if (related_stream >= 0 && wanted_stream_nb < 0) {
4239 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4241 program = p->stream_index;
4242 nb_streams = p->nb_stream_indexes;
4245 for (i = 0; i < nb_streams; i++) {
4246 int real_stream_index = program ? program[i] : i;
4247 AVStream *st = ic->streams[real_stream_index];
4248 AVCodecParameters *par = st->codecpar;
4249 if (par->codec_type != type)
4251 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4253 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4256 decoder = find_decoder(ic, st, par->codec_id);
4259 ret = AVERROR_DECODER_NOT_FOUND;
4263 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4264 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4265 count = st->codec_info_nb_frames;
4266 bitrate = par->bit_rate;
4267 multiframe = FFMIN(5, count);
4268 if ((best_disposition > disposition) ||
4269 (best_disposition == disposition && best_multiframe > multiframe) ||
4270 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4271 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4273 best_disposition = disposition;
4275 best_bitrate = bitrate;
4276 best_multiframe = multiframe;
4277 ret = real_stream_index;
4278 best_decoder = decoder;
4279 if (program && i == nb_streams - 1 && ret < 0) {
4281 nb_streams = ic->nb_streams;
4282 /* no related stream found, try again with everything */
4287 *decoder_ret = (AVCodec*)best_decoder;
4291 /*******************************************************/
4293 int av_read_play(AVFormatContext *s)
4295 if (s->iformat->read_play)
4296 return s->iformat->read_play(s);
4298 return avio_pause(s->pb, 0);
4299 return AVERROR(ENOSYS);
4302 int av_read_pause(AVFormatContext *s)
4304 if (s->iformat->read_pause)
4305 return s->iformat->read_pause(s);
4307 return avio_pause(s->pb, 1);
4308 return AVERROR(ENOSYS);
4311 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4316 dst->time_base = src->time_base;
4317 dst->nb_frames = src->nb_frames;
4318 dst->disposition = src->disposition;
4319 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4320 dst->avg_frame_rate = src->avg_frame_rate;
4321 dst->r_frame_rate = src->r_frame_rate;
4323 av_dict_free(&dst->metadata);
4324 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4328 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4332 /* Free existing side data*/
4333 for (i = 0; i < dst->nb_side_data; i++)
4334 av_free(dst->side_data[i].data);
4335 av_freep(&dst->side_data);
4336 dst->nb_side_data = 0;
4338 /* Copy side data if present */
4339 if (src->nb_side_data) {
4340 dst->side_data = av_mallocz_array(src->nb_side_data,
4341 sizeof(AVPacketSideData));
4342 if (!dst->side_data)
4343 return AVERROR(ENOMEM);
4344 dst->nb_side_data = src->nb_side_data;
4346 for (i = 0; i < src->nb_side_data; i++) {
4347 uint8_t *data = av_memdup(src->side_data[i].data,
4348 src->side_data[i].size);
4350 return AVERROR(ENOMEM);
4351 dst->side_data[i].type = src->side_data[i].type;
4352 dst->side_data[i].size = src->side_data[i].size;
4353 dst->side_data[i].data = data;
4357 #if FF_API_LAVF_FFSERVER
4358 FF_DISABLE_DEPRECATION_WARNINGS
4359 av_freep(&dst->recommended_encoder_configuration);
4360 if (src->recommended_encoder_configuration) {
4361 const char *conf_str = src->recommended_encoder_configuration;
4362 dst->recommended_encoder_configuration = av_strdup(conf_str);
4363 if (!dst->recommended_encoder_configuration)
4364 return AVERROR(ENOMEM);
4366 FF_ENABLE_DEPRECATION_WARNINGS
4372 static void free_stream(AVStream **pst)
4374 AVStream *st = *pst;
4380 for (i = 0; i < st->nb_side_data; i++)
4381 av_freep(&st->side_data[i].data);
4382 av_freep(&st->side_data);
4385 av_parser_close(st->parser);
4387 if (st->attached_pic.data)
4388 av_packet_unref(&st->attached_pic);
4391 avcodec_free_context(&st->internal->avctx);
4392 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4393 av_bsf_free(&st->internal->bsfcs[i]);
4394 av_freep(&st->internal->bsfcs);
4396 av_freep(&st->internal->priv_pts);
4397 av_bsf_free(&st->internal->extract_extradata.bsf);
4398 av_packet_free(&st->internal->extract_extradata.pkt);
4400 av_freep(&st->internal);
4402 av_dict_free(&st->metadata);
4403 avcodec_parameters_free(&st->codecpar);
4404 av_freep(&st->probe_data.buf);
4405 av_freep(&st->index_entries);
4406 #if FF_API_LAVF_AVCTX
4407 FF_DISABLE_DEPRECATION_WARNINGS
4408 avcodec_free_context(&st->codec);
4409 FF_ENABLE_DEPRECATION_WARNINGS
4411 av_freep(&st->priv_data);
4413 av_freep(&st->info->duration_error);
4414 av_freep(&st->info);
4415 #if FF_API_LAVF_FFSERVER
4416 FF_DISABLE_DEPRECATION_WARNINGS
4417 av_freep(&st->recommended_encoder_configuration);
4418 FF_ENABLE_DEPRECATION_WARNINGS
4424 void ff_free_stream(AVFormatContext *s, AVStream *st)
4426 av_assert0(s->nb_streams>0);
4427 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4429 free_stream(&s->streams[ --s->nb_streams ]);
4432 void avformat_free_context(AVFormatContext *s)
4439 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4440 s->oformat->deinit(s);
4443 if (s->iformat && s->iformat->priv_class && s->priv_data)
4444 av_opt_free(s->priv_data);
4445 if (s->oformat && s->oformat->priv_class && s->priv_data)
4446 av_opt_free(s->priv_data);
4448 for (i = s->nb_streams - 1; i >= 0; i--)
4449 ff_free_stream(s, s->streams[i]);
4452 for (i = s->nb_programs - 1; i >= 0; i--) {
4453 av_dict_free(&s->programs[i]->metadata);
4454 av_freep(&s->programs[i]->stream_index);
4455 av_freep(&s->programs[i]);
4457 av_freep(&s->programs);
4458 av_freep(&s->priv_data);
4459 while (s->nb_chapters--) {
4460 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4461 av_freep(&s->chapters[s->nb_chapters]);
4463 av_freep(&s->chapters);
4464 av_dict_free(&s->metadata);
4465 av_dict_free(&s->internal->id3v2_meta);
4466 av_freep(&s->streams);
4467 flush_packet_queue(s);
4468 av_freep(&s->internal);
4473 void avformat_close_input(AVFormatContext **ps)
4484 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4485 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4488 flush_packet_queue(s);
4491 if (s->iformat->read_close)
4492 s->iformat->read_close(s);
4494 avformat_free_context(s);
4501 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4507 if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4508 if (s->max_streams < INT_MAX/sizeof(*streams))
4509 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);
4512 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4515 s->streams = streams;
4517 st = av_mallocz(sizeof(AVStream));
4520 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4524 st->info->last_dts = AV_NOPTS_VALUE;
4526 #if FF_API_LAVF_AVCTX
4527 FF_DISABLE_DEPRECATION_WARNINGS
4528 st->codec = avcodec_alloc_context3(c);
4534 FF_ENABLE_DEPRECATION_WARNINGS
4537 st->internal = av_mallocz(sizeof(*st->internal));
4541 st->codecpar = avcodec_parameters_alloc();
4545 st->internal->avctx = avcodec_alloc_context3(NULL);
4546 if (!st->internal->avctx)
4550 #if FF_API_LAVF_AVCTX
4551 FF_DISABLE_DEPRECATION_WARNINGS
4552 /* no default bitrate if decoding */
4553 st->codec->bit_rate = 0;
4554 FF_ENABLE_DEPRECATION_WARNINGS
4557 /* default pts setting is MPEG-like */
4558 avpriv_set_pts_info(st, 33, 1, 90000);
4559 /* we set the current DTS to 0 so that formats without any timestamps
4560 * but durations get some timestamps, formats with some unknown
4561 * timestamps have their first few packets buffered and the
4562 * timestamps corrected before they are returned to the user */
4563 st->cur_dts = RELATIVE_TS_BASE;
4565 st->cur_dts = AV_NOPTS_VALUE;
4568 st->index = s->nb_streams;
4569 st->start_time = AV_NOPTS_VALUE;
4570 st->duration = AV_NOPTS_VALUE;
4571 st->first_dts = AV_NOPTS_VALUE;
4572 st->probe_packets = s->max_probe_packets;
4573 st->pts_wrap_reference = AV_NOPTS_VALUE;
4574 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4576 st->last_IP_pts = AV_NOPTS_VALUE;
4577 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4578 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4579 st->pts_buffer[i] = AV_NOPTS_VALUE;
4581 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4583 #if FF_API_R_FRAME_RATE
4584 st->info->last_dts = AV_NOPTS_VALUE;
4586 st->info->fps_first_dts = AV_NOPTS_VALUE;
4587 st->info->fps_last_dts = AV_NOPTS_VALUE;
4589 st->inject_global_side_data = s->internal->inject_global_side_data;
4591 st->internal->need_context_update = 1;
4593 s->streams[s->nb_streams++] = st;
4600 AVProgram *av_new_program(AVFormatContext *ac, int id)
4602 AVProgram *program = NULL;
4605 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4607 for (i = 0; i < ac->nb_programs; i++)
4608 if (ac->programs[i]->id == id)
4609 program = ac->programs[i];
4612 program = av_mallocz(sizeof(AVProgram));
4615 dynarray_add(&ac->programs, &ac->nb_programs, program);
4616 program->discard = AVDISCARD_NONE;
4617 program->pmt_version = -1;
4620 program->pts_wrap_reference = AV_NOPTS_VALUE;
4621 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4623 program->start_time =
4624 program->end_time = AV_NOPTS_VALUE;
4629 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4630 int64_t start, int64_t end, const char *title)
4632 AVChapter *chapter = NULL;
4635 if (end != AV_NOPTS_VALUE && start > end) {
4636 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4640 for (i = 0; i < s->nb_chapters; i++)
4641 if (s->chapters[i]->id == id)
4642 chapter = s->chapters[i];
4645 chapter = av_mallocz(sizeof(AVChapter));
4648 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4650 av_dict_set(&chapter->metadata, "title", title, 0);
4652 chapter->time_base = time_base;
4653 chapter->start = start;
4659 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4662 AVProgram *program = NULL;
4665 if (idx >= ac->nb_streams) {
4666 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4670 for (i = 0; i < ac->nb_programs; i++) {
4671 if (ac->programs[i]->id != progid)
4673 program = ac->programs[i];
4674 for (j = 0; j < program->nb_stream_indexes; j++)
4675 if (program->stream_index[j] == idx)
4678 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4681 program->stream_index = tmp;
4682 program->stream_index[program->nb_stream_indexes++] = idx;
4687 uint64_t ff_ntp_time(void)
4689 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4692 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4694 uint64_t ntp_ts, frac_part, sec;
4697 //current ntp time in seconds and micro seconds
4698 sec = ntp_time_us / 1000000;
4699 usec = ntp_time_us % 1000000;
4701 //encoding in ntp timestamp format
4702 frac_part = usec * 0xFFFFFFFFULL;
4703 frac_part /= 1000000;
4705 if (sec > 0xFFFFFFFFULL)
4706 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4709 ntp_ts |= frac_part;
4714 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4717 char *q, buf1[20], c;
4718 int nd, len, percentd_found;
4730 while (av_isdigit(*p))
4731 nd = nd * 10 + *p++ - '0';
4733 } while (av_isdigit(c));
4739 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4744 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4746 if ((q - buf + len) > buf_size - 1)
4748 memcpy(q, buf1, len);
4756 if ((q - buf) < buf_size - 1)
4760 if (!percentd_found)
4769 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4771 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4774 void av_url_split(char *proto, int proto_size,
4775 char *authorization, int authorization_size,
4776 char *hostname, int hostname_size,
4777 int *port_ptr, char *path, int path_size, const char *url)
4779 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4785 if (authorization_size > 0)
4786 authorization[0] = 0;
4787 if (hostname_size > 0)
4792 /* parse protocol */
4793 if ((p = strchr(url, ':'))) {
4794 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4801 /* no protocol means plain filename */
4802 av_strlcpy(path, url, path_size);
4806 /* separate path from hostname */
4807 ls = strchr(p, '/');
4808 ls2 = strchr(p, '?');
4812 ls = FFMIN(ls, ls2);
4814 av_strlcpy(path, ls, path_size);
4816 ls = &p[strlen(p)]; // XXX
4818 /* the rest is hostname, use that to parse auth/port */
4820 /* authorization (user[:pass]@hostname) */
4822 while ((at = strchr(p, '@')) && at < ls) {
4823 av_strlcpy(authorization, at2,
4824 FFMIN(authorization_size, at + 1 - at2));
4825 p = at + 1; /* skip '@' */
4828 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4830 av_strlcpy(hostname, p + 1,
4831 FFMIN(hostname_size, brk - p));
4832 if (brk[1] == ':' && port_ptr)
4833 *port_ptr = atoi(brk + 2);
4834 } else if ((col = strchr(p, ':')) && col < ls) {
4835 av_strlcpy(hostname, p,
4836 FFMIN(col + 1 - p, hostname_size));
4838 *port_ptr = atoi(col + 1);
4840 av_strlcpy(hostname, p,
4841 FFMIN(ls + 1 - p, hostname_size));
4845 int ff_mkdir_p(const char *path)
4848 char *temp = av_strdup(path);
4852 if (!path || !temp) {
4856 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4858 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4862 for ( ; *pos != '\0'; ++pos) {
4863 if (*pos == '/' || *pos == '\\') {
4866 ret = mkdir(temp, 0755);
4871 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4872 ret = mkdir(temp, 0755);
4879 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4882 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4885 'C', 'D', 'E', 'F' };
4886 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4889 'c', 'd', 'e', 'f' };
4890 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4892 for (i = 0; i < s; i++) {
4893 buff[i * 2] = hex_table[src[i] >> 4];
4894 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4900 int ff_hex_to_data(uint8_t *data, const char *p)
4907 p += strspn(p, SPACE_CHARS);
4910 c = av_toupper((unsigned char) *p++);
4911 if (c >= '0' && c <= '9')
4913 else if (c >= 'A' && c <= 'F')
4928 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4929 unsigned int pts_num, unsigned int pts_den)
4932 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4933 if (new_tb.num != pts_num)
4934 av_log(NULL, AV_LOG_DEBUG,
4935 "st:%d removing common factor %d from timebase\n",
4936 s->index, pts_num / new_tb.num);
4938 av_log(NULL, AV_LOG_WARNING,
4939 "st:%d has too large timebase, reducing\n", s->index);
4941 if (new_tb.num <= 0 || new_tb.den <= 0) {
4942 av_log(NULL, AV_LOG_ERROR,
4943 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4944 new_tb.num, new_tb.den,
4948 s->time_base = new_tb;
4949 #if FF_API_LAVF_AVCTX
4950 FF_DISABLE_DEPRECATION_WARNINGS
4951 s->codec->pkt_timebase = new_tb;
4952 FF_ENABLE_DEPRECATION_WARNINGS
4954 s->internal->avctx->pkt_timebase = new_tb;
4955 s->pts_wrap_bits = pts_wrap_bits;
4958 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4961 const char *ptr = str;
4963 /* Parse key=value pairs. */
4966 char *dest = NULL, *dest_end;
4967 int key_len, dest_len = 0;
4969 /* Skip whitespace and potential commas. */
4970 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4977 if (!(ptr = strchr(key, '=')))
4980 key_len = ptr - key;
4982 callback_get_buf(context, key, key_len, &dest, &dest_len);
4983 dest_end = dest + dest_len - 1;
4987 while (*ptr && *ptr != '\"') {
4991 if (dest && dest < dest_end)
4995 if (dest && dest < dest_end)
5003 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5004 if (dest && dest < dest_end)
5012 int ff_find_stream_index(AVFormatContext *s, int id)
5015 for (i = 0; i < s->nb_streams; i++)
5016 if (s->streams[i]->id == id)
5021 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5025 unsigned int codec_tag;
5026 if (ofmt->query_codec)
5027 return ofmt->query_codec(codec_id, std_compliance);
5028 else if (ofmt->codec_tag)
5029 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5030 else if (codec_id == ofmt->video_codec ||
5031 codec_id == ofmt->audio_codec ||
5032 codec_id == ofmt->subtitle_codec ||
5033 codec_id == ofmt->data_codec)
5036 return AVERROR_PATCHWELCOME;
5039 int avformat_network_init(void)
5043 if ((ret = ff_network_init()) < 0)
5045 if ((ret = ff_tls_init()) < 0)
5051 int avformat_network_deinit(void)
5060 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5061 uint64_t channel_layout, int32_t sample_rate,
5062 int32_t width, int32_t height)
5068 return AVERROR(EINVAL);
5071 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5073 if (channel_layout) {
5075 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5079 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5081 if (width || height) {
5083 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5085 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5087 return AVERROR(ENOMEM);
5088 bytestream_put_le32(&data, flags);
5090 bytestream_put_le32(&data, channels);
5092 bytestream_put_le64(&data, channel_layout);
5094 bytestream_put_le32(&data, sample_rate);
5095 if (width || height) {
5096 bytestream_put_le32(&data, width);
5097 bytestream_put_le32(&data, height);
5102 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5104 AVRational undef = {0, 1};
5105 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5106 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5107 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5109 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5110 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5111 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5112 stream_sample_aspect_ratio = undef;
5114 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5115 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5116 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5117 frame_sample_aspect_ratio = undef;
5119 if (stream_sample_aspect_ratio.num)
5120 return stream_sample_aspect_ratio;
5122 return frame_sample_aspect_ratio;
5125 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5127 AVRational fr = st->r_frame_rate;
5128 AVRational codec_fr = st->internal->avctx->framerate;
5129 AVRational avg_fr = st->avg_frame_rate;
5131 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5132 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5137 if (st->internal->avctx->ticks_per_frame > 1) {
5138 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5139 (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))
5147 * Matches a stream specifier (but ignores requested index).
5149 * @param indexptr set to point to the requested stream index if there is one
5151 * @return <0 on error
5152 * 0 if st is NOT a matching stream
5153 * >0 if st is a matching stream
5155 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5156 const char *spec, const char **indexptr, AVProgram **p)
5158 int match = 1; /* Stores if the specifier matches so far. */
5160 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5164 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5165 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5166 enum AVMediaType type;
5170 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5171 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5172 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5173 case 'd': type = AVMEDIA_TYPE_DATA; break;
5174 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5175 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5176 default: av_assert0(0);
5178 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5179 return AVERROR(EINVAL);
5181 #if FF_API_LAVF_AVCTX
5182 FF_DISABLE_DEPRECATION_WARNINGS
5183 if (type != st->codecpar->codec_type
5184 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5186 FF_ENABLE_DEPRECATION_WARNINGS
5188 if (type != st->codecpar->codec_type)
5191 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5193 } else if (*spec == 'p' && *(spec + 1) == ':') {
5198 prog_id = strtol(spec, &endptr, 0);
5199 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5200 if (spec == endptr || (*endptr && *endptr++ != ':'))
5201 return AVERROR(EINVAL);
5204 for (i = 0; i < s->nb_programs; i++) {
5205 if (s->programs[i]->id != prog_id)
5208 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5209 if (st->index == s->programs[i]->stream_index[j]) {
5212 *p = s->programs[i];
5221 } else if (*spec == '#' ||
5222 (*spec == 'i' && *(spec + 1) == ':')) {
5225 spec += 1 + (*spec == 'i');
5226 stream_id = strtol(spec, &endptr, 0);
5227 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5228 return AVERROR(EINVAL);
5229 return match && (stream_id == st->id);
5230 } else if (*spec == 'm' && *(spec + 1) == ':') {
5231 AVDictionaryEntry *tag;
5237 val = strchr(spec, ':');
5239 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5241 return AVERROR(ENOMEM);
5243 tag = av_dict_get(st->metadata, key, NULL, 0);
5245 if (!val || !strcmp(tag->value, val + 1))
5254 return match && ret;
5255 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5256 AVCodecParameters *par = st->codecpar;
5257 #if FF_API_LAVF_AVCTX
5258 FF_DISABLE_DEPRECATION_WARNINGS
5259 AVCodecContext *codec = st->codec;
5260 FF_ENABLE_DEPRECATION_WARNINGS
5263 switch (par->codec_type) {
5264 case AVMEDIA_TYPE_AUDIO:
5265 val = par->sample_rate && par->channels;
5266 #if FF_API_LAVF_AVCTX
5267 val = val || (codec->sample_rate && codec->channels);
5269 if (par->format == AV_SAMPLE_FMT_NONE
5270 #if FF_API_LAVF_AVCTX
5271 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5276 case AVMEDIA_TYPE_VIDEO:
5277 val = par->width && par->height;
5278 #if FF_API_LAVF_AVCTX
5279 val = val || (codec->width && codec->height);
5281 if (par->format == AV_PIX_FMT_NONE
5282 #if FF_API_LAVF_AVCTX
5283 && codec->pix_fmt == AV_PIX_FMT_NONE
5288 case AVMEDIA_TYPE_UNKNOWN:
5295 #if FF_API_LAVF_AVCTX
5296 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5298 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5301 return AVERROR(EINVAL);
5309 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5314 const char *indexptr = NULL;
5315 AVProgram *p = NULL;
5318 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5325 index = strtol(indexptr, &endptr, 0);
5326 if (*endptr) { /* We can't have anything after the requested index. */
5327 ret = AVERROR(EINVAL);
5331 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5332 if (spec == indexptr)
5333 return (index == st->index);
5335 /* If we requested a matching stream index, we have to ensure st is that. */
5336 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5337 for (int i = 0; i < nb_streams && index >= 0; i++) {
5338 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5339 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5342 if (ret > 0 && index-- == 0 && st == candidate)
5348 if (ret == AVERROR(EINVAL))
5349 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5353 int ff_generate_avci_extradata(AVStream *st)
5355 static const uint8_t avci100_1080p_extradata[] = {
5357 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5358 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5359 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5360 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5361 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5362 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5363 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5364 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5365 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5367 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5370 static const uint8_t avci100_1080i_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, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5376 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5377 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5378 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5379 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5380 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5381 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5382 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5384 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5387 static const uint8_t avci50_1080p_extradata[] = {
5389 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5390 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5391 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5392 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5393 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5394 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5395 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5396 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5397 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5399 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5402 static const uint8_t avci50_1080i_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, 0x6e, 0x61,
5408 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5409 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5410 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5411 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5412 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5413 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5414 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5416 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5419 static const uint8_t avci100_720p_extradata[] = {
5421 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5422 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5423 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5424 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5425 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5426 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5427 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5428 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5429 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5430 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5432 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5435 static const uint8_t avci50_720p_extradata[] = {
5437 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5438 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5439 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5440 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5441 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5442 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5443 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5444 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5445 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5447 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5451 const uint8_t *data = NULL;
5454 if (st->codecpar->width == 1920) {
5455 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5456 data = avci100_1080p_extradata;
5457 size = sizeof(avci100_1080p_extradata);
5459 data = avci100_1080i_extradata;
5460 size = sizeof(avci100_1080i_extradata);
5462 } else if (st->codecpar->width == 1440) {
5463 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5464 data = avci50_1080p_extradata;
5465 size = sizeof(avci50_1080p_extradata);
5467 data = avci50_1080i_extradata;
5468 size = sizeof(avci50_1080i_extradata);
5470 } else if (st->codecpar->width == 1280) {
5471 data = avci100_720p_extradata;
5472 size = sizeof(avci100_720p_extradata);
5473 } else if (st->codecpar->width == 960) {
5474 data = avci50_720p_extradata;
5475 size = sizeof(avci50_720p_extradata);
5481 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5483 memcpy(st->codecpar->extradata, data, size);
5488 uint8_t *av_stream_get_side_data(const AVStream *st,
5489 enum AVPacketSideDataType type, int *size)
5493 for (i = 0; i < st->nb_side_data; i++) {
5494 if (st->side_data[i].type == type) {
5496 *size = st->side_data[i].size;
5497 return st->side_data[i].data;
5503 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5504 uint8_t *data, size_t size)
5506 AVPacketSideData *sd, *tmp;
5509 for (i = 0; i < st->nb_side_data; i++) {
5510 sd = &st->side_data[i];
5512 if (sd->type == type) {
5513 av_freep(&sd->data);
5520 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5521 return AVERROR(ERANGE);
5523 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5525 return AVERROR(ENOMEM);
5528 st->side_data = tmp;
5531 sd = &st->side_data[st->nb_side_data - 1];
5539 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5543 uint8_t *data = av_malloc(size);
5548 ret = av_stream_add_side_data(st, type, data, size);
5557 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5560 const AVBitStreamFilter *bsf;
5562 AVCodecParameters *in_par;
5564 if (!(bsf = av_bsf_get_by_name(name))) {
5565 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5566 return AVERROR_BSF_NOT_FOUND;
5569 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5572 if (st->internal->nb_bsfcs) {
5573 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5574 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5576 in_par = st->codecpar;
5577 bsfc->time_base_in = st->time_base;
5580 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5585 if (args && bsfc->filter->priv_class) {
5586 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5587 const char * shorthand[2] = {NULL};
5590 shorthand[0] = opt->name;
5592 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5598 if ((ret = av_bsf_init(bsfc)) < 0) {
5603 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5608 av_log(NULL, AV_LOG_VERBOSE,
5609 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5610 name, args ? args : "");
5615 FF_DISABLE_DEPRECATION_WARNINGS
5616 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5617 AVBitStreamFilterContext *bsfc)
5621 AVPacket new_pkt = *pkt;
5622 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5623 &new_pkt.data, &new_pkt.size,
5624 pkt->data, pkt->size,
5625 pkt->flags & AV_PKT_FLAG_KEY);
5626 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5627 av_packet_unref(pkt);
5628 memset(pkt, 0, sizeof(*pkt));
5631 if(a == 0 && new_pkt.data != pkt->data) {
5632 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
5634 memcpy(t, new_pkt.data, new_pkt.size);
5635 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5640 a = AVERROR(ENOMEM);
5644 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5645 av_buffer_default_free, NULL, 0);
5647 pkt->side_data = NULL;
5648 pkt->side_data_elems = 0;
5649 av_packet_unref(pkt);
5651 av_freep(&new_pkt.data);
5652 a = AVERROR(ENOMEM);
5656 av_log(codec, AV_LOG_ERROR,
5657 "Failed to open bitstream filter %s for stream %d with codec %s",
5658 bsfc->filter->name, pkt->stream_index,
5659 codec->codec ? codec->codec->name : "copy");
5669 FF_ENABLE_DEPRECATION_WARNINGS
5672 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5675 return AVERROR(EINVAL);
5677 if (!(s->oformat->flags & AVFMT_NOFILE))
5678 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5682 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5685 s->io_close(s, *pb);
5689 int ff_is_http_proto(char *filename) {
5690 const char *proto = avio_find_protocol_name(filename);
5691 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5694 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5696 AVDictionaryEntry *entry;
5697 int64_t parsed_timestamp;
5699 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5700 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5701 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5704 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5711 int ff_standardize_creation_time(AVFormatContext *s)
5714 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5716 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5720 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5725 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5727 if (size != AVPALETTE_SIZE) {
5728 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5729 return AVERROR_INVALIDDATA;
5731 memcpy(palette, side_data, AVPALETTE_SIZE);
5735 if (ret == CONTAINS_PAL) {
5737 for (i = 0; i < AVPALETTE_COUNT; i++)
5738 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5745 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5750 ret = av_bprint_finalize(buf, &str);
5753 if (!av_bprint_is_complete(buf)) {
5755 return AVERROR(ENOMEM);
5758 par->extradata = str;
5759 /* Note: the string is NUL terminated (so extradata can be read as a
5760 * string), but the ending character is not accounted in the size (in
5761 * binary formats you are likely not supposed to mux that character). When
5762 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5764 par->extradata_size = buf->len;
5768 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5769 AVStream *ost, const AVStream *ist,
5770 enum AVTimebaseSource copy_tb)
5772 //TODO: use [io]st->internal->avctx
5773 const AVCodecContext *dec_ctx = ist->codec;
5774 AVCodecContext *enc_ctx = ost->codec;
5776 enc_ctx->time_base = ist->time_base;
5778 * Avi is a special case here because it supports variable fps but
5779 * having the fps and timebase differe significantly adds quite some
5782 if (!strcmp(ofmt->name, "avi")) {
5783 #if FF_API_R_FRAME_RATE
5784 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5785 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5786 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5787 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5788 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5789 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5790 enc_ctx->time_base.num = ist->r_frame_rate.den;
5791 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5792 enc_ctx->ticks_per_frame = 2;
5795 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5796 && av_q2d(ist->time_base) < 1.0/500
5797 || copy_tb == AVFMT_TBCF_DECODER) {
5798 enc_ctx->time_base = dec_ctx->time_base;
5799 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5800 enc_ctx->time_base.den *= 2;
5801 enc_ctx->ticks_per_frame = 2;
5803 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5804 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5805 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5806 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5807 && av_q2d(ist->time_base) < 1.0/500
5808 || copy_tb == AVFMT_TBCF_DECODER) {
5809 enc_ctx->time_base = dec_ctx->time_base;
5810 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5814 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5815 && dec_ctx->time_base.num < dec_ctx->time_base.den
5816 && dec_ctx->time_base.num > 0
5817 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5818 enc_ctx->time_base = dec_ctx->time_base;
5821 if (ost->avg_frame_rate.num)
5822 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5824 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5825 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5830 AVRational av_stream_get_codec_timebase(const AVStream *st)
5832 // See avformat_transfer_internal_stream_timing_info() TODO.
5833 #if FF_API_LAVF_AVCTX
5834 FF_DISABLE_DEPRECATION_WARNINGS
5835 return st->codec->time_base;
5836 FF_ENABLE_DEPRECATION_WARNINGS
5838 return st->internal->avctx->time_base;
5842 void ff_format_set_url(AVFormatContext *s, char *url)
5847 #if FF_API_FORMAT_FILENAME
5848 FF_DISABLE_DEPRECATION_WARNINGS
5849 av_strlcpy(s->filename, url, sizeof(s->filename));
5850 FF_ENABLE_DEPRECATION_WARNINGS