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)
1534 int first_audio_index = -1;
1538 if (s->nb_streams <= 0)
1540 for (i = 0; i < s->nb_streams; i++) {
1542 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1543 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1546 if (first_audio_index < 0 &&
1547 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1548 first_audio_index = i;
1550 return first_audio_index >= 0 ? first_audio_index : 0;
1553 /** Flush the frame reader. */
1554 void ff_read_frame_flush(AVFormatContext *s)
1559 flush_packet_queue(s);
1561 /* Reset read state for each stream. */
1562 for (i = 0; i < s->nb_streams; i++) {
1566 av_parser_close(st->parser);
1569 st->last_IP_pts = AV_NOPTS_VALUE;
1570 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1571 if (st->first_dts == AV_NOPTS_VALUE)
1572 st->cur_dts = RELATIVE_TS_BASE;
1574 /* We set the current DTS to an unspecified origin. */
1575 st->cur_dts = AV_NOPTS_VALUE;
1577 st->probe_packets = MAX_PROBE_PACKETS;
1579 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1580 st->pts_buffer[j] = AV_NOPTS_VALUE;
1582 if (s->internal->inject_global_side_data)
1583 st->inject_global_side_data = 1;
1587 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1591 for (i = 0; i < s->nb_streams; i++) {
1592 AVStream *st = s->streams[i];
1595 av_rescale(timestamp,
1596 st->time_base.den * (int64_t) ref_st->time_base.num,
1597 st->time_base.num * (int64_t) ref_st->time_base.den);
1601 void ff_reduce_index(AVFormatContext *s, int stream_index)
1603 AVStream *st = s->streams[stream_index];
1604 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1606 if ((unsigned) st->nb_index_entries >= max_entries) {
1608 for (i = 0; 2 * i < st->nb_index_entries; i++)
1609 st->index_entries[i] = st->index_entries[2 * i];
1610 st->nb_index_entries = i;
1614 int ff_add_index_entry(AVIndexEntry **index_entries,
1615 int *nb_index_entries,
1616 unsigned int *index_entries_allocated_size,
1617 int64_t pos, int64_t timestamp,
1618 int size, int distance, int flags)
1620 AVIndexEntry *entries, *ie;
1623 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1626 if (timestamp == AV_NOPTS_VALUE)
1627 return AVERROR(EINVAL);
1629 if (size < 0 || size > 0x3FFFFFFF)
1630 return AVERROR(EINVAL);
1632 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1633 timestamp -= RELATIVE_TS_BASE;
1635 entries = av_fast_realloc(*index_entries,
1636 index_entries_allocated_size,
1637 (*nb_index_entries + 1) *
1638 sizeof(AVIndexEntry));
1642 *index_entries = entries;
1644 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1645 timestamp, AVSEEK_FLAG_ANY);
1648 index = (*nb_index_entries)++;
1649 ie = &entries[index];
1650 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1652 ie = &entries[index];
1653 if (ie->timestamp != timestamp) {
1654 if (ie->timestamp <= timestamp)
1656 memmove(entries + index + 1, entries + index,
1657 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1658 (*nb_index_entries)++;
1659 } else if (ie->pos == pos && distance < ie->min_distance)
1660 // do not reduce the distance
1661 distance = ie->min_distance;
1665 ie->timestamp = timestamp;
1666 ie->min_distance = distance;
1673 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1674 int size, int distance, int flags)
1676 timestamp = wrap_timestamp(st, timestamp);
1677 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1678 &st->index_entries_allocated_size, pos,
1679 timestamp, size, distance, flags);
1682 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1683 int64_t wanted_timestamp, int flags)
1691 // Optimize appending index entries at the end.
1692 if (b && entries[b - 1].timestamp < wanted_timestamp)
1697 timestamp = entries[m].timestamp;
1698 if (timestamp >= wanted_timestamp)
1700 if (timestamp <= wanted_timestamp)
1703 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1705 if (!(flags & AVSEEK_FLAG_ANY))
1706 while (m >= 0 && m < nb_entries &&
1707 !(entries[m].flags & AVINDEX_KEYFRAME))
1708 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1710 if (m == nb_entries)
1715 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1717 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1718 wanted_timestamp, flags);
1721 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1722 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1724 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1725 if (stream_index >= 0)
1726 ts = wrap_timestamp(s->streams[stream_index], ts);
1730 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1731 int64_t target_ts, int flags)
1733 AVInputFormat *avif = s->iformat;
1734 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1735 int64_t ts_min, ts_max, ts;
1740 if (stream_index < 0)
1743 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1746 ts_min = AV_NOPTS_VALUE;
1747 pos_limit = -1; // GCC falsely says it may be uninitialized.
1749 st = s->streams[stream_index];
1750 if (st->index_entries) {
1753 /* FIXME: Whole function must be checked for non-keyframe entries in
1754 * index case, especially read_timestamp(). */
1755 index = av_index_search_timestamp(st, target_ts,
1756 flags | AVSEEK_FLAG_BACKWARD);
1757 index = FFMAX(index, 0);
1758 e = &st->index_entries[index];
1760 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1762 ts_min = e->timestamp;
1763 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1764 pos_min, av_ts2str(ts_min));
1766 av_assert1(index == 0);
1769 index = av_index_search_timestamp(st, target_ts,
1770 flags & ~AVSEEK_FLAG_BACKWARD);
1771 av_assert0(index < st->nb_index_entries);
1773 e = &st->index_entries[index];
1774 av_assert1(e->timestamp >= target_ts);
1776 ts_max = e->timestamp;
1777 pos_limit = pos_max - e->min_distance;
1778 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1779 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1783 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1784 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1789 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1792 ff_read_frame_flush(s);
1793 ff_update_cur_dts(s, st, ts);
1798 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1799 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1801 int64_t step = 1024;
1802 int64_t limit, ts_max;
1803 int64_t filesize = avio_size(s->pb);
1804 int64_t pos_max = filesize - 1;
1807 pos_max = FFMAX(0, (pos_max) - step);
1808 ts_max = ff_read_timestamp(s, stream_index,
1809 &pos_max, limit, read_timestamp);
1811 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1812 if (ts_max == AV_NOPTS_VALUE)
1816 int64_t tmp_pos = pos_max + 1;
1817 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1818 &tmp_pos, INT64_MAX, read_timestamp);
1819 if (tmp_ts == AV_NOPTS_VALUE)
1821 av_assert0(tmp_pos > pos_max);
1824 if (tmp_pos >= filesize)
1836 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1837 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1838 int64_t ts_min, int64_t ts_max,
1839 int flags, int64_t *ts_ret,
1840 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1841 int64_t *, int64_t))
1848 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1850 if (ts_min == AV_NOPTS_VALUE) {
1851 pos_min = s->data_offset;
1852 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1853 if (ts_min == AV_NOPTS_VALUE)
1857 if (ts_min >= target_ts) {
1862 if (ts_max == AV_NOPTS_VALUE) {
1863 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1865 pos_limit = pos_max;
1868 if (ts_max <= target_ts) {
1873 if (ts_min > ts_max)
1875 else if (ts_min == ts_max)
1876 pos_limit = pos_min;
1879 while (pos_min < pos_limit) {
1881 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1882 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1883 assert(pos_limit <= pos_max);
1885 if (no_change == 0) {
1886 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1887 // interpolate position (better than dichotomy)
1888 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1890 pos_min - approximate_keyframe_distance;
1891 } else if (no_change == 1) {
1892 // bisection if interpolation did not change min / max pos last time
1893 pos = (pos_min + pos_limit) >> 1;
1895 /* linear search if bisection failed, can only happen if there
1896 * are very few or no keyframes between min/max */
1901 else if (pos > pos_limit)
1905 // May pass pos_limit instead of -1.
1906 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1911 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1912 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1913 pos_min, pos, pos_max,
1914 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1915 pos_limit, start_pos, no_change);
1916 if (ts == AV_NOPTS_VALUE) {
1917 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1920 assert(ts != AV_NOPTS_VALUE);
1921 if (target_ts <= ts) {
1922 pos_limit = start_pos - 1;
1926 if (target_ts >= ts) {
1932 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1933 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1936 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1938 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1939 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1940 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1946 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1947 int64_t pos, int flags)
1949 int64_t pos_min, pos_max;
1951 pos_min = s->data_offset;
1952 pos_max = avio_size(s->pb) - 1;
1956 else if (pos > pos_max)
1959 avio_seek(s->pb, pos, SEEK_SET);
1961 s->io_repositioned = 1;
1966 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1967 int64_t timestamp, int flags)
1974 st = s->streams[stream_index];
1976 index = av_index_search_timestamp(st, timestamp, flags);
1978 if (index < 0 && st->nb_index_entries &&
1979 timestamp < st->index_entries[0].timestamp)
1982 if (index < 0 || index == st->nb_index_entries - 1) {
1986 if (st->nb_index_entries) {
1987 av_assert0(st->index_entries);
1988 ie = &st->index_entries[st->nb_index_entries - 1];
1989 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1991 ff_update_cur_dts(s, st, ie->timestamp);
1993 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1999 read_status = av_read_frame(s, &pkt);
2000 } while (read_status == AVERROR(EAGAIN));
2001 if (read_status < 0)
2003 av_free_packet(&pkt);
2004 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2005 if (pkt.flags & AV_PKT_FLAG_KEY)
2007 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2008 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);
2013 index = av_index_search_timestamp(st, timestamp, flags);
2018 ff_read_frame_flush(s);
2019 if (s->iformat->read_seek)
2020 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2022 ie = &st->index_entries[index];
2023 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2025 ff_update_cur_dts(s, st, ie->timestamp);
2030 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2031 int64_t timestamp, int flags)
2036 if (flags & AVSEEK_FLAG_BYTE) {
2037 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2039 ff_read_frame_flush(s);
2040 return seek_frame_byte(s, stream_index, timestamp, flags);
2043 if (stream_index < 0) {
2044 stream_index = av_find_default_stream_index(s);
2045 if (stream_index < 0)
2048 st = s->streams[stream_index];
2049 /* timestamp for default must be expressed in AV_TIME_BASE units */
2050 timestamp = av_rescale(timestamp, st->time_base.den,
2051 AV_TIME_BASE * (int64_t) st->time_base.num);
2054 /* first, we try the format specific seek */
2055 if (s->iformat->read_seek) {
2056 ff_read_frame_flush(s);
2057 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2063 if (s->iformat->read_timestamp &&
2064 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2065 ff_read_frame_flush(s);
2066 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2067 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2068 ff_read_frame_flush(s);
2069 return seek_frame_generic(s, stream_index, timestamp, flags);
2074 int av_seek_frame(AVFormatContext *s, int stream_index,
2075 int64_t timestamp, int flags)
2079 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2080 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2081 if ((flags & AVSEEK_FLAG_BACKWARD))
2085 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2086 flags & ~AVSEEK_FLAG_BACKWARD);
2089 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2092 ret = avformat_queue_attached_pictures(s);
2097 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2098 int64_t ts, int64_t max_ts, int flags)
2100 if (min_ts > ts || max_ts < ts)
2102 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2103 return AVERROR(EINVAL);
2106 flags |= AVSEEK_FLAG_ANY;
2107 flags &= ~AVSEEK_FLAG_BACKWARD;
2109 if (s->iformat->read_seek2) {
2111 ff_read_frame_flush(s);
2113 if (stream_index == -1 && s->nb_streams == 1) {
2114 AVRational time_base = s->streams[0]->time_base;
2115 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2116 min_ts = av_rescale_rnd(min_ts, time_base.den,
2117 time_base.num * (int64_t)AV_TIME_BASE,
2118 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2119 max_ts = av_rescale_rnd(max_ts, time_base.den,
2120 time_base.num * (int64_t)AV_TIME_BASE,
2121 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2124 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2128 ret = avformat_queue_attached_pictures(s);
2132 if (s->iformat->read_timestamp) {
2133 // try to seek via read_timestamp()
2136 // Fall back on old API if new is not implemented but old is.
2137 // Note the old API has somewhat different semantics.
2138 if (s->iformat->read_seek || 1) {
2139 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2140 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2141 if (ret<0 && ts != min_ts && max_ts != ts) {
2142 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2144 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2149 // try some generic seek like seek_frame_generic() but with new ts semantics
2150 return -1; //unreachable
2153 /*******************************************************/
2156 * Return TRUE if the stream has accurate duration in any stream.
2158 * @return TRUE if the stream has accurate duration for at least one component.
2160 static int has_duration(AVFormatContext *ic)
2165 for (i = 0; i < ic->nb_streams; i++) {
2166 st = ic->streams[i];
2167 if (st->duration != AV_NOPTS_VALUE)
2170 if (ic->duration != AV_NOPTS_VALUE)
2176 * Estimate the stream timings from the one of each components.
2178 * Also computes the global bitrate if possible.
2180 static void update_stream_timings(AVFormatContext *ic)
2182 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2183 int64_t duration, duration1, filesize;
2188 start_time = INT64_MAX;
2189 start_time_text = INT64_MAX;
2190 end_time = INT64_MIN;
2191 duration = INT64_MIN;
2192 for (i = 0; i < ic->nb_streams; i++) {
2193 st = ic->streams[i];
2194 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2195 start_time1 = av_rescale_q(st->start_time, st->time_base,
2197 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2198 if (start_time1 < start_time_text)
2199 start_time_text = start_time1;
2201 start_time = FFMIN(start_time, start_time1);
2202 end_time1 = AV_NOPTS_VALUE;
2203 if (st->duration != AV_NOPTS_VALUE) {
2204 end_time1 = start_time1 +
2205 av_rescale_q(st->duration, st->time_base,
2207 end_time = FFMAX(end_time, end_time1);
2209 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2210 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2211 p->start_time = start_time1;
2212 if (p->end_time < end_time1)
2213 p->end_time = end_time1;
2216 if (st->duration != AV_NOPTS_VALUE) {
2217 duration1 = av_rescale_q(st->duration, st->time_base,
2219 duration = FFMAX(duration, duration1);
2222 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2223 start_time = start_time_text;
2224 else if (start_time > start_time_text)
2225 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2227 if (start_time != INT64_MAX) {
2228 ic->start_time = start_time;
2229 if (end_time != INT64_MIN) {
2230 if (ic->nb_programs) {
2231 for (i = 0; i < ic->nb_programs; i++) {
2232 p = ic->programs[i];
2233 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2234 duration = FFMAX(duration, p->end_time - p->start_time);
2237 duration = FFMAX(duration, end_time - start_time);
2240 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2241 ic->duration = duration;
2243 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2244 /* compute the bitrate */
2245 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2246 (double) ic->duration;
2247 if (bitrate >= 0 && bitrate <= INT_MAX)
2248 ic->bit_rate = bitrate;
2252 static void fill_all_stream_timings(AVFormatContext *ic)
2257 update_stream_timings(ic);
2258 for (i = 0; i < ic->nb_streams; i++) {
2259 st = ic->streams[i];
2260 if (st->start_time == AV_NOPTS_VALUE) {
2261 if (ic->start_time != AV_NOPTS_VALUE)
2262 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2264 if (ic->duration != AV_NOPTS_VALUE)
2265 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2271 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2273 int64_t filesize, duration;
2274 int i, show_warning = 0;
2277 /* if bit_rate is already set, we believe it */
2278 if (ic->bit_rate <= 0) {
2280 for (i = 0; i < ic->nb_streams; i++) {
2281 st = ic->streams[i];
2282 if (st->codec->bit_rate > 0) {
2283 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2287 bit_rate += st->codec->bit_rate;
2290 ic->bit_rate = bit_rate;
2293 /* if duration is already set, we believe it */
2294 if (ic->duration == AV_NOPTS_VALUE &&
2295 ic->bit_rate != 0) {
2296 filesize = ic->pb ? avio_size(ic->pb) : 0;
2298 for (i = 0; i < ic->nb_streams; i++) {
2299 st = ic->streams[i];
2300 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2301 && st->duration == AV_NOPTS_VALUE) {
2302 duration = av_rescale(8 * filesize, st->time_base.den,
2304 (int64_t) st->time_base.num);
2305 st->duration = duration;
2312 av_log(ic, AV_LOG_WARNING,
2313 "Estimating duration from bitrate, this may be inaccurate\n");
2316 #define DURATION_MAX_READ_SIZE 250000LL
2317 #define DURATION_MAX_RETRY 4
2319 /* only usable for MPEG-PS streams */
2320 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2322 AVPacket pkt1, *pkt = &pkt1;
2324 int num, den, read_size, i, ret;
2325 int found_duration = 0;
2327 int64_t filesize, offset, duration;
2330 /* flush packet queue */
2331 flush_packet_queue(ic);
2333 for (i = 0; i < ic->nb_streams; i++) {
2334 st = ic->streams[i];
2335 if (st->start_time == AV_NOPTS_VALUE &&
2336 st->first_dts == AV_NOPTS_VALUE &&
2337 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2338 av_log(st->codec, AV_LOG_WARNING,
2339 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2342 av_parser_close(st->parser);
2347 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2348 /* estimate the end time (duration) */
2349 /* XXX: may need to support wrapping */
2350 filesize = ic->pb ? avio_size(ic->pb) : 0;
2352 is_end = found_duration;
2353 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2357 avio_seek(ic->pb, offset, SEEK_SET);
2360 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2364 ret = ff_read_packet(ic, pkt);
2365 } while (ret == AVERROR(EAGAIN));
2368 read_size += pkt->size;
2369 st = ic->streams[pkt->stream_index];
2370 if (pkt->pts != AV_NOPTS_VALUE &&
2371 (st->start_time != AV_NOPTS_VALUE ||
2372 st->first_dts != AV_NOPTS_VALUE)) {
2373 if (pkt->duration == 0) {
2374 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2376 pkt->duration = av_rescale_rnd(1,
2377 num * (int64_t) st->time_base.den,
2378 den * (int64_t) st->time_base.num,
2382 duration = pkt->pts + pkt->duration;
2384 if (st->start_time != AV_NOPTS_VALUE)
2385 duration -= st->start_time;
2387 duration -= st->first_dts;
2389 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2390 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2391 st->duration = duration;
2392 st->info->last_duration = duration;
2395 av_free_packet(pkt);
2398 /* check if all audio/video streams have valid duration */
2401 for (i = 0; i < ic->nb_streams; i++) {
2402 st = ic->streams[i];
2403 switch (st->codec->codec_type) {
2404 case AVMEDIA_TYPE_VIDEO:
2405 case AVMEDIA_TYPE_AUDIO:
2406 if (st->duration == AV_NOPTS_VALUE)
2413 ++retry <= DURATION_MAX_RETRY);
2415 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2417 /* warn about audio/video streams which duration could not be estimated */
2418 for (i = 0; i < ic->nb_streams; i++) {
2419 st = ic->streams[i];
2420 if (st->duration == AV_NOPTS_VALUE) {
2421 switch (st->codec->codec_type) {
2422 case AVMEDIA_TYPE_VIDEO:
2423 case AVMEDIA_TYPE_AUDIO:
2424 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2425 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2427 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2431 fill_all_stream_timings(ic);
2433 avio_seek(ic->pb, old_offset, SEEK_SET);
2434 for (i = 0; i < ic->nb_streams; i++) {
2437 st = ic->streams[i];
2438 st->cur_dts = st->first_dts;
2439 st->last_IP_pts = AV_NOPTS_VALUE;
2440 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2441 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2442 st->pts_buffer[j] = AV_NOPTS_VALUE;
2446 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2450 /* get the file size, if possible */
2451 if (ic->iformat->flags & AVFMT_NOFILE) {
2454 file_size = avio_size(ic->pb);
2455 file_size = FFMAX(0, file_size);
2458 if ((!strcmp(ic->iformat->name, "mpeg") ||
2459 !strcmp(ic->iformat->name, "mpegts")) &&
2460 file_size && ic->pb->seekable) {
2461 /* get accurate estimate from the PTSes */
2462 estimate_timings_from_pts(ic, old_offset);
2463 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2464 } else if (has_duration(ic)) {
2465 /* at least one component has timings - we use them for all
2467 fill_all_stream_timings(ic);
2468 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2470 /* less precise: use bitrate info */
2471 estimate_timings_from_bit_rate(ic);
2472 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2474 update_stream_timings(ic);
2478 AVStream av_unused *st;
2479 for (i = 0; i < ic->nb_streams; i++) {
2480 st = ic->streams[i];
2481 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2482 (double) st->start_time / AV_TIME_BASE,
2483 (double) st->duration / AV_TIME_BASE);
2486 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2487 (double) ic->start_time / AV_TIME_BASE,
2488 (double) ic->duration / AV_TIME_BASE,
2489 ic->bit_rate / 1000);
2493 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2495 AVCodecContext *avctx = st->codec;
2497 #define FAIL(errmsg) do { \
2499 *errmsg_ptr = errmsg; \
2503 if ( avctx->codec_id == AV_CODEC_ID_NONE
2504 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2505 FAIL("unknown codec");
2506 switch (avctx->codec_type) {
2507 case AVMEDIA_TYPE_AUDIO:
2508 if (!avctx->frame_size && determinable_frame_size(avctx))
2509 FAIL("unspecified frame size");
2510 if (st->info->found_decoder >= 0 &&
2511 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2512 FAIL("unspecified sample format");
2513 if (!avctx->sample_rate)
2514 FAIL("unspecified sample rate");
2515 if (!avctx->channels)
2516 FAIL("unspecified number of channels");
2517 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2518 FAIL("no decodable DTS frames");
2520 case AVMEDIA_TYPE_VIDEO:
2522 FAIL("unspecified size");
2523 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2524 FAIL("unspecified pixel format");
2525 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2526 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2527 FAIL("no frame in rv30/40 and no sar");
2529 case AVMEDIA_TYPE_SUBTITLE:
2530 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2531 FAIL("unspecified size");
2533 case AVMEDIA_TYPE_DATA:
2534 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2540 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2541 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2542 AVDictionary **options)
2544 const AVCodec *codec;
2545 int got_picture = 1, ret = 0;
2546 AVFrame *frame = av_frame_alloc();
2547 AVSubtitle subtitle;
2548 AVPacket pkt = *avpkt;
2551 return AVERROR(ENOMEM);
2553 if (!avcodec_is_open(st->codec) &&
2554 st->info->found_decoder <= 0 &&
2555 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2556 AVDictionary *thread_opt = NULL;
2558 codec = find_decoder(s, st, st->codec->codec_id);
2561 st->info->found_decoder = -st->codec->codec_id;
2566 /* Force thread count to 1 since the H.264 decoder will not extract
2567 * SPS and PPS to extradata during multi-threaded decoding. */
2568 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2569 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2571 av_dict_free(&thread_opt);
2573 st->info->found_decoder = -st->codec->codec_id;
2576 st->info->found_decoder = 1;
2577 } else if (!st->info->found_decoder)
2578 st->info->found_decoder = 1;
2580 if (st->info->found_decoder < 0) {
2585 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2587 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2588 (!st->codec_info_nb_frames &&
2589 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2591 switch (st->codec->codec_type) {
2592 case AVMEDIA_TYPE_VIDEO:
2593 ret = avcodec_decode_video2(st->codec, frame,
2594 &got_picture, &pkt);
2596 case AVMEDIA_TYPE_AUDIO:
2597 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2599 case AVMEDIA_TYPE_SUBTITLE:
2600 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2601 &got_picture, &pkt);
2609 st->nb_decoded_frames++;
2616 if (!pkt.data && !got_picture)
2620 av_frame_free(&frame);
2624 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2626 while (tags->id != AV_CODEC_ID_NONE) {
2634 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2637 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2638 if (tag == tags[i].tag)
2640 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2641 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2643 return AV_CODEC_ID_NONE;
2646 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2651 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2653 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2655 return AV_CODEC_ID_NONE;
2660 if (sflags & (1 << (bps - 1))) {
2663 return AV_CODEC_ID_PCM_S8;
2665 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2667 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2669 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2671 return AV_CODEC_ID_NONE;
2676 return AV_CODEC_ID_PCM_U8;
2678 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2680 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2682 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2684 return AV_CODEC_ID_NONE;
2690 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2693 if (!av_codec_get_tag2(tags, id, &tag))
2698 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2702 for (i = 0; tags && tags[i]; i++) {
2703 const AVCodecTag *codec_tags = tags[i];
2704 while (codec_tags->id != AV_CODEC_ID_NONE) {
2705 if (codec_tags->id == id) {
2706 *tag = codec_tags->tag;
2715 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2718 for (i = 0; tags && tags[i]; i++) {
2719 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2720 if (id != AV_CODEC_ID_NONE)
2723 return AV_CODEC_ID_NONE;
2726 static void compute_chapters_end(AVFormatContext *s)
2729 int64_t max_time = s->duration +
2730 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2732 for (i = 0; i < s->nb_chapters; i++)
2733 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2734 AVChapter *ch = s->chapters[i];
2735 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2739 for (j = 0; j < s->nb_chapters; j++) {
2740 AVChapter *ch1 = s->chapters[j];
2741 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2743 if (j != i && next_start > ch->start && next_start < end)
2746 ch->end = (end == INT64_MAX) ? ch->start : end;
2750 static int get_std_framerate(int i)
2753 return (i + 1) * 1001;
2755 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2758 /* Is the time base unreliable?
2759 * This is a heuristic to balance between quick acceptance of the values in
2760 * the headers vs. some extra checks.
2761 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2762 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2763 * And there are "variable" fps files this needs to detect as well. */
2764 static int tb_unreliable(AVCodecContext *c)
2766 if (c->time_base.den >= 101L * c->time_base.num ||
2767 c->time_base.den < 5L * c->time_base.num ||
2768 // c->codec_tag == AV_RL32("DIVX") ||
2769 // c->codec_tag == AV_RL32("XVID") ||
2770 c->codec_tag == AV_RL32("mp4v") ||
2771 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2772 c->codec_id == AV_CODEC_ID_GIF ||
2773 c->codec_id == AV_CODEC_ID_H264)
2778 #if FF_API_FORMAT_PARAMETERS
2779 int av_find_stream_info(AVFormatContext *ic)
2781 return avformat_find_stream_info(ic, NULL);
2785 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2789 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2790 avctx->extradata_size = 0;
2791 return AVERROR(EINVAL);
2793 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2794 if (avctx->extradata) {
2795 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2796 avctx->extradata_size = size;
2799 avctx->extradata_size = 0;
2800 ret = AVERROR(ENOMEM);
2805 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2807 int ret = ff_alloc_extradata(avctx, size);
2810 ret = avio_read(pb, avctx->extradata, size);
2812 av_freep(&avctx->extradata);
2813 avctx->extradata_size = 0;
2814 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2815 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2821 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2824 int64_t last = st->info->last_dts;
2826 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2827 && ts - (uint64_t)last < INT64_MAX) {
2828 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2829 int64_t duration = ts - last;
2831 if (!st->info->duration_error)
2832 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2833 if (!st->info->duration_error)
2834 return AVERROR(ENOMEM);
2836 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2837 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2838 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2839 if (st->info->duration_error[0][1][i] < 1e10) {
2840 int framerate = get_std_framerate(i);
2841 double sdts = dts*framerate/(1001*12);
2842 for (j= 0; j<2; j++) {
2843 int64_t ticks = llrint(sdts+j*0.5);
2844 double error= sdts - ticks + j*0.5;
2845 st->info->duration_error[j][0][i] += error;
2846 st->info->duration_error[j][1][i] += error*error;
2850 st->info->duration_count++;
2851 st->info->rfps_duration_sum += duration;
2853 if (st->info->duration_count % 10 == 0) {
2854 int n = st->info->duration_count;
2855 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2856 if (st->info->duration_error[0][1][i] < 1e10) {
2857 double a0 = st->info->duration_error[0][0][i] / n;
2858 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2859 double a1 = st->info->duration_error[1][0][i] / n;
2860 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2861 if (error0 > 0.04 && error1 > 0.04) {
2862 st->info->duration_error[0][1][i] = 2e10;
2863 st->info->duration_error[1][1][i] = 2e10;
2869 // ignore the first 4 values, they might have some random jitter
2870 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2871 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2873 if (ts != AV_NOPTS_VALUE)
2874 st->info->last_dts = ts;
2879 void ff_rfps_calculate(AVFormatContext *ic)
2883 for (i = 0; i < ic->nb_streams; i++) {
2884 AVStream *st = ic->streams[i];
2886 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2888 // the check for tb_unreliable() is not completely correct, since this is not about handling
2889 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2890 // ipmovie.c produces.
2891 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)
2892 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);
2893 if (st->info->duration_count>1 && !st->r_frame_rate.num
2894 && tb_unreliable(st->codec)) {
2896 double best_error= 0.01;
2897 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2899 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2902 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2904 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2907 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2910 for (k= 0; k<2; k++) {
2911 int n = st->info->duration_count;
2912 double a= st->info->duration_error[k][0][j] / n;
2913 double error= st->info->duration_error[k][1][j]/n - a*a;
2915 if (error < best_error && best_error> 0.000000001) {
2917 num = get_std_framerate(j);
2920 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2923 // do not increase frame rate by more than 1 % in order to match a standard rate.
2924 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2925 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2927 if ( !st->avg_frame_rate.num
2928 && st->r_frame_rate.num && st->info->rfps_duration_sum
2929 && st->info->codec_info_duration <= 0
2930 && st->info->duration_count > 2
2931 && 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
2933 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2934 st->avg_frame_rate = st->r_frame_rate;
2937 av_freep(&st->info->duration_error);
2938 st->info->last_dts = AV_NOPTS_VALUE;
2939 st->info->duration_count = 0;
2940 st->info->rfps_duration_sum = 0;
2944 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2946 int i, count, ret = 0, j;
2949 AVPacket pkt1, *pkt;
2950 int64_t old_offset = avio_tell(ic->pb);
2951 // new streams might appear, no options for those
2952 int orig_nb_streams = ic->nb_streams;
2954 int64_t max_analyze_duration = ic->max_analyze_duration2;
2955 int64_t probesize = ic->probesize2;
2957 if (!max_analyze_duration)
2958 max_analyze_duration = ic->max_analyze_duration;
2960 probesize = ic->probesize;
2961 flush_codecs = probesize > 0;
2963 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2965 if (!max_analyze_duration) {
2966 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2967 max_analyze_duration = 10*AV_TIME_BASE;
2969 max_analyze_duration = 5*AV_TIME_BASE;
2973 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2974 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2976 for (i = 0; i < ic->nb_streams; i++) {
2977 const AVCodec *codec;
2978 AVDictionary *thread_opt = NULL;
2979 st = ic->streams[i];
2981 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2982 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2983 /* if (!st->time_base.num)
2985 if (!st->codec->time_base.num)
2986 st->codec->time_base = st->time_base;
2988 // only for the split stuff
2989 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2990 st->parser = av_parser_init(st->codec->codec_id);
2992 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
2993 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2994 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2995 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2997 } else if (st->need_parsing) {
2998 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2999 "%s, packets or times may be invalid.\n",
3000 avcodec_get_name(st->codec->codec_id));
3003 codec = find_decoder(ic, st, st->codec->codec_id);
3005 /* Force thread count to 1 since the H.264 decoder will not extract
3006 * SPS and PPS to extradata during multi-threaded decoding. */
3007 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3009 /* Ensure that subtitle_header is properly set. */
3010 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3011 && codec && !st->codec->codec) {
3012 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3013 av_log(ic, AV_LOG_WARNING,
3014 "Failed to open codec in av_find_stream_info\n");
3017 // Try to just open decoders, in case this is enough to get parameters.
3018 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3019 if (codec && !st->codec->codec)
3020 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3021 av_log(ic, AV_LOG_WARNING,
3022 "Failed to open codec in av_find_stream_info\n");
3025 av_dict_free(&thread_opt);
3028 for (i = 0; i < ic->nb_streams; i++) {
3029 #if FF_API_R_FRAME_RATE
3030 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3032 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3033 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3039 if (ff_check_interrupt(&ic->interrupt_callback)) {
3041 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3045 /* check if one codec still needs to be handled */
3046 for (i = 0; i < ic->nb_streams; i++) {
3047 int fps_analyze_framecount = 20;
3049 st = ic->streams[i];
3050 if (!has_codec_parameters(st, NULL))
3052 /* If the timebase is coarse (like the usual millisecond precision
3053 * of mkv), we need to analyze more frames to reliably arrive at
3054 * the correct fps. */
3055 if (av_q2d(st->time_base) > 0.0005)
3056 fps_analyze_framecount *= 2;
3057 if (!tb_unreliable(st->codec))
3058 fps_analyze_framecount = 0;
3059 if (ic->fps_probe_size >= 0)
3060 fps_analyze_framecount = ic->fps_probe_size;
3061 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3062 fps_analyze_framecount = 0;
3063 /* variable fps and no guess at the real fps */
3064 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3065 st->info->duration_count < fps_analyze_framecount &&
3066 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3068 if (st->parser && st->parser->parser->split &&
3069 !st->codec->extradata)
3071 if (st->first_dts == AV_NOPTS_VALUE &&
3072 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3073 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3074 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3077 if (i == ic->nb_streams) {
3078 /* NOTE: If the format has no header, then we need to read some
3079 * packets to get most of the streams, so we cannot stop here. */
3080 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3081 /* If we found the info for all the codecs, we can stop. */
3083 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3088 /* We did not get all the codec info, but we read too much data. */
3089 if (read_size >= probesize) {
3091 av_log(ic, AV_LOG_DEBUG,
3092 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3093 for (i = 0; i < ic->nb_streams; i++)
3094 if (!ic->streams[i]->r_frame_rate.num &&
3095 ic->streams[i]->info->duration_count <= 1 &&
3096 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3097 strcmp(ic->iformat->name, "image2"))
3098 av_log(ic, AV_LOG_WARNING,
3099 "Stream #%d: not enough frames to estimate rate; "
3100 "consider increasing probesize\n", i);
3104 /* NOTE: A new stream can be added there if no header in file
3105 * (AVFMTCTX_NOHEADER). */
3106 ret = read_frame_internal(ic, &pkt1);
3107 if (ret == AVERROR(EAGAIN))
3115 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3116 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3118 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3119 &ic->packet_buffer_end);
3121 ret = AVERROR(ENOMEM);
3122 goto find_stream_info_err;
3124 if ((ret = av_dup_packet(pkt)) < 0)
3125 goto find_stream_info_err;
3128 st = ic->streams[pkt->stream_index];
3129 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3130 read_size += pkt->size;
3132 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3133 /* check for non-increasing dts */
3134 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3135 st->info->fps_last_dts >= pkt->dts) {
3136 av_log(ic, AV_LOG_DEBUG,
3137 "Non-increasing DTS in stream %d: packet %d with DTS "
3138 "%"PRId64", packet %d with DTS %"PRId64"\n",
3139 st->index, st->info->fps_last_dts_idx,
3140 st->info->fps_last_dts, st->codec_info_nb_frames,
3142 st->info->fps_first_dts =
3143 st->info->fps_last_dts = AV_NOPTS_VALUE;
3145 /* Check for a discontinuity in dts. If the difference in dts
3146 * is more than 1000 times the average packet duration in the
3147 * sequence, we treat it as a discontinuity. */
3148 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3149 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3150 (pkt->dts - st->info->fps_last_dts) / 1000 >
3151 (st->info->fps_last_dts - st->info->fps_first_dts) /
3152 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3153 av_log(ic, AV_LOG_WARNING,
3154 "DTS discontinuity in stream %d: packet %d with DTS "
3155 "%"PRId64", packet %d with DTS %"PRId64"\n",
3156 st->index, st->info->fps_last_dts_idx,
3157 st->info->fps_last_dts, st->codec_info_nb_frames,
3159 st->info->fps_first_dts =
3160 st->info->fps_last_dts = AV_NOPTS_VALUE;
3163 /* update stored dts values */
3164 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3165 st->info->fps_first_dts = pkt->dts;
3166 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3168 st->info->fps_last_dts = pkt->dts;
3169 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3171 if (st->codec_info_nb_frames>1) {
3174 if (st->time_base.den > 0)
3175 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3176 if (st->avg_frame_rate.num > 0)
3177 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3180 && st->codec_info_nb_frames>30
3181 && st->info->fps_first_dts != AV_NOPTS_VALUE
3182 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3183 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3185 if (t >= max_analyze_duration) {
3186 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3187 max_analyze_duration,
3191 if (pkt->duration) {
3192 st->info->codec_info_duration += pkt->duration;
3193 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3196 #if FF_API_R_FRAME_RATE
3197 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3198 ff_rfps_add_frame(ic, st, pkt->dts);
3200 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3201 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3202 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3203 if (ff_alloc_extradata(st->codec, i))
3204 return AVERROR(ENOMEM);
3205 memcpy(st->codec->extradata, pkt->data,
3206 st->codec->extradata_size);
3210 /* If still no information, we try to open the codec and to
3211 * decompress the frame. We try to avoid that in most cases as
3212 * it takes longer and uses more memory. For MPEG-4, we need to
3213 * decompress for QuickTime.
3215 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3216 * least one frame of codec data, this makes sure the codec initializes
3217 * the channel configuration and does not only trust the values from
3219 try_decode_frame(ic, st, pkt,
3220 (options && i < orig_nb_streams) ? &options[i] : NULL);
3222 st->codec_info_nb_frames++;
3227 AVPacket empty_pkt = { 0 };
3229 av_init_packet(&empty_pkt);
3231 for (i = 0; i < ic->nb_streams; i++) {
3233 st = ic->streams[i];
3235 /* flush the decoders */
3236 if (st->info->found_decoder == 1) {
3238 err = try_decode_frame(ic, st, &empty_pkt,
3239 (options && i < orig_nb_streams)
3240 ? &options[i] : NULL);
3241 } while (err > 0 && !has_codec_parameters(st, NULL));
3244 av_log(ic, AV_LOG_INFO,
3245 "decoding for stream %d failed\n", st->index);
3250 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3252 // close codecs which were opened in try_decode_frame()
3253 for (i = 0; i < ic->nb_streams; i++) {
3254 st = ic->streams[i];
3255 avcodec_close(st->codec);
3258 ff_rfps_calculate(ic);
3260 for (i = 0; i < ic->nb_streams; i++) {
3261 st = ic->streams[i];
3262 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3263 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3264 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3265 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3266 st->codec->codec_tag= tag;
3269 /* estimate average framerate if not set by demuxer */
3270 if (st->info->codec_info_duration_fields &&
3271 !st->avg_frame_rate.num &&
3272 st->info->codec_info_duration) {
3274 double best_error = 0.01;
3276 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3277 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3278 st->info->codec_info_duration < 0)
3280 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3281 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3282 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3284 /* Round guessed framerate to a "standard" framerate if it's
3285 * within 1% of the original estimate. */
3286 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3287 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3288 double error = fabs(av_q2d(st->avg_frame_rate) /
3289 av_q2d(std_fps) - 1);
3291 if (error < best_error) {
3293 best_fps = std_fps.num;
3297 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3298 best_fps, 12 * 1001, INT_MAX);
3301 if (!st->r_frame_rate.num) {
3302 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3303 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3304 st->r_frame_rate.num = st->codec->time_base.den;
3305 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3307 st->r_frame_rate.num = st->time_base.den;
3308 st->r_frame_rate.den = st->time_base.num;
3311 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3312 if (!st->codec->bits_per_coded_sample)
3313 st->codec->bits_per_coded_sample =
3314 av_get_bits_per_sample(st->codec->codec_id);
3315 // set stream disposition based on audio service type
3316 switch (st->codec->audio_service_type) {
3317 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3318 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3320 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3321 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3323 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3324 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3326 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3327 st->disposition = AV_DISPOSITION_COMMENT;
3329 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3330 st->disposition = AV_DISPOSITION_KARAOKE;
3337 estimate_timings(ic, old_offset);
3339 if (ret >= 0 && ic->nb_streams)
3340 /* We could not have all the codec parameters before EOF. */
3342 for (i = 0; i < ic->nb_streams; i++) {
3344 st = ic->streams[i];
3345 if (!has_codec_parameters(st, &errmsg)) {
3347 avcodec_string(buf, sizeof(buf), st->codec, 0);
3348 av_log(ic, AV_LOG_WARNING,
3349 "Could not find codec parameters for stream %d (%s): %s\n"
3350 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3357 compute_chapters_end(ic);
3359 find_stream_info_err:
3360 for (i = 0; i < ic->nb_streams; i++) {
3361 st = ic->streams[i];
3362 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3363 ic->streams[i]->codec->thread_count = 0;
3365 av_freep(&st->info->duration_error);
3366 av_freep(&ic->streams[i]->info);
3369 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3370 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3374 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3378 for (i = 0; i < ic->nb_programs; i++) {
3379 if (ic->programs[i] == last) {
3383 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3384 if (ic->programs[i]->stream_index[j] == s)
3385 return ic->programs[i];
3391 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3392 int wanted_stream_nb, int related_stream,
3393 AVCodec **decoder_ret, int flags)
3395 int i, nb_streams = ic->nb_streams;
3396 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3397 unsigned *program = NULL;
3398 const AVCodec *decoder = NULL, *best_decoder = NULL;
3400 if (related_stream >= 0 && wanted_stream_nb < 0) {
3401 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3403 program = p->stream_index;
3404 nb_streams = p->nb_stream_indexes;
3407 for (i = 0; i < nb_streams; i++) {
3408 int real_stream_index = program ? program[i] : i;
3409 AVStream *st = ic->streams[real_stream_index];
3410 AVCodecContext *avctx = st->codec;
3411 if (avctx->codec_type != type)
3413 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3415 if (wanted_stream_nb != real_stream_index &&
3416 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3417 AV_DISPOSITION_VISUAL_IMPAIRED))
3419 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3422 decoder = find_decoder(ic, st, st->codec->codec_id);
3425 ret = AVERROR_DECODER_NOT_FOUND;
3429 count = st->codec_info_nb_frames;
3430 bitrate = avctx->bit_rate;
3432 bitrate = avctx->rc_max_rate;
3433 multiframe = FFMIN(5, count);
3434 if ((best_multiframe > multiframe) ||
3435 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3436 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3439 best_bitrate = bitrate;
3440 best_multiframe = multiframe;
3441 ret = real_stream_index;
3442 best_decoder = decoder;
3443 if (program && i == nb_streams - 1 && ret < 0) {
3445 nb_streams = ic->nb_streams;
3446 /* no related stream found, try again with everything */
3451 *decoder_ret = (AVCodec*)best_decoder;
3455 /*******************************************************/
3457 int av_read_play(AVFormatContext *s)
3459 if (s->iformat->read_play)
3460 return s->iformat->read_play(s);
3462 return avio_pause(s->pb, 0);
3463 return AVERROR(ENOSYS);
3466 int av_read_pause(AVFormatContext *s)
3468 if (s->iformat->read_pause)
3469 return s->iformat->read_pause(s);
3471 return avio_pause(s->pb, 1);
3472 return AVERROR(ENOSYS);
3475 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3477 av_assert0(s->nb_streams>0);
3478 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3480 for (j = 0; j < st->nb_side_data; j++)
3481 av_freep(&st->side_data[j].data);
3482 av_freep(&st->side_data);
3483 st->nb_side_data = 0;
3486 av_parser_close(st->parser);
3488 if (st->attached_pic.data)
3489 av_free_packet(&st->attached_pic);
3490 av_dict_free(&st->metadata);
3491 av_freep(&st->probe_data.buf);
3492 av_freep(&st->index_entries);
3493 av_freep(&st->codec->extradata);
3494 av_freep(&st->codec->subtitle_header);
3495 av_freep(&st->codec);
3496 av_freep(&st->priv_data);
3498 av_freep(&st->info->duration_error);
3499 av_freep(&st->info);
3500 av_freep(&s->streams[ --s->nb_streams ]);
3503 void avformat_free_context(AVFormatContext *s)
3511 if (s->iformat && s->iformat->priv_class && s->priv_data)
3512 av_opt_free(s->priv_data);
3513 if (s->oformat && s->oformat->priv_class && s->priv_data)
3514 av_opt_free(s->priv_data);
3516 for (i = s->nb_streams - 1; i >= 0; i--) {
3517 ff_free_stream(s, s->streams[i]);
3519 for (i = s->nb_programs - 1; i >= 0; i--) {
3520 av_dict_free(&s->programs[i]->metadata);
3521 av_freep(&s->programs[i]->stream_index);
3522 av_freep(&s->programs[i]);
3524 av_freep(&s->programs);
3525 av_freep(&s->priv_data);
3526 while (s->nb_chapters--) {
3527 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3528 av_freep(&s->chapters[s->nb_chapters]);
3530 av_freep(&s->chapters);
3531 av_dict_free(&s->metadata);
3532 av_freep(&s->streams);
3533 av_freep(&s->internal);
3537 #if FF_API_CLOSE_INPUT_FILE
3538 void av_close_input_file(AVFormatContext *s)
3540 avformat_close_input(&s);
3544 void avformat_close_input(AVFormatContext **ps)
3555 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3556 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3559 flush_packet_queue(s);
3562 if (s->iformat->read_close)
3563 s->iformat->read_close(s);
3565 avformat_free_context(s);
3572 #if FF_API_NEW_STREAM
3573 AVStream *av_new_stream(AVFormatContext *s, int id)
3575 AVStream *st = avformat_new_stream(s, NULL);
3582 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3588 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3590 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3593 s->streams = streams;
3595 st = av_mallocz(sizeof(AVStream));
3598 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3602 st->info->last_dts = AV_NOPTS_VALUE;
3604 st->codec = avcodec_alloc_context3(c);
3606 /* no default bitrate if decoding */
3607 st->codec->bit_rate = 0;
3609 /* default pts setting is MPEG-like */
3610 avpriv_set_pts_info(st, 33, 1, 90000);
3613 st->index = s->nb_streams;
3614 st->start_time = AV_NOPTS_VALUE;
3615 st->duration = AV_NOPTS_VALUE;
3616 /* we set the current DTS to 0 so that formats without any timestamps
3617 * but durations get some timestamps, formats with some unknown
3618 * timestamps have their first few packets buffered and the
3619 * timestamps corrected before they are returned to the user */
3620 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3621 st->first_dts = AV_NOPTS_VALUE;
3622 st->probe_packets = MAX_PROBE_PACKETS;
3623 st->pts_wrap_reference = AV_NOPTS_VALUE;
3624 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3626 st->last_IP_pts = AV_NOPTS_VALUE;
3627 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3628 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3629 st->pts_buffer[i] = AV_NOPTS_VALUE;
3631 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3633 #if FF_API_R_FRAME_RATE
3634 st->info->last_dts = AV_NOPTS_VALUE;
3636 st->info->fps_first_dts = AV_NOPTS_VALUE;
3637 st->info->fps_last_dts = AV_NOPTS_VALUE;
3639 st->inject_global_side_data = s->internal->inject_global_side_data;
3641 s->streams[s->nb_streams++] = st;
3645 AVProgram *av_new_program(AVFormatContext *ac, int id)
3647 AVProgram *program = NULL;
3650 av_dlog(ac, "new_program: id=0x%04x\n", id);
3652 for (i = 0; i < ac->nb_programs; i++)
3653 if (ac->programs[i]->id == id)
3654 program = ac->programs[i];
3657 program = av_mallocz(sizeof(AVProgram));
3660 dynarray_add(&ac->programs, &ac->nb_programs, program);
3661 program->discard = AVDISCARD_NONE;
3664 program->pts_wrap_reference = AV_NOPTS_VALUE;
3665 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3667 program->start_time =
3668 program->end_time = AV_NOPTS_VALUE;
3673 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3674 int64_t start, int64_t end, const char *title)
3676 AVChapter *chapter = NULL;
3679 if (end != AV_NOPTS_VALUE && start > end) {
3680 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3684 for (i = 0; i < s->nb_chapters; i++)
3685 if (s->chapters[i]->id == id)
3686 chapter = s->chapters[i];
3689 chapter = av_mallocz(sizeof(AVChapter));
3692 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3694 av_dict_set(&chapter->metadata, "title", title, 0);
3696 chapter->time_base = time_base;
3697 chapter->start = start;
3703 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3706 AVProgram *program = NULL;
3709 if (idx >= ac->nb_streams) {
3710 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3714 for (i = 0; i < ac->nb_programs; i++) {
3715 if (ac->programs[i]->id != progid)
3717 program = ac->programs[i];
3718 for (j = 0; j < program->nb_stream_indexes; j++)
3719 if (program->stream_index[j] == idx)
3722 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3725 program->stream_index = tmp;
3726 program->stream_index[program->nb_stream_indexes++] = idx;
3731 uint64_t ff_ntp_time(void)
3733 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3736 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3739 char *q, buf1[20], c;
3740 int nd, len, percentd_found;
3752 while (av_isdigit(*p))
3753 nd = nd * 10 + *p++ - '0';
3755 } while (av_isdigit(c));
3764 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3766 if ((q - buf + len) > buf_size - 1)
3768 memcpy(q, buf1, len);
3776 if ((q - buf) < buf_size - 1)
3780 if (!percentd_found)
3789 void av_url_split(char *proto, int proto_size,
3790 char *authorization, int authorization_size,
3791 char *hostname, int hostname_size,
3792 int *port_ptr, char *path, int path_size, const char *url)
3794 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3800 if (authorization_size > 0)
3801 authorization[0] = 0;
3802 if (hostname_size > 0)
3807 /* parse protocol */
3808 if ((p = strchr(url, ':'))) {
3809 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3816 /* no protocol means plain filename */
3817 av_strlcpy(path, url, path_size);
3821 /* separate path from hostname */
3822 ls = strchr(p, '/');
3823 ls2 = strchr(p, '?');
3827 ls = FFMIN(ls, ls2);
3829 av_strlcpy(path, ls, path_size);
3831 ls = &p[strlen(p)]; // XXX
3833 /* the rest is hostname, use that to parse auth/port */
3835 /* authorization (user[:pass]@hostname) */
3837 while ((at = strchr(p, '@')) && at < ls) {
3838 av_strlcpy(authorization, at2,
3839 FFMIN(authorization_size, at + 1 - at2));
3840 p = at + 1; /* skip '@' */
3843 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3845 av_strlcpy(hostname, p + 1,
3846 FFMIN(hostname_size, brk - p));
3847 if (brk[1] == ':' && port_ptr)
3848 *port_ptr = atoi(brk + 2);
3849 } else if ((col = strchr(p, ':')) && col < ls) {
3850 av_strlcpy(hostname, p,
3851 FFMIN(col + 1 - p, hostname_size));
3853 *port_ptr = atoi(col + 1);
3855 av_strlcpy(hostname, p,
3856 FFMIN(ls + 1 - p, hostname_size));
3860 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3863 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3866 'C', 'D', 'E', 'F' };
3867 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3870 'c', 'd', 'e', 'f' };
3871 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3873 for (i = 0; i < s; i++) {
3874 buff[i * 2] = hex_table[src[i] >> 4];
3875 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3881 int ff_hex_to_data(uint8_t *data, const char *p)
3888 p += strspn(p, SPACE_CHARS);
3891 c = av_toupper((unsigned char) *p++);
3892 if (c >= '0' && c <= '9')
3894 else if (c >= 'A' && c <= 'F')
3909 #if FF_API_SET_PTS_INFO
3910 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3911 unsigned int pts_num, unsigned int pts_den)
3913 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3917 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3918 unsigned int pts_num, unsigned int pts_den)
3921 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3922 if (new_tb.num != pts_num)
3923 av_log(NULL, AV_LOG_DEBUG,
3924 "st:%d removing common factor %d from timebase\n",
3925 s->index, pts_num / new_tb.num);
3927 av_log(NULL, AV_LOG_WARNING,
3928 "st:%d has too large timebase, reducing\n", s->index);
3930 if (new_tb.num <= 0 || new_tb.den <= 0) {
3931 av_log(NULL, AV_LOG_ERROR,
3932 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3933 new_tb.num, new_tb.den,
3937 s->time_base = new_tb;
3938 av_codec_set_pkt_timebase(s->codec, new_tb);
3939 s->pts_wrap_bits = pts_wrap_bits;
3942 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3945 const char *ptr = str;
3947 /* Parse key=value pairs. */
3950 char *dest = NULL, *dest_end;
3951 int key_len, dest_len = 0;
3953 /* Skip whitespace and potential commas. */
3954 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3961 if (!(ptr = strchr(key, '=')))
3964 key_len = ptr - key;
3966 callback_get_buf(context, key, key_len, &dest, &dest_len);
3967 dest_end = dest + dest_len - 1;
3971 while (*ptr && *ptr != '\"') {
3975 if (dest && dest < dest_end)
3979 if (dest && dest < dest_end)
3987 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3988 if (dest && dest < dest_end)
3996 int ff_find_stream_index(AVFormatContext *s, int id)
3999 for (i = 0; i < s->nb_streams; i++)
4000 if (s->streams[i]->id == id)
4005 int64_t ff_iso8601_to_unix_time(const char *datestr)
4007 struct tm time1 = { 0 }, time2 = { 0 };
4009 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4010 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4012 return av_timegm(&time2);
4014 return av_timegm(&time1);
4017 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4021 if (ofmt->query_codec)
4022 return ofmt->query_codec(codec_id, std_compliance);
4023 else if (ofmt->codec_tag)
4024 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4025 else if (codec_id == ofmt->video_codec ||
4026 codec_id == ofmt->audio_codec ||
4027 codec_id == ofmt->subtitle_codec)
4030 return AVERROR_PATCHWELCOME;
4033 int avformat_network_init(void)
4037 ff_network_inited_globally = 1;
4038 if ((ret = ff_network_init()) < 0)
4045 int avformat_network_deinit(void)
4054 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4055 uint64_t channel_layout, int32_t sample_rate,
4056 int32_t width, int32_t height)
4062 return AVERROR(EINVAL);
4065 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4067 if (channel_layout) {
4069 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4073 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4075 if (width || height) {
4077 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4079 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4081 return AVERROR(ENOMEM);
4082 bytestream_put_le32(&data, flags);
4084 bytestream_put_le32(&data, channels);
4086 bytestream_put_le64(&data, channel_layout);
4088 bytestream_put_le32(&data, sample_rate);
4089 if (width || height) {
4090 bytestream_put_le32(&data, width);
4091 bytestream_put_le32(&data, height);
4096 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4098 AVRational undef = {0, 1};
4099 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4100 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4101 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4103 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4104 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4105 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4106 stream_sample_aspect_ratio = undef;
4108 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4109 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4110 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4111 frame_sample_aspect_ratio = undef;
4113 if (stream_sample_aspect_ratio.num)
4114 return stream_sample_aspect_ratio;
4116 return frame_sample_aspect_ratio;
4119 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4121 AVRational fr = st->r_frame_rate;
4122 AVRational codec_fr = av_inv_q(st->codec->time_base);
4123 AVRational avg_fr = st->avg_frame_rate;
4125 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4126 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4131 if (st->codec->ticks_per_frame > 1) {
4132 codec_fr.den *= st->codec->ticks_per_frame;
4133 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4134 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4141 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4144 if (*spec <= '9' && *spec >= '0') /* opt:index */
4145 return strtol(spec, NULL, 0) == st->index;
4146 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4147 *spec == 't') { /* opt:[vasdt] */
4148 enum AVMediaType type;
4151 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4152 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4153 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4154 case 'd': type = AVMEDIA_TYPE_DATA; break;
4155 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4156 default: av_assert0(0);
4158 if (type != st->codec->codec_type)
4160 if (*spec++ == ':') { /* possibly followed by :index */
4161 int i, index = strtol(spec, NULL, 0);
4162 for (i = 0; i < s->nb_streams; i++)
4163 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4164 return i == st->index;
4168 } else if (*spec == 'p' && *(spec + 1) == ':') {
4172 prog_id = strtol(spec, &endptr, 0);
4173 for (i = 0; i < s->nb_programs; i++) {
4174 if (s->programs[i]->id != prog_id)
4177 if (*endptr++ == ':') {
4178 int stream_idx = strtol(endptr, NULL, 0);
4179 return stream_idx >= 0 &&
4180 stream_idx < s->programs[i]->nb_stream_indexes &&
4181 st->index == s->programs[i]->stream_index[stream_idx];
4184 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4185 if (st->index == s->programs[i]->stream_index[j])
4189 } else if (*spec == '#' ||
4190 (*spec == 'i' && *(spec + 1) == ':')) {
4193 spec += 1 + (*spec == 'i');
4194 stream_id = strtol(spec, &endptr, 0);
4196 return stream_id == st->id;
4197 } else if (!*spec) /* empty specifier, matches everything */
4200 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4201 return AVERROR(EINVAL);
4204 int ff_generate_avci_extradata(AVStream *st)
4206 static const uint8_t avci100_1080p_extradata[] = {
4208 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4209 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4210 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4211 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4212 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4213 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4214 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4215 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4216 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4218 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4221 static const uint8_t avci100_1080i_extradata[] = {
4223 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4224 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4225 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4226 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4227 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4228 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4229 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4230 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4231 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4232 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4233 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4235 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4238 static const uint8_t avci50_1080i_extradata[] = {
4240 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4241 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4242 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4243 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4244 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4245 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4246 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4247 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4248 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4249 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4250 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4252 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4255 static const uint8_t avci100_720p_extradata[] = {
4257 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4258 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4259 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4260 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4261 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4262 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4263 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4264 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4265 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4266 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4268 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4272 const uint8_t *data = NULL;
4275 if (st->codec->width == 1920) {
4276 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4277 data = avci100_1080p_extradata;
4278 size = sizeof(avci100_1080p_extradata);
4280 data = avci100_1080i_extradata;
4281 size = sizeof(avci100_1080i_extradata);
4283 } else if (st->codec->width == 1440) {
4284 data = avci50_1080i_extradata;
4285 size = sizeof(avci50_1080i_extradata);
4286 } else if (st->codec->width == 1280) {
4287 data = avci100_720p_extradata;
4288 size = sizeof(avci100_720p_extradata);
4294 av_freep(&st->codec->extradata);
4295 if (ff_alloc_extradata(st->codec, size))
4296 return AVERROR(ENOMEM);
4297 memcpy(st->codec->extradata, data, size);
4302 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4307 for (i = 0; i < st->nb_side_data; i++) {
4308 if (st->side_data[i].type == type) {
4310 *size = st->side_data[i].size;
4311 return st->side_data[i].data;