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)
695 /**********************************************************/
697 static int determinable_frame_size(AVCodecContext *avctx)
699 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
700 avctx->codec_id == AV_CODEC_ID_MP1 ||
701 avctx->codec_id == AV_CODEC_ID_MP2 ||
702 avctx->codec_id == AV_CODEC_ID_MP3/* ||
703 avctx->codec_id == AV_CODEC_ID_CELT*/)
709 * Return the frame duration in seconds. Return 0 if not available.
711 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
712 AVCodecParserContext *pc, AVPacket *pkt)
718 switch (st->codec->codec_type) {
719 case AVMEDIA_TYPE_VIDEO:
720 if (st->r_frame_rate.num && !pc) {
721 *pnum = st->r_frame_rate.den;
722 *pden = st->r_frame_rate.num;
723 } else if (st->time_base.num * 1000LL > st->time_base.den) {
724 *pnum = st->time_base.num;
725 *pden = st->time_base.den;
726 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
727 *pnum = st->codec->time_base.num;
728 *pden = st->codec->time_base.den;
729 if (pc && pc->repeat_pict) {
730 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
731 *pden /= 1 + pc->repeat_pict;
733 *pnum *= 1 + pc->repeat_pict;
735 /* If this codec can be interlaced or progressive then we need
736 * a parser to compute duration of a packet. Thus if we have
737 * no parser in such case leave duration undefined. */
738 if (st->codec->ticks_per_frame > 1 && !pc)
742 case AVMEDIA_TYPE_AUDIO:
743 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
744 if (frame_size <= 0 || st->codec->sample_rate <= 0)
747 *pden = st->codec->sample_rate;
754 static int is_intra_only(AVCodecContext *enc) {
755 const AVCodecDescriptor *desc;
757 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
760 desc = av_codec_get_codec_descriptor(enc);
762 desc = avcodec_descriptor_get(enc->codec_id);
763 av_codec_set_codec_descriptor(enc, desc);
766 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
770 static int has_decode_delay_been_guessed(AVStream *st)
772 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
773 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
775 #if CONFIG_H264_DECODER
776 if (st->codec->has_b_frames &&
777 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
780 if (st->codec->has_b_frames<3)
781 return st->nb_decoded_frames >= 7;
782 else if (st->codec->has_b_frames<4)
783 return st->nb_decoded_frames >= 18;
785 return st->nb_decoded_frames >= 20;
788 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
792 if (pktl == s->packet_buffer_end)
793 return s->parse_queue;
797 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
798 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
799 st->codec->codec_id != AV_CODEC_ID_HEVC;
802 int delay = st->codec->has_b_frames;
805 if (dts == AV_NOPTS_VALUE) {
806 int64_t best_score = INT64_MAX;
807 for (i = 0; i<delay; i++) {
808 if (st->pts_reorder_error_count[i]) {
809 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
810 if (score < best_score) {
817 for (i = 0; i<delay; i++) {
818 if (pts_buffer[i] != AV_NOPTS_VALUE) {
819 int64_t diff = FFABS(pts_buffer[i] - dts)
820 + (uint64_t)st->pts_reorder_error[i];
821 diff = FFMAX(diff, st->pts_reorder_error[i]);
822 st->pts_reorder_error[i] = diff;
823 st->pts_reorder_error_count[i]++;
824 if (st->pts_reorder_error_count[i] > 250) {
825 st->pts_reorder_error[i] >>= 1;
826 st->pts_reorder_error_count[i] >>= 1;
833 if (dts == AV_NOPTS_VALUE)
839 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
840 int64_t dts, int64_t pts, AVPacket *pkt)
842 AVStream *st = s->streams[stream_index];
843 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
844 int64_t pts_buffer[MAX_REORDER_DELAY+1];
848 if (st->first_dts != AV_NOPTS_VALUE ||
849 dts == AV_NOPTS_VALUE ||
850 st->cur_dts == AV_NOPTS_VALUE ||
854 delay = st->codec->has_b_frames;
855 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
857 shift = st->first_dts - RELATIVE_TS_BASE;
859 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
860 pts_buffer[i] = AV_NOPTS_VALUE;
862 if (is_relative(pts))
865 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
866 if (pktl->pkt.stream_index != stream_index)
868 if (is_relative(pktl->pkt.pts))
869 pktl->pkt.pts += shift;
871 if (is_relative(pktl->pkt.dts))
872 pktl->pkt.dts += shift;
874 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
875 st->start_time = pktl->pkt.pts;
877 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
878 pts_buffer[0] = pktl->pkt.pts;
879 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
880 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
882 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
886 if (st->start_time == AV_NOPTS_VALUE)
887 st->start_time = pts;
890 static void update_initial_durations(AVFormatContext *s, AVStream *st,
891 int stream_index, int duration)
893 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
894 int64_t cur_dts = RELATIVE_TS_BASE;
896 if (st->first_dts != AV_NOPTS_VALUE) {
897 if (st->update_initial_durations_done)
899 st->update_initial_durations_done = 1;
900 cur_dts = st->first_dts;
901 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
902 if (pktl->pkt.stream_index == stream_index) {
903 if (pktl->pkt.pts != pktl->pkt.dts ||
904 pktl->pkt.dts != AV_NOPTS_VALUE ||
910 if (pktl && pktl->pkt.dts != st->first_dts) {
911 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
912 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
916 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
919 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
920 st->first_dts = cur_dts;
921 } else if (st->cur_dts != RELATIVE_TS_BASE)
924 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
925 if (pktl->pkt.stream_index != stream_index)
927 if (pktl->pkt.pts == pktl->pkt.dts &&
928 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
929 !pktl->pkt.duration) {
930 pktl->pkt.dts = cur_dts;
931 if (!st->codec->has_b_frames)
932 pktl->pkt.pts = cur_dts;
933 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
934 pktl->pkt.duration = duration;
937 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
940 st->cur_dts = cur_dts;
943 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
944 AVCodecParserContext *pc, AVPacket *pkt)
946 int num, den, presentation_delayed, delay, i;
949 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
950 st->codec->codec_id != AV_CODEC_ID_HEVC;
952 if (s->flags & AVFMT_FLAG_NOFILLIN)
955 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
956 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
957 if (st->last_dts_for_order_check <= pkt->dts) {
960 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
961 "DTS %"PRIi64" < %"PRIi64" out of order\n",
963 st->last_dts_for_order_check);
964 st->dts_misordered++;
966 if (st->dts_ordered + st->dts_misordered > 250) {
967 st->dts_ordered >>= 1;
968 st->dts_misordered >>= 1;
972 st->last_dts_for_order_check = pkt->dts;
973 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
974 pkt->dts = AV_NOPTS_VALUE;
977 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
978 pkt->dts = AV_NOPTS_VALUE;
980 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
981 && !st->codec->has_b_frames)
982 //FIXME Set low_delay = 0 when has_b_frames = 1
983 st->codec->has_b_frames = 1;
985 /* do we have a video B-frame ? */
986 delay = st->codec->has_b_frames;
987 presentation_delayed = 0;
989 /* XXX: need has_b_frame, but cannot get it if the codec is
992 pc && pc->pict_type != AV_PICTURE_TYPE_B)
993 presentation_delayed = 1;
995 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
996 st->pts_wrap_bits < 63 &&
997 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
998 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
999 pkt->dts -= 1LL << st->pts_wrap_bits;
1001 pkt->pts += 1LL << st->pts_wrap_bits;
1004 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1005 * We take the conservative approach and discard both.
1006 * Note: If this is misbehaving for an H.264 file, then possibly
1007 * presentation_delayed is not set correctly. */
1008 if (delay == 1 && pkt->dts == pkt->pts &&
1009 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1010 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1011 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1012 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1013 pkt->dts = AV_NOPTS_VALUE;
1016 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1017 if (pkt->duration == 0) {
1018 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1020 duration = (AVRational) {num, den};
1021 pkt->duration = av_rescale_rnd(1,
1022 num * (int64_t) st->time_base.den,
1023 den * (int64_t) st->time_base.num,
1028 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1029 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1031 /* Correct timestamps with byte offset if demuxers only have timestamps
1032 * on packet boundaries */
1033 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1034 /* this will estimate bitrate based on this frame's duration and size */
1035 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1036 if (pkt->pts != AV_NOPTS_VALUE)
1038 if (pkt->dts != AV_NOPTS_VALUE)
1042 /* This may be redundant, but it should not hurt. */
1043 if (pkt->dts != AV_NOPTS_VALUE &&
1044 pkt->pts != AV_NOPTS_VALUE &&
1045 pkt->pts > pkt->dts)
1046 presentation_delayed = 1;
1049 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1050 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1051 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1052 /* Interpolate PTS and DTS if they are not present. We skip H264
1053 * currently because delay and has_b_frames are not reliably set. */
1054 if ((delay == 0 || (delay == 1 && pc)) &&
1056 if (presentation_delayed) {
1057 /* DTS = decompression timestamp */
1058 /* PTS = presentation timestamp */
1059 if (pkt->dts == AV_NOPTS_VALUE)
1060 pkt->dts = st->last_IP_pts;
1061 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1062 if (pkt->dts == AV_NOPTS_VALUE)
1063 pkt->dts = st->cur_dts;
1065 /* This is tricky: the dts must be incremented by the duration
1066 * of the frame we are displaying, i.e. the last I- or P-frame. */
1067 if (st->last_IP_duration == 0)
1068 st->last_IP_duration = pkt->duration;
1069 if (pkt->dts != AV_NOPTS_VALUE)
1070 st->cur_dts = pkt->dts + st->last_IP_duration;
1071 st->last_IP_duration = pkt->duration;
1072 st->last_IP_pts = pkt->pts;
1073 /* Cannot compute PTS if not present (we can compute it only
1074 * by knowing the future. */
1075 } else if (pkt->pts != AV_NOPTS_VALUE ||
1076 pkt->dts != AV_NOPTS_VALUE ||
1079 /* presentation is not delayed : PTS and DTS are the same */
1080 if (pkt->pts == AV_NOPTS_VALUE)
1081 pkt->pts = pkt->dts;
1082 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1084 if (pkt->pts == AV_NOPTS_VALUE)
1085 pkt->pts = st->cur_dts;
1086 pkt->dts = pkt->pts;
1087 if (pkt->pts != AV_NOPTS_VALUE)
1088 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1092 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1093 st->pts_buffer[0] = pkt->pts;
1094 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1095 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1097 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1099 // We skipped it above so we try here.
1101 // This should happen on the first packet
1102 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1103 if (pkt->dts > st->cur_dts)
1104 st->cur_dts = pkt->dts;
1106 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1107 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1110 if (is_intra_only(st->codec))
1111 pkt->flags |= AV_PKT_FLAG_KEY;
1113 pkt->convergence_duration = pc->convergence_duration;
1116 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1119 AVPacketList *pktl = *pkt_buf;
1120 *pkt_buf = pktl->next;
1121 av_free_packet(&pktl->pkt);
1124 *pkt_buf_end = NULL;
1128 * Parse a packet, add all split parts to parse_queue.
1130 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1132 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1134 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1135 AVStream *st = s->streams[stream_index];
1136 uint8_t *data = pkt ? pkt->data : NULL;
1137 int size = pkt ? pkt->size : 0;
1138 int ret = 0, got_output = 0;
1141 av_init_packet(&flush_pkt);
1144 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1145 // preserve 0-size sync packets
1146 compute_pkt_fields(s, st, st->parser, pkt);
1149 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1152 av_init_packet(&out_pkt);
1153 len = av_parser_parse2(st->parser, st->codec,
1154 &out_pkt.data, &out_pkt.size, data, size,
1155 pkt->pts, pkt->dts, pkt->pos);
1157 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1159 /* increment read pointer */
1163 got_output = !!out_pkt.size;
1168 if (pkt->side_data) {
1169 out_pkt.side_data = pkt->side_data;
1170 out_pkt.side_data_elems = pkt->side_data_elems;
1171 pkt->side_data = NULL;
1172 pkt->side_data_elems = 0;
1175 /* set the duration */
1176 out_pkt.duration = 0;
1177 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1178 if (st->codec->sample_rate > 0) {
1180 av_rescale_q_rnd(st->parser->duration,
1181 (AVRational) { 1, st->codec->sample_rate },
1187 out_pkt.stream_index = st->index;
1188 out_pkt.pts = st->parser->pts;
1189 out_pkt.dts = st->parser->dts;
1190 out_pkt.pos = st->parser->pos;
1192 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1193 out_pkt.pos = st->parser->frame_offset;
1195 if (st->parser->key_frame == 1 ||
1196 (st->parser->key_frame == -1 &&
1197 st->parser->pict_type == AV_PICTURE_TYPE_I))
1198 out_pkt.flags |= AV_PKT_FLAG_KEY;
1200 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1201 out_pkt.flags |= AV_PKT_FLAG_KEY;
1203 compute_pkt_fields(s, st, st->parser, &out_pkt);
1205 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1206 out_pkt.buf = pkt->buf;
1208 #if FF_API_DESTRUCT_PACKET
1209 FF_DISABLE_DEPRECATION_WARNINGS
1210 out_pkt.destruct = pkt->destruct;
1211 pkt->destruct = NULL;
1212 FF_ENABLE_DEPRECATION_WARNINGS
1215 if ((ret = av_dup_packet(&out_pkt)) < 0)
1218 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1219 av_free_packet(&out_pkt);
1220 ret = AVERROR(ENOMEM);
1225 /* end of the stream => close and free the parser */
1226 if (pkt == &flush_pkt) {
1227 av_parser_close(st->parser);
1232 av_free_packet(pkt);
1236 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1237 AVPacketList **pkt_buffer_end,
1241 av_assert0(*pkt_buffer);
1244 *pkt_buffer = pktl->next;
1246 *pkt_buffer_end = NULL;
1251 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1253 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1256 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1258 int ret = 0, i, got_packet = 0;
1259 AVDictionary *metadata = NULL;
1261 av_init_packet(pkt);
1263 while (!got_packet && !s->parse_queue) {
1267 /* read next packet */
1268 ret = ff_read_packet(s, &cur_pkt);
1270 if (ret == AVERROR(EAGAIN))
1272 /* flush the parsers */
1273 for (i = 0; i < s->nb_streams; i++) {
1275 if (st->parser && st->need_parsing)
1276 parse_packet(s, NULL, st->index);
1278 /* all remaining packets are now in parse_queue =>
1279 * really terminate parsing */
1283 st = s->streams[cur_pkt.stream_index];
1285 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1286 cur_pkt.dts != AV_NOPTS_VALUE &&
1287 cur_pkt.pts < cur_pkt.dts) {
1288 av_log(s, AV_LOG_WARNING,
1289 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1290 cur_pkt.stream_index,
1291 av_ts2str(cur_pkt.pts),
1292 av_ts2str(cur_pkt.dts),
1295 if (s->debug & FF_FDEBUG_TS)
1296 av_log(s, AV_LOG_DEBUG,
1297 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1298 cur_pkt.stream_index,
1299 av_ts2str(cur_pkt.pts),
1300 av_ts2str(cur_pkt.dts),
1301 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1303 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1304 st->parser = av_parser_init(st->codec->codec_id);
1306 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1307 "%s, packets or times may be invalid.\n",
1308 avcodec_get_name(st->codec->codec_id));
1309 /* no parser available: just output the raw packets */
1310 st->need_parsing = AVSTREAM_PARSE_NONE;
1311 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1312 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1313 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1314 st->parser->flags |= PARSER_FLAG_ONCE;
1315 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1316 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1319 if (!st->need_parsing || !st->parser) {
1320 /* no parsing needed: we just output the packet as is */
1322 compute_pkt_fields(s, st, NULL, pkt);
1323 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1324 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1325 ff_reduce_index(s, st->index);
1326 av_add_index_entry(st, pkt->pos, pkt->dts,
1327 0, 0, AVINDEX_KEYFRAME);
1330 } else if (st->discard < AVDISCARD_ALL) {
1331 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1335 av_free_packet(&cur_pkt);
1337 if (pkt->flags & AV_PKT_FLAG_KEY)
1338 st->skip_to_keyframe = 0;
1339 if (st->skip_to_keyframe) {
1340 av_free_packet(&cur_pkt);
1348 if (!got_packet && s->parse_queue)
1349 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1352 AVStream *st = s->streams[pkt->stream_index];
1353 int discard_padding = 0;
1354 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1355 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1356 int64_t sample = ts_to_samples(st, pts);
1357 int duration = ts_to_samples(st, pkt->duration);
1358 int64_t end_sample = sample + duration;
1359 if (duration > 0 && end_sample >= st->first_discard_sample &&
1360 sample < st->last_discard_sample)
1361 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1363 if (st->skip_samples || discard_padding) {
1364 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1366 AV_WL32(p, st->skip_samples);
1367 AV_WL32(p + 4, discard_padding);
1368 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1370 st->skip_samples = 0;
1373 if (st->inject_global_side_data) {
1374 for (i = 0; i < st->nb_side_data; i++) {
1375 AVPacketSideData *src_sd = &st->side_data[i];
1378 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1381 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1383 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1387 memcpy(dst_data, src_sd->data, src_sd->size);
1389 st->inject_global_side_data = 0;
1392 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1393 av_packet_merge_side_data(pkt);
1396 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1398 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1399 av_dict_copy(&s->metadata, metadata, 0);
1400 av_dict_free(&metadata);
1401 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1404 if (s->debug & FF_FDEBUG_TS)
1405 av_log(s, AV_LOG_DEBUG,
1406 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1407 "size=%d, duration=%d, flags=%d\n",
1409 av_ts2str(pkt->pts),
1410 av_ts2str(pkt->dts),
1411 pkt->size, pkt->duration, pkt->flags);
1416 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1418 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1424 ret = s->packet_buffer
1425 ? read_from_packet_buffer(&s->packet_buffer,
1426 &s->packet_buffer_end, pkt)
1427 : read_frame_internal(s, pkt);
1434 AVPacketList *pktl = s->packet_buffer;
1437 AVPacket *next_pkt = &pktl->pkt;
1439 if (next_pkt->dts != AV_NOPTS_VALUE) {
1440 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1441 // last dts seen for this stream. if any of packets following
1442 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1443 int64_t last_dts = next_pkt->dts;
1444 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1445 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1446 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1447 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1449 next_pkt->pts = pktl->pkt.dts;
1451 if (last_dts != AV_NOPTS_VALUE) {
1452 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1453 last_dts = pktl->pkt.dts;
1458 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1459 // Fixing the last reference frame had none pts issue (For MXF etc).
1460 // We only do this when
1462 // 2. we are not able to resolve a pts value for current packet.
1463 // 3. the packets for this stream at the end of the files had valid dts.
1464 next_pkt->pts = last_dts + next_pkt->duration;
1466 pktl = s->packet_buffer;
1469 /* read packet from packet buffer, if there is data */
1470 st = s->streams[next_pkt->stream_index];
1471 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1472 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1473 ret = read_from_packet_buffer(&s->packet_buffer,
1474 &s->packet_buffer_end, pkt);
1479 ret = read_frame_internal(s, pkt);
1481 if (pktl && ret != AVERROR(EAGAIN)) {
1488 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1489 &s->packet_buffer_end)) < 0)
1490 return AVERROR(ENOMEM);
1495 st = s->streams[pkt->stream_index];
1496 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1497 ff_reduce_index(s, st->index);
1498 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1501 if (is_relative(pkt->dts))
1502 pkt->dts -= RELATIVE_TS_BASE;
1503 if (is_relative(pkt->pts))
1504 pkt->pts -= RELATIVE_TS_BASE;
1509 /* XXX: suppress the packet queue */
1510 static void flush_packet_queue(AVFormatContext *s)
1512 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1513 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1514 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1516 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1519 /*******************************************************/
1522 int av_find_default_stream_index(AVFormatContext *s)
1526 int best_stream = 0;
1527 int best_score = -1;
1529 if (s->nb_streams <= 0)
1531 for (i = 0; i < s->nb_streams; i++) {
1534 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1535 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1536 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1541 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1542 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1548 if (score > best_score) {
1556 /** Flush the frame reader. */
1557 void ff_read_frame_flush(AVFormatContext *s)
1562 flush_packet_queue(s);
1564 /* Reset read state for each stream. */
1565 for (i = 0; i < s->nb_streams; i++) {
1569 av_parser_close(st->parser);
1572 st->last_IP_pts = AV_NOPTS_VALUE;
1573 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1574 if (st->first_dts == AV_NOPTS_VALUE)
1575 st->cur_dts = RELATIVE_TS_BASE;
1577 /* We set the current DTS to an unspecified origin. */
1578 st->cur_dts = AV_NOPTS_VALUE;
1580 st->probe_packets = MAX_PROBE_PACKETS;
1582 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1583 st->pts_buffer[j] = AV_NOPTS_VALUE;
1585 if (s->internal->inject_global_side_data)
1586 st->inject_global_side_data = 1;
1590 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1594 for (i = 0; i < s->nb_streams; i++) {
1595 AVStream *st = s->streams[i];
1598 av_rescale(timestamp,
1599 st->time_base.den * (int64_t) ref_st->time_base.num,
1600 st->time_base.num * (int64_t) ref_st->time_base.den);
1604 void ff_reduce_index(AVFormatContext *s, int stream_index)
1606 AVStream *st = s->streams[stream_index];
1607 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1609 if ((unsigned) st->nb_index_entries >= max_entries) {
1611 for (i = 0; 2 * i < st->nb_index_entries; i++)
1612 st->index_entries[i] = st->index_entries[2 * i];
1613 st->nb_index_entries = i;
1617 int ff_add_index_entry(AVIndexEntry **index_entries,
1618 int *nb_index_entries,
1619 unsigned int *index_entries_allocated_size,
1620 int64_t pos, int64_t timestamp,
1621 int size, int distance, int flags)
1623 AVIndexEntry *entries, *ie;
1626 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1629 if (timestamp == AV_NOPTS_VALUE)
1630 return AVERROR(EINVAL);
1632 if (size < 0 || size > 0x3FFFFFFF)
1633 return AVERROR(EINVAL);
1635 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1636 timestamp -= RELATIVE_TS_BASE;
1638 entries = av_fast_realloc(*index_entries,
1639 index_entries_allocated_size,
1640 (*nb_index_entries + 1) *
1641 sizeof(AVIndexEntry));
1645 *index_entries = entries;
1647 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1648 timestamp, AVSEEK_FLAG_ANY);
1651 index = (*nb_index_entries)++;
1652 ie = &entries[index];
1653 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1655 ie = &entries[index];
1656 if (ie->timestamp != timestamp) {
1657 if (ie->timestamp <= timestamp)
1659 memmove(entries + index + 1, entries + index,
1660 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1661 (*nb_index_entries)++;
1662 } else if (ie->pos == pos && distance < ie->min_distance)
1663 // do not reduce the distance
1664 distance = ie->min_distance;
1668 ie->timestamp = timestamp;
1669 ie->min_distance = distance;
1676 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1677 int size, int distance, int flags)
1679 timestamp = wrap_timestamp(st, timestamp);
1680 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1681 &st->index_entries_allocated_size, pos,
1682 timestamp, size, distance, flags);
1685 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1686 int64_t wanted_timestamp, int flags)
1694 // Optimize appending index entries at the end.
1695 if (b && entries[b - 1].timestamp < wanted_timestamp)
1700 timestamp = entries[m].timestamp;
1701 if (timestamp >= wanted_timestamp)
1703 if (timestamp <= wanted_timestamp)
1706 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1708 if (!(flags & AVSEEK_FLAG_ANY))
1709 while (m >= 0 && m < nb_entries &&
1710 !(entries[m].flags & AVINDEX_KEYFRAME))
1711 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1713 if (m == nb_entries)
1718 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1720 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1721 wanted_timestamp, flags);
1724 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1725 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1727 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1728 if (stream_index >= 0)
1729 ts = wrap_timestamp(s->streams[stream_index], ts);
1733 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1734 int64_t target_ts, int flags)
1736 AVInputFormat *avif = s->iformat;
1737 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1738 int64_t ts_min, ts_max, ts;
1743 if (stream_index < 0)
1746 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1749 ts_min = AV_NOPTS_VALUE;
1750 pos_limit = -1; // GCC falsely says it may be uninitialized.
1752 st = s->streams[stream_index];
1753 if (st->index_entries) {
1756 /* FIXME: Whole function must be checked for non-keyframe entries in
1757 * index case, especially read_timestamp(). */
1758 index = av_index_search_timestamp(st, target_ts,
1759 flags | AVSEEK_FLAG_BACKWARD);
1760 index = FFMAX(index, 0);
1761 e = &st->index_entries[index];
1763 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1765 ts_min = e->timestamp;
1766 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1767 pos_min, av_ts2str(ts_min));
1769 av_assert1(index == 0);
1772 index = av_index_search_timestamp(st, target_ts,
1773 flags & ~AVSEEK_FLAG_BACKWARD);
1774 av_assert0(index < st->nb_index_entries);
1776 e = &st->index_entries[index];
1777 av_assert1(e->timestamp >= target_ts);
1779 ts_max = e->timestamp;
1780 pos_limit = pos_max - e->min_distance;
1781 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1782 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1786 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1787 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1792 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1795 ff_read_frame_flush(s);
1796 ff_update_cur_dts(s, st, ts);
1801 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1802 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1804 int64_t step = 1024;
1805 int64_t limit, ts_max;
1806 int64_t filesize = avio_size(s->pb);
1807 int64_t pos_max = filesize - 1;
1810 pos_max = FFMAX(0, (pos_max) - step);
1811 ts_max = ff_read_timestamp(s, stream_index,
1812 &pos_max, limit, read_timestamp);
1814 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1815 if (ts_max == AV_NOPTS_VALUE)
1819 int64_t tmp_pos = pos_max + 1;
1820 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1821 &tmp_pos, INT64_MAX, read_timestamp);
1822 if (tmp_ts == AV_NOPTS_VALUE)
1824 av_assert0(tmp_pos > pos_max);
1827 if (tmp_pos >= filesize)
1839 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1840 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1841 int64_t ts_min, int64_t ts_max,
1842 int flags, int64_t *ts_ret,
1843 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1844 int64_t *, int64_t))
1851 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1853 if (ts_min == AV_NOPTS_VALUE) {
1854 pos_min = s->data_offset;
1855 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1856 if (ts_min == AV_NOPTS_VALUE)
1860 if (ts_min >= target_ts) {
1865 if (ts_max == AV_NOPTS_VALUE) {
1866 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1868 pos_limit = pos_max;
1871 if (ts_max <= target_ts) {
1876 if (ts_min > ts_max)
1878 else if (ts_min == ts_max)
1879 pos_limit = pos_min;
1882 while (pos_min < pos_limit) {
1884 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1885 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1886 assert(pos_limit <= pos_max);
1888 if (no_change == 0) {
1889 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1890 // interpolate position (better than dichotomy)
1891 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1893 pos_min - approximate_keyframe_distance;
1894 } else if (no_change == 1) {
1895 // bisection if interpolation did not change min / max pos last time
1896 pos = (pos_min + pos_limit) >> 1;
1898 /* linear search if bisection failed, can only happen if there
1899 * are very few or no keyframes between min/max */
1904 else if (pos > pos_limit)
1908 // May pass pos_limit instead of -1.
1909 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1914 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1915 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1916 pos_min, pos, pos_max,
1917 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1918 pos_limit, start_pos, no_change);
1919 if (ts == AV_NOPTS_VALUE) {
1920 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1923 if (target_ts <= ts) {
1924 pos_limit = start_pos - 1;
1928 if (target_ts >= ts) {
1934 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1935 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1938 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1940 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1941 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1942 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1948 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1949 int64_t pos, int flags)
1951 int64_t pos_min, pos_max;
1953 pos_min = s->data_offset;
1954 pos_max = avio_size(s->pb) - 1;
1958 else if (pos > pos_max)
1961 avio_seek(s->pb, pos, SEEK_SET);
1963 s->io_repositioned = 1;
1968 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1969 int64_t timestamp, int flags)
1976 st = s->streams[stream_index];
1978 index = av_index_search_timestamp(st, timestamp, flags);
1980 if (index < 0 && st->nb_index_entries &&
1981 timestamp < st->index_entries[0].timestamp)
1984 if (index < 0 || index == st->nb_index_entries - 1) {
1988 if (st->nb_index_entries) {
1989 av_assert0(st->index_entries);
1990 ie = &st->index_entries[st->nb_index_entries - 1];
1991 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1993 ff_update_cur_dts(s, st, ie->timestamp);
1995 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2001 read_status = av_read_frame(s, &pkt);
2002 } while (read_status == AVERROR(EAGAIN));
2003 if (read_status < 0)
2005 av_free_packet(&pkt);
2006 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2007 if (pkt.flags & AV_PKT_FLAG_KEY)
2009 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2010 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);
2015 index = av_index_search_timestamp(st, timestamp, flags);
2020 ff_read_frame_flush(s);
2021 if (s->iformat->read_seek)
2022 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2024 ie = &st->index_entries[index];
2025 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2027 ff_update_cur_dts(s, st, ie->timestamp);
2032 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2033 int64_t timestamp, int flags)
2038 if (flags & AVSEEK_FLAG_BYTE) {
2039 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2041 ff_read_frame_flush(s);
2042 return seek_frame_byte(s, stream_index, timestamp, flags);
2045 if (stream_index < 0) {
2046 stream_index = av_find_default_stream_index(s);
2047 if (stream_index < 0)
2050 st = s->streams[stream_index];
2051 /* timestamp for default must be expressed in AV_TIME_BASE units */
2052 timestamp = av_rescale(timestamp, st->time_base.den,
2053 AV_TIME_BASE * (int64_t) st->time_base.num);
2056 /* first, we try the format specific seek */
2057 if (s->iformat->read_seek) {
2058 ff_read_frame_flush(s);
2059 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2065 if (s->iformat->read_timestamp &&
2066 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2067 ff_read_frame_flush(s);
2068 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2069 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2070 ff_read_frame_flush(s);
2071 return seek_frame_generic(s, stream_index, timestamp, flags);
2076 int av_seek_frame(AVFormatContext *s, int stream_index,
2077 int64_t timestamp, int flags)
2081 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2082 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2083 if ((flags & AVSEEK_FLAG_BACKWARD))
2087 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2088 flags & ~AVSEEK_FLAG_BACKWARD);
2091 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2094 ret = avformat_queue_attached_pictures(s);
2099 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2100 int64_t ts, int64_t max_ts, int flags)
2102 if (min_ts > ts || max_ts < ts)
2104 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2105 return AVERROR(EINVAL);
2108 flags |= AVSEEK_FLAG_ANY;
2109 flags &= ~AVSEEK_FLAG_BACKWARD;
2111 if (s->iformat->read_seek2) {
2113 ff_read_frame_flush(s);
2115 if (stream_index == -1 && s->nb_streams == 1) {
2116 AVRational time_base = s->streams[0]->time_base;
2117 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2118 min_ts = av_rescale_rnd(min_ts, time_base.den,
2119 time_base.num * (int64_t)AV_TIME_BASE,
2120 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2121 max_ts = av_rescale_rnd(max_ts, time_base.den,
2122 time_base.num * (int64_t)AV_TIME_BASE,
2123 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2126 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2130 ret = avformat_queue_attached_pictures(s);
2134 if (s->iformat->read_timestamp) {
2135 // try to seek via read_timestamp()
2138 // Fall back on old API if new is not implemented but old is.
2139 // Note the old API has somewhat different semantics.
2140 if (s->iformat->read_seek || 1) {
2141 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2142 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2143 if (ret<0 && ts != min_ts && max_ts != ts) {
2144 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2146 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2151 // try some generic seek like seek_frame_generic() but with new ts semantics
2152 return -1; //unreachable
2155 /*******************************************************/
2158 * Return TRUE if the stream has accurate duration in any stream.
2160 * @return TRUE if the stream has accurate duration for at least one component.
2162 static int has_duration(AVFormatContext *ic)
2167 for (i = 0; i < ic->nb_streams; i++) {
2168 st = ic->streams[i];
2169 if (st->duration != AV_NOPTS_VALUE)
2172 if (ic->duration != AV_NOPTS_VALUE)
2178 * Estimate the stream timings from the one of each components.
2180 * Also computes the global bitrate if possible.
2182 static void update_stream_timings(AVFormatContext *ic)
2184 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2185 int64_t duration, duration1, filesize;
2190 start_time = INT64_MAX;
2191 start_time_text = INT64_MAX;
2192 end_time = INT64_MIN;
2193 duration = INT64_MIN;
2194 for (i = 0; i < ic->nb_streams; i++) {
2195 st = ic->streams[i];
2196 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2197 start_time1 = av_rescale_q(st->start_time, st->time_base,
2199 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2200 if (start_time1 < start_time_text)
2201 start_time_text = start_time1;
2203 start_time = FFMIN(start_time, start_time1);
2204 end_time1 = AV_NOPTS_VALUE;
2205 if (st->duration != AV_NOPTS_VALUE) {
2206 end_time1 = start_time1 +
2207 av_rescale_q(st->duration, st->time_base,
2209 end_time = FFMAX(end_time, end_time1);
2211 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2212 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2213 p->start_time = start_time1;
2214 if (p->end_time < end_time1)
2215 p->end_time = end_time1;
2218 if (st->duration != AV_NOPTS_VALUE) {
2219 duration1 = av_rescale_q(st->duration, st->time_base,
2221 duration = FFMAX(duration, duration1);
2224 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2225 start_time = start_time_text;
2226 else if (start_time > start_time_text)
2227 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2229 if (start_time != INT64_MAX) {
2230 ic->start_time = start_time;
2231 if (end_time != INT64_MIN) {
2232 if (ic->nb_programs) {
2233 for (i = 0; i < ic->nb_programs; i++) {
2234 p = ic->programs[i];
2235 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2236 duration = FFMAX(duration, p->end_time - p->start_time);
2239 duration = FFMAX(duration, end_time - start_time);
2242 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2243 ic->duration = duration;
2245 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2246 /* compute the bitrate */
2247 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2248 (double) ic->duration;
2249 if (bitrate >= 0 && bitrate <= INT_MAX)
2250 ic->bit_rate = bitrate;
2254 static void fill_all_stream_timings(AVFormatContext *ic)
2259 update_stream_timings(ic);
2260 for (i = 0; i < ic->nb_streams; i++) {
2261 st = ic->streams[i];
2262 if (st->start_time == AV_NOPTS_VALUE) {
2263 if (ic->start_time != AV_NOPTS_VALUE)
2264 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2266 if (ic->duration != AV_NOPTS_VALUE)
2267 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2273 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2275 int64_t filesize, duration;
2276 int i, show_warning = 0;
2279 /* if bit_rate is already set, we believe it */
2280 if (ic->bit_rate <= 0) {
2282 for (i = 0; i < ic->nb_streams; i++) {
2283 st = ic->streams[i];
2284 if (st->codec->bit_rate > 0) {
2285 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2289 bit_rate += st->codec->bit_rate;
2292 ic->bit_rate = bit_rate;
2295 /* if duration is already set, we believe it */
2296 if (ic->duration == AV_NOPTS_VALUE &&
2297 ic->bit_rate != 0) {
2298 filesize = ic->pb ? avio_size(ic->pb) : 0;
2299 if (filesize > ic->data_offset) {
2300 filesize -= ic->data_offset;
2301 for (i = 0; i < ic->nb_streams; i++) {
2302 st = ic->streams[i];
2303 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2304 && st->duration == AV_NOPTS_VALUE) {
2305 duration = av_rescale(8 * filesize, st->time_base.den,
2307 (int64_t) st->time_base.num);
2308 st->duration = duration;
2315 av_log(ic, AV_LOG_WARNING,
2316 "Estimating duration from bitrate, this may be inaccurate\n");
2319 #define DURATION_MAX_READ_SIZE 250000LL
2320 #define DURATION_MAX_RETRY 4
2322 /* only usable for MPEG-PS streams */
2323 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2325 AVPacket pkt1, *pkt = &pkt1;
2327 int num, den, read_size, i, ret;
2328 int found_duration = 0;
2330 int64_t filesize, offset, duration;
2333 /* flush packet queue */
2334 flush_packet_queue(ic);
2336 for (i = 0; i < ic->nb_streams; i++) {
2337 st = ic->streams[i];
2338 if (st->start_time == AV_NOPTS_VALUE &&
2339 st->first_dts == AV_NOPTS_VALUE &&
2340 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2341 av_log(st->codec, AV_LOG_WARNING,
2342 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2345 av_parser_close(st->parser);
2350 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2351 /* estimate the end time (duration) */
2352 /* XXX: may need to support wrapping */
2353 filesize = ic->pb ? avio_size(ic->pb) : 0;
2355 is_end = found_duration;
2356 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2360 avio_seek(ic->pb, offset, SEEK_SET);
2363 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2367 ret = ff_read_packet(ic, pkt);
2368 } while (ret == AVERROR(EAGAIN));
2371 read_size += pkt->size;
2372 st = ic->streams[pkt->stream_index];
2373 if (pkt->pts != AV_NOPTS_VALUE &&
2374 (st->start_time != AV_NOPTS_VALUE ||
2375 st->first_dts != AV_NOPTS_VALUE)) {
2376 if (pkt->duration == 0) {
2377 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2379 pkt->duration = av_rescale_rnd(1,
2380 num * (int64_t) st->time_base.den,
2381 den * (int64_t) st->time_base.num,
2385 duration = pkt->pts + pkt->duration;
2387 if (st->start_time != AV_NOPTS_VALUE)
2388 duration -= st->start_time;
2390 duration -= st->first_dts;
2392 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2393 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2394 st->duration = duration;
2395 st->info->last_duration = duration;
2398 av_free_packet(pkt);
2401 /* check if all audio/video streams have valid duration */
2404 for (i = 0; i < ic->nb_streams; i++) {
2405 st = ic->streams[i];
2406 switch (st->codec->codec_type) {
2407 case AVMEDIA_TYPE_VIDEO:
2408 case AVMEDIA_TYPE_AUDIO:
2409 if (st->duration == AV_NOPTS_VALUE)
2416 ++retry <= DURATION_MAX_RETRY);
2418 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2420 /* warn about audio/video streams which duration could not be estimated */
2421 for (i = 0; i < ic->nb_streams; i++) {
2422 st = ic->streams[i];
2423 if (st->duration == AV_NOPTS_VALUE) {
2424 switch (st->codec->codec_type) {
2425 case AVMEDIA_TYPE_VIDEO:
2426 case AVMEDIA_TYPE_AUDIO:
2427 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2428 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2430 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2434 fill_all_stream_timings(ic);
2436 avio_seek(ic->pb, old_offset, SEEK_SET);
2437 for (i = 0; i < ic->nb_streams; i++) {
2440 st = ic->streams[i];
2441 st->cur_dts = st->first_dts;
2442 st->last_IP_pts = AV_NOPTS_VALUE;
2443 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2444 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2445 st->pts_buffer[j] = AV_NOPTS_VALUE;
2449 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2453 /* get the file size, if possible */
2454 if (ic->iformat->flags & AVFMT_NOFILE) {
2457 file_size = avio_size(ic->pb);
2458 file_size = FFMAX(0, file_size);
2461 if ((!strcmp(ic->iformat->name, "mpeg") ||
2462 !strcmp(ic->iformat->name, "mpegts")) &&
2463 file_size && ic->pb->seekable) {
2464 /* get accurate estimate from the PTSes */
2465 estimate_timings_from_pts(ic, old_offset);
2466 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2467 } else if (has_duration(ic)) {
2468 /* at least one component has timings - we use them for all
2470 fill_all_stream_timings(ic);
2471 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2473 /* less precise: use bitrate info */
2474 estimate_timings_from_bit_rate(ic);
2475 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2477 update_stream_timings(ic);
2481 AVStream av_unused *st;
2482 for (i = 0; i < ic->nb_streams; i++) {
2483 st = ic->streams[i];
2484 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2485 (double) st->start_time / AV_TIME_BASE,
2486 (double) st->duration / AV_TIME_BASE);
2489 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2490 (double) ic->start_time / AV_TIME_BASE,
2491 (double) ic->duration / AV_TIME_BASE,
2492 ic->bit_rate / 1000);
2496 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2498 AVCodecContext *avctx = st->codec;
2500 #define FAIL(errmsg) do { \
2502 *errmsg_ptr = errmsg; \
2506 if ( avctx->codec_id == AV_CODEC_ID_NONE
2507 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2508 FAIL("unknown codec");
2509 switch (avctx->codec_type) {
2510 case AVMEDIA_TYPE_AUDIO:
2511 if (!avctx->frame_size && determinable_frame_size(avctx))
2512 FAIL("unspecified frame size");
2513 if (st->info->found_decoder >= 0 &&
2514 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2515 FAIL("unspecified sample format");
2516 if (!avctx->sample_rate)
2517 FAIL("unspecified sample rate");
2518 if (!avctx->channels)
2519 FAIL("unspecified number of channels");
2520 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2521 FAIL("no decodable DTS frames");
2523 case AVMEDIA_TYPE_VIDEO:
2525 FAIL("unspecified size");
2526 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2527 FAIL("unspecified pixel format");
2528 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2529 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2530 FAIL("no frame in rv30/40 and no sar");
2532 case AVMEDIA_TYPE_SUBTITLE:
2533 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2534 FAIL("unspecified size");
2536 case AVMEDIA_TYPE_DATA:
2537 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2543 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2544 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2545 AVDictionary **options)
2547 const AVCodec *codec;
2548 int got_picture = 1, ret = 0;
2549 AVFrame *frame = av_frame_alloc();
2550 AVSubtitle subtitle;
2551 AVPacket pkt = *avpkt;
2554 return AVERROR(ENOMEM);
2556 if (!avcodec_is_open(st->codec) &&
2557 st->info->found_decoder <= 0 &&
2558 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2559 AVDictionary *thread_opt = NULL;
2561 codec = find_decoder(s, st, st->codec->codec_id);
2564 st->info->found_decoder = -st->codec->codec_id;
2569 /* Force thread count to 1 since the H.264 decoder will not extract
2570 * SPS and PPS to extradata during multi-threaded decoding. */
2571 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2572 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2574 av_dict_free(&thread_opt);
2576 st->info->found_decoder = -st->codec->codec_id;
2579 st->info->found_decoder = 1;
2580 } else if (!st->info->found_decoder)
2581 st->info->found_decoder = 1;
2583 if (st->info->found_decoder < 0) {
2588 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2590 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2591 (!st->codec_info_nb_frames &&
2592 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2594 switch (st->codec->codec_type) {
2595 case AVMEDIA_TYPE_VIDEO:
2596 ret = avcodec_decode_video2(st->codec, frame,
2597 &got_picture, &pkt);
2599 case AVMEDIA_TYPE_AUDIO:
2600 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2602 case AVMEDIA_TYPE_SUBTITLE:
2603 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2604 &got_picture, &pkt);
2612 st->nb_decoded_frames++;
2619 if (!pkt.data && !got_picture)
2623 av_frame_free(&frame);
2627 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2629 while (tags->id != AV_CODEC_ID_NONE) {
2637 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2640 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2641 if (tag == tags[i].tag)
2643 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2644 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2646 return AV_CODEC_ID_NONE;
2649 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2654 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2656 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2658 return AV_CODEC_ID_NONE;
2663 if (sflags & (1 << (bps - 1))) {
2666 return AV_CODEC_ID_PCM_S8;
2668 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2670 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2672 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2674 return AV_CODEC_ID_NONE;
2679 return AV_CODEC_ID_PCM_U8;
2681 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2683 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2685 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2687 return AV_CODEC_ID_NONE;
2693 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2696 if (!av_codec_get_tag2(tags, id, &tag))
2701 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2705 for (i = 0; tags && tags[i]; i++) {
2706 const AVCodecTag *codec_tags = tags[i];
2707 while (codec_tags->id != AV_CODEC_ID_NONE) {
2708 if (codec_tags->id == id) {
2709 *tag = codec_tags->tag;
2718 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2721 for (i = 0; tags && tags[i]; i++) {
2722 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2723 if (id != AV_CODEC_ID_NONE)
2726 return AV_CODEC_ID_NONE;
2729 static void compute_chapters_end(AVFormatContext *s)
2732 int64_t max_time = s->duration +
2733 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2735 for (i = 0; i < s->nb_chapters; i++)
2736 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2737 AVChapter *ch = s->chapters[i];
2738 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2742 for (j = 0; j < s->nb_chapters; j++) {
2743 AVChapter *ch1 = s->chapters[j];
2744 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2746 if (j != i && next_start > ch->start && next_start < end)
2749 ch->end = (end == INT64_MAX) ? ch->start : end;
2753 static int get_std_framerate(int i)
2756 return (i + 1) * 1001;
2758 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2761 /* Is the time base unreliable?
2762 * This is a heuristic to balance between quick acceptance of the values in
2763 * the headers vs. some extra checks.
2764 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2765 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2766 * And there are "variable" fps files this needs to detect as well. */
2767 static int tb_unreliable(AVCodecContext *c)
2769 if (c->time_base.den >= 101L * c->time_base.num ||
2770 c->time_base.den < 5L * c->time_base.num ||
2771 // c->codec_tag == AV_RL32("DIVX") ||
2772 // c->codec_tag == AV_RL32("XVID") ||
2773 c->codec_tag == AV_RL32("mp4v") ||
2774 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2775 c->codec_id == AV_CODEC_ID_GIF ||
2776 c->codec_id == AV_CODEC_ID_H264)
2781 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2785 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2786 avctx->extradata_size = 0;
2787 return AVERROR(EINVAL);
2789 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2790 if (avctx->extradata) {
2791 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2792 avctx->extradata_size = size;
2795 avctx->extradata_size = 0;
2796 ret = AVERROR(ENOMEM);
2801 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2803 int ret = ff_alloc_extradata(avctx, size);
2806 ret = avio_read(pb, avctx->extradata, size);
2808 av_freep(&avctx->extradata);
2809 avctx->extradata_size = 0;
2810 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2811 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2817 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2820 int64_t last = st->info->last_dts;
2822 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2823 && ts - (uint64_t)last < INT64_MAX) {
2824 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2825 int64_t duration = ts - last;
2827 if (!st->info->duration_error)
2828 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2829 if (!st->info->duration_error)
2830 return AVERROR(ENOMEM);
2832 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2833 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2834 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2835 if (st->info->duration_error[0][1][i] < 1e10) {
2836 int framerate = get_std_framerate(i);
2837 double sdts = dts*framerate/(1001*12);
2838 for (j= 0; j<2; j++) {
2839 int64_t ticks = llrint(sdts+j*0.5);
2840 double error= sdts - ticks + j*0.5;
2841 st->info->duration_error[j][0][i] += error;
2842 st->info->duration_error[j][1][i] += error*error;
2846 st->info->duration_count++;
2847 st->info->rfps_duration_sum += duration;
2849 if (st->info->duration_count % 10 == 0) {
2850 int n = st->info->duration_count;
2851 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2852 if (st->info->duration_error[0][1][i] < 1e10) {
2853 double a0 = st->info->duration_error[0][0][i] / n;
2854 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2855 double a1 = st->info->duration_error[1][0][i] / n;
2856 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2857 if (error0 > 0.04 && error1 > 0.04) {
2858 st->info->duration_error[0][1][i] = 2e10;
2859 st->info->duration_error[1][1][i] = 2e10;
2865 // ignore the first 4 values, they might have some random jitter
2866 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2867 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2869 if (ts != AV_NOPTS_VALUE)
2870 st->info->last_dts = ts;
2875 void ff_rfps_calculate(AVFormatContext *ic)
2879 for (i = 0; i < ic->nb_streams; i++) {
2880 AVStream *st = ic->streams[i];
2882 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2884 // the check for tb_unreliable() is not completely correct, since this is not about handling
2885 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2886 // ipmovie.c produces.
2887 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)
2888 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);
2889 if (st->info->duration_count>1 && !st->r_frame_rate.num
2890 && tb_unreliable(st->codec)) {
2892 double best_error= 0.01;
2893 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2895 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2898 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2900 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2903 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2906 for (k= 0; k<2; k++) {
2907 int n = st->info->duration_count;
2908 double a= st->info->duration_error[k][0][j] / n;
2909 double error= st->info->duration_error[k][1][j]/n - a*a;
2911 if (error < best_error && best_error> 0.000000001) {
2913 num = get_std_framerate(j);
2916 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2919 // do not increase frame rate by more than 1 % in order to match a standard rate.
2920 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2921 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2923 if ( !st->avg_frame_rate.num
2924 && st->r_frame_rate.num && st->info->rfps_duration_sum
2925 && st->info->codec_info_duration <= 0
2926 && st->info->duration_count > 2
2927 && 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
2929 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2930 st->avg_frame_rate = st->r_frame_rate;
2933 av_freep(&st->info->duration_error);
2934 st->info->last_dts = AV_NOPTS_VALUE;
2935 st->info->duration_count = 0;
2936 st->info->rfps_duration_sum = 0;
2940 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2942 int i, count, ret = 0, j;
2945 AVPacket pkt1, *pkt;
2946 int64_t old_offset = avio_tell(ic->pb);
2947 // new streams might appear, no options for those
2948 int orig_nb_streams = ic->nb_streams;
2950 int64_t max_analyze_duration = ic->max_analyze_duration2;
2951 int64_t probesize = ic->probesize2;
2953 if (!max_analyze_duration)
2954 max_analyze_duration = ic->max_analyze_duration;
2956 probesize = ic->probesize;
2957 flush_codecs = probesize > 0;
2959 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2961 if (!max_analyze_duration) {
2962 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2963 max_analyze_duration = 10*AV_TIME_BASE;
2965 max_analyze_duration = 5*AV_TIME_BASE;
2969 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2970 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2972 for (i = 0; i < ic->nb_streams; i++) {
2973 const AVCodec *codec;
2974 AVDictionary *thread_opt = NULL;
2975 st = ic->streams[i];
2977 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2978 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2979 /* if (!st->time_base.num)
2981 if (!st->codec->time_base.num)
2982 st->codec->time_base = st->time_base;
2984 // only for the split stuff
2985 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2986 st->parser = av_parser_init(st->codec->codec_id);
2988 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
2989 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2990 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2991 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2993 } else if (st->need_parsing) {
2994 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2995 "%s, packets or times may be invalid.\n",
2996 avcodec_get_name(st->codec->codec_id));
2999 codec = find_decoder(ic, st, st->codec->codec_id);
3001 /* Force thread count to 1 since the H.264 decoder will not extract
3002 * SPS and PPS to extradata during multi-threaded decoding. */
3003 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3005 /* Ensure that subtitle_header is properly set. */
3006 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3007 && codec && !st->codec->codec) {
3008 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3009 av_log(ic, AV_LOG_WARNING,
3010 "Failed to open codec in av_find_stream_info\n");
3013 // Try to just open decoders, in case this is enough to get parameters.
3014 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3015 if (codec && !st->codec->codec)
3016 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3017 av_log(ic, AV_LOG_WARNING,
3018 "Failed to open codec in av_find_stream_info\n");
3021 av_dict_free(&thread_opt);
3024 for (i = 0; i < ic->nb_streams; i++) {
3025 #if FF_API_R_FRAME_RATE
3026 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3028 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3029 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3035 if (ff_check_interrupt(&ic->interrupt_callback)) {
3037 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3041 /* check if one codec still needs to be handled */
3042 for (i = 0; i < ic->nb_streams; i++) {
3043 int fps_analyze_framecount = 20;
3045 st = ic->streams[i];
3046 if (!has_codec_parameters(st, NULL))
3048 /* If the timebase is coarse (like the usual millisecond precision
3049 * of mkv), we need to analyze more frames to reliably arrive at
3050 * the correct fps. */
3051 if (av_q2d(st->time_base) > 0.0005)
3052 fps_analyze_framecount *= 2;
3053 if (!tb_unreliable(st->codec))
3054 fps_analyze_framecount = 0;
3055 if (ic->fps_probe_size >= 0)
3056 fps_analyze_framecount = ic->fps_probe_size;
3057 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3058 fps_analyze_framecount = 0;
3059 /* variable fps and no guess at the real fps */
3060 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3061 st->info->duration_count < fps_analyze_framecount &&
3062 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3064 if (st->parser && st->parser->parser->split &&
3065 !st->codec->extradata)
3067 if (st->first_dts == AV_NOPTS_VALUE &&
3068 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3069 st->codec_info_nb_frames < ic->max_ts_probe &&
3070 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3071 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3074 if (i == ic->nb_streams) {
3075 /* NOTE: If the format has no header, then we need to read some
3076 * packets to get most of the streams, so we cannot stop here. */
3077 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3078 /* If we found the info for all the codecs, we can stop. */
3080 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3085 /* We did not get all the codec info, but we read too much data. */
3086 if (read_size >= probesize) {
3088 av_log(ic, AV_LOG_DEBUG,
3089 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3090 for (i = 0; i < ic->nb_streams; i++)
3091 if (!ic->streams[i]->r_frame_rate.num &&
3092 ic->streams[i]->info->duration_count <= 1 &&
3093 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3094 strcmp(ic->iformat->name, "image2"))
3095 av_log(ic, AV_LOG_WARNING,
3096 "Stream #%d: not enough frames to estimate rate; "
3097 "consider increasing probesize\n", i);
3101 /* NOTE: A new stream can be added there if no header in file
3102 * (AVFMTCTX_NOHEADER). */
3103 ret = read_frame_internal(ic, &pkt1);
3104 if (ret == AVERROR(EAGAIN))
3112 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3113 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3115 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3116 &ic->packet_buffer_end);
3118 ret = AVERROR(ENOMEM);
3119 goto find_stream_info_err;
3121 if ((ret = av_dup_packet(pkt)) < 0)
3122 goto find_stream_info_err;
3125 st = ic->streams[pkt->stream_index];
3126 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3127 read_size += pkt->size;
3129 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3130 /* check for non-increasing dts */
3131 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3132 st->info->fps_last_dts >= pkt->dts) {
3133 av_log(ic, AV_LOG_DEBUG,
3134 "Non-increasing DTS in stream %d: packet %d with DTS "
3135 "%"PRId64", packet %d with DTS %"PRId64"\n",
3136 st->index, st->info->fps_last_dts_idx,
3137 st->info->fps_last_dts, st->codec_info_nb_frames,
3139 st->info->fps_first_dts =
3140 st->info->fps_last_dts = AV_NOPTS_VALUE;
3142 /* Check for a discontinuity in dts. If the difference in dts
3143 * is more than 1000 times the average packet duration in the
3144 * sequence, we treat it as a discontinuity. */
3145 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3146 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3147 (pkt->dts - st->info->fps_last_dts) / 1000 >
3148 (st->info->fps_last_dts - st->info->fps_first_dts) /
3149 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3150 av_log(ic, AV_LOG_WARNING,
3151 "DTS discontinuity in stream %d: packet %d with DTS "
3152 "%"PRId64", packet %d with DTS %"PRId64"\n",
3153 st->index, st->info->fps_last_dts_idx,
3154 st->info->fps_last_dts, st->codec_info_nb_frames,
3156 st->info->fps_first_dts =
3157 st->info->fps_last_dts = AV_NOPTS_VALUE;
3160 /* update stored dts values */
3161 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3162 st->info->fps_first_dts = pkt->dts;
3163 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3165 st->info->fps_last_dts = pkt->dts;
3166 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3168 if (st->codec_info_nb_frames>1) {
3171 if (st->time_base.den > 0)
3172 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3173 if (st->avg_frame_rate.num > 0)
3174 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3177 && st->codec_info_nb_frames>30
3178 && st->info->fps_first_dts != AV_NOPTS_VALUE
3179 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3180 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3182 if (t >= max_analyze_duration) {
3183 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3184 max_analyze_duration,
3186 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3187 av_packet_unref(pkt);
3190 if (pkt->duration) {
3191 st->info->codec_info_duration += pkt->duration;
3192 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3195 #if FF_API_R_FRAME_RATE
3196 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3197 ff_rfps_add_frame(ic, st, pkt->dts);
3199 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3200 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3201 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3202 if (ff_alloc_extradata(st->codec, i))
3203 return AVERROR(ENOMEM);
3204 memcpy(st->codec->extradata, pkt->data,
3205 st->codec->extradata_size);
3209 /* If still no information, we try to open the codec and to
3210 * decompress the frame. We try to avoid that in most cases as
3211 * it takes longer and uses more memory. For MPEG-4, we need to
3212 * decompress for QuickTime.
3214 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3215 * least one frame of codec data, this makes sure the codec initializes
3216 * the channel configuration and does not only trust the values from
3218 try_decode_frame(ic, st, pkt,
3219 (options && i < orig_nb_streams) ? &options[i] : NULL);
3221 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3222 av_packet_unref(pkt);
3224 st->codec_info_nb_frames++;
3229 AVPacket empty_pkt = { 0 };
3231 av_init_packet(&empty_pkt);
3233 for (i = 0; i < ic->nb_streams; i++) {
3235 st = ic->streams[i];
3237 /* flush the decoders */
3238 if (st->info->found_decoder == 1) {
3240 err = try_decode_frame(ic, st, &empty_pkt,
3241 (options && i < orig_nb_streams)
3242 ? &options[i] : NULL);
3243 } while (err > 0 && !has_codec_parameters(st, NULL));
3246 av_log(ic, AV_LOG_INFO,
3247 "decoding for stream %d failed\n", st->index);
3252 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3254 // close codecs which were opened in try_decode_frame()
3255 for (i = 0; i < ic->nb_streams; i++) {
3256 st = ic->streams[i];
3257 avcodec_close(st->codec);
3260 ff_rfps_calculate(ic);
3262 for (i = 0; i < ic->nb_streams; i++) {
3263 st = ic->streams[i];
3264 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3265 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3266 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3267 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3268 st->codec->codec_tag= tag;
3271 /* estimate average framerate if not set by demuxer */
3272 if (st->info->codec_info_duration_fields &&
3273 !st->avg_frame_rate.num &&
3274 st->info->codec_info_duration) {
3276 double best_error = 0.01;
3278 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3279 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3280 st->info->codec_info_duration < 0)
3282 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3283 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3284 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3286 /* Round guessed framerate to a "standard" framerate if it's
3287 * within 1% of the original estimate. */
3288 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3289 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3290 double error = fabs(av_q2d(st->avg_frame_rate) /
3291 av_q2d(std_fps) - 1);
3293 if (error < best_error) {
3295 best_fps = std_fps.num;
3299 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3300 best_fps, 12 * 1001, INT_MAX);
3303 if (!st->r_frame_rate.num) {
3304 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3305 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3306 st->r_frame_rate.num = st->codec->time_base.den;
3307 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3309 st->r_frame_rate.num = st->time_base.den;
3310 st->r_frame_rate.den = st->time_base.num;
3313 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3314 if (!st->codec->bits_per_coded_sample)
3315 st->codec->bits_per_coded_sample =
3316 av_get_bits_per_sample(st->codec->codec_id);
3317 // set stream disposition based on audio service type
3318 switch (st->codec->audio_service_type) {
3319 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3320 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3322 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3323 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3325 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3326 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3328 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3329 st->disposition = AV_DISPOSITION_COMMENT;
3331 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3332 st->disposition = AV_DISPOSITION_KARAOKE;
3339 estimate_timings(ic, old_offset);
3341 if (ret >= 0 && ic->nb_streams)
3342 /* We could not have all the codec parameters before EOF. */
3344 for (i = 0; i < ic->nb_streams; i++) {
3346 st = ic->streams[i];
3347 if (!has_codec_parameters(st, &errmsg)) {
3349 avcodec_string(buf, sizeof(buf), st->codec, 0);
3350 av_log(ic, AV_LOG_WARNING,
3351 "Could not find codec parameters for stream %d (%s): %s\n"
3352 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3359 compute_chapters_end(ic);
3361 find_stream_info_err:
3362 for (i = 0; i < ic->nb_streams; i++) {
3363 st = ic->streams[i];
3364 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3365 ic->streams[i]->codec->thread_count = 0;
3367 av_freep(&st->info->duration_error);
3368 av_freep(&ic->streams[i]->info);
3371 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3372 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3376 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3380 for (i = 0; i < ic->nb_programs; i++) {
3381 if (ic->programs[i] == last) {
3385 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3386 if (ic->programs[i]->stream_index[j] == s)
3387 return ic->programs[i];
3393 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3394 int wanted_stream_nb, int related_stream,
3395 AVCodec **decoder_ret, int flags)
3397 int i, nb_streams = ic->nb_streams;
3398 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3399 unsigned *program = NULL;
3400 const AVCodec *decoder = NULL, *best_decoder = NULL;
3402 if (related_stream >= 0 && wanted_stream_nb < 0) {
3403 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3405 program = p->stream_index;
3406 nb_streams = p->nb_stream_indexes;
3409 for (i = 0; i < nb_streams; i++) {
3410 int real_stream_index = program ? program[i] : i;
3411 AVStream *st = ic->streams[real_stream_index];
3412 AVCodecContext *avctx = st->codec;
3413 if (avctx->codec_type != type)
3415 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3417 if (wanted_stream_nb != real_stream_index &&
3418 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3419 AV_DISPOSITION_VISUAL_IMPAIRED))
3421 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3424 decoder = find_decoder(ic, st, st->codec->codec_id);
3427 ret = AVERROR_DECODER_NOT_FOUND;
3431 count = st->codec_info_nb_frames;
3432 bitrate = avctx->bit_rate;
3434 bitrate = avctx->rc_max_rate;
3435 multiframe = FFMIN(5, count);
3436 if ((best_multiframe > multiframe) ||
3437 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3438 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3441 best_bitrate = bitrate;
3442 best_multiframe = multiframe;
3443 ret = real_stream_index;
3444 best_decoder = decoder;
3445 if (program && i == nb_streams - 1 && ret < 0) {
3447 nb_streams = ic->nb_streams;
3448 /* no related stream found, try again with everything */
3453 *decoder_ret = (AVCodec*)best_decoder;
3457 /*******************************************************/
3459 int av_read_play(AVFormatContext *s)
3461 if (s->iformat->read_play)
3462 return s->iformat->read_play(s);
3464 return avio_pause(s->pb, 0);
3465 return AVERROR(ENOSYS);
3468 int av_read_pause(AVFormatContext *s)
3470 if (s->iformat->read_pause)
3471 return s->iformat->read_pause(s);
3473 return avio_pause(s->pb, 1);
3474 return AVERROR(ENOSYS);
3477 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3479 av_assert0(s->nb_streams>0);
3480 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3482 for (j = 0; j < st->nb_side_data; j++)
3483 av_freep(&st->side_data[j].data);
3484 av_freep(&st->side_data);
3485 st->nb_side_data = 0;
3488 av_parser_close(st->parser);
3490 if (st->attached_pic.data)
3491 av_free_packet(&st->attached_pic);
3492 av_dict_free(&st->metadata);
3493 av_freep(&st->probe_data.buf);
3494 av_freep(&st->index_entries);
3495 av_freep(&st->codec->extradata);
3496 av_freep(&st->codec->subtitle_header);
3497 av_freep(&st->codec);
3498 av_freep(&st->priv_data);
3500 av_freep(&st->info->duration_error);
3501 av_freep(&st->info);
3502 av_freep(&s->streams[ --s->nb_streams ]);
3505 void avformat_free_context(AVFormatContext *s)
3513 if (s->iformat && s->iformat->priv_class && s->priv_data)
3514 av_opt_free(s->priv_data);
3515 if (s->oformat && s->oformat->priv_class && s->priv_data)
3516 av_opt_free(s->priv_data);
3518 for (i = s->nb_streams - 1; i >= 0; i--) {
3519 ff_free_stream(s, s->streams[i]);
3521 for (i = s->nb_programs - 1; i >= 0; i--) {
3522 av_dict_free(&s->programs[i]->metadata);
3523 av_freep(&s->programs[i]->stream_index);
3524 av_freep(&s->programs[i]);
3526 av_freep(&s->programs);
3527 av_freep(&s->priv_data);
3528 while (s->nb_chapters--) {
3529 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3530 av_freep(&s->chapters[s->nb_chapters]);
3532 av_freep(&s->chapters);
3533 av_dict_free(&s->metadata);
3534 av_freep(&s->streams);
3535 av_freep(&s->internal);
3536 flush_packet_queue(s);
3540 void avformat_close_input(AVFormatContext **ps)
3551 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3552 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3555 flush_packet_queue(s);
3558 if (s->iformat->read_close)
3559 s->iformat->read_close(s);
3561 avformat_free_context(s);
3568 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3574 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3576 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3579 s->streams = streams;
3581 st = av_mallocz(sizeof(AVStream));
3584 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3588 st->info->last_dts = AV_NOPTS_VALUE;
3590 st->codec = avcodec_alloc_context3(c);
3592 /* no default bitrate if decoding */
3593 st->codec->bit_rate = 0;
3595 /* default pts setting is MPEG-like */
3596 avpriv_set_pts_info(st, 33, 1, 90000);
3599 st->index = s->nb_streams;
3600 st->start_time = AV_NOPTS_VALUE;
3601 st->duration = AV_NOPTS_VALUE;
3602 /* we set the current DTS to 0 so that formats without any timestamps
3603 * but durations get some timestamps, formats with some unknown
3604 * timestamps have their first few packets buffered and the
3605 * timestamps corrected before they are returned to the user */
3606 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3607 st->first_dts = AV_NOPTS_VALUE;
3608 st->probe_packets = MAX_PROBE_PACKETS;
3609 st->pts_wrap_reference = AV_NOPTS_VALUE;
3610 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3612 st->last_IP_pts = AV_NOPTS_VALUE;
3613 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3614 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3615 st->pts_buffer[i] = AV_NOPTS_VALUE;
3617 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3619 #if FF_API_R_FRAME_RATE
3620 st->info->last_dts = AV_NOPTS_VALUE;
3622 st->info->fps_first_dts = AV_NOPTS_VALUE;
3623 st->info->fps_last_dts = AV_NOPTS_VALUE;
3625 st->inject_global_side_data = s->internal->inject_global_side_data;
3627 s->streams[s->nb_streams++] = st;
3631 AVProgram *av_new_program(AVFormatContext *ac, int id)
3633 AVProgram *program = NULL;
3636 av_dlog(ac, "new_program: id=0x%04x\n", id);
3638 for (i = 0; i < ac->nb_programs; i++)
3639 if (ac->programs[i]->id == id)
3640 program = ac->programs[i];
3643 program = av_mallocz(sizeof(AVProgram));
3646 dynarray_add(&ac->programs, &ac->nb_programs, program);
3647 program->discard = AVDISCARD_NONE;
3650 program->pts_wrap_reference = AV_NOPTS_VALUE;
3651 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3653 program->start_time =
3654 program->end_time = AV_NOPTS_VALUE;
3659 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3660 int64_t start, int64_t end, const char *title)
3662 AVChapter *chapter = NULL;
3665 if (end != AV_NOPTS_VALUE && start > end) {
3666 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3670 for (i = 0; i < s->nb_chapters; i++)
3671 if (s->chapters[i]->id == id)
3672 chapter = s->chapters[i];
3675 chapter = av_mallocz(sizeof(AVChapter));
3678 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3680 av_dict_set(&chapter->metadata, "title", title, 0);
3682 chapter->time_base = time_base;
3683 chapter->start = start;
3689 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3692 AVProgram *program = NULL;
3695 if (idx >= ac->nb_streams) {
3696 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3700 for (i = 0; i < ac->nb_programs; i++) {
3701 if (ac->programs[i]->id != progid)
3703 program = ac->programs[i];
3704 for (j = 0; j < program->nb_stream_indexes; j++)
3705 if (program->stream_index[j] == idx)
3708 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3711 program->stream_index = tmp;
3712 program->stream_index[program->nb_stream_indexes++] = idx;
3717 uint64_t ff_ntp_time(void)
3719 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3722 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3725 char *q, buf1[20], c;
3726 int nd, len, percentd_found;
3738 while (av_isdigit(*p))
3739 nd = nd * 10 + *p++ - '0';
3741 } while (av_isdigit(c));
3750 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3752 if ((q - buf + len) > buf_size - 1)
3754 memcpy(q, buf1, len);
3762 if ((q - buf) < buf_size - 1)
3766 if (!percentd_found)
3775 void av_url_split(char *proto, int proto_size,
3776 char *authorization, int authorization_size,
3777 char *hostname, int hostname_size,
3778 int *port_ptr, char *path, int path_size, const char *url)
3780 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3786 if (authorization_size > 0)
3787 authorization[0] = 0;
3788 if (hostname_size > 0)
3793 /* parse protocol */
3794 if ((p = strchr(url, ':'))) {
3795 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3802 /* no protocol means plain filename */
3803 av_strlcpy(path, url, path_size);
3807 /* separate path from hostname */
3808 ls = strchr(p, '/');
3809 ls2 = strchr(p, '?');
3813 ls = FFMIN(ls, ls2);
3815 av_strlcpy(path, ls, path_size);
3817 ls = &p[strlen(p)]; // XXX
3819 /* the rest is hostname, use that to parse auth/port */
3821 /* authorization (user[:pass]@hostname) */
3823 while ((at = strchr(p, '@')) && at < ls) {
3824 av_strlcpy(authorization, at2,
3825 FFMIN(authorization_size, at + 1 - at2));
3826 p = at + 1; /* skip '@' */
3829 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3831 av_strlcpy(hostname, p + 1,
3832 FFMIN(hostname_size, brk - p));
3833 if (brk[1] == ':' && port_ptr)
3834 *port_ptr = atoi(brk + 2);
3835 } else if ((col = strchr(p, ':')) && col < ls) {
3836 av_strlcpy(hostname, p,
3837 FFMIN(col + 1 - p, hostname_size));
3839 *port_ptr = atoi(col + 1);
3841 av_strlcpy(hostname, p,
3842 FFMIN(ls + 1 - p, hostname_size));
3846 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3849 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3852 'C', 'D', 'E', 'F' };
3853 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3856 'c', 'd', 'e', 'f' };
3857 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3859 for (i = 0; i < s; i++) {
3860 buff[i * 2] = hex_table[src[i] >> 4];
3861 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3867 int ff_hex_to_data(uint8_t *data, const char *p)
3874 p += strspn(p, SPACE_CHARS);
3877 c = av_toupper((unsigned char) *p++);
3878 if (c >= '0' && c <= '9')
3880 else if (c >= 'A' && c <= 'F')
3895 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3896 unsigned int pts_num, unsigned int pts_den)
3899 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3900 if (new_tb.num != pts_num)
3901 av_log(NULL, AV_LOG_DEBUG,
3902 "st:%d removing common factor %d from timebase\n",
3903 s->index, pts_num / new_tb.num);
3905 av_log(NULL, AV_LOG_WARNING,
3906 "st:%d has too large timebase, reducing\n", s->index);
3908 if (new_tb.num <= 0 || new_tb.den <= 0) {
3909 av_log(NULL, AV_LOG_ERROR,
3910 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3911 new_tb.num, new_tb.den,
3915 s->time_base = new_tb;
3916 av_codec_set_pkt_timebase(s->codec, new_tb);
3917 s->pts_wrap_bits = pts_wrap_bits;
3920 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3923 const char *ptr = str;
3925 /* Parse key=value pairs. */
3928 char *dest = NULL, *dest_end;
3929 int key_len, dest_len = 0;
3931 /* Skip whitespace and potential commas. */
3932 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3939 if (!(ptr = strchr(key, '=')))
3942 key_len = ptr - key;
3944 callback_get_buf(context, key, key_len, &dest, &dest_len);
3945 dest_end = dest + dest_len - 1;
3949 while (*ptr && *ptr != '\"') {
3953 if (dest && dest < dest_end)
3957 if (dest && dest < dest_end)
3965 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3966 if (dest && dest < dest_end)
3974 int ff_find_stream_index(AVFormatContext *s, int id)
3977 for (i = 0; i < s->nb_streams; i++)
3978 if (s->streams[i]->id == id)
3983 int64_t ff_iso8601_to_unix_time(const char *datestr)
3985 struct tm time1 = { 0 }, time2 = { 0 };
3987 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
3988 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
3990 return av_timegm(&time2);
3992 return av_timegm(&time1);
3995 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
3999 if (ofmt->query_codec)
4000 return ofmt->query_codec(codec_id, std_compliance);
4001 else if (ofmt->codec_tag)
4002 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4003 else if (codec_id == ofmt->video_codec ||
4004 codec_id == ofmt->audio_codec ||
4005 codec_id == ofmt->subtitle_codec)
4008 return AVERROR_PATCHWELCOME;
4011 int avformat_network_init(void)
4015 ff_network_inited_globally = 1;
4016 if ((ret = ff_network_init()) < 0)
4023 int avformat_network_deinit(void)
4032 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4033 uint64_t channel_layout, int32_t sample_rate,
4034 int32_t width, int32_t height)
4040 return AVERROR(EINVAL);
4043 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4045 if (channel_layout) {
4047 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4051 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4053 if (width || height) {
4055 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4057 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4059 return AVERROR(ENOMEM);
4060 bytestream_put_le32(&data, flags);
4062 bytestream_put_le32(&data, channels);
4064 bytestream_put_le64(&data, channel_layout);
4066 bytestream_put_le32(&data, sample_rate);
4067 if (width || height) {
4068 bytestream_put_le32(&data, width);
4069 bytestream_put_le32(&data, height);
4074 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4076 AVRational undef = {0, 1};
4077 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4078 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4079 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4081 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4082 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4083 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4084 stream_sample_aspect_ratio = undef;
4086 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4087 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4088 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4089 frame_sample_aspect_ratio = undef;
4091 if (stream_sample_aspect_ratio.num)
4092 return stream_sample_aspect_ratio;
4094 return frame_sample_aspect_ratio;
4097 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4099 AVRational fr = st->r_frame_rate;
4100 AVRational codec_fr = av_inv_q(st->codec->time_base);
4101 AVRational avg_fr = st->avg_frame_rate;
4103 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4104 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4109 if (st->codec->ticks_per_frame > 1) {
4110 codec_fr.den *= st->codec->ticks_per_frame;
4111 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4112 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4119 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4122 if (*spec <= '9' && *spec >= '0') /* opt:index */
4123 return strtol(spec, NULL, 0) == st->index;
4124 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4125 *spec == 't') { /* opt:[vasdt] */
4126 enum AVMediaType type;
4129 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4130 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4131 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4132 case 'd': type = AVMEDIA_TYPE_DATA; break;
4133 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4134 default: av_assert0(0);
4136 if (type != st->codec->codec_type)
4138 if (*spec++ == ':') { /* possibly followed by :index */
4139 int i, index = strtol(spec, NULL, 0);
4140 for (i = 0; i < s->nb_streams; i++)
4141 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4142 return i == st->index;
4146 } else if (*spec == 'p' && *(spec + 1) == ':') {
4150 prog_id = strtol(spec, &endptr, 0);
4151 for (i = 0; i < s->nb_programs; i++) {
4152 if (s->programs[i]->id != prog_id)
4155 if (*endptr++ == ':') {
4156 int stream_idx = strtol(endptr, NULL, 0);
4157 return stream_idx >= 0 &&
4158 stream_idx < s->programs[i]->nb_stream_indexes &&
4159 st->index == s->programs[i]->stream_index[stream_idx];
4162 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4163 if (st->index == s->programs[i]->stream_index[j])
4167 } else if (*spec == '#' ||
4168 (*spec == 'i' && *(spec + 1) == ':')) {
4171 spec += 1 + (*spec == 'i');
4172 stream_id = strtol(spec, &endptr, 0);
4174 return stream_id == st->id;
4175 } else if (*spec == 'm' && *(spec + 1) == ':') {
4176 AVDictionaryEntry *tag;
4181 val = strchr(spec, ':');
4183 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4185 return AVERROR(ENOMEM);
4187 tag = av_dict_get(st->metadata, key, NULL, 0);
4189 if (!val || !strcmp(tag->value, val + 1))
4198 } else if (!*spec) /* empty specifier, matches everything */
4201 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4202 return AVERROR(EINVAL);
4205 int ff_generate_avci_extradata(AVStream *st)
4207 static const uint8_t avci100_1080p_extradata[] = {
4209 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4210 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4211 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4212 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4213 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4214 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4215 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4216 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4217 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4219 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4222 static const uint8_t avci100_1080i_extradata[] = {
4224 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4225 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4226 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4227 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4228 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4229 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4230 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4231 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4232 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4233 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4234 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4236 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4239 static const uint8_t avci50_1080i_extradata[] = {
4241 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4242 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4243 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4244 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4245 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4246 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4247 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4248 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4249 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4250 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4251 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4253 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4256 static const uint8_t avci100_720p_extradata[] = {
4258 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4259 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4260 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4261 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4262 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4263 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4264 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4265 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4266 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4267 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4269 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4273 const uint8_t *data = NULL;
4276 if (st->codec->width == 1920) {
4277 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4278 data = avci100_1080p_extradata;
4279 size = sizeof(avci100_1080p_extradata);
4281 data = avci100_1080i_extradata;
4282 size = sizeof(avci100_1080i_extradata);
4284 } else if (st->codec->width == 1440) {
4285 data = avci50_1080i_extradata;
4286 size = sizeof(avci50_1080i_extradata);
4287 } else if (st->codec->width == 1280) {
4288 data = avci100_720p_extradata;
4289 size = sizeof(avci100_720p_extradata);
4295 av_freep(&st->codec->extradata);
4296 if (ff_alloc_extradata(st->codec, size))
4297 return AVERROR(ENOMEM);
4298 memcpy(st->codec->extradata, data, size);
4303 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4308 for (i = 0; i < st->nb_side_data; i++) {
4309 if (st->side_data[i].type == type) {
4311 *size = st->side_data[i].size;
4312 return st->side_data[i].data;