2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/internal.h"
40 #include "libavcodec/raw.h"
42 #include "audiointerleave.h"
44 #include "avio_internal.h"
54 #include "libavutil/ffversion.h"
55 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
59 * various utility functions for use within FFmpeg
62 unsigned avformat_version(void)
64 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
65 return LIBAVFORMAT_VERSION_INT;
68 const char *avformat_configuration(void)
70 return FFMPEG_CONFIGURATION;
73 const char *avformat_license(void)
75 #define LICENSE_PREFIX "libavformat license: "
76 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
79 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
81 static int is_relative(int64_t ts) {
82 return ts > (RELATIVE_TS_BASE - (1LL<<48));
86 * Wrap a given time stamp, if there is an indication for an overflow
89 * @param timestamp the time stamp to wrap
90 * @return resulting time stamp
92 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
94 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
95 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
96 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
97 timestamp < st->pts_wrap_reference)
98 return timestamp + (1ULL << st->pts_wrap_bits);
99 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
100 timestamp >= st->pts_wrap_reference)
101 return timestamp - (1ULL << st->pts_wrap_bits);
106 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
107 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
113 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
114 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
115 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
117 int64_t av_stream_get_end_pts(const AVStream *st)
120 return st->priv_pts->val;
122 return AV_NOPTS_VALUE;
125 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
130 void av_format_inject_global_side_data(AVFormatContext *s)
133 s->internal->inject_global_side_data = 1;
134 for (i = 0; i < s->nb_streams; i++) {
135 AVStream *st = s->streams[i];
136 st->inject_global_side_data = 1;
140 int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
142 av_assert0(!dst->codec_whitelist && !dst->format_whitelist);
143 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
144 dst->format_whitelist = av_strdup(src->format_whitelist);
145 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
146 || (src->format_whitelist && !dst->format_whitelist)) {
147 av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
148 return AVERROR(ENOMEM);
153 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
155 if (st->codec->codec)
156 return st->codec->codec;
158 switch (st->codec->codec_type) {
159 case AVMEDIA_TYPE_VIDEO:
160 if (s->video_codec) return s->video_codec;
162 case AVMEDIA_TYPE_AUDIO:
163 if (s->audio_codec) return s->audio_codec;
165 case AVMEDIA_TYPE_SUBTITLE:
166 if (s->subtitle_codec) return s->subtitle_codec;
170 return avcodec_find_decoder(codec_id);
173 int av_format_get_probe_score(const AVFormatContext *s)
175 return s->probe_score;
178 /* an arbitrarily chosen "sane" max packet size -- 50M */
179 #define SANE_CHUNK_SIZE (50000000)
181 int ffio_limit(AVIOContext *s, int size)
183 if (s->maxsize>= 0) {
184 int64_t remaining= s->maxsize - avio_tell(s);
185 if (remaining < size) {
186 int64_t newsize = avio_size(s);
187 if (!s->maxsize || s->maxsize<newsize)
188 s->maxsize = newsize - !newsize;
189 remaining= s->maxsize - avio_tell(s);
190 remaining= FFMAX(remaining, 0);
193 if (s->maxsize>= 0 && remaining+1 < size) {
194 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
201 /* Read the data in sane-sized chunks and append to pkt.
202 * Return the number of bytes read or an error. */
203 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
205 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
206 int orig_size = pkt->size;
210 int prev_size = pkt->size;
213 /* When the caller requests a lot of data, limit it to the amount
214 * left in file or SANE_CHUNK_SIZE when it is not known. */
216 if (read_size > SANE_CHUNK_SIZE/10) {
217 read_size = ffio_limit(s, read_size);
218 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
220 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
223 ret = av_grow_packet(pkt, read_size);
227 ret = avio_read(s, pkt->data + prev_size, read_size);
228 if (ret != read_size) {
229 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
236 pkt->flags |= AV_PKT_FLAG_CORRUPT;
241 return pkt->size > orig_size ? pkt->size - orig_size : ret;
244 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
249 pkt->pos = avio_tell(s);
251 return append_packet_chunked(s, pkt, size);
254 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
257 return av_get_packet(s, pkt, size);
258 return append_packet_chunked(s, pkt, size);
261 int av_filename_number_test(const char *filename)
265 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
268 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
271 static const struct {
274 enum AVMediaType type;
276 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
277 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
278 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
279 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
280 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
281 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
282 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
283 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
284 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
285 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
286 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
290 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
292 if (fmt && st->request_probe <= score) {
294 av_log(s, AV_LOG_DEBUG,
295 "Probe with size=%d, packets=%d detected %s with score=%d\n",
296 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
298 for (i = 0; fmt_id_type[i].name; i++) {
299 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
300 st->codec->codec_id = fmt_id_type[i].id;
301 st->codec->codec_type = fmt_id_type[i].type;
309 /************************************************************/
310 /* input media file */
312 int av_demuxer_open(AVFormatContext *ic) {
315 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
316 av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
317 return AVERROR(EINVAL);
320 if (ic->iformat->read_header) {
321 err = ic->iformat->read_header(ic);
326 if (ic->pb && !ic->internal->data_offset)
327 ic->internal->data_offset = avio_tell(ic->pb);
332 /* Open input file and probe the format if necessary. */
333 static int init_input(AVFormatContext *s, const char *filename,
334 AVDictionary **options)
337 AVProbeData pd = { filename, NULL, 0 };
338 int score = AVPROBE_SCORE_RETRY;
341 s->flags |= AVFMT_FLAG_CUSTOM_IO;
343 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
344 s, 0, s->format_probesize);
345 else if (s->iformat->flags & AVFMT_NOFILE)
346 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
347 "will be ignored with AVFMT_NOFILE format.\n");
351 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
352 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
355 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
356 &s->interrupt_callback, options)) < 0)
360 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
361 s, 0, s->format_probesize);
364 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
365 AVPacketList **plast_pktl)
367 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
372 (*plast_pktl)->next = pktl;
374 *packet_buffer = pktl;
376 /* Add the packet in the buffered packet list. */
382 int avformat_queue_attached_pictures(AVFormatContext *s)
385 for (i = 0; i < s->nb_streams; i++)
386 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
387 s->streams[i]->discard < AVDISCARD_ALL) {
388 AVPacket copy = s->streams[i]->attached_pic;
389 if (copy.size <= 0) {
390 av_log(s, AV_LOG_WARNING,
391 "Attached picture on stream %d has invalid size, "
395 copy.buf = av_buffer_ref(copy.buf);
397 return AVERROR(ENOMEM);
399 add_to_pktbuf(&s->internal->raw_packet_buffer, ©,
400 &s->internal->raw_packet_buffer_end);
405 int avformat_open_input(AVFormatContext **ps, const char *filename,
406 AVInputFormat *fmt, AVDictionary **options)
408 AVFormatContext *s = *ps;
410 AVDictionary *tmp = NULL;
411 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
413 if (!s && !(s = avformat_alloc_context()))
414 return AVERROR(ENOMEM);
416 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
417 return AVERROR(EINVAL);
423 av_dict_copy(&tmp, *options, 0);
425 if (s->pb) // must be before any goto fail
426 s->flags |= AVFMT_FLAG_CUSTOM_IO;
428 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
431 if ((ret = init_input(s, filename, &tmp)) < 0)
433 s->probe_score = ret;
435 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
436 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
437 ret = AVERROR(EINVAL);
441 avio_skip(s->pb, s->skip_initial_bytes);
443 /* Check filename in case an image number is expected. */
444 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
445 if (!av_filename_number_test(filename)) {
446 ret = AVERROR(EINVAL);
451 s->duration = s->start_time = AV_NOPTS_VALUE;
452 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
454 /* Allocate private data. */
455 if (s->iformat->priv_data_size > 0) {
456 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
457 ret = AVERROR(ENOMEM);
460 if (s->iformat->priv_class) {
461 *(const AVClass **) s->priv_data = s->iformat->priv_class;
462 av_opt_set_defaults(s->priv_data);
463 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
468 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
470 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
472 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
473 if ((ret = s->iformat->read_header(s)) < 0)
476 if (id3v2_extra_meta) {
477 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
478 !strcmp(s->iformat->name, "tta")) {
479 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
482 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
484 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
486 if ((ret = avformat_queue_attached_pictures(s)) < 0)
489 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
490 s->internal->data_offset = avio_tell(s->pb);
492 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
495 av_dict_free(options);
502 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
504 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
506 avformat_free_context(s);
511 /*******************************************************/
513 static void force_codec_ids(AVFormatContext *s, AVStream *st)
515 switch (st->codec->codec_type) {
516 case AVMEDIA_TYPE_VIDEO:
517 if (s->video_codec_id)
518 st->codec->codec_id = s->video_codec_id;
520 case AVMEDIA_TYPE_AUDIO:
521 if (s->audio_codec_id)
522 st->codec->codec_id = s->audio_codec_id;
524 case AVMEDIA_TYPE_SUBTITLE:
525 if (s->subtitle_codec_id)
526 st->codec->codec_id = s->subtitle_codec_id;
531 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
533 if (st->request_probe>0) {
534 AVProbeData *pd = &st->probe_data;
536 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
540 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
542 av_log(s, AV_LOG_WARNING,
543 "Failed to reallocate probe buffer for stream %d\n",
548 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
549 pd->buf_size += pkt->size;
550 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
553 st->probe_packets = 0;
555 av_log(s, AV_LOG_WARNING,
556 "nothing to probe for stream %d\n", st->index);
560 end= s->internal->raw_packet_buffer_remaining_size <= 0
561 || st->probe_packets<= 0;
563 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
564 int score = set_codec_from_probe_data(s, st, pd);
565 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
569 st->request_probe = -1;
570 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
571 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
573 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
575 force_codec_ids(s, st);
581 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
583 int64_t ref = pkt->dts;
584 int i, pts_wrap_behavior;
585 int64_t pts_wrap_reference;
586 AVProgram *first_program;
588 if (ref == AV_NOPTS_VALUE)
590 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
592 ref &= (1LL << st->pts_wrap_bits)-1;
594 // reference time stamp should be 60 s before first time stamp
595 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
596 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
597 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
598 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
599 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
601 first_program = av_find_program_from_stream(s, NULL, stream_index);
603 if (!first_program) {
604 int default_stream_index = av_find_default_stream_index(s);
605 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
606 for (i = 0; i < s->nb_streams; i++) {
607 if (av_find_program_from_stream(s, NULL, i))
609 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
610 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
614 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
615 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
619 AVProgram *program = first_program;
621 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
622 pts_wrap_reference = program->pts_wrap_reference;
623 pts_wrap_behavior = program->pts_wrap_behavior;
626 program = av_find_program_from_stream(s, program, stream_index);
629 // update every program with differing pts_wrap_reference
630 program = first_program;
632 if (program->pts_wrap_reference != pts_wrap_reference) {
633 for (i = 0; i<program->nb_stream_indexes; i++) {
634 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
635 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
638 program->pts_wrap_reference = pts_wrap_reference;
639 program->pts_wrap_behavior = pts_wrap_behavior;
641 program = av_find_program_from_stream(s, program, stream_index);
647 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
653 AVPacketList *pktl = s->internal->raw_packet_buffer;
657 st = s->streams[pkt->stream_index];
658 if (s->internal->raw_packet_buffer_remaining_size <= 0)
659 if ((err = probe_codec(s, st, NULL)) < 0)
661 if (st->request_probe <= 0) {
662 s->internal->raw_packet_buffer = pktl->next;
663 s->internal->raw_packet_buffer_remaining_size += pkt->size;
672 ret = s->iformat->read_packet(s, pkt);
674 if (!pktl || ret == AVERROR(EAGAIN))
676 for (i = 0; i < s->nb_streams; i++) {
678 if (st->probe_packets)
679 if ((err = probe_codec(s, st, NULL)) < 0)
681 av_assert0(st->request_probe <= 0);
686 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
687 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
688 av_log(s, AV_LOG_WARNING,
689 "Dropped corrupted packet (stream = %d)\n",
695 if (pkt->stream_index >= (unsigned)s->nb_streams) {
696 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
700 st = s->streams[pkt->stream_index];
702 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
703 // correct first time stamps to negative values
704 if (!is_relative(st->first_dts))
705 st->first_dts = wrap_timestamp(st, st->first_dts);
706 if (!is_relative(st->start_time))
707 st->start_time = wrap_timestamp(st, st->start_time);
708 if (!is_relative(st->cur_dts))
709 st->cur_dts = wrap_timestamp(st, st->cur_dts);
712 pkt->dts = wrap_timestamp(st, pkt->dts);
713 pkt->pts = wrap_timestamp(st, pkt->pts);
715 force_codec_ids(s, st);
717 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
718 if (s->use_wallclock_as_timestamps)
719 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
721 if (!pktl && st->request_probe <= 0)
724 add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
725 &s->internal->raw_packet_buffer_end);
726 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
728 if ((err = probe_codec(s, st, pkt)) < 0)
734 /**********************************************************/
736 static int determinable_frame_size(AVCodecContext *avctx)
738 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
739 avctx->codec_id == AV_CODEC_ID_MP1 ||
740 avctx->codec_id == AV_CODEC_ID_MP2 ||
741 avctx->codec_id == AV_CODEC_ID_MP3/* ||
742 avctx->codec_id == AV_CODEC_ID_CELT*/)
748 * Return the frame duration in seconds. Return 0 if not available.
750 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
751 AVCodecParserContext *pc, AVPacket *pkt)
753 AVRational codec_framerate = s->iformat ? st->codec->framerate :
754 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
759 switch (st->codec->codec_type) {
760 case AVMEDIA_TYPE_VIDEO:
761 if (st->r_frame_rate.num && !pc && s->iformat) {
762 *pnum = st->r_frame_rate.den;
763 *pden = st->r_frame_rate.num;
764 } else if (st->time_base.num * 1000LL > st->time_base.den) {
765 *pnum = st->time_base.num;
766 *pden = st->time_base.den;
767 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
768 av_assert0(st->codec->ticks_per_frame);
769 av_reduce(pnum, pden,
771 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
774 if (pc && pc->repeat_pict) {
775 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
776 av_reduce(pnum, pden,
777 (*pnum) * (1LL + pc->repeat_pict),
781 /* If this codec can be interlaced or progressive then we need
782 * a parser to compute duration of a packet. Thus if we have
783 * no parser in such case leave duration undefined. */
784 if (st->codec->ticks_per_frame > 1 && !pc)
788 case AVMEDIA_TYPE_AUDIO:
789 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
790 if (frame_size <= 0 || st->codec->sample_rate <= 0)
793 *pden = st->codec->sample_rate;
800 static int is_intra_only(AVCodecContext *enc) {
801 const AVCodecDescriptor *desc;
803 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
806 desc = av_codec_get_codec_descriptor(enc);
808 desc = avcodec_descriptor_get(enc->codec_id);
809 av_codec_set_codec_descriptor(enc, desc);
812 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
816 static int has_decode_delay_been_guessed(AVStream *st)
818 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
819 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
821 #if CONFIG_H264_DECODER
822 if (st->codec->has_b_frames &&
823 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
826 if (st->codec->has_b_frames<3)
827 return st->nb_decoded_frames >= 7;
828 else if (st->codec->has_b_frames<4)
829 return st->nb_decoded_frames >= 18;
831 return st->nb_decoded_frames >= 20;
834 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
838 if (pktl == s->internal->packet_buffer_end)
839 return s->internal->parse_queue;
843 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
844 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
845 st->codec->codec_id != AV_CODEC_ID_HEVC;
848 int delay = st->codec->has_b_frames;
851 if (dts == AV_NOPTS_VALUE) {
852 int64_t best_score = INT64_MAX;
853 for (i = 0; i<delay; i++) {
854 if (st->pts_reorder_error_count[i]) {
855 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
856 if (score < best_score) {
863 for (i = 0; i<delay; i++) {
864 if (pts_buffer[i] != AV_NOPTS_VALUE) {
865 int64_t diff = FFABS(pts_buffer[i] - dts)
866 + (uint64_t)st->pts_reorder_error[i];
867 diff = FFMAX(diff, st->pts_reorder_error[i]);
868 st->pts_reorder_error[i] = diff;
869 st->pts_reorder_error_count[i]++;
870 if (st->pts_reorder_error_count[i] > 250) {
871 st->pts_reorder_error[i] >>= 1;
872 st->pts_reorder_error_count[i] >>= 1;
879 if (dts == AV_NOPTS_VALUE)
885 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
886 int64_t dts, int64_t pts, AVPacket *pkt)
888 AVStream *st = s->streams[stream_index];
889 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
890 int64_t pts_buffer[MAX_REORDER_DELAY+1];
894 if (st->first_dts != AV_NOPTS_VALUE ||
895 dts == AV_NOPTS_VALUE ||
896 st->cur_dts == AV_NOPTS_VALUE ||
900 delay = st->codec->has_b_frames;
901 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
903 shift = st->first_dts - RELATIVE_TS_BASE;
905 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
906 pts_buffer[i] = AV_NOPTS_VALUE;
908 if (is_relative(pts))
911 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
912 if (pktl->pkt.stream_index != stream_index)
914 if (is_relative(pktl->pkt.pts))
915 pktl->pkt.pts += shift;
917 if (is_relative(pktl->pkt.dts))
918 pktl->pkt.dts += shift;
920 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
921 st->start_time = pktl->pkt.pts;
923 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
924 pts_buffer[0] = pktl->pkt.pts;
925 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
926 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
928 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
932 if (st->start_time == AV_NOPTS_VALUE)
933 st->start_time = pts;
936 static void update_initial_durations(AVFormatContext *s, AVStream *st,
937 int stream_index, int duration)
939 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
940 int64_t cur_dts = RELATIVE_TS_BASE;
942 if (st->first_dts != AV_NOPTS_VALUE) {
943 if (st->update_initial_durations_done)
945 st->update_initial_durations_done = 1;
946 cur_dts = st->first_dts;
947 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
948 if (pktl->pkt.stream_index == stream_index) {
949 if (pktl->pkt.pts != pktl->pkt.dts ||
950 pktl->pkt.dts != AV_NOPTS_VALUE ||
956 if (pktl && pktl->pkt.dts != st->first_dts) {
957 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
958 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
962 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
965 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
966 st->first_dts = cur_dts;
967 } else if (st->cur_dts != RELATIVE_TS_BASE)
970 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
971 if (pktl->pkt.stream_index != stream_index)
973 if (pktl->pkt.pts == pktl->pkt.dts &&
974 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
975 !pktl->pkt.duration) {
976 pktl->pkt.dts = cur_dts;
977 if (!st->codec->has_b_frames)
978 pktl->pkt.pts = cur_dts;
979 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
980 pktl->pkt.duration = duration;
983 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
986 st->cur_dts = cur_dts;
989 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
990 AVCodecParserContext *pc, AVPacket *pkt,
991 int64_t next_dts, int64_t next_pts)
993 int num, den, presentation_delayed, delay, i;
996 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
997 st->codec->codec_id != AV_CODEC_ID_HEVC;
999 if (s->flags & AVFMT_FLAG_NOFILLIN)
1002 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1003 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1004 if (st->last_dts_for_order_check <= pkt->dts) {
1007 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1008 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1010 st->last_dts_for_order_check);
1011 st->dts_misordered++;
1013 if (st->dts_ordered + st->dts_misordered > 250) {
1014 st->dts_ordered >>= 1;
1015 st->dts_misordered >>= 1;
1019 st->last_dts_for_order_check = pkt->dts;
1020 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1021 pkt->dts = AV_NOPTS_VALUE;
1024 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1025 pkt->dts = AV_NOPTS_VALUE;
1027 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1028 && !st->codec->has_b_frames)
1029 //FIXME Set low_delay = 0 when has_b_frames = 1
1030 st->codec->has_b_frames = 1;
1032 /* do we have a video B-frame ? */
1033 delay = st->codec->has_b_frames;
1034 presentation_delayed = 0;
1036 /* XXX: need has_b_frame, but cannot get it if the codec is
1037 * not initialized */
1039 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1040 presentation_delayed = 1;
1042 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1043 st->pts_wrap_bits < 63 &&
1044 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1045 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1046 pkt->dts -= 1LL << st->pts_wrap_bits;
1048 pkt->pts += 1LL << st->pts_wrap_bits;
1051 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1052 * We take the conservative approach and discard both.
1053 * Note: If this is misbehaving for an H.264 file, then possibly
1054 * presentation_delayed is not set correctly. */
1055 if (delay == 1 && pkt->dts == pkt->pts &&
1056 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1057 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1058 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1059 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1060 pkt->dts = AV_NOPTS_VALUE;
1063 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1064 if (pkt->duration == 0) {
1065 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1067 duration = (AVRational) {num, den};
1068 pkt->duration = av_rescale_rnd(1,
1069 num * (int64_t) st->time_base.den,
1070 den * (int64_t) st->time_base.num,
1075 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1076 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1078 /* Correct timestamps with byte offset if demuxers only have timestamps
1079 * on packet boundaries */
1080 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1081 /* this will estimate bitrate based on this frame's duration and size */
1082 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1083 if (pkt->pts != AV_NOPTS_VALUE)
1085 if (pkt->dts != AV_NOPTS_VALUE)
1089 /* This may be redundant, but it should not hurt. */
1090 if (pkt->dts != AV_NOPTS_VALUE &&
1091 pkt->pts != AV_NOPTS_VALUE &&
1092 pkt->pts > pkt->dts)
1093 presentation_delayed = 1;
1095 if (s->debug & FF_FDEBUG_TS)
1096 av_log(s, AV_LOG_TRACE,
1097 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1098 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1099 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1101 /* Interpolate PTS and DTS if they are not present. We skip H264
1102 * currently because delay and has_b_frames are not reliably set. */
1103 if ((delay == 0 || (delay == 1 && pc)) &&
1105 if (presentation_delayed) {
1106 /* DTS = decompression timestamp */
1107 /* PTS = presentation timestamp */
1108 if (pkt->dts == AV_NOPTS_VALUE)
1109 pkt->dts = st->last_IP_pts;
1110 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1111 if (pkt->dts == AV_NOPTS_VALUE)
1112 pkt->dts = st->cur_dts;
1114 /* This is tricky: the dts must be incremented by the duration
1115 * of the frame we are displaying, i.e. the last I- or P-frame. */
1116 if (st->last_IP_duration == 0)
1117 st->last_IP_duration = pkt->duration;
1118 if (pkt->dts != AV_NOPTS_VALUE)
1119 st->cur_dts = pkt->dts + st->last_IP_duration;
1120 if (pkt->dts != AV_NOPTS_VALUE &&
1121 pkt->pts == AV_NOPTS_VALUE &&
1122 st->last_IP_duration > 0 &&
1123 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1124 next_dts != next_pts &&
1125 next_pts != AV_NOPTS_VALUE)
1126 pkt->pts = next_dts;
1128 st->last_IP_duration = pkt->duration;
1129 st->last_IP_pts = pkt->pts;
1130 /* Cannot compute PTS if not present (we can compute it only
1131 * by knowing the future. */
1132 } else if (pkt->pts != AV_NOPTS_VALUE ||
1133 pkt->dts != AV_NOPTS_VALUE ||
1136 /* presentation is not delayed : PTS and DTS are the same */
1137 if (pkt->pts == AV_NOPTS_VALUE)
1138 pkt->pts = pkt->dts;
1139 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1141 if (pkt->pts == AV_NOPTS_VALUE)
1142 pkt->pts = st->cur_dts;
1143 pkt->dts = pkt->pts;
1144 if (pkt->pts != AV_NOPTS_VALUE)
1145 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1149 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1150 st->pts_buffer[0] = pkt->pts;
1151 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1152 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1154 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1156 // We skipped it above so we try here.
1158 // This should happen on the first packet
1159 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1160 if (pkt->dts > st->cur_dts)
1161 st->cur_dts = pkt->dts;
1163 if (s->debug & FF_FDEBUG_TS)
1164 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1165 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1168 if (is_intra_only(st->codec))
1169 pkt->flags |= AV_PKT_FLAG_KEY;
1171 pkt->convergence_duration = pc->convergence_duration;
1174 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1177 AVPacketList *pktl = *pkt_buf;
1178 *pkt_buf = pktl->next;
1179 av_free_packet(&pktl->pkt);
1182 *pkt_buf_end = NULL;
1186 * Parse a packet, add all split parts to parse_queue.
1188 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1190 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1192 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1193 AVStream *st = s->streams[stream_index];
1194 uint8_t *data = pkt ? pkt->data : NULL;
1195 int size = pkt ? pkt->size : 0;
1196 int ret = 0, got_output = 0;
1199 av_init_packet(&flush_pkt);
1202 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1203 // preserve 0-size sync packets
1204 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1207 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1209 int64_t next_pts = pkt->pts;
1210 int64_t next_dts = pkt->dts;
1212 av_init_packet(&out_pkt);
1213 len = av_parser_parse2(st->parser, st->codec,
1214 &out_pkt.data, &out_pkt.size, data, size,
1215 pkt->pts, pkt->dts, pkt->pos);
1217 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1219 /* increment read pointer */
1223 got_output = !!out_pkt.size;
1228 if (pkt->side_data) {
1229 out_pkt.side_data = pkt->side_data;
1230 out_pkt.side_data_elems = pkt->side_data_elems;
1231 pkt->side_data = NULL;
1232 pkt->side_data_elems = 0;
1235 /* set the duration */
1236 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1237 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1238 if (st->codec->sample_rate > 0) {
1240 av_rescale_q_rnd(st->parser->duration,
1241 (AVRational) { 1, st->codec->sample_rate },
1247 out_pkt.stream_index = st->index;
1248 out_pkt.pts = st->parser->pts;
1249 out_pkt.dts = st->parser->dts;
1250 out_pkt.pos = st->parser->pos;
1252 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1253 out_pkt.pos = st->parser->frame_offset;
1255 if (st->parser->key_frame == 1 ||
1256 (st->parser->key_frame == -1 &&
1257 st->parser->pict_type == AV_PICTURE_TYPE_I))
1258 out_pkt.flags |= AV_PKT_FLAG_KEY;
1260 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1261 out_pkt.flags |= AV_PKT_FLAG_KEY;
1263 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1265 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1266 out_pkt.buf = pkt->buf;
1269 if ((ret = av_dup_packet(&out_pkt)) < 0)
1272 if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
1273 av_free_packet(&out_pkt);
1274 ret = AVERROR(ENOMEM);
1279 /* end of the stream => close and free the parser */
1280 if (pkt == &flush_pkt) {
1281 av_parser_close(st->parser);
1286 av_free_packet(pkt);
1290 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1291 AVPacketList **pkt_buffer_end,
1295 av_assert0(*pkt_buffer);
1298 *pkt_buffer = pktl->next;
1300 *pkt_buffer_end = NULL;
1305 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1307 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1310 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1312 int ret = 0, i, got_packet = 0;
1313 AVDictionary *metadata = NULL;
1315 av_init_packet(pkt);
1317 while (!got_packet && !s->internal->parse_queue) {
1321 /* read next packet */
1322 ret = ff_read_packet(s, &cur_pkt);
1324 if (ret == AVERROR(EAGAIN))
1326 /* flush the parsers */
1327 for (i = 0; i < s->nb_streams; i++) {
1329 if (st->parser && st->need_parsing)
1330 parse_packet(s, NULL, st->index);
1332 /* all remaining packets are now in parse_queue =>
1333 * really terminate parsing */
1337 st = s->streams[cur_pkt.stream_index];
1339 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1340 cur_pkt.dts != AV_NOPTS_VALUE &&
1341 cur_pkt.pts < cur_pkt.dts) {
1342 av_log(s, AV_LOG_WARNING,
1343 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1344 cur_pkt.stream_index,
1345 av_ts2str(cur_pkt.pts),
1346 av_ts2str(cur_pkt.dts),
1349 if (s->debug & FF_FDEBUG_TS)
1350 av_log(s, AV_LOG_DEBUG,
1351 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1352 cur_pkt.stream_index,
1353 av_ts2str(cur_pkt.pts),
1354 av_ts2str(cur_pkt.dts),
1355 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1357 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1358 st->parser = av_parser_init(st->codec->codec_id);
1360 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1361 "%s, packets or times may be invalid.\n",
1362 avcodec_get_name(st->codec->codec_id));
1363 /* no parser available: just output the raw packets */
1364 st->need_parsing = AVSTREAM_PARSE_NONE;
1365 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1366 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1367 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1368 st->parser->flags |= PARSER_FLAG_ONCE;
1369 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1370 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1373 if (!st->need_parsing || !st->parser) {
1374 /* no parsing needed: we just output the packet as is */
1376 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1377 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1378 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1379 ff_reduce_index(s, st->index);
1380 av_add_index_entry(st, pkt->pos, pkt->dts,
1381 0, 0, AVINDEX_KEYFRAME);
1384 } else if (st->discard < AVDISCARD_ALL) {
1385 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1389 av_free_packet(&cur_pkt);
1391 if (pkt->flags & AV_PKT_FLAG_KEY)
1392 st->skip_to_keyframe = 0;
1393 if (st->skip_to_keyframe) {
1394 av_free_packet(&cur_pkt);
1402 if (!got_packet && s->internal->parse_queue)
1403 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1406 AVStream *st = s->streams[pkt->stream_index];
1407 int discard_padding = 0;
1408 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1409 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1410 int64_t sample = ts_to_samples(st, pts);
1411 int duration = ts_to_samples(st, pkt->duration);
1412 int64_t end_sample = sample + duration;
1413 if (duration > 0 && end_sample >= st->first_discard_sample &&
1414 sample < st->last_discard_sample)
1415 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1417 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1418 st->skip_samples = st->start_skip_samples;
1419 if (st->skip_samples || discard_padding) {
1420 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1422 AV_WL32(p, st->skip_samples);
1423 AV_WL32(p + 4, discard_padding);
1424 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1426 st->skip_samples = 0;
1429 if (st->inject_global_side_data) {
1430 for (i = 0; i < st->nb_side_data; i++) {
1431 AVPacketSideData *src_sd = &st->side_data[i];
1434 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1437 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1439 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1443 memcpy(dst_data, src_sd->data, src_sd->size);
1445 st->inject_global_side_data = 0;
1448 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1449 av_packet_merge_side_data(pkt);
1452 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1454 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1455 av_dict_copy(&s->metadata, metadata, 0);
1456 av_dict_free(&metadata);
1457 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1460 if (s->debug & FF_FDEBUG_TS)
1461 av_log(s, AV_LOG_DEBUG,
1462 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1463 "size=%d, duration=%d, flags=%d\n",
1465 av_ts2str(pkt->pts),
1466 av_ts2str(pkt->dts),
1467 pkt->size, pkt->duration, pkt->flags);
1472 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1474 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1480 ret = s->internal->packet_buffer
1481 ? read_from_packet_buffer(&s->internal->packet_buffer,
1482 &s->internal->packet_buffer_end, pkt)
1483 : read_frame_internal(s, pkt);
1490 AVPacketList *pktl = s->internal->packet_buffer;
1493 AVPacket *next_pkt = &pktl->pkt;
1495 if (next_pkt->dts != AV_NOPTS_VALUE) {
1496 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1497 // last dts seen for this stream. if any of packets following
1498 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1499 int64_t last_dts = next_pkt->dts;
1500 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1501 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1502 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1503 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1505 next_pkt->pts = pktl->pkt.dts;
1507 if (last_dts != AV_NOPTS_VALUE) {
1508 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1509 last_dts = pktl->pkt.dts;
1514 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1515 // Fixing the last reference frame had none pts issue (For MXF etc).
1516 // We only do this when
1518 // 2. we are not able to resolve a pts value for current packet.
1519 // 3. the packets for this stream at the end of the files had valid dts.
1520 next_pkt->pts = last_dts + next_pkt->duration;
1522 pktl = s->internal->packet_buffer;
1525 /* read packet from packet buffer, if there is data */
1526 st = s->streams[next_pkt->stream_index];
1527 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1528 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1529 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1530 &s->internal->packet_buffer_end, pkt);
1535 ret = read_frame_internal(s, pkt);
1537 if (pktl && ret != AVERROR(EAGAIN)) {
1544 if (av_dup_packet(add_to_pktbuf(&s->internal->packet_buffer, pkt,
1545 &s->internal->packet_buffer_end)) < 0)
1546 return AVERROR(ENOMEM);
1551 st = s->streams[pkt->stream_index];
1552 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1553 ff_reduce_index(s, st->index);
1554 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1557 if (is_relative(pkt->dts))
1558 pkt->dts -= RELATIVE_TS_BASE;
1559 if (is_relative(pkt->pts))
1560 pkt->pts -= RELATIVE_TS_BASE;
1565 /* XXX: suppress the packet queue */
1566 static void flush_packet_queue(AVFormatContext *s)
1570 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1571 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1572 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1574 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1577 /*******************************************************/
1580 int av_find_default_stream_index(AVFormatContext *s)
1584 int best_stream = 0;
1585 int best_score = INT_MIN;
1587 if (s->nb_streams <= 0)
1589 for (i = 0; i < s->nb_streams; i++) {
1592 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1593 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1595 if (st->codec->width && st->codec->height)
1599 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1600 if (st->codec->sample_rate)
1603 if (st->codec_info_nb_frames)
1606 if (st->discard != AVDISCARD_ALL)
1609 if (score > best_score) {
1617 /** Flush the frame reader. */
1618 void ff_read_frame_flush(AVFormatContext *s)
1623 flush_packet_queue(s);
1625 /* Reset read state for each stream. */
1626 for (i = 0; i < s->nb_streams; i++) {
1630 av_parser_close(st->parser);
1633 st->last_IP_pts = AV_NOPTS_VALUE;
1634 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1635 if (st->first_dts == AV_NOPTS_VALUE)
1636 st->cur_dts = RELATIVE_TS_BASE;
1638 /* We set the current DTS to an unspecified origin. */
1639 st->cur_dts = AV_NOPTS_VALUE;
1641 st->probe_packets = MAX_PROBE_PACKETS;
1643 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1644 st->pts_buffer[j] = AV_NOPTS_VALUE;
1646 if (s->internal->inject_global_side_data)
1647 st->inject_global_side_data = 1;
1649 st->skip_samples = 0;
1653 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1657 for (i = 0; i < s->nb_streams; i++) {
1658 AVStream *st = s->streams[i];
1661 av_rescale(timestamp,
1662 st->time_base.den * (int64_t) ref_st->time_base.num,
1663 st->time_base.num * (int64_t) ref_st->time_base.den);
1667 void ff_reduce_index(AVFormatContext *s, int stream_index)
1669 AVStream *st = s->streams[stream_index];
1670 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1672 if ((unsigned) st->nb_index_entries >= max_entries) {
1674 for (i = 0; 2 * i < st->nb_index_entries; i++)
1675 st->index_entries[i] = st->index_entries[2 * i];
1676 st->nb_index_entries = i;
1680 int ff_add_index_entry(AVIndexEntry **index_entries,
1681 int *nb_index_entries,
1682 unsigned int *index_entries_allocated_size,
1683 int64_t pos, int64_t timestamp,
1684 int size, int distance, int flags)
1686 AVIndexEntry *entries, *ie;
1689 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1692 if (timestamp == AV_NOPTS_VALUE)
1693 return AVERROR(EINVAL);
1695 if (size < 0 || size > 0x3FFFFFFF)
1696 return AVERROR(EINVAL);
1698 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1699 timestamp -= RELATIVE_TS_BASE;
1701 entries = av_fast_realloc(*index_entries,
1702 index_entries_allocated_size,
1703 (*nb_index_entries + 1) *
1704 sizeof(AVIndexEntry));
1708 *index_entries = entries;
1710 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1711 timestamp, AVSEEK_FLAG_ANY);
1714 index = (*nb_index_entries)++;
1715 ie = &entries[index];
1716 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1718 ie = &entries[index];
1719 if (ie->timestamp != timestamp) {
1720 if (ie->timestamp <= timestamp)
1722 memmove(entries + index + 1, entries + index,
1723 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1724 (*nb_index_entries)++;
1725 } else if (ie->pos == pos && distance < ie->min_distance)
1726 // do not reduce the distance
1727 distance = ie->min_distance;
1731 ie->timestamp = timestamp;
1732 ie->min_distance = distance;
1739 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1740 int size, int distance, int flags)
1742 timestamp = wrap_timestamp(st, timestamp);
1743 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1744 &st->index_entries_allocated_size, pos,
1745 timestamp, size, distance, flags);
1748 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1749 int64_t wanted_timestamp, int flags)
1757 // Optimize appending index entries at the end.
1758 if (b && entries[b - 1].timestamp < wanted_timestamp)
1763 timestamp = entries[m].timestamp;
1764 if (timestamp >= wanted_timestamp)
1766 if (timestamp <= wanted_timestamp)
1769 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1771 if (!(flags & AVSEEK_FLAG_ANY))
1772 while (m >= 0 && m < nb_entries &&
1773 !(entries[m].flags & AVINDEX_KEYFRAME))
1774 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1776 if (m == nb_entries)
1781 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1784 int64_t pos_delta = 0;
1786 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1787 const char *proto = avio_find_protocol_name(s->filename);
1790 av_log(s, AV_LOG_INFO,
1791 "Protocol name not provided, cannot determine if input is local or "
1792 "a network protocol, buffers and access patterns cannot be configured "
1793 "optimally without knowing the protocol\n");
1796 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1799 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1800 AVStream *st1 = s->streams[ist1];
1801 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1802 AVStream *st2 = s->streams[ist2];
1808 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1809 AVIndexEntry *e1 = &st1->index_entries[i1];
1810 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1812 skip = FFMAX(skip, e1->size);
1813 for (; i2 < st2->nb_index_entries; i2++) {
1814 AVIndexEntry *e2 = &st2->index_entries[i2];
1815 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1816 if (e2_pts - e1_pts < time_tolerance)
1818 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1826 /* XXX This could be adjusted depending on protocol*/
1827 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1828 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1829 ffio_set_buf_size(s->pb, pos_delta);
1830 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
1833 if (skip < (1<<23)) {
1834 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
1838 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1840 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1841 wanted_timestamp, flags);
1844 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1845 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1847 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1848 if (stream_index >= 0)
1849 ts = wrap_timestamp(s->streams[stream_index], ts);
1853 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1854 int64_t target_ts, int flags)
1856 AVInputFormat *avif = s->iformat;
1857 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1858 int64_t ts_min, ts_max, ts;
1863 if (stream_index < 0)
1866 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1869 ts_min = AV_NOPTS_VALUE;
1870 pos_limit = -1; // GCC falsely says it may be uninitialized.
1872 st = s->streams[stream_index];
1873 if (st->index_entries) {
1876 /* FIXME: Whole function must be checked for non-keyframe entries in
1877 * index case, especially read_timestamp(). */
1878 index = av_index_search_timestamp(st, target_ts,
1879 flags | AVSEEK_FLAG_BACKWARD);
1880 index = FFMAX(index, 0);
1881 e = &st->index_entries[index];
1883 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1885 ts_min = e->timestamp;
1886 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1887 pos_min, av_ts2str(ts_min));
1889 av_assert1(index == 0);
1892 index = av_index_search_timestamp(st, target_ts,
1893 flags & ~AVSEEK_FLAG_BACKWARD);
1894 av_assert0(index < st->nb_index_entries);
1896 e = &st->index_entries[index];
1897 av_assert1(e->timestamp >= target_ts);
1899 ts_max = e->timestamp;
1900 pos_limit = pos_max - e->min_distance;
1901 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1902 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1906 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1907 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1912 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1915 ff_read_frame_flush(s);
1916 ff_update_cur_dts(s, st, ts);
1921 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1922 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1924 int64_t step = 1024;
1925 int64_t limit, ts_max;
1926 int64_t filesize = avio_size(s->pb);
1927 int64_t pos_max = filesize - 1;
1930 pos_max = FFMAX(0, (pos_max) - step);
1931 ts_max = ff_read_timestamp(s, stream_index,
1932 &pos_max, limit, read_timestamp);
1934 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1935 if (ts_max == AV_NOPTS_VALUE)
1939 int64_t tmp_pos = pos_max + 1;
1940 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1941 &tmp_pos, INT64_MAX, read_timestamp);
1942 if (tmp_ts == AV_NOPTS_VALUE)
1944 av_assert0(tmp_pos > pos_max);
1947 if (tmp_pos >= filesize)
1959 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1960 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1961 int64_t ts_min, int64_t ts_max,
1962 int flags, int64_t *ts_ret,
1963 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1964 int64_t *, int64_t))
1971 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1973 if (ts_min == AV_NOPTS_VALUE) {
1974 pos_min = s->internal->data_offset;
1975 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1976 if (ts_min == AV_NOPTS_VALUE)
1980 if (ts_min >= target_ts) {
1985 if (ts_max == AV_NOPTS_VALUE) {
1986 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1988 pos_limit = pos_max;
1991 if (ts_max <= target_ts) {
1996 av_assert0(ts_min < ts_max);
1999 while (pos_min < pos_limit) {
2000 av_log(s, AV_LOG_TRACE,
2001 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2002 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2003 av_assert0(pos_limit <= pos_max);
2005 if (no_change == 0) {
2006 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2007 // interpolate position (better than dichotomy)
2008 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2010 pos_min - approximate_keyframe_distance;
2011 } else if (no_change == 1) {
2012 // bisection if interpolation did not change min / max pos last time
2013 pos = (pos_min + pos_limit) >> 1;
2015 /* linear search if bisection failed, can only happen if there
2016 * are very few or no keyframes between min/max */
2021 else if (pos > pos_limit)
2025 // May pass pos_limit instead of -1.
2026 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2031 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2032 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2033 pos_min, pos, pos_max,
2034 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2035 pos_limit, start_pos, no_change);
2036 if (ts == AV_NOPTS_VALUE) {
2037 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2040 if (target_ts <= ts) {
2041 pos_limit = start_pos - 1;
2045 if (target_ts >= ts) {
2051 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2052 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2055 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2057 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2058 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2059 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2065 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2066 int64_t pos, int flags)
2068 int64_t pos_min, pos_max;
2070 pos_min = s->internal->data_offset;
2071 pos_max = avio_size(s->pb) - 1;
2075 else if (pos > pos_max)
2078 avio_seek(s->pb, pos, SEEK_SET);
2080 s->io_repositioned = 1;
2085 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2086 int64_t timestamp, int flags)
2093 st = s->streams[stream_index];
2095 index = av_index_search_timestamp(st, timestamp, flags);
2097 if (index < 0 && st->nb_index_entries &&
2098 timestamp < st->index_entries[0].timestamp)
2101 if (index < 0 || index == st->nb_index_entries - 1) {
2105 if (st->nb_index_entries) {
2106 av_assert0(st->index_entries);
2107 ie = &st->index_entries[st->nb_index_entries - 1];
2108 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2110 ff_update_cur_dts(s, st, ie->timestamp);
2112 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2118 read_status = av_read_frame(s, &pkt);
2119 } while (read_status == AVERROR(EAGAIN));
2120 if (read_status < 0)
2122 av_free_packet(&pkt);
2123 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2124 if (pkt.flags & AV_PKT_FLAG_KEY)
2126 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2127 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);
2132 index = av_index_search_timestamp(st, timestamp, flags);
2137 ff_read_frame_flush(s);
2138 if (s->iformat->read_seek)
2139 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2141 ie = &st->index_entries[index];
2142 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2144 ff_update_cur_dts(s, st, ie->timestamp);
2149 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2150 int64_t timestamp, int flags)
2155 if (flags & AVSEEK_FLAG_BYTE) {
2156 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2158 ff_read_frame_flush(s);
2159 return seek_frame_byte(s, stream_index, timestamp, flags);
2162 if (stream_index < 0) {
2163 stream_index = av_find_default_stream_index(s);
2164 if (stream_index < 0)
2167 st = s->streams[stream_index];
2168 /* timestamp for default must be expressed in AV_TIME_BASE units */
2169 timestamp = av_rescale(timestamp, st->time_base.den,
2170 AV_TIME_BASE * (int64_t) st->time_base.num);
2173 /* first, we try the format specific seek */
2174 if (s->iformat->read_seek) {
2175 ff_read_frame_flush(s);
2176 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2182 if (s->iformat->read_timestamp &&
2183 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2184 ff_read_frame_flush(s);
2185 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2186 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2187 ff_read_frame_flush(s);
2188 return seek_frame_generic(s, stream_index, timestamp, flags);
2193 int av_seek_frame(AVFormatContext *s, int stream_index,
2194 int64_t timestamp, int flags)
2198 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2199 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2200 if ((flags & AVSEEK_FLAG_BACKWARD))
2204 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2205 flags & ~AVSEEK_FLAG_BACKWARD);
2208 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2211 ret = avformat_queue_attached_pictures(s);
2216 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2217 int64_t ts, int64_t max_ts, int flags)
2219 if (min_ts > ts || max_ts < ts)
2221 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2222 return AVERROR(EINVAL);
2225 flags |= AVSEEK_FLAG_ANY;
2226 flags &= ~AVSEEK_FLAG_BACKWARD;
2228 if (s->iformat->read_seek2) {
2230 ff_read_frame_flush(s);
2232 if (stream_index == -1 && s->nb_streams == 1) {
2233 AVRational time_base = s->streams[0]->time_base;
2234 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2235 min_ts = av_rescale_rnd(min_ts, time_base.den,
2236 time_base.num * (int64_t)AV_TIME_BASE,
2237 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2238 max_ts = av_rescale_rnd(max_ts, time_base.den,
2239 time_base.num * (int64_t)AV_TIME_BASE,
2240 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2243 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2247 ret = avformat_queue_attached_pictures(s);
2251 if (s->iformat->read_timestamp) {
2252 // try to seek via read_timestamp()
2255 // Fall back on old API if new is not implemented but old is.
2256 // Note the old API has somewhat different semantics.
2257 if (s->iformat->read_seek || 1) {
2258 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2259 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2260 if (ret<0 && ts != min_ts && max_ts != ts) {
2261 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2263 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2268 // try some generic seek like seek_frame_generic() but with new ts semantics
2269 return -1; //unreachable
2272 int avformat_flush(AVFormatContext *s)
2274 ff_read_frame_flush(s);
2278 /*******************************************************/
2281 * Return TRUE if the stream has accurate duration in any stream.
2283 * @return TRUE if the stream has accurate duration for at least one component.
2285 static int has_duration(AVFormatContext *ic)
2290 for (i = 0; i < ic->nb_streams; i++) {
2291 st = ic->streams[i];
2292 if (st->duration != AV_NOPTS_VALUE)
2295 if (ic->duration != AV_NOPTS_VALUE)
2301 * Estimate the stream timings from the one of each components.
2303 * Also computes the global bitrate if possible.
2305 static void update_stream_timings(AVFormatContext *ic)
2307 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2308 int64_t duration, duration1, filesize;
2313 start_time = INT64_MAX;
2314 start_time_text = INT64_MAX;
2315 end_time = INT64_MIN;
2316 duration = INT64_MIN;
2317 for (i = 0; i < ic->nb_streams; i++) {
2318 st = ic->streams[i];
2319 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2320 start_time1 = av_rescale_q(st->start_time, st->time_base,
2322 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2323 if (start_time1 < start_time_text)
2324 start_time_text = start_time1;
2326 start_time = FFMIN(start_time, start_time1);
2327 end_time1 = AV_NOPTS_VALUE;
2328 if (st->duration != AV_NOPTS_VALUE) {
2329 end_time1 = start_time1 +
2330 av_rescale_q(st->duration, st->time_base,
2332 end_time = FFMAX(end_time, end_time1);
2334 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2335 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2336 p->start_time = start_time1;
2337 if (p->end_time < end_time1)
2338 p->end_time = end_time1;
2341 if (st->duration != AV_NOPTS_VALUE) {
2342 duration1 = av_rescale_q(st->duration, st->time_base,
2344 duration = FFMAX(duration, duration1);
2347 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2348 start_time = start_time_text;
2349 else if (start_time > start_time_text)
2350 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2352 if (start_time != INT64_MAX) {
2353 ic->start_time = start_time;
2354 if (end_time != INT64_MIN) {
2355 if (ic->nb_programs) {
2356 for (i = 0; i < ic->nb_programs; i++) {
2357 p = ic->programs[i];
2358 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2359 duration = FFMAX(duration, p->end_time - p->start_time);
2362 duration = FFMAX(duration, end_time - start_time);
2365 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2366 ic->duration = duration;
2368 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2369 /* compute the bitrate */
2370 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2371 (double) ic->duration;
2372 if (bitrate >= 0 && bitrate <= INT64_MAX)
2373 ic->bit_rate = bitrate;
2377 static void fill_all_stream_timings(AVFormatContext *ic)
2382 update_stream_timings(ic);
2383 for (i = 0; i < ic->nb_streams; i++) {
2384 st = ic->streams[i];
2385 if (st->start_time == AV_NOPTS_VALUE) {
2386 if (ic->start_time != AV_NOPTS_VALUE)
2387 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2389 if (ic->duration != AV_NOPTS_VALUE)
2390 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2396 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2398 int64_t filesize, duration;
2399 int i, show_warning = 0;
2402 /* if bit_rate is already set, we believe it */
2403 if (ic->bit_rate <= 0) {
2405 for (i = 0; i < ic->nb_streams; i++) {
2406 st = ic->streams[i];
2407 if (st->codec->bit_rate > 0) {
2408 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2412 bit_rate += st->codec->bit_rate;
2413 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2414 // If we have a videostream with packets but without a bitrate
2415 // then consider the sum not known
2420 ic->bit_rate = bit_rate;
2423 /* if duration is already set, we believe it */
2424 if (ic->duration == AV_NOPTS_VALUE &&
2425 ic->bit_rate != 0) {
2426 filesize = ic->pb ? avio_size(ic->pb) : 0;
2427 if (filesize > ic->internal->data_offset) {
2428 filesize -= ic->internal->data_offset;
2429 for (i = 0; i < ic->nb_streams; i++) {
2430 st = ic->streams[i];
2431 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2432 && st->duration == AV_NOPTS_VALUE) {
2433 duration = av_rescale(8 * filesize, st->time_base.den,
2435 (int64_t) st->time_base.num);
2436 st->duration = duration;
2443 av_log(ic, AV_LOG_WARNING,
2444 "Estimating duration from bitrate, this may be inaccurate\n");
2447 #define DURATION_MAX_READ_SIZE 250000LL
2448 #define DURATION_MAX_RETRY 4
2450 /* only usable for MPEG-PS streams */
2451 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2453 AVPacket pkt1, *pkt = &pkt1;
2455 int num, den, read_size, i, ret;
2456 int found_duration = 0;
2458 int64_t filesize, offset, duration;
2461 /* flush packet queue */
2462 flush_packet_queue(ic);
2464 for (i = 0; i < ic->nb_streams; i++) {
2465 st = ic->streams[i];
2466 if (st->start_time == AV_NOPTS_VALUE &&
2467 st->first_dts == AV_NOPTS_VALUE &&
2468 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2469 av_log(st->codec, AV_LOG_WARNING,
2470 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2473 av_parser_close(st->parser);
2478 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2479 /* estimate the end time (duration) */
2480 /* XXX: may need to support wrapping */
2481 filesize = ic->pb ? avio_size(ic->pb) : 0;
2483 is_end = found_duration;
2484 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2488 avio_seek(ic->pb, offset, SEEK_SET);
2491 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2495 ret = ff_read_packet(ic, pkt);
2496 } while (ret == AVERROR(EAGAIN));
2499 read_size += pkt->size;
2500 st = ic->streams[pkt->stream_index];
2501 if (pkt->pts != AV_NOPTS_VALUE &&
2502 (st->start_time != AV_NOPTS_VALUE ||
2503 st->first_dts != AV_NOPTS_VALUE)) {
2504 if (pkt->duration == 0) {
2505 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2507 pkt->duration = av_rescale_rnd(1,
2508 num * (int64_t) st->time_base.den,
2509 den * (int64_t) st->time_base.num,
2513 duration = pkt->pts + pkt->duration;
2515 if (st->start_time != AV_NOPTS_VALUE)
2516 duration -= st->start_time;
2518 duration -= st->first_dts;
2520 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2521 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2522 st->duration = duration;
2523 st->info->last_duration = duration;
2526 av_free_packet(pkt);
2529 /* check if all audio/video streams have valid duration */
2532 for (i = 0; i < ic->nb_streams; i++) {
2533 st = ic->streams[i];
2534 switch (st->codec->codec_type) {
2535 case AVMEDIA_TYPE_VIDEO:
2536 case AVMEDIA_TYPE_AUDIO:
2537 if (st->duration == AV_NOPTS_VALUE)
2544 ++retry <= DURATION_MAX_RETRY);
2546 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2548 /* warn about audio/video streams which duration could not be estimated */
2549 for (i = 0; i < ic->nb_streams; i++) {
2550 st = ic->streams[i];
2551 if (st->duration == AV_NOPTS_VALUE) {
2552 switch (st->codec->codec_type) {
2553 case AVMEDIA_TYPE_VIDEO:
2554 case AVMEDIA_TYPE_AUDIO:
2555 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2556 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2558 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2562 fill_all_stream_timings(ic);
2564 avio_seek(ic->pb, old_offset, SEEK_SET);
2565 for (i = 0; i < ic->nb_streams; i++) {
2568 st = ic->streams[i];
2569 st->cur_dts = st->first_dts;
2570 st->last_IP_pts = AV_NOPTS_VALUE;
2571 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2572 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2573 st->pts_buffer[j] = AV_NOPTS_VALUE;
2577 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2581 /* get the file size, if possible */
2582 if (ic->iformat->flags & AVFMT_NOFILE) {
2585 file_size = avio_size(ic->pb);
2586 file_size = FFMAX(0, file_size);
2589 if ((!strcmp(ic->iformat->name, "mpeg") ||
2590 !strcmp(ic->iformat->name, "mpegts")) &&
2591 file_size && ic->pb->seekable) {
2592 /* get accurate estimate from the PTSes */
2593 estimate_timings_from_pts(ic, old_offset);
2594 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2595 } else if (has_duration(ic)) {
2596 /* at least one component has timings - we use them for all
2598 fill_all_stream_timings(ic);
2599 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2601 /* less precise: use bitrate info */
2602 estimate_timings_from_bit_rate(ic);
2603 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2605 update_stream_timings(ic);
2609 AVStream av_unused *st;
2610 for (i = 0; i < ic->nb_streams; i++) {
2611 st = ic->streams[i];
2612 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2613 (double) st->start_time / AV_TIME_BASE,
2614 (double) st->duration / AV_TIME_BASE);
2616 av_log(ic, AV_LOG_TRACE,
2617 "stream: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2618 (double) ic->start_time / AV_TIME_BASE,
2619 (double) ic->duration / AV_TIME_BASE,
2620 (int64_t)ic->bit_rate / 1000);
2624 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2626 AVCodecContext *avctx = st->codec;
2628 #define FAIL(errmsg) do { \
2630 *errmsg_ptr = errmsg; \
2634 if ( avctx->codec_id == AV_CODEC_ID_NONE
2635 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2636 FAIL("unknown codec");
2637 switch (avctx->codec_type) {
2638 case AVMEDIA_TYPE_AUDIO:
2639 if (!avctx->frame_size && determinable_frame_size(avctx))
2640 FAIL("unspecified frame size");
2641 if (st->info->found_decoder >= 0 &&
2642 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2643 FAIL("unspecified sample format");
2644 if (!avctx->sample_rate)
2645 FAIL("unspecified sample rate");
2646 if (!avctx->channels)
2647 FAIL("unspecified number of channels");
2648 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2649 FAIL("no decodable DTS frames");
2651 case AVMEDIA_TYPE_VIDEO:
2653 FAIL("unspecified size");
2654 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2655 FAIL("unspecified pixel format");
2656 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2657 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2658 FAIL("no frame in rv30/40 and no sar");
2660 case AVMEDIA_TYPE_SUBTITLE:
2661 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2662 FAIL("unspecified size");
2664 case AVMEDIA_TYPE_DATA:
2665 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2671 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2672 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2673 AVDictionary **options)
2675 const AVCodec *codec;
2676 int got_picture = 1, ret = 0;
2677 AVFrame *frame = av_frame_alloc();
2678 AVSubtitle subtitle;
2679 AVPacket pkt = *avpkt;
2682 return AVERROR(ENOMEM);
2684 if (!avcodec_is_open(st->codec) &&
2685 st->info->found_decoder <= 0 &&
2686 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2687 AVDictionary *thread_opt = NULL;
2689 codec = find_decoder(s, st, st->codec->codec_id);
2692 st->info->found_decoder = -st->codec->codec_id;
2697 /* Force thread count to 1 since the H.264 decoder will not extract
2698 * SPS and PPS to extradata during multi-threaded decoding. */
2699 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2700 if (s->codec_whitelist)
2701 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2702 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2704 av_dict_free(&thread_opt);
2706 st->info->found_decoder = -st->codec->codec_id;
2709 st->info->found_decoder = 1;
2710 } else if (!st->info->found_decoder)
2711 st->info->found_decoder = 1;
2713 if (st->info->found_decoder < 0) {
2718 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2720 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2721 (!st->codec_info_nb_frames &&
2722 (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2724 switch (st->codec->codec_type) {
2725 case AVMEDIA_TYPE_VIDEO:
2726 ret = avcodec_decode_video2(st->codec, frame,
2727 &got_picture, &pkt);
2729 case AVMEDIA_TYPE_AUDIO:
2730 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2732 case AVMEDIA_TYPE_SUBTITLE:
2733 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2734 &got_picture, &pkt);
2742 st->nb_decoded_frames++;
2749 if (!pkt.data && !got_picture)
2753 av_frame_free(&frame);
2757 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2759 while (tags->id != AV_CODEC_ID_NONE) {
2767 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2770 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2771 if (tag == tags[i].tag)
2773 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2774 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2776 return AV_CODEC_ID_NONE;
2779 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2784 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2786 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2788 return AV_CODEC_ID_NONE;
2793 if (sflags & (1 << (bps - 1))) {
2796 return AV_CODEC_ID_PCM_S8;
2798 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2800 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2802 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2804 return AV_CODEC_ID_NONE;
2809 return AV_CODEC_ID_PCM_U8;
2811 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2813 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2815 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2817 return AV_CODEC_ID_NONE;
2823 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2826 if (!av_codec_get_tag2(tags, id, &tag))
2831 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2835 for (i = 0; tags && tags[i]; i++) {
2836 const AVCodecTag *codec_tags = tags[i];
2837 while (codec_tags->id != AV_CODEC_ID_NONE) {
2838 if (codec_tags->id == id) {
2839 *tag = codec_tags->tag;
2848 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2851 for (i = 0; tags && tags[i]; i++) {
2852 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2853 if (id != AV_CODEC_ID_NONE)
2856 return AV_CODEC_ID_NONE;
2859 static void compute_chapters_end(AVFormatContext *s)
2862 int64_t max_time = s->duration +
2863 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2865 for (i = 0; i < s->nb_chapters; i++)
2866 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2867 AVChapter *ch = s->chapters[i];
2868 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2872 for (j = 0; j < s->nb_chapters; j++) {
2873 AVChapter *ch1 = s->chapters[j];
2874 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2876 if (j != i && next_start > ch->start && next_start < end)
2879 ch->end = (end == INT64_MAX) ? ch->start : end;
2883 static int get_std_framerate(int i)
2886 return (i + 1) * 1001;
2890 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2894 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2897 /* Is the time base unreliable?
2898 * This is a heuristic to balance between quick acceptance of the values in
2899 * the headers vs. some extra checks.
2900 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2901 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2902 * And there are "variable" fps files this needs to detect as well. */
2903 static int tb_unreliable(AVCodecContext *c)
2905 if (c->time_base.den >= 101LL * c->time_base.num ||
2906 c->time_base.den < 5LL * c->time_base.num ||
2907 // c->codec_tag == AV_RL32("DIVX") ||
2908 // c->codec_tag == AV_RL32("XVID") ||
2909 c->codec_tag == AV_RL32("mp4v") ||
2910 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2911 c->codec_id == AV_CODEC_ID_GIF ||
2912 c->codec_id == AV_CODEC_ID_HEVC ||
2913 c->codec_id == AV_CODEC_ID_H264)
2918 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2922 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
2923 avctx->extradata = NULL;
2924 avctx->extradata_size = 0;
2925 return AVERROR(EINVAL);
2927 avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
2928 if (avctx->extradata) {
2929 memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2930 avctx->extradata_size = size;
2933 avctx->extradata_size = 0;
2934 ret = AVERROR(ENOMEM);
2939 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2941 int ret = ff_alloc_extradata(avctx, size);
2944 ret = avio_read(pb, avctx->extradata, size);
2946 av_freep(&avctx->extradata);
2947 avctx->extradata_size = 0;
2948 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2949 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2955 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2958 int64_t last = st->info->last_dts;
2960 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2961 && ts - (uint64_t)last < INT64_MAX) {
2962 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2963 int64_t duration = ts - last;
2965 if (!st->info->duration_error)
2966 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2967 if (!st->info->duration_error)
2968 return AVERROR(ENOMEM);
2970 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2971 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2972 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2973 if (st->info->duration_error[0][1][i] < 1e10) {
2974 int framerate = get_std_framerate(i);
2975 double sdts = dts*framerate/(1001*12);
2976 for (j= 0; j<2; j++) {
2977 int64_t ticks = llrint(sdts+j*0.5);
2978 double error= sdts - ticks + j*0.5;
2979 st->info->duration_error[j][0][i] += error;
2980 st->info->duration_error[j][1][i] += error*error;
2984 st->info->duration_count++;
2985 st->info->rfps_duration_sum += duration;
2987 if (st->info->duration_count % 10 == 0) {
2988 int n = st->info->duration_count;
2989 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2990 if (st->info->duration_error[0][1][i] < 1e10) {
2991 double a0 = st->info->duration_error[0][0][i] / n;
2992 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2993 double a1 = st->info->duration_error[1][0][i] / n;
2994 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2995 if (error0 > 0.04 && error1 > 0.04) {
2996 st->info->duration_error[0][1][i] = 2e10;
2997 st->info->duration_error[1][1][i] = 2e10;
3003 // ignore the first 4 values, they might have some random jitter
3004 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3005 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3007 if (ts != AV_NOPTS_VALUE)
3008 st->info->last_dts = ts;
3013 void ff_rfps_calculate(AVFormatContext *ic)
3017 for (i = 0; i < ic->nb_streams; i++) {
3018 AVStream *st = ic->streams[i];
3020 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3022 // the check for tb_unreliable() is not completely correct, since this is not about handling
3023 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3024 // ipmovie.c produces.
3025 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)
3026 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);
3027 if (st->info->duration_count>1 && !st->r_frame_rate.num
3028 && tb_unreliable(st->codec)) {
3030 double best_error= 0.01;
3031 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3033 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3036 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3038 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3041 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3044 for (k= 0; k<2; k++) {
3045 int n = st->info->duration_count;
3046 double a= st->info->duration_error[k][0][j] / n;
3047 double error= st->info->duration_error[k][1][j]/n - a*a;
3049 if (error < best_error && best_error> 0.000000001) {
3051 num = get_std_framerate(j);
3054 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3057 // do not increase frame rate by more than 1 % in order to match a standard rate.
3058 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3059 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3061 if ( !st->avg_frame_rate.num
3062 && st->r_frame_rate.num && st->info->rfps_duration_sum
3063 && st->info->codec_info_duration <= 0
3064 && st->info->duration_count > 2
3065 && 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
3067 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3068 st->avg_frame_rate = st->r_frame_rate;
3071 av_freep(&st->info->duration_error);
3072 st->info->last_dts = AV_NOPTS_VALUE;
3073 st->info->duration_count = 0;
3074 st->info->rfps_duration_sum = 0;
3078 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3080 int i, count, ret = 0, j;
3083 AVPacket pkt1, *pkt;
3084 int64_t old_offset = avio_tell(ic->pb);
3085 // new streams might appear, no options for those
3086 int orig_nb_streams = ic->nb_streams;
3088 int64_t max_analyze_duration = ic->max_analyze_duration;
3089 int64_t max_stream_analyze_duration;
3090 int64_t max_subtitle_analyze_duration;
3091 int64_t probesize = ic->probesize;
3093 flush_codecs = probesize > 0;
3095 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3097 max_stream_analyze_duration = max_analyze_duration;
3098 max_subtitle_analyze_duration = max_analyze_duration;
3099 if (!max_analyze_duration) {
3100 max_stream_analyze_duration =
3101 max_analyze_duration = 5*AV_TIME_BASE;
3102 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3103 if (!strcmp(ic->iformat->name, "flv"))
3104 max_stream_analyze_duration = 90*AV_TIME_BASE;
3108 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3109 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3111 for (i = 0; i < ic->nb_streams; i++) {
3112 const AVCodec *codec;
3113 AVDictionary *thread_opt = NULL;
3114 st = ic->streams[i];
3116 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3117 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3118 /* if (!st->time_base.num)
3120 if (!st->codec->time_base.num)
3121 st->codec->time_base = st->time_base;
3123 // only for the split stuff
3124 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3125 st->parser = av_parser_init(st->codec->codec_id);
3127 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3128 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3129 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3130 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3132 } else if (st->need_parsing) {
3133 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3134 "%s, packets or times may be invalid.\n",
3135 avcodec_get_name(st->codec->codec_id));
3138 codec = find_decoder(ic, st, st->codec->codec_id);
3140 /* Force thread count to 1 since the H.264 decoder will not extract
3141 * SPS and PPS to extradata during multi-threaded decoding. */
3142 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3144 if (ic->codec_whitelist)
3145 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3147 /* Ensure that subtitle_header is properly set. */
3148 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3149 && codec && !st->codec->codec) {
3150 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3151 av_log(ic, AV_LOG_WARNING,
3152 "Failed to open codec in av_find_stream_info\n");
3155 // Try to just open decoders, in case this is enough to get parameters.
3156 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3157 if (codec && !st->codec->codec)
3158 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3159 av_log(ic, AV_LOG_WARNING,
3160 "Failed to open codec in av_find_stream_info\n");
3163 av_dict_free(&thread_opt);
3166 for (i = 0; i < ic->nb_streams; i++) {
3167 #if FF_API_R_FRAME_RATE
3168 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3170 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3171 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3177 int analyzed_all_streams;
3178 if (ff_check_interrupt(&ic->interrupt_callback)) {
3180 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3184 /* check if one codec still needs to be handled */
3185 for (i = 0; i < ic->nb_streams; i++) {
3186 int fps_analyze_framecount = 20;
3188 st = ic->streams[i];
3189 if (!has_codec_parameters(st, NULL))
3191 /* If the timebase is coarse (like the usual millisecond precision
3192 * of mkv), we need to analyze more frames to reliably arrive at
3193 * the correct fps. */
3194 if (av_q2d(st->time_base) > 0.0005)
3195 fps_analyze_framecount *= 2;
3196 if (!tb_unreliable(st->codec))
3197 fps_analyze_framecount = 0;
3198 if (ic->fps_probe_size >= 0)
3199 fps_analyze_framecount = ic->fps_probe_size;
3200 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3201 fps_analyze_framecount = 0;
3202 /* variable fps and no guess at the real fps */
3203 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3204 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3205 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3206 st->info->codec_info_duration_fields/2 :
3207 st->info->duration_count;
3208 if (count < fps_analyze_framecount)
3211 if (st->parser && st->parser->parser->split &&
3212 !st->codec->extradata)
3214 if (st->first_dts == AV_NOPTS_VALUE &&
3215 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3216 st->codec_info_nb_frames < ic->max_ts_probe &&
3217 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3218 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3221 analyzed_all_streams = 0;
3222 if (i == ic->nb_streams) {
3223 analyzed_all_streams = 1;
3224 /* NOTE: If the format has no header, then we need to read some
3225 * packets to get most of the streams, so we cannot stop here. */
3226 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3227 /* If we found the info for all the codecs, we can stop. */
3229 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3234 /* We did not get all the codec info, but we read too much data. */
3235 if (read_size >= probesize) {
3237 av_log(ic, AV_LOG_DEBUG,
3238 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3239 for (i = 0; i < ic->nb_streams; i++)
3240 if (!ic->streams[i]->r_frame_rate.num &&
3241 ic->streams[i]->info->duration_count <= 1 &&
3242 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3243 strcmp(ic->iformat->name, "image2"))
3244 av_log(ic, AV_LOG_WARNING,
3245 "Stream #%d: not enough frames to estimate rate; "
3246 "consider increasing probesize\n", i);
3250 /* NOTE: A new stream can be added there if no header in file
3251 * (AVFMTCTX_NOHEADER). */
3252 ret = read_frame_internal(ic, &pkt1);
3253 if (ret == AVERROR(EAGAIN))
3261 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3262 free_packet_buffer(&ic->internal->packet_buffer,
3263 &ic->internal->packet_buffer_end);
3265 pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3266 &ic->internal->packet_buffer_end);
3268 ret = AVERROR(ENOMEM);
3269 goto find_stream_info_err;
3271 if ((ret = av_dup_packet(pkt)) < 0)
3272 goto find_stream_info_err;
3275 st = ic->streams[pkt->stream_index];
3276 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3277 read_size += pkt->size;
3279 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3280 /* check for non-increasing dts */
3281 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3282 st->info->fps_last_dts >= pkt->dts) {
3283 av_log(ic, AV_LOG_DEBUG,
3284 "Non-increasing DTS in stream %d: packet %d with DTS "
3285 "%"PRId64", packet %d with DTS %"PRId64"\n",
3286 st->index, st->info->fps_last_dts_idx,
3287 st->info->fps_last_dts, st->codec_info_nb_frames,
3289 st->info->fps_first_dts =
3290 st->info->fps_last_dts = AV_NOPTS_VALUE;
3292 /* Check for a discontinuity in dts. If the difference in dts
3293 * is more than 1000 times the average packet duration in the
3294 * sequence, we treat it as a discontinuity. */
3295 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3296 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3297 (pkt->dts - st->info->fps_last_dts) / 1000 >
3298 (st->info->fps_last_dts - st->info->fps_first_dts) /
3299 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3300 av_log(ic, AV_LOG_WARNING,
3301 "DTS discontinuity in stream %d: packet %d with DTS "
3302 "%"PRId64", packet %d with DTS %"PRId64"\n",
3303 st->index, st->info->fps_last_dts_idx,
3304 st->info->fps_last_dts, st->codec_info_nb_frames,
3306 st->info->fps_first_dts =
3307 st->info->fps_last_dts = AV_NOPTS_VALUE;
3310 /* update stored dts values */
3311 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3312 st->info->fps_first_dts = pkt->dts;
3313 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3315 st->info->fps_last_dts = pkt->dts;
3316 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3318 if (st->codec_info_nb_frames>1) {
3322 if (st->time_base.den > 0)
3323 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3324 if (st->avg_frame_rate.num > 0)
3325 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3328 && st->codec_info_nb_frames>30
3329 && st->info->fps_first_dts != AV_NOPTS_VALUE
3330 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3331 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3333 if (analyzed_all_streams) limit = max_analyze_duration;
3334 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3335 else limit = max_stream_analyze_duration;
3338 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3340 t, pkt->stream_index);
3341 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3342 av_packet_unref(pkt);
3345 if (pkt->duration) {
3346 st->info->codec_info_duration += pkt->duration;
3347 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3350 #if FF_API_R_FRAME_RATE
3351 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3352 ff_rfps_add_frame(ic, st, pkt->dts);
3354 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3355 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3356 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3357 if (ff_alloc_extradata(st->codec, i))
3358 return AVERROR(ENOMEM);
3359 memcpy(st->codec->extradata, pkt->data,
3360 st->codec->extradata_size);
3364 /* If still no information, we try to open the codec and to
3365 * decompress the frame. We try to avoid that in most cases as
3366 * it takes longer and uses more memory. For MPEG-4, we need to
3367 * decompress for QuickTime.
3369 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3370 * least one frame of codec data, this makes sure the codec initializes
3371 * the channel configuration and does not only trust the values from
3373 try_decode_frame(ic, st, pkt,
3374 (options && i < orig_nb_streams) ? &options[i] : NULL);
3376 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3377 av_packet_unref(pkt);
3379 st->codec_info_nb_frames++;
3384 AVPacket empty_pkt = { 0 };
3386 av_init_packet(&empty_pkt);
3388 for (i = 0; i < ic->nb_streams; i++) {
3390 st = ic->streams[i];
3392 /* flush the decoders */
3393 if (st->info->found_decoder == 1) {
3395 err = try_decode_frame(ic, st, &empty_pkt,
3396 (options && i < orig_nb_streams)
3397 ? &options[i] : NULL);
3398 } while (err > 0 && !has_codec_parameters(st, NULL));
3401 av_log(ic, AV_LOG_INFO,
3402 "decoding for stream %d failed\n", st->index);
3408 // close codecs which were opened in try_decode_frame()
3409 for (i = 0; i < ic->nb_streams; i++) {
3410 st = ic->streams[i];
3411 avcodec_close(st->codec);
3414 ff_rfps_calculate(ic);
3416 for (i = 0; i < ic->nb_streams; i++) {
3417 st = ic->streams[i];
3418 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3419 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3420 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3421 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3422 st->codec->codec_tag= tag;
3425 /* estimate average framerate if not set by demuxer */
3426 if (st->info->codec_info_duration_fields &&
3427 !st->avg_frame_rate.num &&
3428 st->info->codec_info_duration) {
3430 double best_error = 0.01;
3432 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3433 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3434 st->info->codec_info_duration < 0)
3436 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3437 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3438 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3440 /* Round guessed framerate to a "standard" framerate if it's
3441 * within 1% of the original estimate. */
3442 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3443 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3444 double error = fabs(av_q2d(st->avg_frame_rate) /
3445 av_q2d(std_fps) - 1);
3447 if (error < best_error) {
3449 best_fps = std_fps.num;
3453 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3454 best_fps, 12 * 1001, INT_MAX);
3457 if (!st->r_frame_rate.num) {
3458 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3459 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3460 st->r_frame_rate.num = st->codec->time_base.den;
3461 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3463 st->r_frame_rate.num = st->time_base.den;
3464 st->r_frame_rate.den = st->time_base.num;
3467 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3468 AVRational hw_ratio = { st->codec->height, st->codec->width };
3469 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3472 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3473 if (!st->codec->bits_per_coded_sample)
3474 st->codec->bits_per_coded_sample =
3475 av_get_bits_per_sample(st->codec->codec_id);
3476 // set stream disposition based on audio service type
3477 switch (st->codec->audio_service_type) {
3478 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3479 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3481 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3482 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3484 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3485 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3487 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3488 st->disposition = AV_DISPOSITION_COMMENT;
3490 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3491 st->disposition = AV_DISPOSITION_KARAOKE;
3498 estimate_timings(ic, old_offset);
3500 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3502 if (ret >= 0 && ic->nb_streams)
3503 /* We could not have all the codec parameters before EOF. */
3505 for (i = 0; i < ic->nb_streams; i++) {
3507 st = ic->streams[i];
3508 if (!has_codec_parameters(st, &errmsg)) {
3510 avcodec_string(buf, sizeof(buf), st->codec, 0);
3511 av_log(ic, AV_LOG_WARNING,
3512 "Could not find codec parameters for stream %d (%s): %s\n"
3513 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3520 compute_chapters_end(ic);
3522 find_stream_info_err:
3523 for (i = 0; i < ic->nb_streams; i++) {
3524 st = ic->streams[i];
3525 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3526 ic->streams[i]->codec->thread_count = 0;
3528 av_freep(&st->info->duration_error);
3529 av_freep(&ic->streams[i]->info);
3532 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3533 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3537 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3541 for (i = 0; i < ic->nb_programs; i++) {
3542 if (ic->programs[i] == last) {
3546 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3547 if (ic->programs[i]->stream_index[j] == s)
3548 return ic->programs[i];
3554 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3555 int wanted_stream_nb, int related_stream,
3556 AVCodec **decoder_ret, int flags)
3558 int i, nb_streams = ic->nb_streams;
3559 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3560 unsigned *program = NULL;
3561 const AVCodec *decoder = NULL, *best_decoder = NULL;
3563 if (related_stream >= 0 && wanted_stream_nb < 0) {
3564 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3566 program = p->stream_index;
3567 nb_streams = p->nb_stream_indexes;
3570 for (i = 0; i < nb_streams; i++) {
3571 int real_stream_index = program ? program[i] : i;
3572 AVStream *st = ic->streams[real_stream_index];
3573 AVCodecContext *avctx = st->codec;
3574 if (avctx->codec_type != type)
3576 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3578 if (wanted_stream_nb != real_stream_index &&
3579 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3580 AV_DISPOSITION_VISUAL_IMPAIRED))
3582 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3585 decoder = find_decoder(ic, st, st->codec->codec_id);
3588 ret = AVERROR_DECODER_NOT_FOUND;
3592 count = st->codec_info_nb_frames;
3593 bitrate = avctx->bit_rate;
3595 bitrate = avctx->rc_max_rate;
3596 multiframe = FFMIN(5, count);
3597 if ((best_multiframe > multiframe) ||
3598 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3599 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3602 best_bitrate = bitrate;
3603 best_multiframe = multiframe;
3604 ret = real_stream_index;
3605 best_decoder = decoder;
3606 if (program && i == nb_streams - 1 && ret < 0) {
3608 nb_streams = ic->nb_streams;
3609 /* no related stream found, try again with everything */
3614 *decoder_ret = (AVCodec*)best_decoder;
3618 /*******************************************************/
3620 int av_read_play(AVFormatContext *s)
3622 if (s->iformat->read_play)
3623 return s->iformat->read_play(s);
3625 return avio_pause(s->pb, 0);
3626 return AVERROR(ENOSYS);
3629 int av_read_pause(AVFormatContext *s)
3631 if (s->iformat->read_pause)
3632 return s->iformat->read_pause(s);
3634 return avio_pause(s->pb, 1);
3635 return AVERROR(ENOSYS);
3638 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3640 av_assert0(s->nb_streams>0);
3641 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3643 for (j = 0; j < st->nb_side_data; j++)
3644 av_freep(&st->side_data[j].data);
3645 av_freep(&st->side_data);
3646 st->nb_side_data = 0;
3649 av_parser_close(st->parser);
3651 if (st->attached_pic.data)
3652 av_free_packet(&st->attached_pic);
3653 av_dict_free(&st->metadata);
3654 av_freep(&st->probe_data.buf);
3655 av_freep(&st->index_entries);
3656 av_freep(&st->codec->extradata);
3657 av_freep(&st->codec->subtitle_header);
3658 av_freep(&st->codec);
3659 av_freep(&st->priv_data);
3661 av_freep(&st->info->duration_error);
3662 av_freep(&st->info);
3663 av_freep(&st->recommended_encoder_configuration);
3664 av_freep(&st->priv_pts);
3665 av_freep(&s->streams[ --s->nb_streams ]);
3668 void avformat_free_context(AVFormatContext *s)
3676 if (s->iformat && s->iformat->priv_class && s->priv_data)
3677 av_opt_free(s->priv_data);
3678 if (s->oformat && s->oformat->priv_class && s->priv_data)
3679 av_opt_free(s->priv_data);
3681 for (i = s->nb_streams - 1; i >= 0; i--) {
3682 ff_free_stream(s, s->streams[i]);
3684 for (i = s->nb_programs - 1; i >= 0; i--) {
3685 av_dict_free(&s->programs[i]->metadata);
3686 av_freep(&s->programs[i]->stream_index);
3687 av_freep(&s->programs[i]);
3689 av_freep(&s->programs);
3690 av_freep(&s->priv_data);
3691 while (s->nb_chapters--) {
3692 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3693 av_freep(&s->chapters[s->nb_chapters]);
3695 av_freep(&s->chapters);
3696 av_dict_free(&s->metadata);
3697 av_freep(&s->streams);
3698 av_freep(&s->internal);
3699 flush_packet_queue(s);
3703 void avformat_close_input(AVFormatContext **ps)
3714 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3715 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3718 flush_packet_queue(s);
3721 if (s->iformat->read_close)
3722 s->iformat->read_close(s);
3724 avformat_free_context(s);
3731 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3737 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3739 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3742 s->streams = streams;
3744 st = av_mallocz(sizeof(AVStream));
3747 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3751 st->info->last_dts = AV_NOPTS_VALUE;
3753 st->codec = avcodec_alloc_context3(c);
3760 /* no default bitrate if decoding */
3761 st->codec->bit_rate = 0;
3763 /* default pts setting is MPEG-like */
3764 avpriv_set_pts_info(st, 33, 1, 90000);
3767 st->index = s->nb_streams;
3768 st->start_time = AV_NOPTS_VALUE;
3769 st->duration = AV_NOPTS_VALUE;
3770 /* we set the current DTS to 0 so that formats without any timestamps
3771 * but durations get some timestamps, formats with some unknown
3772 * timestamps have their first few packets buffered and the
3773 * timestamps corrected before they are returned to the user */
3774 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3775 st->first_dts = AV_NOPTS_VALUE;
3776 st->probe_packets = MAX_PROBE_PACKETS;
3777 st->pts_wrap_reference = AV_NOPTS_VALUE;
3778 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3780 st->last_IP_pts = AV_NOPTS_VALUE;
3781 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3782 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3783 st->pts_buffer[i] = AV_NOPTS_VALUE;
3785 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3787 #if FF_API_R_FRAME_RATE
3788 st->info->last_dts = AV_NOPTS_VALUE;
3790 st->info->fps_first_dts = AV_NOPTS_VALUE;
3791 st->info->fps_last_dts = AV_NOPTS_VALUE;
3793 st->inject_global_side_data = s->internal->inject_global_side_data;
3795 s->streams[s->nb_streams++] = st;
3799 AVProgram *av_new_program(AVFormatContext *ac, int id)
3801 AVProgram *program = NULL;
3804 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3806 for (i = 0; i < ac->nb_programs; i++)
3807 if (ac->programs[i]->id == id)
3808 program = ac->programs[i];
3811 program = av_mallocz(sizeof(AVProgram));
3814 dynarray_add(&ac->programs, &ac->nb_programs, program);
3815 program->discard = AVDISCARD_NONE;
3818 program->pts_wrap_reference = AV_NOPTS_VALUE;
3819 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3821 program->start_time =
3822 program->end_time = AV_NOPTS_VALUE;
3827 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3828 int64_t start, int64_t end, const char *title)
3830 AVChapter *chapter = NULL;
3833 if (end != AV_NOPTS_VALUE && start > end) {
3834 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3838 for (i = 0; i < s->nb_chapters; i++)
3839 if (s->chapters[i]->id == id)
3840 chapter = s->chapters[i];
3843 chapter = av_mallocz(sizeof(AVChapter));
3846 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3848 av_dict_set(&chapter->metadata, "title", title, 0);
3850 chapter->time_base = time_base;
3851 chapter->start = start;
3857 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3860 AVProgram *program = NULL;
3863 if (idx >= ac->nb_streams) {
3864 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3868 for (i = 0; i < ac->nb_programs; i++) {
3869 if (ac->programs[i]->id != progid)
3871 program = ac->programs[i];
3872 for (j = 0; j < program->nb_stream_indexes; j++)
3873 if (program->stream_index[j] == idx)
3876 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3879 program->stream_index = tmp;
3880 program->stream_index[program->nb_stream_indexes++] = idx;
3885 uint64_t ff_ntp_time(void)
3887 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3890 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3893 char *q, buf1[20], c;
3894 int nd, len, percentd_found;
3906 while (av_isdigit(*p))
3907 nd = nd * 10 + *p++ - '0';
3909 } while (av_isdigit(c));
3920 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3922 if ((q - buf + len) > buf_size - 1)
3924 memcpy(q, buf1, len);
3932 if ((q - buf) < buf_size - 1)
3936 if (!percentd_found)
3945 void av_url_split(char *proto, int proto_size,
3946 char *authorization, int authorization_size,
3947 char *hostname, int hostname_size,
3948 int *port_ptr, char *path, int path_size, const char *url)
3950 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3956 if (authorization_size > 0)
3957 authorization[0] = 0;
3958 if (hostname_size > 0)
3963 /* parse protocol */
3964 if ((p = strchr(url, ':'))) {
3965 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3972 /* no protocol means plain filename */
3973 av_strlcpy(path, url, path_size);
3977 /* separate path from hostname */
3978 ls = strchr(p, '/');
3979 ls2 = strchr(p, '?');
3983 ls = FFMIN(ls, ls2);
3985 av_strlcpy(path, ls, path_size);
3987 ls = &p[strlen(p)]; // XXX
3989 /* the rest is hostname, use that to parse auth/port */
3991 /* authorization (user[:pass]@hostname) */
3993 while ((at = strchr(p, '@')) && at < ls) {
3994 av_strlcpy(authorization, at2,
3995 FFMIN(authorization_size, at + 1 - at2));
3996 p = at + 1; /* skip '@' */
3999 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4001 av_strlcpy(hostname, p + 1,
4002 FFMIN(hostname_size, brk - p));
4003 if (brk[1] == ':' && port_ptr)
4004 *port_ptr = atoi(brk + 2);
4005 } else if ((col = strchr(p, ':')) && col < ls) {
4006 av_strlcpy(hostname, p,
4007 FFMIN(col + 1 - p, hostname_size));
4009 *port_ptr = atoi(col + 1);
4011 av_strlcpy(hostname, p,
4012 FFMIN(ls + 1 - p, hostname_size));
4016 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4019 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4022 'C', 'D', 'E', 'F' };
4023 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4026 'c', 'd', 'e', 'f' };
4027 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4029 for (i = 0; i < s; i++) {
4030 buff[i * 2] = hex_table[src[i] >> 4];
4031 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4037 int ff_hex_to_data(uint8_t *data, const char *p)
4044 p += strspn(p, SPACE_CHARS);
4047 c = av_toupper((unsigned char) *p++);
4048 if (c >= '0' && c <= '9')
4050 else if (c >= 'A' && c <= 'F')
4065 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4066 unsigned int pts_num, unsigned int pts_den)
4069 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4070 if (new_tb.num != pts_num)
4071 av_log(NULL, AV_LOG_DEBUG,
4072 "st:%d removing common factor %d from timebase\n",
4073 s->index, pts_num / new_tb.num);
4075 av_log(NULL, AV_LOG_WARNING,
4076 "st:%d has too large timebase, reducing\n", s->index);
4078 if (new_tb.num <= 0 || new_tb.den <= 0) {
4079 av_log(NULL, AV_LOG_ERROR,
4080 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4081 new_tb.num, new_tb.den,
4085 s->time_base = new_tb;
4086 av_codec_set_pkt_timebase(s->codec, new_tb);
4087 s->pts_wrap_bits = pts_wrap_bits;
4090 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4093 const char *ptr = str;
4095 /* Parse key=value pairs. */
4098 char *dest = NULL, *dest_end;
4099 int key_len, dest_len = 0;
4101 /* Skip whitespace and potential commas. */
4102 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4109 if (!(ptr = strchr(key, '=')))
4112 key_len = ptr - key;
4114 callback_get_buf(context, key, key_len, &dest, &dest_len);
4115 dest_end = dest + dest_len - 1;
4119 while (*ptr && *ptr != '\"') {
4123 if (dest && dest < dest_end)
4127 if (dest && dest < dest_end)
4135 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4136 if (dest && dest < dest_end)
4144 int ff_find_stream_index(AVFormatContext *s, int id)
4147 for (i = 0; i < s->nb_streams; i++)
4148 if (s->streams[i]->id == id)
4153 int64_t ff_iso8601_to_unix_time(const char *datestr)
4155 struct tm time1 = { 0 }, time2 = { 0 };
4156 const char *ret1, *ret2;
4157 ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4158 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4160 return av_timegm(&time2);
4162 return av_timegm(&time1);
4165 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4169 unsigned int codec_tag;
4170 if (ofmt->query_codec)
4171 return ofmt->query_codec(codec_id, std_compliance);
4172 else if (ofmt->codec_tag)
4173 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4174 else if (codec_id == ofmt->video_codec ||
4175 codec_id == ofmt->audio_codec ||
4176 codec_id == ofmt->subtitle_codec)
4179 return AVERROR_PATCHWELCOME;
4182 int avformat_network_init(void)
4186 ff_network_inited_globally = 1;
4187 if ((ret = ff_network_init()) < 0)
4189 if ((ret = ff_tls_init()) < 0)
4195 int avformat_network_deinit(void)
4200 ff_network_inited_globally = 0;
4205 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4206 uint64_t channel_layout, int32_t sample_rate,
4207 int32_t width, int32_t height)
4213 return AVERROR(EINVAL);
4216 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4218 if (channel_layout) {
4220 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4224 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4226 if (width || height) {
4228 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4230 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4232 return AVERROR(ENOMEM);
4233 bytestream_put_le32(&data, flags);
4235 bytestream_put_le32(&data, channels);
4237 bytestream_put_le64(&data, channel_layout);
4239 bytestream_put_le32(&data, sample_rate);
4240 if (width || height) {
4241 bytestream_put_le32(&data, width);
4242 bytestream_put_le32(&data, height);
4247 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4249 AVRational undef = {0, 1};
4250 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4251 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4252 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4254 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4255 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4256 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4257 stream_sample_aspect_ratio = undef;
4259 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4260 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4261 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4262 frame_sample_aspect_ratio = undef;
4264 if (stream_sample_aspect_ratio.num)
4265 return stream_sample_aspect_ratio;
4267 return frame_sample_aspect_ratio;
4270 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4272 AVRational fr = st->r_frame_rate;
4273 AVRational codec_fr = st->codec->framerate;
4274 AVRational avg_fr = st->avg_frame_rate;
4276 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4277 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4282 if (st->codec->ticks_per_frame > 1) {
4283 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4284 (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
4291 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4294 if (*spec <= '9' && *spec >= '0') /* opt:index */
4295 return strtol(spec, NULL, 0) == st->index;
4296 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4297 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4298 enum AVMediaType type;
4302 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4303 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4304 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4305 case 'd': type = AVMEDIA_TYPE_DATA; break;
4306 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4307 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4308 default: av_assert0(0);
4310 if (type != st->codec->codec_type)
4312 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4314 if (*spec++ == ':') { /* possibly followed by :index */
4315 int i, index = strtol(spec, NULL, 0);
4316 for (i = 0; i < s->nb_streams; i++)
4317 if (s->streams[i]->codec->codec_type == type &&
4318 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4320 return i == st->index;
4324 } else if (*spec == 'p' && *(spec + 1) == ':') {
4328 prog_id = strtol(spec, &endptr, 0);
4329 for (i = 0; i < s->nb_programs; i++) {
4330 if (s->programs[i]->id != prog_id)
4333 if (*endptr++ == ':') {
4334 int stream_idx = strtol(endptr, NULL, 0);
4335 return stream_idx >= 0 &&
4336 stream_idx < s->programs[i]->nb_stream_indexes &&
4337 st->index == s->programs[i]->stream_index[stream_idx];
4340 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4341 if (st->index == s->programs[i]->stream_index[j])
4345 } else if (*spec == '#' ||
4346 (*spec == 'i' && *(spec + 1) == ':')) {
4349 spec += 1 + (*spec == 'i');
4350 stream_id = strtol(spec, &endptr, 0);
4352 return stream_id == st->id;
4353 } else if (*spec == 'm' && *(spec + 1) == ':') {
4354 AVDictionaryEntry *tag;
4359 val = strchr(spec, ':');
4361 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4363 return AVERROR(ENOMEM);
4365 tag = av_dict_get(st->metadata, key, NULL, 0);
4367 if (!val || !strcmp(tag->value, val + 1))
4376 } else if (*spec == 'u') {
4377 AVCodecContext *avctx = st->codec;
4379 switch (avctx->codec_type) {
4380 case AVMEDIA_TYPE_AUDIO:
4381 val = avctx->sample_rate && avctx->channels;
4382 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4385 case AVMEDIA_TYPE_VIDEO:
4386 val = avctx->width && avctx->height;
4387 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4390 case AVMEDIA_TYPE_UNKNOWN:
4397 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4398 } else if (!*spec) /* empty specifier, matches everything */
4401 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4402 return AVERROR(EINVAL);
4405 int ff_generate_avci_extradata(AVStream *st)
4407 static const uint8_t avci100_1080p_extradata[] = {
4409 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4410 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4411 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4412 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4413 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4414 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4415 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4416 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4417 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4419 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4422 static const uint8_t avci100_1080i_extradata[] = {
4424 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4425 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4426 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4427 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4428 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4429 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4430 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4431 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4432 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4433 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4434 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4436 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4439 static const uint8_t avci50_1080p_extradata[] = {
4441 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4442 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4443 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4444 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4445 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4446 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4447 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4448 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4449 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4451 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4454 static const uint8_t avci50_1080i_extradata[] = {
4456 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4457 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4458 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4459 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4460 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4461 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4462 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4463 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4464 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4465 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4466 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4468 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4471 static const uint8_t avci100_720p_extradata[] = {
4473 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4474 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4475 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4476 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4477 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4478 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4479 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4480 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4481 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4482 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4484 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4487 static const uint8_t avci50_720p_extradata[] = {
4489 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4490 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4491 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4492 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4493 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4494 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4495 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4496 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4497 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4499 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4503 const uint8_t *data = NULL;
4506 if (st->codec->width == 1920) {
4507 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4508 data = avci100_1080p_extradata;
4509 size = sizeof(avci100_1080p_extradata);
4511 data = avci100_1080i_extradata;
4512 size = sizeof(avci100_1080i_extradata);
4514 } else if (st->codec->width == 1440) {
4515 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4516 data = avci50_1080p_extradata;
4517 size = sizeof(avci50_1080p_extradata);
4519 data = avci50_1080i_extradata;
4520 size = sizeof(avci50_1080i_extradata);
4522 } else if (st->codec->width == 1280) {
4523 data = avci100_720p_extradata;
4524 size = sizeof(avci100_720p_extradata);
4525 } else if (st->codec->width == 960) {
4526 data = avci50_720p_extradata;
4527 size = sizeof(avci50_720p_extradata);
4533 av_freep(&st->codec->extradata);
4534 if (ff_alloc_extradata(st->codec, size))
4535 return AVERROR(ENOMEM);
4536 memcpy(st->codec->extradata, data, size);
4541 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4546 for (i = 0; i < st->nb_side_data; i++) {
4547 if (st->side_data[i].type == type) {
4549 *size = st->side_data[i].size;
4550 return st->side_data[i].data;
4556 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4559 AVPacketSideData *sd, *tmp;
4561 uint8_t *data = av_malloc(size);
4566 for (i = 0; i < st->nb_side_data; i++) {
4567 sd = &st->side_data[i];
4569 if (sd->type == type) {
4570 av_freep(&sd->data);
4577 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4583 st->side_data = tmp;
4586 sd = &st->side_data[st->nb_side_data - 1];