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 FF_API_FORMAT_FILENAME
551 FF_DISABLE_DEPRECATION_WARNINGS
552 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
553 FF_ENABLE_DEPRECATION_WARNINGS
555 if ((ret = init_input(s, filename, &tmp)) < 0)
557 s->probe_score = ret;
559 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
560 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
561 if (!s->protocol_whitelist) {
562 ret = AVERROR(ENOMEM);
567 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
568 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
569 if (!s->protocol_blacklist) {
570 ret = AVERROR(ENOMEM);
575 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
576 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
577 ret = AVERROR(EINVAL);
581 avio_skip(s->pb, s->skip_initial_bytes);
583 /* Check filename in case an image number is expected. */
584 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
585 if (!av_filename_number_test(filename)) {
586 ret = AVERROR(EINVAL);
591 s->duration = s->start_time = AV_NOPTS_VALUE;
593 /* Allocate private data. */
594 if (s->iformat->priv_data_size > 0) {
595 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
596 ret = AVERROR(ENOMEM);
599 if (s->iformat->priv_class) {
600 *(const AVClass **) s->priv_data = s->iformat->priv_class;
601 av_opt_set_defaults(s->priv_data);
602 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
607 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
609 ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
611 #if FF_API_DEMUXER_OPEN
612 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
614 if (s->iformat->read_header)
616 if ((ret = s->iformat->read_header(s)) < 0)
620 s->metadata = s->internal->id3v2_meta;
621 s->internal->id3v2_meta = NULL;
622 } else if (s->internal->id3v2_meta) {
623 av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
624 av_dict_free(&s->internal->id3v2_meta);
627 if (id3v2_extra_meta) {
628 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
629 !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
630 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
632 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
634 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
637 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
639 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
641 if ((ret = avformat_queue_attached_pictures(s)) < 0)
644 #if FF_API_DEMUXER_OPEN
645 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
647 if (s->pb && !s->internal->data_offset)
649 s->internal->data_offset = avio_tell(s->pb);
651 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
653 update_stream_avctx(s);
655 for (i = 0; i < s->nb_streams; i++)
656 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
659 av_dict_free(options);
666 if (s->iformat->read_close)
667 s->iformat->read_close(s);
669 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
671 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
673 avformat_free_context(s);
678 /*******************************************************/
680 static void force_codec_ids(AVFormatContext *s, AVStream *st)
682 switch (st->codecpar->codec_type) {
683 case AVMEDIA_TYPE_VIDEO:
684 if (s->video_codec_id)
685 st->codecpar->codec_id = s->video_codec_id;
687 case AVMEDIA_TYPE_AUDIO:
688 if (s->audio_codec_id)
689 st->codecpar->codec_id = s->audio_codec_id;
691 case AVMEDIA_TYPE_SUBTITLE:
692 if (s->subtitle_codec_id)
693 st->codecpar->codec_id = s->subtitle_codec_id;
695 case AVMEDIA_TYPE_DATA:
696 if (s->data_codec_id)
697 st->codecpar->codec_id = s->data_codec_id;
702 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
704 if (st->internal->request_probe>0) {
705 AVProbeData *pd = &st->internal->probe_data;
707 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
711 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
713 av_log(s, AV_LOG_WARNING,
714 "Failed to reallocate probe buffer for stream %d\n",
719 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
720 pd->buf_size += pkt->size;
721 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
724 st->probe_packets = 0;
726 av_log(s, AV_LOG_WARNING,
727 "nothing to probe for stream %d\n", st->index);
731 end= s->internal->raw_packet_buffer_remaining_size <= 0
732 || st->probe_packets<= 0;
734 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
735 int score = set_codec_from_probe_data(s, st, pd);
736 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
740 st->internal->request_probe = -1;
741 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
742 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
744 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
746 force_codec_ids(s, st);
752 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
754 int64_t ref = pkt->dts;
755 int i, pts_wrap_behavior;
756 int64_t pts_wrap_reference;
757 AVProgram *first_program;
759 if (ref == AV_NOPTS_VALUE)
761 if (st->internal->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
763 ref &= (1LL << st->pts_wrap_bits)-1;
765 // reference time stamp should be 60 s before first time stamp
766 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
767 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
768 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
769 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
770 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
772 first_program = av_find_program_from_stream(s, NULL, stream_index);
774 if (!first_program) {
775 int default_stream_index = av_find_default_stream_index(s);
776 if (s->streams[default_stream_index]->internal->pts_wrap_reference == AV_NOPTS_VALUE) {
777 for (i = 0; i < s->nb_streams; i++) {
778 if (av_find_program_from_stream(s, NULL, i))
780 s->streams[i]->internal->pts_wrap_reference = pts_wrap_reference;
781 s->streams[i]->internal->pts_wrap_behavior = pts_wrap_behavior;
785 st->internal->pts_wrap_reference = s->streams[default_stream_index]->internal->pts_wrap_reference;
786 st->internal->pts_wrap_behavior = s->streams[default_stream_index]->internal->pts_wrap_behavior;
790 AVProgram *program = first_program;
792 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
793 pts_wrap_reference = program->pts_wrap_reference;
794 pts_wrap_behavior = program->pts_wrap_behavior;
797 program = av_find_program_from_stream(s, program, stream_index);
800 // update every program with differing pts_wrap_reference
801 program = first_program;
803 if (program->pts_wrap_reference != pts_wrap_reference) {
804 for (i = 0; i<program->nb_stream_indexes; i++) {
805 s->streams[program->stream_index[i]]->internal->pts_wrap_reference = pts_wrap_reference;
806 s->streams[program->stream_index[i]]->internal->pts_wrap_behavior = pts_wrap_behavior;
809 program->pts_wrap_reference = pts_wrap_reference;
810 program->pts_wrap_behavior = pts_wrap_behavior;
812 program = av_find_program_from_stream(s, program, stream_index);
818 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
823 #if FF_API_INIT_PACKET
824 FF_DISABLE_DEPRECATION_WARNINGS
828 FF_ENABLE_DEPRECATION_WARNINGS
830 av_packet_unref(pkt);
834 PacketList *pktl = s->internal->raw_packet_buffer;
835 const AVPacket *pkt1;
838 st = s->streams[pktl->pkt.stream_index];
839 if (s->internal->raw_packet_buffer_remaining_size <= 0)
840 if ((err = probe_codec(s, st, NULL)) < 0)
842 if (st->internal->request_probe <= 0) {
843 avpriv_packet_list_get(&s->internal->raw_packet_buffer,
844 &s->internal->raw_packet_buffer_end, pkt);
845 s->internal->raw_packet_buffer_remaining_size += pkt->size;
850 err = s->iformat->read_packet(s, pkt);
852 av_packet_unref(pkt);
854 /* Some demuxers return FFERROR_REDO when they consume
855 data and discard it (ignored streams, junk, extradata).
856 We must re-call the demuxer to get the real packet. */
857 if (err == FFERROR_REDO)
859 if (!pktl || err == AVERROR(EAGAIN))
861 for (i = 0; i < s->nb_streams; i++) {
863 if (st->probe_packets || st->internal->request_probe > 0)
864 if ((err = probe_codec(s, st, NULL)) < 0)
866 av_assert0(st->internal->request_probe <= 0);
871 err = av_packet_make_refcounted(pkt);
873 av_packet_unref(pkt);
877 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
878 av_log(s, AV_LOG_WARNING,
879 "Packet corrupt (stream = %d, dts = %s)",
880 pkt->stream_index, av_ts2str(pkt->dts));
881 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
882 av_log(s, AV_LOG_WARNING, ", dropping it.\n");
883 av_packet_unref(pkt);
886 av_log(s, AV_LOG_WARNING, ".\n");
889 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
890 "Invalid stream index.\n");
892 st = s->streams[pkt->stream_index];
894 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->internal->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
895 // correct first time stamps to negative values
896 if (!is_relative(st->first_dts))
897 st->first_dts = wrap_timestamp(st, st->first_dts);
898 if (!is_relative(st->start_time))
899 st->start_time = wrap_timestamp(st, st->start_time);
900 if (!is_relative(st->cur_dts))
901 st->cur_dts = wrap_timestamp(st, st->cur_dts);
904 pkt->dts = wrap_timestamp(st, pkt->dts);
905 pkt->pts = wrap_timestamp(st, pkt->pts);
907 force_codec_ids(s, st);
909 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
910 if (s->use_wallclock_as_timestamps)
911 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
913 if (!pktl && st->internal->request_probe <= 0)
916 err = avpriv_packet_list_put(&s->internal->raw_packet_buffer,
917 &s->internal->raw_packet_buffer_end,
920 av_packet_unref(pkt);
923 pkt1 = &s->internal->raw_packet_buffer_end->pkt;
924 s->internal->raw_packet_buffer_remaining_size -= pkt1->size;
926 if ((err = probe_codec(s, st, pkt1)) < 0)
932 /**********************************************************/
934 static int determinable_frame_size(AVCodecContext *avctx)
936 switch(avctx->codec_id) {
937 case AV_CODEC_ID_MP1:
938 case AV_CODEC_ID_MP2:
939 case AV_CODEC_ID_MP3:
940 case AV_CODEC_ID_CODEC2:
948 * Return the frame duration in seconds. Return 0 if not available.
950 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
951 AVCodecParserContext *pc, AVPacket *pkt)
953 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
954 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
955 int frame_size, sample_rate;
957 #if FF_API_LAVF_AVCTX
958 FF_DISABLE_DEPRECATION_WARNINGS
959 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
960 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
961 FF_ENABLE_DEPRECATION_WARNINGS
966 switch (st->codecpar->codec_type) {
967 case AVMEDIA_TYPE_VIDEO:
968 if (st->r_frame_rate.num && !pc && s->iformat) {
969 *pnum = st->r_frame_rate.den;
970 *pden = st->r_frame_rate.num;
971 } else if (st->time_base.num * 1000LL > st->time_base.den) {
972 *pnum = st->time_base.num;
973 *pden = st->time_base.den;
974 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
975 av_assert0(st->internal->avctx->ticks_per_frame);
976 av_reduce(pnum, pden,
978 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
981 if (pc && pc->repeat_pict) {
982 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
983 av_reduce(pnum, pden,
984 (*pnum) * (1LL + pc->repeat_pict),
988 /* If this codec can be interlaced or progressive then we need
989 * a parser to compute duration of a packet. Thus if we have
990 * no parser in such case leave duration undefined. */
991 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
995 case AVMEDIA_TYPE_AUDIO:
996 if (st->internal->avctx_inited) {
997 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
998 sample_rate = st->internal->avctx->sample_rate;
1000 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
1001 sample_rate = st->codecpar->sample_rate;
1003 if (frame_size <= 0 || sample_rate <= 0)
1006 *pden = sample_rate;
1013 int ff_is_intra_only(enum AVCodecID id)
1015 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1018 if ((d->type == AVMEDIA_TYPE_VIDEO || d->type == AVMEDIA_TYPE_AUDIO) &&
1019 !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1024 static int has_decode_delay_been_guessed(AVStream *st)
1026 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1027 if (!st->internal->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1029 #if CONFIG_H264_DECODER
1030 if (st->internal->avctx->has_b_frames &&
1031 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1034 if (st->internal->avctx->has_b_frames<3)
1035 return st->internal->nb_decoded_frames >= 7;
1036 else if (st->internal->avctx->has_b_frames<4)
1037 return st->internal->nb_decoded_frames >= 18;
1039 return st->internal->nb_decoded_frames >= 20;
1042 static PacketList *get_next_pkt(AVFormatContext *s, AVStream *st, PacketList *pktl)
1046 if (pktl == s->internal->packet_buffer_end)
1047 return s->internal->parse_queue;
1051 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1052 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1053 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1056 int delay = st->internal->avctx->has_b_frames;
1059 if (dts == AV_NOPTS_VALUE) {
1060 int64_t best_score = INT64_MAX;
1061 for (i = 0; i<delay; i++) {
1062 if (st->internal->pts_reorder_error_count[i]) {
1063 int64_t score = st->internal->pts_reorder_error[i] / st->internal->pts_reorder_error_count[i];
1064 if (score < best_score) {
1066 dts = pts_buffer[i];
1071 for (i = 0; i<delay; i++) {
1072 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1073 int64_t diff = FFABS(pts_buffer[i] - dts)
1074 + (uint64_t)st->internal->pts_reorder_error[i];
1075 diff = FFMAX(diff, st->internal->pts_reorder_error[i]);
1076 st->internal->pts_reorder_error[i] = diff;
1077 st->internal->pts_reorder_error_count[i]++;
1078 if (st->internal->pts_reorder_error_count[i] > 250) {
1079 st->internal->pts_reorder_error[i] >>= 1;
1080 st->internal->pts_reorder_error_count[i] >>= 1;
1087 if (dts == AV_NOPTS_VALUE)
1088 dts = pts_buffer[0];
1094 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1095 * of the packets in a window.
1097 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1098 PacketList *pkt_buffer)
1100 AVStream *st = s->streams[stream_index];
1101 int delay = st->internal->avctx->has_b_frames;
1104 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1106 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1107 pts_buffer[i] = AV_NOPTS_VALUE;
1109 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1110 if (pkt_buffer->pkt.stream_index != stream_index)
1113 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1114 pts_buffer[0] = pkt_buffer->pkt.pts;
1115 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1116 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1118 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1123 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1124 int64_t dts, int64_t pts, AVPacket *pkt)
1126 AVStream *st = s->streams[stream_index];
1127 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1128 PacketList *pktl_it;
1132 if (st->first_dts != AV_NOPTS_VALUE ||
1133 dts == AV_NOPTS_VALUE ||
1134 st->cur_dts == AV_NOPTS_VALUE ||
1135 st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1136 dts < INT_MIN + (st->cur_dts - RELATIVE_TS_BASE) ||
1140 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1142 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1144 if (is_relative(pts))
1147 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1148 if (pktl_it->pkt.stream_index != stream_index)
1150 if (is_relative(pktl_it->pkt.pts))
1151 pktl_it->pkt.pts += shift;
1153 if (is_relative(pktl_it->pkt.dts))
1154 pktl_it->pkt.dts += shift;
1156 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1157 st->start_time = pktl_it->pkt.pts;
1158 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1159 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));
1163 if (has_decode_delay_been_guessed(st)) {
1164 update_dts_from_pts(s, stream_index, pktl);
1167 if (st->start_time == AV_NOPTS_VALUE) {
1168 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1169 st->start_time = pts;
1171 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1172 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));
1176 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1177 int stream_index, int64_t duration)
1179 PacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1180 int64_t cur_dts = RELATIVE_TS_BASE;
1182 if (st->first_dts != AV_NOPTS_VALUE) {
1183 if (st->internal->update_initial_durations_done)
1185 st->internal->update_initial_durations_done = 1;
1186 cur_dts = st->first_dts;
1187 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1188 if (pktl->pkt.stream_index == stream_index) {
1189 if (pktl->pkt.pts != pktl->pkt.dts ||
1190 pktl->pkt.dts != AV_NOPTS_VALUE ||
1193 cur_dts -= duration;
1196 if (pktl && pktl->pkt.dts != st->first_dts) {
1197 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1198 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1202 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1205 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1206 st->first_dts = cur_dts;
1207 } else if (st->cur_dts != RELATIVE_TS_BASE)
1210 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1211 if (pktl->pkt.stream_index != stream_index)
1213 if ((pktl->pkt.pts == pktl->pkt.dts ||
1214 pktl->pkt.pts == AV_NOPTS_VALUE) &&
1215 (pktl->pkt.dts == AV_NOPTS_VALUE ||
1216 pktl->pkt.dts == st->first_dts ||
1217 pktl->pkt.dts == RELATIVE_TS_BASE) &&
1218 !pktl->pkt.duration) {
1219 pktl->pkt.dts = cur_dts;
1220 if (!st->internal->avctx->has_b_frames)
1221 pktl->pkt.pts = cur_dts;
1222 pktl->pkt.duration = duration;
1225 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1228 st->cur_dts = cur_dts;
1231 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1232 AVCodecParserContext *pc, AVPacket *pkt,
1233 int64_t next_dts, int64_t next_pts)
1235 int num, den, presentation_delayed, delay, i;
1237 AVRational duration;
1238 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1239 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1241 if (s->flags & AVFMT_FLAG_NOFILLIN)
1244 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1245 if (pkt->dts == pkt->pts && st->internal->last_dts_for_order_check != AV_NOPTS_VALUE) {
1246 if (st->internal->last_dts_for_order_check <= pkt->dts) {
1247 st->internal->dts_ordered++;
1249 av_log(s, st->internal->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1250 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1252 st->internal->last_dts_for_order_check);
1253 st->internal->dts_misordered++;
1255 if (st->internal->dts_ordered + st->internal->dts_misordered > 250) {
1256 st->internal->dts_ordered >>= 1;
1257 st->internal->dts_misordered >>= 1;
1261 st->internal->last_dts_for_order_check = pkt->dts;
1262 if (st->internal->dts_ordered < 8*st->internal->dts_misordered && pkt->dts == pkt->pts)
1263 pkt->dts = AV_NOPTS_VALUE;
1266 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1267 pkt->dts = AV_NOPTS_VALUE;
1269 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1270 && !st->internal->avctx->has_b_frames)
1271 //FIXME Set low_delay = 0 when has_b_frames = 1
1272 st->internal->avctx->has_b_frames = 1;
1274 /* do we have a video B-frame ? */
1275 delay = st->internal->avctx->has_b_frames;
1276 presentation_delayed = 0;
1278 /* XXX: need has_b_frame, but cannot get it if the codec is
1279 * not initialized */
1281 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1282 presentation_delayed = 1;
1284 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1285 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1286 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1287 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1288 pkt->dts -= 1LL << st->pts_wrap_bits;
1290 pkt->pts += 1LL << st->pts_wrap_bits;
1293 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1294 * We take the conservative approach and discard both.
1295 * Note: If this is misbehaving for an H.264 file, then possibly
1296 * presentation_delayed is not set correctly. */
1297 if (delay == 1 && pkt->dts == pkt->pts &&
1298 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1299 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1300 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1301 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1302 pkt->dts = AV_NOPTS_VALUE;
1305 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1306 if (pkt->duration <= 0) {
1307 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1309 duration = (AVRational) {num, den};
1310 pkt->duration = av_rescale_rnd(1,
1311 num * (int64_t) st->time_base.den,
1312 den * (int64_t) st->time_base.num,
1317 if (pkt->duration > 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1318 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1320 /* Correct timestamps with byte offset if demuxers only have timestamps
1321 * on packet boundaries */
1322 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1323 /* this will estimate bitrate based on this frame's duration and size */
1324 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1325 if (pkt->pts != AV_NOPTS_VALUE)
1327 if (pkt->dts != AV_NOPTS_VALUE)
1331 /* This may be redundant, but it should not hurt. */
1332 if (pkt->dts != AV_NOPTS_VALUE &&
1333 pkt->pts != AV_NOPTS_VALUE &&
1334 pkt->pts > pkt->dts)
1335 presentation_delayed = 1;
1337 if (s->debug & FF_FDEBUG_TS)
1338 av_log(s, AV_LOG_DEBUG,
1339 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1340 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1341 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1343 /* Interpolate PTS and DTS if they are not present. We skip H264
1344 * currently because delay and has_b_frames are not reliably set. */
1345 if ((delay == 0 || (delay == 1 && pc)) &&
1347 if (presentation_delayed) {
1348 /* DTS = decompression timestamp */
1349 /* PTS = presentation timestamp */
1350 if (pkt->dts == AV_NOPTS_VALUE)
1351 pkt->dts = st->last_IP_pts;
1352 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1353 if (pkt->dts == AV_NOPTS_VALUE)
1354 pkt->dts = st->cur_dts;
1356 /* This is tricky: the dts must be incremented by the duration
1357 * of the frame we are displaying, i.e. the last I- or P-frame. */
1358 if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1359 st->last_IP_duration = pkt->duration;
1360 if (pkt->dts != AV_NOPTS_VALUE)
1361 st->cur_dts = av_sat_add64(pkt->dts, st->last_IP_duration);
1362 if (pkt->dts != AV_NOPTS_VALUE &&
1363 pkt->pts == AV_NOPTS_VALUE &&
1364 st->last_IP_duration > 0 &&
1365 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1366 next_dts != next_pts &&
1367 next_pts != AV_NOPTS_VALUE)
1368 pkt->pts = next_dts;
1370 if ((uint64_t)pkt->duration <= INT32_MAX)
1371 st->last_IP_duration = pkt->duration;
1372 st->last_IP_pts = pkt->pts;
1373 /* Cannot compute PTS if not present (we can compute it only
1374 * by knowing the future. */
1375 } else if (pkt->pts != AV_NOPTS_VALUE ||
1376 pkt->dts != AV_NOPTS_VALUE ||
1377 pkt->duration > 0 ) {
1379 /* presentation is not delayed : PTS and DTS are the same */
1380 if (pkt->pts == AV_NOPTS_VALUE)
1381 pkt->pts = pkt->dts;
1382 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1384 if (pkt->pts == AV_NOPTS_VALUE)
1385 pkt->pts = st->cur_dts;
1386 pkt->dts = pkt->pts;
1387 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1388 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1392 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1393 st->internal->pts_buffer[0] = pkt->pts;
1394 for (i = 0; i<delay && st->internal->pts_buffer[i] > st->internal->pts_buffer[i + 1]; i++)
1395 FFSWAP(int64_t, st->internal->pts_buffer[i], st->internal->pts_buffer[i + 1]);
1397 if(has_decode_delay_been_guessed(st))
1398 pkt->dts = select_from_pts_buffer(st, st->internal->pts_buffer, pkt->dts);
1400 // We skipped it above so we try here.
1402 // This should happen on the first packet
1403 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1404 if (pkt->dts > st->cur_dts)
1405 st->cur_dts = pkt->dts;
1407 if (s->debug & FF_FDEBUG_TS)
1408 av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1409 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1412 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1413 pkt->flags |= AV_PKT_FLAG_KEY;
1417 * Parse a packet, add all split parts to parse_queue.
1419 * @param pkt Packet to parse; must not be NULL.
1420 * @param flush Indicates whether to flush. If set, pkt must be blank.
1422 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1423 int stream_index, int flush)
1425 AVPacket *out_pkt = s->internal->parse_pkt;
1426 AVStream *st = s->streams[stream_index];
1427 uint8_t *data = pkt->data;
1428 int size = pkt->size;
1429 int ret = 0, got_output = flush;
1431 if (!size && !flush && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1432 // preserve 0-size sync packets
1433 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1436 while (size > 0 || (flush && got_output)) {
1438 int64_t next_pts = pkt->pts;
1439 int64_t next_dts = pkt->dts;
1441 len = av_parser_parse2(st->parser, st->internal->avctx,
1442 &out_pkt->data, &out_pkt->size, data, size,
1443 pkt->pts, pkt->dts, pkt->pos);
1445 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1447 /* increment read pointer */
1448 av_assert1(data || !len);
1449 data = len ? data + len : data;
1452 got_output = !!out_pkt->size;
1457 if (pkt->buf && out_pkt->data == pkt->data) {
1458 /* reference pkt->buf only when out_pkt->data is guaranteed to point
1459 * to data in it and not in the parser's internal buffer. */
1460 /* XXX: Ensure this is the case with all parsers when st->parser->flags
1461 * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1462 out_pkt->buf = av_buffer_ref(pkt->buf);
1463 if (!out_pkt->buf) {
1464 ret = AVERROR(ENOMEM);
1468 ret = av_packet_make_refcounted(out_pkt);
1473 if (pkt->side_data) {
1474 out_pkt->side_data = pkt->side_data;
1475 out_pkt->side_data_elems = pkt->side_data_elems;
1476 pkt->side_data = NULL;
1477 pkt->side_data_elems = 0;
1480 /* set the duration */
1481 out_pkt->duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1482 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1483 if (st->internal->avctx->sample_rate > 0) {
1485 av_rescale_q_rnd(st->parser->duration,
1486 (AVRational) { 1, st->internal->avctx->sample_rate },
1492 out_pkt->stream_index = st->index;
1493 out_pkt->pts = st->parser->pts;
1494 out_pkt->dts = st->parser->dts;
1495 out_pkt->pos = st->parser->pos;
1496 out_pkt->flags |= pkt->flags & AV_PKT_FLAG_DISCARD;
1498 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1499 out_pkt->pos = st->parser->frame_offset;
1501 if (st->parser->key_frame == 1 ||
1502 (st->parser->key_frame == -1 &&
1503 st->parser->pict_type == AV_PICTURE_TYPE_I))
1504 out_pkt->flags |= AV_PKT_FLAG_KEY;
1506 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1507 out_pkt->flags |= AV_PKT_FLAG_KEY;
1509 compute_pkt_fields(s, st, st->parser, out_pkt, next_dts, next_pts);
1511 ret = avpriv_packet_list_put(&s->internal->parse_queue,
1512 &s->internal->parse_queue_end,
1518 /* end of the stream => close and free the parser */
1520 av_parser_close(st->parser);
1526 av_packet_unref(out_pkt);
1527 av_packet_unref(pkt);
1531 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1533 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1536 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1538 int ret, i, got_packet = 0;
1539 AVDictionary *metadata = NULL;
1541 while (!got_packet && !s->internal->parse_queue) {
1544 /* read next packet */
1545 ret = ff_read_packet(s, pkt);
1547 if (ret == AVERROR(EAGAIN))
1549 /* flush the parsers */
1550 for (i = 0; i < s->nb_streams; i++) {
1552 if (st->parser && st->need_parsing)
1553 parse_packet(s, pkt, st->index, 1);
1555 /* all remaining packets are now in parse_queue =>
1556 * really terminate parsing */
1560 st = s->streams[pkt->stream_index];
1562 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1564 /* update context if required */
1565 if (st->internal->need_context_update) {
1566 if (avcodec_is_open(st->internal->avctx)) {
1567 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1568 avcodec_close(st->internal->avctx);
1569 st->internal->info->found_decoder = 0;
1572 /* close parser, because it depends on the codec */
1573 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1574 av_parser_close(st->parser);
1578 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1580 av_packet_unref(pkt);
1584 #if FF_API_LAVF_AVCTX
1585 FF_DISABLE_DEPRECATION_WARNINGS
1586 /* update deprecated public codec context */
1587 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1589 av_packet_unref(pkt);
1592 FF_ENABLE_DEPRECATION_WARNINGS
1595 st->internal->need_context_update = 0;
1598 if (pkt->pts != AV_NOPTS_VALUE &&
1599 pkt->dts != AV_NOPTS_VALUE &&
1600 pkt->pts < pkt->dts) {
1601 av_log(s, AV_LOG_WARNING,
1602 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1604 av_ts2str(pkt->pts),
1605 av_ts2str(pkt->dts),
1608 if (s->debug & FF_FDEBUG_TS)
1609 av_log(s, AV_LOG_DEBUG,
1610 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1612 av_ts2str(pkt->pts),
1613 av_ts2str(pkt->dts),
1614 pkt->size, pkt->duration, pkt->flags);
1616 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1617 st->parser = av_parser_init(st->codecpar->codec_id);
1619 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1620 "%s, packets or times may be invalid.\n",
1621 avcodec_get_name(st->codecpar->codec_id));
1622 /* no parser available: just output the raw packets */
1623 st->need_parsing = AVSTREAM_PARSE_NONE;
1624 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1625 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1626 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1627 st->parser->flags |= PARSER_FLAG_ONCE;
1628 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1629 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1632 if (!st->need_parsing || !st->parser) {
1633 /* no parsing needed: we just output the packet as is */
1634 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1635 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1636 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1637 ff_reduce_index(s, st->index);
1638 av_add_index_entry(st, pkt->pos, pkt->dts,
1639 0, 0, AVINDEX_KEYFRAME);
1642 } else if (st->discard < AVDISCARD_ALL) {
1643 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1645 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1646 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1647 st->codecpar->channels = st->internal->avctx->channels;
1648 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1649 st->codecpar->codec_id = st->internal->avctx->codec_id;
1652 av_packet_unref(pkt);
1654 if (pkt->flags & AV_PKT_FLAG_KEY)
1655 st->internal->skip_to_keyframe = 0;
1656 if (st->internal->skip_to_keyframe) {
1657 av_packet_unref(pkt);
1662 if (!got_packet && s->internal->parse_queue)
1663 ret = avpriv_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1666 AVStream *st = s->streams[pkt->stream_index];
1667 int discard_padding = 0;
1668 if (st->internal->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1669 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1670 int64_t sample = ts_to_samples(st, pts);
1671 int duration = ts_to_samples(st, pkt->duration);
1672 int64_t end_sample = sample + duration;
1673 if (duration > 0 && end_sample >= st->internal->first_discard_sample &&
1674 sample < st->internal->last_discard_sample)
1675 discard_padding = FFMIN(end_sample - st->internal->first_discard_sample, duration);
1677 if (st->internal->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1678 st->internal->skip_samples = st->internal->start_skip_samples;
1679 if (st->internal->skip_samples || discard_padding) {
1680 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1682 AV_WL32(p, st->internal->skip_samples);
1683 AV_WL32(p + 4, discard_padding);
1684 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->internal->skip_samples, discard_padding);
1686 st->internal->skip_samples = 0;
1689 if (st->internal->inject_global_side_data) {
1690 for (i = 0; i < st->nb_side_data; i++) {
1691 AVPacketSideData *src_sd = &st->side_data[i];
1694 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1697 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1699 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1703 memcpy(dst_data, src_sd->data, src_sd->size);
1705 st->internal->inject_global_side_data = 0;
1709 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1711 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1712 av_dict_copy(&s->metadata, metadata, 0);
1713 av_dict_free(&metadata);
1714 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1717 #if FF_API_LAVF_AVCTX
1718 update_stream_avctx(s);
1721 if (s->debug & FF_FDEBUG_TS)
1722 av_log(s, AV_LOG_DEBUG,
1723 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1724 "size=%d, duration=%"PRId64", flags=%d\n",
1726 av_ts2str(pkt->pts),
1727 av_ts2str(pkt->dts),
1728 pkt->size, pkt->duration, pkt->flags);
1730 /* A demuxer might have returned EOF because of an IO error, let's
1731 * propagate this back to the user. */
1732 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1738 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1740 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1746 ret = s->internal->packet_buffer
1747 ? avpriv_packet_list_get(&s->internal->packet_buffer,
1748 &s->internal->packet_buffer_end, pkt)
1749 : read_frame_internal(s, pkt);
1756 PacketList *pktl = s->internal->packet_buffer;
1759 AVPacket *next_pkt = &pktl->pkt;
1761 if (next_pkt->dts != AV_NOPTS_VALUE) {
1762 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1763 // last dts seen for this stream. if any of packets following
1764 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1765 int64_t last_dts = next_pkt->dts;
1766 av_assert2(wrap_bits <= 64);
1767 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1768 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1769 av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1770 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1772 next_pkt->pts = pktl->pkt.dts;
1774 if (last_dts != AV_NOPTS_VALUE) {
1775 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1776 last_dts = pktl->pkt.dts;
1781 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1782 // Fixing the last reference frame had none pts issue (For MXF etc).
1783 // We only do this when
1785 // 2. we are not able to resolve a pts value for current packet.
1786 // 3. the packets for this stream at the end of the files had valid dts.
1787 next_pkt->pts = last_dts + next_pkt->duration;
1789 pktl = s->internal->packet_buffer;
1792 /* read packet from packet buffer, if there is data */
1793 st = s->streams[next_pkt->stream_index];
1794 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1795 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1796 ret = avpriv_packet_list_get(&s->internal->packet_buffer,
1797 &s->internal->packet_buffer_end, pkt);
1802 ret = read_frame_internal(s, pkt);
1804 if (pktl && ret != AVERROR(EAGAIN)) {
1811 ret = avpriv_packet_list_put(&s->internal->packet_buffer,
1812 &s->internal->packet_buffer_end,
1815 av_packet_unref(pkt);
1822 st = s->streams[pkt->stream_index];
1823 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1824 ff_reduce_index(s, st->index);
1825 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1828 if (is_relative(pkt->dts))
1829 pkt->dts -= RELATIVE_TS_BASE;
1830 if (is_relative(pkt->pts))
1831 pkt->pts -= RELATIVE_TS_BASE;
1836 /* XXX: suppress the packet queue */
1837 static void flush_packet_queue(AVFormatContext *s)
1841 avpriv_packet_list_free(&s->internal->parse_queue, &s->internal->parse_queue_end);
1842 avpriv_packet_list_free(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1843 avpriv_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1845 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1848 /*******************************************************/
1851 int av_find_default_stream_index(AVFormatContext *s)
1855 int best_stream = 0;
1856 int best_score = INT_MIN;
1858 if (s->nb_streams <= 0)
1860 for (i = 0; i < s->nb_streams; i++) {
1863 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1864 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1866 if (st->codecpar->width && st->codecpar->height)
1870 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1871 if (st->codecpar->sample_rate)
1874 if (st->codec_info_nb_frames)
1877 if (st->discard != AVDISCARD_ALL)
1880 if (score > best_score) {
1888 /** Flush the frame reader. */
1889 void ff_read_frame_flush(AVFormatContext *s)
1894 flush_packet_queue(s);
1896 /* Reset read state for each stream. */
1897 for (i = 0; i < s->nb_streams; i++) {
1901 av_parser_close(st->parser);
1904 st->last_IP_pts = AV_NOPTS_VALUE;
1905 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
1906 if (st->first_dts == AV_NOPTS_VALUE)
1907 st->cur_dts = RELATIVE_TS_BASE;
1909 /* We set the current DTS to an unspecified origin. */
1910 st->cur_dts = AV_NOPTS_VALUE;
1912 st->probe_packets = s->max_probe_packets;
1914 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1915 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
1917 if (s->internal->inject_global_side_data)
1918 st->internal->inject_global_side_data = 1;
1920 st->internal->skip_samples = 0;
1924 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1928 for (i = 0; i < s->nb_streams; i++) {
1929 AVStream *st = s->streams[i];
1932 av_rescale(timestamp,
1933 st->time_base.den * (int64_t) ref_st->time_base.num,
1934 st->time_base.num * (int64_t) ref_st->time_base.den);
1938 void ff_reduce_index(AVFormatContext *s, int stream_index)
1940 AVStream *st = s->streams[stream_index];
1941 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1943 if ((unsigned) st->internal->nb_index_entries >= max_entries) {
1945 for (i = 0; 2 * i < st->internal->nb_index_entries; i++)
1946 st->internal->index_entries[i] = st->internal->index_entries[2 * i];
1947 st->internal->nb_index_entries = i;
1951 int ff_add_index_entry(AVIndexEntry **index_entries,
1952 int *nb_index_entries,
1953 unsigned int *index_entries_allocated_size,
1954 int64_t pos, int64_t timestamp,
1955 int size, int distance, int flags)
1957 AVIndexEntry *entries, *ie;
1960 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1963 if (timestamp == AV_NOPTS_VALUE)
1964 return AVERROR(EINVAL);
1966 if (size < 0 || size > 0x3FFFFFFF)
1967 return AVERROR(EINVAL);
1969 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1970 timestamp -= RELATIVE_TS_BASE;
1972 entries = av_fast_realloc(*index_entries,
1973 index_entries_allocated_size,
1974 (*nb_index_entries + 1) *
1975 sizeof(AVIndexEntry));
1979 *index_entries = entries;
1981 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1982 timestamp, AVSEEK_FLAG_ANY);
1985 index = (*nb_index_entries)++;
1986 ie = &entries[index];
1987 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1989 ie = &entries[index];
1990 if (ie->timestamp != timestamp) {
1991 if (ie->timestamp <= timestamp)
1993 memmove(entries + index + 1, entries + index,
1994 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1995 (*nb_index_entries)++;
1996 } else if (ie->pos == pos && distance < ie->min_distance)
1997 // do not reduce the distance
1998 distance = ie->min_distance;
2002 ie->timestamp = timestamp;
2003 ie->min_distance = distance;
2010 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2011 int size, int distance, int flags)
2013 timestamp = wrap_timestamp(st, timestamp);
2014 return ff_add_index_entry(&st->internal->index_entries, &st->internal->nb_index_entries,
2015 &st->internal->index_entries_allocated_size, pos,
2016 timestamp, size, distance, flags);
2019 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2020 int64_t wanted_timestamp, int flags)
2028 // Optimize appending index entries at the end.
2029 if (b && entries[b - 1].timestamp < wanted_timestamp)
2035 // Search for the next non-discarded packet.
2036 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2038 if (m == b && entries[m].timestamp >= wanted_timestamp) {
2044 timestamp = entries[m].timestamp;
2045 if (timestamp >= wanted_timestamp)
2047 if (timestamp <= wanted_timestamp)
2050 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2052 if (!(flags & AVSEEK_FLAG_ANY))
2053 while (m >= 0 && m < nb_entries &&
2054 !(entries[m].flags & AVINDEX_KEYFRAME))
2055 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2057 if (m == nb_entries)
2062 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2065 int64_t pos_delta = 0;
2067 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2068 const char *proto = avio_find_protocol_name(s->url);
2070 av_assert0(time_tolerance >= 0);
2073 av_log(s, AV_LOG_INFO,
2074 "Protocol name not provided, cannot determine if input is local or "
2075 "a network protocol, buffers and access patterns cannot be configured "
2076 "optimally without knowing the protocol\n");
2079 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2082 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2083 AVStream *st1 = s->streams[ist1];
2084 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2085 AVStream *st2 = s->streams[ist2];
2091 for (i1 = i2 = 0; i1 < st1->internal->nb_index_entries; i1++) {
2092 AVIndexEntry *e1 = &st1->internal->index_entries[i1];
2093 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2095 skip = FFMAX(skip, e1->size);
2096 for (; i2 < st2->internal->nb_index_entries; i2++) {
2097 AVIndexEntry *e2 = &st2->internal->index_entries[i2];
2098 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2099 if (e2_pts < e1_pts || e2_pts - (uint64_t)e1_pts < time_tolerance)
2101 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2109 /* XXX This could be adjusted depending on protocol*/
2110 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2111 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2113 /* realloc the buffer and the original data will be retained */
2114 if (ffio_realloc_buf(s->pb, pos_delta)) {
2115 av_log(s, AV_LOG_ERROR, "Realloc buffer fail.\n");
2119 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2122 if (skip < (1<<23)) {
2123 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2127 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2129 return ff_index_search_timestamp(st->internal->index_entries, st->internal->nb_index_entries,
2130 wanted_timestamp, flags);
2133 int avformat_index_get_entries_count(const AVStream *st)
2135 return st->internal->nb_index_entries;
2138 const AVIndexEntry *avformat_index_get_entry(const AVStream *st, int idx)
2140 if (idx < 0 || idx >= st->internal->nb_index_entries)
2143 return &st->internal->index_entries[idx];
2146 const AVIndexEntry *avformat_index_get_entry_from_timestamp(const AVStream *st,
2147 int64_t wanted_timestamp,
2150 int idx = ff_index_search_timestamp(st->internal->index_entries,
2151 st->internal->nb_index_entries,
2152 wanted_timestamp, flags);
2157 return &st->internal->index_entries[idx];
2160 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2161 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2163 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2164 if (stream_index >= 0)
2165 ts = wrap_timestamp(s->streams[stream_index], ts);
2169 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2170 int64_t target_ts, int flags)
2172 const AVInputFormat *avif = s->iformat;
2173 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2174 int64_t ts_min, ts_max, ts;
2179 if (stream_index < 0)
2182 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2185 ts_min = AV_NOPTS_VALUE;
2186 pos_limit = -1; // GCC falsely says it may be uninitialized.
2188 st = s->streams[stream_index];
2189 if (st->internal->index_entries) {
2192 /* FIXME: Whole function must be checked for non-keyframe entries in
2193 * index case, especially read_timestamp(). */
2194 index = av_index_search_timestamp(st, target_ts,
2195 flags | AVSEEK_FLAG_BACKWARD);
2196 index = FFMAX(index, 0);
2197 e = &st->internal->index_entries[index];
2199 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2201 ts_min = e->timestamp;
2202 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2203 pos_min, av_ts2str(ts_min));
2205 av_assert1(index == 0);
2208 index = av_index_search_timestamp(st, target_ts,
2209 flags & ~AVSEEK_FLAG_BACKWARD);
2210 av_assert0(index < st->internal->nb_index_entries);
2212 e = &st->internal->index_entries[index];
2213 av_assert1(e->timestamp >= target_ts);
2215 ts_max = e->timestamp;
2216 pos_limit = pos_max - e->min_distance;
2217 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2218 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2222 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2223 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2228 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2231 ff_read_frame_flush(s);
2232 ff_update_cur_dts(s, st, ts);
2237 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2238 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2240 int64_t step = 1024;
2241 int64_t limit, ts_max;
2242 int64_t filesize = avio_size(s->pb);
2243 int64_t pos_max = filesize - 1;
2246 pos_max = FFMAX(0, (pos_max) - step);
2247 ts_max = ff_read_timestamp(s, stream_index,
2248 &pos_max, limit, read_timestamp);
2250 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2251 if (ts_max == AV_NOPTS_VALUE)
2255 int64_t tmp_pos = pos_max + 1;
2256 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2257 &tmp_pos, INT64_MAX, read_timestamp);
2258 if (tmp_ts == AV_NOPTS_VALUE)
2260 av_assert0(tmp_pos > pos_max);
2263 if (tmp_pos >= filesize)
2275 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2276 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2277 int64_t ts_min, int64_t ts_max,
2278 int flags, int64_t *ts_ret,
2279 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2280 int64_t *, int64_t))
2287 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2289 if (ts_min == AV_NOPTS_VALUE) {
2290 pos_min = s->internal->data_offset;
2291 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2292 if (ts_min == AV_NOPTS_VALUE)
2296 if (ts_min >= target_ts) {
2301 if (ts_max == AV_NOPTS_VALUE) {
2302 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2304 pos_limit = pos_max;
2307 if (ts_max <= target_ts) {
2312 av_assert0(ts_min < ts_max);
2315 while (pos_min < pos_limit) {
2316 av_log(s, AV_LOG_TRACE,
2317 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2318 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2319 av_assert0(pos_limit <= pos_max);
2321 if (no_change == 0) {
2322 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2323 // interpolate position (better than dichotomy)
2324 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2326 pos_min - approximate_keyframe_distance;
2327 } else if (no_change == 1) {
2328 // bisection if interpolation did not change min / max pos last time
2329 pos = (pos_min + pos_limit) >> 1;
2331 /* linear search if bisection failed, can only happen if there
2332 * are very few or no keyframes between min/max */
2337 else if (pos > pos_limit)
2341 // May pass pos_limit instead of -1.
2342 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2347 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2348 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2349 pos_min, pos, pos_max,
2350 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2351 pos_limit, start_pos, no_change);
2352 if (ts == AV_NOPTS_VALUE) {
2353 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2356 if (target_ts <= ts) {
2357 pos_limit = start_pos - 1;
2361 if (target_ts >= ts) {
2367 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2368 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2371 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2373 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2374 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2375 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2381 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2382 int64_t pos, int flags)
2384 int64_t pos_min, pos_max;
2386 pos_min = s->internal->data_offset;
2387 pos_max = avio_size(s->pb) - 1;
2391 else if (pos > pos_max)
2394 avio_seek(s->pb, pos, SEEK_SET);
2396 s->io_repositioned = 1;
2401 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2402 int64_t timestamp, int flags)
2409 st = s->streams[stream_index];
2411 index = av_index_search_timestamp(st, timestamp, flags);
2413 if (index < 0 && st->internal->nb_index_entries &&
2414 timestamp < st->internal->index_entries[0].timestamp)
2417 if (index < 0 || index == st->internal->nb_index_entries - 1) {
2418 AVPacket *pkt = s->internal->pkt;
2421 if (st->internal->nb_index_entries) {
2422 av_assert0(st->internal->index_entries);
2423 ie = &st->internal->index_entries[st->internal->nb_index_entries - 1];
2424 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2426 ff_update_cur_dts(s, st, ie->timestamp);
2428 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2431 av_packet_unref(pkt);
2435 read_status = av_read_frame(s, pkt);
2436 } while (read_status == AVERROR(EAGAIN));
2437 if (read_status < 0)
2439 if (stream_index == pkt->stream_index && pkt->dts > timestamp) {
2440 if (pkt->flags & AV_PKT_FLAG_KEY) {
2441 av_packet_unref(pkt);
2444 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2445 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);
2446 av_packet_unref(pkt);
2450 av_packet_unref(pkt);
2452 index = av_index_search_timestamp(st, timestamp, flags);
2457 ff_read_frame_flush(s);
2458 if (s->iformat->read_seek)
2459 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2461 ie = &st->internal->index_entries[index];
2462 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2464 ff_update_cur_dts(s, st, ie->timestamp);
2469 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2470 int64_t timestamp, int flags)
2475 if (flags & AVSEEK_FLAG_BYTE) {
2476 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2478 ff_read_frame_flush(s);
2479 return seek_frame_byte(s, stream_index, timestamp, flags);
2482 if (stream_index < 0) {
2483 stream_index = av_find_default_stream_index(s);
2484 if (stream_index < 0)
2487 st = s->streams[stream_index];
2488 /* timestamp for default must be expressed in AV_TIME_BASE units */
2489 timestamp = av_rescale(timestamp, st->time_base.den,
2490 AV_TIME_BASE * (int64_t) st->time_base.num);
2493 /* first, we try the format specific seek */
2494 if (s->iformat->read_seek) {
2495 ff_read_frame_flush(s);
2496 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2502 if (s->iformat->read_timestamp &&
2503 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2504 ff_read_frame_flush(s);
2505 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2506 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2507 ff_read_frame_flush(s);
2508 return seek_frame_generic(s, stream_index, timestamp, flags);
2513 int av_seek_frame(AVFormatContext *s, int stream_index,
2514 int64_t timestamp, int flags)
2518 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2519 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2520 if ((flags & AVSEEK_FLAG_BACKWARD))
2524 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2525 flags & ~AVSEEK_FLAG_BACKWARD);
2528 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2531 ret = avformat_queue_attached_pictures(s);
2536 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2537 int64_t ts, int64_t max_ts, int flags)
2539 if (min_ts > ts || max_ts < ts)
2541 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2542 return AVERROR(EINVAL);
2545 flags |= AVSEEK_FLAG_ANY;
2546 flags &= ~AVSEEK_FLAG_BACKWARD;
2548 if (s->iformat->read_seek2) {
2550 ff_read_frame_flush(s);
2552 if (stream_index == -1 && s->nb_streams == 1) {
2553 AVRational time_base = s->streams[0]->time_base;
2554 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2555 min_ts = av_rescale_rnd(min_ts, time_base.den,
2556 time_base.num * (int64_t)AV_TIME_BASE,
2557 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2558 max_ts = av_rescale_rnd(max_ts, time_base.den,
2559 time_base.num * (int64_t)AV_TIME_BASE,
2560 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2564 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2568 ret = avformat_queue_attached_pictures(s);
2572 if (s->iformat->read_timestamp) {
2573 // try to seek via read_timestamp()
2576 // Fall back on old API if new is not implemented but old is.
2577 // Note the old API has somewhat different semantics.
2578 if (s->iformat->read_seek || 1) {
2579 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2580 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2581 if (ret<0 && ts != min_ts && max_ts != ts) {
2582 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2584 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2589 // try some generic seek like seek_frame_generic() but with new ts semantics
2590 return -1; //unreachable
2593 int avformat_flush(AVFormatContext *s)
2595 ff_read_frame_flush(s);
2599 /*******************************************************/
2602 * Return TRUE if the stream has accurate duration in any stream.
2604 * @return TRUE if the stream has accurate duration for at least one component.
2606 static int has_duration(AVFormatContext *ic)
2611 for (i = 0; i < ic->nb_streams; i++) {
2612 st = ic->streams[i];
2613 if (st->duration != AV_NOPTS_VALUE)
2616 if (ic->duration != AV_NOPTS_VALUE)
2622 * Estimate the stream timings from the one of each components.
2624 * Also computes the global bitrate if possible.
2626 static void update_stream_timings(AVFormatContext *ic)
2628 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2629 int64_t duration, duration1, duration_text, filesize;
2633 start_time = INT64_MAX;
2634 start_time_text = INT64_MAX;
2635 end_time = INT64_MIN;
2636 end_time_text = INT64_MIN;
2637 duration = INT64_MIN;
2638 duration_text = INT64_MIN;
2640 for (i = 0; i < ic->nb_streams; i++) {
2641 AVStream *st = ic->streams[i];
2642 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2643 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2644 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2645 start_time1 = av_rescale_q(st->start_time, st->time_base,
2648 start_time_text = FFMIN(start_time_text, start_time1);
2650 start_time = FFMIN(start_time, start_time1);
2651 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2653 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2654 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2655 end_time1 += start_time1;
2657 end_time_text = FFMAX(end_time_text, end_time1);
2659 end_time = FFMAX(end_time, end_time1);
2661 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2662 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2663 p->start_time = start_time1;
2664 if (p->end_time < end_time1)
2665 p->end_time = end_time1;
2668 if (st->duration != AV_NOPTS_VALUE) {
2669 duration1 = av_rescale_q(st->duration, st->time_base,
2672 duration_text = FFMAX(duration_text, duration1);
2674 duration = FFMAX(duration, duration1);
2677 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2678 start_time = start_time_text;
2679 else if (start_time > start_time_text)
2680 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2682 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2683 end_time = end_time_text;
2684 else if (end_time < end_time_text)
2685 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2687 if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2688 duration = duration_text;
2689 else if (duration < duration_text)
2690 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2692 if (start_time != INT64_MAX) {
2693 ic->start_time = start_time;
2694 if (end_time != INT64_MIN) {
2695 if (ic->nb_programs > 1) {
2696 for (i = 0; i < ic->nb_programs; i++) {
2697 p = ic->programs[i];
2698 if (p->start_time != AV_NOPTS_VALUE &&
2699 p->end_time > p->start_time &&
2700 p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2701 duration = FFMAX(duration, p->end_time - p->start_time);
2703 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2704 duration = FFMAX(duration, end_time - start_time);
2708 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2709 ic->duration = duration;
2711 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2712 /* compute the bitrate */
2713 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2714 (double) ic->duration;
2715 if (bitrate >= 0 && bitrate <= INT64_MAX)
2716 ic->bit_rate = bitrate;
2720 static void fill_all_stream_timings(AVFormatContext *ic)
2725 update_stream_timings(ic);
2726 for (i = 0; i < ic->nb_streams; i++) {
2727 st = ic->streams[i];
2728 if (st->start_time == AV_NOPTS_VALUE) {
2729 if (ic->start_time != AV_NOPTS_VALUE)
2730 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2732 if (ic->duration != AV_NOPTS_VALUE)
2733 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2739 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2741 int64_t filesize, duration;
2742 int i, show_warning = 0;
2745 /* if bit_rate is already set, we believe it */
2746 if (ic->bit_rate <= 0) {
2747 int64_t bit_rate = 0;
2748 for (i = 0; i < ic->nb_streams; i++) {
2749 st = ic->streams[i];
2750 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2751 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2752 if (st->codecpar->bit_rate > 0) {
2753 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2757 bit_rate += st->codecpar->bit_rate;
2758 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2759 // If we have a videostream with packets but without a bitrate
2760 // then consider the sum not known
2765 ic->bit_rate = bit_rate;
2768 /* if duration is already set, we believe it */
2769 if (ic->duration == AV_NOPTS_VALUE &&
2770 ic->bit_rate != 0) {
2771 filesize = ic->pb ? avio_size(ic->pb) : 0;
2772 if (filesize > ic->internal->data_offset) {
2773 filesize -= ic->internal->data_offset;
2774 for (i = 0; i < ic->nb_streams; i++) {
2775 st = ic->streams[i];
2776 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2777 && st->duration == AV_NOPTS_VALUE) {
2778 duration = av_rescale(filesize, 8LL * st->time_base.den,
2780 (int64_t) st->time_base.num);
2781 st->duration = duration;
2788 av_log(ic, AV_LOG_WARNING,
2789 "Estimating duration from bitrate, this may be inaccurate\n");
2792 #define DURATION_MAX_READ_SIZE 250000LL
2793 #define DURATION_MAX_RETRY 6
2795 /* only usable for MPEG-PS streams */
2796 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2798 AVPacket *pkt = ic->internal->pkt;
2800 int num, den, read_size, i, ret;
2801 int found_duration = 0;
2803 int64_t filesize, offset, duration;
2806 /* flush packet queue */
2807 flush_packet_queue(ic);
2809 for (i = 0; i < ic->nb_streams; i++) {
2810 st = ic->streams[i];
2811 if (st->start_time == AV_NOPTS_VALUE &&
2812 st->first_dts == AV_NOPTS_VALUE &&
2813 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2814 av_log(ic, AV_LOG_WARNING,
2815 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2818 av_parser_close(st->parser);
2823 if (ic->skip_estimate_duration_from_pts) {
2824 av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2825 goto skip_duration_calc;
2828 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2829 /* estimate the end time (duration) */
2830 /* XXX: may need to support wrapping */
2831 filesize = ic->pb ? avio_size(ic->pb) : 0;
2833 is_end = found_duration;
2834 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2838 avio_seek(ic->pb, offset, SEEK_SET);
2841 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2845 ret = ff_read_packet(ic, pkt);
2846 } while (ret == AVERROR(EAGAIN));
2849 read_size += pkt->size;
2850 st = ic->streams[pkt->stream_index];
2851 if (pkt->pts != AV_NOPTS_VALUE &&
2852 (st->start_time != AV_NOPTS_VALUE ||
2853 st->first_dts != AV_NOPTS_VALUE)) {
2854 if (pkt->duration == 0) {
2855 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2857 pkt->duration = av_rescale_rnd(1,
2858 num * (int64_t) st->time_base.den,
2859 den * (int64_t) st->time_base.num,
2863 duration = pkt->pts + pkt->duration;
2865 if (st->start_time != AV_NOPTS_VALUE)
2866 duration -= st->start_time;
2868 duration -= st->first_dts;
2870 if (st->duration == AV_NOPTS_VALUE || st->internal->info->last_duration<= 0 ||
2871 (st->duration < duration && FFABS(duration - st->internal->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2872 st->duration = duration;
2873 st->internal->info->last_duration = duration;
2876 av_packet_unref(pkt);
2879 /* check if all audio/video streams have valid duration */
2882 for (i = 0; i < ic->nb_streams; i++) {
2883 st = ic->streams[i];
2884 switch (st->codecpar->codec_type) {
2885 case AVMEDIA_TYPE_VIDEO:
2886 case AVMEDIA_TYPE_AUDIO:
2887 if (st->duration == AV_NOPTS_VALUE)
2894 ++retry <= DURATION_MAX_RETRY);
2896 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2898 /* warn about audio/video streams which duration could not be estimated */
2899 for (i = 0; i < ic->nb_streams; i++) {
2900 st = ic->streams[i];
2901 if (st->duration == AV_NOPTS_VALUE) {
2902 switch (st->codecpar->codec_type) {
2903 case AVMEDIA_TYPE_VIDEO:
2904 case AVMEDIA_TYPE_AUDIO:
2905 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2906 av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i);
2908 av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i);
2913 fill_all_stream_timings(ic);
2915 avio_seek(ic->pb, old_offset, SEEK_SET);
2916 for (i = 0; i < ic->nb_streams; i++) {
2919 st = ic->streams[i];
2920 st->cur_dts = st->first_dts;
2921 st->last_IP_pts = AV_NOPTS_VALUE;
2922 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
2923 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2924 st->internal->pts_buffer[j] = AV_NOPTS_VALUE;
2928 /* 1:1 map to AVDurationEstimationMethod */
2929 static const char *const duration_name[] = {
2930 [AVFMT_DURATION_FROM_PTS] = "pts",
2931 [AVFMT_DURATION_FROM_STREAM] = "stream",
2932 [AVFMT_DURATION_FROM_BITRATE] = "bit rate",
2935 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2937 return duration_name[method];
2940 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2944 /* get the file size, if possible */
2945 if (ic->iformat->flags & AVFMT_NOFILE) {
2948 file_size = avio_size(ic->pb);
2949 file_size = FFMAX(0, file_size);
2952 if ((!strcmp(ic->iformat->name, "mpeg") ||
2953 !strcmp(ic->iformat->name, "mpegts")) &&
2954 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2955 /* get accurate estimate from the PTSes */
2956 estimate_timings_from_pts(ic, old_offset);
2957 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2958 } else if (has_duration(ic)) {
2959 /* at least one component has timings - we use them for all
2961 fill_all_stream_timings(ic);
2962 /* nut demuxer estimate the duration from PTS */
2963 if(!strcmp(ic->iformat->name, "nut"))
2964 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2966 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2968 /* less precise: use bitrate info */
2969 estimate_timings_from_bit_rate(ic);
2970 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2972 update_stream_timings(ic);
2974 for (unsigned i = 0; i < ic->nb_streams; i++) {
2975 AVStream *st = ic->streams[i];
2976 if (st->time_base.den)
2977 av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
2978 av_ts2timestr(st->start_time, &st->time_base),
2979 av_ts2timestr(st->duration, &st->time_base));
2981 av_log(ic, AV_LOG_TRACE,
2982 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2983 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2984 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2985 duration_estimate_name(ic->duration_estimation_method),
2986 (int64_t)ic->bit_rate / 1000);
2989 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2991 AVCodecContext *avctx = st->internal->avctx;
2993 #define FAIL(errmsg) do { \
2995 *errmsg_ptr = errmsg; \
2999 if ( avctx->codec_id == AV_CODEC_ID_NONE
3000 && avctx->codec_type != AVMEDIA_TYPE_DATA)
3001 FAIL("unknown codec");
3002 switch (avctx->codec_type) {
3003 case AVMEDIA_TYPE_AUDIO:
3004 if (!avctx->frame_size && determinable_frame_size(avctx))
3005 FAIL("unspecified frame size");
3006 if (st->internal->info->found_decoder >= 0 &&
3007 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
3008 FAIL("unspecified sample format");
3009 if (!avctx->sample_rate)
3010 FAIL("unspecified sample rate");
3011 if (!avctx->channels)
3012 FAIL("unspecified number of channels");
3013 if (st->internal->info->found_decoder >= 0 && !st->internal->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
3014 FAIL("no decodable DTS frames");
3016 case AVMEDIA_TYPE_VIDEO:
3018 FAIL("unspecified size");
3019 if (st->internal->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3020 FAIL("unspecified pixel format");
3021 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3022 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3023 FAIL("no frame in rv30/40 and no sar");
3025 case AVMEDIA_TYPE_SUBTITLE:
3026 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3027 FAIL("unspecified size");
3029 case AVMEDIA_TYPE_DATA:
3030 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3036 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3037 static int try_decode_frame(AVFormatContext *s, AVStream *st,
3038 const AVPacket *avpkt, AVDictionary **options)
3040 AVCodecContext *avctx = st->internal->avctx;
3041 const AVCodec *codec;
3042 int got_picture = 1, ret = 0;
3043 AVFrame *frame = av_frame_alloc();
3044 AVSubtitle subtitle;
3045 AVPacket pkt = *avpkt;
3046 int do_skip_frame = 0;
3047 enum AVDiscard skip_frame;
3050 return AVERROR(ENOMEM);
3052 if (!avcodec_is_open(avctx) &&
3053 st->internal->info->found_decoder <= 0 &&
3054 (st->codecpar->codec_id != -st->internal->info->found_decoder || !st->codecpar->codec_id)) {
3055 AVDictionary *thread_opt = NULL;
3057 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3060 st->internal->info->found_decoder = -st->codecpar->codec_id;
3065 /* Force thread count to 1 since the H.264 decoder will not extract
3066 * SPS and PPS to extradata during multi-threaded decoding. */
3067 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3068 /* Force lowres to 0. The decoder might reduce the video size by the
3069 * lowres factor, and we don't want that propagated to the stream's
3071 av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
3072 if (s->codec_whitelist)
3073 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3074 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3076 av_dict_free(&thread_opt);
3078 st->internal->info->found_decoder = -avctx->codec_id;
3081 st->internal->info->found_decoder = 1;
3082 } else if (!st->internal->info->found_decoder)
3083 st->internal->info->found_decoder = 1;
3085 if (st->internal->info->found_decoder < 0) {
3090 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3092 skip_frame = avctx->skip_frame;
3093 avctx->skip_frame = AVDISCARD_ALL;
3096 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3098 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3099 (!st->codec_info_nb_frames &&
3100 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3102 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3103 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3104 ret = avcodec_send_packet(avctx, &pkt);
3105 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3109 ret = avcodec_receive_frame(avctx, frame);
3112 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3114 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3115 ret = avcodec_decode_subtitle2(avctx, &subtitle,
3116 &got_picture, &pkt);
3118 avsubtitle_free(&subtitle);
3124 st->internal->nb_decoded_frames++;
3129 if (!pkt.data && !got_picture)
3133 if (do_skip_frame) {
3134 avctx->skip_frame = skip_frame;
3137 av_frame_free(&frame);
3141 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3143 while (tags->id != AV_CODEC_ID_NONE) {
3151 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3154 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3155 if (tag == tags[i].tag)
3157 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3158 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3160 return AV_CODEC_ID_NONE;
3163 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3165 if (bps <= 0 || bps > 64)
3166 return AV_CODEC_ID_NONE;
3171 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3173 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3175 return AV_CODEC_ID_NONE;
3180 if (sflags & (1 << (bps - 1))) {
3183 return AV_CODEC_ID_PCM_S8;
3185 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3187 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3189 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3191 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3193 return AV_CODEC_ID_NONE;
3198 return AV_CODEC_ID_PCM_U8;
3200 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3202 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3204 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3206 return AV_CODEC_ID_NONE;
3212 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3215 if (!av_codec_get_tag2(tags, id, &tag))
3220 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3224 for (i = 0; tags && tags[i]; i++) {
3225 const AVCodecTag *codec_tags = tags[i];
3226 while (codec_tags->id != AV_CODEC_ID_NONE) {
3227 if (codec_tags->id == id) {
3228 *tag = codec_tags->tag;
3237 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3240 for (i = 0; tags && tags[i]; i++) {
3241 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3242 if (id != AV_CODEC_ID_NONE)
3245 return AV_CODEC_ID_NONE;
3248 static int chapter_start_cmp(const void *p1, const void *p2)
3250 AVChapter *ch1 = *(AVChapter**)p1;
3251 AVChapter *ch2 = *(AVChapter**)p2;
3252 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
3255 return (ch1 > ch2) - (ch1 < ch2);
3258 static int compute_chapters_end(AVFormatContext *s)
3261 int64_t max_time = 0;
3262 AVChapter **timetable = av_malloc(s->nb_chapters * sizeof(*timetable));
3265 return AVERROR(ENOMEM);
3267 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3268 max_time = s->duration +
3269 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3271 for (i = 0; i < s->nb_chapters; i++)
3272 timetable[i] = s->chapters[i];
3273 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
3275 for (i = 0; i < s->nb_chapters; i++)
3276 if (timetable[i]->end == AV_NOPTS_VALUE) {
3277 AVChapter *ch = timetable[i];
3278 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3282 if (i + 1 < s->nb_chapters) {
3283 AVChapter *ch1 = timetable[i + 1];
3284 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3286 if (next_start > ch->start && next_start < end)
3289 ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3295 static int get_std_framerate(int i)
3298 return (i + 1) * 1001;
3302 return (i + 31) * 1001 * 12;
3306 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3310 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3313 /* Is the time base unreliable?
3314 * This is a heuristic to balance between quick acceptance of the values in
3315 * the headers vs. some extra checks.
3316 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3317 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3318 * And there are "variable" fps files this needs to detect as well. */
3319 static int tb_unreliable(AVCodecContext *c)
3321 if (c->time_base.den >= 101LL * c->time_base.num ||
3322 c->time_base.den < 5LL * c->time_base.num ||
3323 // c->codec_tag == AV_RL32("DIVX") ||
3324 // c->codec_tag == AV_RL32("XVID") ||
3325 c->codec_tag == AV_RL32("mp4v") ||
3326 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3327 c->codec_id == AV_CODEC_ID_GIF ||
3328 c->codec_id == AV_CODEC_ID_HEVC ||
3329 c->codec_id == AV_CODEC_ID_H264)
3334 int ff_alloc_extradata(AVCodecParameters *par, int size)
3336 av_freep(&par->extradata);
3337 par->extradata_size = 0;
3339 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3340 return AVERROR(EINVAL);
3342 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3343 if (!par->extradata)
3344 return AVERROR(ENOMEM);
3346 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3347 par->extradata_size = size;
3352 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3354 int ret = ff_alloc_extradata(par, size);
3357 ret = avio_read(pb, par->extradata, size);
3359 av_freep(&par->extradata);
3360 par->extradata_size = 0;
3361 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3362 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3368 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3371 int64_t last = st->internal->info->last_dts;
3373 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3374 && ts - (uint64_t)last < INT64_MAX) {
3375 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3376 int64_t duration = ts - last;
3378 if (!st->internal->info->duration_error)
3379 st->internal->info->duration_error = av_mallocz(sizeof(st->internal->info->duration_error[0])*2);
3380 if (!st->internal->info->duration_error)
3381 return AVERROR(ENOMEM);
3383 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3384 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3385 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3386 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3387 int framerate = get_std_framerate(i);
3388 double sdts = dts*framerate/(1001*12);
3389 for (j= 0; j<2; j++) {
3390 int64_t ticks = llrint(sdts+j*0.5);
3391 double error= sdts - ticks + j*0.5;
3392 st->internal->info->duration_error[j][0][i] += error;
3393 st->internal->info->duration_error[j][1][i] += error*error;
3397 if (st->internal->info->rfps_duration_sum <= INT64_MAX - duration) {
3398 st->internal->info->duration_count++;
3399 st->internal->info->rfps_duration_sum += duration;
3402 if (st->internal->info->duration_count % 10 == 0) {
3403 int n = st->internal->info->duration_count;
3404 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3405 if (st->internal->info->duration_error[0][1][i] < 1e10) {
3406 double a0 = st->internal->info->duration_error[0][0][i] / n;
3407 double error0 = st->internal->info->duration_error[0][1][i] / n - a0*a0;
3408 double a1 = st->internal->info->duration_error[1][0][i] / n;
3409 double error1 = st->internal->info->duration_error[1][1][i] / n - a1*a1;
3410 if (error0 > 0.04 && error1 > 0.04) {
3411 st->internal->info->duration_error[0][1][i] = 2e10;
3412 st->internal->info->duration_error[1][1][i] = 2e10;
3418 // ignore the first 4 values, they might have some random jitter
3419 if (st->internal->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3420 st->internal->info->duration_gcd = av_gcd(st->internal->info->duration_gcd, duration);
3422 if (ts != AV_NOPTS_VALUE)
3423 st->internal->info->last_dts = ts;
3428 void ff_rfps_calculate(AVFormatContext *ic)
3432 for (i = 0; i < ic->nb_streams; i++) {
3433 AVStream *st = ic->streams[i];
3435 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3437 // the check for tb_unreliable() is not completely correct, since this is not about handling
3438 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3439 // ipmovie.c produces.
3440 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 &&
3441 st->internal->info->duration_gcd < INT64_MAX / st->time_base.num)
3442 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);
3443 if (st->internal->info->duration_count>1 && !st->r_frame_rate.num
3444 && tb_unreliable(st->internal->avctx)) {
3446 double best_error= 0.01;
3447 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3449 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3452 if (st->internal->info->codec_info_duration &&
3453 st->internal->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3455 if (!st->internal->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3458 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))
3461 for (k= 0; k<2; k++) {
3462 int n = st->internal->info->duration_count;
3463 double a= st->internal->info->duration_error[k][0][j] / n;
3464 double error= st->internal->info->duration_error[k][1][j]/n - a*a;
3466 if (error < best_error && best_error> 0.000000001) {
3468 num = get_std_framerate(j);
3471 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3474 // do not increase frame rate by more than 1 % in order to match a standard rate.
3475 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3476 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3478 if ( !st->avg_frame_rate.num
3479 && st->r_frame_rate.num && st->internal->info->rfps_duration_sum
3480 && st->internal->info->codec_info_duration <= 0
3481 && st->internal->info->duration_count > 2
3482 && 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
3484 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3485 st->avg_frame_rate = st->r_frame_rate;
3488 av_freep(&st->internal->info->duration_error);
3489 st->internal->info->last_dts = AV_NOPTS_VALUE;
3490 st->internal->info->duration_count = 0;
3491 st->internal->info->rfps_duration_sum = 0;
3495 static int extract_extradata_check(AVStream *st)
3497 const AVBitStreamFilter *f;
3499 f = av_bsf_get_by_name("extract_extradata");
3504 const enum AVCodecID *ids;
3505 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3506 if (*ids == st->codecpar->codec_id)
3513 static int extract_extradata_init(AVStream *st)
3515 AVStreamInternal *sti = st->internal;
3516 const AVBitStreamFilter *f;
3519 f = av_bsf_get_by_name("extract_extradata");
3523 /* check that the codec id is supported */
3524 ret = extract_extradata_check(st);
3528 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3532 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3537 sti->extract_extradata.bsf->time_base_in = st->time_base;
3539 ret = av_bsf_init(sti->extract_extradata.bsf);
3544 sti->extract_extradata.inited = 1;
3548 av_bsf_free(&sti->extract_extradata.bsf);
3552 static int extract_extradata(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
3554 AVStreamInternal *sti = st->internal;
3555 AVPacket *pkt_ref = s->internal->parse_pkt;
3558 if (!sti->extract_extradata.inited) {
3559 ret = extract_extradata_init(st);
3564 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3567 ret = av_packet_ref(pkt_ref, pkt);
3571 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3573 av_packet_unref(pkt_ref);
3577 while (ret >= 0 && !sti->avctx->extradata) {
3578 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3580 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3585 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
3586 AVPacketSideData *side_data = &pkt_ref->side_data[i];
3587 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
3588 sti->avctx->extradata = side_data->data;
3589 sti->avctx->extradata_size = side_data->size;
3590 side_data->data = NULL;
3591 side_data->size = 0;
3595 av_packet_unref(pkt_ref);
3601 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3605 for (i = 0; i < avctx->nb_coded_side_data; i++) {
3606 const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3608 dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3610 return AVERROR(ENOMEM);
3611 memcpy(dst_data, sd_src->data, sd_src->size);
3616 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3618 int i, count = 0, ret = 0, j;
3621 AVCodecContext *avctx;
3622 AVPacket *pkt1 = ic->internal->pkt;
3623 int64_t old_offset = avio_tell(ic->pb);
3624 // new streams might appear, no options for those
3625 int orig_nb_streams = ic->nb_streams;
3627 int64_t max_analyze_duration = ic->max_analyze_duration;
3628 int64_t max_stream_analyze_duration;
3629 int64_t max_subtitle_analyze_duration;
3630 int64_t probesize = ic->probesize;
3631 int eof_reached = 0;
3632 int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3634 flush_codecs = probesize > 0;
3636 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3638 max_stream_analyze_duration = max_analyze_duration;
3639 max_subtitle_analyze_duration = max_analyze_duration;
3640 if (!max_analyze_duration) {
3641 max_stream_analyze_duration =
3642 max_analyze_duration = 5*AV_TIME_BASE;
3643 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3644 if (!strcmp(ic->iformat->name, "flv"))
3645 max_stream_analyze_duration = 90*AV_TIME_BASE;
3646 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3647 max_stream_analyze_duration = 7*AV_TIME_BASE;
3651 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3652 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3654 for (i = 0; i < ic->nb_streams; i++) {
3655 const AVCodec *codec;
3656 AVDictionary *thread_opt = NULL;
3657 st = ic->streams[i];
3658 avctx = st->internal->avctx;
3660 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3661 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3662 /* if (!st->time_base.num)
3664 if (!avctx->time_base.num)
3665 avctx->time_base = st->time_base;
3668 /* check if the caller has overridden the codec id */
3669 #if FF_API_LAVF_AVCTX
3670 FF_DISABLE_DEPRECATION_WARNINGS
3671 if (st->codec->codec_id != st->internal->orig_codec_id) {
3672 st->codecpar->codec_id = st->codec->codec_id;
3673 st->codecpar->codec_type = st->codec->codec_type;
3674 st->internal->orig_codec_id = st->codec->codec_id;
3676 FF_ENABLE_DEPRECATION_WARNINGS
3678 // only for the split stuff
3679 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->internal->request_probe <= 0) {
3680 st->parser = av_parser_init(st->codecpar->codec_id);
3682 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3683 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3684 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3685 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3687 } else if (st->need_parsing) {
3688 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3689 "%s, packets or times may be invalid.\n",
3690 avcodec_get_name(st->codecpar->codec_id));
3694 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3695 st->internal->orig_codec_id = st->codecpar->codec_id;
3697 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3699 goto find_stream_info_err;
3700 if (st->internal->request_probe <= 0)
3701 st->internal->avctx_inited = 1;
3703 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3705 /* Force thread count to 1 since the H.264 decoder will not extract
3706 * SPS and PPS to extradata during multi-threaded decoding. */
3707 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3708 /* Force lowres to 0. The decoder might reduce the video size by the
3709 * lowres factor, and we don't want that propagated to the stream's
3711 av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
3713 if (ic->codec_whitelist)
3714 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3716 // Try to just open decoders, in case this is enough to get parameters.
3717 // Also ensure that subtitle_header is properly set.
3718 if (!has_codec_parameters(st, NULL) && st->internal->request_probe <= 0 ||
3719 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3720 if (codec && !avctx->codec)
3721 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3722 av_log(ic, AV_LOG_WARNING,
3723 "Failed to open codec in %s\n",__FUNCTION__);
3726 av_dict_free(&thread_opt);
3729 for (i = 0; i < ic->nb_streams; i++) {
3730 #if FF_API_R_FRAME_RATE
3731 ic->streams[i]->internal->info->last_dts = AV_NOPTS_VALUE;
3733 ic->streams[i]->internal->info->fps_first_dts = AV_NOPTS_VALUE;
3734 ic->streams[i]->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3739 const AVPacket *pkt;
3740 int analyzed_all_streams;
3741 if (ff_check_interrupt(&ic->interrupt_callback)) {
3743 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3747 /* check if one codec still needs to be handled */
3748 for (i = 0; i < ic->nb_streams; i++) {
3749 int fps_analyze_framecount = 20;
3752 st = ic->streams[i];
3753 if (!has_codec_parameters(st, NULL))
3755 /* If the timebase is coarse (like the usual millisecond precision
3756 * of mkv), we need to analyze more frames to reliably arrive at
3757 * the correct fps. */
3758 if (av_q2d(st->time_base) > 0.0005)
3759 fps_analyze_framecount *= 2;
3760 if (!tb_unreliable(st->internal->avctx))
3761 fps_analyze_framecount = 0;
3762 if (ic->fps_probe_size >= 0)
3763 fps_analyze_framecount = ic->fps_probe_size;
3764 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3765 fps_analyze_framecount = 0;
3766 /* variable fps and no guess at the real fps */
3767 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3768 st->internal->info->codec_info_duration_fields/2 :
3769 st->internal->info->duration_count;
3770 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3771 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3772 if (count < fps_analyze_framecount)
3775 // Look at the first 3 frames if there is evidence of frame delay
3776 // but the decoder delay is not set.
3777 if (st->internal->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3779 if (!st->internal->avctx->extradata &&
3780 (!st->internal->extract_extradata.inited ||
3781 st->internal->extract_extradata.bsf) &&
3782 extract_extradata_check(st))
3784 if (st->first_dts == AV_NOPTS_VALUE &&
3785 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3786 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3787 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3788 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3791 analyzed_all_streams = 0;
3792 if (!missing_streams || !*missing_streams)
3793 if (i == ic->nb_streams) {
3794 analyzed_all_streams = 1;
3795 /* NOTE: If the format has no header, then we need to read some
3796 * packets to get most of the streams, so we cannot stop here. */
3797 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3798 /* If we found the info for all the codecs, we can stop. */
3800 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3805 /* We did not get all the codec info, but we read too much data. */
3806 if (read_size >= probesize) {
3808 av_log(ic, AV_LOG_DEBUG,
3809 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3810 for (i = 0; i < ic->nb_streams; i++)
3811 if (!ic->streams[i]->r_frame_rate.num &&
3812 ic->streams[i]->internal->info->duration_count <= 1 &&
3813 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3814 strcmp(ic->iformat->name, "image2"))
3815 av_log(ic, AV_LOG_WARNING,
3816 "Stream #%d: not enough frames to estimate rate; "
3817 "consider increasing probesize\n", i);
3821 /* NOTE: A new stream can be added there if no header in file
3822 * (AVFMTCTX_NOHEADER). */
3823 ret = read_frame_internal(ic, pkt1);
3824 if (ret == AVERROR(EAGAIN))
3833 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3834 ret = avpriv_packet_list_put(&ic->internal->packet_buffer,
3835 &ic->internal->packet_buffer_end,
3838 goto unref_then_goto_end;
3840 pkt = &ic->internal->packet_buffer_end->pkt;
3845 st = ic->streams[pkt->stream_index];
3846 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3847 read_size += pkt->size;
3849 avctx = st->internal->avctx;
3850 if (!st->internal->avctx_inited) {
3851 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3853 goto unref_then_goto_end;
3854 st->internal->avctx_inited = 1;
3857 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3858 /* check for non-increasing dts */
3859 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3860 st->internal->info->fps_last_dts >= pkt->dts) {
3861 av_log(ic, AV_LOG_DEBUG,
3862 "Non-increasing DTS in stream %d: packet %d with DTS "
3863 "%"PRId64", packet %d with DTS %"PRId64"\n",
3864 st->index, st->internal->info->fps_last_dts_idx,
3865 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3867 st->internal->info->fps_first_dts =
3868 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3870 /* Check for a discontinuity in dts. If the difference in dts
3871 * is more than 1000 times the average packet duration in the
3872 * sequence, we treat it as a discontinuity. */
3873 if (st->internal->info->fps_last_dts != AV_NOPTS_VALUE &&
3874 st->internal->info->fps_last_dts_idx > st->internal->info->fps_first_dts_idx &&
3875 (pkt->dts - (uint64_t)st->internal->info->fps_last_dts) / 1000 >
3876 (st->internal->info->fps_last_dts - (uint64_t)st->internal->info->fps_first_dts) /
3877 (st->internal->info->fps_last_dts_idx - st->internal->info->fps_first_dts_idx)) {
3878 av_log(ic, AV_LOG_WARNING,
3879 "DTS discontinuity in stream %d: packet %d with DTS "
3880 "%"PRId64", packet %d with DTS %"PRId64"\n",
3881 st->index, st->internal->info->fps_last_dts_idx,
3882 st->internal->info->fps_last_dts, st->codec_info_nb_frames,
3884 st->internal->info->fps_first_dts =
3885 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
3888 /* update stored dts values */
3889 if (st->internal->info->fps_first_dts == AV_NOPTS_VALUE) {
3890 st->internal->info->fps_first_dts = pkt->dts;
3891 st->internal->info->fps_first_dts_idx = st->codec_info_nb_frames;
3893 st->internal->info->fps_last_dts = pkt->dts;
3894 st->internal->info->fps_last_dts_idx = st->codec_info_nb_frames;
3896 if (st->codec_info_nb_frames>1) {
3900 if (st->time_base.den > 0)
3901 t = av_rescale_q(st->internal->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3902 if (st->avg_frame_rate.num > 0)
3903 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3906 && st->codec_info_nb_frames>30
3907 && st->internal->info->fps_first_dts != AV_NOPTS_VALUE
3908 && st->internal->info->fps_last_dts != AV_NOPTS_VALUE) {
3909 int64_t dur = av_sat_sub64(st->internal->info->fps_last_dts, st->internal->info->fps_first_dts);
3910 t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q));
3913 if (analyzed_all_streams) limit = max_analyze_duration;
3914 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3915 else limit = max_stream_analyze_duration;
3918 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3920 t, pkt->stream_index);
3921 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3922 av_packet_unref(pkt1);
3925 if (pkt->duration) {
3926 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3927 st->internal->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->internal->info->codec_info_duration + pkt->duration);
3929 st->internal->info->codec_info_duration += pkt->duration;
3930 st->internal->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3933 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3934 #if FF_API_R_FRAME_RATE
3935 ff_rfps_add_frame(ic, st, pkt->dts);
3937 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3938 st->internal->info->frame_delay_evidence = 1;
3940 if (!st->internal->avctx->extradata) {
3941 ret = extract_extradata(ic, st, pkt);
3943 goto unref_then_goto_end;
3946 /* If still no information, we try to open the codec and to
3947 * decompress the frame. We try to avoid that in most cases as
3948 * it takes longer and uses more memory. For MPEG-4, we need to
3949 * decompress for QuickTime.
3951 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3952 * least one frame of codec data, this makes sure the codec initializes
3953 * the channel configuration and does not only trust the values from
3955 try_decode_frame(ic, st, pkt,
3956 (options && i < orig_nb_streams) ? &options[i] : NULL);
3958 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3959 av_packet_unref(pkt1);
3961 st->codec_info_nb_frames++;
3967 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3968 st = ic->streams[stream_index];
3969 avctx = st->internal->avctx;
3970 if (!has_codec_parameters(st, NULL)) {
3971 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3972 if (codec && !avctx->codec) {
3973 AVDictionary *opts = NULL;
3974 if (ic->codec_whitelist)
3975 av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3976 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3977 av_log(ic, AV_LOG_WARNING,
3978 "Failed to open codec in %s\n",__FUNCTION__);
3979 av_dict_free(&opts);
3983 // EOF already reached while reading the stream above.
3984 // So continue with reoordering DTS with whatever delay we have.
3985 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3986 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3992 AVPacket *empty_pkt = ic->internal->pkt;
3994 av_packet_unref(empty_pkt);
3996 for (i = 0; i < ic->nb_streams; i++) {
3998 st = ic->streams[i];
4000 /* flush the decoders */
4001 if (st->internal->info->found_decoder == 1) {
4003 err = try_decode_frame(ic, st, empty_pkt,
4004 (options && i < orig_nb_streams)
4005 ? &options[i] : NULL);
4006 } while (err > 0 && !has_codec_parameters(st, NULL));
4009 av_log(ic, AV_LOG_INFO,
4010 "decoding for stream %d failed\n", st->index);
4016 ff_rfps_calculate(ic);
4018 for (i = 0; i < ic->nb_streams; i++) {
4019 st = ic->streams[i];
4020 avctx = st->internal->avctx;
4021 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4022 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4023 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4024 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4025 avctx->codec_tag= tag;
4028 /* estimate average framerate if not set by demuxer */
4029 if (st->internal->info->codec_info_duration_fields &&
4030 !st->avg_frame_rate.num &&
4031 st->internal->info->codec_info_duration) {
4033 double best_error = 0.01;
4034 AVRational codec_frame_rate = avctx->framerate;
4036 if (st->internal->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
4037 st->internal->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4038 st->internal->info->codec_info_duration < 0)
4040 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4041 st->internal->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4042 st->internal->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4044 /* Round guessed framerate to a "standard" framerate if it's
4045 * within 1% of the original estimate. */
4046 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4047 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4048 double error = fabs(av_q2d(st->avg_frame_rate) /
4049 av_q2d(std_fps) - 1);
4051 if (error < best_error) {
4053 best_fps = std_fps.num;
4056 if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4057 error = fabs(av_q2d(codec_frame_rate) /
4058 av_q2d(std_fps) - 1);
4059 if (error < best_error) {
4061 best_fps = std_fps.num;
4066 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4067 best_fps, 12 * 1001, INT_MAX);
4070 if (!st->r_frame_rate.num) {
4071 if ( avctx->time_base.den * (int64_t) st->time_base.num
4072 <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4073 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4074 avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4076 st->r_frame_rate.num = st->time_base.den;
4077 st->r_frame_rate.den = st->time_base.num;
4080 if (st->internal->display_aspect_ratio.num && st->internal->display_aspect_ratio.den) {
4081 AVRational hw_ratio = { avctx->height, avctx->width };
4082 st->sample_aspect_ratio = av_mul_q(st->internal->display_aspect_ratio,
4085 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4086 if (!avctx->bits_per_coded_sample)
4087 avctx->bits_per_coded_sample =
4088 av_get_bits_per_sample(avctx->codec_id);
4089 // set stream disposition based on audio service type
4090 switch (avctx->audio_service_type) {
4091 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4092 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4094 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4095 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4097 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4098 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4100 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4101 st->disposition = AV_DISPOSITION_COMMENT;
4103 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4104 st->disposition = AV_DISPOSITION_KARAOKE;
4111 estimate_timings(ic, old_offset);
4113 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4115 if (ret >= 0 && ic->nb_streams)
4116 /* We could not have all the codec parameters before EOF. */
4118 for (i = 0; i < ic->nb_streams; i++) {
4120 st = ic->streams[i];
4122 /* if no packet was ever seen, update context now for has_codec_parameters */
4123 if (!st->internal->avctx_inited) {
4124 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4125 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4126 st->codecpar->format = st->internal->avctx->sample_fmt;
4127 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4129 goto find_stream_info_err;
4131 if (!has_codec_parameters(st, &errmsg)) {
4133 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4134 av_log(ic, AV_LOG_WARNING,
4135 "Could not find codec parameters for stream %d (%s): %s\n"
4136 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4137 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4143 ret = compute_chapters_end(ic);
4145 goto find_stream_info_err;
4147 /* update the stream parameters from the internal codec contexts */
4148 for (i = 0; i < ic->nb_streams; i++) {
4149 st = ic->streams[i];
4151 if (st->internal->avctx_inited) {
4152 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4154 goto find_stream_info_err;
4155 ret = add_coded_side_data(st, st->internal->avctx);
4157 goto find_stream_info_err;
4160 #if FF_API_LAVF_AVCTX
4161 FF_DISABLE_DEPRECATION_WARNINGS
4162 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4164 goto find_stream_info_err;
4166 // The old API (AVStream.codec) "requires" the resolution to be adjusted
4167 // by the lowres factor.
4168 if (st->internal->avctx->lowres && st->internal->avctx->width) {
4169 st->codec->lowres = st->internal->avctx->lowres;
4170 st->codec->width = st->internal->avctx->width;
4171 st->codec->height = st->internal->avctx->height;
4174 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4175 st->codec->time_base = st->internal->avctx->time_base;
4176 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4178 st->codec->framerate = st->avg_frame_rate;
4180 if (st->internal->avctx->subtitle_header) {
4181 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4182 if (!st->codec->subtitle_header)
4183 goto find_stream_info_err;
4184 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4185 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4186 st->codec->subtitle_header_size);
4189 // Fields unavailable in AVCodecParameters
4190 st->codec->coded_width = st->internal->avctx->coded_width;
4191 st->codec->coded_height = st->internal->avctx->coded_height;
4192 st->codec->properties = st->internal->avctx->properties;
4193 FF_ENABLE_DEPRECATION_WARNINGS
4196 st->internal->avctx_inited = 0;
4199 find_stream_info_err:
4200 for (i = 0; i < ic->nb_streams; i++) {
4201 st = ic->streams[i];
4202 if (st->internal->info)
4203 av_freep(&st->internal->info->duration_error);
4204 avcodec_close(ic->streams[i]->internal->avctx);
4205 av_freep(&ic->streams[i]->internal->info);
4206 av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4209 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4210 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4213 unref_then_goto_end:
4214 av_packet_unref(pkt1);
4215 goto find_stream_info_err;
4218 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4222 for (i = 0; i < ic->nb_programs; i++) {
4223 if (ic->programs[i] == last) {
4227 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4228 if (ic->programs[i]->stream_index[j] == s)
4229 return ic->programs[i];
4235 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4236 int wanted_stream_nb, int related_stream,
4237 AVCodec **decoder_ret, int flags)
4239 int i, nb_streams = ic->nb_streams;
4240 int ret = AVERROR_STREAM_NOT_FOUND;
4241 int best_count = -1, best_multiframe = -1, best_disposition = -1;
4242 int count, multiframe, disposition;
4243 int64_t best_bitrate = -1;
4245 unsigned *program = NULL;
4246 const AVCodec *decoder = NULL, *best_decoder = NULL;
4248 if (related_stream >= 0 && wanted_stream_nb < 0) {
4249 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4251 program = p->stream_index;
4252 nb_streams = p->nb_stream_indexes;
4255 for (i = 0; i < nb_streams; i++) {
4256 int real_stream_index = program ? program[i] : i;
4257 AVStream *st = ic->streams[real_stream_index];
4258 AVCodecParameters *par = st->codecpar;
4259 if (par->codec_type != type)
4261 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4263 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4266 decoder = find_decoder(ic, st, par->codec_id);
4269 ret = AVERROR_DECODER_NOT_FOUND;
4273 disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4274 + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4275 count = st->codec_info_nb_frames;
4276 bitrate = par->bit_rate;
4277 multiframe = FFMIN(5, count);
4278 if ((best_disposition > disposition) ||
4279 (best_disposition == disposition && best_multiframe > multiframe) ||
4280 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate > bitrate) ||
4281 (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4283 best_disposition = disposition;
4285 best_bitrate = bitrate;
4286 best_multiframe = multiframe;
4287 ret = real_stream_index;
4288 best_decoder = decoder;
4289 if (program && i == nb_streams - 1 && ret < 0) {
4291 nb_streams = ic->nb_streams;
4292 /* no related stream found, try again with everything */
4297 *decoder_ret = (AVCodec*)best_decoder;
4301 /*******************************************************/
4303 int av_read_play(AVFormatContext *s)
4305 if (s->iformat->read_play)
4306 return s->iformat->read_play(s);
4308 return avio_pause(s->pb, 0);
4309 return AVERROR(ENOSYS);
4312 int av_read_pause(AVFormatContext *s)
4314 if (s->iformat->read_pause)
4315 return s->iformat->read_pause(s);
4317 return avio_pause(s->pb, 1);
4318 return AVERROR(ENOSYS);
4321 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4326 dst->time_base = src->time_base;
4327 dst->nb_frames = src->nb_frames;
4328 dst->disposition = src->disposition;
4329 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4330 dst->avg_frame_rate = src->avg_frame_rate;
4331 dst->r_frame_rate = src->r_frame_rate;
4333 av_dict_free(&dst->metadata);
4334 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4338 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4342 /* Free existing side data*/
4343 for (i = 0; i < dst->nb_side_data; i++)
4344 av_free(dst->side_data[i].data);
4345 av_freep(&dst->side_data);
4346 dst->nb_side_data = 0;
4348 /* Copy side data if present */
4349 if (src->nb_side_data) {
4350 dst->side_data = av_mallocz_array(src->nb_side_data,
4351 sizeof(AVPacketSideData));
4352 if (!dst->side_data)
4353 return AVERROR(ENOMEM);
4354 dst->nb_side_data = src->nb_side_data;
4356 for (i = 0; i < src->nb_side_data; i++) {
4357 uint8_t *data = av_memdup(src->side_data[i].data,
4358 src->side_data[i].size);
4360 return AVERROR(ENOMEM);
4361 dst->side_data[i].type = src->side_data[i].type;
4362 dst->side_data[i].size = src->side_data[i].size;
4363 dst->side_data[i].data = data;
4370 static void free_stream(AVStream **pst)
4372 AVStream *st = *pst;
4378 for (i = 0; i < st->nb_side_data; i++)
4379 av_freep(&st->side_data[i].data);
4380 av_freep(&st->side_data);
4383 av_parser_close(st->parser);
4385 if (st->attached_pic.data)
4386 av_packet_unref(&st->attached_pic);
4389 avcodec_free_context(&st->internal->avctx);
4390 av_bsf_free(&st->internal->bsfc);
4391 av_freep(&st->internal->priv_pts);
4392 av_freep(&st->internal->index_entries);
4393 av_freep(&st->internal->probe_data.buf);
4395 av_bsf_free(&st->internal->extract_extradata.bsf);
4397 if (st->internal->info)
4398 av_freep(&st->internal->info->duration_error);
4399 av_freep(&st->internal->info);
4401 av_freep(&st->internal);
4403 av_dict_free(&st->metadata);
4404 avcodec_parameters_free(&st->codecpar);
4405 #if FF_API_LAVF_AVCTX
4406 FF_DISABLE_DEPRECATION_WARNINGS
4407 avcodec_free_context(&st->codec);
4408 FF_ENABLE_DEPRECATION_WARNINGS
4410 av_freep(&st->priv_data);
4415 void ff_free_stream(AVFormatContext *s, AVStream *st)
4417 av_assert0(s->nb_streams>0);
4418 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4420 free_stream(&s->streams[ --s->nb_streams ]);
4423 void avformat_free_context(AVFormatContext *s)
4430 if (s->oformat && s->oformat->deinit && s->internal->initialized)
4431 s->oformat->deinit(s);
4434 if (s->iformat && s->iformat->priv_class && s->priv_data)
4435 av_opt_free(s->priv_data);
4436 if (s->oformat && s->oformat->priv_class && s->priv_data)
4437 av_opt_free(s->priv_data);
4439 for (i = 0; i < s->nb_streams; i++)
4440 free_stream(&s->streams[i]);
4443 for (i = 0; i < s->nb_programs; i++) {
4444 av_dict_free(&s->programs[i]->metadata);
4445 av_freep(&s->programs[i]->stream_index);
4446 av_freep(&s->programs[i]);
4450 av_freep(&s->programs);
4451 av_freep(&s->priv_data);
4452 while (s->nb_chapters--) {
4453 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4454 av_freep(&s->chapters[s->nb_chapters]);
4456 av_freep(&s->chapters);
4457 av_dict_free(&s->metadata);
4458 av_dict_free(&s->internal->id3v2_meta);
4459 av_packet_free(&s->internal->pkt);
4460 av_packet_free(&s->internal->parse_pkt);
4461 av_freep(&s->streams);
4462 flush_packet_queue(s);
4463 av_freep(&s->internal);
4468 void avformat_close_input(AVFormatContext **ps)
4479 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4480 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4483 flush_packet_queue(s);
4486 if (s->iformat->read_close)
4487 s->iformat->read_close(s);
4489 avformat_free_context(s);
4496 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4502 if (s->nb_streams >= s->max_streams) {
4503 av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
4504 " (%d), see the documentation if you wish to increase it\n",
4508 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4511 s->streams = streams;
4513 st = av_mallocz(sizeof(AVStream));
4517 #if FF_API_LAVF_AVCTX
4518 FF_DISABLE_DEPRECATION_WARNINGS
4519 st->codec = avcodec_alloc_context3(c);
4524 FF_ENABLE_DEPRECATION_WARNINGS
4527 st->internal = av_mallocz(sizeof(*st->internal));
4531 st->internal->info = av_mallocz(sizeof(*st->internal->info));
4532 if (!st->internal->info)
4534 st->internal->info->last_dts = AV_NOPTS_VALUE;
4536 st->codecpar = avcodec_parameters_alloc();
4540 st->internal->avctx = avcodec_alloc_context3(NULL);
4541 if (!st->internal->avctx)
4545 #if FF_API_LAVF_AVCTX
4546 FF_DISABLE_DEPRECATION_WARNINGS
4547 /* no default bitrate if decoding */
4548 st->codec->bit_rate = 0;
4549 FF_ENABLE_DEPRECATION_WARNINGS
4552 /* default pts setting is MPEG-like */
4553 avpriv_set_pts_info(st, 33, 1, 90000);
4554 /* we set the current DTS to 0 so that formats without any timestamps
4555 * but durations get some timestamps, formats with some unknown
4556 * timestamps have their first few packets buffered and the
4557 * timestamps corrected before they are returned to the user */
4558 st->cur_dts = RELATIVE_TS_BASE;
4560 st->cur_dts = AV_NOPTS_VALUE;
4563 st->index = s->nb_streams;
4564 st->start_time = AV_NOPTS_VALUE;
4565 st->duration = AV_NOPTS_VALUE;
4566 st->first_dts = AV_NOPTS_VALUE;
4567 st->probe_packets = s->max_probe_packets;
4568 st->internal->pts_wrap_reference = AV_NOPTS_VALUE;
4569 st->internal->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4571 st->last_IP_pts = AV_NOPTS_VALUE;
4572 st->internal->last_dts_for_order_check = AV_NOPTS_VALUE;
4573 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4574 st->internal->pts_buffer[i] = AV_NOPTS_VALUE;
4576 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4578 #if FF_API_R_FRAME_RATE
4579 st->internal->info->last_dts = AV_NOPTS_VALUE;
4581 st->internal->info->fps_first_dts = AV_NOPTS_VALUE;
4582 st->internal->info->fps_last_dts = AV_NOPTS_VALUE;
4584 st->internal->inject_global_side_data = s->internal->inject_global_side_data;
4586 st->internal->need_context_update = 1;
4588 s->streams[s->nb_streams++] = st;
4595 AVProgram *av_new_program(AVFormatContext *ac, int id)
4597 AVProgram *program = NULL;
4600 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4602 for (i = 0; i < ac->nb_programs; i++)
4603 if (ac->programs[i]->id == id)
4604 program = ac->programs[i];
4607 program = av_mallocz(sizeof(AVProgram));
4610 ret = av_dynarray_add_nofree(&ac->programs, &ac->nb_programs, program);
4615 program->discard = AVDISCARD_NONE;
4616 program->pmt_version = -1;
4618 program->pts_wrap_reference = AV_NOPTS_VALUE;
4619 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4620 program->start_time =
4621 program->end_time = AV_NOPTS_VALUE;
4626 #if FF_API_CHAPTER_ID_INT
4627 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4629 AVChapter *avpriv_new_chapter(AVFormatContext *s, int64_t id, AVRational time_base,
4631 int64_t start, int64_t end, const char *title)
4633 AVChapter *chapter = NULL;
4636 if (end != AV_NOPTS_VALUE && start > end) {
4637 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4641 if (!s->nb_chapters) {
4642 s->internal->chapter_ids_monotonic = 1;
4643 } else if (!s->internal->chapter_ids_monotonic || s->chapters[s->nb_chapters-1]->id >= id) {
4644 s->internal->chapter_ids_monotonic = 0;
4645 for (i = 0; i < s->nb_chapters; i++)
4646 if (s->chapters[i]->id == id)
4647 chapter = s->chapters[i];
4651 chapter = av_mallocz(sizeof(AVChapter));
4654 ret = av_dynarray_add_nofree(&s->chapters, &s->nb_chapters, chapter);
4660 av_dict_set(&chapter->metadata, "title", title, 0);
4662 chapter->time_base = time_base;
4663 chapter->start = start;
4669 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4672 AVProgram *program = NULL;
4675 if (idx >= ac->nb_streams) {
4676 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4680 for (i = 0; i < ac->nb_programs; i++) {
4681 if (ac->programs[i]->id != progid)
4683 program = ac->programs[i];
4684 for (j = 0; j < program->nb_stream_indexes; j++)
4685 if (program->stream_index[j] == idx)
4688 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4691 program->stream_index = tmp;
4692 program->stream_index[program->nb_stream_indexes++] = idx;
4697 uint64_t ff_ntp_time(void)
4699 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4702 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4704 uint64_t ntp_ts, frac_part, sec;
4707 //current ntp time in seconds and micro seconds
4708 sec = ntp_time_us / 1000000;
4709 usec = ntp_time_us % 1000000;
4711 //encoding in ntp timestamp format
4712 frac_part = usec * 0xFFFFFFFFULL;
4713 frac_part /= 1000000;
4715 if (sec > 0xFFFFFFFFULL)
4716 av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4719 ntp_ts |= frac_part;
4724 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
4726 uint64_t sec = ntp_ts >> 32;
4727 uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
4728 uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
4730 return (sec * 1000000) + usec;
4733 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4736 char *q, buf1[20], c;
4737 int nd, len, percentd_found;
4749 while (av_isdigit(*p)) {
4750 if (nd >= INT_MAX / 10 - 255)
4752 nd = nd * 10 + *p++ - '0';
4755 } while (av_isdigit(c));
4761 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4766 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4768 if ((q - buf + len) > buf_size - 1)
4770 memcpy(q, buf1, len);
4778 if ((q - buf) < buf_size - 1)
4782 if (!percentd_found)
4791 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4793 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4796 void av_url_split(char *proto, int proto_size,
4797 char *authorization, int authorization_size,
4798 char *hostname, int hostname_size,
4799 int *port_ptr, char *path, int path_size, const char *url)
4801 const char *p, *ls, *at, *at2, *col, *brk;
4807 if (authorization_size > 0)
4808 authorization[0] = 0;
4809 if (hostname_size > 0)
4814 /* parse protocol */
4815 if ((p = strchr(url, ':'))) {
4816 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4823 /* no protocol means plain filename */
4824 av_strlcpy(path, url, path_size);
4828 /* separate path from hostname */
4829 ls = p + strcspn(p, "/?#");
4830 av_strlcpy(path, ls, path_size);
4832 /* the rest is hostname, use that to parse auth/port */
4834 /* authorization (user[:pass]@hostname) */
4836 while ((at = strchr(p, '@')) && at < ls) {
4837 av_strlcpy(authorization, at2,
4838 FFMIN(authorization_size, at + 1 - at2));
4839 p = at + 1; /* skip '@' */
4842 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4844 av_strlcpy(hostname, p + 1,
4845 FFMIN(hostname_size, brk - p));
4846 if (brk[1] == ':' && port_ptr)
4847 *port_ptr = atoi(brk + 2);
4848 } else if ((col = strchr(p, ':')) && col < ls) {
4849 av_strlcpy(hostname, p,
4850 FFMIN(col + 1 - p, hostname_size));
4852 *port_ptr = atoi(col + 1);
4854 av_strlcpy(hostname, p,
4855 FFMIN(ls + 1 - p, hostname_size));
4859 int ff_mkdir_p(const char *path)
4862 char *temp = av_strdup(path);
4866 if (!path || !temp) {
4870 if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4872 } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4876 for ( ; *pos != '\0'; ++pos) {
4877 if (*pos == '/' || *pos == '\\') {
4880 ret = mkdir(temp, 0755);
4885 if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4886 ret = mkdir(temp, 0755);
4893 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4896 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4899 'C', 'D', 'E', 'F' };
4900 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4903 'c', 'd', 'e', 'f' };
4904 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4906 for (i = 0; i < s; i++) {
4907 buff[i * 2] = hex_table[src[i] >> 4];
4908 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4914 int ff_hex_to_data(uint8_t *data, const char *p)
4921 p += strspn(p, SPACE_CHARS);
4924 c = av_toupper((unsigned char) *p++);
4925 if (c >= '0' && c <= '9')
4927 else if (c >= 'A' && c <= 'F')
4942 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4943 unsigned int pts_num, unsigned int pts_den)
4946 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4947 if (new_tb.num != pts_num)
4948 av_log(NULL, AV_LOG_DEBUG,
4949 "st:%d removing common factor %d from timebase\n",
4950 s->index, pts_num / new_tb.num);
4952 av_log(NULL, AV_LOG_WARNING,
4953 "st:%d has too large timebase, reducing\n", s->index);
4955 if (new_tb.num <= 0 || new_tb.den <= 0) {
4956 av_log(NULL, AV_LOG_ERROR,
4957 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4958 new_tb.num, new_tb.den,
4962 s->time_base = new_tb;
4963 #if FF_API_LAVF_AVCTX
4964 FF_DISABLE_DEPRECATION_WARNINGS
4965 s->codec->pkt_timebase = new_tb;
4966 FF_ENABLE_DEPRECATION_WARNINGS
4968 s->internal->avctx->pkt_timebase = new_tb;
4969 s->pts_wrap_bits = pts_wrap_bits;
4972 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4975 const char *ptr = str;
4977 /* Parse key=value pairs. */
4980 char *dest = NULL, *dest_end;
4981 int key_len, dest_len = 0;
4983 /* Skip whitespace and potential commas. */
4984 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4991 if (!(ptr = strchr(key, '=')))
4994 key_len = ptr - key;
4996 callback_get_buf(context, key, key_len, &dest, &dest_len);
4997 dest_end = dest + dest_len - 1;
5001 while (*ptr && *ptr != '\"') {
5005 if (dest && dest < dest_end)
5009 if (dest && dest < dest_end)
5017 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5018 if (dest && dest < dest_end)
5026 int ff_find_stream_index(AVFormatContext *s, int id)
5029 for (i = 0; i < s->nb_streams; i++)
5030 if (s->streams[i]->id == id)
5035 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5039 unsigned int codec_tag;
5040 if (ofmt->query_codec)
5041 return ofmt->query_codec(codec_id, std_compliance);
5042 else if (ofmt->codec_tag)
5043 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5044 else if (codec_id == ofmt->video_codec ||
5045 codec_id == ofmt->audio_codec ||
5046 codec_id == ofmt->subtitle_codec ||
5047 codec_id == ofmt->data_codec)
5050 return AVERROR_PATCHWELCOME;
5053 int avformat_network_init(void)
5057 if ((ret = ff_network_init()) < 0)
5059 if ((ret = ff_tls_init()) < 0)
5065 int avformat_network_deinit(void)
5074 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5075 uint64_t channel_layout, int32_t sample_rate,
5076 int32_t width, int32_t height)
5082 return AVERROR(EINVAL);
5085 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5087 if (channel_layout) {
5089 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5093 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5095 if (width || height) {
5097 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5099 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5101 return AVERROR(ENOMEM);
5102 bytestream_put_le32(&data, flags);
5104 bytestream_put_le32(&data, channels);
5106 bytestream_put_le64(&data, channel_layout);
5108 bytestream_put_le32(&data, sample_rate);
5109 if (width || height) {
5110 bytestream_put_le32(&data, width);
5111 bytestream_put_le32(&data, height);
5116 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5118 AVRational undef = {0, 1};
5119 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5120 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5121 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
5123 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5124 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
5125 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5126 stream_sample_aspect_ratio = undef;
5128 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5129 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
5130 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5131 frame_sample_aspect_ratio = undef;
5133 if (stream_sample_aspect_ratio.num)
5134 return stream_sample_aspect_ratio;
5136 return frame_sample_aspect_ratio;
5139 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5141 AVRational fr = st->r_frame_rate;
5142 AVRational codec_fr = st->internal->avctx->framerate;
5143 AVRational avg_fr = st->avg_frame_rate;
5145 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5146 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5151 if (st->internal->avctx->ticks_per_frame > 1) {
5152 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
5153 (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))
5161 * Matches a stream specifier (but ignores requested index).
5163 * @param indexptr set to point to the requested stream index if there is one
5165 * @return <0 on error
5166 * 0 if st is NOT a matching stream
5167 * >0 if st is a matching stream
5169 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5170 const char *spec, const char **indexptr, AVProgram **p)
5172 int match = 1; /* Stores if the specifier matches so far. */
5174 if (*spec <= '9' && *spec >= '0') { /* opt:index */
5178 } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5179 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5180 enum AVMediaType type;
5184 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
5185 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
5186 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
5187 case 'd': type = AVMEDIA_TYPE_DATA; break;
5188 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5189 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5190 default: av_assert0(0);
5192 if (*spec && *spec++ != ':') /* If we are not at the end, then another specifier must follow. */
5193 return AVERROR(EINVAL);
5195 #if FF_API_LAVF_AVCTX
5196 FF_DISABLE_DEPRECATION_WARNINGS
5197 if (type != st->codecpar->codec_type
5198 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5200 FF_ENABLE_DEPRECATION_WARNINGS
5202 if (type != st->codecpar->codec_type)
5205 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5207 } else if (*spec == 'p' && *(spec + 1) == ':') {
5212 prog_id = strtol(spec, &endptr, 0);
5213 /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5214 if (spec == endptr || (*endptr && *endptr++ != ':'))
5215 return AVERROR(EINVAL);
5218 for (i = 0; i < s->nb_programs; i++) {
5219 if (s->programs[i]->id != prog_id)
5222 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5223 if (st->index == s->programs[i]->stream_index[j]) {
5226 *p = s->programs[i];
5235 } else if (*spec == '#' ||
5236 (*spec == 'i' && *(spec + 1) == ':')) {
5239 spec += 1 + (*spec == 'i');
5240 stream_id = strtol(spec, &endptr, 0);
5241 if (spec == endptr || *endptr) /* Disallow empty id and make sure we are at the end. */
5242 return AVERROR(EINVAL);
5243 return match && (stream_id == st->id);
5244 } else if (*spec == 'm' && *(spec + 1) == ':') {
5245 AVDictionaryEntry *tag;
5251 val = strchr(spec, ':');
5253 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5255 return AVERROR(ENOMEM);
5257 tag = av_dict_get(st->metadata, key, NULL, 0);
5259 if (!val || !strcmp(tag->value, val + 1))
5268 return match && ret;
5269 } else if (*spec == 'u' && *(spec + 1) == '\0') {
5270 AVCodecParameters *par = st->codecpar;
5271 #if FF_API_LAVF_AVCTX
5272 FF_DISABLE_DEPRECATION_WARNINGS
5273 AVCodecContext *codec = st->codec;
5274 FF_ENABLE_DEPRECATION_WARNINGS
5277 switch (par->codec_type) {
5278 case AVMEDIA_TYPE_AUDIO:
5279 val = par->sample_rate && par->channels;
5280 #if FF_API_LAVF_AVCTX
5281 val = val || (codec->sample_rate && codec->channels);
5283 if (par->format == AV_SAMPLE_FMT_NONE
5284 #if FF_API_LAVF_AVCTX
5285 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5290 case AVMEDIA_TYPE_VIDEO:
5291 val = par->width && par->height;
5292 #if FF_API_LAVF_AVCTX
5293 val = val || (codec->width && codec->height);
5295 if (par->format == AV_PIX_FMT_NONE
5296 #if FF_API_LAVF_AVCTX
5297 && codec->pix_fmt == AV_PIX_FMT_NONE
5302 case AVMEDIA_TYPE_UNKNOWN:
5309 #if FF_API_LAVF_AVCTX
5310 return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5312 return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5315 return AVERROR(EINVAL);
5323 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5328 const char *indexptr = NULL;
5329 AVProgram *p = NULL;
5332 ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5339 index = strtol(indexptr, &endptr, 0);
5340 if (*endptr) { /* We can't have anything after the requested index. */
5341 ret = AVERROR(EINVAL);
5345 /* This is not really needed but saves us a loop for simple stream index specifiers. */
5346 if (spec == indexptr)
5347 return (index == st->index);
5349 /* If we requested a matching stream index, we have to ensure st is that. */
5350 nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5351 for (int i = 0; i < nb_streams && index >= 0; i++) {
5352 AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5353 ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5356 if (ret > 0 && index-- == 0 && st == candidate)
5362 if (ret == AVERROR(EINVAL))
5363 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5367 int ff_generate_avci_extradata(AVStream *st)
5369 static const uint8_t avci100_1080p_extradata[] = {
5371 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5372 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5373 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5374 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5375 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5376 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5377 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5378 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5379 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5381 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5384 static const uint8_t avci100_1080i_extradata[] = {
5386 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5387 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5388 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5389 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5390 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5391 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5392 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5393 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5394 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5395 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5396 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5398 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5401 static const uint8_t avci50_1080p_extradata[] = {
5403 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5404 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5405 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5406 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5407 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5408 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5409 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5410 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5411 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5413 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5416 static const uint8_t avci50_1080i_extradata[] = {
5418 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5419 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5420 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5421 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5422 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5423 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5424 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5425 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5426 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5427 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5428 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5430 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5433 static const uint8_t avci100_720p_extradata[] = {
5435 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5436 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5437 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5438 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5439 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5440 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5441 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5442 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5443 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5444 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5446 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5449 static const uint8_t avci50_720p_extradata[] = {
5451 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5452 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5453 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5454 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5455 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5456 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5457 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5458 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5459 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5461 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5465 const uint8_t *data = NULL;
5468 if (st->codecpar->width == 1920) {
5469 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5470 data = avci100_1080p_extradata;
5471 size = sizeof(avci100_1080p_extradata);
5473 data = avci100_1080i_extradata;
5474 size = sizeof(avci100_1080i_extradata);
5476 } else if (st->codecpar->width == 1440) {
5477 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5478 data = avci50_1080p_extradata;
5479 size = sizeof(avci50_1080p_extradata);
5481 data = avci50_1080i_extradata;
5482 size = sizeof(avci50_1080i_extradata);
5484 } else if (st->codecpar->width == 1280) {
5485 data = avci100_720p_extradata;
5486 size = sizeof(avci100_720p_extradata);
5487 } else if (st->codecpar->width == 960) {
5488 data = avci50_720p_extradata;
5489 size = sizeof(avci50_720p_extradata);
5495 if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5497 memcpy(st->codecpar->extradata, data, size);
5502 uint8_t *av_stream_get_side_data(const AVStream *st,
5503 enum AVPacketSideDataType type, buffer_size_t *size)
5507 for (i = 0; i < st->nb_side_data; i++) {
5508 if (st->side_data[i].type == type) {
5510 *size = st->side_data[i].size;
5511 return st->side_data[i].data;
5519 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5520 uint8_t *data, size_t size)
5522 AVPacketSideData *sd, *tmp;
5525 for (i = 0; i < st->nb_side_data; i++) {
5526 sd = &st->side_data[i];
5528 if (sd->type == type) {
5529 av_freep(&sd->data);
5536 if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5537 return AVERROR(ERANGE);
5539 tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5541 return AVERROR(ENOMEM);
5544 st->side_data = tmp;
5547 sd = &st->side_data[st->nb_side_data - 1];
5555 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5559 uint8_t *data = av_malloc(size);
5564 ret = av_stream_add_side_data(st, type, data, size);
5573 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5576 const AVBitStreamFilter *bsf;
5579 av_assert0(!st->internal->bsfc);
5581 if (!(bsf = av_bsf_get_by_name(name))) {
5582 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5583 return AVERROR_BSF_NOT_FOUND;
5586 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5589 bsfc->time_base_in = st->time_base;
5590 if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5595 if (args && bsfc->filter->priv_class) {
5596 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5597 const char * shorthand[2] = {NULL};
5600 shorthand[0] = opt->name;
5602 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5608 if ((ret = av_bsf_init(bsfc)) < 0) {
5613 st->internal->bsfc = bsfc;
5615 av_log(NULL, AV_LOG_VERBOSE,
5616 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5617 name, args ? args : "");
5621 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5624 return AVERROR(EINVAL);
5626 if (!(s->oformat->flags & AVFMT_NOFILE))
5627 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5631 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5634 s->io_close(s, *pb);
5638 int ff_is_http_proto(char *filename) {
5639 const char *proto = avio_find_protocol_name(filename);
5640 return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5643 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5645 AVDictionaryEntry *entry;
5646 int64_t parsed_timestamp;
5648 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5649 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5650 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5653 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5660 int ff_standardize_creation_time(AVFormatContext *s)
5663 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5665 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5669 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5674 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5676 if (size != AVPALETTE_SIZE) {
5677 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5678 return AVERROR_INVALIDDATA;
5680 memcpy(palette, side_data, AVPALETTE_SIZE);
5684 if (ret == CONTAINS_PAL) {
5686 for (i = 0; i < AVPALETTE_COUNT; i++)
5687 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5694 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5699 ret = av_bprint_finalize(buf, &str);
5702 if (!av_bprint_is_complete(buf)) {
5704 return AVERROR(ENOMEM);
5707 par->extradata = str;
5708 /* Note: the string is NUL terminated (so extradata can be read as a
5709 * string), but the ending character is not accounted in the size (in
5710 * binary formats you are likely not supposed to mux that character). When
5711 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5713 par->extradata_size = buf->len;
5717 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5718 AVStream *ost, const AVStream *ist,
5719 enum AVTimebaseSource copy_tb)
5721 //TODO: use [io]st->internal->avctx
5722 const AVCodecContext *dec_ctx;
5723 AVCodecContext *enc_ctx;
5725 #if FF_API_LAVF_AVCTX
5726 FF_DISABLE_DEPRECATION_WARNINGS
5727 dec_ctx = ist->codec;
5728 enc_ctx = ost->codec;
5729 FF_ENABLE_DEPRECATION_WARNINGS
5731 dec_ctx = ist->internal->avctx;
5732 enc_ctx = ost->internal->avctx;
5735 enc_ctx->time_base = ist->time_base;
5737 * Avi is a special case here because it supports variable fps but
5738 * having the fps and timebase differe significantly adds quite some
5741 if (!strcmp(ofmt->name, "avi")) {
5742 #if FF_API_R_FRAME_RATE
5743 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5744 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5745 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5746 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5747 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5748 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5749 enc_ctx->time_base.num = ist->r_frame_rate.den;
5750 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5751 enc_ctx->ticks_per_frame = 2;
5754 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5755 && av_q2d(ist->time_base) < 1.0/500
5756 || copy_tb == AVFMT_TBCF_DECODER) {
5757 enc_ctx->time_base = dec_ctx->time_base;
5758 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5759 enc_ctx->time_base.den *= 2;
5760 enc_ctx->ticks_per_frame = 2;
5762 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5763 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5764 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5765 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5766 && av_q2d(ist->time_base) < 1.0/500
5767 || copy_tb == AVFMT_TBCF_DECODER) {
5768 enc_ctx->time_base = dec_ctx->time_base;
5769 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5773 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5774 && dec_ctx->time_base.num < dec_ctx->time_base.den
5775 && dec_ctx->time_base.num > 0
5776 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5777 enc_ctx->time_base = dec_ctx->time_base;
5780 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5781 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5786 AVRational av_stream_get_codec_timebase(const AVStream *st)
5788 // See avformat_transfer_internal_stream_timing_info() TODO.
5789 #if FF_API_LAVF_AVCTX
5790 FF_DISABLE_DEPRECATION_WARNINGS
5791 return st->codec->time_base;
5792 FF_ENABLE_DEPRECATION_WARNINGS
5794 return st->internal->avctx->time_base;
5798 void ff_format_set_url(AVFormatContext *s, char *url)
5803 #if FF_API_FORMAT_FILENAME
5804 FF_DISABLE_DEPRECATION_WARNINGS
5805 av_strlcpy(s->filename, url, sizeof(s->filename));
5806 FF_ENABLE_DEPRECATION_WARNINGS