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
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
58 * various utility functions for use within FFmpeg
61 unsigned avformat_version(void)
63 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
64 return LIBAVFORMAT_VERSION_INT;
67 const char *avformat_configuration(void)
69 return FFMPEG_CONFIGURATION;
72 const char *avformat_license(void)
74 #define LICENSE_PREFIX "libavformat license: "
75 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 static int is_relative(int64_t ts) {
81 return ts > (RELATIVE_TS_BASE - (1LL<<48));
85 * Wrap a given time stamp, if there is an indication for an overflow
88 * @param timestamp the time stamp to wrap
89 * @return resulting time stamp
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
93 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
94 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
95 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
96 timestamp < st->pts_wrap_reference)
97 return timestamp + (1ULL << st->pts_wrap_bits);
98 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99 timestamp >= st->pts_wrap_reference)
100 return timestamp - (1ULL << st->pts_wrap_bits);
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
113 int64_t av_stream_get_end_pts(const AVStream *st)
118 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
123 void av_format_inject_global_side_data(AVFormatContext *s)
126 s->internal->inject_global_side_data = 1;
127 for (i = 0; i < s->nb_streams; i++) {
128 AVStream *st = s->streams[i];
129 st->inject_global_side_data = 1;
133 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
135 if (st->codec->codec)
136 return st->codec->codec;
138 switch (st->codec->codec_type) {
139 case AVMEDIA_TYPE_VIDEO:
140 if (s->video_codec) return s->video_codec;
142 case AVMEDIA_TYPE_AUDIO:
143 if (s->audio_codec) return s->audio_codec;
145 case AVMEDIA_TYPE_SUBTITLE:
146 if (s->subtitle_codec) return s->subtitle_codec;
150 return avcodec_find_decoder(codec_id);
153 int av_format_get_probe_score(const AVFormatContext *s)
155 return s->probe_score;
158 /* an arbitrarily chosen "sane" max packet size -- 50M */
159 #define SANE_CHUNK_SIZE (50000000)
161 int ffio_limit(AVIOContext *s, int size)
163 if (s->maxsize>= 0) {
164 int64_t remaining= s->maxsize - avio_tell(s);
165 if (remaining < size) {
166 int64_t newsize = avio_size(s);
167 if (!s->maxsize || s->maxsize<newsize)
168 s->maxsize = newsize - !newsize;
169 remaining= s->maxsize - avio_tell(s);
170 remaining= FFMAX(remaining, 0);
173 if (s->maxsize>= 0 && remaining+1 < size) {
174 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
181 /* Read the data in sane-sized chunks and append to pkt.
182 * Return the number of bytes read or an error. */
183 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
185 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
186 int orig_size = pkt->size;
190 int prev_size = pkt->size;
193 /* When the caller requests a lot of data, limit it to the amount
194 * left in file or SANE_CHUNK_SIZE when it is not known. */
196 if (read_size > SANE_CHUNK_SIZE/10) {
197 read_size = ffio_limit(s, read_size);
198 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
200 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
203 ret = av_grow_packet(pkt, read_size);
207 ret = avio_read(s, pkt->data + prev_size, read_size);
208 if (ret != read_size) {
209 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
216 pkt->flags |= AV_PKT_FLAG_CORRUPT;
221 return pkt->size > orig_size ? pkt->size - orig_size : ret;
224 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
229 pkt->pos = avio_tell(s);
231 return append_packet_chunked(s, pkt, size);
234 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
237 return av_get_packet(s, pkt, size);
238 return append_packet_chunked(s, pkt, size);
241 int av_filename_number_test(const char *filename)
245 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
248 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
251 static const struct {
254 enum AVMediaType type;
256 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
257 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
258 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
259 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
260 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
261 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
262 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
263 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
264 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
265 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
269 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
271 if (fmt && st->request_probe <= score) {
273 av_log(s, AV_LOG_DEBUG,
274 "Probe with size=%d, packets=%d detected %s with score=%d\n",
275 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
277 for (i = 0; fmt_id_type[i].name; i++) {
278 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
279 st->codec->codec_id = fmt_id_type[i].id;
280 st->codec->codec_type = fmt_id_type[i].type;
288 /************************************************************/
289 /* input media file */
291 int av_demuxer_open(AVFormatContext *ic) {
294 if (ic->iformat->read_header) {
295 err = ic->iformat->read_header(ic);
300 if (ic->pb && !ic->data_offset)
301 ic->data_offset = avio_tell(ic->pb);
306 /* Open input file and probe the format if necessary. */
307 static int init_input(AVFormatContext *s, const char *filename,
308 AVDictionary **options)
311 AVProbeData pd = { filename, NULL, 0 };
312 int score = AVPROBE_SCORE_RETRY;
315 s->flags |= AVFMT_FLAG_CUSTOM_IO;
317 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
318 s, 0, s->format_probesize);
319 else if (s->iformat->flags & AVFMT_NOFILE)
320 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
321 "will be ignored with AVFMT_NOFILE format.\n");
325 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
326 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
329 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
330 &s->interrupt_callback, options)) < 0)
334 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
335 s, 0, s->format_probesize);
338 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
339 AVPacketList **plast_pktl)
341 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
346 (*plast_pktl)->next = pktl;
348 *packet_buffer = pktl;
350 /* Add the packet in the buffered packet list. */
356 int avformat_queue_attached_pictures(AVFormatContext *s)
359 for (i = 0; i < s->nb_streams; i++)
360 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
361 s->streams[i]->discard < AVDISCARD_ALL) {
362 AVPacket copy = s->streams[i]->attached_pic;
363 if (copy.size <= 0) {
364 av_log(s, AV_LOG_WARNING,
365 "Attached picture on stream %d has invalid size, "
369 copy.buf = av_buffer_ref(copy.buf);
371 return AVERROR(ENOMEM);
373 add_to_pktbuf(&s->raw_packet_buffer, ©,
374 &s->raw_packet_buffer_end);
379 int avformat_open_input(AVFormatContext **ps, const char *filename,
380 AVInputFormat *fmt, AVDictionary **options)
382 AVFormatContext *s = *ps;
384 AVDictionary *tmp = NULL;
385 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
387 if (!s && !(s = avformat_alloc_context()))
388 return AVERROR(ENOMEM);
390 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
391 return AVERROR(EINVAL);
397 av_dict_copy(&tmp, *options, 0);
399 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
402 if ((ret = init_input(s, filename, &tmp)) < 0)
404 s->probe_score = ret;
405 avio_skip(s->pb, s->skip_initial_bytes);
407 /* Check filename in case an image number is expected. */
408 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
409 if (!av_filename_number_test(filename)) {
410 ret = AVERROR(EINVAL);
415 s->duration = s->start_time = AV_NOPTS_VALUE;
416 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
418 /* Allocate private data. */
419 if (s->iformat->priv_data_size > 0) {
420 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
421 ret = AVERROR(ENOMEM);
424 if (s->iformat->priv_class) {
425 *(const AVClass **) s->priv_data = s->iformat->priv_class;
426 av_opt_set_defaults(s->priv_data);
427 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
432 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
434 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
436 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
437 if ((ret = s->iformat->read_header(s)) < 0)
440 if (id3v2_extra_meta) {
441 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
442 !strcmp(s->iformat->name, "tta")) {
443 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
446 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
448 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
450 if ((ret = avformat_queue_attached_pictures(s)) < 0)
453 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
454 s->data_offset = avio_tell(s->pb);
456 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
459 av_dict_free(options);
466 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
468 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
470 avformat_free_context(s);
475 /*******************************************************/
477 static void force_codec_ids(AVFormatContext *s, AVStream *st)
479 switch (st->codec->codec_type) {
480 case AVMEDIA_TYPE_VIDEO:
481 if (s->video_codec_id)
482 st->codec->codec_id = s->video_codec_id;
484 case AVMEDIA_TYPE_AUDIO:
485 if (s->audio_codec_id)
486 st->codec->codec_id = s->audio_codec_id;
488 case AVMEDIA_TYPE_SUBTITLE:
489 if (s->subtitle_codec_id)
490 st->codec->codec_id = s->subtitle_codec_id;
495 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
497 if (st->request_probe>0) {
498 AVProbeData *pd = &st->probe_data;
500 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
504 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
506 av_log(s, AV_LOG_WARNING,
507 "Failed to reallocate probe buffer for stream %d\n",
512 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
513 pd->buf_size += pkt->size;
514 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
517 st->probe_packets = 0;
519 av_log(s, AV_LOG_WARNING,
520 "nothing to probe for stream %d\n", st->index);
524 end= s->raw_packet_buffer_remaining_size <= 0
525 || st->probe_packets<= 0;
527 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
528 int score = set_codec_from_probe_data(s, st, pd);
529 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
533 st->request_probe = -1;
534 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
535 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
537 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
539 force_codec_ids(s, st);
545 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
547 int64_t ref = pkt->dts;
548 int i, pts_wrap_behavior;
549 int64_t pts_wrap_reference;
550 AVProgram *first_program;
552 if (ref == AV_NOPTS_VALUE)
554 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
556 ref &= (1LL << st->pts_wrap_bits)-1;
558 // reference time stamp should be 60 s before first time stamp
559 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
560 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
561 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
562 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
563 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
565 first_program = av_find_program_from_stream(s, NULL, stream_index);
567 if (!first_program) {
568 int default_stream_index = av_find_default_stream_index(s);
569 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
570 for (i = 0; i < s->nb_streams; i++) {
571 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
572 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
576 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
577 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
581 AVProgram *program = first_program;
583 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
584 pts_wrap_reference = program->pts_wrap_reference;
585 pts_wrap_behavior = program->pts_wrap_behavior;
588 program = av_find_program_from_stream(s, program, stream_index);
591 // update every program with differing pts_wrap_reference
592 program = first_program;
594 if (program->pts_wrap_reference != pts_wrap_reference) {
595 for (i = 0; i<program->nb_stream_indexes; i++) {
596 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
597 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
600 program->pts_wrap_reference = pts_wrap_reference;
601 program->pts_wrap_behavior = pts_wrap_behavior;
603 program = av_find_program_from_stream(s, program, stream_index);
609 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
615 AVPacketList *pktl = s->raw_packet_buffer;
619 st = s->streams[pkt->stream_index];
620 if (s->raw_packet_buffer_remaining_size <= 0)
621 if ((err = probe_codec(s, st, NULL)) < 0)
623 if (st->request_probe <= 0) {
624 s->raw_packet_buffer = pktl->next;
625 s->raw_packet_buffer_remaining_size += pkt->size;
634 ret = s->iformat->read_packet(s, pkt);
636 if (!pktl || ret == AVERROR(EAGAIN))
638 for (i = 0; i < s->nb_streams; i++) {
640 if (st->probe_packets)
641 if ((err = probe_codec(s, st, NULL)) < 0)
643 av_assert0(st->request_probe <= 0);
648 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
649 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
650 av_log(s, AV_LOG_WARNING,
651 "Dropped corrupted packet (stream = %d)\n",
657 if (pkt->stream_index >= (unsigned)s->nb_streams) {
658 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
662 st = s->streams[pkt->stream_index];
664 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
665 // correct first time stamps to negative values
666 if (!is_relative(st->first_dts))
667 st->first_dts = wrap_timestamp(st, st->first_dts);
668 if (!is_relative(st->start_time))
669 st->start_time = wrap_timestamp(st, st->start_time);
670 if (!is_relative(st->cur_dts))
671 st->cur_dts = wrap_timestamp(st, st->cur_dts);
674 pkt->dts = wrap_timestamp(st, pkt->dts);
675 pkt->pts = wrap_timestamp(st, pkt->pts);
677 force_codec_ids(s, st);
679 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
680 if (s->use_wallclock_as_timestamps)
681 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
683 if (!pktl && st->request_probe <= 0)
686 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
687 s->raw_packet_buffer_remaining_size -= pkt->size;
689 if ((err = probe_codec(s, st, pkt)) < 0)
694 #if FF_API_READ_PACKET
695 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
697 return ff_read_packet(s, pkt);
702 /**********************************************************/
704 static int determinable_frame_size(AVCodecContext *avctx)
706 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
707 avctx->codec_id == AV_CODEC_ID_MP1 ||
708 avctx->codec_id == AV_CODEC_ID_MP2 ||
709 avctx->codec_id == AV_CODEC_ID_MP3/* ||
710 avctx->codec_id == AV_CODEC_ID_CELT*/)
716 * Get the number of samples of an audio frame. Return -1 on error.
718 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
722 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
725 //For WMA we currently have no other means to calculate duration thus we
726 //do it here by assuming CBR, which is true for all known cases.
727 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
728 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
729 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
736 * Return the frame duration in seconds. Return 0 if not available.
738 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
739 AVCodecParserContext *pc, AVPacket *pkt)
745 switch (st->codec->codec_type) {
746 case AVMEDIA_TYPE_VIDEO:
747 if (st->r_frame_rate.num && !pc) {
748 *pnum = st->r_frame_rate.den;
749 *pden = st->r_frame_rate.num;
750 } else if (st->time_base.num * 1000LL > st->time_base.den) {
751 *pnum = st->time_base.num;
752 *pden = st->time_base.den;
753 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
754 *pnum = st->codec->time_base.num;
755 *pden = st->codec->time_base.den;
756 if (pc && pc->repeat_pict) {
757 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
758 *pden /= 1 + pc->repeat_pict;
760 *pnum *= 1 + pc->repeat_pict;
762 /* If this codec can be interlaced or progressive then we need
763 * a parser to compute duration of a packet. Thus if we have
764 * no parser in such case leave duration undefined. */
765 if (st->codec->ticks_per_frame > 1 && !pc)
769 case AVMEDIA_TYPE_AUDIO:
770 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
771 if (frame_size <= 0 || st->codec->sample_rate <= 0)
774 *pden = st->codec->sample_rate;
781 static int is_intra_only(AVCodecContext *enc) {
782 const AVCodecDescriptor *desc;
784 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
787 desc = av_codec_get_codec_descriptor(enc);
789 desc = avcodec_descriptor_get(enc->codec_id);
790 av_codec_set_codec_descriptor(enc, desc);
793 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
797 static int has_decode_delay_been_guessed(AVStream *st)
799 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
800 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
802 #if CONFIG_H264_DECODER
803 if (st->codec->has_b_frames &&
804 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
807 if (st->codec->has_b_frames<3)
808 return st->nb_decoded_frames >= 7;
809 else if (st->codec->has_b_frames<4)
810 return st->nb_decoded_frames >= 18;
812 return st->nb_decoded_frames >= 20;
815 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
819 if (pktl == s->packet_buffer_end)
820 return s->parse_queue;
824 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
825 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
826 st->codec->codec_id != AV_CODEC_ID_HEVC;
829 int delay = st->codec->has_b_frames;
832 if (dts == AV_NOPTS_VALUE) {
833 int64_t best_score = INT64_MAX;
834 for (i = 0; i<delay; i++) {
835 if (st->pts_reorder_error_count[i]) {
836 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
837 if (score < best_score) {
844 for (i = 0; i<delay; i++) {
845 if (pts_buffer[i] != AV_NOPTS_VALUE) {
846 int64_t diff = FFABS(pts_buffer[i] - dts)
847 + (uint64_t)st->pts_reorder_error[i];
848 diff = FFMAX(diff, st->pts_reorder_error[i]);
849 st->pts_reorder_error[i] = diff;
850 st->pts_reorder_error_count[i]++;
851 if (st->pts_reorder_error_count[i] > 250) {
852 st->pts_reorder_error[i] >>= 1;
853 st->pts_reorder_error_count[i] >>= 1;
860 if (dts == AV_NOPTS_VALUE)
866 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
867 int64_t dts, int64_t pts, AVPacket *pkt)
869 AVStream *st = s->streams[stream_index];
870 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
871 int64_t pts_buffer[MAX_REORDER_DELAY+1];
875 if (st->first_dts != AV_NOPTS_VALUE ||
876 dts == AV_NOPTS_VALUE ||
877 st->cur_dts == AV_NOPTS_VALUE ||
881 delay = st->codec->has_b_frames;
882 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
884 shift = st->first_dts - RELATIVE_TS_BASE;
886 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
887 pts_buffer[i] = AV_NOPTS_VALUE;
889 if (is_relative(pts))
892 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
893 if (pktl->pkt.stream_index != stream_index)
895 if (is_relative(pktl->pkt.pts))
896 pktl->pkt.pts += shift;
898 if (is_relative(pktl->pkt.dts))
899 pktl->pkt.dts += shift;
901 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
902 st->start_time = pktl->pkt.pts;
904 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
905 pts_buffer[0] = pktl->pkt.pts;
906 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
907 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
909 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
913 if (st->start_time == AV_NOPTS_VALUE)
914 st->start_time = pts;
917 static void update_initial_durations(AVFormatContext *s, AVStream *st,
918 int stream_index, int duration)
920 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
921 int64_t cur_dts = RELATIVE_TS_BASE;
923 if (st->first_dts != AV_NOPTS_VALUE) {
924 if (st->update_initial_durations_done)
926 st->update_initial_durations_done = 1;
927 cur_dts = st->first_dts;
928 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
929 if (pktl->pkt.stream_index == stream_index) {
930 if (pktl->pkt.pts != pktl->pkt.dts ||
931 pktl->pkt.dts != AV_NOPTS_VALUE ||
937 if (pktl && pktl->pkt.dts != st->first_dts) {
938 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
939 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
943 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
946 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
947 st->first_dts = cur_dts;
948 } else if (st->cur_dts != RELATIVE_TS_BASE)
951 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
952 if (pktl->pkt.stream_index != stream_index)
954 if (pktl->pkt.pts == pktl->pkt.dts &&
955 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
956 !pktl->pkt.duration) {
957 pktl->pkt.dts = cur_dts;
958 if (!st->codec->has_b_frames)
959 pktl->pkt.pts = cur_dts;
960 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
961 pktl->pkt.duration = duration;
964 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
967 st->cur_dts = cur_dts;
970 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
971 AVCodecParserContext *pc, AVPacket *pkt)
973 int num, den, presentation_delayed, delay, i;
976 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
977 st->codec->codec_id != AV_CODEC_ID_HEVC;
979 if (s->flags & AVFMT_FLAG_NOFILLIN)
982 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
983 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
984 if (st->last_dts_for_order_check <= pkt->dts) {
987 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
988 "DTS %"PRIi64" < %"PRIi64" out of order\n",
990 st->last_dts_for_order_check);
991 st->dts_misordered++;
993 if (st->dts_ordered + st->dts_misordered > 250) {
994 st->dts_ordered >>= 1;
995 st->dts_misordered >>= 1;
999 st->last_dts_for_order_check = pkt->dts;
1000 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1001 pkt->dts = AV_NOPTS_VALUE;
1004 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1005 pkt->dts = AV_NOPTS_VALUE;
1007 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1008 && !st->codec->has_b_frames)
1009 //FIXME Set low_delay = 0 when has_b_frames = 1
1010 st->codec->has_b_frames = 1;
1012 /* do we have a video B-frame ? */
1013 delay = st->codec->has_b_frames;
1014 presentation_delayed = 0;
1016 /* XXX: need has_b_frame, but cannot get it if the codec is
1017 * not initialized */
1019 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1020 presentation_delayed = 1;
1022 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1023 st->pts_wrap_bits < 63 &&
1024 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1025 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1026 pkt->dts -= 1LL << st->pts_wrap_bits;
1028 pkt->pts += 1LL << st->pts_wrap_bits;
1031 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1032 * We take the conservative approach and discard both.
1033 * Note: If this is misbehaving for an H.264 file, then possibly
1034 * presentation_delayed is not set correctly. */
1035 if (delay == 1 && pkt->dts == pkt->pts &&
1036 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1037 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1038 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1039 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1040 pkt->dts = AV_NOPTS_VALUE;
1043 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1044 if (pkt->duration == 0) {
1045 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1047 duration = (AVRational) {num, den};
1048 pkt->duration = av_rescale_rnd(1,
1049 num * (int64_t) st->time_base.den,
1050 den * (int64_t) st->time_base.num,
1055 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1056 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1058 /* Correct timestamps with byte offset if demuxers only have timestamps
1059 * on packet boundaries */
1060 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1061 /* this will estimate bitrate based on this frame's duration and size */
1062 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1063 if (pkt->pts != AV_NOPTS_VALUE)
1065 if (pkt->dts != AV_NOPTS_VALUE)
1069 /* This may be redundant, but it should not hurt. */
1070 if (pkt->dts != AV_NOPTS_VALUE &&
1071 pkt->pts != AV_NOPTS_VALUE &&
1072 pkt->pts > pkt->dts)
1073 presentation_delayed = 1;
1076 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1077 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1078 pkt->stream_index, pc, pkt->duration);
1079 /* Interpolate PTS and DTS if they are not present. We skip H264
1080 * currently because delay and has_b_frames are not reliably set. */
1081 if ((delay == 0 || (delay == 1 && pc)) &&
1083 if (presentation_delayed) {
1084 /* DTS = decompression timestamp */
1085 /* PTS = presentation timestamp */
1086 if (pkt->dts == AV_NOPTS_VALUE)
1087 pkt->dts = st->last_IP_pts;
1088 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1089 if (pkt->dts == AV_NOPTS_VALUE)
1090 pkt->dts = st->cur_dts;
1092 /* This is tricky: the dts must be incremented by the duration
1093 * of the frame we are displaying, i.e. the last I- or P-frame. */
1094 if (st->last_IP_duration == 0)
1095 st->last_IP_duration = pkt->duration;
1096 if (pkt->dts != AV_NOPTS_VALUE)
1097 st->cur_dts = pkt->dts + st->last_IP_duration;
1098 st->last_IP_duration = pkt->duration;
1099 st->last_IP_pts = pkt->pts;
1100 /* Cannot compute PTS if not present (we can compute it only
1101 * by knowing the future. */
1102 } else if (pkt->pts != AV_NOPTS_VALUE ||
1103 pkt->dts != AV_NOPTS_VALUE ||
1106 /* presentation is not delayed : PTS and DTS are the same */
1107 if (pkt->pts == AV_NOPTS_VALUE)
1108 pkt->pts = pkt->dts;
1109 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1111 if (pkt->pts == AV_NOPTS_VALUE)
1112 pkt->pts = st->cur_dts;
1113 pkt->dts = pkt->pts;
1114 if (pkt->pts != AV_NOPTS_VALUE)
1115 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1119 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1120 st->pts_buffer[0] = pkt->pts;
1121 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1122 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1124 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1126 // We skipped it above so we try here.
1128 // This should happen on the first packet
1129 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1130 if (pkt->dts > st->cur_dts)
1131 st->cur_dts = pkt->dts;
1133 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1134 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1137 if (is_intra_only(st->codec))
1138 pkt->flags |= AV_PKT_FLAG_KEY;
1140 pkt->convergence_duration = pc->convergence_duration;
1143 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1146 AVPacketList *pktl = *pkt_buf;
1147 *pkt_buf = pktl->next;
1148 av_free_packet(&pktl->pkt);
1151 *pkt_buf_end = NULL;
1155 * Parse a packet, add all split parts to parse_queue.
1157 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1159 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1161 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1162 AVStream *st = s->streams[stream_index];
1163 uint8_t *data = pkt ? pkt->data : NULL;
1164 int size = pkt ? pkt->size : 0;
1165 int ret = 0, got_output = 0;
1168 av_init_packet(&flush_pkt);
1171 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1172 // preserve 0-size sync packets
1173 compute_pkt_fields(s, st, st->parser, pkt);
1176 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1179 av_init_packet(&out_pkt);
1180 len = av_parser_parse2(st->parser, st->codec,
1181 &out_pkt.data, &out_pkt.size, data, size,
1182 pkt->pts, pkt->dts, pkt->pos);
1184 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1186 /* increment read pointer */
1190 got_output = !!out_pkt.size;
1195 if (pkt->side_data) {
1196 out_pkt.side_data = pkt->side_data;
1197 out_pkt.side_data_elems = pkt->side_data_elems;
1198 pkt->side_data = NULL;
1199 pkt->side_data_elems = 0;
1202 /* set the duration */
1203 out_pkt.duration = 0;
1204 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1205 if (st->codec->sample_rate > 0) {
1207 av_rescale_q_rnd(st->parser->duration,
1208 (AVRational) { 1, st->codec->sample_rate },
1214 out_pkt.stream_index = st->index;
1215 out_pkt.pts = st->parser->pts;
1216 out_pkt.dts = st->parser->dts;
1217 out_pkt.pos = st->parser->pos;
1219 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1220 out_pkt.pos = st->parser->frame_offset;
1222 if (st->parser->key_frame == 1 ||
1223 (st->parser->key_frame == -1 &&
1224 st->parser->pict_type == AV_PICTURE_TYPE_I))
1225 out_pkt.flags |= AV_PKT_FLAG_KEY;
1227 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1228 out_pkt.flags |= AV_PKT_FLAG_KEY;
1230 compute_pkt_fields(s, st, st->parser, &out_pkt);
1232 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1233 out_pkt.buf = pkt->buf;
1235 #if FF_API_DESTRUCT_PACKET
1236 FF_DISABLE_DEPRECATION_WARNINGS
1237 out_pkt.destruct = pkt->destruct;
1238 pkt->destruct = NULL;
1239 FF_ENABLE_DEPRECATION_WARNINGS
1242 if ((ret = av_dup_packet(&out_pkt)) < 0)
1245 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1246 av_free_packet(&out_pkt);
1247 ret = AVERROR(ENOMEM);
1252 /* end of the stream => close and free the parser */
1253 if (pkt == &flush_pkt) {
1254 av_parser_close(st->parser);
1259 av_free_packet(pkt);
1263 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1264 AVPacketList **pkt_buffer_end,
1268 av_assert0(*pkt_buffer);
1271 *pkt_buffer = pktl->next;
1273 *pkt_buffer_end = NULL;
1278 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1280 int ret = 0, i, got_packet = 0;
1281 AVDictionary *metadata = NULL;
1283 av_init_packet(pkt);
1285 while (!got_packet && !s->parse_queue) {
1289 /* read next packet */
1290 ret = ff_read_packet(s, &cur_pkt);
1292 if (ret == AVERROR(EAGAIN))
1294 /* flush the parsers */
1295 for (i = 0; i < s->nb_streams; i++) {
1297 if (st->parser && st->need_parsing)
1298 parse_packet(s, NULL, st->index);
1300 /* all remaining packets are now in parse_queue =>
1301 * really terminate parsing */
1305 st = s->streams[cur_pkt.stream_index];
1307 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1308 cur_pkt.dts != AV_NOPTS_VALUE &&
1309 cur_pkt.pts < cur_pkt.dts) {
1310 av_log(s, AV_LOG_WARNING,
1311 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1312 cur_pkt.stream_index,
1313 av_ts2str(cur_pkt.pts),
1314 av_ts2str(cur_pkt.dts),
1317 if (s->debug & FF_FDEBUG_TS)
1318 av_log(s, AV_LOG_DEBUG,
1319 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1320 cur_pkt.stream_index,
1321 av_ts2str(cur_pkt.pts),
1322 av_ts2str(cur_pkt.dts),
1323 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1325 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1326 st->parser = av_parser_init(st->codec->codec_id);
1328 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1329 "%s, packets or times may be invalid.\n",
1330 avcodec_get_name(st->codec->codec_id));
1331 /* no parser available: just output the raw packets */
1332 st->need_parsing = AVSTREAM_PARSE_NONE;
1333 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1334 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1335 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1336 st->parser->flags |= PARSER_FLAG_ONCE;
1337 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1338 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1341 if (!st->need_parsing || !st->parser) {
1342 /* no parsing needed: we just output the packet as is */
1344 compute_pkt_fields(s, st, NULL, pkt);
1345 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1346 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1347 ff_reduce_index(s, st->index);
1348 av_add_index_entry(st, pkt->pos, pkt->dts,
1349 0, 0, AVINDEX_KEYFRAME);
1352 } else if (st->discard < AVDISCARD_ALL) {
1353 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1357 av_free_packet(&cur_pkt);
1359 if (pkt->flags & AV_PKT_FLAG_KEY)
1360 st->skip_to_keyframe = 0;
1361 if (st->skip_to_keyframe) {
1362 av_free_packet(&cur_pkt);
1370 if (!got_packet && s->parse_queue)
1371 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1374 AVStream *st = s->streams[pkt->stream_index];
1375 if (st->skip_samples) {
1376 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1378 AV_WL32(p, st->skip_samples);
1379 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1381 st->skip_samples = 0;
1384 if (st->inject_global_side_data) {
1385 for (i = 0; i < st->nb_side_data; i++) {
1386 AVPacketSideData *src_sd = &st->side_data[i];
1389 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1392 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1394 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1398 memcpy(dst_data, src_sd->data, src_sd->size);
1400 st->inject_global_side_data = 0;
1403 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1404 av_packet_merge_side_data(pkt);
1407 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1409 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1410 av_dict_copy(&s->metadata, metadata, 0);
1411 av_dict_free(&metadata);
1412 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1415 if (s->debug & FF_FDEBUG_TS)
1416 av_log(s, AV_LOG_DEBUG,
1417 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1418 "size=%d, duration=%d, flags=%d\n",
1420 av_ts2str(pkt->pts),
1421 av_ts2str(pkt->dts),
1422 pkt->size, pkt->duration, pkt->flags);
1427 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1429 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1435 ret = s->packet_buffer
1436 ? read_from_packet_buffer(&s->packet_buffer,
1437 &s->packet_buffer_end, pkt)
1438 : read_frame_internal(s, pkt);
1445 AVPacketList *pktl = s->packet_buffer;
1448 AVPacket *next_pkt = &pktl->pkt;
1450 if (next_pkt->dts != AV_NOPTS_VALUE) {
1451 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1452 // last dts seen for this stream. if any of packets following
1453 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1454 int64_t last_dts = next_pkt->dts;
1455 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1456 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1457 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1458 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1460 next_pkt->pts = pktl->pkt.dts;
1462 if (last_dts != AV_NOPTS_VALUE) {
1463 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1464 last_dts = pktl->pkt.dts;
1469 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1470 // Fixing the last reference frame had none pts issue (For MXF etc).
1471 // We only do this when
1473 // 2. we are not able to resolve a pts value for current packet.
1474 // 3. the packets for this stream at the end of the files had valid dts.
1475 next_pkt->pts = last_dts + next_pkt->duration;
1477 pktl = s->packet_buffer;
1480 /* read packet from packet buffer, if there is data */
1481 st = s->streams[next_pkt->stream_index];
1482 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1483 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1484 ret = read_from_packet_buffer(&s->packet_buffer,
1485 &s->packet_buffer_end, pkt);
1490 ret = read_frame_internal(s, pkt);
1492 if (pktl && ret != AVERROR(EAGAIN)) {
1499 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1500 &s->packet_buffer_end)) < 0)
1501 return AVERROR(ENOMEM);
1506 st = s->streams[pkt->stream_index];
1507 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1508 ff_reduce_index(s, st->index);
1509 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1512 if (is_relative(pkt->dts))
1513 pkt->dts -= RELATIVE_TS_BASE;
1514 if (is_relative(pkt->pts))
1515 pkt->pts -= RELATIVE_TS_BASE;
1520 /* XXX: suppress the packet queue */
1521 static void flush_packet_queue(AVFormatContext *s)
1523 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1524 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1525 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1527 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1530 /*******************************************************/
1533 int av_find_default_stream_index(AVFormatContext *s)
1537 int best_stream = 0;
1538 int best_score = -1;
1540 if (s->nb_streams <= 0)
1542 for (i = 0; i < s->nb_streams; i++) {
1545 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1546 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1547 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1552 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1553 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1559 if (score > best_score) {
1567 /** Flush the frame reader. */
1568 void ff_read_frame_flush(AVFormatContext *s)
1573 flush_packet_queue(s);
1575 /* Reset read state for each stream. */
1576 for (i = 0; i < s->nb_streams; i++) {
1580 av_parser_close(st->parser);
1583 st->last_IP_pts = AV_NOPTS_VALUE;
1584 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1585 if (st->first_dts == AV_NOPTS_VALUE)
1586 st->cur_dts = RELATIVE_TS_BASE;
1588 /* We set the current DTS to an unspecified origin. */
1589 st->cur_dts = AV_NOPTS_VALUE;
1591 st->probe_packets = MAX_PROBE_PACKETS;
1593 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1594 st->pts_buffer[j] = AV_NOPTS_VALUE;
1596 if (s->internal->inject_global_side_data)
1597 st->inject_global_side_data = 1;
1601 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1605 for (i = 0; i < s->nb_streams; i++) {
1606 AVStream *st = s->streams[i];
1609 av_rescale(timestamp,
1610 st->time_base.den * (int64_t) ref_st->time_base.num,
1611 st->time_base.num * (int64_t) ref_st->time_base.den);
1615 void ff_reduce_index(AVFormatContext *s, int stream_index)
1617 AVStream *st = s->streams[stream_index];
1618 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1620 if ((unsigned) st->nb_index_entries >= max_entries) {
1622 for (i = 0; 2 * i < st->nb_index_entries; i++)
1623 st->index_entries[i] = st->index_entries[2 * i];
1624 st->nb_index_entries = i;
1628 int ff_add_index_entry(AVIndexEntry **index_entries,
1629 int *nb_index_entries,
1630 unsigned int *index_entries_allocated_size,
1631 int64_t pos, int64_t timestamp,
1632 int size, int distance, int flags)
1634 AVIndexEntry *entries, *ie;
1637 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1640 if (timestamp == AV_NOPTS_VALUE)
1641 return AVERROR(EINVAL);
1643 if (size < 0 || size > 0x3FFFFFFF)
1644 return AVERROR(EINVAL);
1646 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1647 timestamp -= RELATIVE_TS_BASE;
1649 entries = av_fast_realloc(*index_entries,
1650 index_entries_allocated_size,
1651 (*nb_index_entries + 1) *
1652 sizeof(AVIndexEntry));
1656 *index_entries = entries;
1658 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1659 timestamp, AVSEEK_FLAG_ANY);
1662 index = (*nb_index_entries)++;
1663 ie = &entries[index];
1664 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1666 ie = &entries[index];
1667 if (ie->timestamp != timestamp) {
1668 if (ie->timestamp <= timestamp)
1670 memmove(entries + index + 1, entries + index,
1671 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1672 (*nb_index_entries)++;
1673 } else if (ie->pos == pos && distance < ie->min_distance)
1674 // do not reduce the distance
1675 distance = ie->min_distance;
1679 ie->timestamp = timestamp;
1680 ie->min_distance = distance;
1687 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1688 int size, int distance, int flags)
1690 timestamp = wrap_timestamp(st, timestamp);
1691 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1692 &st->index_entries_allocated_size, pos,
1693 timestamp, size, distance, flags);
1696 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1697 int64_t wanted_timestamp, int flags)
1705 // Optimize appending index entries at the end.
1706 if (b && entries[b - 1].timestamp < wanted_timestamp)
1711 timestamp = entries[m].timestamp;
1712 if (timestamp >= wanted_timestamp)
1714 if (timestamp <= wanted_timestamp)
1717 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1719 if (!(flags & AVSEEK_FLAG_ANY))
1720 while (m >= 0 && m < nb_entries &&
1721 !(entries[m].flags & AVINDEX_KEYFRAME))
1722 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1724 if (m == nb_entries)
1729 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1731 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1732 wanted_timestamp, flags);
1735 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1736 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1738 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1739 if (stream_index >= 0)
1740 ts = wrap_timestamp(s->streams[stream_index], ts);
1744 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1745 int64_t target_ts, int flags)
1747 AVInputFormat *avif = s->iformat;
1748 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1749 int64_t ts_min, ts_max, ts;
1754 if (stream_index < 0)
1757 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1760 ts_min = AV_NOPTS_VALUE;
1761 pos_limit = -1; // GCC falsely says it may be uninitialized.
1763 st = s->streams[stream_index];
1764 if (st->index_entries) {
1767 /* FIXME: Whole function must be checked for non-keyframe entries in
1768 * index case, especially read_timestamp(). */
1769 index = av_index_search_timestamp(st, target_ts,
1770 flags | AVSEEK_FLAG_BACKWARD);
1771 index = FFMAX(index, 0);
1772 e = &st->index_entries[index];
1774 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1776 ts_min = e->timestamp;
1777 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1778 pos_min, av_ts2str(ts_min));
1780 av_assert1(index == 0);
1783 index = av_index_search_timestamp(st, target_ts,
1784 flags & ~AVSEEK_FLAG_BACKWARD);
1785 av_assert0(index < st->nb_index_entries);
1787 e = &st->index_entries[index];
1788 av_assert1(e->timestamp >= target_ts);
1790 ts_max = e->timestamp;
1791 pos_limit = pos_max - e->min_distance;
1792 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1793 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1797 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1798 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1803 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1806 ff_read_frame_flush(s);
1807 ff_update_cur_dts(s, st, ts);
1812 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1813 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1815 int64_t step = 1024;
1816 int64_t limit, ts_max;
1817 int64_t filesize = avio_size(s->pb);
1818 int64_t pos_max = filesize - 1;
1821 pos_max = FFMAX(0, (pos_max) - step);
1822 ts_max = ff_read_timestamp(s, stream_index,
1823 &pos_max, limit, read_timestamp);
1825 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1826 if (ts_max == AV_NOPTS_VALUE)
1830 int64_t tmp_pos = pos_max + 1;
1831 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1832 &tmp_pos, INT64_MAX, read_timestamp);
1833 if (tmp_ts == AV_NOPTS_VALUE)
1835 av_assert0(tmp_pos > pos_max);
1838 if (tmp_pos >= filesize)
1850 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1851 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1852 int64_t ts_min, int64_t ts_max,
1853 int flags, int64_t *ts_ret,
1854 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1855 int64_t *, int64_t))
1862 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1864 if (ts_min == AV_NOPTS_VALUE) {
1865 pos_min = s->data_offset;
1866 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1867 if (ts_min == AV_NOPTS_VALUE)
1871 if (ts_min >= target_ts) {
1876 if (ts_max == AV_NOPTS_VALUE) {
1877 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1879 pos_limit = pos_max;
1882 if (ts_max <= target_ts) {
1887 if (ts_min > ts_max)
1889 else if (ts_min == ts_max)
1890 pos_limit = pos_min;
1893 while (pos_min < pos_limit) {
1895 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1896 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1897 assert(pos_limit <= pos_max);
1899 if (no_change == 0) {
1900 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1901 // interpolate position (better than dichotomy)
1902 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1904 pos_min - approximate_keyframe_distance;
1905 } else if (no_change == 1) {
1906 // bisection if interpolation did not change min / max pos last time
1907 pos = (pos_min + pos_limit) >> 1;
1909 /* linear search if bisection failed, can only happen if there
1910 * are very few or no keyframes between min/max */
1915 else if (pos > pos_limit)
1919 // May pass pos_limit instead of -1.
1920 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1925 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1926 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1927 pos_min, pos, pos_max,
1928 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1929 pos_limit, start_pos, no_change);
1930 if (ts == AV_NOPTS_VALUE) {
1931 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1934 assert(ts != AV_NOPTS_VALUE);
1935 if (target_ts <= ts) {
1936 pos_limit = start_pos - 1;
1940 if (target_ts >= ts) {
1946 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1947 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1950 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1952 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1953 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1954 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1960 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1961 int64_t pos, int flags)
1963 int64_t pos_min, pos_max;
1965 pos_min = s->data_offset;
1966 pos_max = avio_size(s->pb) - 1;
1970 else if (pos > pos_max)
1973 avio_seek(s->pb, pos, SEEK_SET);
1975 s->io_repositioned = 1;
1980 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1981 int64_t timestamp, int flags)
1988 st = s->streams[stream_index];
1990 index = av_index_search_timestamp(st, timestamp, flags);
1992 if (index < 0 && st->nb_index_entries &&
1993 timestamp < st->index_entries[0].timestamp)
1996 if (index < 0 || index == st->nb_index_entries - 1) {
2000 if (st->nb_index_entries) {
2001 av_assert0(st->index_entries);
2002 ie = &st->index_entries[st->nb_index_entries - 1];
2003 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2005 ff_update_cur_dts(s, st, ie->timestamp);
2007 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2013 read_status = av_read_frame(s, &pkt);
2014 } while (read_status == AVERROR(EAGAIN));
2015 if (read_status < 0)
2017 av_free_packet(&pkt);
2018 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2019 if (pkt.flags & AV_PKT_FLAG_KEY)
2021 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2022 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);
2027 index = av_index_search_timestamp(st, timestamp, flags);
2032 ff_read_frame_flush(s);
2033 if (s->iformat->read_seek)
2034 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2036 ie = &st->index_entries[index];
2037 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2039 ff_update_cur_dts(s, st, ie->timestamp);
2044 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2045 int64_t timestamp, int flags)
2050 if (flags & AVSEEK_FLAG_BYTE) {
2051 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2053 ff_read_frame_flush(s);
2054 return seek_frame_byte(s, stream_index, timestamp, flags);
2057 if (stream_index < 0) {
2058 stream_index = av_find_default_stream_index(s);
2059 if (stream_index < 0)
2062 st = s->streams[stream_index];
2063 /* timestamp for default must be expressed in AV_TIME_BASE units */
2064 timestamp = av_rescale(timestamp, st->time_base.den,
2065 AV_TIME_BASE * (int64_t) st->time_base.num);
2068 /* first, we try the format specific seek */
2069 if (s->iformat->read_seek) {
2070 ff_read_frame_flush(s);
2071 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2077 if (s->iformat->read_timestamp &&
2078 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2079 ff_read_frame_flush(s);
2080 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2081 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2082 ff_read_frame_flush(s);
2083 return seek_frame_generic(s, stream_index, timestamp, flags);
2088 int av_seek_frame(AVFormatContext *s, int stream_index,
2089 int64_t timestamp, int flags)
2093 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2094 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2095 if ((flags & AVSEEK_FLAG_BACKWARD))
2099 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2100 flags & ~AVSEEK_FLAG_BACKWARD);
2103 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2106 ret = avformat_queue_attached_pictures(s);
2111 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2112 int64_t ts, int64_t max_ts, int flags)
2114 if (min_ts > ts || max_ts < ts)
2116 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2117 return AVERROR(EINVAL);
2120 flags |= AVSEEK_FLAG_ANY;
2121 flags &= ~AVSEEK_FLAG_BACKWARD;
2123 if (s->iformat->read_seek2) {
2125 ff_read_frame_flush(s);
2127 if (stream_index == -1 && s->nb_streams == 1) {
2128 AVRational time_base = s->streams[0]->time_base;
2129 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2130 min_ts = av_rescale_rnd(min_ts, time_base.den,
2131 time_base.num * (int64_t)AV_TIME_BASE,
2132 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2133 max_ts = av_rescale_rnd(max_ts, time_base.den,
2134 time_base.num * (int64_t)AV_TIME_BASE,
2135 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2138 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2142 ret = avformat_queue_attached_pictures(s);
2146 if (s->iformat->read_timestamp) {
2147 // try to seek via read_timestamp()
2150 // Fall back on old API if new is not implemented but old is.
2151 // Note the old API has somewhat different semantics.
2152 if (s->iformat->read_seek || 1) {
2153 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2154 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2155 if (ret<0 && ts != min_ts && max_ts != ts) {
2156 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2158 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2163 // try some generic seek like seek_frame_generic() but with new ts semantics
2164 return -1; //unreachable
2167 /*******************************************************/
2170 * Return TRUE if the stream has accurate duration in any stream.
2172 * @return TRUE if the stream has accurate duration for at least one component.
2174 static int has_duration(AVFormatContext *ic)
2179 for (i = 0; i < ic->nb_streams; i++) {
2180 st = ic->streams[i];
2181 if (st->duration != AV_NOPTS_VALUE)
2184 if (ic->duration != AV_NOPTS_VALUE)
2190 * Estimate the stream timings from the one of each components.
2192 * Also computes the global bitrate if possible.
2194 static void update_stream_timings(AVFormatContext *ic)
2196 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2197 int64_t duration, duration1, filesize;
2202 start_time = INT64_MAX;
2203 start_time_text = INT64_MAX;
2204 end_time = INT64_MIN;
2205 duration = INT64_MIN;
2206 for (i = 0; i < ic->nb_streams; i++) {
2207 st = ic->streams[i];
2208 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2209 start_time1 = av_rescale_q(st->start_time, st->time_base,
2211 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2212 if (start_time1 < start_time_text)
2213 start_time_text = start_time1;
2215 start_time = FFMIN(start_time, start_time1);
2216 end_time1 = AV_NOPTS_VALUE;
2217 if (st->duration != AV_NOPTS_VALUE) {
2218 end_time1 = start_time1 +
2219 av_rescale_q(st->duration, st->time_base,
2221 end_time = FFMAX(end_time, end_time1);
2223 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2224 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2225 p->start_time = start_time1;
2226 if (p->end_time < end_time1)
2227 p->end_time = end_time1;
2230 if (st->duration != AV_NOPTS_VALUE) {
2231 duration1 = av_rescale_q(st->duration, st->time_base,
2233 duration = FFMAX(duration, duration1);
2236 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2237 start_time = start_time_text;
2238 else if (start_time > start_time_text)
2239 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2241 if (start_time != INT64_MAX) {
2242 ic->start_time = start_time;
2243 if (end_time != INT64_MIN) {
2244 if (ic->nb_programs) {
2245 for (i = 0; i < ic->nb_programs; i++) {
2246 p = ic->programs[i];
2247 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2248 duration = FFMAX(duration, p->end_time - p->start_time);
2251 duration = FFMAX(duration, end_time - start_time);
2254 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2255 ic->duration = duration;
2257 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2258 /* compute the bitrate */
2259 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2260 (double) ic->duration;
2261 if (bitrate >= 0 && bitrate <= INT_MAX)
2262 ic->bit_rate = bitrate;
2266 static void fill_all_stream_timings(AVFormatContext *ic)
2271 update_stream_timings(ic);
2272 for (i = 0; i < ic->nb_streams; i++) {
2273 st = ic->streams[i];
2274 if (st->start_time == AV_NOPTS_VALUE) {
2275 if (ic->start_time != AV_NOPTS_VALUE)
2276 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2278 if (ic->duration != AV_NOPTS_VALUE)
2279 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2285 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2287 int64_t filesize, duration;
2288 int i, show_warning = 0;
2291 /* if bit_rate is already set, we believe it */
2292 if (ic->bit_rate <= 0) {
2294 for (i = 0; i < ic->nb_streams; i++) {
2295 st = ic->streams[i];
2296 if (st->codec->bit_rate > 0) {
2297 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2301 bit_rate += st->codec->bit_rate;
2304 ic->bit_rate = bit_rate;
2307 /* if duration is already set, we believe it */
2308 if (ic->duration == AV_NOPTS_VALUE &&
2309 ic->bit_rate != 0) {
2310 filesize = ic->pb ? avio_size(ic->pb) : 0;
2312 for (i = 0; i < ic->nb_streams; i++) {
2313 st = ic->streams[i];
2314 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2315 && st->duration == AV_NOPTS_VALUE) {
2316 duration = av_rescale(8 * filesize, st->time_base.den,
2318 (int64_t) st->time_base.num);
2319 st->duration = duration;
2326 av_log(ic, AV_LOG_WARNING,
2327 "Estimating duration from bitrate, this may be inaccurate\n");
2330 #define DURATION_MAX_READ_SIZE 250000LL
2331 #define DURATION_MAX_RETRY 4
2333 /* only usable for MPEG-PS streams */
2334 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2336 AVPacket pkt1, *pkt = &pkt1;
2338 int num, den, read_size, i, ret;
2339 int found_duration = 0;
2341 int64_t filesize, offset, duration;
2344 /* flush packet queue */
2345 flush_packet_queue(ic);
2347 for (i = 0; i < ic->nb_streams; i++) {
2348 st = ic->streams[i];
2349 if (st->start_time == AV_NOPTS_VALUE &&
2350 st->first_dts == AV_NOPTS_VALUE &&
2351 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2352 av_log(st->codec, AV_LOG_WARNING,
2353 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2356 av_parser_close(st->parser);
2361 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2362 /* estimate the end time (duration) */
2363 /* XXX: may need to support wrapping */
2364 filesize = ic->pb ? avio_size(ic->pb) : 0;
2366 is_end = found_duration;
2367 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2371 avio_seek(ic->pb, offset, SEEK_SET);
2374 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2378 ret = ff_read_packet(ic, pkt);
2379 } while (ret == AVERROR(EAGAIN));
2382 read_size += pkt->size;
2383 st = ic->streams[pkt->stream_index];
2384 if (pkt->pts != AV_NOPTS_VALUE &&
2385 (st->start_time != AV_NOPTS_VALUE ||
2386 st->first_dts != AV_NOPTS_VALUE)) {
2387 if (pkt->duration == 0) {
2388 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2390 pkt->duration = av_rescale_rnd(1,
2391 num * (int64_t) st->time_base.den,
2392 den * (int64_t) st->time_base.num,
2396 duration = pkt->pts + pkt->duration;
2398 if (st->start_time != AV_NOPTS_VALUE)
2399 duration -= st->start_time;
2401 duration -= st->first_dts;
2403 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2404 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2405 st->duration = duration;
2406 st->info->last_duration = duration;
2409 av_free_packet(pkt);
2412 /* check if all audio/video streams have valid duration */
2415 for (i = 0; i < ic->nb_streams; i++) {
2416 st = ic->streams[i];
2417 switch (st->codec->codec_type) {
2418 case AVMEDIA_TYPE_VIDEO:
2419 case AVMEDIA_TYPE_AUDIO:
2420 if (st->duration == AV_NOPTS_VALUE)
2427 ++retry <= DURATION_MAX_RETRY);
2429 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2431 /* warn about audio/video streams which duration could not be estimated */
2432 for (i = 0; i < ic->nb_streams; i++) {
2433 st = ic->streams[i];
2434 if (st->duration == AV_NOPTS_VALUE) {
2435 switch (st->codec->codec_type) {
2436 case AVMEDIA_TYPE_VIDEO:
2437 case AVMEDIA_TYPE_AUDIO:
2438 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2439 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2441 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2445 fill_all_stream_timings(ic);
2447 avio_seek(ic->pb, old_offset, SEEK_SET);
2448 for (i = 0; i < ic->nb_streams; i++) {
2451 st = ic->streams[i];
2452 st->cur_dts = st->first_dts;
2453 st->last_IP_pts = AV_NOPTS_VALUE;
2454 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2455 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2456 st->pts_buffer[j] = AV_NOPTS_VALUE;
2460 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2464 /* get the file size, if possible */
2465 if (ic->iformat->flags & AVFMT_NOFILE) {
2468 file_size = avio_size(ic->pb);
2469 file_size = FFMAX(0, file_size);
2472 if ((!strcmp(ic->iformat->name, "mpeg") ||
2473 !strcmp(ic->iformat->name, "mpegts")) &&
2474 file_size && ic->pb->seekable) {
2475 /* get accurate estimate from the PTSes */
2476 estimate_timings_from_pts(ic, old_offset);
2477 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2478 } else if (has_duration(ic)) {
2479 /* at least one component has timings - we use them for all
2481 fill_all_stream_timings(ic);
2482 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2484 /* less precise: use bitrate info */
2485 estimate_timings_from_bit_rate(ic);
2486 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2488 update_stream_timings(ic);
2492 AVStream av_unused *st;
2493 for (i = 0; i < ic->nb_streams; i++) {
2494 st = ic->streams[i];
2495 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2496 (double) st->start_time / AV_TIME_BASE,
2497 (double) st->duration / AV_TIME_BASE);
2500 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2501 (double) ic->start_time / AV_TIME_BASE,
2502 (double) ic->duration / AV_TIME_BASE,
2503 ic->bit_rate / 1000);
2507 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2509 AVCodecContext *avctx = st->codec;
2511 #define FAIL(errmsg) do { \
2513 *errmsg_ptr = errmsg; \
2517 if ( avctx->codec_id == AV_CODEC_ID_NONE
2518 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2519 FAIL("unknown codec");
2520 switch (avctx->codec_type) {
2521 case AVMEDIA_TYPE_AUDIO:
2522 if (!avctx->frame_size && determinable_frame_size(avctx))
2523 FAIL("unspecified frame size");
2524 if (st->info->found_decoder >= 0 &&
2525 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2526 FAIL("unspecified sample format");
2527 if (!avctx->sample_rate)
2528 FAIL("unspecified sample rate");
2529 if (!avctx->channels)
2530 FAIL("unspecified number of channels");
2531 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2532 FAIL("no decodable DTS frames");
2534 case AVMEDIA_TYPE_VIDEO:
2536 FAIL("unspecified size");
2537 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2538 FAIL("unspecified pixel format");
2539 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2540 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2541 FAIL("no frame in rv30/40 and no sar");
2543 case AVMEDIA_TYPE_SUBTITLE:
2544 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2545 FAIL("unspecified size");
2547 case AVMEDIA_TYPE_DATA:
2548 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2554 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2555 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2556 AVDictionary **options)
2558 const AVCodec *codec;
2559 int got_picture = 1, ret = 0;
2560 AVFrame *frame = av_frame_alloc();
2561 AVSubtitle subtitle;
2562 AVPacket pkt = *avpkt;
2565 return AVERROR(ENOMEM);
2567 if (!avcodec_is_open(st->codec) &&
2568 st->info->found_decoder <= 0 &&
2569 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2570 AVDictionary *thread_opt = NULL;
2572 codec = find_decoder(s, st, st->codec->codec_id);
2575 st->info->found_decoder = -st->codec->codec_id;
2580 /* Force thread count to 1 since the H.264 decoder will not extract
2581 * SPS and PPS to extradata during multi-threaded decoding. */
2582 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2583 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2585 av_dict_free(&thread_opt);
2587 st->info->found_decoder = -st->codec->codec_id;
2590 st->info->found_decoder = 1;
2591 } else if (!st->info->found_decoder)
2592 st->info->found_decoder = 1;
2594 if (st->info->found_decoder < 0) {
2599 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2601 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2602 (!st->codec_info_nb_frames &&
2603 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2605 switch (st->codec->codec_type) {
2606 case AVMEDIA_TYPE_VIDEO:
2607 ret = avcodec_decode_video2(st->codec, frame,
2608 &got_picture, &pkt);
2610 case AVMEDIA_TYPE_AUDIO:
2611 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2613 case AVMEDIA_TYPE_SUBTITLE:
2614 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2615 &got_picture, &pkt);
2623 st->nb_decoded_frames++;
2630 if (!pkt.data && !got_picture)
2634 av_frame_free(&frame);
2638 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2640 while (tags->id != AV_CODEC_ID_NONE) {
2648 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2651 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2652 if (tag == tags[i].tag)
2654 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2655 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2657 return AV_CODEC_ID_NONE;
2660 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2665 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2667 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2669 return AV_CODEC_ID_NONE;
2674 if (sflags & (1 << (bps - 1))) {
2677 return AV_CODEC_ID_PCM_S8;
2679 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2681 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2683 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2685 return AV_CODEC_ID_NONE;
2690 return AV_CODEC_ID_PCM_U8;
2692 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2694 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2696 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2698 return AV_CODEC_ID_NONE;
2704 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2707 if (!av_codec_get_tag2(tags, id, &tag))
2712 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2716 for (i = 0; tags && tags[i]; i++) {
2717 const AVCodecTag *codec_tags = tags[i];
2718 while (codec_tags->id != AV_CODEC_ID_NONE) {
2719 if (codec_tags->id == id) {
2720 *tag = codec_tags->tag;
2729 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2732 for (i = 0; tags && tags[i]; i++) {
2733 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2734 if (id != AV_CODEC_ID_NONE)
2737 return AV_CODEC_ID_NONE;
2740 static void compute_chapters_end(AVFormatContext *s)
2743 int64_t max_time = s->duration +
2744 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2746 for (i = 0; i < s->nb_chapters; i++)
2747 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2748 AVChapter *ch = s->chapters[i];
2749 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2753 for (j = 0; j < s->nb_chapters; j++) {
2754 AVChapter *ch1 = s->chapters[j];
2755 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2757 if (j != i && next_start > ch->start && next_start < end)
2760 ch->end = (end == INT64_MAX) ? ch->start : end;
2764 static int get_std_framerate(int i)
2767 return (i + 1) * 1001;
2769 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2772 /* Is the time base unreliable?
2773 * This is a heuristic to balance between quick acceptance of the values in
2774 * the headers vs. some extra checks.
2775 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2776 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2777 * And there are "variable" fps files this needs to detect as well. */
2778 static int tb_unreliable(AVCodecContext *c)
2780 if (c->time_base.den >= 101L * c->time_base.num ||
2781 c->time_base.den < 5L * c->time_base.num ||
2782 // c->codec_tag == AV_RL32("DIVX") ||
2783 // c->codec_tag == AV_RL32("XVID") ||
2784 c->codec_tag == AV_RL32("mp4v") ||
2785 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2786 c->codec_id == AV_CODEC_ID_GIF ||
2787 c->codec_id == AV_CODEC_ID_H264)
2792 #if FF_API_FORMAT_PARAMETERS
2793 int av_find_stream_info(AVFormatContext *ic)
2795 return avformat_find_stream_info(ic, NULL);
2799 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2803 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2804 avctx->extradata_size = 0;
2805 return AVERROR(EINVAL);
2807 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2808 if (avctx->extradata) {
2809 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2810 avctx->extradata_size = size;
2813 avctx->extradata_size = 0;
2814 ret = AVERROR(ENOMEM);
2819 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2821 int ret = ff_alloc_extradata(avctx, size);
2824 ret = avio_read(pb, avctx->extradata, size);
2826 av_freep(&avctx->extradata);
2827 avctx->extradata_size = 0;
2828 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2829 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2835 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2838 int64_t last = st->info->last_dts;
2840 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2841 && ts - (uint64_t)last < INT64_MAX) {
2842 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2843 int64_t duration = ts - last;
2845 if (!st->info->duration_error)
2846 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2847 if (!st->info->duration_error)
2848 return AVERROR(ENOMEM);
2850 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2851 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2852 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2853 if (st->info->duration_error[0][1][i] < 1e10) {
2854 int framerate = get_std_framerate(i);
2855 double sdts = dts*framerate/(1001*12);
2856 for (j= 0; j<2; j++) {
2857 int64_t ticks = llrint(sdts+j*0.5);
2858 double error= sdts - ticks + j*0.5;
2859 st->info->duration_error[j][0][i] += error;
2860 st->info->duration_error[j][1][i] += error*error;
2864 st->info->duration_count++;
2865 st->info->rfps_duration_sum += duration;
2867 if (st->info->duration_count % 10 == 0) {
2868 int n = st->info->duration_count;
2869 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2870 if (st->info->duration_error[0][1][i] < 1e10) {
2871 double a0 = st->info->duration_error[0][0][i] / n;
2872 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2873 double a1 = st->info->duration_error[1][0][i] / n;
2874 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2875 if (error0 > 0.04 && error1 > 0.04) {
2876 st->info->duration_error[0][1][i] = 2e10;
2877 st->info->duration_error[1][1][i] = 2e10;
2883 // ignore the first 4 values, they might have some random jitter
2884 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2885 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2887 if (ts != AV_NOPTS_VALUE)
2888 st->info->last_dts = ts;
2893 void ff_rfps_calculate(AVFormatContext *ic)
2897 for (i = 0; i < ic->nb_streams; i++) {
2898 AVStream *st = ic->streams[i];
2900 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2902 // the check for tb_unreliable() is not completely correct, since this is not about handling
2903 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2904 // ipmovie.c produces.
2905 if (tb_unreliable(st->codec) && 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)
2906 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);
2907 if (st->info->duration_count>1 && !st->r_frame_rate.num
2908 && tb_unreliable(st->codec)) {
2910 double best_error= 0.01;
2911 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2913 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2916 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2918 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2921 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2924 for (k= 0; k<2; k++) {
2925 int n = st->info->duration_count;
2926 double a= st->info->duration_error[k][0][j] / n;
2927 double error= st->info->duration_error[k][1][j]/n - a*a;
2929 if (error < best_error && best_error> 0.000000001) {
2931 num = get_std_framerate(j);
2934 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2937 // do not increase frame rate by more than 1 % in order to match a standard rate.
2938 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2939 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2941 if ( !st->avg_frame_rate.num
2942 && st->r_frame_rate.num && st->info->rfps_duration_sum
2943 && st->info->codec_info_duration <= 0
2944 && st->info->duration_count > 2
2945 && 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
2947 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2948 st->avg_frame_rate = st->r_frame_rate;
2951 av_freep(&st->info->duration_error);
2952 st->info->last_dts = AV_NOPTS_VALUE;
2953 st->info->duration_count = 0;
2954 st->info->rfps_duration_sum = 0;
2958 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2960 int i, count, ret = 0, j;
2963 AVPacket pkt1, *pkt;
2964 int64_t old_offset = avio_tell(ic->pb);
2965 // new streams might appear, no options for those
2966 int orig_nb_streams = ic->nb_streams;
2968 int64_t max_analyze_duration = ic->max_analyze_duration2;
2969 int64_t probesize = ic->probesize2;
2971 if (!max_analyze_duration)
2972 max_analyze_duration = ic->max_analyze_duration;
2974 probesize = ic->probesize;
2975 flush_codecs = probesize > 0;
2977 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2979 if (!max_analyze_duration) {
2980 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2981 max_analyze_duration = 10*AV_TIME_BASE;
2983 max_analyze_duration = 5*AV_TIME_BASE;
2987 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2988 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2990 for (i = 0; i < ic->nb_streams; i++) {
2991 const AVCodec *codec;
2992 AVDictionary *thread_opt = NULL;
2993 st = ic->streams[i];
2995 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2996 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2997 /* if (!st->time_base.num)
2999 if (!st->codec->time_base.num)
3000 st->codec->time_base = st->time_base;
3002 // only for the split stuff
3003 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3004 st->parser = av_parser_init(st->codec->codec_id);
3006 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3007 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3008 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3009 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3011 } else if (st->need_parsing) {
3012 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3013 "%s, packets or times may be invalid.\n",
3014 avcodec_get_name(st->codec->codec_id));
3017 codec = find_decoder(ic, st, st->codec->codec_id);
3019 /* Force thread count to 1 since the H.264 decoder will not extract
3020 * SPS and PPS to extradata during multi-threaded decoding. */
3021 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3023 /* Ensure that subtitle_header is properly set. */
3024 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3025 && codec && !st->codec->codec) {
3026 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3027 av_log(ic, AV_LOG_WARNING,
3028 "Failed to open codec in av_find_stream_info\n");
3031 // Try to just open decoders, in case this is enough to get parameters.
3032 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3033 if (codec && !st->codec->codec)
3034 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3035 av_log(ic, AV_LOG_WARNING,
3036 "Failed to open codec in av_find_stream_info\n");
3039 av_dict_free(&thread_opt);
3042 for (i = 0; i < ic->nb_streams; i++) {
3043 #if FF_API_R_FRAME_RATE
3044 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3046 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3047 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3053 if (ff_check_interrupt(&ic->interrupt_callback)) {
3055 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3059 /* check if one codec still needs to be handled */
3060 for (i = 0; i < ic->nb_streams; i++) {
3061 int fps_analyze_framecount = 20;
3063 st = ic->streams[i];
3064 if (!has_codec_parameters(st, NULL))
3066 /* If the timebase is coarse (like the usual millisecond precision
3067 * of mkv), we need to analyze more frames to reliably arrive at
3068 * the correct fps. */
3069 if (av_q2d(st->time_base) > 0.0005)
3070 fps_analyze_framecount *= 2;
3071 if (!tb_unreliable(st->codec))
3072 fps_analyze_framecount = 0;
3073 if (ic->fps_probe_size >= 0)
3074 fps_analyze_framecount = ic->fps_probe_size;
3075 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3076 fps_analyze_framecount = 0;
3077 /* variable fps and no guess at the real fps */
3078 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3079 st->info->duration_count < fps_analyze_framecount &&
3080 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3082 if (st->parser && st->parser->parser->split &&
3083 !st->codec->extradata)
3085 if (st->first_dts == AV_NOPTS_VALUE &&
3086 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3087 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3088 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3091 if (i == ic->nb_streams) {
3092 /* NOTE: If the format has no header, then we need to read some
3093 * packets to get most of the streams, so we cannot stop here. */
3094 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3095 /* If we found the info for all the codecs, we can stop. */
3097 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3102 /* We did not get all the codec info, but we read too much data. */
3103 if (read_size >= probesize) {
3105 av_log(ic, AV_LOG_DEBUG,
3106 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3107 for (i = 0; i < ic->nb_streams; i++)
3108 if (!ic->streams[i]->r_frame_rate.num &&
3109 ic->streams[i]->info->duration_count <= 1 &&
3110 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3111 strcmp(ic->iformat->name, "image2"))
3112 av_log(ic, AV_LOG_WARNING,
3113 "Stream #%d: not enough frames to estimate rate; "
3114 "consider increasing probesize\n", i);
3118 /* NOTE: A new stream can be added there if no header in file
3119 * (AVFMTCTX_NOHEADER). */
3120 ret = read_frame_internal(ic, &pkt1);
3121 if (ret == AVERROR(EAGAIN))
3129 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3130 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3132 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3133 &ic->packet_buffer_end);
3135 ret = AVERROR(ENOMEM);
3136 goto find_stream_info_err;
3138 if ((ret = av_dup_packet(pkt)) < 0)
3139 goto find_stream_info_err;
3142 st = ic->streams[pkt->stream_index];
3143 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3144 read_size += pkt->size;
3146 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3147 /* check for non-increasing dts */
3148 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3149 st->info->fps_last_dts >= pkt->dts) {
3150 av_log(ic, AV_LOG_DEBUG,
3151 "Non-increasing DTS in stream %d: packet %d with DTS "
3152 "%"PRId64", packet %d with DTS %"PRId64"\n",
3153 st->index, st->info->fps_last_dts_idx,
3154 st->info->fps_last_dts, st->codec_info_nb_frames,
3156 st->info->fps_first_dts =
3157 st->info->fps_last_dts = AV_NOPTS_VALUE;
3159 /* Check for a discontinuity in dts. If the difference in dts
3160 * is more than 1000 times the average packet duration in the
3161 * sequence, we treat it as a discontinuity. */
3162 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3163 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3164 (pkt->dts - st->info->fps_last_dts) / 1000 >
3165 (st->info->fps_last_dts - st->info->fps_first_dts) /
3166 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3167 av_log(ic, AV_LOG_WARNING,
3168 "DTS discontinuity in stream %d: packet %d with DTS "
3169 "%"PRId64", packet %d with DTS %"PRId64"\n",
3170 st->index, st->info->fps_last_dts_idx,
3171 st->info->fps_last_dts, st->codec_info_nb_frames,
3173 st->info->fps_first_dts =
3174 st->info->fps_last_dts = AV_NOPTS_VALUE;
3177 /* update stored dts values */
3178 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3179 st->info->fps_first_dts = pkt->dts;
3180 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3182 st->info->fps_last_dts = pkt->dts;
3183 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3185 if (st->codec_info_nb_frames>1) {
3188 if (st->time_base.den > 0)
3189 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3190 if (st->avg_frame_rate.num > 0)
3191 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3194 && st->codec_info_nb_frames>30
3195 && st->info->fps_first_dts != AV_NOPTS_VALUE
3196 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3197 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3199 if (t >= max_analyze_duration) {
3200 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3201 max_analyze_duration,
3205 if (pkt->duration) {
3206 st->info->codec_info_duration += pkt->duration;
3207 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3210 #if FF_API_R_FRAME_RATE
3211 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3212 ff_rfps_add_frame(ic, st, pkt->dts);
3214 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3215 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3216 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3217 if (ff_alloc_extradata(st->codec, i))
3218 return AVERROR(ENOMEM);
3219 memcpy(st->codec->extradata, pkt->data,
3220 st->codec->extradata_size);
3224 /* If still no information, we try to open the codec and to
3225 * decompress the frame. We try to avoid that in most cases as
3226 * it takes longer and uses more memory. For MPEG-4, we need to
3227 * decompress for QuickTime.
3229 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3230 * least one frame of codec data, this makes sure the codec initializes
3231 * the channel configuration and does not only trust the values from
3233 try_decode_frame(ic, st, pkt,
3234 (options && i < orig_nb_streams) ? &options[i] : NULL);
3236 st->codec_info_nb_frames++;
3241 AVPacket empty_pkt = { 0 };
3243 av_init_packet(&empty_pkt);
3245 for (i = 0; i < ic->nb_streams; i++) {
3247 st = ic->streams[i];
3249 /* flush the decoders */
3250 if (st->info->found_decoder == 1) {
3252 err = try_decode_frame(ic, st, &empty_pkt,
3253 (options && i < orig_nb_streams)
3254 ? &options[i] : NULL);
3255 } while (err > 0 && !has_codec_parameters(st, NULL));
3258 av_log(ic, AV_LOG_INFO,
3259 "decoding for stream %d failed\n", st->index);
3264 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3266 // close codecs which were opened in try_decode_frame()
3267 for (i = 0; i < ic->nb_streams; i++) {
3268 st = ic->streams[i];
3269 avcodec_close(st->codec);
3272 ff_rfps_calculate(ic);
3274 for (i = 0; i < ic->nb_streams; i++) {
3275 st = ic->streams[i];
3276 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3277 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3278 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3279 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3280 st->codec->codec_tag= tag;
3283 /* estimate average framerate if not set by demuxer */
3284 if (st->info->codec_info_duration_fields &&
3285 !st->avg_frame_rate.num &&
3286 st->info->codec_info_duration) {
3288 double best_error = 0.01;
3290 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3291 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3292 st->info->codec_info_duration < 0)
3294 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3295 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3296 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3298 /* Round guessed framerate to a "standard" framerate if it's
3299 * within 1% of the original estimate. */
3300 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3301 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3302 double error = fabs(av_q2d(st->avg_frame_rate) /
3303 av_q2d(std_fps) - 1);
3305 if (error < best_error) {
3307 best_fps = std_fps.num;
3311 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3312 best_fps, 12 * 1001, INT_MAX);
3315 if (!st->r_frame_rate.num) {
3316 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3317 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3318 st->r_frame_rate.num = st->codec->time_base.den;
3319 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3321 st->r_frame_rate.num = st->time_base.den;
3322 st->r_frame_rate.den = st->time_base.num;
3325 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3326 if (!st->codec->bits_per_coded_sample)
3327 st->codec->bits_per_coded_sample =
3328 av_get_bits_per_sample(st->codec->codec_id);
3329 // set stream disposition based on audio service type
3330 switch (st->codec->audio_service_type) {
3331 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3332 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3334 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3335 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3337 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3338 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3340 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3341 st->disposition = AV_DISPOSITION_COMMENT;
3343 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3344 st->disposition = AV_DISPOSITION_KARAOKE;
3351 estimate_timings(ic, old_offset);
3353 if (ret >= 0 && ic->nb_streams)
3354 /* We could not have all the codec parameters before EOF. */
3356 for (i = 0; i < ic->nb_streams; i++) {
3358 st = ic->streams[i];
3359 if (!has_codec_parameters(st, &errmsg)) {
3361 avcodec_string(buf, sizeof(buf), st->codec, 0);
3362 av_log(ic, AV_LOG_WARNING,
3363 "Could not find codec parameters for stream %d (%s): %s\n"
3364 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3371 compute_chapters_end(ic);
3373 find_stream_info_err:
3374 for (i = 0; i < ic->nb_streams; i++) {
3375 st = ic->streams[i];
3376 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3377 ic->streams[i]->codec->thread_count = 0;
3379 av_freep(&st->info->duration_error);
3380 av_freep(&ic->streams[i]->info);
3383 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3384 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3388 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3392 for (i = 0; i < ic->nb_programs; i++) {
3393 if (ic->programs[i] == last) {
3397 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3398 if (ic->programs[i]->stream_index[j] == s)
3399 return ic->programs[i];
3405 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3406 int wanted_stream_nb, int related_stream,
3407 AVCodec **decoder_ret, int flags)
3409 int i, nb_streams = ic->nb_streams;
3410 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3411 unsigned *program = NULL;
3412 const AVCodec *decoder = NULL, *best_decoder = NULL;
3414 if (related_stream >= 0 && wanted_stream_nb < 0) {
3415 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3417 program = p->stream_index;
3418 nb_streams = p->nb_stream_indexes;
3421 for (i = 0; i < nb_streams; i++) {
3422 int real_stream_index = program ? program[i] : i;
3423 AVStream *st = ic->streams[real_stream_index];
3424 AVCodecContext *avctx = st->codec;
3425 if (avctx->codec_type != type)
3427 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3429 if (wanted_stream_nb != real_stream_index &&
3430 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3431 AV_DISPOSITION_VISUAL_IMPAIRED))
3433 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3436 decoder = find_decoder(ic, st, st->codec->codec_id);
3439 ret = AVERROR_DECODER_NOT_FOUND;
3443 count = st->codec_info_nb_frames;
3444 bitrate = avctx->bit_rate;
3446 bitrate = avctx->rc_max_rate;
3447 multiframe = FFMIN(5, count);
3448 if ((best_multiframe > multiframe) ||
3449 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3450 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3453 best_bitrate = bitrate;
3454 best_multiframe = multiframe;
3455 ret = real_stream_index;
3456 best_decoder = decoder;
3457 if (program && i == nb_streams - 1 && ret < 0) {
3459 nb_streams = ic->nb_streams;
3460 /* no related stream found, try again with everything */
3465 *decoder_ret = (AVCodec*)best_decoder;
3469 /*******************************************************/
3471 int av_read_play(AVFormatContext *s)
3473 if (s->iformat->read_play)
3474 return s->iformat->read_play(s);
3476 return avio_pause(s->pb, 0);
3477 return AVERROR(ENOSYS);
3480 int av_read_pause(AVFormatContext *s)
3482 if (s->iformat->read_pause)
3483 return s->iformat->read_pause(s);
3485 return avio_pause(s->pb, 1);
3486 return AVERROR(ENOSYS);
3489 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3491 av_assert0(s->nb_streams>0);
3492 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3494 for (j = 0; j < st->nb_side_data; j++)
3495 av_freep(&st->side_data[j].data);
3496 av_freep(&st->side_data);
3497 st->nb_side_data = 0;
3500 av_parser_close(st->parser);
3502 if (st->attached_pic.data)
3503 av_free_packet(&st->attached_pic);
3504 av_dict_free(&st->metadata);
3505 av_freep(&st->probe_data.buf);
3506 av_freep(&st->index_entries);
3507 av_freep(&st->codec->extradata);
3508 av_freep(&st->codec->subtitle_header);
3509 av_freep(&st->codec);
3510 av_freep(&st->priv_data);
3512 av_freep(&st->info->duration_error);
3513 av_freep(&st->info);
3514 av_freep(&s->streams[ --s->nb_streams ]);
3517 void avformat_free_context(AVFormatContext *s)
3525 if (s->iformat && s->iformat->priv_class && s->priv_data)
3526 av_opt_free(s->priv_data);
3527 if (s->oformat && s->oformat->priv_class && s->priv_data)
3528 av_opt_free(s->priv_data);
3530 for (i = s->nb_streams - 1; i >= 0; i--) {
3531 ff_free_stream(s, s->streams[i]);
3533 for (i = s->nb_programs - 1; i >= 0; i--) {
3534 av_dict_free(&s->programs[i]->metadata);
3535 av_freep(&s->programs[i]->stream_index);
3536 av_freep(&s->programs[i]);
3538 av_freep(&s->programs);
3539 av_freep(&s->priv_data);
3540 while (s->nb_chapters--) {
3541 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3542 av_freep(&s->chapters[s->nb_chapters]);
3544 av_freep(&s->chapters);
3545 av_dict_free(&s->metadata);
3546 av_freep(&s->streams);
3547 av_freep(&s->internal);
3551 #if FF_API_CLOSE_INPUT_FILE
3552 void av_close_input_file(AVFormatContext *s)
3554 avformat_close_input(&s);
3558 void avformat_close_input(AVFormatContext **ps)
3569 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3570 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3573 flush_packet_queue(s);
3576 if (s->iformat->read_close)
3577 s->iformat->read_close(s);
3579 avformat_free_context(s);
3586 #if FF_API_NEW_STREAM
3587 AVStream *av_new_stream(AVFormatContext *s, int id)
3589 AVStream *st = avformat_new_stream(s, NULL);
3596 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3602 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3604 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3607 s->streams = streams;
3609 st = av_mallocz(sizeof(AVStream));
3612 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3616 st->info->last_dts = AV_NOPTS_VALUE;
3618 st->codec = avcodec_alloc_context3(c);
3620 /* no default bitrate if decoding */
3621 st->codec->bit_rate = 0;
3623 /* default pts setting is MPEG-like */
3624 avpriv_set_pts_info(st, 33, 1, 90000);
3627 st->index = s->nb_streams;
3628 st->start_time = AV_NOPTS_VALUE;
3629 st->duration = AV_NOPTS_VALUE;
3630 /* we set the current DTS to 0 so that formats without any timestamps
3631 * but durations get some timestamps, formats with some unknown
3632 * timestamps have their first few packets buffered and the
3633 * timestamps corrected before they are returned to the user */
3634 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3635 st->first_dts = AV_NOPTS_VALUE;
3636 st->probe_packets = MAX_PROBE_PACKETS;
3637 st->pts_wrap_reference = AV_NOPTS_VALUE;
3638 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3640 st->last_IP_pts = AV_NOPTS_VALUE;
3641 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3642 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3643 st->pts_buffer[i] = AV_NOPTS_VALUE;
3645 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3647 #if FF_API_R_FRAME_RATE
3648 st->info->last_dts = AV_NOPTS_VALUE;
3650 st->info->fps_first_dts = AV_NOPTS_VALUE;
3651 st->info->fps_last_dts = AV_NOPTS_VALUE;
3653 st->inject_global_side_data = s->internal->inject_global_side_data;
3655 s->streams[s->nb_streams++] = st;
3659 AVProgram *av_new_program(AVFormatContext *ac, int id)
3661 AVProgram *program = NULL;
3664 av_dlog(ac, "new_program: id=0x%04x\n", id);
3666 for (i = 0; i < ac->nb_programs; i++)
3667 if (ac->programs[i]->id == id)
3668 program = ac->programs[i];
3671 program = av_mallocz(sizeof(AVProgram));
3674 dynarray_add(&ac->programs, &ac->nb_programs, program);
3675 program->discard = AVDISCARD_NONE;
3678 program->pts_wrap_reference = AV_NOPTS_VALUE;
3679 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3681 program->start_time =
3682 program->end_time = AV_NOPTS_VALUE;
3687 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3688 int64_t start, int64_t end, const char *title)
3690 AVChapter *chapter = NULL;
3693 if (end != AV_NOPTS_VALUE && start > end) {
3694 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3698 for (i = 0; i < s->nb_chapters; i++)
3699 if (s->chapters[i]->id == id)
3700 chapter = s->chapters[i];
3703 chapter = av_mallocz(sizeof(AVChapter));
3706 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3708 av_dict_set(&chapter->metadata, "title", title, 0);
3710 chapter->time_base = time_base;
3711 chapter->start = start;
3717 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3720 AVProgram *program = NULL;
3723 if (idx >= ac->nb_streams) {
3724 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3728 for (i = 0; i < ac->nb_programs; i++) {
3729 if (ac->programs[i]->id != progid)
3731 program = ac->programs[i];
3732 for (j = 0; j < program->nb_stream_indexes; j++)
3733 if (program->stream_index[j] == idx)
3736 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3739 program->stream_index = tmp;
3740 program->stream_index[program->nb_stream_indexes++] = idx;
3745 uint64_t ff_ntp_time(void)
3747 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3750 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3753 char *q, buf1[20], c;
3754 int nd, len, percentd_found;
3766 while (av_isdigit(*p))
3767 nd = nd * 10 + *p++ - '0';
3769 } while (av_isdigit(c));
3778 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3780 if ((q - buf + len) > buf_size - 1)
3782 memcpy(q, buf1, len);
3790 if ((q - buf) < buf_size - 1)
3794 if (!percentd_found)
3803 void av_url_split(char *proto, int proto_size,
3804 char *authorization, int authorization_size,
3805 char *hostname, int hostname_size,
3806 int *port_ptr, char *path, int path_size, const char *url)
3808 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3814 if (authorization_size > 0)
3815 authorization[0] = 0;
3816 if (hostname_size > 0)
3821 /* parse protocol */
3822 if ((p = strchr(url, ':'))) {
3823 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3830 /* no protocol means plain filename */
3831 av_strlcpy(path, url, path_size);
3835 /* separate path from hostname */
3836 ls = strchr(p, '/');
3837 ls2 = strchr(p, '?');
3841 ls = FFMIN(ls, ls2);
3843 av_strlcpy(path, ls, path_size);
3845 ls = &p[strlen(p)]; // XXX
3847 /* the rest is hostname, use that to parse auth/port */
3849 /* authorization (user[:pass]@hostname) */
3851 while ((at = strchr(p, '@')) && at < ls) {
3852 av_strlcpy(authorization, at2,
3853 FFMIN(authorization_size, at + 1 - at2));
3854 p = at + 1; /* skip '@' */
3857 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3859 av_strlcpy(hostname, p + 1,
3860 FFMIN(hostname_size, brk - p));
3861 if (brk[1] == ':' && port_ptr)
3862 *port_ptr = atoi(brk + 2);
3863 } else if ((col = strchr(p, ':')) && col < ls) {
3864 av_strlcpy(hostname, p,
3865 FFMIN(col + 1 - p, hostname_size));
3867 *port_ptr = atoi(col + 1);
3869 av_strlcpy(hostname, p,
3870 FFMIN(ls + 1 - p, hostname_size));
3874 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3877 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3880 'C', 'D', 'E', 'F' };
3881 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3884 'c', 'd', 'e', 'f' };
3885 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3887 for (i = 0; i < s; i++) {
3888 buff[i * 2] = hex_table[src[i] >> 4];
3889 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3895 int ff_hex_to_data(uint8_t *data, const char *p)
3902 p += strspn(p, SPACE_CHARS);
3905 c = av_toupper((unsigned char) *p++);
3906 if (c >= '0' && c <= '9')
3908 else if (c >= 'A' && c <= 'F')
3923 #if FF_API_SET_PTS_INFO
3924 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3925 unsigned int pts_num, unsigned int pts_den)
3927 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3931 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3932 unsigned int pts_num, unsigned int pts_den)
3935 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3936 if (new_tb.num != pts_num)
3937 av_log(NULL, AV_LOG_DEBUG,
3938 "st:%d removing common factor %d from timebase\n",
3939 s->index, pts_num / new_tb.num);
3941 av_log(NULL, AV_LOG_WARNING,
3942 "st:%d has too large timebase, reducing\n", s->index);
3944 if (new_tb.num <= 0 || new_tb.den <= 0) {
3945 av_log(NULL, AV_LOG_ERROR,
3946 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3947 new_tb.num, new_tb.den,
3951 s->time_base = new_tb;
3952 av_codec_set_pkt_timebase(s->codec, new_tb);
3953 s->pts_wrap_bits = pts_wrap_bits;
3956 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3959 const char *ptr = str;
3961 /* Parse key=value pairs. */
3964 char *dest = NULL, *dest_end;
3965 int key_len, dest_len = 0;
3967 /* Skip whitespace and potential commas. */
3968 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3975 if (!(ptr = strchr(key, '=')))
3978 key_len = ptr - key;
3980 callback_get_buf(context, key, key_len, &dest, &dest_len);
3981 dest_end = dest + dest_len - 1;
3985 while (*ptr && *ptr != '\"') {
3989 if (dest && dest < dest_end)
3993 if (dest && dest < dest_end)
4001 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4002 if (dest && dest < dest_end)
4010 int ff_find_stream_index(AVFormatContext *s, int id)
4013 for (i = 0; i < s->nb_streams; i++)
4014 if (s->streams[i]->id == id)
4019 int64_t ff_iso8601_to_unix_time(const char *datestr)
4021 struct tm time1 = { 0 }, time2 = { 0 };
4023 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4024 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4026 return av_timegm(&time2);
4028 return av_timegm(&time1);
4031 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4035 if (ofmt->query_codec)
4036 return ofmt->query_codec(codec_id, std_compliance);
4037 else if (ofmt->codec_tag)
4038 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4039 else if (codec_id == ofmt->video_codec ||
4040 codec_id == ofmt->audio_codec ||
4041 codec_id == ofmt->subtitle_codec)
4044 return AVERROR_PATCHWELCOME;
4047 int avformat_network_init(void)
4051 ff_network_inited_globally = 1;
4052 if ((ret = ff_network_init()) < 0)
4059 int avformat_network_deinit(void)
4068 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4069 uint64_t channel_layout, int32_t sample_rate,
4070 int32_t width, int32_t height)
4076 return AVERROR(EINVAL);
4079 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4081 if (channel_layout) {
4083 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4087 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4089 if (width || height) {
4091 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4093 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4095 return AVERROR(ENOMEM);
4096 bytestream_put_le32(&data, flags);
4098 bytestream_put_le32(&data, channels);
4100 bytestream_put_le64(&data, channel_layout);
4102 bytestream_put_le32(&data, sample_rate);
4103 if (width || height) {
4104 bytestream_put_le32(&data, width);
4105 bytestream_put_le32(&data, height);
4110 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4112 AVRational undef = {0, 1};
4113 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4114 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4115 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4117 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4118 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4119 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4120 stream_sample_aspect_ratio = undef;
4122 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4123 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4124 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4125 frame_sample_aspect_ratio = undef;
4127 if (stream_sample_aspect_ratio.num)
4128 return stream_sample_aspect_ratio;
4130 return frame_sample_aspect_ratio;
4133 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4135 AVRational fr = st->r_frame_rate;
4136 AVRational codec_fr = av_inv_q(st->codec->time_base);
4137 AVRational avg_fr = st->avg_frame_rate;
4139 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4140 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4145 if (st->codec->ticks_per_frame > 1) {
4146 codec_fr.den *= st->codec->ticks_per_frame;
4147 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4148 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4155 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4158 if (*spec <= '9' && *spec >= '0') /* opt:index */
4159 return strtol(spec, NULL, 0) == st->index;
4160 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4161 *spec == 't') { /* opt:[vasdt] */
4162 enum AVMediaType type;
4165 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4166 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4167 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4168 case 'd': type = AVMEDIA_TYPE_DATA; break;
4169 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4170 default: av_assert0(0);
4172 if (type != st->codec->codec_type)
4174 if (*spec++ == ':') { /* possibly followed by :index */
4175 int i, index = strtol(spec, NULL, 0);
4176 for (i = 0; i < s->nb_streams; i++)
4177 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4178 return i == st->index;
4182 } else if (*spec == 'p' && *(spec + 1) == ':') {
4186 prog_id = strtol(spec, &endptr, 0);
4187 for (i = 0; i < s->nb_programs; i++) {
4188 if (s->programs[i]->id != prog_id)
4191 if (*endptr++ == ':') {
4192 int stream_idx = strtol(endptr, NULL, 0);
4193 return stream_idx >= 0 &&
4194 stream_idx < s->programs[i]->nb_stream_indexes &&
4195 st->index == s->programs[i]->stream_index[stream_idx];
4198 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4199 if (st->index == s->programs[i]->stream_index[j])
4203 } else if (*spec == '#' ||
4204 (*spec == 'i' && *(spec + 1) == ':')) {
4207 spec += 1 + (*spec == 'i');
4208 stream_id = strtol(spec, &endptr, 0);
4210 return stream_id == st->id;
4211 } else if (*spec == 'm' && *(spec + 1) == ':') {
4212 AVDictionaryEntry *tag;
4217 val = strchr(spec, ':');
4219 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4221 return AVERROR(ENOMEM);
4223 tag = av_dict_get(st->metadata, key, NULL, 0);
4225 if (!val || !strcmp(tag->value, val + 1))
4234 } else if (!*spec) /* empty specifier, matches everything */
4237 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4238 return AVERROR(EINVAL);
4241 int ff_generate_avci_extradata(AVStream *st)
4243 static const uint8_t avci100_1080p_extradata[] = {
4245 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4246 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4247 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4248 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4249 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4250 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4251 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4252 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4253 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4255 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4258 static const uint8_t avci100_1080i_extradata[] = {
4260 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4261 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4262 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4263 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4264 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4265 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4266 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4267 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4268 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4269 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4270 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4272 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4275 static const uint8_t avci50_1080i_extradata[] = {
4277 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4278 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4279 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4280 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4281 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4282 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4283 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4284 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4285 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4286 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4287 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4289 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4292 static const uint8_t avci100_720p_extradata[] = {
4294 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4295 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4296 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4297 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4298 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4299 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4300 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4301 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4302 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4303 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4305 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4309 const uint8_t *data = NULL;
4312 if (st->codec->width == 1920) {
4313 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4314 data = avci100_1080p_extradata;
4315 size = sizeof(avci100_1080p_extradata);
4317 data = avci100_1080i_extradata;
4318 size = sizeof(avci100_1080i_extradata);
4320 } else if (st->codec->width == 1440) {
4321 data = avci50_1080i_extradata;
4322 size = sizeof(avci50_1080i_extradata);
4323 } else if (st->codec->width == 1280) {
4324 data = avci100_720p_extradata;
4325 size = sizeof(avci100_720p_extradata);
4331 av_freep(&st->codec->extradata);
4332 if (ff_alloc_extradata(st->codec, size))
4333 return AVERROR(ENOMEM);
4334 memcpy(st->codec->extradata, data, size);
4339 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4344 for (i = 0; i < st->nb_side_data; i++) {
4345 if (st->side_data[i].type == type) {
4347 *size = st->side_data[i].size;
4348 return st->side_data[i].data;