2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixfmt.h"
34 #include "libavutil/thread.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/packet_internal.h"
41 #include "libavcodec/raw.h"
44 #include "avio_internal.h"
52 #include "libavutil/ffversion.h"
53 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
55 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
59 * various utility functions for use within FFmpeg
62 unsigned avformat_version(void)
64 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
65 return LIBAVFORMAT_VERSION_INT;
68 const char *avformat_configuration(void)
70 return FFMPEG_CONFIGURATION;
73 const char *avformat_license(void)
75 #define LICENSE_PREFIX "libavformat license: "
76 return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
79 int ff_lock_avformat(void)
81 return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
84 int ff_unlock_avformat(void)
86 return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
89 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
91 static int is_relative(int64_t ts) {
92 return ts > (RELATIVE_TS_BASE - (1LL<<48));
96 * Wrap a given time stamp, if there is an indication for an overflow
99 * @param timestamp the time stamp to wrap
100 * @return resulting time stamp
102 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
104 if (st->internal->pts_wrap_behavior != AV_PTS_WRAP_IGNORE && st->pts_wrap_bits < 64 &&
105 st->internal->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
106 if (st->internal->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
107 timestamp < st->internal->pts_wrap_reference)
108 return timestamp + (1ULL << st->pts_wrap_bits);
109 else if (st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
110 timestamp >= st->internal->pts_wrap_reference)
111 return timestamp - (1ULL << st->pts_wrap_bits);
116 int64_t av_stream_get_end_pts(const AVStream *st)
118 if (st->internal->priv_pts) {
119 return st->internal->priv_pts->val;
121 return AV_NOPTS_VALUE;
124 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
129 void av_format_inject_global_side_data(AVFormatContext *s)
132 s->internal->inject_global_side_data = 1;
133 for (i = 0; i < s->nb_streams; i++) {
134 AVStream *st = s->streams[i];
135 st->internal->inject_global_side_data = 1;
139 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
141 av_assert0(!dst->codec_whitelist &&
142 !dst->format_whitelist &&
143 !dst->protocol_whitelist &&
144 !dst->protocol_blacklist);
145 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
146 dst->format_whitelist = av_strdup(src->format_whitelist);
147 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
148 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
149 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
150 || (src-> format_whitelist && !dst-> format_whitelist)
151 || (src->protocol_whitelist && !dst->protocol_whitelist)
152 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
153 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
154 return AVERROR(ENOMEM);
159 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
161 #if FF_API_LAVF_AVCTX
162 FF_DISABLE_DEPRECATION_WARNINGS
163 if (st->codec->codec)
164 return st->codec->codec;
165 FF_ENABLE_DEPRECATION_WARNINGS
168 switch (st->codecpar->codec_type) {
169 case AVMEDIA_TYPE_VIDEO:
170 if (s->video_codec) return s->video_codec;
172 case AVMEDIA_TYPE_AUDIO:
173 if (s->audio_codec) return s->audio_codec;
175 case AVMEDIA_TYPE_SUBTITLE:
176 if (s->subtitle_codec) return s->subtitle_codec;
180 return avcodec_find_decoder(codec_id);
183 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
185 const AVCodec *codec;
187 #if CONFIG_H264_DECODER
188 /* Other parts of the code assume this decoder to be used for h264,
189 * so force it if possible. */
190 if (codec_id == AV_CODEC_ID_H264)
191 return avcodec_find_decoder_by_name("h264");
194 codec = find_decoder(s, st, codec_id);
198 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
199 const AVCodec *probe_codec = NULL;
201 while ((probe_codec = av_codec_iterate(&iter))) {
202 if (probe_codec->id == codec->id &&
203 av_codec_is_decoder(probe_codec) &&
204 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
213 /* an arbitrarily chosen "sane" max packet size -- 50M */
214 #define SANE_CHUNK_SIZE (50000000)
216 int ffio_limit(AVIOContext *s, int size)
218 if (s->maxsize>= 0) {
219 int64_t pos = avio_tell(s);
220 int64_t remaining= s->maxsize - pos;
221 if (remaining < size) {
222 int64_t newsize = avio_size(s);
223 if (!s->maxsize || s->maxsize<newsize)
224 s->maxsize = newsize - !newsize;
225 if (pos > s->maxsize && s->maxsize >= 0)
226 s->maxsize = AVERROR(EIO);
228 remaining = s->maxsize - pos;
231 if (s->maxsize >= 0 && remaining < size && size > 1) {
232 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG,
233 "Truncating packet of size %d to %"PRId64"\n",
234 size, remaining + !remaining);
235 size = remaining + !remaining;
241 /* Read the data in sane-sized chunks and append to pkt.
242 * Return the number of bytes read or an error. */
243 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
245 int orig_size = pkt->size;
249 int prev_size = pkt->size;
252 /* When the caller requests a lot of data, limit it to the amount
253 * left in file or SANE_CHUNK_SIZE when it is not known. */
255 if (read_size > SANE_CHUNK_SIZE/10) {
256 read_size = ffio_limit(s, read_size);
257 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
259 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
262 ret = av_grow_packet(pkt, read_size);
266 ret = avio_read(s, pkt->data + prev_size, read_size);
267 if (ret != read_size) {
268 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
275 pkt->flags |= AV_PKT_FLAG_CORRUPT;
278 av_packet_unref(pkt);
279 return pkt->size > orig_size ? pkt->size - orig_size : ret;
282 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
284 #if FF_API_INIT_PACKET
285 FF_DISABLE_DEPRECATION_WARNINGS
289 FF_ENABLE_DEPRECATION_WARNINGS
291 av_packet_unref(pkt);
293 pkt->pos = avio_tell(s);
295 return append_packet_chunked(s, pkt, size);
298 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
301 return av_get_packet(s, pkt, size);
302 return append_packet_chunked(s, pkt, size);
305 int av_filename_number_test(const char *filename)
309 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
312 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
315 static const struct {
318 enum AVMediaType type;
320 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
321 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
322 { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO },
323 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
324 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
325 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
326 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
327 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
328 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
329 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
330 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
331 { "mjpeg_2000",AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO },
332 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
333 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
334 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
338 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
342 av_log(s, AV_LOG_DEBUG,
343 "Probe with size=%d, packets=%d detected %s with score=%d\n",
344 pd->buf_size, s->max_probe_packets - st->probe_packets,
346 for (i = 0; fmt_id_type[i].name; i++) {
347 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
348 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
349 st->codecpar->sample_rate)
351 if (st->internal->request_probe > score &&
352 st->codecpar->codec_id != fmt_id_type[i].id)
354 st->codecpar->codec_id = fmt_id_type[i].id;
355 st->codecpar->codec_type = fmt_id_type[i].type;
356 st->internal->need_context_update = 1;
357 #if FF_API_LAVF_AVCTX
358 FF_DISABLE_DEPRECATION_WARNINGS
359 st->codec->codec_type = st->codecpar->codec_type;
360 st->codec->codec_id = st->codecpar->codec_id;
361 FF_ENABLE_DEPRECATION_WARNINGS
370 /************************************************************/
371 /* input media file */
373 #if FF_API_DEMUXER_OPEN
374 int av_demuxer_open(AVFormatContext *ic) {
377 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
378 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
379 return AVERROR(EINVAL);
382 if (ic->iformat->read_header) {
383 err = ic->iformat->read_header(ic);
388 if (ic->pb && !ic->internal->data_offset)
389 ic->internal->data_offset = avio_tell(ic->pb);
394 /* Open input file and probe the format if necessary. */
395 static int init_input(AVFormatContext *s, const char *filename,
396 AVDictionary **options)
399 AVProbeData pd = { filename, NULL, 0 };
400 int score = AVPROBE_SCORE_RETRY;
403 s->flags |= AVFMT_FLAG_CUSTOM_IO;
405 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
406 s, 0, s->format_probesize);
407 else if (s->iformat->flags & AVFMT_NOFILE)
408 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
409 "will be ignored with AVFMT_NOFILE format.\n");
413 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
414 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
417 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
422 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
423 s, 0, s->format_probesize);
426 int avformat_queue_attached_pictures(AVFormatContext *s)
429 for (i = 0; i < s->nb_streams; i++)
430 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
431 s->streams[i]->discard < AVDISCARD_ALL) {
432 if (s->streams[i]->attached_pic.size <= 0) {
433 av_log(s, AV_LOG_WARNING,
434 "Attached picture on stream %d has invalid size, "
439 ret = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
440 &s->internal->raw_packet_buffer_end,
441 &s->streams[i]->attached_pic,
449 int ff_add_attached_pic(AVFormatContext *s, AVStream *st0, AVIOContext *pb,
450 AVBufferRef **buf, int size)
456 if (!st && !(st = avformat_new_stream(s, NULL)))
457 return AVERROR(ENOMEM);
458 pkt = &st->attached_pic;
461 av_packet_unref(pkt);
463 pkt->data = (*buf)->data;
464 pkt->size = (*buf)->size - AV_INPUT_BUFFER_PADDING_SIZE;
467 ret = av_get_packet(pb, pkt, size);
471 st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
472 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
474 pkt->stream_index = st->index;
475 pkt->flags |= AV_PKT_FLAG_KEY;
480 ff_free_stream(s, st);
484 static int update_stream_avctx(AVFormatContext *s)
487 for (i = 0; i < s->nb_streams; i++) {
488 AVStream *st = s->streams[i];
490 if (!st->internal->need_context_update)
493 /* close parser, because it depends on the codec */
494 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
495 av_parser_close(st->parser);
499 /* update internal codec context, for the parser */
500 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
504 #if FF_API_LAVF_AVCTX
505 FF_DISABLE_DEPRECATION_WARNINGS
506 /* update deprecated public codec context */
507 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
510 FF_ENABLE_DEPRECATION_WARNINGS
513 st->internal->need_context_update = 0;
519 int avformat_open_input(AVFormatContext **ps, const char *filename,
520 const AVInputFormat *fmt, AVDictionary **options)
522 AVFormatContext *s = *ps;
524 AVDictionary *tmp = NULL;
525 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
527 if (!s && !(s = avformat_alloc_context()))
528 return AVERROR(ENOMEM);
530 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
531 return AVERROR(EINVAL);
537 av_dict_copy(&tmp, *options, 0);
539 if (s->pb) // must be before any goto fail
540 s->flags |= AVFMT_FLAG_CUSTOM_IO;
542 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
545 if (!(s->url = av_strdup(filename ? filename : ""))) {
546 ret = AVERROR(ENOMEM);
550 if ((ret = init_input(s, filename, &tmp)) < 0)
552 s->probe_score = ret;
554 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
555 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
556 if (!s->protocol_whitelist) {
557 ret = AVERROR(ENOMEM);
562 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
563 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
564 if (!s->protocol_blacklist) {
565 ret = AVERROR(ENOMEM);
570 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
571 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
572 ret = AVERROR(EINVAL);
576 avio_skip(s->pb, s->skip_initial_bytes);
578 /* Check filename in case an image number is expected. */
579 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
580 if (!av_filename_number_test(filename)) {
581 ret = AVERROR(EINVAL);
586 s->duration = s->start_time = AV_NOPTS_VALUE;
588 /* Allocate private data. */
589 if (s->iformat->priv_data_size > 0) {
590 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
591 ret = AVERROR(ENOMEM);
594 if (s->iformat->priv_class) {
595 *(const AVClass **) s->priv_data = s->iformat->priv_class;
596 av_opt_set_defaults(s->priv_data);
597 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
602 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
604 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
606 #if FF_API_DEMUXER_OPEN
607 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
609 if (s->iformat->read_header)
611 if ((ret = s->iformat->read_header(s)) < 0)
615 s->metadata = s->internal->id3v2_meta;
616 s->internal->id3v2_meta = NULL;
617 } else if (s->internal->id3v2_meta) {
618 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
619 av_dict_free(&s->internal->id3v2_meta);
622 if (id3v2_extra_meta) {
623 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
624 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
625 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
627 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
629 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
632 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
634 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
636 if ((ret = avformat_queue_attached_pictures(s)) < 0)
639 #if FF_API_DEMUXER_OPEN
640 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
642 if (s->pb && !s->internal->data_offset)
644 s->internal->data_offset = avio_tell(s->pb);
646 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
648 update_stream_avctx(s);
650 for (i = 0; i < s->nb_streams; i++)
651 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
654 av_dict_free(options);
661 if (s->iformat->read_close)
662 s->iformat->read_close(s);
664 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
666 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
668 avformat_free_context(s);
673 /*******************************************************/
675 static void force_codec_ids(AVFormatContext *s, AVStream *st)
677 switch (st->codecpar->codec_type) {
678 case AVMEDIA_TYPE_VIDEO:
679 if (s->video_codec_id)
680 st->codecpar->codec_id = s->video_codec_id;
682 case AVMEDIA_TYPE_AUDIO:
683 if (s->audio_codec_id)
684 st->codecpar->codec_id = s->audio_codec_id;
686 case AVMEDIA_TYPE_SUBTITLE:
687 if (s->subtitle_codec_id)
688 st->codecpar->codec_id = s->subtitle_codec_id;
690 case AVMEDIA_TYPE_DATA:
691 if (s->data_codec_id)
692 st->codecpar->codec_id = s->data_codec_id;
697 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
699 if (st->internal->request_probe>0) {
700 AVProbeData *pd = &st->internal->probe_data;
702 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
706 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
708 av_log(s, AV_LOG_WARNING,
709 "Failed to reallocate probe buffer for stream %d\n",
714 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
715 pd->buf_size += pkt->size;
716 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
719 st->probe_packets = 0;
721 av_log(s, AV_LOG_WARNING,
722 "nothing to probe for stream %d\n", st->index);
726 end= s->internal->raw_packet_buffer_remaining_size <= 0
727 || st->probe_packets<= 0;
729 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
730 int score = set_codec_from_probe_data(s, st, pd);
731 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
735 st->internal->request_probe = -1;
736 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
737 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
739 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
741 force_codec_ids(s, st);
747 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
749 int64_t ref = pkt->dts;
750 int i, pts_wrap_behavior;
751 int64_t pts_wrap_reference;
752 AVProgram *first_program;
754 if (ref == AV_NOPTS_VALUE)
756 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
758 ref &= (1LL << st->pts_wrap_bits)-1;
760 // reference time stamp should be 60 s before first time stamp
761 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
762 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
763 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
764 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
765 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
767 first_program = av_find_program_from_stream(s, NULL, stream_index);
769 if (!first_program) {
770 int default_stream_index = av_find_default_stream_index(s);
771 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
772 for (i = 0; i < s->nb_streams; i++) {
773 if (av_find_program_from_stream(s, NULL, i))
775 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
776 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
780 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
781 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
785 AVProgram *program = first_program;
787 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
788 pts_wrap_reference = program->pts_wrap_reference;
789 pts_wrap_behavior = program->pts_wrap_behavior;
792 program = av_find_program_from_stream(s, program, stream_index);
795 // update every program with differing pts_wrap_reference
796 program = first_program;
798 if (program->pts_wrap_reference != pts_wrap_reference) {
799 for (i = 0; i<program->nb_stream_indexes; i++) {
800 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
801 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
804 program->pts_wrap_reference = pts_wrap_reference;
805 program->pts_wrap_behavior = pts_wrap_behavior;
807 program = av_find_program_from_stream(s, program, stream_index);
813 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
818 #if FF_API_INIT_PACKET
819 FF_DISABLE_DEPRECATION_WARNINGS
823 FF_ENABLE_DEPRECATION_WARNINGS
825 av_packet_unref(pkt);
829 PacketList *pktl = s->internal->raw_packet_buffer;
830 const AVPacket *pkt1;
833 st = s->streams[pktl->pkt.stream_index];
834 if (s->internal->raw_packet_buffer_remaining_size <= 0)
835 if ((err = probe_codec(s, st, NULL)) < 0)
837 if (st->internal->request_probe <= 0) {
838 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
839 &s->internal->raw_packet_buffer_end, pkt);
840 s->internal->raw_packet_buffer_remaining_size += pkt->size;
845 err = s->iformat->read_packet(s, pkt);
847 av_packet_unref(pkt);
849 /* Some demuxers return FFERROR_REDO when they consume
850 data and discard it (ignored streams, junk, extradata).
851 We must re-call the demuxer to get the real packet. */
852 if (err == FFERROR_REDO)
854 if (!pktl || err == AVERROR(EAGAIN))
856 for (i = 0; i < s->nb_streams; i++) {
858 if (st->probe_packets || st->internal->request_probe > 0)
859 if ((err = probe_codec(s, st, NULL)) < 0)
861 av_assert0(st->internal->request_probe <= 0);
866 err = av_packet_make_refcounted(pkt);
868 av_packet_unref(pkt);
872 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
873 av_log(s, AV_LOG_WARNING,
874 "Packet corrupt (stream = %d, dts = %s)",
875 pkt->stream_index, av_ts2str(pkt->dts));
876 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
877 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
878 av_packet_unref(pkt);
881 av_log(s, AV_LOG_WARNING, ".\n");
884 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
885 "Invalid stream index.\n");
887 st = s->streams[pkt->stream_index];
889 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
890 // correct first time stamps to negative values
891 if (!is_relative(st->first_dts))
892 st->first_dts = wrap_timestamp(st, st->first_dts);
893 if (!is_relative(st->start_time))
894 st->start_time = wrap_timestamp(st, st->start_time);
895 if (!is_relative(st->cur_dts))
896 st->cur_dts = wrap_timestamp(st, st->cur_dts);
899 pkt->dts = wrap_timestamp(st, pkt->dts);
900 pkt->pts = wrap_timestamp(st, pkt->pts);
902 force_codec_ids(s, st);
904 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
905 if (s->use_wallclock_as_timestamps)
906 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
908 if (!pktl && st->internal->request_probe <= 0)
911 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
912 &s->internal->raw_packet_buffer_end,
915 av_packet_unref(pkt);
918 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
919 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
921 if ((err = probe_codec(s, st, pkt1)) < 0)
927 /**********************************************************/
929 static int determinable_frame_size(AVCodecContext *avctx)
931 switch(avctx->codec_id) {
932 case AV_CODEC_ID_MP1:
933 case AV_CODEC_ID_MP2:
934 case AV_CODEC_ID_MP3:
935 case AV_CODEC_ID_CODEC2:
943 * Return the frame duration in seconds. Return 0 if not available.
945 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
946 AVCodecParserContext *pc, AVPacket *pkt)
948 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
949 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
950 int frame_size, sample_rate;
952 #if FF_API_LAVF_AVCTX
953 FF_DISABLE_DEPRECATION_WARNINGS
954 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
955 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
956 FF_ENABLE_DEPRECATION_WARNINGS
961 switch (st->codecpar->codec_type) {
962 case AVMEDIA_TYPE_VIDEO:
963 if (st->r_frame_rate.num && !pc && s->iformat) {
964 *pnum = st->r_frame_rate.den;
965 *pden = st->r_frame_rate.num;
966 } else if (st->time_base.num * 1000LL > st->time_base.den) {
967 *pnum = st->time_base.num;
968 *pden = st->time_base.den;
969 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
970 av_assert0(st->internal->avctx->ticks_per_frame);
971 av_reduce(pnum, pden,
973 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
976 if (pc && pc->repeat_pict) {
977 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
978 av_reduce(pnum, pden,
979 (*pnum) * (1LL + pc->repeat_pict),
983 /* If this codec can be interlaced or progressive then we need
984 * a parser to compute duration of a packet. Thus if we have
985 * no parser in such case leave duration undefined. */
986 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
990 case AVMEDIA_TYPE_AUDIO:
991 if (st->internal->avctx_inited) {
992 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
993 sample_rate = st->internal->avctx->sample_rate;
995 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
996 sample_rate = st->codecpar->sample_rate;
998 if (frame_size <= 0 || sample_rate <= 0)
1001 *pden = sample_rate;
1008 int ff_is_intra_only(enum AVCodecID id)
1010 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1013 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1014 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1019 static int has_decode_delay_been_guessed(AVStream *st)
1021 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1022 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1024 #if CONFIG_H264_DECODER
1025 if (st->internal->avctx->has_b_frames &&
1026 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1029 if (st->internal->avctx->has_b_frames<3)
1030 return st->internal->nb_decoded_frames >= 7;
1031 else if (st->internal->avctx->has_b_frames<4)
1032 return st->internal->nb_decoded_frames >= 18;
1034 return st->internal->nb_decoded_frames >= 20;
1037 static PacketList *get_next_pkt(AVFormatContext *s, AVStream *st, PacketList *pktl)
1041 if (pktl == s->internal->packet_buffer_end)
1042 return s->internal->parse_queue;
1046 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1047 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1048 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1051 int delay = st->internal->avctx->has_b_frames;
1054 if (dts == AV_NOPTS_VALUE) {
1055 int64_t best_score = INT64_MAX;
1056 for (i = 0; i<delay; i++) {
1057 if (st->internal->pts_reorder_error_count[i]) {
1058 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1059 if (score < best_score) {
1061 dts = pts_buffer[i];
1066 for (i = 0; i<delay; i++) {
1067 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1068 int64_t diff = FFABS(pts_buffer[i] - dts)
1069 + (uint64_t)st->internal->pts_reorder_error[i];
1070 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1071 st->internal->pts_reorder_error[i] = diff;
1072 st->internal->pts_reorder_error_count[i]++;
1073 if (st->internal->pts_reorder_error_count[i] > 250) {
1074 st->internal->pts_reorder_error[i] >>= 1;
1075 st->internal->pts_reorder_error_count[i] >>= 1;
1082 if (dts == AV_NOPTS_VALUE)
1083 dts = pts_buffer[0];
1089 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1090 * of the packets in a window.
1092 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1093 PacketList *pkt_buffer)
1095 AVStream *st = s->streams[stream_index];
1096 int delay = st->internal->avctx->has_b_frames;
1099 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1101 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1102 pts_buffer[i] = AV_NOPTS_VALUE;
1104 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1105 if (pkt_buffer->pkt.stream_index != stream_index)
1108 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1109 pts_buffer[0] = pkt_buffer->pkt.pts;
1110 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1111 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1113 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1118 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1119 int64_t dts, int64_t pts, AVPacket *pkt)
1121 AVStream *st = s->streams[stream_index];
1122 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1123 PacketList *pktl_it;
1127 if (st->first_dts != AV_NOPTS_VALUE ||
1128 dts == AV_NOPTS_VALUE ||
1129 st->cur_dts == AV_NOPTS_VALUE ||
1130 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1131 dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1135 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1137 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1139 if (is_relative(pts))
1142 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1143 if (pktl_it->pkt.stream_index != stream_index)
1145 if (is_relative(pktl_it->pkt.pts))
1146 pktl_it->pkt.pts += shift;
1148 if (is_relative(pktl_it->pkt.dts))
1149 pktl_it->pkt.dts += shift;
1151 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1152 st->start_time = pktl_it->pkt.pts;
1153 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1154 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->internal->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1158 if (has_decode_delay_been_guessed(st)) {
1159 update_dts_from_pts(s, stream_index, pktl);
1162 if (st->start_time == AV_NOPTS_VALUE) {
1163 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1164 st->start_time = pts;
1166 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1167 st->start_time = av_sat_add64(st->start_time, av_rescale_q(st->internal->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base));
1171 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1172 int stream_index, int64_t duration)
1174 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1175 int64_t cur_dts = RELATIVE_TS_BASE;
1177 if (st->first_dts != AV_NOPTS_VALUE) {
1178 if (st->internal->update_initial_durations_done)
1180 st->internal->update_initial_durations_done = 1;
1181 cur_dts = st->first_dts;
1182 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1183 if (pktl->pkt.stream_index == stream_index) {
1184 if (pktl->pkt.pts != pktl->pkt.dts ||
1185 pktl->pkt.dts != AV_NOPTS_VALUE ||
1188 cur_dts -= duration;
1191 if (pktl && pktl->pkt.dts != st->first_dts) {
1192 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1193 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1197 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1200 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1201 st->first_dts = cur_dts;
1202 } else if (st->cur_dts != RELATIVE_TS_BASE)
1205 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1206 if (pktl->pkt.stream_index != stream_index)
1208 if ((pktl->pkt.pts == pktl->pkt.dts ||
1209 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1210 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1211 pktl->pkt.dts == st->first_dts ||
1212 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1213 !pktl->pkt.duration) {
1214 pktl->pkt.dts = cur_dts;
1215 if (!st->internal->avctx->has_b_frames)
1216 pktl->pkt.pts = cur_dts;
1217 pktl->pkt.duration = duration;
1220 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1223 st->cur_dts = cur_dts;
1226 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1227 AVCodecParserContext *pc, AVPacket *pkt,
1228 int64_t next_dts, int64_t next_pts)
1230 int num, den, presentation_delayed, delay, i;
1232 AVRational duration;
1233 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1234 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1236 if (s->flags & AVFMT_FLAG_NOFILLIN)
1239 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1240 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1241 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1242 st->internal->dts_ordered++;
1244 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1245 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1247 st->internal->last_dts_for_order_check);
1248 st->internal->dts_misordered++;
1250 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1251 st->internal->dts_ordered >>= 1;
1252 st->internal->dts_misordered >>= 1;
1256 st->internal->last_dts_for_order_check = pkt->dts;
1257 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1258 pkt->dts = AV_NOPTS_VALUE;
1261 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1262 pkt->dts = AV_NOPTS_VALUE;
1264 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1265 && !st->internal->avctx->has_b_frames)
1266 //FIXME Set low_delay = 0 when has_b_frames = 1
1267 st->internal->avctx->has_b_frames = 1;
1269 /* do we have a video B-frame ? */
1270 delay = st->internal->avctx->has_b_frames;
1271 presentation_delayed = 0;
1273 /* XXX: need has_b_frame, but cannot get it if the codec is
1274 * not initialized */
1276 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1277 presentation_delayed = 1;
1279 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1280 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1281 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1282 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1283 pkt->dts -= 1LL << st->pts_wrap_bits;
1285 pkt->pts += 1LL << st->pts_wrap_bits;
1288 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1289 * We take the conservative approach and discard both.
1290 * Note: If this is misbehaving for an H.264 file, then possibly
1291 * presentation_delayed is not set correctly. */
1292 if (delay == 1 && pkt->dts == pkt->pts &&
1293 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1294 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1295 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1296 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1297 pkt->dts = AV_NOPTS_VALUE;
1300 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1301 if (pkt->duration <= 0) {
1302 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1304 duration = (AVRational) {num, den};
1305 pkt->duration = av_rescale_rnd(1,
1306 num * (int64_t) st->time_base.den,
1307 den * (int64_t) st->time_base.num,
1312 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1313 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1315 /* Correct timestamps with byte offset if demuxers only have timestamps
1316 * on packet boundaries */
1317 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1318 /* this will estimate bitrate based on this frame's duration and size */
1319 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1320 if (pkt->pts != AV_NOPTS_VALUE)
1322 if (pkt->dts != AV_NOPTS_VALUE)
1326 /* This may be redundant, but it should not hurt. */
1327 if (pkt->dts != AV_NOPTS_VALUE &&
1328 pkt->pts != AV_NOPTS_VALUE &&
1329 pkt->pts > pkt->dts)
1330 presentation_delayed = 1;
1332 if (s->debug & FF_FDEBUG_TS)
1333 av_log(s, AV_LOG_DEBUG,
1334 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1335 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1336 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1338 /* Interpolate PTS and DTS if they are not present. We skip H264
1339 * currently because delay and has_b_frames are not reliably set. */
1340 if ((delay == 0 || (delay == 1 && pc)) &&
1342 if (presentation_delayed) {
1343 /* DTS = decompression timestamp */
1344 /* PTS = presentation timestamp */
1345 if (pkt->dts == AV_NOPTS_VALUE)
1346 pkt->dts = st->last_IP_pts;
1347 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1348 if (pkt->dts == AV_NOPTS_VALUE)
1349 pkt->dts = st->cur_dts;
1351 /* This is tricky: the dts must be incremented by the duration
1352 * of the frame we are displaying, i.e. the last I- or P-frame. */
1353 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1354 st->last_IP_duration = pkt->duration;
1355 if (pkt->dts != AV_NOPTS_VALUE)
1356 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1357 if (pkt->dts != AV_NOPTS_VALUE &&
1358 pkt->pts == AV_NOPTS_VALUE &&
1359 st->last_IP_duration > 0 &&
1360 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1361 next_dts != next_pts &&
1362 next_pts != AV_NOPTS_VALUE)
1363 pkt->pts = next_dts;
1365 if ((uint64_t)pkt->duration <= INT32_MAX)
1366 st->last_IP_duration = pkt->duration;
1367 st->last_IP_pts = pkt->pts;
1368 /* Cannot compute PTS if not present (we can compute it only
1369 * by knowing the future. */
1370 } else if (pkt->pts != AV_NOPTS_VALUE ||
1371 pkt->dts != AV_NOPTS_VALUE ||
1372 pkt->duration > 0 ) {
1374 /* presentation is not delayed : PTS and DTS are the same */
1375 if (pkt->pts == AV_NOPTS_VALUE)
1376 pkt->pts = pkt->dts;
1377 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1379 if (pkt->pts == AV_NOPTS_VALUE)
1380 pkt->pts = st->cur_dts;
1381 pkt->dts = pkt->pts;
1382 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1383 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1387 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1388 st->internal->pts_buffer[0] = pkt->pts;
1389 for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1390 FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1392 if(has_decode_delay_been_guessed(st))
1393 pkt->dts = select_from_pts_buffer(st, st->internal->pts_buffer, pkt->dts);
1395 // We skipped it above so we try here.
1397 // This should happen on the first packet
1398 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1399 if (pkt->dts > st->cur_dts)
1400 st->cur_dts = pkt->dts;
1402 if (s->debug & FF_FDEBUG_TS)
1403 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1404 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1407 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1408 pkt->flags |= AV_PKT_FLAG_KEY;
1412 * Parse a packet, add all split parts to parse_queue.
1414 * @param pkt Packet to parse; must not be NULL.
1415 * @param flush Indicates whether to flush. If set, pkt must be blank.
1417 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1418 int stream_index, int flush)
1420 AVPacket *out_pkt = s->internal->parse_pkt;
1421 AVStream *st = s->streams[stream_index];
1422 uint8_t *data = pkt->data;
1423 int size = pkt->size;
1424 int ret = 0, got_output = flush;
1426 if (!size && !flush && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1427 // preserve 0-size sync packets
1428 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1431 while (size > 0 || (flush && got_output)) {
1433 int64_t next_pts = pkt->pts;
1434 int64_t next_dts = pkt->dts;
1436 len = av_parser_parse2(st->parser, st->internal->avctx,
1437 &out_pkt->data, &out_pkt->size, data, size,
1438 pkt->pts, pkt->dts, pkt->pos);
1440 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1442 /* increment read pointer */
1443 av_assert1(data || !len);
1444 data = len ? data + len : data;
1447 got_output = !!out_pkt->size;
1452 if (pkt->buf && out_pkt->data == pkt->data) {
1453 /* reference pkt->buf only when out_pkt->data is guaranteed to point
1454 * to data in it and not in the parser's internal buffer. */
1455 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1456 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1457 out_pkt->buf = av_buffer_ref(pkt->buf);
1458 if (!out_pkt->buf) {
1459 ret = AVERROR(ENOMEM);
1463 ret = av_packet_make_refcounted(out_pkt);
1468 if (pkt->side_data) {
1469 out_pkt->side_data = pkt->side_data;
1470 out_pkt->side_data_elems = pkt->side_data_elems;
1471 pkt->side_data = NULL;
1472 pkt->side_data_elems = 0;
1475 /* set the duration */
1476 out_pkt->duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1477 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1478 if (st->internal->avctx->sample_rate > 0) {
1480 av_rescale_q_rnd(st->parser->duration,
1481 (AVRational) { 1, st->internal->avctx->sample_rate },
1487 out_pkt->stream_index = st->index;
1488 out_pkt->pts = st->parser->pts;
1489 out_pkt->dts = st->parser->dts;
1490 out_pkt->pos = st->parser->pos;
1491 out_pkt->flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1493 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1494 out_pkt->pos = st->parser->frame_offset;
1496 if (st->parser->key_frame == 1 ||
1497 (st->parser->key_frame == -1 &&
1498 st->parser->pict_type == AV_PICTURE_TYPE_I))
1499 out_pkt->flags |= AV_PKT_FLAG_KEY;
1501 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1502 out_pkt->flags |= AV_PKT_FLAG_KEY;
1504 compute_pkt_fields(s, st, st->parser, out_pkt, next_dts, next_pts);
1506 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1507 &s->internal->parse_queue_end,
1513 /* end of the stream => close and free the parser */
1515 av_parser_close(st->parser);
1521 av_packet_unref(out_pkt);
1522 av_packet_unref(pkt);
1526 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1528 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1531 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1533 int ret, i, got_packet = 0;
1534 AVDictionary *metadata = NULL;
1536 while (!got_packet && !s->internal->parse_queue) {
1539 /* read next packet */
1540 ret = ff_read_packet(s, pkt);
1542 if (ret == AVERROR(EAGAIN))
1544 /* flush the parsers */
1545 for (i = 0; i < s->nb_streams; i++) {
1547 if (st->parser && st->need_parsing)
1548 parse_packet(s, pkt, st->index, 1);
1550 /* all remaining packets are now in parse_queue =>
1551 * really terminate parsing */
1555 st = s->streams[pkt->stream_index];
1557 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1559 /* update context if required */
1560 if (st->internal->need_context_update) {
1561 if (avcodec_is_open(st->internal->avctx)) {
1562 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1563 avcodec_close(st->internal->avctx);
1564 st->internal->info->found_decoder = 0;
1567 /* close parser, because it depends on the codec */
1568 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1569 av_parser_close(st->parser);
1573 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1575 av_packet_unref(pkt);
1579 #if FF_API_LAVF_AVCTX
1580 FF_DISABLE_DEPRECATION_WARNINGS
1581 /* update deprecated public codec context */
1582 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1584 av_packet_unref(pkt);
1587 FF_ENABLE_DEPRECATION_WARNINGS
1590 st->internal->need_context_update = 0;
1593 if (pkt->pts != AV_NOPTS_VALUE &&
1594 pkt->dts != AV_NOPTS_VALUE &&
1595 pkt->pts < pkt->dts) {
1596 av_log(s, AV_LOG_WARNING,
1597 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1599 av_ts2str(pkt->pts),
1600 av_ts2str(pkt->dts),
1603 if (s->debug & FF_FDEBUG_TS)
1604 av_log(s, AV_LOG_DEBUG,
1605 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1607 av_ts2str(pkt->pts),
1608 av_ts2str(pkt->dts),
1609 pkt->size, pkt->duration, pkt->flags);
1611 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1612 st->parser = av_parser_init(st->codecpar->codec_id);
1614 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1615 "%s, packets or times may be invalid.\n",
1616 avcodec_get_name(st->codecpar->codec_id));
1617 /* no parser available: just output the raw packets */
1618 st->need_parsing = AVSTREAM_PARSE_NONE;
1619 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1620 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1621 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1622 st->parser->flags |= PARSER_FLAG_ONCE;
1623 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1624 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1627 if (!st->need_parsing || !st->parser) {
1628 /* no parsing needed: we just output the packet as is */
1629 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1630 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1631 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1632 ff_reduce_index(s, st->index);
1633 av_add_index_entry(st, pkt->pos, pkt->dts,
1634 0, 0, AVINDEX_KEYFRAME);
1637 } else if (st->discard < AVDISCARD_ALL) {
1638 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1640 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1641 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1642 st->codecpar->channels = st->internal->avctx->channels;
1643 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1644 st->codecpar->codec_id = st->internal->avctx->codec_id;
1647 av_packet_unref(pkt);
1649 if (pkt->flags & AV_PKT_FLAG_KEY)
1650 st->internal->skip_to_keyframe = 0;
1651 if (st->internal->skip_to_keyframe) {
1652 av_packet_unref(pkt);
1657 if (!got_packet && s->internal->parse_queue)
1658 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1661 AVStream *st = s->streams[pkt->stream_index];
1662 int discard_padding = 0;
1663 if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1664 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1665 int64_t sample = ts_to_samples(st, pts);
1666 int duration = ts_to_samples(st, pkt->duration);
1667 int64_t end_sample = sample + duration;
1668 if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1669 sample < st->internal->last_discard_sample)
1670 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1672 if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1673 st->internal->skip_samples = st->internal->start_skip_samples;
1674 if (st->internal->skip_samples || discard_padding) {
1675 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1677 AV_WL32(p, st->internal->skip_samples);
1678 AV_WL32(p + 4, discard_padding);
1679 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1681 st->internal->skip_samples = 0;
1684 if (st->internal->inject_global_side_data) {
1685 for (i = 0; i < st->nb_side_data; i++) {
1686 AVPacketSideData *src_sd = &st->side_data[i];
1689 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1692 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1694 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1698 memcpy(dst_data, src_sd->data, src_sd->size);
1700 st->internal->inject_global_side_data = 0;
1704 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1706 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1707 av_dict_copy(&s->metadata, metadata, 0);
1708 av_dict_free(&metadata);
1709 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1712 #if FF_API_LAVF_AVCTX
1713 update_stream_avctx(s);
1716 if (s->debug & FF_FDEBUG_TS)
1717 av_log(s, AV_LOG_DEBUG,
1718 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1719 "size=%d, duration=%"PRId64", flags=%d\n",
1721 av_ts2str(pkt->pts),
1722 av_ts2str(pkt->dts),
1723 pkt->size, pkt->duration, pkt->flags);
1725 /* A demuxer might have returned EOF because of an IO error, let's
1726 * propagate this back to the user. */
1727 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1733 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1735 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1741 ret = s->internal->packet_buffer
1742 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1743 &s->internal->packet_buffer_end, pkt)
1744 : read_frame_internal(s, pkt);
1751 PacketList *pktl = s->internal->packet_buffer;
1754 AVPacket *next_pkt = &pktl->pkt;
1756 if (next_pkt->dts != AV_NOPTS_VALUE) {
1757 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1758 // last dts seen for this stream. if any of packets following
1759 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1760 int64_t last_dts = next_pkt->dts;
1761 av_assert2(wrap_bits <= 64);
1762 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1763 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1764 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1765 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1767 next_pkt->pts = pktl->pkt.dts;
1769 if (last_dts != AV_NOPTS_VALUE) {
1770 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1771 last_dts = pktl->pkt.dts;
1776 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1777 // Fixing the last reference frame had none pts issue (For MXF etc).
1778 // We only do this when
1780 // 2. we are not able to resolve a pts value for current packet.
1781 // 3. the packets for this stream at the end of the files had valid dts.
1782 next_pkt->pts = last_dts + next_pkt->duration;
1784 pktl = s->internal->packet_buffer;
1787 /* read packet from packet buffer, if there is data */
1788 st = s->streams[next_pkt->stream_index];
1789 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1790 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1791 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1792 &s->internal->packet_buffer_end, pkt);
1797 ret = read_frame_internal(s, pkt);
1799 if (pktl && ret != AVERROR(EAGAIN)) {
1806 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1807 &s->internal->packet_buffer_end,
1810 av_packet_unref(pkt);
1817 st = s->streams[pkt->stream_index];
1818 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1819 ff_reduce_index(s, st->index);
1820 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1823 if (is_relative(pkt->dts))
1824 pkt->dts -= RELATIVE_TS_BASE;
1825 if (is_relative(pkt->pts))
1826 pkt->pts -= RELATIVE_TS_BASE;
1831 /* XXX: suppress the packet queue */
1832 static void flush_packet_queue(AVFormatContext *s)
1836 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1837 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1838 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1840 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1843 /*******************************************************/
1846 int av_find_default_stream_index(AVFormatContext *s)
1850 int best_stream = 0;
1851 int best_score = INT_MIN;
1853 if (s->nb_streams <= 0)
1855 for (i = 0; i < s->nb_streams; i++) {
1858 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1859 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1861 if (st->codecpar->width && st->codecpar->height)
1865 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1866 if (st->codecpar->sample_rate)
1869 if (st->codec_info_nb_frames)
1872 if (st->discard != AVDISCARD_ALL)
1875 if (score > best_score) {
1883 /** Flush the frame reader. */
1884 void ff_read_frame_flush(AVFormatContext *s)
1889 flush_packet_queue(s);
1891 /* Reset read state for each stream. */
1892 for (i = 0; i < s->nb_streams; i++) {
1896 av_parser_close(st->parser);
1899 st->last_IP_pts = AV_NOPTS_VALUE;
1900 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1901 if (st->first_dts == AV_NOPTS_VALUE)
1902 st->cur_dts = RELATIVE_TS_BASE;
1904 /* We set the current DTS to an unspecified origin. */
1905 st->cur_dts = AV_NOPTS_VALUE;
1907 st->probe_packets = s->max_probe_packets;
1909 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1910 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1912 if (s->internal->inject_global_side_data)
1913 st->internal->inject_global_side_data = 1;
1915 st->internal->skip_samples = 0;
1919 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1923 for (i = 0; i < s->nb_streams; i++) {
1924 AVStream *st = s->streams[i];
1927 av_rescale(timestamp,
1928 st->time_base.den * (int64_t) ref_st->time_base.num,
1929 st->time_base.num * (int64_t) ref_st->time_base.den);
1933 void ff_reduce_index(AVFormatContext *s, int stream_index)
1935 AVStream *st = s->streams[stream_index];
1936 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1938 if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1940 for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1941 st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1942 st->internal->nb_index_entries = i;
1946 int ff_add_index_entry(AVIndexEntry **index_entries,
1947 int *nb_index_entries,
1948 unsigned int *index_entries_allocated_size,
1949 int64_t pos, int64_t timestamp,
1950 int size, int distance, int flags)
1952 AVIndexEntry *entries, *ie;
1955 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1958 if (timestamp == AV_NOPTS_VALUE)
1959 return AVERROR(EINVAL);
1961 if (size < 0 || size > 0x3FFFFFFF)
1962 return AVERROR(EINVAL);
1964 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1965 timestamp -= RELATIVE_TS_BASE;
1967 entries = av_fast_realloc(*index_entries,
1968 index_entries_allocated_size,
1969 (*nb_index_entries + 1) *
1970 sizeof(AVIndexEntry));
1974 *index_entries = entries;
1976 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1977 timestamp, AVSEEK_FLAG_ANY);
1980 index = (*nb_index_entries)++;
1981 ie = &entries[index];
1982 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1984 ie = &entries[index];
1985 if (ie->timestamp != timestamp) {
1986 if (ie->timestamp <= timestamp)
1988 memmove(entries + index + 1, entries + index,
1989 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1990 (*nb_index_entries)++;
1991 } else if (ie->pos == pos && distance < ie->min_distance)
1992 // do not reduce the distance
1993 distance = ie->min_distance;
1997 ie->timestamp = timestamp;
1998 ie->min_distance = distance;
2005 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2006 int size, int distance, int flags)
2008 timestamp = wrap_timestamp(st, timestamp);
2009 return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
2010 &st->internal->index_entries_allocated_size, pos,
2011 timestamp, size, distance, flags);
2014 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2015 int64_t wanted_timestamp, int flags)
2023 // Optimize appending index entries at the end.
2024 if (b && entries[b - 1].timestamp < wanted_timestamp)
2030 // Search for the next non-discarded packet.
2031 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2033 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2039 timestamp = entries[m].timestamp;
2040 if (timestamp >= wanted_timestamp)
2042 if (timestamp <= wanted_timestamp)
2045 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2047 if (!(flags & AVSEEK_FLAG_ANY))
2048 while (m >= 0 && m < nb_entries &&
2049 !(entries[m].flags & AVINDEX_KEYFRAME))
2050 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2052 if (m == nb_entries)
2057 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2060 int64_t pos_delta = 0;
2062 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2063 const char *proto = avio_find_protocol_name(s->url);
2065 av_assert0(time_tolerance >= 0);
2068 av_log(s, AV_LOG_INFO,
2069 "Protocol name not provided, cannot determine if input is local or "
2070 "a network protocol, buffers and access patterns cannot be configured "
2071 "optimally without knowing the protocol\n");
2074 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2077 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2078 AVStream *st1 = s->streams[ist1];
2079 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2080 AVStream *st2 = s->streams[ist2];
2086 for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2087 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2088 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2090 skip = FFMAX(skip, e1->size);
2091 for (; i2 < st2->internal->nb_index_entries; i2++) {
2092 AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2093 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2094 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2096 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2104 /* XXX This could be adjusted depending on protocol*/
2105 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2106 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2108 /* realloc the buffer and the original data will be retained */
2109 if (ffio_realloc_buf(s->pb, pos_delta)) {
2110 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2114 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2117 if (skip < (1<<23)) {
2118 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2122 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2124 return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2125 wanted_timestamp, flags);
2128 int avformat_index_get_entries_count(const AVStream *st)
2130 return st->internal->nb_index_entries;
2133 const AVIndexEntry *avformat_index_get_entry(const AVStream *st, int idx)
2135 if (idx < 0 || idx >= st->internal->nb_index_entries)
2138 return &st->internal->index_entries[idx];
2141 const AVIndexEntry *avformat_index_get_entry_from_timestamp(const AVStream *st,
2142 int64_t wanted_timestamp,
2145 int idx = ff_index_search_timestamp(st->internal->index_entries,
2146 st->internal->nb_index_entries,
2147 wanted_timestamp, flags);
2152 return &st->internal->index_entries[idx];
2155 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2156 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2158 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2159 if (stream_index >= 0)
2160 ts = wrap_timestamp(s->streams[stream_index], ts);
2164 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2165 int64_t target_ts, int flags)
2167 const AVInputFormat *avif = s->iformat;
2168 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2169 int64_t ts_min, ts_max, ts;
2174 if (stream_index < 0)
2177 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2180 ts_min = AV_NOPTS_VALUE;
2181 pos_limit = -1; // GCC falsely says it may be uninitialized.
2183 st = s->streams[stream_index];
2184 if (st->internal->index_entries) {
2187 /* FIXME: Whole function must be checked for non-keyframe entries in
2188 * index case, especially read_timestamp(). */
2189 index = av_index_search_timestamp(st, target_ts,
2190 flags | AVSEEK_FLAG_BACKWARD);
2191 index = FFMAX(index, 0);
2192 e = &st->internal->index_entries[index];
2194 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2196 ts_min = e->timestamp;
2197 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2198 pos_min, av_ts2str(ts_min));
2200 av_assert1(index == 0);
2203 index = av_index_search_timestamp(st, target_ts,
2204 flags & ~AVSEEK_FLAG_BACKWARD);
2205 av_assert0(index < st->internal->nb_index_entries);
2207 e = &st->internal->index_entries[index];
2208 av_assert1(e->timestamp >= target_ts);
2210 ts_max = e->timestamp;
2211 pos_limit = pos_max - e->min_distance;
2212 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2213 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2217 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2218 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2223 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2226 ff_read_frame_flush(s);
2227 ff_update_cur_dts(s, st, ts);
2232 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2233 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2235 int64_t step = 1024;
2236 int64_t limit, ts_max;
2237 int64_t filesize = avio_size(s->pb);
2238 int64_t pos_max = filesize - 1;
2241 pos_max = FFMAX(0, (pos_max) - step);
2242 ts_max = ff_read_timestamp(s, stream_index,
2243 &pos_max, limit, read_timestamp);
2245 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2246 if (ts_max == AV_NOPTS_VALUE)
2250 int64_t tmp_pos = pos_max + 1;
2251 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2252 &tmp_pos, INT64_MAX, read_timestamp);
2253 if (tmp_ts == AV_NOPTS_VALUE)
2255 av_assert0(tmp_pos > pos_max);
2258 if (tmp_pos >= filesize)
2270 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2271 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2272 int64_t ts_min, int64_t ts_max,
2273 int flags, int64_t *ts_ret,
2274 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2275 int64_t *, int64_t))
2282 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2284 if (ts_min == AV_NOPTS_VALUE) {
2285 pos_min = s->internal->data_offset;
2286 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2287 if (ts_min == AV_NOPTS_VALUE)
2291 if (ts_min >= target_ts) {
2296 if (ts_max == AV_NOPTS_VALUE) {
2297 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2299 pos_limit = pos_max;
2302 if (ts_max <= target_ts) {
2307 av_assert0(ts_min < ts_max);
2310 while (pos_min < pos_limit) {
2311 av_log(s, AV_LOG_TRACE,
2312 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2313 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2314 av_assert0(pos_limit <= pos_max);
2316 if (no_change == 0) {
2317 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2318 // interpolate position (better than dichotomy)
2319 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2321 pos_min - approximate_keyframe_distance;
2322 } else if (no_change == 1) {
2323 // bisection if interpolation did not change min / max pos last time
2324 pos = (pos_min + pos_limit) >> 1;
2326 /* linear search if bisection failed, can only happen if there
2327 * are very few or no keyframes between min/max */
2332 else if (pos > pos_limit)
2336 // May pass pos_limit instead of -1.
2337 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2342 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2343 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2344 pos_min, pos, pos_max,
2345 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2346 pos_limit, start_pos, no_change);
2347 if (ts == AV_NOPTS_VALUE) {
2348 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2351 if (target_ts <= ts) {
2352 pos_limit = start_pos - 1;
2356 if (target_ts >= ts) {
2362 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2363 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2366 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2368 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2369 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2370 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2376 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2377 int64_t pos, int flags)
2379 int64_t pos_min, pos_max;
2381 pos_min = s->internal->data_offset;
2382 pos_max = avio_size(s->pb) - 1;
2386 else if (pos > pos_max)
2389 avio_seek(s->pb, pos, SEEK_SET);
2391 s->io_repositioned = 1;
2396 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2397 int64_t timestamp, int flags)
2404 st = s->streams[stream_index];
2406 index = av_index_search_timestamp(st, timestamp, flags);
2408 if (index < 0 && st->internal->nb_index_entries &&
2409 timestamp < st->internal->index_entries[0].timestamp)
2412 if (index < 0 || index == st->internal->nb_index_entries - 1) {
2413 AVPacket *pkt = s->internal->pkt;
2416 if (st->internal->nb_index_entries) {
2417 av_assert0(st->internal->index_entries);
2418 ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2419 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2421 ff_update_cur_dts(s, st, ie->timestamp);
2423 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2426 av_packet_unref(pkt);
2430 read_status = av_read_frame(s, pkt);
2431 } while (read_status == AVERROR(EAGAIN));
2432 if (read_status < 0)
2434 if (stream_index == pkt->stream_index && pkt->dts > timestamp) {
2435 if (pkt->flags & AV_PKT_FLAG_KEY) {
2436 av_packet_unref(pkt);
2439 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2440 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);
2441 av_packet_unref(pkt);
2445 av_packet_unref(pkt);
2447 index = av_index_search_timestamp(st, timestamp, flags);
2452 ff_read_frame_flush(s);
2453 if (s->iformat->read_seek)
2454 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2456 ie = &st->internal->index_entries[index];
2457 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2459 ff_update_cur_dts(s, st, ie->timestamp);
2464 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2465 int64_t timestamp, int flags)
2470 if (flags & AVSEEK_FLAG_BYTE) {
2471 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2473 ff_read_frame_flush(s);
2474 return seek_frame_byte(s, stream_index, timestamp, flags);
2477 if (stream_index < 0) {
2478 stream_index = av_find_default_stream_index(s);
2479 if (stream_index < 0)
2482 st = s->streams[stream_index];
2483 /* timestamp for default must be expressed in AV_TIME_BASE units */
2484 timestamp = av_rescale(timestamp, st->time_base.den,
2485 AV_TIME_BASE * (int64_t) st->time_base.num);
2488 /* first, we try the format specific seek */
2489 if (s->iformat->read_seek) {
2490 ff_read_frame_flush(s);
2491 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2497 if (s->iformat->read_timestamp &&
2498 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2499 ff_read_frame_flush(s);
2500 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2501 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2502 ff_read_frame_flush(s);
2503 return seek_frame_generic(s, stream_index, timestamp, flags);
2508 int av_seek_frame(AVFormatContext *s, int stream_index,
2509 int64_t timestamp, int flags)
2513 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2514 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2515 if ((flags & AVSEEK_FLAG_BACKWARD))
2519 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2520 flags & ~AVSEEK_FLAG_BACKWARD);
2523 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2526 ret = avformat_queue_attached_pictures(s);
2531 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2532 int64_t ts, int64_t max_ts, int flags)
2534 if (min_ts > ts || max_ts < ts)
2536 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2537 return AVERROR(EINVAL);
2540 flags |= AVSEEK_FLAG_ANY;
2541 flags &= ~AVSEEK_FLAG_BACKWARD;
2543 if (s->iformat->read_seek2) {
2545 ff_read_frame_flush(s);
2547 if (stream_index == -1 && s->nb_streams == 1) {
2548 AVRational time_base = s->streams[0]->time_base;
2549 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2550 min_ts = av_rescale_rnd(min_ts, time_base.den,
2551 time_base.num * (int64_t)AV_TIME_BASE,
2552 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2553 max_ts = av_rescale_rnd(max_ts, time_base.den,
2554 time_base.num * (int64_t)AV_TIME_BASE,
2555 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2559 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2563 ret = avformat_queue_attached_pictures(s);
2567 if (s->iformat->read_timestamp) {
2568 // try to seek via read_timestamp()
2571 // Fall back on old API if new is not implemented but old is.
2572 // Note the old API has somewhat different semantics.
2573 if (s->iformat->read_seek || 1) {
2574 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2575 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2576 if (ret<0 && ts != min_ts && max_ts != ts) {
2577 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2579 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2584 // try some generic seek like seek_frame_generic() but with new ts semantics
2585 return -1; //unreachable
2588 int avformat_flush(AVFormatContext *s)
2590 ff_read_frame_flush(s);
2594 /*******************************************************/
2597 * Return TRUE if the stream has accurate duration in any stream.
2599 * @return TRUE if the stream has accurate duration for at least one component.
2601 static int has_duration(AVFormatContext *ic)
2606 for (i = 0; i < ic->nb_streams; i++) {
2607 st = ic->streams[i];
2608 if (st->duration != AV_NOPTS_VALUE)
2611 if (ic->duration != AV_NOPTS_VALUE)
2617 * Estimate the stream timings from the one of each components.
2619 * Also computes the global bitrate if possible.
2621 static void update_stream_timings(AVFormatContext *ic)
2623 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2624 int64_t duration, duration1, duration_text, filesize;
2628 start_time = INT64_MAX;
2629 start_time_text = INT64_MAX;
2630 end_time = INT64_MIN;
2631 end_time_text = INT64_MIN;
2632 duration = INT64_MIN;
2633 duration_text = INT64_MIN;
2635 for (i = 0; i < ic->nb_streams; i++) {
2636 AVStream *st = ic->streams[i];
2637 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2638 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2639 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2640 start_time1 = av_rescale_q(st->start_time, st->time_base,
2643 start_time_text = FFMIN(start_time_text, start_time1);
2645 start_time = FFMIN(start_time, start_time1);
2646 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2648 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2649 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2650 end_time1 += start_time1;
2652 end_time_text = FFMAX(end_time_text, end_time1);
2654 end_time = FFMAX(end_time, end_time1);
2656 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2657 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2658 p->start_time = start_time1;
2659 if (p->end_time < end_time1)
2660 p->end_time = end_time1;
2663 if (st->duration != AV_NOPTS_VALUE) {
2664 duration1 = av_rescale_q(st->duration, st->time_base,
2667 duration_text = FFMAX(duration_text, duration1);
2669 duration = FFMAX(duration, duration1);
2672 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2673 start_time = start_time_text;
2674 else if (start_time > start_time_text)
2675 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2677 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2678 end_time = end_time_text;
2679 else if (end_time < end_time_text)
2680 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2682 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2683 duration = duration_text;
2684 else if (duration < duration_text)
2685 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2687 if (start_time != INT64_MAX) {
2688 ic->start_time = start_time;
2689 if (end_time != INT64_MIN) {
2690 if (ic->nb_programs > 1) {
2691 for (i = 0; i < ic->nb_programs; i++) {
2692 p = ic->programs[i];
2693 if (p->start_time != AV_NOPTS_VALUE &&
2694 p->end_time > p->start_time &&
2695 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2696 duration = FFMAX(duration, p->end_time - p->start_time);
2698 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2699 duration = FFMAX(duration, end_time - start_time);
2703 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2704 ic->duration = duration;
2706 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2707 /* compute the bitrate */
2708 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2709 (double) ic->duration;
2710 if (bitrate >= 0 && bitrate <= INT64_MAX)
2711 ic->bit_rate = bitrate;
2715 static void fill_all_stream_timings(AVFormatContext *ic)
2720 update_stream_timings(ic);
2721 for (i = 0; i < ic->nb_streams; i++) {
2722 st = ic->streams[i];
2723 if (st->start_time == AV_NOPTS_VALUE) {
2724 if (ic->start_time != AV_NOPTS_VALUE)
2725 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2727 if (ic->duration != AV_NOPTS_VALUE)
2728 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2734 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2736 int64_t filesize, duration;
2737 int i, show_warning = 0;
2740 /* if bit_rate is already set, we believe it */
2741 if (ic->bit_rate <= 0) {
2742 int64_t bit_rate = 0;
2743 for (i = 0; i < ic->nb_streams; i++) {
2744 st = ic->streams[i];
2745 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2746 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2747 if (st->codecpar->bit_rate > 0) {
2748 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2752 bit_rate += st->codecpar->bit_rate;
2753 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2754 // If we have a videostream with packets but without a bitrate
2755 // then consider the sum not known
2760 ic->bit_rate = bit_rate;
2763 /* if duration is already set, we believe it */
2764 if (ic->duration == AV_NOPTS_VALUE &&
2765 ic->bit_rate != 0) {
2766 filesize = ic->pb ? avio_size(ic->pb) : 0;
2767 if (filesize > ic->internal->data_offset) {
2768 filesize -= ic->internal->data_offset;
2769 for (i = 0; i < ic->nb_streams; i++) {
2770 st = ic->streams[i];
2771 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2772 && st->duration == AV_NOPTS_VALUE) {
2773 duration = av_rescale(filesize, 8LL * st->time_base.den,
2775 (int64_t) st->time_base.num);
2776 st->duration = duration;
2783 av_log(ic, AV_LOG_WARNING,
2784 "Estimating duration from bitrate, this may be inaccurate\n");
2787 #define DURATION_MAX_READ_SIZE 250000LL
2788 #define DURATION_MAX_RETRY 6
2790 /* only usable for MPEG-PS streams */
2791 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2793 AVPacket *pkt = ic->internal->pkt;
2795 int num, den, read_size, i, ret;
2796 int found_duration = 0;
2798 int64_t filesize, offset, duration;
2801 /* flush packet queue */
2802 flush_packet_queue(ic);
2804 for (i = 0; i < ic->nb_streams; i++) {
2805 st = ic->streams[i];
2806 if (st->start_time == AV_NOPTS_VALUE &&
2807 st->first_dts == AV_NOPTS_VALUE &&
2808 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2809 av_log(ic, AV_LOG_WARNING,
2810 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2813 av_parser_close(st->parser);
2818 if (ic->skip_estimate_duration_from_pts) {
2819 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2820 goto skip_duration_calc;
2823 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2824 /* estimate the end time (duration) */
2825 /* XXX: may need to support wrapping */
2826 filesize = ic->pb ? avio_size(ic->pb) : 0;
2828 is_end = found_duration;
2829 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2833 avio_seek(ic->pb, offset, SEEK_SET);
2836 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2840 ret = ff_read_packet(ic, pkt);
2841 } while (ret == AVERROR(EAGAIN));
2844 read_size += pkt->size;
2845 st = ic->streams[pkt->stream_index];
2846 if (pkt->pts != AV_NOPTS_VALUE &&
2847 (st->start_time != AV_NOPTS_VALUE ||
2848 st->first_dts != AV_NOPTS_VALUE)) {
2849 if (pkt->duration == 0) {
2850 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2852 pkt->duration = av_rescale_rnd(1,
2853 num * (int64_t) st->time_base.den,
2854 den * (int64_t) st->time_base.num,
2858 duration = pkt->pts + pkt->duration;
2860 if (st->start_time != AV_NOPTS_VALUE)
2861 duration -= st->start_time;
2863 duration -= st->first_dts;
2865 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2866 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2867 st->duration = duration;
2868 st->internal->info->last_duration = duration;
2871 av_packet_unref(pkt);
2874 /* check if all audio/video streams have valid duration */
2877 for (i = 0; i < ic->nb_streams; i++) {
2878 st = ic->streams[i];
2879 switch (st->codecpar->codec_type) {
2880 case AVMEDIA_TYPE_VIDEO:
2881 case AVMEDIA_TYPE_AUDIO:
2882 if (st->duration == AV_NOPTS_VALUE)
2889 ++retry <= DURATION_MAX_RETRY);
2891 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2893 /* warn about audio/video streams which duration could not be estimated */
2894 for (i = 0; i < ic->nb_streams; i++) {
2895 st = ic->streams[i];
2896 if (st->duration == AV_NOPTS_VALUE) {
2897 switch (st->codecpar->codec_type) {
2898 case AVMEDIA_TYPE_VIDEO:
2899 case AVMEDIA_TYPE_AUDIO:
2900 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2901 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2903 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2908 fill_all_stream_timings(ic);
2910 avio_seek(ic->pb, old_offset, SEEK_SET);
2911 for (i = 0; i < ic->nb_streams; i++) {
2914 st = ic->streams[i];
2915 st->cur_dts = st->first_dts;
2916 st->last_IP_pts = AV_NOPTS_VALUE;
2917 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2918 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2919 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2923 /* 1:1 map to AVDurationEstimationMethod */
2924 static const char *const duration_name[] = {
2925 [AVFMT_DURATION_FROM_PTS] = "pts",
2926 [AVFMT_DURATION_FROM_STREAM] = "stream",
2927 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2930 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2932 return duration_name[method];
2935 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2939 /* get the file size, if possible */
2940 if (ic->iformat->flags & AVFMT_NOFILE) {
2943 file_size = avio_size(ic->pb);
2944 file_size = FFMAX(0, file_size);
2947 if ((!strcmp(ic->iformat->name, "mpeg") ||
2948 !strcmp(ic->iformat->name, "mpegts")) &&
2949 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2950 /* get accurate estimate from the PTSes */
2951 estimate_timings_from_pts(ic, old_offset);
2952 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2953 } else if (has_duration(ic)) {
2954 /* at least one component has timings - we use them for all
2956 fill_all_stream_timings(ic);
2957 /* nut demuxer estimate the duration from PTS */
2958 if(!strcmp(ic->iformat->name, "nut"))
2959 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2961 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2963 /* less precise: use bitrate info */
2964 estimate_timings_from_bit_rate(ic);
2965 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2967 update_stream_timings(ic);
2969 for (unsigned i = 0; i < ic->nb_streams; i++) {
2970 AVStream *st = ic->streams[i];
2971 if (st->time_base.den)
2972 av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
2973 av_ts2timestr(st->start_time, &st->time_base),
2974 av_ts2timestr(st->duration, &st->time_base));
2976 av_log(ic, AV_LOG_TRACE,
2977 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2978 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2979 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2980 duration_estimate_name(ic->duration_estimation_method),
2981 (int64_t)ic->bit_rate / 1000);
2984 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2986 AVCodecContext *avctx = st->internal->avctx;
2988 #define FAIL(errmsg) do { \
2990 *errmsg_ptr = errmsg; \
2994 if ( avctx->codec_id == AV_CODEC_ID_NONE
2995 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2996 FAIL("unknown codec");
2997 switch (avctx->codec_type) {
2998 case AVMEDIA_TYPE_AUDIO:
2999 if (!avctx->frame_size && determinable_frame_size(avctx))
3000 FAIL("unspecified frame size");
3001 if (st->internal->info->found_decoder >= 0 &&
3002 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3003 FAIL("unspecified sample format");
3004 if (!avctx->sample_rate)
3005 FAIL("unspecified sample rate");
3006 if (!avctx->channels)
3007 FAIL("unspecified number of channels");
3008 if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3009 FAIL("no decodable DTS frames");
3011 case AVMEDIA_TYPE_VIDEO:
3013 FAIL("unspecified size");
3014 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3015 FAIL("unspecified pixel format");
3016 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3017 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3018 FAIL("no frame in rv30/40 and no sar");
3020 case AVMEDIA_TYPE_SUBTITLE:
3021 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3022 FAIL("unspecified size");
3024 case AVMEDIA_TYPE_DATA:
3025 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3031 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3032 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3033 const AVPacket *avpkt, AVDictionary **options)
3035 AVCodecContext *avctx = st->internal->avctx;
3036 const AVCodec *codec;
3037 int got_picture = 1, ret = 0;
3038 AVFrame *frame = av_frame_alloc();
3039 AVSubtitle subtitle;
3040 AVPacket pkt = *avpkt;
3041 int do_skip_frame = 0;
3042 enum AVDiscard skip_frame;
3045 return AVERROR(ENOMEM);
3047 if (!avcodec_is_open(avctx) &&
3048 st->internal->info->found_decoder <= 0 &&
3049 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3050 AVDictionary *thread_opt = NULL;
3052 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3055 st->internal->info->found_decoder = -st->codecpar->codec_id;
3060 /* Force thread count to 1 since the H.264 decoder will not extract
3061 * SPS and PPS to extradata during multi-threaded decoding. */
3062 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3063 /* Force lowres to 0. The decoder might reduce the video size by the
3064 * lowres factor, and we don't want that propagated to the stream's
3066 av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
3067 if (s->codec_whitelist)
3068 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3069 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3071 av_dict_free(&thread_opt);
3073 st->internal->info->found_decoder = -avctx->codec_id;
3076 st->internal->info->found_decoder = 1;
3077 } else if (!st->internal->info->found_decoder)
3078 st->internal->info->found_decoder = 1;
3080 if (st->internal->info->found_decoder < 0) {
3085 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3087 skip_frame = avctx->skip_frame;
3088 avctx->skip_frame = AVDISCARD_ALL;
3091 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3093 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3094 (!st->codec_info_nb_frames &&
3095 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3097 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3098 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3099 ret = avcodec_send_packet(avctx, &pkt);
3100 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3104 ret = avcodec_receive_frame(avctx, frame);
3107 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3109 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3110 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3111 &got_picture, &pkt);
3113 avsubtitle_free(&subtitle);
3119 st->internal->nb_decoded_frames++;
3124 if (!pkt.data && !got_picture)
3128 if (do_skip_frame) {
3129 avctx->skip_frame = skip_frame;
3132 av_frame_free(&frame);
3136 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3138 while (tags->id != AV_CODEC_ID_NONE) {
3146 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3149 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3150 if (tag == tags[i].tag)
3152 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3153 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3155 return AV_CODEC_ID_NONE;
3158 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3160 if (bps <= 0 || bps > 64)
3161 return AV_CODEC_ID_NONE;
3166 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3168 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3170 return AV_CODEC_ID_NONE;
3175 if (sflags & (1 << (bps - 1))) {
3178 return AV_CODEC_ID_PCM_S8;
3180 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3182 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3184 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3186 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3188 return AV_CODEC_ID_NONE;
3193 return AV_CODEC_ID_PCM_U8;
3195 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3197 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3199 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3201 return AV_CODEC_ID_NONE;
3207 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3210 if (!av_codec_get_tag2(tags, id, &tag))
3215 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3219 for (i = 0; tags && tags[i]; i++) {
3220 const AVCodecTag *codec_tags = tags[i];
3221 while (codec_tags->id != AV_CODEC_ID_NONE) {
3222 if (codec_tags->id == id) {
3223 *tag = codec_tags->tag;
3232 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3235 for (i = 0; tags && tags[i]; i++) {
3236 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3237 if (id != AV_CODEC_ID_NONE)
3240 return AV_CODEC_ID_NONE;
3243 static int chapter_start_cmp(const void *p1, const void *p2)
3245 AVChapter *ch1 = *(AVChapter**)p1;
3246 AVChapter *ch2 = *(AVChapter**)p2;
3247 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3250 return (ch1 > ch2) - (ch1 < ch2);
3253 static int compute_chapters_end(AVFormatContext *s)
3256 int64_t max_time = 0;
3257 AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3260 return AVERROR(ENOMEM);
3262 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3263 max_time = s->duration +
3264 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3266 for (i = 0; i < s->nb_chapters; i++)
3267 timetable[i] = s->chapters[i];
3268 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3270 for (i = 0; i < s->nb_chapters; i++)
3271 if (timetable[i]->end == AV_NOPTS_VALUE) {
3272 AVChapter *ch = timetable[i];
3273 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3277 if (i + 1 < s->nb_chapters) {
3278 AVChapter *ch1 = timetable[i + 1];
3279 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3281 if (next_start > ch->start && next_start < end)
3284 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3290 static int get_std_framerate(int i)
3293 return (i + 1) * 1001;
3297 return (i + 31) * 1001 * 12;
3301 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3305 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3308 /* Is the time base unreliable?
3309 * This is a heuristic to balance between quick acceptance of the values in
3310 * the headers vs. some extra checks.
3311 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3312 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3313 * And there are "variable" fps files this needs to detect as well. */
3314 static int tb_unreliable(AVCodecContext *c)
3316 if (c->time_base.den >= 101LL * c->time_base.num ||
3317 c->time_base.den < 5LL * c->time_base.num ||
3318 // c->codec_tag == AV_RL32("DIVX") ||
3319 // c->codec_tag == AV_RL32("XVID") ||
3320 c->codec_tag == AV_RL32("mp4v") ||
3321 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3322 c->codec_id == AV_CODEC_ID_GIF ||
3323 c->codec_id == AV_CODEC_ID_HEVC ||
3324 c->codec_id == AV_CODEC_ID_H264)
3329 int ff_alloc_extradata(AVCodecParameters *par, int size)
3331 av_freep(&par->extradata);
3332 par->extradata_size = 0;
3334 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3335 return AVERROR(EINVAL);
3337 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3338 if (!par->extradata)
3339 return AVERROR(ENOMEM);
3341 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3342 par->extradata_size = size;
3347 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3349 int ret = ff_alloc_extradata(par, size);
3352 ret = avio_read(pb, par->extradata, size);
3354 av_freep(&par->extradata);
3355 par->extradata_size = 0;
3356 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3357 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3363 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3366 int64_t last = st->internal->info->last_dts;
3368 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3369 && ts - (uint64_t)last < INT64_MAX) {
3370 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3371 int64_t duration = ts - last;
3373 if (!st->internal->info->duration_error)
3374 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3375 if (!st->internal->info->duration_error)
3376 return AVERROR(ENOMEM);
3378 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3379 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3380 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3381 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3382 int framerate = get_std_framerate(i);
3383 double sdts = dts*framerate/(1001*12);
3384 for (j= 0; j<2; j++) {
3385 int64_t ticks = llrint(sdts+j*0.5);
3386 double error= sdts - ticks + j*0.5;
3387 st->internal->info->duration_error[j][0][i] += error;
3388 st->internal->info->duration_error[j][1][i] += error*error;
3392 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3393 st->internal->info->duration_count++;
3394 st->internal->info->rfps_duration_sum += duration;
3397 if (st->internal->info->duration_count % 10 == 0) {
3398 int n = st->internal->info->duration_count;
3399 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3400 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3401 double a0 = st->internal->info->duration_error[0][0][i] / n;
3402 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3403 double a1 = st->internal->info->duration_error[1][0][i] / n;
3404 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3405 if (error0 > 0.04 && error1 > 0.04) {
3406 st->internal->info->duration_error[0][1][i] = 2e10;
3407 st->internal->info->duration_error[1][1][i] = 2e10;
3413 // ignore the first 4 values, they might have some random jitter
3414 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3415 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3417 if (ts != AV_NOPTS_VALUE)
3418 st->internal->info->last_dts = ts;
3423 void ff_rfps_calculate(AVFormatContext *ic)
3427 for (i = 0; i < ic->nb_streams; i++) {
3428 AVStream *st = ic->streams[i];
3430 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3432 // the check for tb_unreliable() is not completely correct, since this is not about handling
3433 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3434 // ipmovie.c produces.
3435 if (tb_unreliable(st->internal->avctx) && st->internal->info->duration_count > 15 && st->internal->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num &&
3436 st->internal->info->duration_gcd < INT64_MAX / st->time_base.num)
3437 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->internal->info->duration_gcd, INT_MAX);
3438 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3439 && tb_unreliable(st->internal->avctx)) {
3441 double best_error= 0.01;
3442 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3444 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3447 if (st->internal->info->codec_info_duration &&
3448 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3450 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3453 if (av_q2d(st->time_base) * st->internal->info->rfps_duration_sum / st->internal->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3456 for (k= 0; k<2; k++) {
3457 int n = st->internal->info->duration_count;
3458 double a= st->internal->info->duration_error[k][0][j] / n;
3459 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3461 if (error < best_error && best_error> 0.000000001) {
3463 num = get_std_framerate(j);
3466 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3469 // do not increase frame rate by more than 1 % in order to match a standard rate.
3470 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3471 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3473 if ( !st->avg_frame_rate.num
3474 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3475 && st->internal->info->codec_info_duration <= 0
3476 && st->internal->info->duration_count > 2
3477 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->internal->info->rfps_duration_sum / (double)st->internal->info->duration_count) <= 1.0
3479 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3480 st->avg_frame_rate = st->r_frame_rate;
3483 av_freep(&st->internal->info->duration_error);
3484 st->internal->info->last_dts = AV_NOPTS_VALUE;
3485 st->internal->info->duration_count = 0;
3486 st->internal->info->rfps_duration_sum = 0;
3490 static int extract_extradata_check(AVStream *st)
3492 const AVBitStreamFilter *f;
3494 f = av_bsf_get_by_name("extract_extradata");
3499 const enum AVCodecID *ids;
3500 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3501 if (*ids == st->codecpar->codec_id)
3508 static int extract_extradata_init(AVStream *st)
3510 AVStreamInternal *sti = st->internal;
3511 const AVBitStreamFilter *f;
3514 f = av_bsf_get_by_name("extract_extradata");
3518 /* check that the codec id is supported */
3519 ret = extract_extradata_check(st);
3523 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3527 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3532 sti->extract_extradata.bsf->time_base_in = st->time_base;
3534 ret = av_bsf_init(sti->extract_extradata.bsf);
3539 sti->extract_extradata.inited = 1;
3543 av_bsf_free(&sti->extract_extradata.bsf);
3547 static int extract_extradata(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
3549 AVStreamInternal *sti = st->internal;
3550 AVPacket *pkt_ref = s->internal->parse_pkt;
3553 if (!sti->extract_extradata.inited) {
3554 ret = extract_extradata_init(st);
3559 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3562 ret = av_packet_ref(pkt_ref, pkt);
3566 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3568 av_packet_unref(pkt_ref);
3572 while (ret >= 0 && !sti->avctx->extradata) {
3573 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3575 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3580 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3581 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3582 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3583 sti->avctx->extradata = side_data->data;
3584 sti->avctx->extradata_size = side_data->size;
3585 side_data->data = NULL;
3586 side_data->size = 0;
3590 av_packet_unref(pkt_ref);
3596 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3600 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3601 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3603 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3605 return AVERROR(ENOMEM);
3606 memcpy(dst_data, sd_src->data, sd_src->size);
3611 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3613 int i, count = 0, ret = 0, j;
3616 AVCodecContext *avctx;
3617 AVPacket *pkt1 = ic->internal->pkt;
3618 int64_t old_offset = avio_tell(ic->pb);
3619 // new streams might appear, no options for those
3620 int orig_nb_streams = ic->nb_streams;
3622 int64_t max_analyze_duration = ic->max_analyze_duration;
3623 int64_t max_stream_analyze_duration;
3624 int64_t max_subtitle_analyze_duration;
3625 int64_t probesize = ic->probesize;
3626 int eof_reached = 0;
3627 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3629 flush_codecs = probesize > 0;
3631 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3633 max_stream_analyze_duration = max_analyze_duration;
3634 max_subtitle_analyze_duration = max_analyze_duration;
3635 if (!max_analyze_duration) {
3636 max_stream_analyze_duration =
3637 max_analyze_duration = 5*AV_TIME_BASE;
3638 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3639 if (!strcmp(ic->iformat->name, "flv"))
3640 max_stream_analyze_duration = 90*AV_TIME_BASE;
3641 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3642 max_stream_analyze_duration = 7*AV_TIME_BASE;
3646 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3647 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3649 for (i = 0; i < ic->nb_streams; i++) {
3650 const AVCodec *codec;
3651 AVDictionary *thread_opt = NULL;
3652 st = ic->streams[i];
3653 avctx = st->internal->avctx;
3655 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3656 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3657 /* if (!st->time_base.num)
3659 if (!avctx->time_base.num)
3660 avctx->time_base = st->time_base;
3663 /* check if the caller has overridden the codec id */
3664 #if FF_API_LAVF_AVCTX
3665 FF_DISABLE_DEPRECATION_WARNINGS
3666 if (st->codec->codec_id != st->internal->orig_codec_id) {
3667 st->codecpar->codec_id = st->codec->codec_id;
3668 st->codecpar->codec_type = st->codec->codec_type;
3669 st->internal->orig_codec_id = st->codec->codec_id;
3671 FF_ENABLE_DEPRECATION_WARNINGS
3673 // only for the split stuff
3674 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3675 st->parser = av_parser_init(st->codecpar->codec_id);
3677 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3678 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3679 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3680 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3682 } else if (st->need_parsing) {
3683 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3684 "%s, packets or times may be invalid.\n",
3685 avcodec_get_name(st->codecpar->codec_id));
3689 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3690 st->internal->orig_codec_id = st->codecpar->codec_id;
3692 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3694 goto find_stream_info_err;
3695 if (st->internal->request_probe <= 0)
3696 st->internal->avctx_inited = 1;
3698 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3700 /* Force thread count to 1 since the H.264 decoder will not extract
3701 * SPS and PPS to extradata during multi-threaded decoding. */
3702 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3703 /* Force lowres to 0. The decoder might reduce the video size by the
3704 * lowres factor, and we don't want that propagated to the stream's
3706 av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
3708 if (ic->codec_whitelist)
3709 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3711 // Try to just open decoders, in case this is enough to get parameters.
3712 // Also ensure that subtitle_header is properly set.
3713 if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0 ||
3714 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3715 if (codec && !avctx->codec)
3716 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3717 av_log(ic, AV_LOG_WARNING,
3718 "Failed to open codec in %s\n",__FUNCTION__);
3721 av_dict_free(&thread_opt);
3724 for (i = 0; i < ic->nb_streams; i++) {
3725 #if FF_API_R_FRAME_RATE
3726 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3728 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3729 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3734 const AVPacket *pkt;
3735 int analyzed_all_streams;
3736 if (ff_check_interrupt(&ic->interrupt_callback)) {
3738 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3742 /* check if one codec still needs to be handled */
3743 for (i = 0; i < ic->nb_streams; i++) {
3744 int fps_analyze_framecount = 20;
3747 st = ic->streams[i];
3748 if (!has_codec_parameters(st, NULL))
3750 /* If the timebase is coarse (like the usual millisecond precision
3751 * of mkv), we need to analyze more frames to reliably arrive at
3752 * the correct fps. */
3753 if (av_q2d(st->time_base) > 0.0005)
3754 fps_analyze_framecount *= 2;
3755 if (!tb_unreliable(st->internal->avctx))
3756 fps_analyze_framecount = 0;
3757 if (ic->fps_probe_size >= 0)
3758 fps_analyze_framecount = ic->fps_probe_size;
3759 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3760 fps_analyze_framecount = 0;
3761 /* variable fps and no guess at the real fps */
3762 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3763 st->internal->info->codec_info_duration_fields/2 :
3764 st->internal->info->duration_count;
3765 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3766 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3767 if (count < fps_analyze_framecount)
3770 // Look at the first 3 frames if there is evidence of frame delay
3771 // but the decoder delay is not set.
3772 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3774 if (!st->internal->avctx->extradata &&
3775 (!st->internal->extract_extradata.inited ||
3776 st->internal->extract_extradata.bsf) &&
3777 extract_extradata_check(st))
3779 if (st->first_dts == AV_NOPTS_VALUE &&
3780 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3781 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3782 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3783 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3786 analyzed_all_streams = 0;
3787 if (!missing_streams || !*missing_streams)
3788 if (i == ic->nb_streams) {
3789 analyzed_all_streams = 1;
3790 /* NOTE: If the format has no header, then we need to read some
3791 * packets to get most of the streams, so we cannot stop here. */
3792 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3793 /* If we found the info for all the codecs, we can stop. */
3795 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3800 /* We did not get all the codec info, but we read too much data. */
3801 if (read_size >= probesize) {
3803 av_log(ic, AV_LOG_DEBUG,
3804 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3805 for (i = 0; i < ic->nb_streams; i++)
3806 if (!ic->streams[i]->r_frame_rate.num &&
3807 ic->streams[i]->internal->info->duration_count <= 1 &&
3808 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3809 strcmp(ic->iformat->name, "image2"))
3810 av_log(ic, AV_LOG_WARNING,
3811 "Stream #%d: not enough frames to estimate rate; "
3812 "consider increasing probesize\n", i);
3816 /* NOTE: A new stream can be added there if no header in file
3817 * (AVFMTCTX_NOHEADER). */
3818 ret = read_frame_internal(ic, pkt1);
3819 if (ret == AVERROR(EAGAIN))
3828 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3829 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3830 &ic->internal->packet_buffer_end,
3833 goto unref_then_goto_end;
3835 pkt = &ic->internal->packet_buffer_end->pkt;
3840 st = ic->streams[pkt->stream_index];
3841 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3842 read_size += pkt->size;
3844 avctx = st->internal->avctx;
3845 if (!st->internal->avctx_inited) {
3846 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3848 goto unref_then_goto_end;
3849 st->internal->avctx_inited = 1;
3852 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3853 /* check for non-increasing dts */
3854 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3855 st->internal->info->fps_last_dts >= pkt->dts) {
3856 av_log(ic, AV_LOG_DEBUG,
3857 "Non-increasing DTS in stream %d: packet %d with DTS "
3858 "%"PRId64", packet %d with DTS %"PRId64"\n",
3859 st->index, st->internal->info->fps_last_dts_idx,
3860 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3862 st->internal->info->fps_first_dts =
3863 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3865 /* Check for a discontinuity in dts. If the difference in dts
3866 * is more than 1000 times the average packet duration in the
3867 * sequence, we treat it as a discontinuity. */
3868 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3869 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3870 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3871 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3872 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3873 av_log(ic, AV_LOG_WARNING,
3874 "DTS discontinuity in stream %d: packet %d with DTS "
3875 "%"PRId64", packet %d with DTS %"PRId64"\n",
3876 st->index, st->internal->info->fps_last_dts_idx,
3877 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3879 st->internal->info->fps_first_dts =
3880 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3883 /* update stored dts values */
3884 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3885 st->internal->info->fps_first_dts = pkt->dts;
3886 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3888 st->internal->info->fps_last_dts = pkt->dts;
3889 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3891 if (st->codec_info_nb_frames>1) {
3895 if (st->time_base.den > 0)
3896 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3897 if (st->avg_frame_rate.num > 0)
3898 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3901 && st->codec_info_nb_frames>30
3902 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3903 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE) {
3904 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3905 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3908 if (analyzed_all_streams) limit = max_analyze_duration;
3909 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3910 else limit = max_stream_analyze_duration;
3913 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3915 t, pkt->stream_index);
3916 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3917 av_packet_unref(pkt1);
3920 if (pkt->duration) {
3921 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3922 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3924 st->internal->info->codec_info_duration += pkt->duration;
3925 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3928 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3929 #if FF_API_R_FRAME_RATE
3930 ff_rfps_add_frame(ic, st, pkt->dts);
3932 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3933 st->internal->info->frame_delay_evidence = 1;
3935 if (!st->internal->avctx->extradata) {
3936 ret = extract_extradata(ic, st, pkt);
3938 goto unref_then_goto_end;
3941 /* If still no information, we try to open the codec and to
3942 * decompress the frame. We try to avoid that in most cases as
3943 * it takes longer and uses more memory. For MPEG-4, we need to
3944 * decompress for QuickTime.
3946 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3947 * least one frame of codec data, this makes sure the codec initializes
3948 * the channel configuration and does not only trust the values from
3950 try_decode_frame(ic, st, pkt,
3951 (options && i < orig_nb_streams) ? &options[i] : NULL);
3953 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3954 av_packet_unref(pkt1);
3956 st->codec_info_nb_frames++;
3962 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3963 st = ic->streams[stream_index];
3964 avctx = st->internal->avctx;
3965 if (!has_codec_parameters(st, NULL)) {
3966 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3967 if (codec && !avctx->codec) {
3968 AVDictionary *opts = NULL;
3969 if (ic->codec_whitelist)
3970 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3971 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3972 av_log(ic, AV_LOG_WARNING,
3973 "Failed to open codec in %s\n",__FUNCTION__);
3974 av_dict_free(&opts);
3978 // EOF already reached while reading the stream above.
3979 // So continue with reoordering DTS with whatever delay we have.
3980 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3981 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3987 AVPacket *empty_pkt = ic->internal->pkt;
3989 av_packet_unref(empty_pkt);
3991 for (i = 0; i < ic->nb_streams; i++) {
3993 st = ic->streams[i];
3995 /* flush the decoders */
3996 if (st->internal->info->found_decoder == 1) {
3998 err = try_decode_frame(ic, st, empty_pkt,
3999 (options && i < orig_nb_streams)
4000 ? &options[i] : NULL);
4001 } while (err > 0 && !has_codec_parameters(st, NULL));
4004 av_log(ic, AV_LOG_INFO,
4005 "decoding for stream %d failed\n", st->index);
4011 ff_rfps_calculate(ic);
4013 for (i = 0; i < ic->nb_streams; i++) {
4014 st = ic->streams[i];
4015 avctx = st->internal->avctx;
4016 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4017 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4018 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4019 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4020 avctx->codec_tag= tag;
4023 /* estimate average framerate if not set by demuxer */
4024 if (st->internal->info->codec_info_duration_fields &&
4025 !st->avg_frame_rate.num &&
4026 st->internal->info->codec_info_duration) {
4028 double best_error = 0.01;
4029 AVRational codec_frame_rate = avctx->framerate;
4031 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4032 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4033 st->internal->info->codec_info_duration < 0)
4035 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4036 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4037 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4039 /* Round guessed framerate to a "standard" framerate if it's
4040 * within 1% of the original estimate. */
4041 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4042 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4043 double error = fabs(av_q2d(st->avg_frame_rate) /
4044 av_q2d(std_fps) - 1);
4046 if (error < best_error) {
4048 best_fps = std_fps.num;
4051 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4052 error = fabs(av_q2d(codec_frame_rate) /
4053 av_q2d(std_fps) - 1);
4054 if (error < best_error) {
4056 best_fps = std_fps.num;
4061 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4062 best_fps, 12 * 1001, INT_MAX);
4065 if (!st->r_frame_rate.num) {
4066 if ( avctx->time_base.den * (int64_t) st->time_base.num
4067 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4068 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4069 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4071 st->r_frame_rate.num = st->time_base.den;
4072 st->r_frame_rate.den = st->time_base.num;
4075 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4076 AVRational hw_ratio = { avctx->height, avctx->width };
4077 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4080 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4081 if (!avctx->bits_per_coded_sample)
4082 avctx->bits_per_coded_sample =
4083 av_get_bits_per_sample(avctx->codec_id);
4084 // set stream disposition based on audio service type
4085 switch (avctx->audio_service_type) {
4086 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4087 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4089 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4090 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4092 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4093 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4095 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4096 st->disposition = AV_DISPOSITION_COMMENT;
4098 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4099 st->disposition = AV_DISPOSITION_KARAOKE;
4106 estimate_timings(ic, old_offset);
4108 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4110 if (ret >= 0 && ic->nb_streams)
4111 /* We could not have all the codec parameters before EOF. */
4113 for (i = 0; i < ic->nb_streams; i++) {
4115 st = ic->streams[i];
4117 /* if no packet was ever seen, update context now for has_codec_parameters */
4118 if (!st->internal->avctx_inited) {
4119 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4120 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4121 st->codecpar->format = st->internal->avctx->sample_fmt;
4122 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4124 goto find_stream_info_err;
4126 if (!has_codec_parameters(st, &errmsg)) {
4128 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4129 av_log(ic, AV_LOG_WARNING,
4130 "Could not find codec parameters for stream %d (%s): %s\n"
4131 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4132 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4138 ret = compute_chapters_end(ic);
4140 goto find_stream_info_err;
4142 /* update the stream parameters from the internal codec contexts */
4143 for (i = 0; i < ic->nb_streams; i++) {
4144 st = ic->streams[i];
4146 if (st->internal->avctx_inited) {
4147 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4149 goto find_stream_info_err;
4150 ret = add_coded_side_data(st, st->internal->avctx);
4152 goto find_stream_info_err;
4155 #if FF_API_LAVF_AVCTX
4156 FF_DISABLE_DEPRECATION_WARNINGS
4157 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4159 goto find_stream_info_err;
4161 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4162 // by the lowres factor.
4163 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4164 st->codec->lowres = st->internal->avctx->lowres;
4165 st->codec->width = st->internal->avctx->width;
4166 st->codec->height = st->internal->avctx->height;
4169 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4170 st->codec->time_base = st->internal->avctx->time_base;
4171 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4173 st->codec->framerate = st->avg_frame_rate;
4175 if (st->internal->avctx->subtitle_header) {
4176 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4177 if (!st->codec->subtitle_header)
4178 goto find_stream_info_err;
4179 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4180 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4181 st->codec->subtitle_header_size);
4184 // Fields unavailable in AVCodecParameters
4185 st->codec->coded_width = st->internal->avctx->coded_width;
4186 st->codec->coded_height = st->internal->avctx->coded_height;
4187 st->codec->properties = st->internal->avctx->properties;
4188 FF_ENABLE_DEPRECATION_WARNINGS
4191 st->internal->avctx_inited = 0;
4194 find_stream_info_err:
4195 for (i = 0; i < ic->nb_streams; i++) {
4196 st = ic->streams[i];
4197 if (st->internal->info)
4198 av_freep(&st->internal->info->duration_error);
4199 avcodec_close(ic->streams[i]->internal->avctx);
4200 av_freep(&ic->streams[i]->internal->info);
4201 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4204 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4205 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4208 unref_then_goto_end:
4209 av_packet_unref(pkt1);
4210 goto find_stream_info_err;
4213 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4217 for (i = 0; i < ic->nb_programs; i++) {
4218 if (ic->programs[i] == last) {
4222 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4223 if (ic->programs[i]->stream_index[j] == s)
4224 return ic->programs[i];
4230 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4231 int wanted_stream_nb, int related_stream,
4232 AVCodec **decoder_ret, int flags)
4234 int i, nb_streams = ic->nb_streams;
4235 int ret = AVERROR_STREAM_NOT_FOUND;
4236 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4237 int count, multiframe, disposition;
4238 int64_t best_bitrate = -1;
4240 unsigned *program = NULL;
4241 const AVCodec *decoder = NULL, *best_decoder = NULL;
4243 if (related_stream >= 0 && wanted_stream_nb < 0) {
4244 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4246 program = p->stream_index;
4247 nb_streams = p->nb_stream_indexes;
4250 for (i = 0; i < nb_streams; i++) {
4251 int real_stream_index = program ? program[i] : i;
4252 AVStream *st = ic->streams[real_stream_index];
4253 AVCodecParameters *par = st->codecpar;
4254 if (par->codec_type != type)
4256 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4258 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4261 decoder = find_decoder(ic, st, par->codec_id);
4264 ret = AVERROR_DECODER_NOT_FOUND;
4268 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4269 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4270 count = st->codec_info_nb_frames;
4271 bitrate = par->bit_rate;
4272 multiframe = FFMIN(5, count);
4273 if ((best_disposition > disposition) ||
4274 (best_disposition == disposition && best_multiframe > multiframe) ||
4275 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4276 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4278 best_disposition = disposition;
4280 best_bitrate = bitrate;
4281 best_multiframe = multiframe;
4282 ret = real_stream_index;
4283 best_decoder = decoder;
4284 if (program && i == nb_streams - 1 && ret < 0) {
4286 nb_streams = ic->nb_streams;
4287 /* no related stream found, try again with everything */
4292 *decoder_ret = (AVCodec*)best_decoder;
4296 /*******************************************************/
4298 int av_read_play(AVFormatContext *s)
4300 if (s->iformat->read_play)
4301 return s->iformat->read_play(s);
4303 return avio_pause(s->pb, 0);
4304 return AVERROR(ENOSYS);
4307 int av_read_pause(AVFormatContext *s)
4309 if (s->iformat->read_pause)
4310 return s->iformat->read_pause(s);
4312 return avio_pause(s->pb, 1);
4313 return AVERROR(ENOSYS);
4316 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4321 dst->time_base = src->time_base;
4322 dst->nb_frames = src->nb_frames;
4323 dst->disposition = src->disposition;
4324 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4325 dst->avg_frame_rate = src->avg_frame_rate;
4326 dst->r_frame_rate = src->r_frame_rate;
4328 av_dict_free(&dst->metadata);
4329 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4333 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4337 /* Free existing side data*/
4338 for (i = 0; i < dst->nb_side_data; i++)
4339 av_free(dst->side_data[i].data);
4340 av_freep(&dst->side_data);
4341 dst->nb_side_data = 0;
4343 /* Copy side data if present */
4344 if (src->nb_side_data) {
4345 dst->side_data = av_mallocz_array(src->nb_side_data,
4346 sizeof(AVPacketSideData));
4347 if (!dst->side_data)
4348 return AVERROR(ENOMEM);
4349 dst->nb_side_data = src->nb_side_data;
4351 for (i = 0; i < src->nb_side_data; i++) {
4352 uint8_t *data = av_memdup(src->side_data[i].data,
4353 src->side_data[i].size);
4355 return AVERROR(ENOMEM);
4356 dst->side_data[i].type = src->side_data[i].type;
4357 dst->side_data[i].size = src->side_data[i].size;
4358 dst->side_data[i].data = data;
4365 static void free_stream(AVStream **pst)
4367 AVStream *st = *pst;
4373 for (i = 0; i < st->nb_side_data; i++)
4374 av_freep(&st->side_data[i].data);
4375 av_freep(&st->side_data);
4378 av_parser_close(st->parser);
4380 if (st->attached_pic.data)
4381 av_packet_unref(&st->attached_pic);
4384 avcodec_free_context(&st->internal->avctx);
4385 av_bsf_free(&st->internal->bsfc);
4386 av_freep(&st->internal->priv_pts);
4387 av_freep(&st->internal->index_entries);
4388 av_freep(&st->internal->probe_data.buf);
4390 av_bsf_free(&st->internal->extract_extradata.bsf);
4392 if (st->internal->info)
4393 av_freep(&st->internal->info->duration_error);
4394 av_freep(&st->internal->info);
4396 av_freep(&st->internal);
4398 av_dict_free(&st->metadata);
4399 avcodec_parameters_free(&st->codecpar);
4400 #if FF_API_LAVF_AVCTX
4401 FF_DISABLE_DEPRECATION_WARNINGS
4402 avcodec_free_context(&st->codec);
4403 FF_ENABLE_DEPRECATION_WARNINGS
4405 av_freep(&st->priv_data);
4410 void ff_free_stream(AVFormatContext *s, AVStream *st)
4412 av_assert0(s->nb_streams>0);
4413 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4415 free_stream(&s->streams[ --s->nb_streams ]);
4418 void avformat_free_context(AVFormatContext *s)
4425 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4426 s->oformat->deinit(s);
4429 if (s->iformat && s->iformat->priv_class && s->priv_data)
4430 av_opt_free(s->priv_data);
4431 if (s->oformat && s->oformat->priv_class && s->priv_data)
4432 av_opt_free(s->priv_data);
4434 for (i = 0; i < s->nb_streams; i++)
4435 free_stream(&s->streams[i]);
4438 for (i = 0; i < s->nb_programs; i++) {
4439 av_dict_free(&s->programs[i]->metadata);
4440 av_freep(&s->programs[i]->stream_index);
4441 av_freep(&s->programs[i]);
4445 av_freep(&s->programs);
4446 av_freep(&s->priv_data);
4447 while (s->nb_chapters--) {
4448 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4449 av_freep(&s->chapters[s->nb_chapters]);
4451 av_freep(&s->chapters);
4452 av_dict_free(&s->metadata);
4453 av_dict_free(&s->internal->id3v2_meta);
4454 av_packet_free(&s->internal->pkt);
4455 av_packet_free(&s->internal->parse_pkt);
4456 av_freep(&s->streams);
4457 flush_packet_queue(s);
4458 av_freep(&s->internal);
4463 void avformat_close_input(AVFormatContext **ps)
4474 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4475 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4478 flush_packet_queue(s);
4481 if (s->iformat->read_close)
4482 s->iformat->read_close(s);
4484 avformat_free_context(s);
4491 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4497 if (s->nb_streams >= s->max_streams) {
4498 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
4499 " (%d), see the documentation if you wish to increase it\n",
4503 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4506 s->streams = streams;
4508 st = av_mallocz(sizeof(AVStream));
4512 #if FF_API_LAVF_AVCTX
4513 FF_DISABLE_DEPRECATION_WARNINGS
4514 st->codec = avcodec_alloc_context3(c);
4519 FF_ENABLE_DEPRECATION_WARNINGS
4522 st->internal = av_mallocz(sizeof(*st->internal));
4526 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4527 if (!st->internal->info)
4529 st->internal->info->last_dts = AV_NOPTS_VALUE;
4531 st->codecpar = avcodec_parameters_alloc();
4535 st->internal->avctx = avcodec_alloc_context3(NULL);
4536 if (!st->internal->avctx)
4540 #if FF_API_LAVF_AVCTX
4541 FF_DISABLE_DEPRECATION_WARNINGS
4542 /* no default bitrate if decoding */
4543 st->codec->bit_rate = 0;
4544 FF_ENABLE_DEPRECATION_WARNINGS
4547 /* default pts setting is MPEG-like */
4548 avpriv_set_pts_info(st, 33, 1, 90000);
4549 /* we set the current DTS to 0 so that formats without any timestamps
4550 * but durations get some timestamps, formats with some unknown
4551 * timestamps have their first few packets buffered and the
4552 * timestamps corrected before they are returned to the user */
4553 st->cur_dts = RELATIVE_TS_BASE;
4555 st->cur_dts = AV_NOPTS_VALUE;
4558 st->index = s->nb_streams;
4559 st->start_time = AV_NOPTS_VALUE;
4560 st->duration = AV_NOPTS_VALUE;
4561 st->first_dts = AV_NOPTS_VALUE;
4562 st->probe_packets = s->max_probe_packets;
4563 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4564 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4566 st->last_IP_pts = AV_NOPTS_VALUE;
4567 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4568 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4569 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4571 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4573 #if FF_API_R_FRAME_RATE
4574 st->internal->info->last_dts = AV_NOPTS_VALUE;
4576 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4577 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4579 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4581 st->internal->need_context_update = 1;
4583 s->streams[s->nb_streams++] = st;
4590 AVProgram *av_new_program(AVFormatContext *ac, int id)
4592 AVProgram *program = NULL;
4595 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4597 for (i = 0; i < ac->nb_programs; i++)
4598 if (ac->programs[i]->id == id)
4599 program = ac->programs[i];
4602 program = av_mallocz(sizeof(AVProgram));
4605 ret = av_dynarray_add_nofree(&ac->programs, &ac->nb_programs, program);
4610 program->discard = AVDISCARD_NONE;
4611 program->pmt_version = -1;
4613 program->pts_wrap_reference = AV_NOPTS_VALUE;
4614 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4615 program->start_time =
4616 program->end_time = AV_NOPTS_VALUE;
4621 #if FF_API_CHAPTER_ID_INT
4622 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4624 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
4626 int64_t start, int64_t end, const char *title)
4628 AVChapter *chapter = NULL;
4631 if (end != AV_NOPTS_VALUE && start > end) {
4632 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4636 if (!s->nb_chapters) {
4637 s->internal->chapter_ids_monotonic = 1;
4638 } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4639 s->internal->chapter_ids_monotonic = 0;
4640 for (i = 0; i < s->nb_chapters; i++)
4641 if (s->chapters[i]->id == id)
4642 chapter = s->chapters[i];
4646 chapter = av_mallocz(sizeof(AVChapter));
4649 ret = av_dynarray_add_nofree(&s->chapters, &s->nb_chapters, chapter);
4655 av_dict_set(&chapter->metadata, "title", title, 0);
4657 chapter->time_base = time_base;
4658 chapter->start = start;
4664 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4667 AVProgram *program = NULL;
4670 if (idx >= ac->nb_streams) {
4671 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4675 for (i = 0; i < ac->nb_programs; i++) {
4676 if (ac->programs[i]->id != progid)
4678 program = ac->programs[i];
4679 for (j = 0; j < program->nb_stream_indexes; j++)
4680 if (program->stream_index[j] == idx)
4683 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4686 program->stream_index = tmp;
4687 program->stream_index[program->nb_stream_indexes++] = idx;
4692 uint64_t ff_ntp_time(void)
4694 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4697 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4699 uint64_t ntp_ts, frac_part, sec;
4702 //current ntp time in seconds and micro seconds
4703 sec = ntp_time_us / 1000000;
4704 usec = ntp_time_us % 1000000;
4706 //encoding in ntp timestamp format
4707 frac_part = usec * 0xFFFFFFFFULL;
4708 frac_part /= 1000000;
4710 if (sec > 0xFFFFFFFFULL)
4711 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4714 ntp_ts |= frac_part;
4719 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
4721 uint64_t sec = ntp_ts >> 32;
4722 uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
4723 uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
4725 return (sec * 1000000) + usec;
4728 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4731 char *q, buf1[20], c;
4732 int nd, len, percentd_found;
4744 while (av_isdigit(*p)) {
4745 if (nd >= INT_MAX / 10 - 255)
4747 nd = nd * 10 + *p++ - '0';
4750 } while (av_isdigit(c));
4756 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4761 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4763 if ((q - buf + len) > buf_size - 1)
4765 memcpy(q, buf1, len);
4773 if ((q - buf) < buf_size - 1)
4777 if (!percentd_found)
4786 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4788 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4791 void av_url_split(char *proto, int proto_size,
4792 char *authorization, int authorization_size,
4793 char *hostname, int hostname_size,
4794 int *port_ptr, char *path, int path_size, const char *url)
4796 const char *p, *ls, *at, *at2, *col, *brk;
4802 if (authorization_size > 0)
4803 authorization[0] = 0;
4804 if (hostname_size > 0)
4809 /* parse protocol */
4810 if ((p = strchr(url, ':'))) {
4811 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4818 /* no protocol means plain filename */
4819 av_strlcpy(path, url, path_size);
4823 /* separate path from hostname */
4824 ls = p + strcspn(p, "/?#");
4825 av_strlcpy(path, ls, path_size);
4827 /* the rest is hostname, use that to parse auth/port */
4829 /* authorization (user[:pass]@hostname) */
4831 while ((at = strchr(p, '@')) && at < ls) {
4832 av_strlcpy(authorization, at2,
4833 FFMIN(authorization_size, at + 1 - at2));
4834 p = at + 1; /* skip '@' */
4837 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4839 av_strlcpy(hostname, p + 1,
4840 FFMIN(hostname_size, brk - p));
4841 if (brk[1] == ':' && port_ptr)
4842 *port_ptr = atoi(brk + 2);
4843 } else if ((col = strchr(p, ':')) && col < ls) {
4844 av_strlcpy(hostname, p,
4845 FFMIN(col + 1 - p, hostname_size));
4847 *port_ptr = atoi(col + 1);
4849 av_strlcpy(hostname, p,
4850 FFMIN(ls + 1 - p, hostname_size));
4854 int ff_mkdir_p(const char *path)
4857 char *temp = av_strdup(path);
4861 if (!path || !temp) {
4865 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4867 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4871 for ( ; *pos != '\0'; ++pos) {
4872 if (*pos == '/' || *pos == '\\') {
4875 ret = mkdir(temp, 0755);
4880 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4881 ret = mkdir(temp, 0755);
4888 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4891 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4894 'C', 'D', 'E', 'F' };
4895 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4898 'c', 'd', 'e', 'f' };
4899 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4901 for (i = 0; i < s; i++) {
4902 buff[i * 2] = hex_table[src[i] >> 4];
4903 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4909 int ff_hex_to_data(uint8_t *data, const char *p)
4916 p += strspn(p, SPACE_CHARS);
4919 c = av_toupper((unsigned char) *p++);
4920 if (c >= '0' && c <= '9')
4922 else if (c >= 'A' && c <= 'F')
4937 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4938 unsigned int pts_num, unsigned int pts_den)
4941 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4942 if (new_tb.num != pts_num)
4943 av_log(NULL, AV_LOG_DEBUG,
4944 "st:%d removing common factor %d from timebase\n",
4945 s->index, pts_num / new_tb.num);
4947 av_log(NULL, AV_LOG_WARNING,
4948 "st:%d has too large timebase, reducing\n", s->index);
4950 if (new_tb.num <= 0 || new_tb.den <= 0) {
4951 av_log(NULL, AV_LOG_ERROR,
4952 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4953 new_tb.num, new_tb.den,
4957 s->time_base = new_tb;
4958 #if FF_API_LAVF_AVCTX
4959 FF_DISABLE_DEPRECATION_WARNINGS
4960 s->codec->pkt_timebase = new_tb;
4961 FF_ENABLE_DEPRECATION_WARNINGS
4963 s->internal->avctx->pkt_timebase = new_tb;
4964 s->pts_wrap_bits = pts_wrap_bits;
4967 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4970 const char *ptr = str;
4972 /* Parse key=value pairs. */
4975 char *dest = NULL, *dest_end;
4976 int key_len, dest_len = 0;
4978 /* Skip whitespace and potential commas. */
4979 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4986 if (!(ptr = strchr(key, '=')))
4989 key_len = ptr - key;
4991 callback_get_buf(context, key, key_len, &dest, &dest_len);
4992 dest_end = dest + dest_len - 1;
4996 while (*ptr && *ptr != '\"') {
5000 if (dest && dest < dest_end)
5004 if (dest && dest < dest_end)
5012 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5013 if (dest && dest < dest_end)
5021 int ff_find_stream_index(AVFormatContext *s, int id)
5024 for (i = 0; i < s->nb_streams; i++)
5025 if (s->streams[i]->id == id)
5030 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5034 unsigned int codec_tag;
5035 if (ofmt->query_codec)
5036 return ofmt->query_codec(codec_id, std_compliance);
5037 else if (ofmt->codec_tag)
5038 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5039 else if (codec_id == ofmt->video_codec ||
5040 codec_id == ofmt->audio_codec ||
5041 codec_id == ofmt->subtitle_codec ||
5042 codec_id == ofmt->data_codec)
5045 return AVERROR_PATCHWELCOME;
5048 int avformat_network_init(void)
5052 if ((ret = ff_network_init()) < 0)
5054 if ((ret = ff_tls_init()) < 0)
5060 int avformat_network_deinit(void)
5069 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5070 uint64_t channel_layout, int32_t sample_rate,
5071 int32_t width, int32_t height)
5077 return AVERROR(EINVAL);
5080 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5082 if (channel_layout) {
5084 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5088 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5090 if (width || height) {
5092 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5094 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5096 return AVERROR(ENOMEM);
5097 bytestream_put_le32(&data, flags);
5099 bytestream_put_le32(&data, channels);
5101 bytestream_put_le64(&data, channel_layout);
5103 bytestream_put_le32(&data, sample_rate);
5104 if (width || height) {
5105 bytestream_put_le32(&data, width);
5106 bytestream_put_le32(&data, height);
5111 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5113 AVRational undef = {0, 1};
5114 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5115 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5116 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5118 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5119 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5120 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5121 stream_sample_aspect_ratio = undef;
5123 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5124 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5125 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5126 frame_sample_aspect_ratio = undef;
5128 if (stream_sample_aspect_ratio.num)
5129 return stream_sample_aspect_ratio;
5131 return frame_sample_aspect_ratio;
5134 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5136 AVRational fr = st->r_frame_rate;
5137 AVRational codec_fr = st->internal->avctx->framerate;
5138 AVRational avg_fr = st->avg_frame_rate;
5140 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5141 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5146 if (st->internal->avctx->ticks_per_frame > 1) {
5147 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5148 (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))
5156 * Matches a stream specifier (but ignores requested index).
5158 * @param indexptr set to point to the requested stream index if there is one
5160 * @return <0 on error
5161 * 0 if st is NOT a matching stream
5162 * >0 if st is a matching stream
5164 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5165 const char *spec, const char **indexptr, AVProgram **p)
5167 int match = 1; /* Stores if the specifier matches so far. */
5169 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5173 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5174 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5175 enum AVMediaType type;
5179 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5180 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5181 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5182 case 'd': type = AVMEDIA_TYPE_DATA; break;
5183 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5184 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5185 default: av_assert0(0);
5187 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5188 return AVERROR(EINVAL);
5190 #if FF_API_LAVF_AVCTX
5191 FF_DISABLE_DEPRECATION_WARNINGS
5192 if (type != st->codecpar->codec_type
5193 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5195 FF_ENABLE_DEPRECATION_WARNINGS
5197 if (type != st->codecpar->codec_type)
5200 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5202 } else if (*spec == 'p' && *(spec + 1) == ':') {
5207 prog_id = strtol(spec, &endptr, 0);
5208 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5209 if (spec == endptr || (*endptr && *endptr++ != ':'))
5210 return AVERROR(EINVAL);
5213 for (i = 0; i < s->nb_programs; i++) {
5214 if (s->programs[i]->id != prog_id)
5217 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5218 if (st->index == s->programs[i]->stream_index[j]) {
5221 *p = s->programs[i];
5230 } else if (*spec == '#' ||
5231 (*spec == 'i' && *(spec + 1) == ':')) {
5234 spec += 1 + (*spec == 'i');
5235 stream_id = strtol(spec, &endptr, 0);
5236 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5237 return AVERROR(EINVAL);
5238 return match && (stream_id == st->id);
5239 } else if (*spec == 'm' && *(spec + 1) == ':') {
5240 AVDictionaryEntry *tag;
5246 val = strchr(spec, ':');
5248 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5250 return AVERROR(ENOMEM);
5252 tag = av_dict_get(st->metadata, key, NULL, 0);
5254 if (!val || !strcmp(tag->value, val + 1))
5263 return match && ret;
5264 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5265 AVCodecParameters *par = st->codecpar;
5266 #if FF_API_LAVF_AVCTX
5267 FF_DISABLE_DEPRECATION_WARNINGS
5268 AVCodecContext *codec = st->codec;
5269 FF_ENABLE_DEPRECATION_WARNINGS
5272 switch (par->codec_type) {
5273 case AVMEDIA_TYPE_AUDIO:
5274 val = par->sample_rate && par->channels;
5275 #if FF_API_LAVF_AVCTX
5276 val = val || (codec->sample_rate && codec->channels);
5278 if (par->format == AV_SAMPLE_FMT_NONE
5279 #if FF_API_LAVF_AVCTX
5280 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5285 case AVMEDIA_TYPE_VIDEO:
5286 val = par->width && par->height;
5287 #if FF_API_LAVF_AVCTX
5288 val = val || (codec->width && codec->height);
5290 if (par->format == AV_PIX_FMT_NONE
5291 #if FF_API_LAVF_AVCTX
5292 && codec->pix_fmt == AV_PIX_FMT_NONE
5297 case AVMEDIA_TYPE_UNKNOWN:
5304 #if FF_API_LAVF_AVCTX
5305 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5307 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5310 return AVERROR(EINVAL);
5318 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5323 const char *indexptr = NULL;
5324 AVProgram *p = NULL;
5327 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5334 index = strtol(indexptr, &endptr, 0);
5335 if (*endptr) { /* We can't have anything after the requested index. */
5336 ret = AVERROR(EINVAL);
5340 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5341 if (spec == indexptr)
5342 return (index == st->index);
5344 /* If we requested a matching stream index, we have to ensure st is that. */
5345 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5346 for (int i = 0; i < nb_streams && index >= 0; i++) {
5347 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5348 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5351 if (ret > 0 && index-- == 0 && st == candidate)
5357 if (ret == AVERROR(EINVAL))
5358 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5362 int ff_generate_avci_extradata(AVStream *st)
5364 static const uint8_t avci100_1080p_extradata[] = {
5366 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5367 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5368 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5369 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5370 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5371 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5372 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5373 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5374 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5376 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5379 static const uint8_t avci100_1080i_extradata[] = {
5381 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5382 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5383 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5384 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5385 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5386 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5387 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5388 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5389 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5390 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5391 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5393 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5396 static const uint8_t avci50_1080p_extradata[] = {
5398 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5399 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5400 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5401 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5402 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5403 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5404 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5405 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5406 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5408 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5411 static const uint8_t avci50_1080i_extradata[] = {
5413 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5414 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5415 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5416 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5417 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5418 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5419 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5420 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5421 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5422 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5423 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5425 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5428 static const uint8_t avci100_720p_extradata[] = {
5430 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5431 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5432 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5433 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5434 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5435 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5436 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5437 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5438 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5439 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5441 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5444 static const uint8_t avci50_720p_extradata[] = {
5446 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5447 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5448 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5449 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5450 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5451 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5452 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5453 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5454 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5456 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5460 const uint8_t *data = NULL;
5463 if (st->codecpar->width == 1920) {
5464 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5465 data = avci100_1080p_extradata;
5466 size = sizeof(avci100_1080p_extradata);
5468 data = avci100_1080i_extradata;
5469 size = sizeof(avci100_1080i_extradata);
5471 } else if (st->codecpar->width == 1440) {
5472 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5473 data = avci50_1080p_extradata;
5474 size = sizeof(avci50_1080p_extradata);
5476 data = avci50_1080i_extradata;
5477 size = sizeof(avci50_1080i_extradata);
5479 } else if (st->codecpar->width == 1280) {
5480 data = avci100_720p_extradata;
5481 size = sizeof(avci100_720p_extradata);
5482 } else if (st->codecpar->width == 960) {
5483 data = avci50_720p_extradata;
5484 size = sizeof(avci50_720p_extradata);
5490 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5492 memcpy(st->codecpar->extradata, data, size);
5497 uint8_t *av_stream_get_side_data(const AVStream *st,
5498 enum AVPacketSideDataType type, buffer_size_t *size)
5502 for (i = 0; i < st->nb_side_data; i++) {
5503 if (st->side_data[i].type == type) {
5505 *size = st->side_data[i].size;
5506 return st->side_data[i].data;
5514 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5515 uint8_t *data, size_t size)
5517 AVPacketSideData *sd, *tmp;
5520 for (i = 0; i < st->nb_side_data; i++) {
5521 sd = &st->side_data[i];
5523 if (sd->type == type) {
5524 av_freep(&sd->data);
5531 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5532 return AVERROR(ERANGE);
5534 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5536 return AVERROR(ENOMEM);
5539 st->side_data = tmp;
5542 sd = &st->side_data[st->nb_side_data - 1];
5550 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5554 uint8_t *data = av_malloc(size);
5559 ret = av_stream_add_side_data(st, type, data, size);
5568 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5571 const AVBitStreamFilter *bsf;
5574 av_assert0(!st->internal->bsfc);
5576 if (!(bsf = av_bsf_get_by_name(name))) {
5577 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5578 return AVERROR_BSF_NOT_FOUND;
5581 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5584 bsfc->time_base_in = st->time_base;
5585 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5590 if (args && bsfc->filter->priv_class) {
5591 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5592 const char * shorthand[2] = {NULL};
5595 shorthand[0] = opt->name;
5597 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5603 if ((ret = av_bsf_init(bsfc)) < 0) {
5608 st->internal->bsfc = bsfc;
5610 av_log(NULL, AV_LOG_VERBOSE,
5611 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5612 name, args ? args : "");
5616 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5619 return AVERROR(EINVAL);
5621 if (!(s->oformat->flags & AVFMT_NOFILE))
5622 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5626 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5629 s->io_close(s, *pb);
5633 int ff_is_http_proto(char *filename) {
5634 const char *proto = avio_find_protocol_name(filename);
5635 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5638 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5640 AVDictionaryEntry *entry;
5641 int64_t parsed_timestamp;
5643 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5644 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5645 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5648 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5655 int ff_standardize_creation_time(AVFormatContext *s)
5658 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5660 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5664 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5669 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5671 if (size != AVPALETTE_SIZE) {
5672 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5673 return AVERROR_INVALIDDATA;
5675 memcpy(palette, side_data, AVPALETTE_SIZE);
5679 if (ret == CONTAINS_PAL) {
5681 for (i = 0; i < AVPALETTE_COUNT; i++)
5682 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5689 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5694 ret = av_bprint_finalize(buf, &str);
5697 if (!av_bprint_is_complete(buf)) {
5699 return AVERROR(ENOMEM);
5702 par->extradata = str;
5703 /* Note: the string is NUL terminated (so extradata can be read as a
5704 * string), but the ending character is not accounted in the size (in
5705 * binary formats you are likely not supposed to mux that character). When
5706 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5708 par->extradata_size = buf->len;
5712 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5713 AVStream *ost, const AVStream *ist,
5714 enum AVTimebaseSource copy_tb)
5716 //TODO: use [io]st->internal->avctx
5717 const AVCodecContext *dec_ctx;
5718 AVCodecContext *enc_ctx;
5720 #if FF_API_LAVF_AVCTX
5721 FF_DISABLE_DEPRECATION_WARNINGS
5722 dec_ctx = ist->codec;
5723 enc_ctx = ost->codec;
5724 FF_ENABLE_DEPRECATION_WARNINGS
5726 dec_ctx = ist->internal->avctx;
5727 enc_ctx = ost->internal->avctx;
5730 enc_ctx->time_base = ist->time_base;
5732 * Avi is a special case here because it supports variable fps but
5733 * having the fps and timebase differe significantly adds quite some
5736 if (!strcmp(ofmt->name, "avi")) {
5737 #if FF_API_R_FRAME_RATE
5738 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5739 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5740 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5741 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5742 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5743 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5744 enc_ctx->time_base.num = ist->r_frame_rate.den;
5745 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5746 enc_ctx->ticks_per_frame = 2;
5749 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5750 && av_q2d(ist->time_base) < 1.0/500
5751 || copy_tb == AVFMT_TBCF_DECODER) {
5752 enc_ctx->time_base = dec_ctx->time_base;
5753 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5754 enc_ctx->time_base.den *= 2;
5755 enc_ctx->ticks_per_frame = 2;
5757 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5758 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5759 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5760 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5761 && av_q2d(ist->time_base) < 1.0/500
5762 || copy_tb == AVFMT_TBCF_DECODER) {
5763 enc_ctx->time_base = dec_ctx->time_base;
5764 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5768 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5769 && dec_ctx->time_base.num < dec_ctx->time_base.den
5770 && dec_ctx->time_base.num > 0
5771 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5772 enc_ctx->time_base = dec_ctx->time_base;
5775 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5776 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5781 AVRational av_stream_get_codec_timebase(const AVStream *st)
5783 // See avformat_transfer_internal_stream_timing_info() TODO.
5784 #if FF_API_LAVF_AVCTX
5785 FF_DISABLE_DEPRECATION_WARNINGS
5786 return st->codec->time_base;
5787 FF_ENABLE_DEPRECATION_WARNINGS
5789 return st->internal->avctx->time_base;
5793 void ff_format_set_url(AVFormatContext *s, char *url)