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 /* give frame_size priority if demuxing */
723 if (!mux && enc->frame_size > 1)
724 return enc->frame_size;
726 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
729 /* Fall back on using frame_size if muxing. */
730 if (enc->frame_size > 1)
731 return enc->frame_size;
733 //For WMA we currently have no other means to calculate duration thus we
734 //do it here by assuming CBR, which is true for all known cases.
735 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
736 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
737 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
744 * Return the frame duration in seconds. Return 0 if not available.
746 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
747 AVCodecParserContext *pc, AVPacket *pkt)
753 switch (st->codec->codec_type) {
754 case AVMEDIA_TYPE_VIDEO:
755 if (st->r_frame_rate.num && !pc) {
756 *pnum = st->r_frame_rate.den;
757 *pden = st->r_frame_rate.num;
758 } else if (st->time_base.num * 1000LL > st->time_base.den) {
759 *pnum = st->time_base.num;
760 *pden = st->time_base.den;
761 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
762 *pnum = st->codec->time_base.num;
763 *pden = st->codec->time_base.den;
764 if (pc && pc->repeat_pict) {
765 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
766 *pden /= 1 + pc->repeat_pict;
768 *pnum *= 1 + pc->repeat_pict;
770 /* If this codec can be interlaced or progressive then we need
771 * a parser to compute duration of a packet. Thus if we have
772 * no parser in such case leave duration undefined. */
773 if (st->codec->ticks_per_frame > 1 && !pc)
777 case AVMEDIA_TYPE_AUDIO:
778 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
779 if (frame_size <= 0 || st->codec->sample_rate <= 0)
782 *pden = st->codec->sample_rate;
789 static int is_intra_only(AVCodecContext *enc) {
790 const AVCodecDescriptor *desc;
792 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
795 desc = av_codec_get_codec_descriptor(enc);
797 desc = avcodec_descriptor_get(enc->codec_id);
798 av_codec_set_codec_descriptor(enc, desc);
801 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
805 static int has_decode_delay_been_guessed(AVStream *st)
807 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
808 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
810 #if CONFIG_H264_DECODER
811 if (st->codec->has_b_frames &&
812 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
815 if (st->codec->has_b_frames<3)
816 return st->nb_decoded_frames >= 7;
817 else if (st->codec->has_b_frames<4)
818 return st->nb_decoded_frames >= 18;
820 return st->nb_decoded_frames >= 20;
823 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
827 if (pktl == s->packet_buffer_end)
828 return s->parse_queue;
832 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
833 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
834 st->codec->codec_id != AV_CODEC_ID_HEVC;
837 int delay = st->codec->has_b_frames;
840 if (dts == AV_NOPTS_VALUE) {
841 int64_t best_score = INT64_MAX;
842 for (i = 0; i<delay; i++) {
843 if (st->pts_reorder_error_count[i]) {
844 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
845 if (score < best_score) {
852 for (i = 0; i<delay; i++) {
853 if (pts_buffer[i] != AV_NOPTS_VALUE) {
854 int64_t diff = FFABS(pts_buffer[i] - dts)
855 + (uint64_t)st->pts_reorder_error[i];
856 diff = FFMAX(diff, st->pts_reorder_error[i]);
857 st->pts_reorder_error[i] = diff;
858 st->pts_reorder_error_count[i]++;
859 if (st->pts_reorder_error_count[i] > 250) {
860 st->pts_reorder_error[i] >>= 1;
861 st->pts_reorder_error_count[i] >>= 1;
868 if (dts == AV_NOPTS_VALUE)
874 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
875 int64_t dts, int64_t pts, AVPacket *pkt)
877 AVStream *st = s->streams[stream_index];
878 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
879 int64_t pts_buffer[MAX_REORDER_DELAY+1];
883 if (st->first_dts != AV_NOPTS_VALUE ||
884 dts == AV_NOPTS_VALUE ||
885 st->cur_dts == AV_NOPTS_VALUE ||
889 delay = st->codec->has_b_frames;
890 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
892 shift = st->first_dts - RELATIVE_TS_BASE;
894 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
895 pts_buffer[i] = AV_NOPTS_VALUE;
897 if (is_relative(pts))
900 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
901 if (pktl->pkt.stream_index != stream_index)
903 if (is_relative(pktl->pkt.pts))
904 pktl->pkt.pts += shift;
906 if (is_relative(pktl->pkt.dts))
907 pktl->pkt.dts += shift;
909 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
910 st->start_time = pktl->pkt.pts;
912 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
913 pts_buffer[0] = pktl->pkt.pts;
914 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
915 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
917 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
921 if (st->start_time == AV_NOPTS_VALUE)
922 st->start_time = pts;
925 static void update_initial_durations(AVFormatContext *s, AVStream *st,
926 int stream_index, int duration)
928 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
929 int64_t cur_dts = RELATIVE_TS_BASE;
931 if (st->first_dts != AV_NOPTS_VALUE) {
932 if (st->update_initial_durations_done)
934 st->update_initial_durations_done = 1;
935 cur_dts = st->first_dts;
936 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
937 if (pktl->pkt.stream_index == stream_index) {
938 if (pktl->pkt.pts != pktl->pkt.dts ||
939 pktl->pkt.dts != AV_NOPTS_VALUE ||
945 if (pktl && pktl->pkt.dts != st->first_dts) {
946 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
947 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
951 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
954 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
955 st->first_dts = cur_dts;
956 } else if (st->cur_dts != RELATIVE_TS_BASE)
959 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
960 if (pktl->pkt.stream_index != stream_index)
962 if (pktl->pkt.pts == pktl->pkt.dts &&
963 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
964 !pktl->pkt.duration) {
965 pktl->pkt.dts = cur_dts;
966 if (!st->codec->has_b_frames)
967 pktl->pkt.pts = cur_dts;
968 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
969 pktl->pkt.duration = duration;
972 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
975 st->cur_dts = cur_dts;
978 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
979 AVCodecParserContext *pc, AVPacket *pkt)
981 int num, den, presentation_delayed, delay, i;
984 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
985 st->codec->codec_id != AV_CODEC_ID_HEVC;
987 if (s->flags & AVFMT_FLAG_NOFILLIN)
990 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
991 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
992 if (st->last_dts_for_order_check <= pkt->dts) {
995 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
996 "DTS %"PRIi64" < %"PRIi64" out of order\n",
998 st->last_dts_for_order_check);
999 st->dts_misordered++;
1001 if (st->dts_ordered + st->dts_misordered > 250) {
1002 st->dts_ordered >>= 1;
1003 st->dts_misordered >>= 1;
1007 st->last_dts_for_order_check = pkt->dts;
1008 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1009 pkt->dts = AV_NOPTS_VALUE;
1012 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1013 pkt->dts = AV_NOPTS_VALUE;
1015 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1016 && !st->codec->has_b_frames)
1017 //FIXME Set low_delay = 0 when has_b_frames = 1
1018 st->codec->has_b_frames = 1;
1020 /* do we have a video B-frame ? */
1021 delay = st->codec->has_b_frames;
1022 presentation_delayed = 0;
1024 /* XXX: need has_b_frame, but cannot get it if the codec is
1025 * not initialized */
1027 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1028 presentation_delayed = 1;
1030 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1031 st->pts_wrap_bits < 63 &&
1032 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1033 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1034 pkt->dts -= 1LL << st->pts_wrap_bits;
1036 pkt->pts += 1LL << st->pts_wrap_bits;
1039 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1040 * We take the conservative approach and discard both.
1041 * Note: If this is misbehaving for an H.264 file, then possibly
1042 * presentation_delayed is not set correctly. */
1043 if (delay == 1 && pkt->dts == pkt->pts &&
1044 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1045 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1046 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1047 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1048 pkt->dts = AV_NOPTS_VALUE;
1051 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1052 if (pkt->duration == 0) {
1053 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1055 duration = (AVRational) {num, den};
1056 pkt->duration = av_rescale_rnd(1,
1057 num * (int64_t) st->time_base.den,
1058 den * (int64_t) st->time_base.num,
1063 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1064 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1066 /* Correct timestamps with byte offset if demuxers only have timestamps
1067 * on packet boundaries */
1068 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1069 /* this will estimate bitrate based on this frame's duration and size */
1070 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1071 if (pkt->pts != AV_NOPTS_VALUE)
1073 if (pkt->dts != AV_NOPTS_VALUE)
1077 /* This may be redundant, but it should not hurt. */
1078 if (pkt->dts != AV_NOPTS_VALUE &&
1079 pkt->pts != AV_NOPTS_VALUE &&
1080 pkt->pts > pkt->dts)
1081 presentation_delayed = 1;
1084 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1085 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1086 pkt->stream_index, pc, pkt->duration);
1087 /* Interpolate PTS and DTS if they are not present. We skip H264
1088 * currently because delay and has_b_frames are not reliably set. */
1089 if ((delay == 0 || (delay == 1 && pc)) &&
1091 if (presentation_delayed) {
1092 /* DTS = decompression timestamp */
1093 /* PTS = presentation timestamp */
1094 if (pkt->dts == AV_NOPTS_VALUE)
1095 pkt->dts = st->last_IP_pts;
1096 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1097 if (pkt->dts == AV_NOPTS_VALUE)
1098 pkt->dts = st->cur_dts;
1100 /* This is tricky: the dts must be incremented by the duration
1101 * of the frame we are displaying, i.e. the last I- or P-frame. */
1102 if (st->last_IP_duration == 0)
1103 st->last_IP_duration = pkt->duration;
1104 if (pkt->dts != AV_NOPTS_VALUE)
1105 st->cur_dts = pkt->dts + st->last_IP_duration;
1106 st->last_IP_duration = pkt->duration;
1107 st->last_IP_pts = pkt->pts;
1108 /* Cannot compute PTS if not present (we can compute it only
1109 * by knowing the future. */
1110 } else if (pkt->pts != AV_NOPTS_VALUE ||
1111 pkt->dts != AV_NOPTS_VALUE ||
1114 /* presentation is not delayed : PTS and DTS are the same */
1115 if (pkt->pts == AV_NOPTS_VALUE)
1116 pkt->pts = pkt->dts;
1117 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1119 if (pkt->pts == AV_NOPTS_VALUE)
1120 pkt->pts = st->cur_dts;
1121 pkt->dts = pkt->pts;
1122 if (pkt->pts != AV_NOPTS_VALUE)
1123 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1127 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1128 st->pts_buffer[0] = pkt->pts;
1129 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1130 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1132 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1134 // We skipped it above so we try here.
1136 // This should happen on the first packet
1137 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1138 if (pkt->dts > st->cur_dts)
1139 st->cur_dts = pkt->dts;
1141 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1142 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1145 if (is_intra_only(st->codec))
1146 pkt->flags |= AV_PKT_FLAG_KEY;
1148 pkt->convergence_duration = pc->convergence_duration;
1151 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1154 AVPacketList *pktl = *pkt_buf;
1155 *pkt_buf = pktl->next;
1156 av_free_packet(&pktl->pkt);
1159 *pkt_buf_end = NULL;
1163 * Parse a packet, add all split parts to parse_queue.
1165 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1167 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1169 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1170 AVStream *st = s->streams[stream_index];
1171 uint8_t *data = pkt ? pkt->data : NULL;
1172 int size = pkt ? pkt->size : 0;
1173 int ret = 0, got_output = 0;
1176 av_init_packet(&flush_pkt);
1179 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1180 // preserve 0-size sync packets
1181 compute_pkt_fields(s, st, st->parser, pkt);
1184 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1187 av_init_packet(&out_pkt);
1188 len = av_parser_parse2(st->parser, st->codec,
1189 &out_pkt.data, &out_pkt.size, data, size,
1190 pkt->pts, pkt->dts, pkt->pos);
1192 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1194 /* increment read pointer */
1198 got_output = !!out_pkt.size;
1203 if (pkt->side_data) {
1204 out_pkt.side_data = pkt->side_data;
1205 out_pkt.side_data_elems = pkt->side_data_elems;
1206 pkt->side_data = NULL;
1207 pkt->side_data_elems = 0;
1210 /* set the duration */
1211 out_pkt.duration = 0;
1212 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1213 if (st->codec->sample_rate > 0) {
1215 av_rescale_q_rnd(st->parser->duration,
1216 (AVRational) { 1, st->codec->sample_rate },
1222 out_pkt.stream_index = st->index;
1223 out_pkt.pts = st->parser->pts;
1224 out_pkt.dts = st->parser->dts;
1225 out_pkt.pos = st->parser->pos;
1227 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1228 out_pkt.pos = st->parser->frame_offset;
1230 if (st->parser->key_frame == 1 ||
1231 (st->parser->key_frame == -1 &&
1232 st->parser->pict_type == AV_PICTURE_TYPE_I))
1233 out_pkt.flags |= AV_PKT_FLAG_KEY;
1235 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1236 out_pkt.flags |= AV_PKT_FLAG_KEY;
1238 compute_pkt_fields(s, st, st->parser, &out_pkt);
1240 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1241 out_pkt.buf = pkt->buf;
1243 #if FF_API_DESTRUCT_PACKET
1244 FF_DISABLE_DEPRECATION_WARNINGS
1245 out_pkt.destruct = pkt->destruct;
1246 pkt->destruct = NULL;
1247 FF_ENABLE_DEPRECATION_WARNINGS
1250 if ((ret = av_dup_packet(&out_pkt)) < 0)
1253 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1254 av_free_packet(&out_pkt);
1255 ret = AVERROR(ENOMEM);
1260 /* end of the stream => close and free the parser */
1261 if (pkt == &flush_pkt) {
1262 av_parser_close(st->parser);
1267 av_free_packet(pkt);
1271 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1272 AVPacketList **pkt_buffer_end,
1276 av_assert0(*pkt_buffer);
1279 *pkt_buffer = pktl->next;
1281 *pkt_buffer_end = NULL;
1286 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1288 int ret = 0, i, got_packet = 0;
1290 av_init_packet(pkt);
1292 while (!got_packet && !s->parse_queue) {
1296 /* read next packet */
1297 ret = ff_read_packet(s, &cur_pkt);
1299 if (ret == AVERROR(EAGAIN))
1301 /* flush the parsers */
1302 for (i = 0; i < s->nb_streams; i++) {
1304 if (st->parser && st->need_parsing)
1305 parse_packet(s, NULL, st->index);
1307 /* all remaining packets are now in parse_queue =>
1308 * really terminate parsing */
1312 st = s->streams[cur_pkt.stream_index];
1314 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1315 cur_pkt.dts != AV_NOPTS_VALUE &&
1316 cur_pkt.pts < cur_pkt.dts) {
1317 av_log(s, AV_LOG_WARNING,
1318 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1319 cur_pkt.stream_index,
1320 av_ts2str(cur_pkt.pts),
1321 av_ts2str(cur_pkt.dts),
1324 if (s->debug & FF_FDEBUG_TS)
1325 av_log(s, AV_LOG_DEBUG,
1326 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1327 cur_pkt.stream_index,
1328 av_ts2str(cur_pkt.pts),
1329 av_ts2str(cur_pkt.dts),
1330 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1332 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1333 st->parser = av_parser_init(st->codec->codec_id);
1335 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1336 "%s, packets or times may be invalid.\n",
1337 avcodec_get_name(st->codec->codec_id));
1338 /* no parser available: just output the raw packets */
1339 st->need_parsing = AVSTREAM_PARSE_NONE;
1340 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1341 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1342 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1343 st->parser->flags |= PARSER_FLAG_ONCE;
1344 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1345 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1348 if (!st->need_parsing || !st->parser) {
1349 /* no parsing needed: we just output the packet as is */
1351 compute_pkt_fields(s, st, NULL, pkt);
1352 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1353 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1354 ff_reduce_index(s, st->index);
1355 av_add_index_entry(st, pkt->pos, pkt->dts,
1356 0, 0, AVINDEX_KEYFRAME);
1359 } else if (st->discard < AVDISCARD_ALL) {
1360 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1364 av_free_packet(&cur_pkt);
1366 if (pkt->flags & AV_PKT_FLAG_KEY)
1367 st->skip_to_keyframe = 0;
1368 if (st->skip_to_keyframe) {
1369 av_free_packet(&cur_pkt);
1377 if (!got_packet && s->parse_queue)
1378 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1381 AVStream *st = s->streams[pkt->stream_index];
1382 if (st->skip_samples) {
1383 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1385 AV_WL32(p, st->skip_samples);
1386 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1388 st->skip_samples = 0;
1391 if (st->inject_global_side_data) {
1392 for (i = 0; i < st->nb_side_data; i++) {
1393 AVPacketSideData *src_sd = &st->side_data[i];
1396 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1399 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1401 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1405 memcpy(dst_data, src_sd->data, src_sd->size);
1407 st->inject_global_side_data = 0;
1410 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1411 av_packet_merge_side_data(pkt);
1414 if (s->debug & FF_FDEBUG_TS)
1415 av_log(s, AV_LOG_DEBUG,
1416 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1417 "size=%d, duration=%d, flags=%d\n",
1419 av_ts2str(pkt->pts),
1420 av_ts2str(pkt->dts),
1421 pkt->size, pkt->duration, pkt->flags);
1426 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1428 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1434 ret = s->packet_buffer
1435 ? read_from_packet_buffer(&s->packet_buffer,
1436 &s->packet_buffer_end, pkt)
1437 : read_frame_internal(s, pkt);
1444 AVPacketList *pktl = s->packet_buffer;
1447 AVPacket *next_pkt = &pktl->pkt;
1449 if (next_pkt->dts != AV_NOPTS_VALUE) {
1450 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1451 // last dts seen for this stream. if any of packets following
1452 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1453 int64_t last_dts = next_pkt->dts;
1454 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1455 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1456 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1457 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1459 next_pkt->pts = pktl->pkt.dts;
1461 if (last_dts != AV_NOPTS_VALUE) {
1462 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1463 last_dts = pktl->pkt.dts;
1468 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1469 // Fixing the last reference frame had none pts issue (For MXF etc).
1470 // We only do this when
1472 // 2. we are not able to resolve a pts value for current packet.
1473 // 3. the packets for this stream at the end of the files had valid dts.
1474 next_pkt->pts = last_dts + next_pkt->duration;
1476 pktl = s->packet_buffer;
1479 /* read packet from packet buffer, if there is data */
1480 st = s->streams[next_pkt->stream_index];
1481 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1482 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1483 ret = read_from_packet_buffer(&s->packet_buffer,
1484 &s->packet_buffer_end, pkt);
1489 ret = read_frame_internal(s, pkt);
1491 if (pktl && ret != AVERROR(EAGAIN)) {
1498 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1499 &s->packet_buffer_end)) < 0)
1500 return AVERROR(ENOMEM);
1505 st = s->streams[pkt->stream_index];
1506 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1507 ff_reduce_index(s, st->index);
1508 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1511 if (is_relative(pkt->dts))
1512 pkt->dts -= RELATIVE_TS_BASE;
1513 if (is_relative(pkt->pts))
1514 pkt->pts -= RELATIVE_TS_BASE;
1519 /* XXX: suppress the packet queue */
1520 static void flush_packet_queue(AVFormatContext *s)
1522 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1523 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1524 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1526 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1529 /*******************************************************/
1532 int av_find_default_stream_index(AVFormatContext *s)
1536 int best_stream = 0;
1537 int best_score = -1;
1539 if (s->nb_streams <= 0)
1541 for (i = 0; i < s->nb_streams; i++) {
1544 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1545 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1546 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1551 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1552 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1558 if (score > best_score) {
1566 /** Flush the frame reader. */
1567 void ff_read_frame_flush(AVFormatContext *s)
1572 flush_packet_queue(s);
1574 /* Reset read state for each stream. */
1575 for (i = 0; i < s->nb_streams; i++) {
1579 av_parser_close(st->parser);
1582 st->last_IP_pts = AV_NOPTS_VALUE;
1583 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1584 if (st->first_dts == AV_NOPTS_VALUE)
1585 st->cur_dts = RELATIVE_TS_BASE;
1587 /* We set the current DTS to an unspecified origin. */
1588 st->cur_dts = AV_NOPTS_VALUE;
1590 st->probe_packets = MAX_PROBE_PACKETS;
1592 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1593 st->pts_buffer[j] = AV_NOPTS_VALUE;
1595 if (s->internal->inject_global_side_data)
1596 st->inject_global_side_data = 1;
1600 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1604 for (i = 0; i < s->nb_streams; i++) {
1605 AVStream *st = s->streams[i];
1608 av_rescale(timestamp,
1609 st->time_base.den * (int64_t) ref_st->time_base.num,
1610 st->time_base.num * (int64_t) ref_st->time_base.den);
1614 void ff_reduce_index(AVFormatContext *s, int stream_index)
1616 AVStream *st = s->streams[stream_index];
1617 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1619 if ((unsigned) st->nb_index_entries >= max_entries) {
1621 for (i = 0; 2 * i < st->nb_index_entries; i++)
1622 st->index_entries[i] = st->index_entries[2 * i];
1623 st->nb_index_entries = i;
1627 int ff_add_index_entry(AVIndexEntry **index_entries,
1628 int *nb_index_entries,
1629 unsigned int *index_entries_allocated_size,
1630 int64_t pos, int64_t timestamp,
1631 int size, int distance, int flags)
1633 AVIndexEntry *entries, *ie;
1636 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1639 if (timestamp == AV_NOPTS_VALUE)
1640 return AVERROR(EINVAL);
1642 if (size < 0 || size > 0x3FFFFFFF)
1643 return AVERROR(EINVAL);
1645 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1646 timestamp -= RELATIVE_TS_BASE;
1648 entries = av_fast_realloc(*index_entries,
1649 index_entries_allocated_size,
1650 (*nb_index_entries + 1) *
1651 sizeof(AVIndexEntry));
1655 *index_entries = entries;
1657 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1658 timestamp, AVSEEK_FLAG_ANY);
1661 index = (*nb_index_entries)++;
1662 ie = &entries[index];
1663 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1665 ie = &entries[index];
1666 if (ie->timestamp != timestamp) {
1667 if (ie->timestamp <= timestamp)
1669 memmove(entries + index + 1, entries + index,
1670 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1671 (*nb_index_entries)++;
1672 } else if (ie->pos == pos && distance < ie->min_distance)
1673 // do not reduce the distance
1674 distance = ie->min_distance;
1678 ie->timestamp = timestamp;
1679 ie->min_distance = distance;
1686 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1687 int size, int distance, int flags)
1689 timestamp = wrap_timestamp(st, timestamp);
1690 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1691 &st->index_entries_allocated_size, pos,
1692 timestamp, size, distance, flags);
1695 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1696 int64_t wanted_timestamp, int flags)
1704 // Optimize appending index entries at the end.
1705 if (b && entries[b - 1].timestamp < wanted_timestamp)
1710 timestamp = entries[m].timestamp;
1711 if (timestamp >= wanted_timestamp)
1713 if (timestamp <= wanted_timestamp)
1716 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1718 if (!(flags & AVSEEK_FLAG_ANY))
1719 while (m >= 0 && m < nb_entries &&
1720 !(entries[m].flags & AVINDEX_KEYFRAME))
1721 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1723 if (m == nb_entries)
1728 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1730 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1731 wanted_timestamp, flags);
1734 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1735 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1737 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1738 if (stream_index >= 0)
1739 ts = wrap_timestamp(s->streams[stream_index], ts);
1743 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1744 int64_t target_ts, int flags)
1746 AVInputFormat *avif = s->iformat;
1747 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1748 int64_t ts_min, ts_max, ts;
1753 if (stream_index < 0)
1756 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1759 ts_min = AV_NOPTS_VALUE;
1760 pos_limit = -1; // GCC falsely says it may be uninitialized.
1762 st = s->streams[stream_index];
1763 if (st->index_entries) {
1766 /* FIXME: Whole function must be checked for non-keyframe entries in
1767 * index case, especially read_timestamp(). */
1768 index = av_index_search_timestamp(st, target_ts,
1769 flags | AVSEEK_FLAG_BACKWARD);
1770 index = FFMAX(index, 0);
1771 e = &st->index_entries[index];
1773 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1775 ts_min = e->timestamp;
1776 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1777 pos_min, av_ts2str(ts_min));
1779 av_assert1(index == 0);
1782 index = av_index_search_timestamp(st, target_ts,
1783 flags & ~AVSEEK_FLAG_BACKWARD);
1784 av_assert0(index < st->nb_index_entries);
1786 e = &st->index_entries[index];
1787 av_assert1(e->timestamp >= target_ts);
1789 ts_max = e->timestamp;
1790 pos_limit = pos_max - e->min_distance;
1791 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1792 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1796 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1797 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1802 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1805 ff_read_frame_flush(s);
1806 ff_update_cur_dts(s, st, ts);
1811 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1812 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1814 int64_t step = 1024;
1815 int64_t limit, ts_max;
1816 int64_t filesize = avio_size(s->pb);
1817 int64_t pos_max = filesize - 1;
1820 pos_max = FFMAX(0, (pos_max) - step);
1821 ts_max = ff_read_timestamp(s, stream_index,
1822 &pos_max, limit, read_timestamp);
1824 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1825 if (ts_max == AV_NOPTS_VALUE)
1829 int64_t tmp_pos = pos_max + 1;
1830 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1831 &tmp_pos, INT64_MAX, read_timestamp);
1832 if (tmp_ts == AV_NOPTS_VALUE)
1834 av_assert0(tmp_pos > pos_max);
1837 if (tmp_pos >= filesize)
1849 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1850 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1851 int64_t ts_min, int64_t ts_max,
1852 int flags, int64_t *ts_ret,
1853 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1854 int64_t *, int64_t))
1861 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1863 if (ts_min == AV_NOPTS_VALUE) {
1864 pos_min = s->data_offset;
1865 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1866 if (ts_min == AV_NOPTS_VALUE)
1870 if (ts_min >= target_ts) {
1875 if (ts_max == AV_NOPTS_VALUE) {
1876 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1878 pos_limit = pos_max;
1881 if (ts_max <= target_ts) {
1886 if (ts_min > ts_max)
1888 else if (ts_min == ts_max)
1889 pos_limit = pos_min;
1892 while (pos_min < pos_limit) {
1894 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1895 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1896 assert(pos_limit <= pos_max);
1898 if (no_change == 0) {
1899 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1900 // interpolate position (better than dichotomy)
1901 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1903 pos_min - approximate_keyframe_distance;
1904 } else if (no_change == 1) {
1905 // bisection if interpolation did not change min / max pos last time
1906 pos = (pos_min + pos_limit) >> 1;
1908 /* linear search if bisection failed, can only happen if there
1909 * are very few or no keyframes between min/max */
1914 else if (pos > pos_limit)
1918 // May pass pos_limit instead of -1.
1919 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1924 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1925 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1926 pos_min, pos, pos_max,
1927 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1928 pos_limit, start_pos, no_change);
1929 if (ts == AV_NOPTS_VALUE) {
1930 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1933 assert(ts != AV_NOPTS_VALUE);
1934 if (target_ts <= ts) {
1935 pos_limit = start_pos - 1;
1939 if (target_ts >= ts) {
1945 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1946 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1949 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1951 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1952 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1953 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1959 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1960 int64_t pos, int flags)
1962 int64_t pos_min, pos_max;
1964 pos_min = s->data_offset;
1965 pos_max = avio_size(s->pb) - 1;
1969 else if (pos > pos_max)
1972 avio_seek(s->pb, pos, SEEK_SET);
1974 s->io_repositioned = 1;
1979 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1980 int64_t timestamp, int flags)
1987 st = s->streams[stream_index];
1989 index = av_index_search_timestamp(st, timestamp, flags);
1991 if (index < 0 && st->nb_index_entries &&
1992 timestamp < st->index_entries[0].timestamp)
1995 if (index < 0 || index == st->nb_index_entries - 1) {
1999 if (st->nb_index_entries) {
2000 av_assert0(st->index_entries);
2001 ie = &st->index_entries[st->nb_index_entries - 1];
2002 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2004 ff_update_cur_dts(s, st, ie->timestamp);
2006 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2012 read_status = av_read_frame(s, &pkt);
2013 } while (read_status == AVERROR(EAGAIN));
2014 if (read_status < 0)
2016 av_free_packet(&pkt);
2017 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2018 if (pkt.flags & AV_PKT_FLAG_KEY)
2020 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2021 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);
2026 index = av_index_search_timestamp(st, timestamp, flags);
2031 ff_read_frame_flush(s);
2032 if (s->iformat->read_seek)
2033 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2035 ie = &st->index_entries[index];
2036 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2038 ff_update_cur_dts(s, st, ie->timestamp);
2043 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2044 int64_t timestamp, int flags)
2049 if (flags & AVSEEK_FLAG_BYTE) {
2050 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2052 ff_read_frame_flush(s);
2053 return seek_frame_byte(s, stream_index, timestamp, flags);
2056 if (stream_index < 0) {
2057 stream_index = av_find_default_stream_index(s);
2058 if (stream_index < 0)
2061 st = s->streams[stream_index];
2062 /* timestamp for default must be expressed in AV_TIME_BASE units */
2063 timestamp = av_rescale(timestamp, st->time_base.den,
2064 AV_TIME_BASE * (int64_t) st->time_base.num);
2067 /* first, we try the format specific seek */
2068 if (s->iformat->read_seek) {
2069 ff_read_frame_flush(s);
2070 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2076 if (s->iformat->read_timestamp &&
2077 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2078 ff_read_frame_flush(s);
2079 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2080 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2081 ff_read_frame_flush(s);
2082 return seek_frame_generic(s, stream_index, timestamp, flags);
2087 int av_seek_frame(AVFormatContext *s, int stream_index,
2088 int64_t timestamp, int flags)
2092 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2093 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2094 if ((flags & AVSEEK_FLAG_BACKWARD))
2098 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2099 flags & ~AVSEEK_FLAG_BACKWARD);
2102 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2105 ret = avformat_queue_attached_pictures(s);
2110 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2111 int64_t ts, int64_t max_ts, int flags)
2113 if (min_ts > ts || max_ts < ts)
2115 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2116 return AVERROR(EINVAL);
2119 flags |= AVSEEK_FLAG_ANY;
2120 flags &= ~AVSEEK_FLAG_BACKWARD;
2122 if (s->iformat->read_seek2) {
2124 ff_read_frame_flush(s);
2126 if (stream_index == -1 && s->nb_streams == 1) {
2127 AVRational time_base = s->streams[0]->time_base;
2128 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2129 min_ts = av_rescale_rnd(min_ts, time_base.den,
2130 time_base.num * (int64_t)AV_TIME_BASE,
2131 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2132 max_ts = av_rescale_rnd(max_ts, time_base.den,
2133 time_base.num * (int64_t)AV_TIME_BASE,
2134 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2137 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2141 ret = avformat_queue_attached_pictures(s);
2145 if (s->iformat->read_timestamp) {
2146 // try to seek via read_timestamp()
2149 // Fall back on old API if new is not implemented but old is.
2150 // Note the old API has somewhat different semantics.
2151 if (s->iformat->read_seek || 1) {
2152 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2153 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2154 if (ret<0 && ts != min_ts && max_ts != ts) {
2155 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2157 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2162 // try some generic seek like seek_frame_generic() but with new ts semantics
2163 return -1; //unreachable
2166 /*******************************************************/
2169 * Return TRUE if the stream has accurate duration in any stream.
2171 * @return TRUE if the stream has accurate duration for at least one component.
2173 static int has_duration(AVFormatContext *ic)
2178 for (i = 0; i < ic->nb_streams; i++) {
2179 st = ic->streams[i];
2180 if (st->duration != AV_NOPTS_VALUE)
2183 if (ic->duration != AV_NOPTS_VALUE)
2189 * Estimate the stream timings from the one of each components.
2191 * Also computes the global bitrate if possible.
2193 static void update_stream_timings(AVFormatContext *ic)
2195 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2196 int64_t duration, duration1, filesize;
2201 start_time = INT64_MAX;
2202 start_time_text = INT64_MAX;
2203 end_time = INT64_MIN;
2204 duration = INT64_MIN;
2205 for (i = 0; i < ic->nb_streams; i++) {
2206 st = ic->streams[i];
2207 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2208 start_time1 = av_rescale_q(st->start_time, st->time_base,
2210 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2211 if (start_time1 < start_time_text)
2212 start_time_text = start_time1;
2214 start_time = FFMIN(start_time, start_time1);
2215 end_time1 = AV_NOPTS_VALUE;
2216 if (st->duration != AV_NOPTS_VALUE) {
2217 end_time1 = start_time1 +
2218 av_rescale_q(st->duration, st->time_base,
2220 end_time = FFMAX(end_time, end_time1);
2222 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2223 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2224 p->start_time = start_time1;
2225 if (p->end_time < end_time1)
2226 p->end_time = end_time1;
2229 if (st->duration != AV_NOPTS_VALUE) {
2230 duration1 = av_rescale_q(st->duration, st->time_base,
2232 duration = FFMAX(duration, duration1);
2235 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2236 start_time = start_time_text;
2237 else if (start_time > start_time_text)
2238 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2240 if (start_time != INT64_MAX) {
2241 ic->start_time = start_time;
2242 if (end_time != INT64_MIN) {
2243 if (ic->nb_programs) {
2244 for (i = 0; i < ic->nb_programs; i++) {
2245 p = ic->programs[i];
2246 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2247 duration = FFMAX(duration, p->end_time - p->start_time);
2250 duration = FFMAX(duration, end_time - start_time);
2253 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2254 ic->duration = duration;
2256 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2257 /* compute the bitrate */
2258 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2259 (double) ic->duration;
2260 if (bitrate >= 0 && bitrate <= INT_MAX)
2261 ic->bit_rate = bitrate;
2265 static void fill_all_stream_timings(AVFormatContext *ic)
2270 update_stream_timings(ic);
2271 for (i = 0; i < ic->nb_streams; i++) {
2272 st = ic->streams[i];
2273 if (st->start_time == AV_NOPTS_VALUE) {
2274 if (ic->start_time != AV_NOPTS_VALUE)
2275 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2277 if (ic->duration != AV_NOPTS_VALUE)
2278 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2284 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2286 int64_t filesize, duration;
2287 int i, show_warning = 0;
2290 /* if bit_rate is already set, we believe it */
2291 if (ic->bit_rate <= 0) {
2293 for (i = 0; i < ic->nb_streams; i++) {
2294 st = ic->streams[i];
2295 if (st->codec->bit_rate > 0) {
2296 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2300 bit_rate += st->codec->bit_rate;
2303 ic->bit_rate = bit_rate;
2306 /* if duration is already set, we believe it */
2307 if (ic->duration == AV_NOPTS_VALUE &&
2308 ic->bit_rate != 0) {
2309 filesize = ic->pb ? avio_size(ic->pb) : 0;
2311 for (i = 0; i < ic->nb_streams; i++) {
2312 st = ic->streams[i];
2313 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2314 && st->duration == AV_NOPTS_VALUE) {
2315 duration = av_rescale(8 * filesize, st->time_base.den,
2317 (int64_t) st->time_base.num);
2318 st->duration = duration;
2325 av_log(ic, AV_LOG_WARNING,
2326 "Estimating duration from bitrate, this may be inaccurate\n");
2329 #define DURATION_MAX_READ_SIZE 250000LL
2330 #define DURATION_MAX_RETRY 4
2332 /* only usable for MPEG-PS streams */
2333 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2335 AVPacket pkt1, *pkt = &pkt1;
2337 int num, den, read_size, i, ret;
2338 int found_duration = 0;
2340 int64_t filesize, offset, duration;
2343 /* flush packet queue */
2344 flush_packet_queue(ic);
2346 for (i = 0; i < ic->nb_streams; i++) {
2347 st = ic->streams[i];
2348 if (st->start_time == AV_NOPTS_VALUE &&
2349 st->first_dts == AV_NOPTS_VALUE &&
2350 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2351 av_log(st->codec, AV_LOG_WARNING,
2352 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2355 av_parser_close(st->parser);
2360 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2361 /* estimate the end time (duration) */
2362 /* XXX: may need to support wrapping */
2363 filesize = ic->pb ? avio_size(ic->pb) : 0;
2365 is_end = found_duration;
2366 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2370 avio_seek(ic->pb, offset, SEEK_SET);
2373 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2377 ret = ff_read_packet(ic, pkt);
2378 } while (ret == AVERROR(EAGAIN));
2381 read_size += pkt->size;
2382 st = ic->streams[pkt->stream_index];
2383 if (pkt->pts != AV_NOPTS_VALUE &&
2384 (st->start_time != AV_NOPTS_VALUE ||
2385 st->first_dts != AV_NOPTS_VALUE)) {
2386 if (pkt->duration == 0) {
2387 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2389 pkt->duration = av_rescale_rnd(1,
2390 num * (int64_t) st->time_base.den,
2391 den * (int64_t) st->time_base.num,
2395 duration = pkt->pts + pkt->duration;
2397 if (st->start_time != AV_NOPTS_VALUE)
2398 duration -= st->start_time;
2400 duration -= st->first_dts;
2402 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2403 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2404 st->duration = duration;
2405 st->info->last_duration = duration;
2408 av_free_packet(pkt);
2411 /* check if all audio/video streams have valid duration */
2414 for (i = 0; i < ic->nb_streams; i++) {
2415 st = ic->streams[i];
2416 switch (st->codec->codec_type) {
2417 case AVMEDIA_TYPE_VIDEO:
2418 case AVMEDIA_TYPE_AUDIO:
2419 if (st->duration == AV_NOPTS_VALUE)
2426 ++retry <= DURATION_MAX_RETRY);
2428 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2430 /* warn about audio/video streams which duration could not be estimated */
2431 for (i = 0; i < ic->nb_streams; i++) {
2432 st = ic->streams[i];
2433 if (st->duration == AV_NOPTS_VALUE) {
2434 switch (st->codec->codec_type) {
2435 case AVMEDIA_TYPE_VIDEO:
2436 case AVMEDIA_TYPE_AUDIO:
2437 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2438 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2440 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2444 fill_all_stream_timings(ic);
2446 avio_seek(ic->pb, old_offset, SEEK_SET);
2447 for (i = 0; i < ic->nb_streams; i++) {
2450 st = ic->streams[i];
2451 st->cur_dts = st->first_dts;
2452 st->last_IP_pts = AV_NOPTS_VALUE;
2453 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2454 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2455 st->pts_buffer[j] = AV_NOPTS_VALUE;
2459 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2463 /* get the file size, if possible */
2464 if (ic->iformat->flags & AVFMT_NOFILE) {
2467 file_size = avio_size(ic->pb);
2468 file_size = FFMAX(0, file_size);
2471 if ((!strcmp(ic->iformat->name, "mpeg") ||
2472 !strcmp(ic->iformat->name, "mpegts")) &&
2473 file_size && ic->pb->seekable) {
2474 /* get accurate estimate from the PTSes */
2475 estimate_timings_from_pts(ic, old_offset);
2476 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2477 } else if (has_duration(ic)) {
2478 /* at least one component has timings - we use them for all
2480 fill_all_stream_timings(ic);
2481 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2483 /* less precise: use bitrate info */
2484 estimate_timings_from_bit_rate(ic);
2485 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2487 update_stream_timings(ic);
2491 AVStream av_unused *st;
2492 for (i = 0; i < ic->nb_streams; i++) {
2493 st = ic->streams[i];
2494 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2495 (double) st->start_time / AV_TIME_BASE,
2496 (double) st->duration / AV_TIME_BASE);
2499 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2500 (double) ic->start_time / AV_TIME_BASE,
2501 (double) ic->duration / AV_TIME_BASE,
2502 ic->bit_rate / 1000);
2506 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2508 AVCodecContext *avctx = st->codec;
2510 #define FAIL(errmsg) do { \
2512 *errmsg_ptr = errmsg; \
2516 if ( avctx->codec_id == AV_CODEC_ID_NONE
2517 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2518 FAIL("unknown codec");
2519 switch (avctx->codec_type) {
2520 case AVMEDIA_TYPE_AUDIO:
2521 if (!avctx->frame_size && determinable_frame_size(avctx))
2522 FAIL("unspecified frame size");
2523 if (st->info->found_decoder >= 0 &&
2524 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2525 FAIL("unspecified sample format");
2526 if (!avctx->sample_rate)
2527 FAIL("unspecified sample rate");
2528 if (!avctx->channels)
2529 FAIL("unspecified number of channels");
2530 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2531 FAIL("no decodable DTS frames");
2533 case AVMEDIA_TYPE_VIDEO:
2535 FAIL("unspecified size");
2536 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2537 FAIL("unspecified pixel format");
2538 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2539 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2540 FAIL("no frame in rv30/40 and no sar");
2542 case AVMEDIA_TYPE_SUBTITLE:
2543 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2544 FAIL("unspecified size");
2546 case AVMEDIA_TYPE_DATA:
2547 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2553 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2554 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2555 AVDictionary **options)
2557 const AVCodec *codec;
2558 int got_picture = 1, ret = 0;
2559 AVFrame *frame = av_frame_alloc();
2560 AVSubtitle subtitle;
2561 AVPacket pkt = *avpkt;
2564 return AVERROR(ENOMEM);
2566 if (!avcodec_is_open(st->codec) &&
2567 st->info->found_decoder <= 0 &&
2568 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2569 AVDictionary *thread_opt = NULL;
2571 codec = find_decoder(s, st, st->codec->codec_id);
2574 st->info->found_decoder = -st->codec->codec_id;
2579 /* Force thread count to 1 since the H.264 decoder will not extract
2580 * SPS and PPS to extradata during multi-threaded decoding. */
2581 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2582 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2584 av_dict_free(&thread_opt);
2586 st->info->found_decoder = -st->codec->codec_id;
2589 st->info->found_decoder = 1;
2590 } else if (!st->info->found_decoder)
2591 st->info->found_decoder = 1;
2593 if (st->info->found_decoder < 0) {
2598 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2600 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2601 (!st->codec_info_nb_frames &&
2602 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2604 switch (st->codec->codec_type) {
2605 case AVMEDIA_TYPE_VIDEO:
2606 ret = avcodec_decode_video2(st->codec, frame,
2607 &got_picture, &pkt);
2609 case AVMEDIA_TYPE_AUDIO:
2610 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2612 case AVMEDIA_TYPE_SUBTITLE:
2613 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2614 &got_picture, &pkt);
2622 st->nb_decoded_frames++;
2629 if (!pkt.data && !got_picture)
2633 av_frame_free(&frame);
2637 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2639 while (tags->id != AV_CODEC_ID_NONE) {
2647 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2650 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2651 if (tag == tags[i].tag)
2653 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2654 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2656 return AV_CODEC_ID_NONE;
2659 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2664 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2666 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2668 return AV_CODEC_ID_NONE;
2673 if (sflags & (1 << (bps - 1))) {
2676 return AV_CODEC_ID_PCM_S8;
2678 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2680 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2682 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2684 return AV_CODEC_ID_NONE;
2689 return AV_CODEC_ID_PCM_U8;
2691 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2693 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2695 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2697 return AV_CODEC_ID_NONE;
2703 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2706 if (!av_codec_get_tag2(tags, id, &tag))
2711 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2715 for (i = 0; tags && tags[i]; i++) {
2716 const AVCodecTag *codec_tags = tags[i];
2717 while (codec_tags->id != AV_CODEC_ID_NONE) {
2718 if (codec_tags->id == id) {
2719 *tag = codec_tags->tag;
2728 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2731 for (i = 0; tags && tags[i]; i++) {
2732 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2733 if (id != AV_CODEC_ID_NONE)
2736 return AV_CODEC_ID_NONE;
2739 static void compute_chapters_end(AVFormatContext *s)
2742 int64_t max_time = s->duration +
2743 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2745 for (i = 0; i < s->nb_chapters; i++)
2746 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2747 AVChapter *ch = s->chapters[i];
2748 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2752 for (j = 0; j < s->nb_chapters; j++) {
2753 AVChapter *ch1 = s->chapters[j];
2754 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2756 if (j != i && next_start > ch->start && next_start < end)
2759 ch->end = (end == INT64_MAX) ? ch->start : end;
2763 static int get_std_framerate(int i)
2766 return (i + 1) * 1001;
2768 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2771 /* Is the time base unreliable?
2772 * This is a heuristic to balance between quick acceptance of the values in
2773 * the headers vs. some extra checks.
2774 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2775 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2776 * And there are "variable" fps files this needs to detect as well. */
2777 static int tb_unreliable(AVCodecContext *c)
2779 if (c->time_base.den >= 101L * c->time_base.num ||
2780 c->time_base.den < 5L * c->time_base.num ||
2781 // c->codec_tag == AV_RL32("DIVX") ||
2782 // c->codec_tag == AV_RL32("XVID") ||
2783 c->codec_tag == AV_RL32("mp4v") ||
2784 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2785 c->codec_id == AV_CODEC_ID_GIF ||
2786 c->codec_id == AV_CODEC_ID_H264)
2791 #if FF_API_FORMAT_PARAMETERS
2792 int av_find_stream_info(AVFormatContext *ic)
2794 return avformat_find_stream_info(ic, NULL);
2798 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2802 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2803 avctx->extradata_size = 0;
2804 return AVERROR(EINVAL);
2806 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2807 if (avctx->extradata) {
2808 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2809 avctx->extradata_size = size;
2812 avctx->extradata_size = 0;
2813 ret = AVERROR(ENOMEM);
2818 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2820 int ret = ff_alloc_extradata(avctx, size);
2823 ret = avio_read(pb, avctx->extradata, size);
2825 av_freep(&avctx->extradata);
2826 avctx->extradata_size = 0;
2827 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2828 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2834 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2837 int64_t last = st->info->last_dts;
2839 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2840 && ts - (uint64_t)last < INT64_MAX) {
2841 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2842 int64_t duration = ts - last;
2844 if (!st->info->duration_error)
2845 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2846 if (!st->info->duration_error)
2847 return AVERROR(ENOMEM);
2849 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2850 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2851 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2852 if (st->info->duration_error[0][1][i] < 1e10) {
2853 int framerate = get_std_framerate(i);
2854 double sdts = dts*framerate/(1001*12);
2855 for (j= 0; j<2; j++) {
2856 int64_t ticks = llrint(sdts+j*0.5);
2857 double error= sdts - ticks + j*0.5;
2858 st->info->duration_error[j][0][i] += error;
2859 st->info->duration_error[j][1][i] += error*error;
2863 st->info->duration_count++;
2864 st->info->rfps_duration_sum += duration;
2866 if (st->info->duration_count % 10 == 0) {
2867 int n = st->info->duration_count;
2868 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2869 if (st->info->duration_error[0][1][i] < 1e10) {
2870 double a0 = st->info->duration_error[0][0][i] / n;
2871 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2872 double a1 = st->info->duration_error[1][0][i] / n;
2873 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2874 if (error0 > 0.04 && error1 > 0.04) {
2875 st->info->duration_error[0][1][i] = 2e10;
2876 st->info->duration_error[1][1][i] = 2e10;
2882 // ignore the first 4 values, they might have some random jitter
2883 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2884 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2886 if (ts != AV_NOPTS_VALUE)
2887 st->info->last_dts = ts;
2892 void ff_rfps_calculate(AVFormatContext *ic)
2896 for (i = 0; i < ic->nb_streams; i++) {
2897 AVStream *st = ic->streams[i];
2899 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2901 // the check for tb_unreliable() is not completely correct, since this is not about handling
2902 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2903 // ipmovie.c produces.
2904 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)
2905 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);
2906 if (st->info->duration_count>1 && !st->r_frame_rate.num
2907 && tb_unreliable(st->codec)) {
2909 double best_error= 0.01;
2910 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2912 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2915 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2917 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2920 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2923 for (k= 0; k<2; k++) {
2924 int n = st->info->duration_count;
2925 double a= st->info->duration_error[k][0][j] / n;
2926 double error= st->info->duration_error[k][1][j]/n - a*a;
2928 if (error < best_error && best_error> 0.000000001) {
2930 num = get_std_framerate(j);
2933 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2936 // do not increase frame rate by more than 1 % in order to match a standard rate.
2937 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2938 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2940 if ( !st->avg_frame_rate.num
2941 && st->r_frame_rate.num && st->info->rfps_duration_sum
2942 && st->info->codec_info_duration <= 0
2943 && st->info->duration_count > 2
2944 && 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
2946 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2947 st->avg_frame_rate = st->r_frame_rate;
2950 av_freep(&st->info->duration_error);
2951 st->info->last_dts = AV_NOPTS_VALUE;
2952 st->info->duration_count = 0;
2953 st->info->rfps_duration_sum = 0;
2957 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2959 int i, count, ret = 0, j;
2962 AVPacket pkt1, *pkt;
2963 int64_t old_offset = avio_tell(ic->pb);
2964 // new streams might appear, no options for those
2965 int orig_nb_streams = ic->nb_streams;
2967 int64_t max_analyze_duration = ic->max_analyze_duration2;
2968 int64_t probesize = ic->probesize2;
2970 if (!max_analyze_duration)
2971 max_analyze_duration = ic->max_analyze_duration;
2973 probesize = ic->probesize;
2974 flush_codecs = probesize > 0;
2976 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2978 if (!max_analyze_duration) {
2979 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2980 max_analyze_duration = 10*AV_TIME_BASE;
2982 max_analyze_duration = 5*AV_TIME_BASE;
2986 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2987 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2989 for (i = 0; i < ic->nb_streams; i++) {
2990 const AVCodec *codec;
2991 AVDictionary *thread_opt = NULL;
2992 st = ic->streams[i];
2994 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2995 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2996 /* if (!st->time_base.num)
2998 if (!st->codec->time_base.num)
2999 st->codec->time_base = st->time_base;
3001 // only for the split stuff
3002 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3003 st->parser = av_parser_init(st->codec->codec_id);
3005 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3006 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3007 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3008 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3010 } else if (st->need_parsing) {
3011 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3012 "%s, packets or times may be invalid.\n",
3013 avcodec_get_name(st->codec->codec_id));
3016 codec = find_decoder(ic, st, st->codec->codec_id);
3018 /* Force thread count to 1 since the H.264 decoder will not extract
3019 * SPS and PPS to extradata during multi-threaded decoding. */
3020 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3022 /* Ensure that subtitle_header is properly set. */
3023 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3024 && codec && !st->codec->codec) {
3025 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3026 av_log(ic, AV_LOG_WARNING,
3027 "Failed to open codec in av_find_stream_info\n");
3030 // Try to just open decoders, in case this is enough to get parameters.
3031 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3032 if (codec && !st->codec->codec)
3033 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3034 av_log(ic, AV_LOG_WARNING,
3035 "Failed to open codec in av_find_stream_info\n");
3038 av_dict_free(&thread_opt);
3041 for (i = 0; i < ic->nb_streams; i++) {
3042 #if FF_API_R_FRAME_RATE
3043 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3045 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3046 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3052 if (ff_check_interrupt(&ic->interrupt_callback)) {
3054 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3058 /* check if one codec still needs to be handled */
3059 for (i = 0; i < ic->nb_streams; i++) {
3060 int fps_analyze_framecount = 20;
3062 st = ic->streams[i];
3063 if (!has_codec_parameters(st, NULL))
3065 /* If the timebase is coarse (like the usual millisecond precision
3066 * of mkv), we need to analyze more frames to reliably arrive at
3067 * the correct fps. */
3068 if (av_q2d(st->time_base) > 0.0005)
3069 fps_analyze_framecount *= 2;
3070 if (!tb_unreliable(st->codec))
3071 fps_analyze_framecount = 0;
3072 if (ic->fps_probe_size >= 0)
3073 fps_analyze_framecount = ic->fps_probe_size;
3074 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3075 fps_analyze_framecount = 0;
3076 /* variable fps and no guess at the real fps */
3077 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3078 st->info->duration_count < fps_analyze_framecount &&
3079 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3081 if (st->parser && st->parser->parser->split &&
3082 !st->codec->extradata)
3084 if (st->first_dts == AV_NOPTS_VALUE &&
3085 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3086 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3087 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3090 if (i == ic->nb_streams) {
3091 /* NOTE: If the format has no header, then we need to read some
3092 * packets to get most of the streams, so we cannot stop here. */
3093 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3094 /* If we found the info for all the codecs, we can stop. */
3096 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3101 /* We did not get all the codec info, but we read too much data. */
3102 if (read_size >= probesize) {
3104 av_log(ic, AV_LOG_DEBUG,
3105 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3106 for (i = 0; i < ic->nb_streams; i++)
3107 if (!ic->streams[i]->r_frame_rate.num &&
3108 ic->streams[i]->info->duration_count <= 1 &&
3109 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3110 strcmp(ic->iformat->name, "image2"))
3111 av_log(ic, AV_LOG_WARNING,
3112 "Stream #%d: not enough frames to estimate rate; "
3113 "consider increasing probesize\n", i);
3117 /* NOTE: A new stream can be added there if no header in file
3118 * (AVFMTCTX_NOHEADER). */
3119 ret = read_frame_internal(ic, &pkt1);
3120 if (ret == AVERROR(EAGAIN))
3128 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3129 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3131 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3132 &ic->packet_buffer_end);
3134 ret = AVERROR(ENOMEM);
3135 goto find_stream_info_err;
3137 if ((ret = av_dup_packet(pkt)) < 0)
3138 goto find_stream_info_err;
3141 st = ic->streams[pkt->stream_index];
3142 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3143 read_size += pkt->size;
3145 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3146 /* check for non-increasing dts */
3147 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3148 st->info->fps_last_dts >= pkt->dts) {
3149 av_log(ic, AV_LOG_DEBUG,
3150 "Non-increasing DTS in stream %d: packet %d with DTS "
3151 "%"PRId64", packet %d with DTS %"PRId64"\n",
3152 st->index, st->info->fps_last_dts_idx,
3153 st->info->fps_last_dts, st->codec_info_nb_frames,
3155 st->info->fps_first_dts =
3156 st->info->fps_last_dts = AV_NOPTS_VALUE;
3158 /* Check for a discontinuity in dts. If the difference in dts
3159 * is more than 1000 times the average packet duration in the
3160 * sequence, we treat it as a discontinuity. */
3161 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3162 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3163 (pkt->dts - st->info->fps_last_dts) / 1000 >
3164 (st->info->fps_last_dts - st->info->fps_first_dts) /
3165 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3166 av_log(ic, AV_LOG_WARNING,
3167 "DTS discontinuity in stream %d: packet %d with DTS "
3168 "%"PRId64", packet %d with DTS %"PRId64"\n",
3169 st->index, st->info->fps_last_dts_idx,
3170 st->info->fps_last_dts, st->codec_info_nb_frames,
3172 st->info->fps_first_dts =
3173 st->info->fps_last_dts = AV_NOPTS_VALUE;
3176 /* update stored dts values */
3177 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3178 st->info->fps_first_dts = pkt->dts;
3179 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3181 st->info->fps_last_dts = pkt->dts;
3182 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3184 if (st->codec_info_nb_frames>1) {
3187 if (st->time_base.den > 0)
3188 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3189 if (st->avg_frame_rate.num > 0)
3190 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3193 && st->codec_info_nb_frames>30
3194 && st->info->fps_first_dts != AV_NOPTS_VALUE
3195 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3196 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3198 if (t >= max_analyze_duration) {
3199 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3200 max_analyze_duration,
3204 if (pkt->duration) {
3205 st->info->codec_info_duration += pkt->duration;
3206 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3209 #if FF_API_R_FRAME_RATE
3210 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3211 ff_rfps_add_frame(ic, st, pkt->dts);
3213 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3214 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3215 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3216 if (ff_alloc_extradata(st->codec, i))
3217 return AVERROR(ENOMEM);
3218 memcpy(st->codec->extradata, pkt->data,
3219 st->codec->extradata_size);
3223 /* If still no information, we try to open the codec and to
3224 * decompress the frame. We try to avoid that in most cases as
3225 * it takes longer and uses more memory. For MPEG-4, we need to
3226 * decompress for QuickTime.
3228 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3229 * least one frame of codec data, this makes sure the codec initializes
3230 * the channel configuration and does not only trust the values from
3232 try_decode_frame(ic, st, pkt,
3233 (options && i < orig_nb_streams) ? &options[i] : NULL);
3235 st->codec_info_nb_frames++;
3240 AVPacket empty_pkt = { 0 };
3242 av_init_packet(&empty_pkt);
3244 for (i = 0; i < ic->nb_streams; i++) {
3246 st = ic->streams[i];
3248 /* flush the decoders */
3249 if (st->info->found_decoder == 1) {
3251 err = try_decode_frame(ic, st, &empty_pkt,
3252 (options && i < orig_nb_streams)
3253 ? &options[i] : NULL);
3254 } while (err > 0 && !has_codec_parameters(st, NULL));
3257 av_log(ic, AV_LOG_INFO,
3258 "decoding for stream %d failed\n", st->index);
3263 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3265 // close codecs which were opened in try_decode_frame()
3266 for (i = 0; i < ic->nb_streams; i++) {
3267 st = ic->streams[i];
3268 avcodec_close(st->codec);
3271 ff_rfps_calculate(ic);
3273 for (i = 0; i < ic->nb_streams; i++) {
3274 st = ic->streams[i];
3275 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3276 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3277 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3278 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3279 st->codec->codec_tag= tag;
3282 /* estimate average framerate if not set by demuxer */
3283 if (st->info->codec_info_duration_fields &&
3284 !st->avg_frame_rate.num &&
3285 st->info->codec_info_duration) {
3287 double best_error = 0.01;
3289 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3290 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3291 st->info->codec_info_duration < 0)
3293 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3294 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3295 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3297 /* Round guessed framerate to a "standard" framerate if it's
3298 * within 1% of the original estimate. */
3299 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3300 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3301 double error = fabs(av_q2d(st->avg_frame_rate) /
3302 av_q2d(std_fps) - 1);
3304 if (error < best_error) {
3306 best_fps = std_fps.num;
3310 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3311 best_fps, 12 * 1001, INT_MAX);
3314 if (!st->r_frame_rate.num) {
3315 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3316 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3317 st->r_frame_rate.num = st->codec->time_base.den;
3318 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3320 st->r_frame_rate.num = st->time_base.den;
3321 st->r_frame_rate.den = st->time_base.num;
3324 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3325 if (!st->codec->bits_per_coded_sample)
3326 st->codec->bits_per_coded_sample =
3327 av_get_bits_per_sample(st->codec->codec_id);
3328 // set stream disposition based on audio service type
3329 switch (st->codec->audio_service_type) {
3330 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3331 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3333 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3334 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3336 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3337 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3339 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3340 st->disposition = AV_DISPOSITION_COMMENT;
3342 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3343 st->disposition = AV_DISPOSITION_KARAOKE;
3350 estimate_timings(ic, old_offset);
3352 if (ret >= 0 && ic->nb_streams)
3353 /* We could not have all the codec parameters before EOF. */
3355 for (i = 0; i < ic->nb_streams; i++) {
3357 st = ic->streams[i];
3358 if (!has_codec_parameters(st, &errmsg)) {
3360 avcodec_string(buf, sizeof(buf), st->codec, 0);
3361 av_log(ic, AV_LOG_WARNING,
3362 "Could not find codec parameters for stream %d (%s): %s\n"
3363 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3370 compute_chapters_end(ic);
3372 find_stream_info_err:
3373 for (i = 0; i < ic->nb_streams; i++) {
3374 st = ic->streams[i];
3375 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3376 ic->streams[i]->codec->thread_count = 0;
3378 av_freep(&st->info->duration_error);
3379 av_freep(&ic->streams[i]->info);
3382 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3383 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3387 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3391 for (i = 0; i < ic->nb_programs; i++) {
3392 if (ic->programs[i] == last) {
3396 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3397 if (ic->programs[i]->stream_index[j] == s)
3398 return ic->programs[i];
3404 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3405 int wanted_stream_nb, int related_stream,
3406 AVCodec **decoder_ret, int flags)
3408 int i, nb_streams = ic->nb_streams;
3409 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3410 unsigned *program = NULL;
3411 const AVCodec *decoder = NULL, *best_decoder = NULL;
3413 if (related_stream >= 0 && wanted_stream_nb < 0) {
3414 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3416 program = p->stream_index;
3417 nb_streams = p->nb_stream_indexes;
3420 for (i = 0; i < nb_streams; i++) {
3421 int real_stream_index = program ? program[i] : i;
3422 AVStream *st = ic->streams[real_stream_index];
3423 AVCodecContext *avctx = st->codec;
3424 if (avctx->codec_type != type)
3426 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3428 if (wanted_stream_nb != real_stream_index &&
3429 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3430 AV_DISPOSITION_VISUAL_IMPAIRED))
3432 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3435 decoder = find_decoder(ic, st, st->codec->codec_id);
3438 ret = AVERROR_DECODER_NOT_FOUND;
3442 count = st->codec_info_nb_frames;
3443 bitrate = avctx->bit_rate;
3445 bitrate = avctx->rc_max_rate;
3446 multiframe = FFMIN(5, count);
3447 if ((best_multiframe > multiframe) ||
3448 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3449 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3452 best_bitrate = bitrate;
3453 best_multiframe = multiframe;
3454 ret = real_stream_index;
3455 best_decoder = decoder;
3456 if (program && i == nb_streams - 1 && ret < 0) {
3458 nb_streams = ic->nb_streams;
3459 /* no related stream found, try again with everything */
3464 *decoder_ret = (AVCodec*)best_decoder;
3468 /*******************************************************/
3470 int av_read_play(AVFormatContext *s)
3472 if (s->iformat->read_play)
3473 return s->iformat->read_play(s);
3475 return avio_pause(s->pb, 0);
3476 return AVERROR(ENOSYS);
3479 int av_read_pause(AVFormatContext *s)
3481 if (s->iformat->read_pause)
3482 return s->iformat->read_pause(s);
3484 return avio_pause(s->pb, 1);
3485 return AVERROR(ENOSYS);
3488 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3490 av_assert0(s->nb_streams>0);
3491 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3493 for (j = 0; j < st->nb_side_data; j++)
3494 av_freep(&st->side_data[j].data);
3495 av_freep(&st->side_data);
3496 st->nb_side_data = 0;
3499 av_parser_close(st->parser);
3501 if (st->attached_pic.data)
3502 av_free_packet(&st->attached_pic);
3503 av_dict_free(&st->metadata);
3504 av_freep(&st->probe_data.buf);
3505 av_freep(&st->index_entries);
3506 av_freep(&st->codec->extradata);
3507 av_freep(&st->codec->subtitle_header);
3508 av_freep(&st->codec);
3509 av_freep(&st->priv_data);
3511 av_freep(&st->info->duration_error);
3512 av_freep(&st->info);
3513 av_freep(&s->streams[ --s->nb_streams ]);
3516 void avformat_free_context(AVFormatContext *s)
3524 if (s->iformat && s->iformat->priv_class && s->priv_data)
3525 av_opt_free(s->priv_data);
3526 if (s->oformat && s->oformat->priv_class && s->priv_data)
3527 av_opt_free(s->priv_data);
3529 for (i = s->nb_streams - 1; i >= 0; i--) {
3530 ff_free_stream(s, s->streams[i]);
3532 for (i = s->nb_programs - 1; i >= 0; i--) {
3533 av_dict_free(&s->programs[i]->metadata);
3534 av_freep(&s->programs[i]->stream_index);
3535 av_freep(&s->programs[i]);
3537 av_freep(&s->programs);
3538 av_freep(&s->priv_data);
3539 while (s->nb_chapters--) {
3540 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3541 av_freep(&s->chapters[s->nb_chapters]);
3543 av_freep(&s->chapters);
3544 av_dict_free(&s->metadata);
3545 av_freep(&s->streams);
3546 av_freep(&s->internal);
3550 #if FF_API_CLOSE_INPUT_FILE
3551 void av_close_input_file(AVFormatContext *s)
3553 avformat_close_input(&s);
3557 void avformat_close_input(AVFormatContext **ps)
3568 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3569 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3572 flush_packet_queue(s);
3575 if (s->iformat->read_close)
3576 s->iformat->read_close(s);
3578 avformat_free_context(s);
3585 #if FF_API_NEW_STREAM
3586 AVStream *av_new_stream(AVFormatContext *s, int id)
3588 AVStream *st = avformat_new_stream(s, NULL);
3595 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3601 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3603 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3606 s->streams = streams;
3608 st = av_mallocz(sizeof(AVStream));
3611 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3615 st->info->last_dts = AV_NOPTS_VALUE;
3617 st->codec = avcodec_alloc_context3(c);
3619 /* no default bitrate if decoding */
3620 st->codec->bit_rate = 0;
3622 /* default pts setting is MPEG-like */
3623 avpriv_set_pts_info(st, 33, 1, 90000);
3626 st->index = s->nb_streams;
3627 st->start_time = AV_NOPTS_VALUE;
3628 st->duration = AV_NOPTS_VALUE;
3629 /* we set the current DTS to 0 so that formats without any timestamps
3630 * but durations get some timestamps, formats with some unknown
3631 * timestamps have their first few packets buffered and the
3632 * timestamps corrected before they are returned to the user */
3633 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3634 st->first_dts = AV_NOPTS_VALUE;
3635 st->probe_packets = MAX_PROBE_PACKETS;
3636 st->pts_wrap_reference = AV_NOPTS_VALUE;
3637 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3639 st->last_IP_pts = AV_NOPTS_VALUE;
3640 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3641 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3642 st->pts_buffer[i] = AV_NOPTS_VALUE;
3644 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3646 #if FF_API_R_FRAME_RATE
3647 st->info->last_dts = AV_NOPTS_VALUE;
3649 st->info->fps_first_dts = AV_NOPTS_VALUE;
3650 st->info->fps_last_dts = AV_NOPTS_VALUE;
3652 st->inject_global_side_data = s->internal->inject_global_side_data;
3654 s->streams[s->nb_streams++] = st;
3658 AVProgram *av_new_program(AVFormatContext *ac, int id)
3660 AVProgram *program = NULL;
3663 av_dlog(ac, "new_program: id=0x%04x\n", id);
3665 for (i = 0; i < ac->nb_programs; i++)
3666 if (ac->programs[i]->id == id)
3667 program = ac->programs[i];
3670 program = av_mallocz(sizeof(AVProgram));
3673 dynarray_add(&ac->programs, &ac->nb_programs, program);
3674 program->discard = AVDISCARD_NONE;
3677 program->pts_wrap_reference = AV_NOPTS_VALUE;
3678 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3680 program->start_time =
3681 program->end_time = AV_NOPTS_VALUE;
3686 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3687 int64_t start, int64_t end, const char *title)
3689 AVChapter *chapter = NULL;
3692 if (end != AV_NOPTS_VALUE && start > end) {
3693 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3697 for (i = 0; i < s->nb_chapters; i++)
3698 if (s->chapters[i]->id == id)
3699 chapter = s->chapters[i];
3702 chapter = av_mallocz(sizeof(AVChapter));
3705 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3707 av_dict_set(&chapter->metadata, "title", title, 0);
3709 chapter->time_base = time_base;
3710 chapter->start = start;
3716 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3719 AVProgram *program = NULL;
3722 if (idx >= ac->nb_streams) {
3723 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3727 for (i = 0; i < ac->nb_programs; i++) {
3728 if (ac->programs[i]->id != progid)
3730 program = ac->programs[i];
3731 for (j = 0; j < program->nb_stream_indexes; j++)
3732 if (program->stream_index[j] == idx)
3735 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3738 program->stream_index = tmp;
3739 program->stream_index[program->nb_stream_indexes++] = idx;
3744 uint64_t ff_ntp_time(void)
3746 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3749 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3752 char *q, buf1[20], c;
3753 int nd, len, percentd_found;
3765 while (av_isdigit(*p))
3766 nd = nd * 10 + *p++ - '0';
3768 } while (av_isdigit(c));
3777 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3779 if ((q - buf + len) > buf_size - 1)
3781 memcpy(q, buf1, len);
3789 if ((q - buf) < buf_size - 1)
3793 if (!percentd_found)
3802 void av_url_split(char *proto, int proto_size,
3803 char *authorization, int authorization_size,
3804 char *hostname, int hostname_size,
3805 int *port_ptr, char *path, int path_size, const char *url)
3807 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3813 if (authorization_size > 0)
3814 authorization[0] = 0;
3815 if (hostname_size > 0)
3820 /* parse protocol */
3821 if ((p = strchr(url, ':'))) {
3822 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3829 /* no protocol means plain filename */
3830 av_strlcpy(path, url, path_size);
3834 /* separate path from hostname */
3835 ls = strchr(p, '/');
3836 ls2 = strchr(p, '?');
3840 ls = FFMIN(ls, ls2);
3842 av_strlcpy(path, ls, path_size);
3844 ls = &p[strlen(p)]; // XXX
3846 /* the rest is hostname, use that to parse auth/port */
3848 /* authorization (user[:pass]@hostname) */
3850 while ((at = strchr(p, '@')) && at < ls) {
3851 av_strlcpy(authorization, at2,
3852 FFMIN(authorization_size, at + 1 - at2));
3853 p = at + 1; /* skip '@' */
3856 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3858 av_strlcpy(hostname, p + 1,
3859 FFMIN(hostname_size, brk - p));
3860 if (brk[1] == ':' && port_ptr)
3861 *port_ptr = atoi(brk + 2);
3862 } else if ((col = strchr(p, ':')) && col < ls) {
3863 av_strlcpy(hostname, p,
3864 FFMIN(col + 1 - p, hostname_size));
3866 *port_ptr = atoi(col + 1);
3868 av_strlcpy(hostname, p,
3869 FFMIN(ls + 1 - p, hostname_size));
3873 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3876 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3879 'C', 'D', 'E', 'F' };
3880 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3883 'c', 'd', 'e', 'f' };
3884 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3886 for (i = 0; i < s; i++) {
3887 buff[i * 2] = hex_table[src[i] >> 4];
3888 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3894 int ff_hex_to_data(uint8_t *data, const char *p)
3901 p += strspn(p, SPACE_CHARS);
3904 c = av_toupper((unsigned char) *p++);
3905 if (c >= '0' && c <= '9')
3907 else if (c >= 'A' && c <= 'F')
3922 #if FF_API_SET_PTS_INFO
3923 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3924 unsigned int pts_num, unsigned int pts_den)
3926 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3930 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3931 unsigned int pts_num, unsigned int pts_den)
3934 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3935 if (new_tb.num != pts_num)
3936 av_log(NULL, AV_LOG_DEBUG,
3937 "st:%d removing common factor %d from timebase\n",
3938 s->index, pts_num / new_tb.num);
3940 av_log(NULL, AV_LOG_WARNING,
3941 "st:%d has too large timebase, reducing\n", s->index);
3943 if (new_tb.num <= 0 || new_tb.den <= 0) {
3944 av_log(NULL, AV_LOG_ERROR,
3945 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3946 new_tb.num, new_tb.den,
3950 s->time_base = new_tb;
3951 av_codec_set_pkt_timebase(s->codec, new_tb);
3952 s->pts_wrap_bits = pts_wrap_bits;
3955 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3958 const char *ptr = str;
3960 /* Parse key=value pairs. */
3963 char *dest = NULL, *dest_end;
3964 int key_len, dest_len = 0;
3966 /* Skip whitespace and potential commas. */
3967 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3974 if (!(ptr = strchr(key, '=')))
3977 key_len = ptr - key;
3979 callback_get_buf(context, key, key_len, &dest, &dest_len);
3980 dest_end = dest + dest_len - 1;
3984 while (*ptr && *ptr != '\"') {
3988 if (dest && dest < dest_end)
3992 if (dest && dest < dest_end)
4000 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4001 if (dest && dest < dest_end)
4009 int ff_find_stream_index(AVFormatContext *s, int id)
4012 for (i = 0; i < s->nb_streams; i++)
4013 if (s->streams[i]->id == id)
4018 int64_t ff_iso8601_to_unix_time(const char *datestr)
4020 struct tm time1 = { 0 }, time2 = { 0 };
4022 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4023 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4025 return av_timegm(&time2);
4027 return av_timegm(&time1);
4030 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4034 if (ofmt->query_codec)
4035 return ofmt->query_codec(codec_id, std_compliance);
4036 else if (ofmt->codec_tag)
4037 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4038 else if (codec_id == ofmt->video_codec ||
4039 codec_id == ofmt->audio_codec ||
4040 codec_id == ofmt->subtitle_codec)
4043 return AVERROR_PATCHWELCOME;
4046 int avformat_network_init(void)
4050 ff_network_inited_globally = 1;
4051 if ((ret = ff_network_init()) < 0)
4058 int avformat_network_deinit(void)
4067 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4068 uint64_t channel_layout, int32_t sample_rate,
4069 int32_t width, int32_t height)
4075 return AVERROR(EINVAL);
4078 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4080 if (channel_layout) {
4082 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4086 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4088 if (width || height) {
4090 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4092 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4094 return AVERROR(ENOMEM);
4095 bytestream_put_le32(&data, flags);
4097 bytestream_put_le32(&data, channels);
4099 bytestream_put_le64(&data, channel_layout);
4101 bytestream_put_le32(&data, sample_rate);
4102 if (width || height) {
4103 bytestream_put_le32(&data, width);
4104 bytestream_put_le32(&data, height);
4109 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4111 AVRational undef = {0, 1};
4112 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4113 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4114 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4116 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4117 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4118 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4119 stream_sample_aspect_ratio = undef;
4121 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4122 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4123 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4124 frame_sample_aspect_ratio = undef;
4126 if (stream_sample_aspect_ratio.num)
4127 return stream_sample_aspect_ratio;
4129 return frame_sample_aspect_ratio;
4132 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4134 AVRational fr = st->r_frame_rate;
4135 AVRational codec_fr = av_inv_q(st->codec->time_base);
4136 AVRational avg_fr = st->avg_frame_rate;
4138 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4139 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4144 if (st->codec->ticks_per_frame > 1) {
4145 codec_fr.den *= st->codec->ticks_per_frame;
4146 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4147 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4154 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4157 if (*spec <= '9' && *spec >= '0') /* opt:index */
4158 return strtol(spec, NULL, 0) == st->index;
4159 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4160 *spec == 't') { /* opt:[vasdt] */
4161 enum AVMediaType type;
4164 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4165 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4166 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4167 case 'd': type = AVMEDIA_TYPE_DATA; break;
4168 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4169 default: av_assert0(0);
4171 if (type != st->codec->codec_type)
4173 if (*spec++ == ':') { /* possibly followed by :index */
4174 int i, index = strtol(spec, NULL, 0);
4175 for (i = 0; i < s->nb_streams; i++)
4176 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4177 return i == st->index;
4181 } else if (*spec == 'p' && *(spec + 1) == ':') {
4185 prog_id = strtol(spec, &endptr, 0);
4186 for (i = 0; i < s->nb_programs; i++) {
4187 if (s->programs[i]->id != prog_id)
4190 if (*endptr++ == ':') {
4191 int stream_idx = strtol(endptr, NULL, 0);
4192 return stream_idx >= 0 &&
4193 stream_idx < s->programs[i]->nb_stream_indexes &&
4194 st->index == s->programs[i]->stream_index[stream_idx];
4197 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4198 if (st->index == s->programs[i]->stream_index[j])
4202 } else if (*spec == '#' ||
4203 (*spec == 'i' && *(spec + 1) == ':')) {
4206 spec += 1 + (*spec == 'i');
4207 stream_id = strtol(spec, &endptr, 0);
4209 return stream_id == st->id;
4210 } else if (!*spec) /* empty specifier, matches everything */
4213 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4214 return AVERROR(EINVAL);
4217 int ff_generate_avci_extradata(AVStream *st)
4219 static const uint8_t avci100_1080p_extradata[] = {
4221 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4222 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4223 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4224 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4225 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4226 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4227 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4228 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4229 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4231 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4234 static const uint8_t avci100_1080i_extradata[] = {
4236 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4237 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4238 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4239 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4240 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4241 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4242 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4243 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4244 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4245 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4246 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4248 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4251 static const uint8_t avci50_1080i_extradata[] = {
4253 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4254 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4255 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4256 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4257 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4258 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4259 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4260 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4261 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4262 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4263 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4265 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4268 static const uint8_t avci100_720p_extradata[] = {
4270 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4271 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4272 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4273 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4274 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4275 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4276 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4277 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4278 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4279 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4281 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4285 const uint8_t *data = NULL;
4288 if (st->codec->width == 1920) {
4289 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4290 data = avci100_1080p_extradata;
4291 size = sizeof(avci100_1080p_extradata);
4293 data = avci100_1080i_extradata;
4294 size = sizeof(avci100_1080i_extradata);
4296 } else if (st->codec->width == 1440) {
4297 data = avci50_1080i_extradata;
4298 size = sizeof(avci50_1080i_extradata);
4299 } else if (st->codec->width == 1280) {
4300 data = avci100_720p_extradata;
4301 size = sizeof(avci100_720p_extradata);
4307 av_freep(&st->codec->extradata);
4308 if (ff_alloc_extradata(st->codec, size))
4309 return AVERROR(ENOMEM);
4310 memcpy(st->codec->extradata, data, size);
4315 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4320 for (i = 0; i < st->nb_side_data; i++) {
4321 if (st->side_data[i].type == type) {
4323 *size = st->side_data[i].size;
4324 return st->side_data[i].data;