2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/time.h"
36 #include "libavutil/time_internal.h"
37 #include "libavutil/timestamp.h"
39 #include "libavcodec/bytestream.h"
40 #include "libavcodec/internal.h"
41 #include "libavcodec/raw.h"
43 #include "audiointerleave.h"
45 #include "avio_internal.h"
55 #include "libavutil/ffversion.h"
56 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
60 * various utility functions for use within FFmpeg
63 unsigned avformat_version(void)
65 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
66 return LIBAVFORMAT_VERSION_INT;
69 const char *avformat_configuration(void)
71 return FFMPEG_CONFIGURATION;
74 const char *avformat_license(void)
76 #define LICENSE_PREFIX "libavformat license: "
77 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
80 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
82 static int is_relative(int64_t ts) {
83 return ts > (RELATIVE_TS_BASE - (1LL<<48));
87 * Wrap a given time stamp, if there is an indication for an overflow
90 * @param timestamp the time stamp to wrap
91 * @return resulting time stamp
93 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
95 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
96 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
97 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
98 timestamp < st->pts_wrap_reference)
99 return timestamp + (1ULL << st->pts_wrap_bits);
100 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
101 timestamp >= st->pts_wrap_reference)
102 return timestamp - (1ULL << st->pts_wrap_bits);
107 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
108 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
113 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
114 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
115 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
116 #if FF_API_OLD_OPEN_CALLBACKS
117 FF_DISABLE_DEPRECATION_WARNINGS
118 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
119 FF_ENABLE_DEPRECATION_WARNINGS
122 int64_t av_stream_get_end_pts(const AVStream *st)
125 return st->priv_pts->val;
127 return AV_NOPTS_VALUE;
130 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
135 void av_format_inject_global_side_data(AVFormatContext *s)
138 s->internal->inject_global_side_data = 1;
139 for (i = 0; i < s->nb_streams; i++) {
140 AVStream *st = s->streams[i];
141 st->inject_global_side_data = 1;
145 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
147 av_assert0(!dst->codec_whitelist &&
148 !dst->format_whitelist &&
149 !dst->protocol_whitelist &&
150 !dst->protocol_blacklist);
151 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
152 dst->format_whitelist = av_strdup(src->format_whitelist);
153 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
154 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
155 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
156 || (src-> format_whitelist && !dst-> format_whitelist)
157 || (src->protocol_whitelist && !dst->protocol_whitelist)
158 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
159 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
160 return AVERROR(ENOMEM);
165 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
167 #if FF_API_LAVF_AVCTX
168 FF_DISABLE_DEPRECATION_WARNINGS
169 if (st->codec->codec)
170 return st->codec->codec;
171 FF_ENABLE_DEPRECATION_WARNINGS
174 switch (st->codecpar->codec_type) {
175 case AVMEDIA_TYPE_VIDEO:
176 if (s->video_codec) return s->video_codec;
178 case AVMEDIA_TYPE_AUDIO:
179 if (s->audio_codec) return s->audio_codec;
181 case AVMEDIA_TYPE_SUBTITLE:
182 if (s->subtitle_codec) return s->subtitle_codec;
186 return avcodec_find_decoder(codec_id);
189 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
191 const AVCodec *codec;
193 #if CONFIG_H264_DECODER
194 /* Other parts of the code assume this decoder to be used for h264,
195 * so force it if possible. */
196 if (codec_id == AV_CODEC_ID_H264)
197 return avcodec_find_decoder_by_name("h264");
200 codec = find_decoder(s, st, codec_id);
204 if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
205 const AVCodec *probe_codec = NULL;
206 while (probe_codec = av_codec_next(probe_codec)) {
207 if (probe_codec->id == codec_id &&
208 av_codec_is_decoder(probe_codec) &&
209 !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
218 int av_format_get_probe_score(const AVFormatContext *s)
220 return s->probe_score;
223 /* an arbitrarily chosen "sane" max packet size -- 50M */
224 #define SANE_CHUNK_SIZE (50000000)
226 int ffio_limit(AVIOContext *s, int size)
228 if (s->maxsize>= 0) {
229 int64_t remaining= s->maxsize - avio_tell(s);
230 if (remaining < size) {
231 int64_t newsize = avio_size(s);
232 if (!s->maxsize || s->maxsize<newsize)
233 s->maxsize = newsize - !newsize;
234 remaining= s->maxsize - avio_tell(s);
235 remaining= FFMAX(remaining, 0);
238 if (s->maxsize>= 0 && remaining+1 < size) {
239 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
246 /* Read the data in sane-sized chunks and append to pkt.
247 * Return the number of bytes read or an error. */
248 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
250 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
251 int orig_size = pkt->size;
255 int prev_size = pkt->size;
258 /* When the caller requests a lot of data, limit it to the amount
259 * left in file or SANE_CHUNK_SIZE when it is not known. */
261 if (read_size > SANE_CHUNK_SIZE/10) {
262 read_size = ffio_limit(s, read_size);
263 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
265 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
268 ret = av_grow_packet(pkt, read_size);
272 ret = avio_read(s, pkt->data + prev_size, read_size);
273 if (ret != read_size) {
274 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
281 pkt->flags |= AV_PKT_FLAG_CORRUPT;
285 av_packet_unref(pkt);
286 return pkt->size > orig_size ? pkt->size - orig_size : ret;
289 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
294 pkt->pos = avio_tell(s);
296 return append_packet_chunked(s, pkt, size);
299 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
302 return av_get_packet(s, pkt, size);
303 return append_packet_chunked(s, pkt, size);
306 int av_filename_number_test(const char *filename)
310 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
313 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
316 static const struct {
319 enum AVMediaType type;
321 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
322 { "ac3", AV_CODEC_ID_AC3, 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 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
332 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
333 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
337 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
341 av_log(s, AV_LOG_DEBUG,
342 "Probe with size=%d, packets=%d detected %s with score=%d\n",
343 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
345 for (i = 0; fmt_id_type[i].name; i++) {
346 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
347 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
348 st->codecpar->sample_rate)
350 if (st->request_probe > score &&
351 st->codecpar->codec_id != fmt_id_type[i].id)
353 st->codecpar->codec_id = fmt_id_type[i].id;
354 st->codecpar->codec_type = fmt_id_type[i].type;
355 st->internal->need_context_update = 1;
356 #if FF_API_LAVF_AVCTX
357 FF_DISABLE_DEPRECATION_WARNINGS
358 st->codec->codec_type = st->codecpar->codec_type;
359 st->codec->codec_id = st->codecpar->codec_id;
360 FF_ENABLE_DEPRECATION_WARNINGS
369 /************************************************************/
370 /* input media file */
372 int av_demuxer_open(AVFormatContext *ic) {
375 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
376 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
377 return AVERROR(EINVAL);
380 if (ic->iformat->read_header) {
381 err = ic->iformat->read_header(ic);
386 if (ic->pb && !ic->internal->data_offset)
387 ic->internal->data_offset = avio_tell(ic->pb);
392 /* Open input file and probe the format if necessary. */
393 static int init_input(AVFormatContext *s, const char *filename,
394 AVDictionary **options)
397 AVProbeData pd = { filename, NULL, 0 };
398 int score = AVPROBE_SCORE_RETRY;
401 s->flags |= AVFMT_FLAG_CUSTOM_IO;
403 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
404 s, 0, s->format_probesize);
405 else if (s->iformat->flags & AVFMT_NOFILE)
406 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
407 "will be ignored with AVFMT_NOFILE format.\n");
411 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
412 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
415 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
420 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
421 s, 0, s->format_probesize);
424 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
425 AVPacketList **plast_pktl, int ref)
427 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
431 return AVERROR(ENOMEM);
434 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
443 (*plast_pktl)->next = pktl;
445 *packet_buffer = pktl;
447 /* Add the packet in the buffered packet list. */
452 int avformat_queue_attached_pictures(AVFormatContext *s)
455 for (i = 0; i < s->nb_streams; i++)
456 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
457 s->streams[i]->discard < AVDISCARD_ALL) {
458 if (s->streams[i]->attached_pic.size <= 0) {
459 av_log(s, AV_LOG_WARNING,
460 "Attached picture on stream %d has invalid size, "
465 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
466 &s->streams[i]->attached_pic,
467 &s->internal->raw_packet_buffer_end, 1);
474 static int update_stream_avctx(AVFormatContext *s)
477 for (i = 0; i < s->nb_streams; i++) {
478 AVStream *st = s->streams[i];
480 if (!st->internal->need_context_update)
483 /* close parser, because it depends on the codec */
484 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
485 av_parser_close(st->parser);
489 /* update internal codec context, for the parser */
490 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
494 #if FF_API_LAVF_AVCTX
495 FF_DISABLE_DEPRECATION_WARNINGS
496 /* update deprecated public codec context */
497 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
500 FF_ENABLE_DEPRECATION_WARNINGS
503 st->internal->need_context_update = 0;
509 int avformat_open_input(AVFormatContext **ps, const char *filename,
510 AVInputFormat *fmt, AVDictionary **options)
512 AVFormatContext *s = *ps;
514 AVDictionary *tmp = NULL;
515 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
517 if (!s && !(s = avformat_alloc_context()))
518 return AVERROR(ENOMEM);
520 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
521 return AVERROR(EINVAL);
527 av_dict_copy(&tmp, *options, 0);
529 if (s->pb) // must be before any goto fail
530 s->flags |= AVFMT_FLAG_CUSTOM_IO;
532 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
535 if ((ret = init_input(s, filename, &tmp)) < 0)
537 s->probe_score = ret;
539 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
540 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
541 if (!s->protocol_whitelist) {
542 ret = AVERROR(ENOMEM);
547 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
548 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
549 if (!s->protocol_blacklist) {
550 ret = AVERROR(ENOMEM);
555 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
556 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
557 ret = AVERROR(EINVAL);
561 avio_skip(s->pb, s->skip_initial_bytes);
563 /* Check filename in case an image number is expected. */
564 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
565 if (!av_filename_number_test(filename)) {
566 ret = AVERROR(EINVAL);
571 s->duration = s->start_time = AV_NOPTS_VALUE;
572 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
574 /* Allocate private data. */
575 if (s->iformat->priv_data_size > 0) {
576 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
577 ret = AVERROR(ENOMEM);
580 if (s->iformat->priv_class) {
581 *(const AVClass **) s->priv_data = s->iformat->priv_class;
582 av_opt_set_defaults(s->priv_data);
583 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
588 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
590 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
592 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
593 if ((ret = s->iformat->read_header(s)) < 0)
596 if (id3v2_extra_meta) {
597 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
598 !strcmp(s->iformat->name, "tta")) {
599 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
602 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
604 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
606 if ((ret = avformat_queue_attached_pictures(s)) < 0)
609 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
610 s->internal->data_offset = avio_tell(s->pb);
612 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
614 update_stream_avctx(s);
616 for (i = 0; i < s->nb_streams; i++)
617 s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
620 av_dict_free(options);
627 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
629 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
631 avformat_free_context(s);
636 /*******************************************************/
638 static void force_codec_ids(AVFormatContext *s, AVStream *st)
640 switch (st->codecpar->codec_type) {
641 case AVMEDIA_TYPE_VIDEO:
642 if (s->video_codec_id)
643 st->codecpar->codec_id = s->video_codec_id;
645 case AVMEDIA_TYPE_AUDIO:
646 if (s->audio_codec_id)
647 st->codecpar->codec_id = s->audio_codec_id;
649 case AVMEDIA_TYPE_SUBTITLE:
650 if (s->subtitle_codec_id)
651 st->codecpar->codec_id = s->subtitle_codec_id;
653 case AVMEDIA_TYPE_DATA:
654 if (s->data_codec_id)
655 st->codecpar->codec_id = s->data_codec_id;
660 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
662 if (st->request_probe>0) {
663 AVProbeData *pd = &st->probe_data;
665 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
669 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
671 av_log(s, AV_LOG_WARNING,
672 "Failed to reallocate probe buffer for stream %d\n",
677 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
678 pd->buf_size += pkt->size;
679 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
682 st->probe_packets = 0;
684 av_log(s, AV_LOG_WARNING,
685 "nothing to probe for stream %d\n", st->index);
689 end= s->internal->raw_packet_buffer_remaining_size <= 0
690 || st->probe_packets<= 0;
692 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
693 int score = set_codec_from_probe_data(s, st, pd);
694 if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
698 st->request_probe = -1;
699 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
700 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
702 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
704 force_codec_ids(s, st);
710 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
712 int64_t ref = pkt->dts;
713 int i, pts_wrap_behavior;
714 int64_t pts_wrap_reference;
715 AVProgram *first_program;
717 if (ref == AV_NOPTS_VALUE)
719 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
721 ref &= (1LL << st->pts_wrap_bits)-1;
723 // reference time stamp should be 60 s before first time stamp
724 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
725 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
726 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
727 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
728 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
730 first_program = av_find_program_from_stream(s, NULL, stream_index);
732 if (!first_program) {
733 int default_stream_index = av_find_default_stream_index(s);
734 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
735 for (i = 0; i < s->nb_streams; i++) {
736 if (av_find_program_from_stream(s, NULL, i))
738 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
739 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
743 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
744 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
748 AVProgram *program = first_program;
750 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
751 pts_wrap_reference = program->pts_wrap_reference;
752 pts_wrap_behavior = program->pts_wrap_behavior;
755 program = av_find_program_from_stream(s, program, stream_index);
758 // update every program with differing pts_wrap_reference
759 program = first_program;
761 if (program->pts_wrap_reference != pts_wrap_reference) {
762 for (i = 0; i<program->nb_stream_indexes; i++) {
763 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
764 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
767 program->pts_wrap_reference = pts_wrap_reference;
768 program->pts_wrap_behavior = pts_wrap_behavior;
770 program = av_find_program_from_stream(s, program, stream_index);
776 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
782 AVPacketList *pktl = s->internal->raw_packet_buffer;
786 st = s->streams[pkt->stream_index];
787 if (s->internal->raw_packet_buffer_remaining_size <= 0)
788 if ((err = probe_codec(s, st, NULL)) < 0)
790 if (st->request_probe <= 0) {
791 s->internal->raw_packet_buffer = pktl->next;
792 s->internal->raw_packet_buffer_remaining_size += pkt->size;
801 ret = s->iformat->read_packet(s, pkt);
803 /* Some demuxers return FFERROR_REDO when they consume
804 data and discard it (ignored streams, junk, extradata).
805 We must re-call the demuxer to get the real packet. */
806 if (ret == FFERROR_REDO)
808 if (!pktl || ret == AVERROR(EAGAIN))
810 for (i = 0; i < s->nb_streams; i++) {
812 if (st->probe_packets || st->request_probe > 0)
813 if ((err = probe_codec(s, st, NULL)) < 0)
815 av_assert0(st->request_probe <= 0);
821 AVPacket tmp = { 0 };
822 ret = av_packet_ref(&tmp, pkt);
828 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
829 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
830 av_log(s, AV_LOG_WARNING,
831 "Dropped corrupted packet (stream = %d)\n",
833 av_packet_unref(pkt);
837 if (pkt->stream_index >= (unsigned)s->nb_streams) {
838 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
842 st = s->streams[pkt->stream_index];
844 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
845 // correct first time stamps to negative values
846 if (!is_relative(st->first_dts))
847 st->first_dts = wrap_timestamp(st, st->first_dts);
848 if (!is_relative(st->start_time))
849 st->start_time = wrap_timestamp(st, st->start_time);
850 if (!is_relative(st->cur_dts))
851 st->cur_dts = wrap_timestamp(st, st->cur_dts);
854 pkt->dts = wrap_timestamp(st, pkt->dts);
855 pkt->pts = wrap_timestamp(st, pkt->pts);
857 force_codec_ids(s, st);
859 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
860 if (s->use_wallclock_as_timestamps)
861 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
863 if (!pktl && st->request_probe <= 0)
866 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
867 &s->internal->raw_packet_buffer_end, 0);
870 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
872 if ((err = probe_codec(s, st, pkt)) < 0)
878 /**********************************************************/
880 static int determinable_frame_size(AVCodecContext *avctx)
882 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
883 avctx->codec_id == AV_CODEC_ID_MP1 ||
884 avctx->codec_id == AV_CODEC_ID_MP2 ||
885 avctx->codec_id == AV_CODEC_ID_MP3/* ||
886 avctx->codec_id == AV_CODEC_ID_CELT*/)
892 * Return the frame duration in seconds. Return 0 if not available.
894 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
895 AVCodecParserContext *pc, AVPacket *pkt)
897 AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
898 av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
899 int frame_size, sample_rate;
901 #if FF_API_LAVF_AVCTX
902 FF_DISABLE_DEPRECATION_WARNINGS
903 if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
904 codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
905 FF_ENABLE_DEPRECATION_WARNINGS
910 switch (st->codecpar->codec_type) {
911 case AVMEDIA_TYPE_VIDEO:
912 if (st->r_frame_rate.num && !pc && s->iformat) {
913 *pnum = st->r_frame_rate.den;
914 *pden = st->r_frame_rate.num;
915 } else if (st->time_base.num * 1000LL > st->time_base.den) {
916 *pnum = st->time_base.num;
917 *pden = st->time_base.den;
918 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
919 av_assert0(st->internal->avctx->ticks_per_frame);
920 av_reduce(pnum, pden,
922 codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
925 if (pc && pc->repeat_pict) {
926 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
927 av_reduce(pnum, pden,
928 (*pnum) * (1LL + pc->repeat_pict),
932 /* If this codec can be interlaced or progressive then we need
933 * a parser to compute duration of a packet. Thus if we have
934 * no parser in such case leave duration undefined. */
935 if (st->internal->avctx->ticks_per_frame > 1 && !pc)
939 case AVMEDIA_TYPE_AUDIO:
940 if (st->internal->avctx_inited) {
941 frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
942 sample_rate = st->internal->avctx->sample_rate;
944 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
945 sample_rate = st->codecpar->sample_rate;
947 if (frame_size <= 0 || sample_rate <= 0)
957 static int is_intra_only(enum AVCodecID id)
959 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
962 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
967 static int has_decode_delay_been_guessed(AVStream *st)
969 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
970 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
972 #if CONFIG_H264_DECODER
973 if (st->internal->avctx->has_b_frames &&
974 avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
977 if (st->internal->avctx->has_b_frames<3)
978 return st->nb_decoded_frames >= 7;
979 else if (st->internal->avctx->has_b_frames<4)
980 return st->nb_decoded_frames >= 18;
982 return st->nb_decoded_frames >= 20;
985 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
989 if (pktl == s->internal->packet_buffer_end)
990 return s->internal->parse_queue;
994 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
995 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
996 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
999 int delay = st->internal->avctx->has_b_frames;
1002 if (dts == AV_NOPTS_VALUE) {
1003 int64_t best_score = INT64_MAX;
1004 for (i = 0; i<delay; i++) {
1005 if (st->pts_reorder_error_count[i]) {
1006 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1007 if (score < best_score) {
1009 dts = pts_buffer[i];
1014 for (i = 0; i<delay; i++) {
1015 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1016 int64_t diff = FFABS(pts_buffer[i] - dts)
1017 + (uint64_t)st->pts_reorder_error[i];
1018 diff = FFMAX(diff, st->pts_reorder_error[i]);
1019 st->pts_reorder_error[i] = diff;
1020 st->pts_reorder_error_count[i]++;
1021 if (st->pts_reorder_error_count[i] > 250) {
1022 st->pts_reorder_error[i] >>= 1;
1023 st->pts_reorder_error_count[i] >>= 1;
1030 if (dts == AV_NOPTS_VALUE)
1031 dts = pts_buffer[0];
1037 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1038 * of the packets in a window.
1040 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1041 AVPacketList *pkt_buffer)
1043 AVStream *st = s->streams[stream_index];
1044 int delay = st->internal->avctx->has_b_frames;
1047 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1049 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1050 pts_buffer[i] = AV_NOPTS_VALUE;
1052 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1053 if (pkt_buffer->pkt.stream_index != stream_index)
1056 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1057 pts_buffer[0] = pkt_buffer->pkt.pts;
1058 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1059 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1061 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1066 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1067 int64_t dts, int64_t pts, AVPacket *pkt)
1069 AVStream *st = s->streams[stream_index];
1070 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1071 AVPacketList *pktl_it;
1075 if (st->first_dts != AV_NOPTS_VALUE ||
1076 dts == AV_NOPTS_VALUE ||
1077 st->cur_dts == AV_NOPTS_VALUE ||
1081 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1083 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1085 if (is_relative(pts))
1088 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1089 if (pktl_it->pkt.stream_index != stream_index)
1091 if (is_relative(pktl_it->pkt.pts))
1092 pktl_it->pkt.pts += shift;
1094 if (is_relative(pktl_it->pkt.dts))
1095 pktl_it->pkt.dts += shift;
1097 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1098 st->start_time = pktl_it->pkt.pts;
1099 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1100 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1104 if (has_decode_delay_been_guessed(st)) {
1105 update_dts_from_pts(s, stream_index, pktl);
1108 if (st->start_time == AV_NOPTS_VALUE) {
1109 st->start_time = pts;
1110 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1111 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1115 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1116 int stream_index, int duration)
1118 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1119 int64_t cur_dts = RELATIVE_TS_BASE;
1121 if (st->first_dts != AV_NOPTS_VALUE) {
1122 if (st->update_initial_durations_done)
1124 st->update_initial_durations_done = 1;
1125 cur_dts = st->first_dts;
1126 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1127 if (pktl->pkt.stream_index == stream_index) {
1128 if (pktl->pkt.pts != pktl->pkt.dts ||
1129 pktl->pkt.dts != AV_NOPTS_VALUE ||
1132 cur_dts -= duration;
1135 if (pktl && pktl->pkt.dts != st->first_dts) {
1136 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1137 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1141 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1144 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1145 st->first_dts = cur_dts;
1146 } else if (st->cur_dts != RELATIVE_TS_BASE)
1149 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1150 if (pktl->pkt.stream_index != stream_index)
1152 if (pktl->pkt.pts == pktl->pkt.dts &&
1153 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1154 !pktl->pkt.duration) {
1155 pktl->pkt.dts = cur_dts;
1156 if (!st->internal->avctx->has_b_frames)
1157 pktl->pkt.pts = cur_dts;
1158 // if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1159 pktl->pkt.duration = duration;
1162 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1165 st->cur_dts = cur_dts;
1168 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1169 AVCodecParserContext *pc, AVPacket *pkt,
1170 int64_t next_dts, int64_t next_pts)
1172 int num, den, presentation_delayed, delay, i;
1174 AVRational duration;
1175 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1176 st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1178 if (s->flags & AVFMT_FLAG_NOFILLIN)
1181 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1182 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1183 if (st->last_dts_for_order_check <= pkt->dts) {
1186 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1187 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1189 st->last_dts_for_order_check);
1190 st->dts_misordered++;
1192 if (st->dts_ordered + st->dts_misordered > 250) {
1193 st->dts_ordered >>= 1;
1194 st->dts_misordered >>= 1;
1198 st->last_dts_for_order_check = pkt->dts;
1199 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1200 pkt->dts = AV_NOPTS_VALUE;
1203 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1204 pkt->dts = AV_NOPTS_VALUE;
1206 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1207 && !st->internal->avctx->has_b_frames)
1208 //FIXME Set low_delay = 0 when has_b_frames = 1
1209 st->internal->avctx->has_b_frames = 1;
1211 /* do we have a video B-frame ? */
1212 delay = st->internal->avctx->has_b_frames;
1213 presentation_delayed = 0;
1215 /* XXX: need has_b_frame, but cannot get it if the codec is
1216 * not initialized */
1218 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1219 presentation_delayed = 1;
1221 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1222 st->pts_wrap_bits < 63 &&
1223 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1224 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1225 pkt->dts -= 1LL << st->pts_wrap_bits;
1227 pkt->pts += 1LL << st->pts_wrap_bits;
1230 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1231 * We take the conservative approach and discard both.
1232 * Note: If this is misbehaving for an H.264 file, then possibly
1233 * presentation_delayed is not set correctly. */
1234 if (delay == 1 && pkt->dts == pkt->pts &&
1235 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1236 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1237 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1238 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1239 pkt->dts = AV_NOPTS_VALUE;
1242 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1243 if (pkt->duration == 0) {
1244 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1246 duration = (AVRational) {num, den};
1247 pkt->duration = av_rescale_rnd(1,
1248 num * (int64_t) st->time_base.den,
1249 den * (int64_t) st->time_base.num,
1254 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1255 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1257 /* Correct timestamps with byte offset if demuxers only have timestamps
1258 * on packet boundaries */
1259 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1260 /* this will estimate bitrate based on this frame's duration and size */
1261 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1262 if (pkt->pts != AV_NOPTS_VALUE)
1264 if (pkt->dts != AV_NOPTS_VALUE)
1268 /* This may be redundant, but it should not hurt. */
1269 if (pkt->dts != AV_NOPTS_VALUE &&
1270 pkt->pts != AV_NOPTS_VALUE &&
1271 pkt->pts > pkt->dts)
1272 presentation_delayed = 1;
1274 if (s->debug & FF_FDEBUG_TS)
1275 av_log(s, AV_LOG_TRACE,
1276 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1277 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1278 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1280 /* Interpolate PTS and DTS if they are not present. We skip H264
1281 * currently because delay and has_b_frames are not reliably set. */
1282 if ((delay == 0 || (delay == 1 && pc)) &&
1284 if (presentation_delayed) {
1285 /* DTS = decompression timestamp */
1286 /* PTS = presentation timestamp */
1287 if (pkt->dts == AV_NOPTS_VALUE)
1288 pkt->dts = st->last_IP_pts;
1289 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1290 if (pkt->dts == AV_NOPTS_VALUE)
1291 pkt->dts = st->cur_dts;
1293 /* This is tricky: the dts must be incremented by the duration
1294 * of the frame we are displaying, i.e. the last I- or P-frame. */
1295 if (st->last_IP_duration == 0)
1296 st->last_IP_duration = pkt->duration;
1297 if (pkt->dts != AV_NOPTS_VALUE)
1298 st->cur_dts = pkt->dts + st->last_IP_duration;
1299 if (pkt->dts != AV_NOPTS_VALUE &&
1300 pkt->pts == AV_NOPTS_VALUE &&
1301 st->last_IP_duration > 0 &&
1302 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1303 next_dts != next_pts &&
1304 next_pts != AV_NOPTS_VALUE)
1305 pkt->pts = next_dts;
1307 st->last_IP_duration = pkt->duration;
1308 st->last_IP_pts = pkt->pts;
1309 /* Cannot compute PTS if not present (we can compute it only
1310 * by knowing the future. */
1311 } else if (pkt->pts != AV_NOPTS_VALUE ||
1312 pkt->dts != AV_NOPTS_VALUE ||
1315 /* presentation is not delayed : PTS and DTS are the same */
1316 if (pkt->pts == AV_NOPTS_VALUE)
1317 pkt->pts = pkt->dts;
1318 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1320 if (pkt->pts == AV_NOPTS_VALUE)
1321 pkt->pts = st->cur_dts;
1322 pkt->dts = pkt->pts;
1323 if (pkt->pts != AV_NOPTS_VALUE)
1324 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1328 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1329 st->pts_buffer[0] = pkt->pts;
1330 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1331 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1333 if(has_decode_delay_been_guessed(st))
1334 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1336 // We skipped it above so we try here.
1338 // This should happen on the first packet
1339 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1340 if (pkt->dts > st->cur_dts)
1341 st->cur_dts = pkt->dts;
1343 if (s->debug & FF_FDEBUG_TS)
1344 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1345 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1348 if (is_intra_only(st->codecpar->codec_id))
1349 pkt->flags |= AV_PKT_FLAG_KEY;
1350 #if FF_API_CONVERGENCE_DURATION
1351 FF_DISABLE_DEPRECATION_WARNINGS
1353 pkt->convergence_duration = pc->convergence_duration;
1354 FF_ENABLE_DEPRECATION_WARNINGS
1358 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1361 AVPacketList *pktl = *pkt_buf;
1362 *pkt_buf = pktl->next;
1363 av_packet_unref(&pktl->pkt);
1366 *pkt_buf_end = NULL;
1370 * Parse a packet, add all split parts to parse_queue.
1372 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1374 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1376 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1377 AVStream *st = s->streams[stream_index];
1378 uint8_t *data = pkt ? pkt->data : NULL;
1379 int size = pkt ? pkt->size : 0;
1380 int ret = 0, got_output = 0;
1383 av_init_packet(&flush_pkt);
1386 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1387 // preserve 0-size sync packets
1388 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1391 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1393 int64_t next_pts = pkt->pts;
1394 int64_t next_dts = pkt->dts;
1396 av_init_packet(&out_pkt);
1397 len = av_parser_parse2(st->parser, st->internal->avctx,
1398 &out_pkt.data, &out_pkt.size, data, size,
1399 pkt->pts, pkt->dts, pkt->pos);
1401 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1403 /* increment read pointer */
1407 got_output = !!out_pkt.size;
1412 if (pkt->side_data) {
1413 out_pkt.side_data = pkt->side_data;
1414 out_pkt.side_data_elems = pkt->side_data_elems;
1415 pkt->side_data = NULL;
1416 pkt->side_data_elems = 0;
1419 /* set the duration */
1420 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1421 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1422 if (st->internal->avctx->sample_rate > 0) {
1424 av_rescale_q_rnd(st->parser->duration,
1425 (AVRational) { 1, st->internal->avctx->sample_rate },
1431 out_pkt.stream_index = st->index;
1432 out_pkt.pts = st->parser->pts;
1433 out_pkt.dts = st->parser->dts;
1434 out_pkt.pos = st->parser->pos;
1436 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1437 out_pkt.pos = st->parser->frame_offset;
1439 if (st->parser->key_frame == 1 ||
1440 (st->parser->key_frame == -1 &&
1441 st->parser->pict_type == AV_PICTURE_TYPE_I))
1442 out_pkt.flags |= AV_PKT_FLAG_KEY;
1444 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1445 out_pkt.flags |= AV_PKT_FLAG_KEY;
1447 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1449 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1450 &s->internal->parse_queue_end, 1);
1451 av_packet_unref(&out_pkt);
1456 /* end of the stream => close and free the parser */
1457 if (pkt == &flush_pkt) {
1458 av_parser_close(st->parser);
1463 av_packet_unref(pkt);
1467 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1468 AVPacketList **pkt_buffer_end,
1472 av_assert0(*pkt_buffer);
1475 *pkt_buffer = pktl->next;
1477 *pkt_buffer_end = NULL;
1482 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1484 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1487 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1489 int ret = 0, i, got_packet = 0;
1490 AVDictionary *metadata = NULL;
1492 av_init_packet(pkt);
1494 while (!got_packet && !s->internal->parse_queue) {
1498 /* read next packet */
1499 ret = ff_read_packet(s, &cur_pkt);
1501 if (ret == AVERROR(EAGAIN))
1503 /* flush the parsers */
1504 for (i = 0; i < s->nb_streams; i++) {
1506 if (st->parser && st->need_parsing)
1507 parse_packet(s, NULL, st->index);
1509 /* all remaining packets are now in parse_queue =>
1510 * really terminate parsing */
1514 st = s->streams[cur_pkt.stream_index];
1516 /* update context if required */
1517 if (st->internal->need_context_update) {
1518 if (avcodec_is_open(st->internal->avctx)) {
1519 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1520 avcodec_close(st->internal->avctx);
1521 st->info->found_decoder = 0;
1524 /* close parser, because it depends on the codec */
1525 if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1526 av_parser_close(st->parser);
1530 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1534 #if FF_API_LAVF_AVCTX
1535 FF_DISABLE_DEPRECATION_WARNINGS
1536 /* update deprecated public codec context */
1537 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1540 FF_ENABLE_DEPRECATION_WARNINGS
1543 st->internal->need_context_update = 0;
1546 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1547 cur_pkt.dts != AV_NOPTS_VALUE &&
1548 cur_pkt.pts < cur_pkt.dts) {
1549 av_log(s, AV_LOG_WARNING,
1550 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1551 cur_pkt.stream_index,
1552 av_ts2str(cur_pkt.pts),
1553 av_ts2str(cur_pkt.dts),
1556 if (s->debug & FF_FDEBUG_TS)
1557 av_log(s, AV_LOG_DEBUG,
1558 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1559 cur_pkt.stream_index,
1560 av_ts2str(cur_pkt.pts),
1561 av_ts2str(cur_pkt.dts),
1562 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1564 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1565 st->parser = av_parser_init(st->codecpar->codec_id);
1567 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1568 "%s, packets or times may be invalid.\n",
1569 avcodec_get_name(st->codecpar->codec_id));
1570 /* no parser available: just output the raw packets */
1571 st->need_parsing = AVSTREAM_PARSE_NONE;
1572 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1573 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1574 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1575 st->parser->flags |= PARSER_FLAG_ONCE;
1576 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1577 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1580 if (!st->need_parsing || !st->parser) {
1581 /* no parsing needed: we just output the packet as is */
1583 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1584 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1585 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1586 ff_reduce_index(s, st->index);
1587 av_add_index_entry(st, pkt->pos, pkt->dts,
1588 0, 0, AVINDEX_KEYFRAME);
1591 } else if (st->discard < AVDISCARD_ALL) {
1592 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1594 st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1595 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1596 st->codecpar->channels = st->internal->avctx->channels;
1597 st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1598 st->codecpar->codec_id = st->internal->avctx->codec_id;
1601 av_packet_unref(&cur_pkt);
1603 if (pkt->flags & AV_PKT_FLAG_KEY)
1604 st->skip_to_keyframe = 0;
1605 if (st->skip_to_keyframe) {
1606 av_packet_unref(&cur_pkt);
1614 if (!got_packet && s->internal->parse_queue)
1615 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1618 AVStream *st = s->streams[pkt->stream_index];
1619 int discard_padding = 0;
1620 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1621 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1622 int64_t sample = ts_to_samples(st, pts);
1623 int duration = ts_to_samples(st, pkt->duration);
1624 int64_t end_sample = sample + duration;
1625 if (duration > 0 && end_sample >= st->first_discard_sample &&
1626 sample < st->last_discard_sample)
1627 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1629 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1630 st->skip_samples = st->start_skip_samples;
1631 if (st->skip_samples || discard_padding) {
1632 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1634 AV_WL32(p, st->skip_samples);
1635 AV_WL32(p + 4, discard_padding);
1636 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1638 st->skip_samples = 0;
1641 if (st->inject_global_side_data) {
1642 for (i = 0; i < st->nb_side_data; i++) {
1643 AVPacketSideData *src_sd = &st->side_data[i];
1646 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1649 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1651 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1655 memcpy(dst_data, src_sd->data, src_sd->size);
1657 st->inject_global_side_data = 0;
1660 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1661 av_packet_merge_side_data(pkt);
1664 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1666 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1667 av_dict_copy(&s->metadata, metadata, 0);
1668 av_dict_free(&metadata);
1669 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1672 #if FF_API_LAVF_AVCTX
1673 update_stream_avctx(s);
1676 if (s->debug & FF_FDEBUG_TS)
1677 av_log(s, AV_LOG_DEBUG,
1678 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1679 "size=%d, duration=%"PRId64", flags=%d\n",
1681 av_ts2str(pkt->pts),
1682 av_ts2str(pkt->dts),
1683 pkt->size, pkt->duration, pkt->flags);
1688 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1690 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1696 ret = s->internal->packet_buffer
1697 ? read_from_packet_buffer(&s->internal->packet_buffer,
1698 &s->internal->packet_buffer_end, pkt)
1699 : read_frame_internal(s, pkt);
1706 AVPacketList *pktl = s->internal->packet_buffer;
1709 AVPacket *next_pkt = &pktl->pkt;
1711 if (next_pkt->dts != AV_NOPTS_VALUE) {
1712 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1713 // last dts seen for this stream. if any of packets following
1714 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1715 int64_t last_dts = next_pkt->dts;
1716 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1717 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1718 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1719 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1721 next_pkt->pts = pktl->pkt.dts;
1723 if (last_dts != AV_NOPTS_VALUE) {
1724 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1725 last_dts = pktl->pkt.dts;
1730 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1731 // Fixing the last reference frame had none pts issue (For MXF etc).
1732 // We only do this when
1734 // 2. we are not able to resolve a pts value for current packet.
1735 // 3. the packets for this stream at the end of the files had valid dts.
1736 next_pkt->pts = last_dts + next_pkt->duration;
1738 pktl = s->internal->packet_buffer;
1741 /* read packet from packet buffer, if there is data */
1742 st = s->streams[next_pkt->stream_index];
1743 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1744 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1745 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1746 &s->internal->packet_buffer_end, pkt);
1751 ret = read_frame_internal(s, pkt);
1753 if (pktl && ret != AVERROR(EAGAIN)) {
1760 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1761 &s->internal->packet_buffer_end, 1);
1762 av_packet_unref(pkt);
1769 st = s->streams[pkt->stream_index];
1770 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1771 ff_reduce_index(s, st->index);
1772 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1775 if (is_relative(pkt->dts))
1776 pkt->dts -= RELATIVE_TS_BASE;
1777 if (is_relative(pkt->pts))
1778 pkt->pts -= RELATIVE_TS_BASE;
1783 /* XXX: suppress the packet queue */
1784 static void flush_packet_queue(AVFormatContext *s)
1788 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1789 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1790 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1792 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1795 /*******************************************************/
1798 int av_find_default_stream_index(AVFormatContext *s)
1802 int best_stream = 0;
1803 int best_score = INT_MIN;
1805 if (s->nb_streams <= 0)
1807 for (i = 0; i < s->nb_streams; i++) {
1810 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1811 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1813 if (st->codecpar->width && st->codecpar->height)
1817 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1818 if (st->codecpar->sample_rate)
1821 if (st->codec_info_nb_frames)
1824 if (st->discard != AVDISCARD_ALL)
1827 if (score > best_score) {
1835 /** Flush the frame reader. */
1836 void ff_read_frame_flush(AVFormatContext *s)
1841 flush_packet_queue(s);
1843 /* Reset read state for each stream. */
1844 for (i = 0; i < s->nb_streams; i++) {
1848 av_parser_close(st->parser);
1851 st->last_IP_pts = AV_NOPTS_VALUE;
1852 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1853 if (st->first_dts == AV_NOPTS_VALUE)
1854 st->cur_dts = RELATIVE_TS_BASE;
1856 /* We set the current DTS to an unspecified origin. */
1857 st->cur_dts = AV_NOPTS_VALUE;
1859 st->probe_packets = MAX_PROBE_PACKETS;
1861 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1862 st->pts_buffer[j] = AV_NOPTS_VALUE;
1864 if (s->internal->inject_global_side_data)
1865 st->inject_global_side_data = 1;
1867 st->skip_samples = 0;
1871 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1875 for (i = 0; i < s->nb_streams; i++) {
1876 AVStream *st = s->streams[i];
1879 av_rescale(timestamp,
1880 st->time_base.den * (int64_t) ref_st->time_base.num,
1881 st->time_base.num * (int64_t) ref_st->time_base.den);
1885 void ff_reduce_index(AVFormatContext *s, int stream_index)
1887 AVStream *st = s->streams[stream_index];
1888 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1890 if ((unsigned) st->nb_index_entries >= max_entries) {
1892 for (i = 0; 2 * i < st->nb_index_entries; i++)
1893 st->index_entries[i] = st->index_entries[2 * i];
1894 st->nb_index_entries = i;
1898 int ff_add_index_entry(AVIndexEntry **index_entries,
1899 int *nb_index_entries,
1900 unsigned int *index_entries_allocated_size,
1901 int64_t pos, int64_t timestamp,
1902 int size, int distance, int flags)
1904 AVIndexEntry *entries, *ie;
1907 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1910 if (timestamp == AV_NOPTS_VALUE)
1911 return AVERROR(EINVAL);
1913 if (size < 0 || size > 0x3FFFFFFF)
1914 return AVERROR(EINVAL);
1916 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1917 timestamp -= RELATIVE_TS_BASE;
1919 entries = av_fast_realloc(*index_entries,
1920 index_entries_allocated_size,
1921 (*nb_index_entries + 1) *
1922 sizeof(AVIndexEntry));
1926 *index_entries = entries;
1928 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1929 timestamp, AVSEEK_FLAG_ANY);
1932 index = (*nb_index_entries)++;
1933 ie = &entries[index];
1934 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1936 ie = &entries[index];
1937 if (ie->timestamp != timestamp) {
1938 if (ie->timestamp <= timestamp)
1940 memmove(entries + index + 1, entries + index,
1941 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1942 (*nb_index_entries)++;
1943 } else if (ie->pos == pos && distance < ie->min_distance)
1944 // do not reduce the distance
1945 distance = ie->min_distance;
1949 ie->timestamp = timestamp;
1950 ie->min_distance = distance;
1957 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1958 int size, int distance, int flags)
1960 timestamp = wrap_timestamp(st, timestamp);
1961 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1962 &st->index_entries_allocated_size, pos,
1963 timestamp, size, distance, flags);
1966 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1967 int64_t wanted_timestamp, int flags)
1975 // Optimize appending index entries at the end.
1976 if (b && entries[b - 1].timestamp < wanted_timestamp)
1982 // Search for the next non-discarded packet.
1983 while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b) {
1985 if (m == b && entries[m].timestamp >= wanted_timestamp) {
1991 timestamp = entries[m].timestamp;
1992 if (timestamp >= wanted_timestamp)
1994 if (timestamp <= wanted_timestamp)
1997 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1999 if (!(flags & AVSEEK_FLAG_ANY))
2000 while (m >= 0 && m < nb_entries &&
2001 !(entries[m].flags & AVINDEX_KEYFRAME))
2002 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2004 if (m == nb_entries)
2009 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2012 int64_t pos_delta = 0;
2014 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2015 const char *proto = avio_find_protocol_name(s->filename);
2018 av_log(s, AV_LOG_INFO,
2019 "Protocol name not provided, cannot determine if input is local or "
2020 "a network protocol, buffers and access patterns cannot be configured "
2021 "optimally without knowing the protocol\n");
2024 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2027 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2028 AVStream *st1 = s->streams[ist1];
2029 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2030 AVStream *st2 = s->streams[ist2];
2036 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2037 AVIndexEntry *e1 = &st1->index_entries[i1];
2038 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2040 skip = FFMAX(skip, e1->size);
2041 for (; i2 < st2->nb_index_entries; i2++) {
2042 AVIndexEntry *e2 = &st2->index_entries[i2];
2043 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2044 if (e2_pts - e1_pts < time_tolerance)
2046 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2054 /* XXX This could be adjusted depending on protocol*/
2055 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2056 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2057 ffio_set_buf_size(s->pb, pos_delta);
2058 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2061 if (skip < (1<<23)) {
2062 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2066 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2068 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2069 wanted_timestamp, flags);
2072 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2073 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2075 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2076 if (stream_index >= 0)
2077 ts = wrap_timestamp(s->streams[stream_index], ts);
2081 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2082 int64_t target_ts, int flags)
2084 AVInputFormat *avif = s->iformat;
2085 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2086 int64_t ts_min, ts_max, ts;
2091 if (stream_index < 0)
2094 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2097 ts_min = AV_NOPTS_VALUE;
2098 pos_limit = -1; // GCC falsely says it may be uninitialized.
2100 st = s->streams[stream_index];
2101 if (st->index_entries) {
2104 /* FIXME: Whole function must be checked for non-keyframe entries in
2105 * index case, especially read_timestamp(). */
2106 index = av_index_search_timestamp(st, target_ts,
2107 flags | AVSEEK_FLAG_BACKWARD);
2108 index = FFMAX(index, 0);
2109 e = &st->index_entries[index];
2111 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2113 ts_min = e->timestamp;
2114 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2115 pos_min, av_ts2str(ts_min));
2117 av_assert1(index == 0);
2120 index = av_index_search_timestamp(st, target_ts,
2121 flags & ~AVSEEK_FLAG_BACKWARD);
2122 av_assert0(index < st->nb_index_entries);
2124 e = &st->index_entries[index];
2125 av_assert1(e->timestamp >= target_ts);
2127 ts_max = e->timestamp;
2128 pos_limit = pos_max - e->min_distance;
2129 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2130 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2134 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2135 ts_min, ts_max, flags, &ts, avif->read_timestamp);
2140 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2143 ff_read_frame_flush(s);
2144 ff_update_cur_dts(s, st, ts);
2149 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2150 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2152 int64_t step = 1024;
2153 int64_t limit, ts_max;
2154 int64_t filesize = avio_size(s->pb);
2155 int64_t pos_max = filesize - 1;
2158 pos_max = FFMAX(0, (pos_max) - step);
2159 ts_max = ff_read_timestamp(s, stream_index,
2160 &pos_max, limit, read_timestamp);
2162 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2163 if (ts_max == AV_NOPTS_VALUE)
2167 int64_t tmp_pos = pos_max + 1;
2168 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2169 &tmp_pos, INT64_MAX, read_timestamp);
2170 if (tmp_ts == AV_NOPTS_VALUE)
2172 av_assert0(tmp_pos > pos_max);
2175 if (tmp_pos >= filesize)
2187 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2188 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2189 int64_t ts_min, int64_t ts_max,
2190 int flags, int64_t *ts_ret,
2191 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2192 int64_t *, int64_t))
2199 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2201 if (ts_min == AV_NOPTS_VALUE) {
2202 pos_min = s->internal->data_offset;
2203 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2204 if (ts_min == AV_NOPTS_VALUE)
2208 if (ts_min >= target_ts) {
2213 if (ts_max == AV_NOPTS_VALUE) {
2214 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2216 pos_limit = pos_max;
2219 if (ts_max <= target_ts) {
2224 av_assert0(ts_min < ts_max);
2227 while (pos_min < pos_limit) {
2228 av_log(s, AV_LOG_TRACE,
2229 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2230 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2231 av_assert0(pos_limit <= pos_max);
2233 if (no_change == 0) {
2234 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2235 // interpolate position (better than dichotomy)
2236 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2238 pos_min - approximate_keyframe_distance;
2239 } else if (no_change == 1) {
2240 // bisection if interpolation did not change min / max pos last time
2241 pos = (pos_min + pos_limit) >> 1;
2243 /* linear search if bisection failed, can only happen if there
2244 * are very few or no keyframes between min/max */
2249 else if (pos > pos_limit)
2253 // May pass pos_limit instead of -1.
2254 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2259 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2260 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2261 pos_min, pos, pos_max,
2262 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2263 pos_limit, start_pos, no_change);
2264 if (ts == AV_NOPTS_VALUE) {
2265 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2268 if (target_ts <= ts) {
2269 pos_limit = start_pos - 1;
2273 if (target_ts >= ts) {
2279 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2280 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2283 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2285 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2286 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2287 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2293 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2294 int64_t pos, int flags)
2296 int64_t pos_min, pos_max;
2298 pos_min = s->internal->data_offset;
2299 pos_max = avio_size(s->pb) - 1;
2303 else if (pos > pos_max)
2306 avio_seek(s->pb, pos, SEEK_SET);
2308 s->io_repositioned = 1;
2313 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2314 int64_t timestamp, int flags)
2321 st = s->streams[stream_index];
2323 index = av_index_search_timestamp(st, timestamp, flags);
2325 if (index < 0 && st->nb_index_entries &&
2326 timestamp < st->index_entries[0].timestamp)
2329 if (index < 0 || index == st->nb_index_entries - 1) {
2333 if (st->nb_index_entries) {
2334 av_assert0(st->index_entries);
2335 ie = &st->index_entries[st->nb_index_entries - 1];
2336 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2338 ff_update_cur_dts(s, st, ie->timestamp);
2340 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2346 read_status = av_read_frame(s, &pkt);
2347 } while (read_status == AVERROR(EAGAIN));
2348 if (read_status < 0)
2350 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2351 if (pkt.flags & AV_PKT_FLAG_KEY) {
2352 av_packet_unref(&pkt);
2355 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2356 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);
2357 av_packet_unref(&pkt);
2361 av_packet_unref(&pkt);
2363 index = av_index_search_timestamp(st, timestamp, flags);
2368 ff_read_frame_flush(s);
2369 if (s->iformat->read_seek)
2370 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2372 ie = &st->index_entries[index];
2373 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2375 ff_update_cur_dts(s, st, ie->timestamp);
2380 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2381 int64_t timestamp, int flags)
2386 if (flags & AVSEEK_FLAG_BYTE) {
2387 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2389 ff_read_frame_flush(s);
2390 return seek_frame_byte(s, stream_index, timestamp, flags);
2393 if (stream_index < 0) {
2394 stream_index = av_find_default_stream_index(s);
2395 if (stream_index < 0)
2398 st = s->streams[stream_index];
2399 /* timestamp for default must be expressed in AV_TIME_BASE units */
2400 timestamp = av_rescale(timestamp, st->time_base.den,
2401 AV_TIME_BASE * (int64_t) st->time_base.num);
2404 /* first, we try the format specific seek */
2405 if (s->iformat->read_seek) {
2406 ff_read_frame_flush(s);
2407 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2413 if (s->iformat->read_timestamp &&
2414 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2415 ff_read_frame_flush(s);
2416 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2417 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2418 ff_read_frame_flush(s);
2419 return seek_frame_generic(s, stream_index, timestamp, flags);
2424 int av_seek_frame(AVFormatContext *s, int stream_index,
2425 int64_t timestamp, int flags)
2429 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2430 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2431 if ((flags & AVSEEK_FLAG_BACKWARD))
2435 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2436 flags & ~AVSEEK_FLAG_BACKWARD);
2439 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2442 ret = avformat_queue_attached_pictures(s);
2447 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2448 int64_t ts, int64_t max_ts, int flags)
2450 if (min_ts > ts || max_ts < ts)
2452 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2453 return AVERROR(EINVAL);
2456 flags |= AVSEEK_FLAG_ANY;
2457 flags &= ~AVSEEK_FLAG_BACKWARD;
2459 if (s->iformat->read_seek2) {
2461 ff_read_frame_flush(s);
2463 if (stream_index == -1 && s->nb_streams == 1) {
2464 AVRational time_base = s->streams[0]->time_base;
2465 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2466 min_ts = av_rescale_rnd(min_ts, time_base.den,
2467 time_base.num * (int64_t)AV_TIME_BASE,
2468 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2469 max_ts = av_rescale_rnd(max_ts, time_base.den,
2470 time_base.num * (int64_t)AV_TIME_BASE,
2471 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2475 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2479 ret = avformat_queue_attached_pictures(s);
2483 if (s->iformat->read_timestamp) {
2484 // try to seek via read_timestamp()
2487 // Fall back on old API if new is not implemented but old is.
2488 // Note the old API has somewhat different semantics.
2489 if (s->iformat->read_seek || 1) {
2490 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2491 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2492 if (ret<0 && ts != min_ts && max_ts != ts) {
2493 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2495 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2500 // try some generic seek like seek_frame_generic() but with new ts semantics
2501 return -1; //unreachable
2504 int avformat_flush(AVFormatContext *s)
2506 ff_read_frame_flush(s);
2510 /*******************************************************/
2513 * Return TRUE if the stream has accurate duration in any stream.
2515 * @return TRUE if the stream has accurate duration for at least one component.
2517 static int has_duration(AVFormatContext *ic)
2522 for (i = 0; i < ic->nb_streams; i++) {
2523 st = ic->streams[i];
2524 if (st->duration != AV_NOPTS_VALUE)
2527 if (ic->duration != AV_NOPTS_VALUE)
2533 * Estimate the stream timings from the one of each components.
2535 * Also computes the global bitrate if possible.
2537 static void update_stream_timings(AVFormatContext *ic)
2539 int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2540 int64_t duration, duration1, filesize;
2545 start_time = INT64_MAX;
2546 start_time_text = INT64_MAX;
2547 end_time = INT64_MIN;
2548 end_time_text = INT64_MIN;
2549 duration = INT64_MIN;
2550 for (i = 0; i < ic->nb_streams; i++) {
2551 st = ic->streams[i];
2552 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2553 start_time1 = av_rescale_q(st->start_time, st->time_base,
2555 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2556 if (start_time1 < start_time_text)
2557 start_time_text = start_time1;
2559 start_time = FFMIN(start_time, start_time1);
2560 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2562 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2563 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2564 end_time1 += start_time1;
2565 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2566 end_time_text = FFMAX(end_time_text, end_time1);
2568 end_time = FFMAX(end_time, end_time1);
2570 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2571 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2572 p->start_time = start_time1;
2573 if (p->end_time < end_time1)
2574 p->end_time = end_time1;
2577 if (st->duration != AV_NOPTS_VALUE) {
2578 duration1 = av_rescale_q(st->duration, st->time_base,
2580 duration = FFMAX(duration, duration1);
2583 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2584 start_time = start_time_text;
2585 else if (start_time > start_time_text)
2586 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2588 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - end_time < AV_TIME_BASE)) {
2589 end_time = end_time_text;
2590 } else if (end_time < end_time_text) {
2591 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2594 if (start_time != INT64_MAX) {
2595 ic->start_time = start_time;
2596 if (end_time != INT64_MIN) {
2597 if (ic->nb_programs > 1) {
2598 for (i = 0; i < ic->nb_programs; i++) {
2599 p = ic->programs[i];
2600 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2601 duration = FFMAX(duration, p->end_time - p->start_time);
2604 duration = FFMAX(duration, end_time - start_time);
2607 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2608 ic->duration = duration;
2610 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2611 /* compute the bitrate */
2612 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2613 (double) ic->duration;
2614 if (bitrate >= 0 && bitrate <= INT64_MAX)
2615 ic->bit_rate = bitrate;
2619 static void fill_all_stream_timings(AVFormatContext *ic)
2624 update_stream_timings(ic);
2625 for (i = 0; i < ic->nb_streams; i++) {
2626 st = ic->streams[i];
2627 if (st->start_time == AV_NOPTS_VALUE) {
2628 if (ic->start_time != AV_NOPTS_VALUE)
2629 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2631 if (ic->duration != AV_NOPTS_VALUE)
2632 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2638 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2640 int64_t filesize, duration;
2641 int i, show_warning = 0;
2644 /* if bit_rate is already set, we believe it */
2645 if (ic->bit_rate <= 0) {
2646 int64_t bit_rate = 0;
2647 for (i = 0; i < ic->nb_streams; i++) {
2648 st = ic->streams[i];
2649 if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2650 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2651 if (st->codecpar->bit_rate > 0) {
2652 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2656 bit_rate += st->codecpar->bit_rate;
2657 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2658 // If we have a videostream with packets but without a bitrate
2659 // then consider the sum not known
2664 ic->bit_rate = bit_rate;
2667 /* if duration is already set, we believe it */
2668 if (ic->duration == AV_NOPTS_VALUE &&
2669 ic->bit_rate != 0) {
2670 filesize = ic->pb ? avio_size(ic->pb) : 0;
2671 if (filesize > ic->internal->data_offset) {
2672 filesize -= ic->internal->data_offset;
2673 for (i = 0; i < ic->nb_streams; i++) {
2674 st = ic->streams[i];
2675 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2676 && st->duration == AV_NOPTS_VALUE) {
2677 duration = av_rescale(8 * filesize, st->time_base.den,
2679 (int64_t) st->time_base.num);
2680 st->duration = duration;
2687 av_log(ic, AV_LOG_WARNING,
2688 "Estimating duration from bitrate, this may be inaccurate\n");
2691 #define DURATION_MAX_READ_SIZE 250000LL
2692 #define DURATION_MAX_RETRY 6
2694 /* only usable for MPEG-PS streams */
2695 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2697 AVPacket pkt1, *pkt = &pkt1;
2699 int num, den, read_size, i, ret;
2700 int found_duration = 0;
2702 int64_t filesize, offset, duration;
2705 /* flush packet queue */
2706 flush_packet_queue(ic);
2708 for (i = 0; i < ic->nb_streams; i++) {
2709 st = ic->streams[i];
2710 if (st->start_time == AV_NOPTS_VALUE &&
2711 st->first_dts == AV_NOPTS_VALUE &&
2712 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2713 av_log(ic, AV_LOG_WARNING,
2714 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2717 av_parser_close(st->parser);
2722 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2723 /* estimate the end time (duration) */
2724 /* XXX: may need to support wrapping */
2725 filesize = ic->pb ? avio_size(ic->pb) : 0;
2727 is_end = found_duration;
2728 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2732 avio_seek(ic->pb, offset, SEEK_SET);
2735 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2739 ret = ff_read_packet(ic, pkt);
2740 } while (ret == AVERROR(EAGAIN));
2743 read_size += pkt->size;
2744 st = ic->streams[pkt->stream_index];
2745 if (pkt->pts != AV_NOPTS_VALUE &&
2746 (st->start_time != AV_NOPTS_VALUE ||
2747 st->first_dts != AV_NOPTS_VALUE)) {
2748 if (pkt->duration == 0) {
2749 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2751 pkt->duration = av_rescale_rnd(1,
2752 num * (int64_t) st->time_base.den,
2753 den * (int64_t) st->time_base.num,
2757 duration = pkt->pts + pkt->duration;
2759 if (st->start_time != AV_NOPTS_VALUE)
2760 duration -= st->start_time;
2762 duration -= st->first_dts;
2764 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2765 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2766 st->duration = duration;
2767 st->info->last_duration = duration;
2770 av_packet_unref(pkt);
2773 /* check if all audio/video streams have valid duration */
2776 for (i = 0; i < ic->nb_streams; i++) {
2777 st = ic->streams[i];
2778 switch (st->codecpar->codec_type) {
2779 case AVMEDIA_TYPE_VIDEO:
2780 case AVMEDIA_TYPE_AUDIO:
2781 if (st->duration == AV_NOPTS_VALUE)
2788 ++retry <= DURATION_MAX_RETRY);
2790 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2792 /* warn about audio/video streams which duration could not be estimated */
2793 for (i = 0; i < ic->nb_streams; i++) {
2794 st = ic->streams[i];
2795 if (st->duration == AV_NOPTS_VALUE) {
2796 switch (st->codecpar->codec_type) {
2797 case AVMEDIA_TYPE_VIDEO:
2798 case AVMEDIA_TYPE_AUDIO:
2799 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2800 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2802 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2806 fill_all_stream_timings(ic);
2808 avio_seek(ic->pb, old_offset, SEEK_SET);
2809 for (i = 0; i < ic->nb_streams; i++) {
2812 st = ic->streams[i];
2813 st->cur_dts = st->first_dts;
2814 st->last_IP_pts = AV_NOPTS_VALUE;
2815 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2816 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2817 st->pts_buffer[j] = AV_NOPTS_VALUE;
2821 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2825 /* get the file size, if possible */
2826 if (ic->iformat->flags & AVFMT_NOFILE) {
2829 file_size = avio_size(ic->pb);
2830 file_size = FFMAX(0, file_size);
2833 if ((!strcmp(ic->iformat->name, "mpeg") ||
2834 !strcmp(ic->iformat->name, "mpegts")) &&
2835 file_size && ic->pb->seekable) {
2836 /* get accurate estimate from the PTSes */
2837 estimate_timings_from_pts(ic, old_offset);
2838 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2839 } else if (has_duration(ic)) {
2840 /* at least one component has timings - we use them for all
2842 fill_all_stream_timings(ic);
2843 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2845 /* less precise: use bitrate info */
2846 estimate_timings_from_bit_rate(ic);
2847 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2849 update_stream_timings(ic);
2853 AVStream av_unused *st;
2854 for (i = 0; i < ic->nb_streams; i++) {
2855 st = ic->streams[i];
2856 av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2857 (double) st->start_time * av_q2d(st->time_base),
2858 (double) st->duration * av_q2d(st->time_base));
2860 av_log(ic, AV_LOG_TRACE,
2861 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2862 (double) ic->start_time / AV_TIME_BASE,
2863 (double) ic->duration / AV_TIME_BASE,
2864 (int64_t)ic->bit_rate / 1000);
2868 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2870 AVCodecContext *avctx = st->internal->avctx;
2872 #define FAIL(errmsg) do { \
2874 *errmsg_ptr = errmsg; \
2878 if ( avctx->codec_id == AV_CODEC_ID_NONE
2879 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2880 FAIL("unknown codec");
2881 switch (avctx->codec_type) {
2882 case AVMEDIA_TYPE_AUDIO:
2883 if (!avctx->frame_size && determinable_frame_size(avctx))
2884 FAIL("unspecified frame size");
2885 if (st->info->found_decoder >= 0 &&
2886 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2887 FAIL("unspecified sample format");
2888 if (!avctx->sample_rate)
2889 FAIL("unspecified sample rate");
2890 if (!avctx->channels)
2891 FAIL("unspecified number of channels");
2892 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2893 FAIL("no decodable DTS frames");
2895 case AVMEDIA_TYPE_VIDEO:
2897 FAIL("unspecified size");
2898 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2899 FAIL("unspecified pixel format");
2900 if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2901 if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2902 FAIL("no frame in rv30/40 and no sar");
2904 case AVMEDIA_TYPE_SUBTITLE:
2905 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2906 FAIL("unspecified size");
2908 case AVMEDIA_TYPE_DATA:
2909 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2915 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2916 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2917 AVDictionary **options)
2919 AVCodecContext *avctx = st->internal->avctx;
2920 const AVCodec *codec;
2921 int got_picture = 1, ret = 0;
2922 AVFrame *frame = av_frame_alloc();
2923 AVSubtitle subtitle;
2924 AVPacket pkt = *avpkt;
2925 int do_skip_frame = 0;
2926 enum AVDiscard skip_frame;
2929 return AVERROR(ENOMEM);
2931 if (!avcodec_is_open(avctx) &&
2932 st->info->found_decoder <= 0 &&
2933 (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
2934 AVDictionary *thread_opt = NULL;
2936 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2939 st->info->found_decoder = -st->codecpar->codec_id;
2944 /* Force thread count to 1 since the H.264 decoder will not extract
2945 * SPS and PPS to extradata during multi-threaded decoding. */
2946 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2947 if (s->codec_whitelist)
2948 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2949 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2951 av_dict_free(&thread_opt);
2953 st->info->found_decoder = -avctx->codec_id;
2956 st->info->found_decoder = 1;
2957 } else if (!st->info->found_decoder)
2958 st->info->found_decoder = 1;
2960 if (st->info->found_decoder < 0) {
2965 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2967 skip_frame = avctx->skip_frame;
2968 avctx->skip_frame = AVDISCARD_ALL;
2971 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2973 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2974 (!st->codec_info_nb_frames &&
2975 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2977 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2978 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2979 ret = avcodec_send_packet(avctx, &pkt);
2980 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2984 ret = avcodec_receive_frame(avctx, frame);
2987 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2989 } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2990 ret = avcodec_decode_subtitle2(avctx, &subtitle,
2991 &got_picture, &pkt);
2997 st->nb_decoded_frames++;
3002 if (!pkt.data && !got_picture)
3006 if (do_skip_frame) {
3007 avctx->skip_frame = skip_frame;
3010 av_frame_free(&frame);
3014 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3016 while (tags->id != AV_CODEC_ID_NONE) {
3024 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3027 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3028 if (tag == tags[i].tag)
3030 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3031 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3033 return AV_CODEC_ID_NONE;
3036 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3038 if (bps <= 0 || bps > 64)
3039 return AV_CODEC_ID_NONE;
3044 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3046 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3048 return AV_CODEC_ID_NONE;
3053 if (sflags & (1 << (bps - 1))) {
3056 return AV_CODEC_ID_PCM_S8;
3058 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3060 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3062 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3064 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3066 return AV_CODEC_ID_NONE;
3071 return AV_CODEC_ID_PCM_U8;
3073 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3075 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3077 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3079 return AV_CODEC_ID_NONE;
3085 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3088 if (!av_codec_get_tag2(tags, id, &tag))
3093 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3097 for (i = 0; tags && tags[i]; i++) {
3098 const AVCodecTag *codec_tags = tags[i];
3099 while (codec_tags->id != AV_CODEC_ID_NONE) {
3100 if (codec_tags->id == id) {
3101 *tag = codec_tags->tag;
3110 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3113 for (i = 0; tags && tags[i]; i++) {
3114 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3115 if (id != AV_CODEC_ID_NONE)
3118 return AV_CODEC_ID_NONE;
3121 static void compute_chapters_end(AVFormatContext *s)
3124 int64_t max_time = 0;
3126 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3127 max_time = s->duration +
3128 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3130 for (i = 0; i < s->nb_chapters; i++)
3131 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3132 AVChapter *ch = s->chapters[i];
3133 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3137 for (j = 0; j < s->nb_chapters; j++) {
3138 AVChapter *ch1 = s->chapters[j];
3139 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3141 if (j != i && next_start > ch->start && next_start < end)
3144 ch->end = (end == INT64_MAX) ? ch->start : end;
3148 static int get_std_framerate(int i)
3151 return (i + 1) * 1001;
3155 return (i + 31) * 1001 * 12;
3159 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3163 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3166 /* Is the time base unreliable?
3167 * This is a heuristic to balance between quick acceptance of the values in
3168 * the headers vs. some extra checks.
3169 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3170 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3171 * And there are "variable" fps files this needs to detect as well. */
3172 static int tb_unreliable(AVCodecContext *c)
3174 if (c->time_base.den >= 101LL * c->time_base.num ||
3175 c->time_base.den < 5LL * c->time_base.num ||
3176 // c->codec_tag == AV_RL32("DIVX") ||
3177 // c->codec_tag == AV_RL32("XVID") ||
3178 c->codec_tag == AV_RL32("mp4v") ||
3179 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3180 c->codec_id == AV_CODEC_ID_GIF ||
3181 c->codec_id == AV_CODEC_ID_HEVC ||
3182 c->codec_id == AV_CODEC_ID_H264)
3187 int ff_alloc_extradata(AVCodecParameters *par, int size)
3191 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3192 par->extradata = NULL;
3193 par->extradata_size = 0;
3194 return AVERROR(EINVAL);
3196 par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3197 if (par->extradata) {
3198 memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3199 par->extradata_size = size;
3202 par->extradata_size = 0;
3203 ret = AVERROR(ENOMEM);
3208 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3210 int ret = ff_alloc_extradata(par, size);
3213 ret = avio_read(pb, par->extradata, size);
3215 av_freep(&par->extradata);
3216 par->extradata_size = 0;
3217 av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3218 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3224 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3227 int64_t last = st->info->last_dts;
3229 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3230 && ts - (uint64_t)last < INT64_MAX) {
3231 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3232 int64_t duration = ts - last;
3234 if (!st->info->duration_error)
3235 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3236 if (!st->info->duration_error)
3237 return AVERROR(ENOMEM);
3239 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3240 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3241 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3242 if (st->info->duration_error[0][1][i] < 1e10) {
3243 int framerate = get_std_framerate(i);
3244 double sdts = dts*framerate/(1001*12);
3245 for (j= 0; j<2; j++) {
3246 int64_t ticks = llrint(sdts+j*0.5);
3247 double error= sdts - ticks + j*0.5;
3248 st->info->duration_error[j][0][i] += error;
3249 st->info->duration_error[j][1][i] += error*error;
3253 st->info->duration_count++;
3254 st->info->rfps_duration_sum += duration;
3256 if (st->info->duration_count % 10 == 0) {
3257 int n = st->info->duration_count;
3258 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3259 if (st->info->duration_error[0][1][i] < 1e10) {
3260 double a0 = st->info->duration_error[0][0][i] / n;
3261 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3262 double a1 = st->info->duration_error[1][0][i] / n;
3263 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3264 if (error0 > 0.04 && error1 > 0.04) {
3265 st->info->duration_error[0][1][i] = 2e10;
3266 st->info->duration_error[1][1][i] = 2e10;
3272 // ignore the first 4 values, they might have some random jitter
3273 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3274 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3276 if (ts != AV_NOPTS_VALUE)
3277 st->info->last_dts = ts;
3282 void ff_rfps_calculate(AVFormatContext *ic)
3286 for (i = 0; i < ic->nb_streams; i++) {
3287 AVStream *st = ic->streams[i];
3289 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3291 // the check for tb_unreliable() is not completely correct, since this is not about handling
3292 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3293 // ipmovie.c produces.
3294 if (tb_unreliable(st->internal->avctx) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
3295 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
3296 if (st->info->duration_count>1 && !st->r_frame_rate.num
3297 && tb_unreliable(st->internal->avctx)) {
3299 double best_error= 0.01;
3300 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3302 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3305 if (st->info->codec_info_duration &&
3306 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3308 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3311 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3314 for (k= 0; k<2; k++) {
3315 int n = st->info->duration_count;
3316 double a= st->info->duration_error[k][0][j] / n;
3317 double error= st->info->duration_error[k][1][j]/n - a*a;
3319 if (error < best_error && best_error> 0.000000001) {
3321 num = get_std_framerate(j);
3324 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3327 // do not increase frame rate by more than 1 % in order to match a standard rate.
3328 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3329 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3331 if ( !st->avg_frame_rate.num
3332 && st->r_frame_rate.num && st->info->rfps_duration_sum
3333 && st->info->codec_info_duration <= 0
3334 && st->info->duration_count > 2
3335 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3337 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3338 st->avg_frame_rate = st->r_frame_rate;
3341 av_freep(&st->info->duration_error);
3342 st->info->last_dts = AV_NOPTS_VALUE;
3343 st->info->duration_count = 0;
3344 st->info->rfps_duration_sum = 0;
3348 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3350 int i, count = 0, ret = 0, j;
3353 AVCodecContext *avctx;
3354 AVPacket pkt1, *pkt;
3355 int64_t old_offset = avio_tell(ic->pb);
3356 // new streams might appear, no options for those
3357 int orig_nb_streams = ic->nb_streams;
3359 int64_t max_analyze_duration = ic->max_analyze_duration;
3360 int64_t max_stream_analyze_duration;
3361 int64_t max_subtitle_analyze_duration;
3362 int64_t probesize = ic->probesize;
3363 int eof_reached = 0;
3364 int64_t *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3366 flush_codecs = probesize > 0;
3368 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3370 max_stream_analyze_duration = max_analyze_duration;
3371 max_subtitle_analyze_duration = max_analyze_duration;
3372 if (!max_analyze_duration) {
3373 max_stream_analyze_duration =
3374 max_analyze_duration = 5*AV_TIME_BASE;
3375 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3376 if (!strcmp(ic->iformat->name, "flv"))
3377 max_stream_analyze_duration = 90*AV_TIME_BASE;
3378 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3379 max_stream_analyze_duration = 7*AV_TIME_BASE;
3383 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3384 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3386 for (i = 0; i < ic->nb_streams; i++) {
3387 const AVCodec *codec;
3388 AVDictionary *thread_opt = NULL;
3389 st = ic->streams[i];
3390 avctx = st->internal->avctx;
3392 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3393 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3394 /* if (!st->time_base.num)
3396 if (!avctx->time_base.num)
3397 avctx->time_base = st->time_base;
3400 /* check if the caller has overridden the codec id */
3401 #if FF_API_LAVF_AVCTX
3402 FF_DISABLE_DEPRECATION_WARNINGS
3403 if (st->codec->codec_id != st->internal->orig_codec_id) {
3404 st->codecpar->codec_id = st->codec->codec_id;
3405 st->codecpar->codec_type = st->codec->codec_type;
3406 st->internal->orig_codec_id = st->codec->codec_id;
3408 FF_ENABLE_DEPRECATION_WARNINGS
3410 // only for the split stuff
3411 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3412 st->parser = av_parser_init(st->codecpar->codec_id);
3414 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3415 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3416 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3417 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3419 } else if (st->need_parsing) {
3420 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3421 "%s, packets or times may be invalid.\n",
3422 avcodec_get_name(st->codecpar->codec_id));
3426 if (st->codecpar->codec_id != st->internal->orig_codec_id)
3427 st->internal->orig_codec_id = st->codecpar->codec_id;
3429 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3431 goto find_stream_info_err;
3432 if (st->request_probe <= 0)
3433 st->internal->avctx_inited = 1;
3435 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3437 /* Force thread count to 1 since the H.264 decoder will not extract
3438 * SPS and PPS to extradata during multi-threaded decoding. */
3439 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3441 if (ic->codec_whitelist)
3442 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3444 /* Ensure that subtitle_header is properly set. */
3445 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3446 && codec && !avctx->codec) {
3447 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3448 av_log(ic, AV_LOG_WARNING,
3449 "Failed to open codec in av_find_stream_info\n");
3452 // Try to just open decoders, in case this is enough to get parameters.
3453 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3454 if (codec && !avctx->codec)
3455 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3456 av_log(ic, AV_LOG_WARNING,
3457 "Failed to open codec in av_find_stream_info\n");
3460 av_dict_free(&thread_opt);
3463 for (i = 0; i < ic->nb_streams; i++) {
3464 #if FF_API_R_FRAME_RATE
3465 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3467 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3468 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3473 int analyzed_all_streams;
3474 if (ff_check_interrupt(&ic->interrupt_callback)) {
3476 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3480 /* check if one codec still needs to be handled */
3481 for (i = 0; i < ic->nb_streams; i++) {
3482 int fps_analyze_framecount = 20;
3484 st = ic->streams[i];
3485 if (!has_codec_parameters(st, NULL))
3487 /* If the timebase is coarse (like the usual millisecond precision
3488 * of mkv), we need to analyze more frames to reliably arrive at
3489 * the correct fps. */
3490 if (av_q2d(st->time_base) > 0.0005)
3491 fps_analyze_framecount *= 2;
3492 if (!tb_unreliable(st->internal->avctx))
3493 fps_analyze_framecount = 0;
3494 if (ic->fps_probe_size >= 0)
3495 fps_analyze_framecount = ic->fps_probe_size;
3496 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3497 fps_analyze_framecount = 0;
3498 /* variable fps and no guess at the real fps */
3499 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3500 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3501 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3502 st->info->codec_info_duration_fields/2 :
3503 st->info->duration_count;
3504 if (count < fps_analyze_framecount)
3507 if (st->parser && st->parser->parser->split &&
3508 !st->internal->avctx->extradata)
3510 if (st->first_dts == AV_NOPTS_VALUE &&
3511 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3512 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3513 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3514 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3517 analyzed_all_streams = 0;
3518 if (!missing_streams || !*missing_streams)
3519 if (i == ic->nb_streams) {
3520 analyzed_all_streams = 1;
3521 /* NOTE: If the format has no header, then we need to read some
3522 * packets to get most of the streams, so we cannot stop here. */
3523 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3524 /* If we found the info for all the codecs, we can stop. */
3526 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3531 /* We did not get all the codec info, but we read too much data. */
3532 if (read_size >= probesize) {
3534 av_log(ic, AV_LOG_DEBUG,
3535 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3536 for (i = 0; i < ic->nb_streams; i++)
3537 if (!ic->streams[i]->r_frame_rate.num &&
3538 ic->streams[i]->info->duration_count <= 1 &&
3539 ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3540 strcmp(ic->iformat->name, "image2"))
3541 av_log(ic, AV_LOG_WARNING,
3542 "Stream #%d: not enough frames to estimate rate; "
3543 "consider increasing probesize\n", i);
3547 /* NOTE: A new stream can be added there if no header in file
3548 * (AVFMTCTX_NOHEADER). */
3549 ret = read_frame_internal(ic, &pkt1);
3550 if (ret == AVERROR(EAGAIN))
3561 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3562 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3563 &ic->internal->packet_buffer_end, 0);
3565 goto find_stream_info_err;
3568 st = ic->streams[pkt->stream_index];
3569 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3570 read_size += pkt->size;
3572 avctx = st->internal->avctx;
3573 if (!st->internal->avctx_inited) {
3574 ret = avcodec_parameters_to_context(avctx, st->codecpar);
3576 goto find_stream_info_err;
3577 st->internal->avctx_inited = 1;
3580 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3581 /* check for non-increasing dts */
3582 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3583 st->info->fps_last_dts >= pkt->dts) {
3584 av_log(ic, AV_LOG_DEBUG,
3585 "Non-increasing DTS in stream %d: packet %d with DTS "
3586 "%"PRId64", packet %d with DTS %"PRId64"\n",
3587 st->index, st->info->fps_last_dts_idx,
3588 st->info->fps_last_dts, st->codec_info_nb_frames,
3590 st->info->fps_first_dts =
3591 st->info->fps_last_dts = AV_NOPTS_VALUE;
3593 /* Check for a discontinuity in dts. If the difference in dts
3594 * is more than 1000 times the average packet duration in the
3595 * sequence, we treat it as a discontinuity. */
3596 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3597 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3598 (pkt->dts - st->info->fps_last_dts) / 1000 >
3599 (st->info->fps_last_dts - st->info->fps_first_dts) /
3600 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3601 av_log(ic, AV_LOG_WARNING,
3602 "DTS discontinuity in stream %d: packet %d with DTS "
3603 "%"PRId64", packet %d with DTS %"PRId64"\n",
3604 st->index, st->info->fps_last_dts_idx,
3605 st->info->fps_last_dts, st->codec_info_nb_frames,
3607 st->info->fps_first_dts =
3608 st->info->fps_last_dts = AV_NOPTS_VALUE;
3611 /* update stored dts values */
3612 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3613 st->info->fps_first_dts = pkt->dts;
3614 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3616 st->info->fps_last_dts = pkt->dts;
3617 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3619 if (st->codec_info_nb_frames>1) {
3623 if (st->time_base.den > 0)
3624 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3625 if (st->avg_frame_rate.num > 0)
3626 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3629 && st->codec_info_nb_frames>30
3630 && st->info->fps_first_dts != AV_NOPTS_VALUE
3631 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3632 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3634 if (analyzed_all_streams) limit = max_analyze_duration;
3635 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3636 else limit = max_stream_analyze_duration;
3639 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3641 t, pkt->stream_index);
3642 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3643 av_packet_unref(pkt);
3646 if (pkt->duration) {
3647 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3648 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3650 st->info->codec_info_duration += pkt->duration;
3651 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3654 #if FF_API_R_FRAME_RATE
3655 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
3656 ff_rfps_add_frame(ic, st, pkt->dts);
3658 if (st->parser && st->parser->parser->split && !avctx->extradata) {
3659 int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
3660 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3661 avctx->extradata_size = i;
3662 avctx->extradata = av_mallocz(avctx->extradata_size +
3663 AV_INPUT_BUFFER_PADDING_SIZE);
3664 if (!avctx->extradata)
3665 return AVERROR(ENOMEM);
3666 memcpy(avctx->extradata, pkt->data,
3667 avctx->extradata_size);
3671 /* If still no information, we try to open the codec and to
3672 * decompress the frame. We try to avoid that in most cases as
3673 * it takes longer and uses more memory. For MPEG-4, we need to
3674 * decompress for QuickTime.
3676 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3677 * least one frame of codec data, this makes sure the codec initializes
3678 * the channel configuration and does not only trust the values from
3680 try_decode_frame(ic, st, pkt,
3681 (options && i < orig_nb_streams) ? &options[i] : NULL);
3683 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3684 av_packet_unref(pkt);
3686 st->codec_info_nb_frames++;
3692 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3693 st = ic->streams[stream_index];
3694 avctx = st->internal->avctx;
3695 if (!has_codec_parameters(st, NULL)) {
3696 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3697 if (codec && !avctx->codec) {
3698 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : NULL) < 0)
3699 av_log(ic, AV_LOG_WARNING,
3700 "Failed to open codec in av_find_stream_info\n");
3704 // EOF already reached while reading the stream above.
3705 // So continue with reoordering DTS with whatever delay we have.
3706 if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3707 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3713 AVPacket empty_pkt = { 0 };
3715 av_init_packet(&empty_pkt);
3717 for (i = 0; i < ic->nb_streams; i++) {
3719 st = ic->streams[i];
3721 /* flush the decoders */
3722 if (st->info->found_decoder == 1) {
3724 err = try_decode_frame(ic, st, &empty_pkt,
3725 (options && i < orig_nb_streams)
3726 ? &options[i] : NULL);
3727 } while (err > 0 && !has_codec_parameters(st, NULL));
3730 av_log(ic, AV_LOG_INFO,
3731 "decoding for stream %d failed\n", st->index);
3737 // close codecs which were opened in try_decode_frame()
3738 for (i = 0; i < ic->nb_streams; i++) {
3739 st = ic->streams[i];
3740 avcodec_close(st->internal->avctx);
3743 ff_rfps_calculate(ic);
3745 for (i = 0; i < ic->nb_streams; i++) {
3746 st = ic->streams[i];
3747 avctx = st->internal->avctx;
3748 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3749 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3750 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3751 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3752 avctx->codec_tag= tag;
3755 /* estimate average framerate if not set by demuxer */
3756 if (st->info->codec_info_duration_fields &&
3757 !st->avg_frame_rate.num &&
3758 st->info->codec_info_duration) {
3760 double best_error = 0.01;
3762 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3763 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3764 st->info->codec_info_duration < 0)
3766 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3767 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3768 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3770 /* Round guessed framerate to a "standard" framerate if it's
3771 * within 1% of the original estimate. */
3772 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3773 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3774 double error = fabs(av_q2d(st->avg_frame_rate) /
3775 av_q2d(std_fps) - 1);
3777 if (error < best_error) {
3779 best_fps = std_fps.num;
3783 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3784 best_fps, 12 * 1001, INT_MAX);
3787 if (!st->r_frame_rate.num) {
3788 if ( avctx->time_base.den * (int64_t) st->time_base.num
3789 <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
3790 st->r_frame_rate.num = avctx->time_base.den;
3791 st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
3793 st->r_frame_rate.num = st->time_base.den;
3794 st->r_frame_rate.den = st->time_base.num;
3797 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3798 AVRational hw_ratio = { avctx->height, avctx->width };
3799 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3802 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3803 if (!avctx->bits_per_coded_sample)
3804 avctx->bits_per_coded_sample =
3805 av_get_bits_per_sample(avctx->codec_id);
3806 // set stream disposition based on audio service type
3807 switch (avctx->audio_service_type) {
3808 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3809 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3811 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3812 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3814 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3815 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3817 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3818 st->disposition = AV_DISPOSITION_COMMENT;
3820 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3821 st->disposition = AV_DISPOSITION_KARAOKE;
3828 estimate_timings(ic, old_offset);
3830 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3832 if (ret >= 0 && ic->nb_streams)
3833 /* We could not have all the codec parameters before EOF. */
3835 for (i = 0; i < ic->nb_streams; i++) {
3837 st = ic->streams[i];
3839 /* if no packet was ever seen, update context now for has_codec_parameters */
3840 if (!st->internal->avctx_inited) {
3841 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3842 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3843 st->codecpar->format = st->internal->avctx->sample_fmt;
3844 ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
3846 goto find_stream_info_err;
3848 if (!has_codec_parameters(st, &errmsg)) {
3850 avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
3851 av_log(ic, AV_LOG_WARNING,
3852 "Could not find codec parameters for stream %d (%s): %s\n"
3853 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3860 compute_chapters_end(ic);
3862 /* update the stream parameters from the internal codec contexts */
3863 for (i = 0; i < ic->nb_streams; i++) {
3864 st = ic->streams[i];
3866 if (st->internal->avctx_inited) {
3867 int orig_w = st->codecpar->width;
3868 int orig_h = st->codecpar->height;
3869 ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
3871 goto find_stream_info_err;
3872 // The decoder might reduce the video size by the lowres factor.
3873 if (av_codec_get_lowres(st->internal->avctx) && orig_w) {
3874 st->codecpar->width = orig_w;
3875 st->codecpar->height = orig_h;
3879 #if FF_API_LAVF_AVCTX
3880 FF_DISABLE_DEPRECATION_WARNINGS
3881 ret = avcodec_parameters_to_context(st->codec, st->codecpar);
3883 goto find_stream_info_err;
3885 // The old API (AVStream.codec) "requires" the resolution to be adjusted
3886 // by the lowres factor.
3887 if (av_codec_get_lowres(st->internal->avctx) && st->internal->avctx->width) {
3888 av_codec_set_lowres(st->codec, av_codec_get_lowres(st->internal->avctx));
3889 st->codec->width = st->internal->avctx->width;
3890 st->codec->height = st->internal->avctx->height;
3893 if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
3894 st->codec->time_base = st->internal->avctx->time_base;
3895 st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
3897 st->codec->framerate = st->avg_frame_rate;
3899 if (st->internal->avctx->subtitle_header) {
3900 st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
3901 if (!st->codec->subtitle_header)
3902 goto find_stream_info_err;
3903 st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
3904 memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
3905 st->codec->subtitle_header_size);
3908 // Fields unavailable in AVCodecParameters
3909 st->codec->coded_width = st->internal->avctx->coded_width;
3910 st->codec->coded_height = st->internal->avctx->coded_height;
3911 st->codec->properties = st->internal->avctx->properties;
3912 FF_ENABLE_DEPRECATION_WARNINGS
3915 st->internal->avctx_inited = 0;
3918 find_stream_info_err:
3919 for (i = 0; i < ic->nb_streams; i++) {
3920 st = ic->streams[i];
3922 av_freep(&st->info->duration_error);
3923 av_freep(&ic->streams[i]->info);
3926 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3927 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3931 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3935 for (i = 0; i < ic->nb_programs; i++) {
3936 if (ic->programs[i] == last) {
3940 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3941 if (ic->programs[i]->stream_index[j] == s)
3942 return ic->programs[i];
3948 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3949 int wanted_stream_nb, int related_stream,
3950 AVCodec **decoder_ret, int flags)
3952 int i, nb_streams = ic->nb_streams;
3953 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3954 unsigned *program = NULL;
3955 const AVCodec *decoder = NULL, *best_decoder = NULL;
3957 if (related_stream >= 0 && wanted_stream_nb < 0) {
3958 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3960 program = p->stream_index;
3961 nb_streams = p->nb_stream_indexes;
3964 for (i = 0; i < nb_streams; i++) {
3965 int real_stream_index = program ? program[i] : i;
3966 AVStream *st = ic->streams[real_stream_index];
3967 AVCodecParameters *par = st->codecpar;
3968 if (par->codec_type != type)
3970 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3972 if (wanted_stream_nb != real_stream_index &&
3973 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3974 AV_DISPOSITION_VISUAL_IMPAIRED))
3976 if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
3979 decoder = find_decoder(ic, st, par->codec_id);
3982 ret = AVERROR_DECODER_NOT_FOUND;
3986 count = st->codec_info_nb_frames;
3987 bitrate = par->bit_rate;
3988 multiframe = FFMIN(5, count);
3989 if ((best_multiframe > multiframe) ||
3990 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3991 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3994 best_bitrate = bitrate;
3995 best_multiframe = multiframe;
3996 ret = real_stream_index;
3997 best_decoder = decoder;
3998 if (program && i == nb_streams - 1 && ret < 0) {
4000 nb_streams = ic->nb_streams;
4001 /* no related stream found, try again with everything */
4006 *decoder_ret = (AVCodec*)best_decoder;
4010 /*******************************************************/
4012 int av_read_play(AVFormatContext *s)
4014 if (s->iformat->read_play)
4015 return s->iformat->read_play(s);
4017 return avio_pause(s->pb, 0);
4018 return AVERROR(ENOSYS);
4021 int av_read_pause(AVFormatContext *s)
4023 if (s->iformat->read_pause)
4024 return s->iformat->read_pause(s);
4026 return avio_pause(s->pb, 1);
4027 return AVERROR(ENOSYS);
4030 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4035 dst->time_base = src->time_base;
4036 dst->nb_frames = src->nb_frames;
4037 dst->disposition = src->disposition;
4038 dst->sample_aspect_ratio = src->sample_aspect_ratio;
4039 dst->avg_frame_rate = src->avg_frame_rate;
4040 dst->r_frame_rate = src->r_frame_rate;
4042 av_dict_free(&dst->metadata);
4043 ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4047 ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4051 /* Free existing side data*/
4052 for (i = 0; i < dst->nb_side_data; i++)
4053 av_free(dst->side_data[i].data);
4054 av_freep(&dst->side_data);
4055 dst->nb_side_data = 0;
4057 /* Copy side data if present */
4058 if (src->nb_side_data) {
4059 dst->side_data = av_mallocz_array(src->nb_side_data,
4060 sizeof(AVPacketSideData));
4061 if (!dst->side_data)
4062 return AVERROR(ENOMEM);
4063 dst->nb_side_data = src->nb_side_data;
4065 for (i = 0; i < src->nb_side_data; i++) {
4066 uint8_t *data = av_memdup(src->side_data[i].data,
4067 src->side_data[i].size);
4069 return AVERROR(ENOMEM);
4070 dst->side_data[i].type = src->side_data[i].type;
4071 dst->side_data[i].size = src->side_data[i].size;
4072 dst->side_data[i].data = data;
4076 av_freep(&dst->recommended_encoder_configuration);
4077 if (src->recommended_encoder_configuration) {
4078 const char *conf_str = src->recommended_encoder_configuration;
4079 dst->recommended_encoder_configuration = av_strdup(conf_str);
4080 if (!dst->recommended_encoder_configuration)
4081 return AVERROR(ENOMEM);
4087 static void free_stream(AVStream **pst)
4089 AVStream *st = *pst;
4095 for (i = 0; i < st->nb_side_data; i++)
4096 av_freep(&st->side_data[i].data);
4097 av_freep(&st->side_data);
4100 av_parser_close(st->parser);
4102 if (st->attached_pic.data)
4103 av_packet_unref(&st->attached_pic);
4106 avcodec_free_context(&st->internal->avctx);
4107 for (i = 0; i < st->internal->nb_bsfcs; i++) {
4108 av_bsf_free(&st->internal->bsfcs[i]);
4109 av_freep(&st->internal->bsfcs);
4112 av_freep(&st->internal);
4114 av_dict_free(&st->metadata);
4115 avcodec_parameters_free(&st->codecpar);
4116 av_freep(&st->probe_data.buf);
4117 av_freep(&st->index_entries);
4118 #if FF_API_LAVF_AVCTX
4119 FF_DISABLE_DEPRECATION_WARNINGS
4120 av_freep(&st->codec->extradata);
4121 av_freep(&st->codec->subtitle_header);
4122 av_freep(&st->codec);
4123 FF_ENABLE_DEPRECATION_WARNINGS
4125 av_freep(&st->priv_data);
4127 av_freep(&st->info->duration_error);
4128 av_freep(&st->info);
4129 av_freep(&st->recommended_encoder_configuration);
4130 av_freep(&st->priv_pts);
4135 void ff_free_stream(AVFormatContext *s, AVStream *st)
4137 av_assert0(s->nb_streams>0);
4138 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4140 free_stream(&s->streams[ --s->nb_streams ]);
4143 void avformat_free_context(AVFormatContext *s)
4151 if (s->iformat && s->iformat->priv_class && s->priv_data)
4152 av_opt_free(s->priv_data);
4153 if (s->oformat && s->oformat->priv_class && s->priv_data)
4154 av_opt_free(s->priv_data);
4156 for (i = s->nb_streams - 1; i >= 0; i--)
4157 ff_free_stream(s, s->streams[i]);
4160 for (i = s->nb_programs - 1; i >= 0; i--) {
4161 av_dict_free(&s->programs[i]->metadata);
4162 av_freep(&s->programs[i]->stream_index);
4163 av_freep(&s->programs[i]);
4165 av_freep(&s->programs);
4166 av_freep(&s->priv_data);
4167 while (s->nb_chapters--) {
4168 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4169 av_freep(&s->chapters[s->nb_chapters]);
4171 av_freep(&s->chapters);
4172 av_dict_free(&s->metadata);
4173 av_freep(&s->streams);
4174 av_freep(&s->internal);
4175 flush_packet_queue(s);
4179 void avformat_close_input(AVFormatContext **ps)
4190 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4191 (s->flags & AVFMT_FLAG_CUSTOM_IO))
4194 flush_packet_queue(s);
4197 if (s->iformat->read_close)
4198 s->iformat->read_close(s);
4200 avformat_free_context(s);
4207 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4213 if (s->nb_streams >= INT_MAX/sizeof(*streams))
4215 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4218 s->streams = streams;
4220 st = av_mallocz(sizeof(AVStream));
4223 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4227 st->info->last_dts = AV_NOPTS_VALUE;
4229 #if FF_API_LAVF_AVCTX
4230 FF_DISABLE_DEPRECATION_WARNINGS
4231 st->codec = avcodec_alloc_context3(c);
4237 FF_ENABLE_DEPRECATION_WARNINGS
4240 st->internal = av_mallocz(sizeof(*st->internal));
4244 st->codecpar = avcodec_parameters_alloc();
4248 st->internal->avctx = avcodec_alloc_context3(NULL);
4249 if (!st->internal->avctx)
4253 #if FF_API_LAVF_AVCTX
4254 FF_DISABLE_DEPRECATION_WARNINGS
4255 /* no default bitrate if decoding */
4256 st->codec->bit_rate = 0;
4257 FF_ENABLE_DEPRECATION_WARNINGS
4260 /* default pts setting is MPEG-like */
4261 avpriv_set_pts_info(st, 33, 1, 90000);
4262 /* we set the current DTS to 0 so that formats without any timestamps
4263 * but durations get some timestamps, formats with some unknown
4264 * timestamps have their first few packets buffered and the
4265 * timestamps corrected before they are returned to the user */
4266 st->cur_dts = RELATIVE_TS_BASE;
4268 st->cur_dts = AV_NOPTS_VALUE;
4271 st->index = s->nb_streams;
4272 st->start_time = AV_NOPTS_VALUE;
4273 st->duration = AV_NOPTS_VALUE;
4274 st->first_dts = AV_NOPTS_VALUE;
4275 st->probe_packets = MAX_PROBE_PACKETS;
4276 st->pts_wrap_reference = AV_NOPTS_VALUE;
4277 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4279 st->last_IP_pts = AV_NOPTS_VALUE;
4280 st->last_dts_for_order_check = AV_NOPTS_VALUE;
4281 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4282 st->pts_buffer[i] = AV_NOPTS_VALUE;
4284 st->sample_aspect_ratio = (AVRational) { 0, 1 };
4286 #if FF_API_R_FRAME_RATE
4287 st->info->last_dts = AV_NOPTS_VALUE;
4289 st->info->fps_first_dts = AV_NOPTS_VALUE;
4290 st->info->fps_last_dts = AV_NOPTS_VALUE;
4292 st->inject_global_side_data = s->internal->inject_global_side_data;
4294 st->internal->need_context_update = 1;
4296 s->streams[s->nb_streams++] = st;
4303 AVProgram *av_new_program(AVFormatContext *ac, int id)
4305 AVProgram *program = NULL;
4308 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4310 for (i = 0; i < ac->nb_programs; i++)
4311 if (ac->programs[i]->id == id)
4312 program = ac->programs[i];
4315 program = av_mallocz(sizeof(AVProgram));
4318 dynarray_add(&ac->programs, &ac->nb_programs, program);
4319 program->discard = AVDISCARD_NONE;
4322 program->pts_wrap_reference = AV_NOPTS_VALUE;
4323 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4325 program->start_time =
4326 program->end_time = AV_NOPTS_VALUE;
4331 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4332 int64_t start, int64_t end, const char *title)
4334 AVChapter *chapter = NULL;
4337 if (end != AV_NOPTS_VALUE && start > end) {
4338 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4342 for (i = 0; i < s->nb_chapters; i++)
4343 if (s->chapters[i]->id == id)
4344 chapter = s->chapters[i];
4347 chapter = av_mallocz(sizeof(AVChapter));
4350 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4352 av_dict_set(&chapter->metadata, "title", title, 0);
4354 chapter->time_base = time_base;
4355 chapter->start = start;
4361 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4364 AVProgram *program = NULL;
4367 if (idx >= ac->nb_streams) {
4368 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4372 for (i = 0; i < ac->nb_programs; i++) {
4373 if (ac->programs[i]->id != progid)
4375 program = ac->programs[i];
4376 for (j = 0; j < program->nb_stream_indexes; j++)
4377 if (program->stream_index[j] == idx)
4380 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4383 program->stream_index = tmp;
4384 program->stream_index[program->nb_stream_indexes++] = idx;
4389 uint64_t ff_ntp_time(void)
4391 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4394 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4397 char *q, buf1[20], c;
4398 int nd, len, percentd_found;
4410 while (av_isdigit(*p))
4411 nd = nd * 10 + *p++ - '0';
4413 } while (av_isdigit(c));
4419 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4424 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4426 if ((q - buf + len) > buf_size - 1)
4428 memcpy(q, buf1, len);
4436 if ((q - buf) < buf_size - 1)
4440 if (!percentd_found)
4449 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4451 return av_get_frame_filename2(buf, buf_size, path, number, 0);
4454 void av_url_split(char *proto, int proto_size,
4455 char *authorization, int authorization_size,
4456 char *hostname, int hostname_size,
4457 int *port_ptr, char *path, int path_size, const char *url)
4459 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4465 if (authorization_size > 0)
4466 authorization[0] = 0;
4467 if (hostname_size > 0)
4472 /* parse protocol */
4473 if ((p = strchr(url, ':'))) {
4474 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4481 /* no protocol means plain filename */
4482 av_strlcpy(path, url, path_size);
4486 /* separate path from hostname */
4487 ls = strchr(p, '/');
4488 ls2 = strchr(p, '?');
4492 ls = FFMIN(ls, ls2);
4494 av_strlcpy(path, ls, path_size);
4496 ls = &p[strlen(p)]; // XXX
4498 /* the rest is hostname, use that to parse auth/port */
4500 /* authorization (user[:pass]@hostname) */
4502 while ((at = strchr(p, '@')) && at < ls) {
4503 av_strlcpy(authorization, at2,
4504 FFMIN(authorization_size, at + 1 - at2));
4505 p = at + 1; /* skip '@' */
4508 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4510 av_strlcpy(hostname, p + 1,
4511 FFMIN(hostname_size, brk - p));
4512 if (brk[1] == ':' && port_ptr)
4513 *port_ptr = atoi(brk + 2);
4514 } else if ((col = strchr(p, ':')) && col < ls) {
4515 av_strlcpy(hostname, p,
4516 FFMIN(col + 1 - p, hostname_size));
4518 *port_ptr = atoi(col + 1);
4520 av_strlcpy(hostname, p,
4521 FFMIN(ls + 1 - p, hostname_size));
4525 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4528 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4531 'C', 'D', 'E', 'F' };
4532 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4535 'c', 'd', 'e', 'f' };
4536 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4538 for (i = 0; i < s; i++) {
4539 buff[i * 2] = hex_table[src[i] >> 4];
4540 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4546 int ff_hex_to_data(uint8_t *data, const char *p)
4553 p += strspn(p, SPACE_CHARS);
4556 c = av_toupper((unsigned char) *p++);
4557 if (c >= '0' && c <= '9')
4559 else if (c >= 'A' && c <= 'F')
4574 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4575 unsigned int pts_num, unsigned int pts_den)
4578 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4579 if (new_tb.num != pts_num)
4580 av_log(NULL, AV_LOG_DEBUG,
4581 "st:%d removing common factor %d from timebase\n",
4582 s->index, pts_num / new_tb.num);
4584 av_log(NULL, AV_LOG_WARNING,
4585 "st:%d has too large timebase, reducing\n", s->index);
4587 if (new_tb.num <= 0 || new_tb.den <= 0) {
4588 av_log(NULL, AV_LOG_ERROR,
4589 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4590 new_tb.num, new_tb.den,
4594 s->time_base = new_tb;
4595 #if FF_API_LAVF_AVCTX
4596 FF_DISABLE_DEPRECATION_WARNINGS
4597 av_codec_set_pkt_timebase(s->codec, new_tb);
4598 FF_ENABLE_DEPRECATION_WARNINGS
4600 av_codec_set_pkt_timebase(s->internal->avctx, new_tb);
4601 s->pts_wrap_bits = pts_wrap_bits;
4604 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4607 const char *ptr = str;
4609 /* Parse key=value pairs. */
4612 char *dest = NULL, *dest_end;
4613 int key_len, dest_len = 0;
4615 /* Skip whitespace and potential commas. */
4616 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4623 if (!(ptr = strchr(key, '=')))
4626 key_len = ptr - key;
4628 callback_get_buf(context, key, key_len, &dest, &dest_len);
4629 dest_end = dest + dest_len - 1;
4633 while (*ptr && *ptr != '\"') {
4637 if (dest && dest < dest_end)
4641 if (dest && dest < dest_end)
4649 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4650 if (dest && dest < dest_end)
4658 int ff_find_stream_index(AVFormatContext *s, int id)
4661 for (i = 0; i < s->nb_streams; i++)
4662 if (s->streams[i]->id == id)
4667 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4671 unsigned int codec_tag;
4672 if (ofmt->query_codec)
4673 return ofmt->query_codec(codec_id, std_compliance);
4674 else if (ofmt->codec_tag)
4675 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4676 else if (codec_id == ofmt->video_codec ||
4677 codec_id == ofmt->audio_codec ||
4678 codec_id == ofmt->subtitle_codec ||
4679 codec_id == ofmt->data_codec)
4682 return AVERROR_PATCHWELCOME;
4685 int avformat_network_init(void)
4689 ff_network_inited_globally = 1;
4690 if ((ret = ff_network_init()) < 0)
4692 if ((ret = ff_tls_init()) < 0)
4698 int avformat_network_deinit(void)
4703 ff_network_inited_globally = 0;
4708 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4709 uint64_t channel_layout, int32_t sample_rate,
4710 int32_t width, int32_t height)
4716 return AVERROR(EINVAL);
4719 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4721 if (channel_layout) {
4723 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4727 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4729 if (width || height) {
4731 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4733 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4735 return AVERROR(ENOMEM);
4736 bytestream_put_le32(&data, flags);
4738 bytestream_put_le32(&data, channels);
4740 bytestream_put_le64(&data, channel_layout);
4742 bytestream_put_le32(&data, sample_rate);
4743 if (width || height) {
4744 bytestream_put_le32(&data, width);
4745 bytestream_put_le32(&data, height);
4750 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4752 AVRational undef = {0, 1};
4753 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4754 AVRational codec_sample_aspect_ratio = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4755 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4757 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4758 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4759 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4760 stream_sample_aspect_ratio = undef;
4762 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4763 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4764 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4765 frame_sample_aspect_ratio = undef;
4767 if (stream_sample_aspect_ratio.num)
4768 return stream_sample_aspect_ratio;
4770 return frame_sample_aspect_ratio;
4773 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4775 AVRational fr = st->r_frame_rate;
4776 AVRational codec_fr = st->internal->avctx->framerate;
4777 AVRational avg_fr = st->avg_frame_rate;
4779 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4780 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4785 if (st->internal->avctx->ticks_per_frame > 1) {
4786 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4787 (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))
4794 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4797 if (*spec <= '9' && *spec >= '0') /* opt:index */
4798 return strtol(spec, NULL, 0) == st->index;
4799 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4800 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4801 enum AVMediaType type;
4805 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4806 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4807 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4808 case 'd': type = AVMEDIA_TYPE_DATA; break;
4809 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4810 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4811 default: av_assert0(0);
4813 #if FF_API_LAVF_AVCTX
4814 FF_DISABLE_DEPRECATION_WARNINGS
4815 if (type != st->codecpar->codec_type
4816 && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
4818 FF_ENABLE_DEPRECATION_WARNINGS
4820 if (type != st->codecpar->codec_type)
4823 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4825 if (*spec++ == ':') { /* possibly followed by :index */
4826 int i, index = strtol(spec, NULL, 0);
4827 for (i = 0; i < s->nb_streams; i++) {
4828 #if FF_API_LAVF_AVCTX
4829 FF_DISABLE_DEPRECATION_WARNINGS
4830 if ((s->streams[i]->codecpar->codec_type == type
4831 || s->streams[i]->codec->codec_type == type
4833 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4835 return i == st->index;
4836 FF_ENABLE_DEPRECATION_WARNINGS
4838 if ((s->streams[i]->codecpar->codec_type == type) &&
4839 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4841 return i == st->index;
4847 } else if (*spec == 'p' && *(spec + 1) == ':') {
4851 prog_id = strtol(spec, &endptr, 0);
4852 for (i = 0; i < s->nb_programs; i++) {
4853 if (s->programs[i]->id != prog_id)
4856 if (*endptr++ == ':') {
4857 int stream_idx = strtol(endptr, NULL, 0);
4858 return stream_idx >= 0 &&
4859 stream_idx < s->programs[i]->nb_stream_indexes &&
4860 st->index == s->programs[i]->stream_index[stream_idx];
4863 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4864 if (st->index == s->programs[i]->stream_index[j])
4868 } else if (*spec == '#' ||
4869 (*spec == 'i' && *(spec + 1) == ':')) {
4872 spec += 1 + (*spec == 'i');
4873 stream_id = strtol(spec, &endptr, 0);
4875 return stream_id == st->id;
4876 } else if (*spec == 'm' && *(spec + 1) == ':') {
4877 AVDictionaryEntry *tag;
4882 val = strchr(spec, ':');
4884 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4886 return AVERROR(ENOMEM);
4888 tag = av_dict_get(st->metadata, key, NULL, 0);
4890 if (!val || !strcmp(tag->value, val + 1))
4899 } else if (*spec == 'u') {
4900 AVCodecParameters *par = st->codecpar;
4901 #if FF_API_LAVF_AVCTX
4902 FF_DISABLE_DEPRECATION_WARNINGS
4903 AVCodecContext *codec = st->codec;
4904 FF_ENABLE_DEPRECATION_WARNINGS
4907 switch (par->codec_type) {
4908 case AVMEDIA_TYPE_AUDIO:
4909 val = par->sample_rate && par->channels;
4910 #if FF_API_LAVF_AVCTX
4911 val = val || (codec->sample_rate && codec->channels);
4913 if (par->format == AV_SAMPLE_FMT_NONE
4914 #if FF_API_LAVF_AVCTX
4915 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
4920 case AVMEDIA_TYPE_VIDEO:
4921 val = par->width && par->height;
4922 #if FF_API_LAVF_AVCTX
4923 val = val || (codec->width && codec->height);
4925 if (par->format == AV_PIX_FMT_NONE
4926 #if FF_API_LAVF_AVCTX
4927 && codec->pix_fmt == AV_PIX_FMT_NONE
4932 case AVMEDIA_TYPE_UNKNOWN:
4939 #if FF_API_LAVF_AVCTX
4940 return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
4942 return par->codec_id != AV_CODEC_ID_NONE && val != 0;
4944 } else if (!*spec) /* empty specifier, matches everything */
4947 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4948 return AVERROR(EINVAL);
4951 int ff_generate_avci_extradata(AVStream *st)
4953 static const uint8_t avci100_1080p_extradata[] = {
4955 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4956 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4957 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4958 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4959 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4960 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4961 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4962 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4963 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4965 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4968 static const uint8_t avci100_1080i_extradata[] = {
4970 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4971 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4972 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4973 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4974 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4975 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4976 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4977 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4978 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4979 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4980 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4982 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4985 static const uint8_t avci50_1080p_extradata[] = {
4987 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4988 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4989 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4990 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4991 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4992 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4993 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4994 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4995 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4997 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5000 static const uint8_t avci50_1080i_extradata[] = {
5002 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5003 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5004 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5005 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5006 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5007 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5008 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5009 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5010 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5011 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5012 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5014 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5017 static const uint8_t avci100_720p_extradata[] = {
5019 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5020 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5021 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5022 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5023 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5024 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5025 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5026 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5027 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5028 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5030 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5033 static const uint8_t avci50_720p_extradata[] = {
5035 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5036 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5037 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5038 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5039 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5040 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5041 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5042 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5043 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5045 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5049 const uint8_t *data = NULL;
5052 if (st->codecpar->width == 1920) {
5053 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5054 data = avci100_1080p_extradata;
5055 size = sizeof(avci100_1080p_extradata);
5057 data = avci100_1080i_extradata;
5058 size = sizeof(avci100_1080i_extradata);
5060 } else if (st->codecpar->width == 1440) {
5061 if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5062 data = avci50_1080p_extradata;
5063 size = sizeof(avci50_1080p_extradata);
5065 data = avci50_1080i_extradata;
5066 size = sizeof(avci50_1080i_extradata);
5068 } else if (st->codecpar->width == 1280) {
5069 data = avci100_720p_extradata;
5070 size = sizeof(avci100_720p_extradata);
5071 } else if (st->codecpar->width == 960) {
5072 data = avci50_720p_extradata;
5073 size = sizeof(avci50_720p_extradata);
5079 av_freep(&st->codecpar->extradata);
5080 if (ff_alloc_extradata(st->codecpar, size))
5081 return AVERROR(ENOMEM);
5082 memcpy(st->codecpar->extradata, data, size);
5087 #if FF_API_NOCONST_GET_SIDE_DATA
5088 uint8_t *av_stream_get_side_data(AVStream *st,
5089 enum AVPacketSideDataType type, int *size)
5091 uint8_t *av_stream_get_side_data(const AVStream *st,
5092 enum AVPacketSideDataType type, int *size)
5097 for (i = 0; i < st->nb_side_data; i++) {
5098 if (st->side_data[i].type == type) {
5100 *size = st->side_data[i].size;
5101 return st->side_data[i].data;
5107 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5110 AVPacketSideData *sd, *tmp;
5112 uint8_t *data = av_malloc(size);
5117 for (i = 0; i < st->nb_side_data; i++) {
5118 sd = &st->side_data[i];
5120 if (sd->type == type) {
5121 av_freep(&sd->data);
5128 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
5134 st->side_data = tmp;
5137 sd = &st->side_data[st->nb_side_data - 1];
5144 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5147 const AVBitStreamFilter *bsf;
5149 AVCodecParameters *in_par;
5151 if (!(bsf = av_bsf_get_by_name(name))) {
5152 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5153 return AVERROR_BSF_NOT_FOUND;
5156 if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5159 if (st->internal->nb_bsfcs) {
5160 in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5161 bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5163 in_par = st->codecpar;
5164 bsfc->time_base_in = st->time_base;
5167 if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5172 if (args && bsfc->filter->priv_class) {
5173 const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5174 const char * shorthand[2] = {NULL};
5177 shorthand[0] = opt->name;
5179 if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5185 if ((ret = av_bsf_init(bsfc)) < 0) {
5190 if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5195 av_log(NULL, AV_LOG_VERBOSE,
5196 "Automatically inserted bitstream filter '%s'; args='%s'\n",
5197 name, args ? args : "");
5202 FF_DISABLE_DEPRECATION_WARNINGS
5203 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5204 AVBitStreamFilterContext *bsfc)
5208 AVPacket new_pkt = *pkt;
5209 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5210 &new_pkt.data, &new_pkt.size,
5211 pkt->data, pkt->size,
5212 pkt->flags & AV_PKT_FLAG_KEY);
5213 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5214 av_packet_unref(pkt);
5215 memset(pkt, 0, sizeof(*pkt));
5218 if(a == 0 && new_pkt.data != pkt->data) {
5219 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5221 memcpy(t, new_pkt.data, new_pkt.size);
5222 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5227 a = AVERROR(ENOMEM);
5231 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5232 av_buffer_default_free, NULL, 0);
5234 pkt->side_data = NULL;
5235 pkt->side_data_elems = 0;
5236 av_packet_unref(pkt);
5238 av_freep(&new_pkt.data);
5239 a = AVERROR(ENOMEM);
5243 av_log(codec, AV_LOG_ERROR,
5244 "Failed to open bitstream filter %s for stream %d with codec %s",
5245 bsfc->filter->name, pkt->stream_index,
5246 codec->codec ? codec->codec->name : "copy");
5256 FF_ENABLE_DEPRECATION_WARNINGS
5259 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5262 return AVERROR(EINVAL);
5264 if (!(s->oformat->flags & AVFMT_NOFILE))
5265 return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5269 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5272 s->io_close(s, *pb);
5276 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5278 AVDictionaryEntry *entry;
5279 int64_t parsed_timestamp;
5281 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5282 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5283 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5286 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5293 int ff_standardize_creation_time(AVFormatContext *s)
5296 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
5298 return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5302 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5307 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5309 if (size != AVPALETTE_SIZE) {
5310 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5311 return AVERROR_INVALIDDATA;
5313 memcpy(palette, side_data, AVPALETTE_SIZE);
5317 if (ret == CONTAINS_PAL) {
5319 for (i = 0; i < AVPALETTE_COUNT; i++)
5320 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5327 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5332 ret = av_bprint_finalize(buf, &str);
5335 if (!av_bprint_is_complete(buf)) {
5337 return AVERROR(ENOMEM);
5340 par->extradata = str;
5341 /* Note: the string is NUL terminated (so extradata can be read as a
5342 * string), but the ending character is not accounted in the size (in
5343 * binary formats you are likely not supposed to mux that character). When
5344 * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5346 par->extradata_size = buf->len;
5350 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5351 AVStream *ost, const AVStream *ist,
5352 enum AVTimebaseSource copy_tb)
5354 //TODO: use [io]st->internal->avctx
5355 const AVCodecContext *dec_ctx = ist->codec;
5356 AVCodecContext *enc_ctx = ost->codec;
5358 enc_ctx->time_base = ist->time_base;
5360 * Avi is a special case here because it supports variable fps but
5361 * having the fps and timebase differe significantly adds quite some
5364 if (!strcmp(ofmt->name, "avi")) {
5365 #if FF_API_R_FRAME_RATE
5366 if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5367 && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5368 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5369 && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5370 && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5371 || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5372 enc_ctx->time_base.num = ist->r_frame_rate.den;
5373 enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5374 enc_ctx->ticks_per_frame = 2;
5377 if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5378 && av_q2d(ist->time_base) < 1.0/500
5379 || copy_tb == AVFMT_TBCF_DECODER) {
5380 enc_ctx->time_base = dec_ctx->time_base;
5381 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5382 enc_ctx->time_base.den *= 2;
5383 enc_ctx->ticks_per_frame = 2;
5385 } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5386 && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5387 if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5388 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5389 && av_q2d(ist->time_base) < 1.0/500
5390 || copy_tb == AVFMT_TBCF_DECODER) {
5391 enc_ctx->time_base = dec_ctx->time_base;
5392 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5396 if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5397 && dec_ctx->time_base.num < dec_ctx->time_base.den
5398 && dec_ctx->time_base.num > 0
5399 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5400 enc_ctx->time_base = dec_ctx->time_base;
5403 if (ost->avg_frame_rate.num)
5404 enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5406 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5407 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5412 AVRational av_stream_get_codec_timebase(const AVStream *st)
5414 // See avformat_transfer_internal_stream_timing_info() TODO.
5415 #if FF_API_LAVF_AVCTX
5416 FF_DISABLE_DEPRECATION_WARNINGS
5417 return st->codec->time_base;
5418 FF_ENABLE_DEPRECATION_WARNINGS
5420 return st->internal->avctx->time_base;