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;
1268 #if FF_API_DESTRUCT_PACKET
1269 FF_DISABLE_DEPRECATION_WARNINGS
1270 out_pkt.destruct = pkt->destruct;
1271 pkt->destruct = NULL;
1272 FF_ENABLE_DEPRECATION_WARNINGS
1275 if ((ret = av_dup_packet(&out_pkt)) < 0)
1278 if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
1279 av_free_packet(&out_pkt);
1280 ret = AVERROR(ENOMEM);
1285 /* end of the stream => close and free the parser */
1286 if (pkt == &flush_pkt) {
1287 av_parser_close(st->parser);
1292 av_free_packet(pkt);
1296 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1297 AVPacketList **pkt_buffer_end,
1301 av_assert0(*pkt_buffer);
1304 *pkt_buffer = pktl->next;
1306 *pkt_buffer_end = NULL;
1311 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1313 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1316 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1318 int ret = 0, i, got_packet = 0;
1319 AVDictionary *metadata = NULL;
1321 av_init_packet(pkt);
1323 while (!got_packet && !s->internal->parse_queue) {
1327 /* read next packet */
1328 ret = ff_read_packet(s, &cur_pkt);
1330 if (ret == AVERROR(EAGAIN))
1332 /* flush the parsers */
1333 for (i = 0; i < s->nb_streams; i++) {
1335 if (st->parser && st->need_parsing)
1336 parse_packet(s, NULL, st->index);
1338 /* all remaining packets are now in parse_queue =>
1339 * really terminate parsing */
1343 st = s->streams[cur_pkt.stream_index];
1345 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1346 cur_pkt.dts != AV_NOPTS_VALUE &&
1347 cur_pkt.pts < cur_pkt.dts) {
1348 av_log(s, AV_LOG_WARNING,
1349 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1350 cur_pkt.stream_index,
1351 av_ts2str(cur_pkt.pts),
1352 av_ts2str(cur_pkt.dts),
1355 if (s->debug & FF_FDEBUG_TS)
1356 av_log(s, AV_LOG_DEBUG,
1357 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1358 cur_pkt.stream_index,
1359 av_ts2str(cur_pkt.pts),
1360 av_ts2str(cur_pkt.dts),
1361 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1363 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1364 st->parser = av_parser_init(st->codec->codec_id);
1366 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1367 "%s, packets or times may be invalid.\n",
1368 avcodec_get_name(st->codec->codec_id));
1369 /* no parser available: just output the raw packets */
1370 st->need_parsing = AVSTREAM_PARSE_NONE;
1371 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1372 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1373 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1374 st->parser->flags |= PARSER_FLAG_ONCE;
1375 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1376 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1379 if (!st->need_parsing || !st->parser) {
1380 /* no parsing needed: we just output the packet as is */
1382 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1383 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1384 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1385 ff_reduce_index(s, st->index);
1386 av_add_index_entry(st, pkt->pos, pkt->dts,
1387 0, 0, AVINDEX_KEYFRAME);
1390 } else if (st->discard < AVDISCARD_ALL) {
1391 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1395 av_free_packet(&cur_pkt);
1397 if (pkt->flags & AV_PKT_FLAG_KEY)
1398 st->skip_to_keyframe = 0;
1399 if (st->skip_to_keyframe) {
1400 av_free_packet(&cur_pkt);
1408 if (!got_packet && s->internal->parse_queue)
1409 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1412 AVStream *st = s->streams[pkt->stream_index];
1413 int discard_padding = 0;
1414 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1415 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1416 int64_t sample = ts_to_samples(st, pts);
1417 int duration = ts_to_samples(st, pkt->duration);
1418 int64_t end_sample = sample + duration;
1419 if (duration > 0 && end_sample >= st->first_discard_sample &&
1420 sample < st->last_discard_sample)
1421 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1423 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1424 st->skip_samples = st->start_skip_samples;
1425 if (st->skip_samples || discard_padding) {
1426 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1428 AV_WL32(p, st->skip_samples);
1429 AV_WL32(p + 4, discard_padding);
1430 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1432 st->skip_samples = 0;
1435 if (st->inject_global_side_data) {
1436 for (i = 0; i < st->nb_side_data; i++) {
1437 AVPacketSideData *src_sd = &st->side_data[i];
1440 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1443 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1445 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1449 memcpy(dst_data, src_sd->data, src_sd->size);
1451 st->inject_global_side_data = 0;
1454 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1455 av_packet_merge_side_data(pkt);
1458 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1460 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1461 av_dict_copy(&s->metadata, metadata, 0);
1462 av_dict_free(&metadata);
1463 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1466 if (s->debug & FF_FDEBUG_TS)
1467 av_log(s, AV_LOG_DEBUG,
1468 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1469 "size=%d, duration=%d, flags=%d\n",
1471 av_ts2str(pkt->pts),
1472 av_ts2str(pkt->dts),
1473 pkt->size, pkt->duration, pkt->flags);
1478 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1480 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1486 ret = s->internal->packet_buffer
1487 ? read_from_packet_buffer(&s->internal->packet_buffer,
1488 &s->internal->packet_buffer_end, pkt)
1489 : read_frame_internal(s, pkt);
1496 AVPacketList *pktl = s->internal->packet_buffer;
1499 AVPacket *next_pkt = &pktl->pkt;
1501 if (next_pkt->dts != AV_NOPTS_VALUE) {
1502 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1503 // last dts seen for this stream. if any of packets following
1504 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1505 int64_t last_dts = next_pkt->dts;
1506 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1507 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1508 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1509 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1511 next_pkt->pts = pktl->pkt.dts;
1513 if (last_dts != AV_NOPTS_VALUE) {
1514 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1515 last_dts = pktl->pkt.dts;
1520 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1521 // Fixing the last reference frame had none pts issue (For MXF etc).
1522 // We only do this when
1524 // 2. we are not able to resolve a pts value for current packet.
1525 // 3. the packets for this stream at the end of the files had valid dts.
1526 next_pkt->pts = last_dts + next_pkt->duration;
1528 pktl = s->internal->packet_buffer;
1531 /* read packet from packet buffer, if there is data */
1532 st = s->streams[next_pkt->stream_index];
1533 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1534 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1535 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1536 &s->internal->packet_buffer_end, pkt);
1541 ret = read_frame_internal(s, pkt);
1543 if (pktl && ret != AVERROR(EAGAIN)) {
1550 if (av_dup_packet(add_to_pktbuf(&s->internal->packet_buffer, pkt,
1551 &s->internal->packet_buffer_end)) < 0)
1552 return AVERROR(ENOMEM);
1557 st = s->streams[pkt->stream_index];
1558 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1559 ff_reduce_index(s, st->index);
1560 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1563 if (is_relative(pkt->dts))
1564 pkt->dts -= RELATIVE_TS_BASE;
1565 if (is_relative(pkt->pts))
1566 pkt->pts -= RELATIVE_TS_BASE;
1571 /* XXX: suppress the packet queue */
1572 static void flush_packet_queue(AVFormatContext *s)
1576 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1577 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1578 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1580 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1583 /*******************************************************/
1586 int av_find_default_stream_index(AVFormatContext *s)
1590 int best_stream = 0;
1591 int best_score = INT_MIN;
1593 if (s->nb_streams <= 0)
1595 for (i = 0; i < s->nb_streams; i++) {
1598 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1599 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1601 if (st->codec->width && st->codec->height)
1605 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1606 if (st->codec->sample_rate)
1609 if (st->codec_info_nb_frames)
1612 if (st->discard != AVDISCARD_ALL)
1615 if (score > best_score) {
1623 /** Flush the frame reader. */
1624 void ff_read_frame_flush(AVFormatContext *s)
1629 flush_packet_queue(s);
1631 /* Reset read state for each stream. */
1632 for (i = 0; i < s->nb_streams; i++) {
1636 av_parser_close(st->parser);
1639 st->last_IP_pts = AV_NOPTS_VALUE;
1640 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1641 if (st->first_dts == AV_NOPTS_VALUE)
1642 st->cur_dts = RELATIVE_TS_BASE;
1644 /* We set the current DTS to an unspecified origin. */
1645 st->cur_dts = AV_NOPTS_VALUE;
1647 st->probe_packets = MAX_PROBE_PACKETS;
1649 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1650 st->pts_buffer[j] = AV_NOPTS_VALUE;
1652 if (s->internal->inject_global_side_data)
1653 st->inject_global_side_data = 1;
1655 st->skip_samples = 0;
1659 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1663 for (i = 0; i < s->nb_streams; i++) {
1664 AVStream *st = s->streams[i];
1667 av_rescale(timestamp,
1668 st->time_base.den * (int64_t) ref_st->time_base.num,
1669 st->time_base.num * (int64_t) ref_st->time_base.den);
1673 void ff_reduce_index(AVFormatContext *s, int stream_index)
1675 AVStream *st = s->streams[stream_index];
1676 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1678 if ((unsigned) st->nb_index_entries >= max_entries) {
1680 for (i = 0; 2 * i < st->nb_index_entries; i++)
1681 st->index_entries[i] = st->index_entries[2 * i];
1682 st->nb_index_entries = i;
1686 int ff_add_index_entry(AVIndexEntry **index_entries,
1687 int *nb_index_entries,
1688 unsigned int *index_entries_allocated_size,
1689 int64_t pos, int64_t timestamp,
1690 int size, int distance, int flags)
1692 AVIndexEntry *entries, *ie;
1695 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1698 if (timestamp == AV_NOPTS_VALUE)
1699 return AVERROR(EINVAL);
1701 if (size < 0 || size > 0x3FFFFFFF)
1702 return AVERROR(EINVAL);
1704 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1705 timestamp -= RELATIVE_TS_BASE;
1707 entries = av_fast_realloc(*index_entries,
1708 index_entries_allocated_size,
1709 (*nb_index_entries + 1) *
1710 sizeof(AVIndexEntry));
1714 *index_entries = entries;
1716 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1717 timestamp, AVSEEK_FLAG_ANY);
1720 index = (*nb_index_entries)++;
1721 ie = &entries[index];
1722 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1724 ie = &entries[index];
1725 if (ie->timestamp != timestamp) {
1726 if (ie->timestamp <= timestamp)
1728 memmove(entries + index + 1, entries + index,
1729 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1730 (*nb_index_entries)++;
1731 } else if (ie->pos == pos && distance < ie->min_distance)
1732 // do not reduce the distance
1733 distance = ie->min_distance;
1737 ie->timestamp = timestamp;
1738 ie->min_distance = distance;
1745 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1746 int size, int distance, int flags)
1748 timestamp = wrap_timestamp(st, timestamp);
1749 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1750 &st->index_entries_allocated_size, pos,
1751 timestamp, size, distance, flags);
1754 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1755 int64_t wanted_timestamp, int flags)
1763 // Optimize appending index entries at the end.
1764 if (b && entries[b - 1].timestamp < wanted_timestamp)
1769 timestamp = entries[m].timestamp;
1770 if (timestamp >= wanted_timestamp)
1772 if (timestamp <= wanted_timestamp)
1775 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1777 if (!(flags & AVSEEK_FLAG_ANY))
1778 while (m >= 0 && m < nb_entries &&
1779 !(entries[m].flags & AVINDEX_KEYFRAME))
1780 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1782 if (m == nb_entries)
1787 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1790 int64_t pos_delta = 0;
1792 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1793 const char *proto = avio_find_protocol_name(s->filename);
1796 av_log(s, AV_LOG_INFO,
1797 "Protocol name not provided, cannot determine if input is local or "
1798 "a network protocol, buffers and access patterns cannot be configured "
1799 "optimally without knowing the protocol\n");
1802 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1805 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1806 AVStream *st1 = s->streams[ist1];
1807 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1808 AVStream *st2 = s->streams[ist2];
1814 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1815 AVIndexEntry *e1 = &st1->index_entries[i1];
1816 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1818 skip = FFMAX(skip, e1->size);
1819 for (; i2 < st2->nb_index_entries; i2++) {
1820 AVIndexEntry *e2 = &st2->index_entries[i2];
1821 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1822 if (e2_pts - e1_pts < time_tolerance)
1824 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1832 /* XXX This could be adjusted depending on protocol*/
1833 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1834 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1835 ffio_set_buf_size(s->pb, pos_delta);
1836 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
1839 if (skip < (1<<23)) {
1840 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
1844 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1846 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1847 wanted_timestamp, flags);
1850 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1851 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1853 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1854 if (stream_index >= 0)
1855 ts = wrap_timestamp(s->streams[stream_index], ts);
1859 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1860 int64_t target_ts, int flags)
1862 AVInputFormat *avif = s->iformat;
1863 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1864 int64_t ts_min, ts_max, ts;
1869 if (stream_index < 0)
1872 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1875 ts_min = AV_NOPTS_VALUE;
1876 pos_limit = -1; // GCC falsely says it may be uninitialized.
1878 st = s->streams[stream_index];
1879 if (st->index_entries) {
1882 /* FIXME: Whole function must be checked for non-keyframe entries in
1883 * index case, especially read_timestamp(). */
1884 index = av_index_search_timestamp(st, target_ts,
1885 flags | AVSEEK_FLAG_BACKWARD);
1886 index = FFMAX(index, 0);
1887 e = &st->index_entries[index];
1889 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1891 ts_min = e->timestamp;
1892 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1893 pos_min, av_ts2str(ts_min));
1895 av_assert1(index == 0);
1898 index = av_index_search_timestamp(st, target_ts,
1899 flags & ~AVSEEK_FLAG_BACKWARD);
1900 av_assert0(index < st->nb_index_entries);
1902 e = &st->index_entries[index];
1903 av_assert1(e->timestamp >= target_ts);
1905 ts_max = e->timestamp;
1906 pos_limit = pos_max - e->min_distance;
1907 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1908 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1912 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1913 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1918 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1921 ff_read_frame_flush(s);
1922 ff_update_cur_dts(s, st, ts);
1927 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1928 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1930 int64_t step = 1024;
1931 int64_t limit, ts_max;
1932 int64_t filesize = avio_size(s->pb);
1933 int64_t pos_max = filesize - 1;
1936 pos_max = FFMAX(0, (pos_max) - step);
1937 ts_max = ff_read_timestamp(s, stream_index,
1938 &pos_max, limit, read_timestamp);
1940 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1941 if (ts_max == AV_NOPTS_VALUE)
1945 int64_t tmp_pos = pos_max + 1;
1946 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1947 &tmp_pos, INT64_MAX, read_timestamp);
1948 if (tmp_ts == AV_NOPTS_VALUE)
1950 av_assert0(tmp_pos > pos_max);
1953 if (tmp_pos >= filesize)
1965 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1966 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1967 int64_t ts_min, int64_t ts_max,
1968 int flags, int64_t *ts_ret,
1969 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1970 int64_t *, int64_t))
1977 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1979 if (ts_min == AV_NOPTS_VALUE) {
1980 pos_min = s->internal->data_offset;
1981 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1982 if (ts_min == AV_NOPTS_VALUE)
1986 if (ts_min >= target_ts) {
1991 if (ts_max == AV_NOPTS_VALUE) {
1992 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1994 pos_limit = pos_max;
1997 if (ts_max <= target_ts) {
2002 av_assert0(ts_min < ts_max);
2005 while (pos_min < pos_limit) {
2006 av_log(s, AV_LOG_TRACE,
2007 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2008 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2009 av_assert0(pos_limit <= pos_max);
2011 if (no_change == 0) {
2012 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2013 // interpolate position (better than dichotomy)
2014 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2016 pos_min - approximate_keyframe_distance;
2017 } else if (no_change == 1) {
2018 // bisection if interpolation did not change min / max pos last time
2019 pos = (pos_min + pos_limit) >> 1;
2021 /* linear search if bisection failed, can only happen if there
2022 * are very few or no keyframes between min/max */
2027 else if (pos > pos_limit)
2031 // May pass pos_limit instead of -1.
2032 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2037 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2038 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2039 pos_min, pos, pos_max,
2040 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2041 pos_limit, start_pos, no_change);
2042 if (ts == AV_NOPTS_VALUE) {
2043 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2046 if (target_ts <= ts) {
2047 pos_limit = start_pos - 1;
2051 if (target_ts >= ts) {
2057 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2058 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2061 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2063 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2064 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2065 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2071 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2072 int64_t pos, int flags)
2074 int64_t pos_min, pos_max;
2076 pos_min = s->internal->data_offset;
2077 pos_max = avio_size(s->pb) - 1;
2081 else if (pos > pos_max)
2084 avio_seek(s->pb, pos, SEEK_SET);
2086 s->io_repositioned = 1;
2091 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2092 int64_t timestamp, int flags)
2099 st = s->streams[stream_index];
2101 index = av_index_search_timestamp(st, timestamp, flags);
2103 if (index < 0 && st->nb_index_entries &&
2104 timestamp < st->index_entries[0].timestamp)
2107 if (index < 0 || index == st->nb_index_entries - 1) {
2111 if (st->nb_index_entries) {
2112 av_assert0(st->index_entries);
2113 ie = &st->index_entries[st->nb_index_entries - 1];
2114 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2116 ff_update_cur_dts(s, st, ie->timestamp);
2118 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2124 read_status = av_read_frame(s, &pkt);
2125 } while (read_status == AVERROR(EAGAIN));
2126 if (read_status < 0)
2128 av_free_packet(&pkt);
2129 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2130 if (pkt.flags & AV_PKT_FLAG_KEY)
2132 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2133 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);
2138 index = av_index_search_timestamp(st, timestamp, flags);
2143 ff_read_frame_flush(s);
2144 if (s->iformat->read_seek)
2145 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2147 ie = &st->index_entries[index];
2148 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2150 ff_update_cur_dts(s, st, ie->timestamp);
2155 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2156 int64_t timestamp, int flags)
2161 if (flags & AVSEEK_FLAG_BYTE) {
2162 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2164 ff_read_frame_flush(s);
2165 return seek_frame_byte(s, stream_index, timestamp, flags);
2168 if (stream_index < 0) {
2169 stream_index = av_find_default_stream_index(s);
2170 if (stream_index < 0)
2173 st = s->streams[stream_index];
2174 /* timestamp for default must be expressed in AV_TIME_BASE units */
2175 timestamp = av_rescale(timestamp, st->time_base.den,
2176 AV_TIME_BASE * (int64_t) st->time_base.num);
2179 /* first, we try the format specific seek */
2180 if (s->iformat->read_seek) {
2181 ff_read_frame_flush(s);
2182 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2188 if (s->iformat->read_timestamp &&
2189 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2190 ff_read_frame_flush(s);
2191 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2192 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2193 ff_read_frame_flush(s);
2194 return seek_frame_generic(s, stream_index, timestamp, flags);
2199 int av_seek_frame(AVFormatContext *s, int stream_index,
2200 int64_t timestamp, int flags)
2204 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2205 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2206 if ((flags & AVSEEK_FLAG_BACKWARD))
2210 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2211 flags & ~AVSEEK_FLAG_BACKWARD);
2214 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2217 ret = avformat_queue_attached_pictures(s);
2222 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2223 int64_t ts, int64_t max_ts, int flags)
2225 if (min_ts > ts || max_ts < ts)
2227 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2228 return AVERROR(EINVAL);
2231 flags |= AVSEEK_FLAG_ANY;
2232 flags &= ~AVSEEK_FLAG_BACKWARD;
2234 if (s->iformat->read_seek2) {
2236 ff_read_frame_flush(s);
2238 if (stream_index == -1 && s->nb_streams == 1) {
2239 AVRational time_base = s->streams[0]->time_base;
2240 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2241 min_ts = av_rescale_rnd(min_ts, time_base.den,
2242 time_base.num * (int64_t)AV_TIME_BASE,
2243 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2244 max_ts = av_rescale_rnd(max_ts, time_base.den,
2245 time_base.num * (int64_t)AV_TIME_BASE,
2246 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2249 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2253 ret = avformat_queue_attached_pictures(s);
2257 if (s->iformat->read_timestamp) {
2258 // try to seek via read_timestamp()
2261 // Fall back on old API if new is not implemented but old is.
2262 // Note the old API has somewhat different semantics.
2263 if (s->iformat->read_seek || 1) {
2264 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2265 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2266 if (ret<0 && ts != min_ts && max_ts != ts) {
2267 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2269 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2274 // try some generic seek like seek_frame_generic() but with new ts semantics
2275 return -1; //unreachable
2278 int avformat_flush(AVFormatContext *s)
2280 ff_read_frame_flush(s);
2284 /*******************************************************/
2287 * Return TRUE if the stream has accurate duration in any stream.
2289 * @return TRUE if the stream has accurate duration for at least one component.
2291 static int has_duration(AVFormatContext *ic)
2296 for (i = 0; i < ic->nb_streams; i++) {
2297 st = ic->streams[i];
2298 if (st->duration != AV_NOPTS_VALUE)
2301 if (ic->duration != AV_NOPTS_VALUE)
2307 * Estimate the stream timings from the one of each components.
2309 * Also computes the global bitrate if possible.
2311 static void update_stream_timings(AVFormatContext *ic)
2313 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2314 int64_t duration, duration1, filesize;
2319 start_time = INT64_MAX;
2320 start_time_text = INT64_MAX;
2321 end_time = INT64_MIN;
2322 duration = INT64_MIN;
2323 for (i = 0; i < ic->nb_streams; i++) {
2324 st = ic->streams[i];
2325 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2326 start_time1 = av_rescale_q(st->start_time, st->time_base,
2328 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2329 if (start_time1 < start_time_text)
2330 start_time_text = start_time1;
2332 start_time = FFMIN(start_time, start_time1);
2333 end_time1 = AV_NOPTS_VALUE;
2334 if (st->duration != AV_NOPTS_VALUE) {
2335 end_time1 = start_time1 +
2336 av_rescale_q(st->duration, st->time_base,
2338 end_time = FFMAX(end_time, end_time1);
2340 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2341 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2342 p->start_time = start_time1;
2343 if (p->end_time < end_time1)
2344 p->end_time = end_time1;
2347 if (st->duration != AV_NOPTS_VALUE) {
2348 duration1 = av_rescale_q(st->duration, st->time_base,
2350 duration = FFMAX(duration, duration1);
2353 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2354 start_time = start_time_text;
2355 else if (start_time > start_time_text)
2356 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2358 if (start_time != INT64_MAX) {
2359 ic->start_time = start_time;
2360 if (end_time != INT64_MIN) {
2361 if (ic->nb_programs) {
2362 for (i = 0; i < ic->nb_programs; i++) {
2363 p = ic->programs[i];
2364 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2365 duration = FFMAX(duration, p->end_time - p->start_time);
2368 duration = FFMAX(duration, end_time - start_time);
2371 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2372 ic->duration = duration;
2374 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2375 /* compute the bitrate */
2376 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2377 (double) ic->duration;
2378 if (bitrate >= 0 && bitrate <= INT_MAX)
2379 ic->bit_rate = bitrate;
2383 static void fill_all_stream_timings(AVFormatContext *ic)
2388 update_stream_timings(ic);
2389 for (i = 0; i < ic->nb_streams; i++) {
2390 st = ic->streams[i];
2391 if (st->start_time == AV_NOPTS_VALUE) {
2392 if (ic->start_time != AV_NOPTS_VALUE)
2393 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2395 if (ic->duration != AV_NOPTS_VALUE)
2396 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2402 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2404 int64_t filesize, duration;
2405 int i, show_warning = 0;
2408 /* if bit_rate is already set, we believe it */
2409 if (ic->bit_rate <= 0) {
2411 for (i = 0; i < ic->nb_streams; i++) {
2412 st = ic->streams[i];
2413 if (st->codec->bit_rate > 0) {
2414 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2418 bit_rate += st->codec->bit_rate;
2419 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2420 // If we have a videostream with packets but without a bitrate
2421 // then consider the sum not known
2426 ic->bit_rate = bit_rate;
2429 /* if duration is already set, we believe it */
2430 if (ic->duration == AV_NOPTS_VALUE &&
2431 ic->bit_rate != 0) {
2432 filesize = ic->pb ? avio_size(ic->pb) : 0;
2433 if (filesize > ic->internal->data_offset) {
2434 filesize -= ic->internal->data_offset;
2435 for (i = 0; i < ic->nb_streams; i++) {
2436 st = ic->streams[i];
2437 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2438 && st->duration == AV_NOPTS_VALUE) {
2439 duration = av_rescale(8 * filesize, st->time_base.den,
2441 (int64_t) st->time_base.num);
2442 st->duration = duration;
2449 av_log(ic, AV_LOG_WARNING,
2450 "Estimating duration from bitrate, this may be inaccurate\n");
2453 #define DURATION_MAX_READ_SIZE 250000LL
2454 #define DURATION_MAX_RETRY 4
2456 /* only usable for MPEG-PS streams */
2457 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2459 AVPacket pkt1, *pkt = &pkt1;
2461 int num, den, read_size, i, ret;
2462 int found_duration = 0;
2464 int64_t filesize, offset, duration;
2467 /* flush packet queue */
2468 flush_packet_queue(ic);
2470 for (i = 0; i < ic->nb_streams; i++) {
2471 st = ic->streams[i];
2472 if (st->start_time == AV_NOPTS_VALUE &&
2473 st->first_dts == AV_NOPTS_VALUE &&
2474 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2475 av_log(st->codec, AV_LOG_WARNING,
2476 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2479 av_parser_close(st->parser);
2484 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2485 /* estimate the end time (duration) */
2486 /* XXX: may need to support wrapping */
2487 filesize = ic->pb ? avio_size(ic->pb) : 0;
2489 is_end = found_duration;
2490 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2494 avio_seek(ic->pb, offset, SEEK_SET);
2497 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2501 ret = ff_read_packet(ic, pkt);
2502 } while (ret == AVERROR(EAGAIN));
2505 read_size += pkt->size;
2506 st = ic->streams[pkt->stream_index];
2507 if (pkt->pts != AV_NOPTS_VALUE &&
2508 (st->start_time != AV_NOPTS_VALUE ||
2509 st->first_dts != AV_NOPTS_VALUE)) {
2510 if (pkt->duration == 0) {
2511 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2513 pkt->duration = av_rescale_rnd(1,
2514 num * (int64_t) st->time_base.den,
2515 den * (int64_t) st->time_base.num,
2519 duration = pkt->pts + pkt->duration;
2521 if (st->start_time != AV_NOPTS_VALUE)
2522 duration -= st->start_time;
2524 duration -= st->first_dts;
2526 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2527 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2528 st->duration = duration;
2529 st->info->last_duration = duration;
2532 av_free_packet(pkt);
2535 /* check if all audio/video streams have valid duration */
2538 for (i = 0; i < ic->nb_streams; i++) {
2539 st = ic->streams[i];
2540 switch (st->codec->codec_type) {
2541 case AVMEDIA_TYPE_VIDEO:
2542 case AVMEDIA_TYPE_AUDIO:
2543 if (st->duration == AV_NOPTS_VALUE)
2550 ++retry <= DURATION_MAX_RETRY);
2552 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2554 /* warn about audio/video streams which duration could not be estimated */
2555 for (i = 0; i < ic->nb_streams; i++) {
2556 st = ic->streams[i];
2557 if (st->duration == AV_NOPTS_VALUE) {
2558 switch (st->codec->codec_type) {
2559 case AVMEDIA_TYPE_VIDEO:
2560 case AVMEDIA_TYPE_AUDIO:
2561 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2562 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2564 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2568 fill_all_stream_timings(ic);
2570 avio_seek(ic->pb, old_offset, SEEK_SET);
2571 for (i = 0; i < ic->nb_streams; i++) {
2574 st = ic->streams[i];
2575 st->cur_dts = st->first_dts;
2576 st->last_IP_pts = AV_NOPTS_VALUE;
2577 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2578 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2579 st->pts_buffer[j] = AV_NOPTS_VALUE;
2583 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2587 /* get the file size, if possible */
2588 if (ic->iformat->flags & AVFMT_NOFILE) {
2591 file_size = avio_size(ic->pb);
2592 file_size = FFMAX(0, file_size);
2595 if ((!strcmp(ic->iformat->name, "mpeg") ||
2596 !strcmp(ic->iformat->name, "mpegts")) &&
2597 file_size && ic->pb->seekable) {
2598 /* get accurate estimate from the PTSes */
2599 estimate_timings_from_pts(ic, old_offset);
2600 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2601 } else if (has_duration(ic)) {
2602 /* at least one component has timings - we use them for all
2604 fill_all_stream_timings(ic);
2605 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2607 /* less precise: use bitrate info */
2608 estimate_timings_from_bit_rate(ic);
2609 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2611 update_stream_timings(ic);
2615 AVStream av_unused *st;
2616 for (i = 0; i < ic->nb_streams; i++) {
2617 st = ic->streams[i];
2618 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2619 (double) st->start_time / AV_TIME_BASE,
2620 (double) st->duration / AV_TIME_BASE);
2622 av_log(ic, AV_LOG_TRACE,
2623 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2624 (double) ic->start_time / AV_TIME_BASE,
2625 (double) ic->duration / AV_TIME_BASE,
2626 ic->bit_rate / 1000);
2630 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2632 AVCodecContext *avctx = st->codec;
2634 #define FAIL(errmsg) do { \
2636 *errmsg_ptr = errmsg; \
2640 if ( avctx->codec_id == AV_CODEC_ID_NONE
2641 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2642 FAIL("unknown codec");
2643 switch (avctx->codec_type) {
2644 case AVMEDIA_TYPE_AUDIO:
2645 if (!avctx->frame_size && determinable_frame_size(avctx))
2646 FAIL("unspecified frame size");
2647 if (st->info->found_decoder >= 0 &&
2648 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2649 FAIL("unspecified sample format");
2650 if (!avctx->sample_rate)
2651 FAIL("unspecified sample rate");
2652 if (!avctx->channels)
2653 FAIL("unspecified number of channels");
2654 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2655 FAIL("no decodable DTS frames");
2657 case AVMEDIA_TYPE_VIDEO:
2659 FAIL("unspecified size");
2660 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2661 FAIL("unspecified pixel format");
2662 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2663 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2664 FAIL("no frame in rv30/40 and no sar");
2666 case AVMEDIA_TYPE_SUBTITLE:
2667 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2668 FAIL("unspecified size");
2670 case AVMEDIA_TYPE_DATA:
2671 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2677 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2678 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2679 AVDictionary **options)
2681 const AVCodec *codec;
2682 int got_picture = 1, ret = 0;
2683 AVFrame *frame = av_frame_alloc();
2684 AVSubtitle subtitle;
2685 AVPacket pkt = *avpkt;
2688 return AVERROR(ENOMEM);
2690 if (!avcodec_is_open(st->codec) &&
2691 st->info->found_decoder <= 0 &&
2692 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2693 AVDictionary *thread_opt = NULL;
2695 codec = find_decoder(s, st, st->codec->codec_id);
2698 st->info->found_decoder = -st->codec->codec_id;
2703 /* Force thread count to 1 since the H.264 decoder will not extract
2704 * SPS and PPS to extradata during multi-threaded decoding. */
2705 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2706 if (s->codec_whitelist)
2707 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2708 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2710 av_dict_free(&thread_opt);
2712 st->info->found_decoder = -st->codec->codec_id;
2715 st->info->found_decoder = 1;
2716 } else if (!st->info->found_decoder)
2717 st->info->found_decoder = 1;
2719 if (st->info->found_decoder < 0) {
2724 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2726 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2727 (!st->codec_info_nb_frames &&
2728 (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2730 switch (st->codec->codec_type) {
2731 case AVMEDIA_TYPE_VIDEO:
2732 ret = avcodec_decode_video2(st->codec, frame,
2733 &got_picture, &pkt);
2735 case AVMEDIA_TYPE_AUDIO:
2736 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2738 case AVMEDIA_TYPE_SUBTITLE:
2739 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2740 &got_picture, &pkt);
2748 st->nb_decoded_frames++;
2755 if (!pkt.data && !got_picture)
2759 av_frame_free(&frame);
2763 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2765 while (tags->id != AV_CODEC_ID_NONE) {
2773 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2776 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2777 if (tag == tags[i].tag)
2779 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2780 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2782 return AV_CODEC_ID_NONE;
2785 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2790 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2792 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2794 return AV_CODEC_ID_NONE;
2799 if (sflags & (1 << (bps - 1))) {
2802 return AV_CODEC_ID_PCM_S8;
2804 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2806 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2808 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2810 return AV_CODEC_ID_NONE;
2815 return AV_CODEC_ID_PCM_U8;
2817 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2819 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2821 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2823 return AV_CODEC_ID_NONE;
2829 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2832 if (!av_codec_get_tag2(tags, id, &tag))
2837 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2841 for (i = 0; tags && tags[i]; i++) {
2842 const AVCodecTag *codec_tags = tags[i];
2843 while (codec_tags->id != AV_CODEC_ID_NONE) {
2844 if (codec_tags->id == id) {
2845 *tag = codec_tags->tag;
2854 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2857 for (i = 0; tags && tags[i]; i++) {
2858 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2859 if (id != AV_CODEC_ID_NONE)
2862 return AV_CODEC_ID_NONE;
2865 static void compute_chapters_end(AVFormatContext *s)
2868 int64_t max_time = s->duration +
2869 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2871 for (i = 0; i < s->nb_chapters; i++)
2872 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2873 AVChapter *ch = s->chapters[i];
2874 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2878 for (j = 0; j < s->nb_chapters; j++) {
2879 AVChapter *ch1 = s->chapters[j];
2880 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2882 if (j != i && next_start > ch->start && next_start < end)
2885 ch->end = (end == INT64_MAX) ? ch->start : end;
2889 static int get_std_framerate(int i)
2892 return (i + 1) * 1001;
2896 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2900 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2903 /* Is the time base unreliable?
2904 * This is a heuristic to balance between quick acceptance of the values in
2905 * the headers vs. some extra checks.
2906 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2907 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2908 * And there are "variable" fps files this needs to detect as well. */
2909 static int tb_unreliable(AVCodecContext *c)
2911 if (c->time_base.den >= 101LL * c->time_base.num ||
2912 c->time_base.den < 5LL * c->time_base.num ||
2913 // c->codec_tag == AV_RL32("DIVX") ||
2914 // c->codec_tag == AV_RL32("XVID") ||
2915 c->codec_tag == AV_RL32("mp4v") ||
2916 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2917 c->codec_id == AV_CODEC_ID_GIF ||
2918 c->codec_id == AV_CODEC_ID_HEVC ||
2919 c->codec_id == AV_CODEC_ID_H264)
2924 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2928 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
2929 avctx->extradata = NULL;
2930 avctx->extradata_size = 0;
2931 return AVERROR(EINVAL);
2933 avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
2934 if (avctx->extradata) {
2935 memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2936 avctx->extradata_size = size;
2939 avctx->extradata_size = 0;
2940 ret = AVERROR(ENOMEM);
2945 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2947 int ret = ff_alloc_extradata(avctx, size);
2950 ret = avio_read(pb, avctx->extradata, size);
2952 av_freep(&avctx->extradata);
2953 avctx->extradata_size = 0;
2954 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2955 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2961 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2964 int64_t last = st->info->last_dts;
2966 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2967 && ts - (uint64_t)last < INT64_MAX) {
2968 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2969 int64_t duration = ts - last;
2971 if (!st->info->duration_error)
2972 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2973 if (!st->info->duration_error)
2974 return AVERROR(ENOMEM);
2976 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2977 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2978 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2979 if (st->info->duration_error[0][1][i] < 1e10) {
2980 int framerate = get_std_framerate(i);
2981 double sdts = dts*framerate/(1001*12);
2982 for (j= 0; j<2; j++) {
2983 int64_t ticks = llrint(sdts+j*0.5);
2984 double error= sdts - ticks + j*0.5;
2985 st->info->duration_error[j][0][i] += error;
2986 st->info->duration_error[j][1][i] += error*error;
2990 st->info->duration_count++;
2991 st->info->rfps_duration_sum += duration;
2993 if (st->info->duration_count % 10 == 0) {
2994 int n = st->info->duration_count;
2995 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2996 if (st->info->duration_error[0][1][i] < 1e10) {
2997 double a0 = st->info->duration_error[0][0][i] / n;
2998 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2999 double a1 = st->info->duration_error[1][0][i] / n;
3000 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3001 if (error0 > 0.04 && error1 > 0.04) {
3002 st->info->duration_error[0][1][i] = 2e10;
3003 st->info->duration_error[1][1][i] = 2e10;
3009 // ignore the first 4 values, they might have some random jitter
3010 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3011 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3013 if (ts != AV_NOPTS_VALUE)
3014 st->info->last_dts = ts;
3019 void ff_rfps_calculate(AVFormatContext *ic)
3023 for (i = 0; i < ic->nb_streams; i++) {
3024 AVStream *st = ic->streams[i];
3026 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3028 // the check for tb_unreliable() is not completely correct, since this is not about handling
3029 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3030 // ipmovie.c produces.
3031 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)
3032 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);
3033 if (st->info->duration_count>1 && !st->r_frame_rate.num
3034 && tb_unreliable(st->codec)) {
3036 double best_error= 0.01;
3037 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3039 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3042 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3044 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3047 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3050 for (k= 0; k<2; k++) {
3051 int n = st->info->duration_count;
3052 double a= st->info->duration_error[k][0][j] / n;
3053 double error= st->info->duration_error[k][1][j]/n - a*a;
3055 if (error < best_error && best_error> 0.000000001) {
3057 num = get_std_framerate(j);
3060 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3063 // do not increase frame rate by more than 1 % in order to match a standard rate.
3064 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3065 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3067 if ( !st->avg_frame_rate.num
3068 && st->r_frame_rate.num && st->info->rfps_duration_sum
3069 && st->info->codec_info_duration <= 0
3070 && st->info->duration_count > 2
3071 && 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
3073 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3074 st->avg_frame_rate = st->r_frame_rate;
3077 av_freep(&st->info->duration_error);
3078 st->info->last_dts = AV_NOPTS_VALUE;
3079 st->info->duration_count = 0;
3080 st->info->rfps_duration_sum = 0;
3084 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3086 int i, count, ret = 0, j;
3089 AVPacket pkt1, *pkt;
3090 int64_t old_offset = avio_tell(ic->pb);
3091 // new streams might appear, no options for those
3092 int orig_nb_streams = ic->nb_streams;
3094 int64_t max_analyze_duration = ic->max_analyze_duration2;
3095 int64_t max_stream_analyze_duration;
3096 int64_t max_subtitle_analyze_duration;
3097 int64_t probesize = ic->probesize2;
3099 if (!max_analyze_duration)
3100 max_analyze_duration = ic->max_analyze_duration;
3102 probesize = ic->probesize;
3103 flush_codecs = probesize > 0;
3105 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3107 max_stream_analyze_duration = max_analyze_duration;
3108 max_subtitle_analyze_duration = max_analyze_duration;
3109 if (!max_analyze_duration) {
3110 max_stream_analyze_duration =
3111 max_analyze_duration = 5*AV_TIME_BASE;
3112 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3113 if (!strcmp(ic->iformat->name, "flv"))
3114 max_stream_analyze_duration = 30*AV_TIME_BASE;
3118 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3119 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3121 for (i = 0; i < ic->nb_streams; i++) {
3122 const AVCodec *codec;
3123 AVDictionary *thread_opt = NULL;
3124 st = ic->streams[i];
3126 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3127 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3128 /* if (!st->time_base.num)
3130 if (!st->codec->time_base.num)
3131 st->codec->time_base = st->time_base;
3133 // only for the split stuff
3134 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3135 st->parser = av_parser_init(st->codec->codec_id);
3137 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3138 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3139 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3140 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3142 } else if (st->need_parsing) {
3143 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3144 "%s, packets or times may be invalid.\n",
3145 avcodec_get_name(st->codec->codec_id));
3148 codec = find_decoder(ic, st, st->codec->codec_id);
3150 /* Force thread count to 1 since the H.264 decoder will not extract
3151 * SPS and PPS to extradata during multi-threaded decoding. */
3152 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3154 if (ic->codec_whitelist)
3155 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3157 /* Ensure that subtitle_header is properly set. */
3158 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3159 && codec && !st->codec->codec) {
3160 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3161 av_log(ic, AV_LOG_WARNING,
3162 "Failed to open codec in av_find_stream_info\n");
3165 // Try to just open decoders, in case this is enough to get parameters.
3166 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3167 if (codec && !st->codec->codec)
3168 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3169 av_log(ic, AV_LOG_WARNING,
3170 "Failed to open codec in av_find_stream_info\n");
3173 av_dict_free(&thread_opt);
3176 for (i = 0; i < ic->nb_streams; i++) {
3177 #if FF_API_R_FRAME_RATE
3178 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3180 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3181 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3187 int analyzed_all_streams;
3188 if (ff_check_interrupt(&ic->interrupt_callback)) {
3190 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3194 /* check if one codec still needs to be handled */
3195 for (i = 0; i < ic->nb_streams; i++) {
3196 int fps_analyze_framecount = 20;
3198 st = ic->streams[i];
3199 if (!has_codec_parameters(st, NULL))
3201 /* If the timebase is coarse (like the usual millisecond precision
3202 * of mkv), we need to analyze more frames to reliably arrive at
3203 * the correct fps. */
3204 if (av_q2d(st->time_base) > 0.0005)
3205 fps_analyze_framecount *= 2;
3206 if (!tb_unreliable(st->codec))
3207 fps_analyze_framecount = 0;
3208 if (ic->fps_probe_size >= 0)
3209 fps_analyze_framecount = ic->fps_probe_size;
3210 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3211 fps_analyze_framecount = 0;
3212 /* variable fps and no guess at the real fps */
3213 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3214 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3215 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3216 st->info->codec_info_duration_fields/2 :
3217 st->info->duration_count;
3218 if (count < fps_analyze_framecount)
3221 if (st->parser && st->parser->parser->split &&
3222 !st->codec->extradata)
3224 if (st->first_dts == AV_NOPTS_VALUE &&
3225 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3226 st->codec_info_nb_frames < ic->max_ts_probe &&
3227 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3228 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3231 analyzed_all_streams = 0;
3232 if (i == ic->nb_streams) {
3233 analyzed_all_streams = 1;
3234 /* NOTE: If the format has no header, then we need to read some
3235 * packets to get most of the streams, so we cannot stop here. */
3236 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3237 /* If we found the info for all the codecs, we can stop. */
3239 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3244 /* We did not get all the codec info, but we read too much data. */
3245 if (read_size >= probesize) {
3247 av_log(ic, AV_LOG_DEBUG,
3248 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3249 for (i = 0; i < ic->nb_streams; i++)
3250 if (!ic->streams[i]->r_frame_rate.num &&
3251 ic->streams[i]->info->duration_count <= 1 &&
3252 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3253 strcmp(ic->iformat->name, "image2"))
3254 av_log(ic, AV_LOG_WARNING,
3255 "Stream #%d: not enough frames to estimate rate; "
3256 "consider increasing probesize\n", i);
3260 /* NOTE: A new stream can be added there if no header in file
3261 * (AVFMTCTX_NOHEADER). */
3262 ret = read_frame_internal(ic, &pkt1);
3263 if (ret == AVERROR(EAGAIN))
3271 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3272 free_packet_buffer(&ic->internal->packet_buffer,
3273 &ic->internal->packet_buffer_end);
3275 pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3276 &ic->internal->packet_buffer_end);
3278 ret = AVERROR(ENOMEM);
3279 goto find_stream_info_err;
3281 if ((ret = av_dup_packet(pkt)) < 0)
3282 goto find_stream_info_err;
3285 st = ic->streams[pkt->stream_index];
3286 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3287 read_size += pkt->size;
3289 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3290 /* check for non-increasing dts */
3291 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3292 st->info->fps_last_dts >= pkt->dts) {
3293 av_log(ic, AV_LOG_DEBUG,
3294 "Non-increasing DTS in stream %d: packet %d with DTS "
3295 "%"PRId64", packet %d with DTS %"PRId64"\n",
3296 st->index, st->info->fps_last_dts_idx,
3297 st->info->fps_last_dts, st->codec_info_nb_frames,
3299 st->info->fps_first_dts =
3300 st->info->fps_last_dts = AV_NOPTS_VALUE;
3302 /* Check for a discontinuity in dts. If the difference in dts
3303 * is more than 1000 times the average packet duration in the
3304 * sequence, we treat it as a discontinuity. */
3305 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3306 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3307 (pkt->dts - st->info->fps_last_dts) / 1000 >
3308 (st->info->fps_last_dts - st->info->fps_first_dts) /
3309 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3310 av_log(ic, AV_LOG_WARNING,
3311 "DTS discontinuity in stream %d: packet %d with DTS "
3312 "%"PRId64", packet %d with DTS %"PRId64"\n",
3313 st->index, st->info->fps_last_dts_idx,
3314 st->info->fps_last_dts, st->codec_info_nb_frames,
3316 st->info->fps_first_dts =
3317 st->info->fps_last_dts = AV_NOPTS_VALUE;
3320 /* update stored dts values */
3321 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3322 st->info->fps_first_dts = pkt->dts;
3323 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3325 st->info->fps_last_dts = pkt->dts;
3326 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3328 if (st->codec_info_nb_frames>1) {
3332 if (st->time_base.den > 0)
3333 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3334 if (st->avg_frame_rate.num > 0)
3335 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3338 && st->codec_info_nb_frames>30
3339 && st->info->fps_first_dts != AV_NOPTS_VALUE
3340 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3341 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3343 if (analyzed_all_streams) limit = max_analyze_duration;
3344 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3345 else limit = max_stream_analyze_duration;
3348 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3349 max_analyze_duration,
3350 t, pkt->stream_index);
3351 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3352 av_packet_unref(pkt);
3355 if (pkt->duration) {
3356 st->info->codec_info_duration += pkt->duration;
3357 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3360 #if FF_API_R_FRAME_RATE
3361 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3362 ff_rfps_add_frame(ic, st, pkt->dts);
3364 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3365 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3366 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3367 if (ff_alloc_extradata(st->codec, i))
3368 return AVERROR(ENOMEM);
3369 memcpy(st->codec->extradata, pkt->data,
3370 st->codec->extradata_size);
3374 /* If still no information, we try to open the codec and to
3375 * decompress the frame. We try to avoid that in most cases as
3376 * it takes longer and uses more memory. For MPEG-4, we need to
3377 * decompress for QuickTime.
3379 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3380 * least one frame of codec data, this makes sure the codec initializes
3381 * the channel configuration and does not only trust the values from
3383 try_decode_frame(ic, st, pkt,
3384 (options && i < orig_nb_streams) ? &options[i] : NULL);
3386 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3387 av_packet_unref(pkt);
3389 st->codec_info_nb_frames++;
3394 AVPacket empty_pkt = { 0 };
3396 av_init_packet(&empty_pkt);
3398 for (i = 0; i < ic->nb_streams; i++) {
3400 st = ic->streams[i];
3402 /* flush the decoders */
3403 if (st->info->found_decoder == 1) {
3405 err = try_decode_frame(ic, st, &empty_pkt,
3406 (options && i < orig_nb_streams)
3407 ? &options[i] : NULL);
3408 } while (err > 0 && !has_codec_parameters(st, NULL));
3411 av_log(ic, AV_LOG_INFO,
3412 "decoding for stream %d failed\n", st->index);
3418 // close codecs which were opened in try_decode_frame()
3419 for (i = 0; i < ic->nb_streams; i++) {
3420 st = ic->streams[i];
3421 avcodec_close(st->codec);
3424 ff_rfps_calculate(ic);
3426 for (i = 0; i < ic->nb_streams; i++) {
3427 st = ic->streams[i];
3428 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3429 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3430 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3431 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3432 st->codec->codec_tag= tag;
3435 /* estimate average framerate if not set by demuxer */
3436 if (st->info->codec_info_duration_fields &&
3437 !st->avg_frame_rate.num &&
3438 st->info->codec_info_duration) {
3440 double best_error = 0.01;
3442 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3443 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3444 st->info->codec_info_duration < 0)
3446 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3447 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3448 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3450 /* Round guessed framerate to a "standard" framerate if it's
3451 * within 1% of the original estimate. */
3452 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3453 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3454 double error = fabs(av_q2d(st->avg_frame_rate) /
3455 av_q2d(std_fps) - 1);
3457 if (error < best_error) {
3459 best_fps = std_fps.num;
3463 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3464 best_fps, 12 * 1001, INT_MAX);
3467 if (!st->r_frame_rate.num) {
3468 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3469 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3470 st->r_frame_rate.num = st->codec->time_base.den;
3471 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3473 st->r_frame_rate.num = st->time_base.den;
3474 st->r_frame_rate.den = st->time_base.num;
3477 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3478 AVRational hw_ratio = { st->codec->height, st->codec->width };
3479 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3482 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3483 if (!st->codec->bits_per_coded_sample)
3484 st->codec->bits_per_coded_sample =
3485 av_get_bits_per_sample(st->codec->codec_id);
3486 // set stream disposition based on audio service type
3487 switch (st->codec->audio_service_type) {
3488 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3489 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3491 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3492 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3494 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3495 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3497 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3498 st->disposition = AV_DISPOSITION_COMMENT;
3500 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3501 st->disposition = AV_DISPOSITION_KARAOKE;
3508 estimate_timings(ic, old_offset);
3510 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3512 if (ret >= 0 && ic->nb_streams)
3513 /* We could not have all the codec parameters before EOF. */
3515 for (i = 0; i < ic->nb_streams; i++) {
3517 st = ic->streams[i];
3518 if (!has_codec_parameters(st, &errmsg)) {
3520 avcodec_string(buf, sizeof(buf), st->codec, 0);
3521 av_log(ic, AV_LOG_WARNING,
3522 "Could not find codec parameters for stream %d (%s): %s\n"
3523 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3530 compute_chapters_end(ic);
3532 find_stream_info_err:
3533 for (i = 0; i < ic->nb_streams; i++) {
3534 st = ic->streams[i];
3535 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3536 ic->streams[i]->codec->thread_count = 0;
3538 av_freep(&st->info->duration_error);
3539 av_freep(&ic->streams[i]->info);
3542 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3543 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3547 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3551 for (i = 0; i < ic->nb_programs; i++) {
3552 if (ic->programs[i] == last) {
3556 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3557 if (ic->programs[i]->stream_index[j] == s)
3558 return ic->programs[i];
3564 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3565 int wanted_stream_nb, int related_stream,
3566 AVCodec **decoder_ret, int flags)
3568 int i, nb_streams = ic->nb_streams;
3569 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3570 unsigned *program = NULL;
3571 const AVCodec *decoder = NULL, *best_decoder = NULL;
3573 if (related_stream >= 0 && wanted_stream_nb < 0) {
3574 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3576 program = p->stream_index;
3577 nb_streams = p->nb_stream_indexes;
3580 for (i = 0; i < nb_streams; i++) {
3581 int real_stream_index = program ? program[i] : i;
3582 AVStream *st = ic->streams[real_stream_index];
3583 AVCodecContext *avctx = st->codec;
3584 if (avctx->codec_type != type)
3586 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3588 if (wanted_stream_nb != real_stream_index &&
3589 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3590 AV_DISPOSITION_VISUAL_IMPAIRED))
3592 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3595 decoder = find_decoder(ic, st, st->codec->codec_id);
3598 ret = AVERROR_DECODER_NOT_FOUND;
3602 count = st->codec_info_nb_frames;
3603 bitrate = avctx->bit_rate;
3605 bitrate = avctx->rc_max_rate;
3606 multiframe = FFMIN(5, count);
3607 if ((best_multiframe > multiframe) ||
3608 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3609 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3612 best_bitrate = bitrate;
3613 best_multiframe = multiframe;
3614 ret = real_stream_index;
3615 best_decoder = decoder;
3616 if (program && i == nb_streams - 1 && ret < 0) {
3618 nb_streams = ic->nb_streams;
3619 /* no related stream found, try again with everything */
3624 *decoder_ret = (AVCodec*)best_decoder;
3628 /*******************************************************/
3630 int av_read_play(AVFormatContext *s)
3632 if (s->iformat->read_play)
3633 return s->iformat->read_play(s);
3635 return avio_pause(s->pb, 0);
3636 return AVERROR(ENOSYS);
3639 int av_read_pause(AVFormatContext *s)
3641 if (s->iformat->read_pause)
3642 return s->iformat->read_pause(s);
3644 return avio_pause(s->pb, 1);
3645 return AVERROR(ENOSYS);
3648 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3650 av_assert0(s->nb_streams>0);
3651 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3653 for (j = 0; j < st->nb_side_data; j++)
3654 av_freep(&st->side_data[j].data);
3655 av_freep(&st->side_data);
3656 st->nb_side_data = 0;
3659 av_parser_close(st->parser);
3661 if (st->attached_pic.data)
3662 av_free_packet(&st->attached_pic);
3663 av_dict_free(&st->metadata);
3664 av_freep(&st->probe_data.buf);
3665 av_freep(&st->index_entries);
3666 av_freep(&st->codec->extradata);
3667 av_freep(&st->codec->subtitle_header);
3668 av_freep(&st->codec);
3669 av_freep(&st->priv_data);
3671 av_freep(&st->info->duration_error);
3672 av_freep(&st->info);
3673 av_freep(&st->recommended_encoder_configuration);
3674 av_freep(&st->priv_pts);
3675 av_freep(&s->streams[ --s->nb_streams ]);
3678 void avformat_free_context(AVFormatContext *s)
3686 if (s->iformat && s->iformat->priv_class && s->priv_data)
3687 av_opt_free(s->priv_data);
3688 if (s->oformat && s->oformat->priv_class && s->priv_data)
3689 av_opt_free(s->priv_data);
3691 for (i = s->nb_streams - 1; i >= 0; i--) {
3692 ff_free_stream(s, s->streams[i]);
3694 for (i = s->nb_programs - 1; i >= 0; i--) {
3695 av_dict_free(&s->programs[i]->metadata);
3696 av_freep(&s->programs[i]->stream_index);
3697 av_freep(&s->programs[i]);
3699 av_freep(&s->programs);
3700 av_freep(&s->priv_data);
3701 while (s->nb_chapters--) {
3702 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3703 av_freep(&s->chapters[s->nb_chapters]);
3705 av_freep(&s->chapters);
3706 av_dict_free(&s->metadata);
3707 av_freep(&s->streams);
3708 av_freep(&s->internal);
3709 flush_packet_queue(s);
3713 void avformat_close_input(AVFormatContext **ps)
3724 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3725 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3728 flush_packet_queue(s);
3731 if (s->iformat->read_close)
3732 s->iformat->read_close(s);
3734 avformat_free_context(s);
3741 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3747 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3749 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3752 s->streams = streams;
3754 st = av_mallocz(sizeof(AVStream));
3757 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3761 st->info->last_dts = AV_NOPTS_VALUE;
3763 st->codec = avcodec_alloc_context3(c);
3770 /* no default bitrate if decoding */
3771 st->codec->bit_rate = 0;
3773 /* default pts setting is MPEG-like */
3774 avpriv_set_pts_info(st, 33, 1, 90000);
3777 st->index = s->nb_streams;
3778 st->start_time = AV_NOPTS_VALUE;
3779 st->duration = AV_NOPTS_VALUE;
3780 /* we set the current DTS to 0 so that formats without any timestamps
3781 * but durations get some timestamps, formats with some unknown
3782 * timestamps have their first few packets buffered and the
3783 * timestamps corrected before they are returned to the user */
3784 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3785 st->first_dts = AV_NOPTS_VALUE;
3786 st->probe_packets = MAX_PROBE_PACKETS;
3787 st->pts_wrap_reference = AV_NOPTS_VALUE;
3788 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3790 st->last_IP_pts = AV_NOPTS_VALUE;
3791 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3792 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3793 st->pts_buffer[i] = AV_NOPTS_VALUE;
3795 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3797 #if FF_API_R_FRAME_RATE
3798 st->info->last_dts = AV_NOPTS_VALUE;
3800 st->info->fps_first_dts = AV_NOPTS_VALUE;
3801 st->info->fps_last_dts = AV_NOPTS_VALUE;
3803 st->inject_global_side_data = s->internal->inject_global_side_data;
3805 s->streams[s->nb_streams++] = st;
3809 AVProgram *av_new_program(AVFormatContext *ac, int id)
3811 AVProgram *program = NULL;
3814 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3816 for (i = 0; i < ac->nb_programs; i++)
3817 if (ac->programs[i]->id == id)
3818 program = ac->programs[i];
3821 program = av_mallocz(sizeof(AVProgram));
3824 dynarray_add(&ac->programs, &ac->nb_programs, program);
3825 program->discard = AVDISCARD_NONE;
3828 program->pts_wrap_reference = AV_NOPTS_VALUE;
3829 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3831 program->start_time =
3832 program->end_time = AV_NOPTS_VALUE;
3837 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3838 int64_t start, int64_t end, const char *title)
3840 AVChapter *chapter = NULL;
3843 if (end != AV_NOPTS_VALUE && start > end) {
3844 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3848 for (i = 0; i < s->nb_chapters; i++)
3849 if (s->chapters[i]->id == id)
3850 chapter = s->chapters[i];
3853 chapter = av_mallocz(sizeof(AVChapter));
3856 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3858 av_dict_set(&chapter->metadata, "title", title, 0);
3860 chapter->time_base = time_base;
3861 chapter->start = start;
3867 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3870 AVProgram *program = NULL;
3873 if (idx >= ac->nb_streams) {
3874 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3878 for (i = 0; i < ac->nb_programs; i++) {
3879 if (ac->programs[i]->id != progid)
3881 program = ac->programs[i];
3882 for (j = 0; j < program->nb_stream_indexes; j++)
3883 if (program->stream_index[j] == idx)
3886 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3889 program->stream_index = tmp;
3890 program->stream_index[program->nb_stream_indexes++] = idx;
3895 uint64_t ff_ntp_time(void)
3897 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3900 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3903 char *q, buf1[20], c;
3904 int nd, len, percentd_found;
3916 while (av_isdigit(*p))
3917 nd = nd * 10 + *p++ - '0';
3919 } while (av_isdigit(c));
3930 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3932 if ((q - buf + len) > buf_size - 1)
3934 memcpy(q, buf1, len);
3942 if ((q - buf) < buf_size - 1)
3946 if (!percentd_found)
3955 void av_url_split(char *proto, int proto_size,
3956 char *authorization, int authorization_size,
3957 char *hostname, int hostname_size,
3958 int *port_ptr, char *path, int path_size, const char *url)
3960 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3966 if (authorization_size > 0)
3967 authorization[0] = 0;
3968 if (hostname_size > 0)
3973 /* parse protocol */
3974 if ((p = strchr(url, ':'))) {
3975 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3982 /* no protocol means plain filename */
3983 av_strlcpy(path, url, path_size);
3987 /* separate path from hostname */
3988 ls = strchr(p, '/');
3989 ls2 = strchr(p, '?');
3993 ls = FFMIN(ls, ls2);
3995 av_strlcpy(path, ls, path_size);
3997 ls = &p[strlen(p)]; // XXX
3999 /* the rest is hostname, use that to parse auth/port */
4001 /* authorization (user[:pass]@hostname) */
4003 while ((at = strchr(p, '@')) && at < ls) {
4004 av_strlcpy(authorization, at2,
4005 FFMIN(authorization_size, at + 1 - at2));
4006 p = at + 1; /* skip '@' */
4009 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4011 av_strlcpy(hostname, p + 1,
4012 FFMIN(hostname_size, brk - p));
4013 if (brk[1] == ':' && port_ptr)
4014 *port_ptr = atoi(brk + 2);
4015 } else if ((col = strchr(p, ':')) && col < ls) {
4016 av_strlcpy(hostname, p,
4017 FFMIN(col + 1 - p, hostname_size));
4019 *port_ptr = atoi(col + 1);
4021 av_strlcpy(hostname, p,
4022 FFMIN(ls + 1 - p, hostname_size));
4026 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4029 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4032 'C', 'D', 'E', 'F' };
4033 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4036 'c', 'd', 'e', 'f' };
4037 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4039 for (i = 0; i < s; i++) {
4040 buff[i * 2] = hex_table[src[i] >> 4];
4041 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4047 int ff_hex_to_data(uint8_t *data, const char *p)
4054 p += strspn(p, SPACE_CHARS);
4057 c = av_toupper((unsigned char) *p++);
4058 if (c >= '0' && c <= '9')
4060 else if (c >= 'A' && c <= 'F')
4075 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4076 unsigned int pts_num, unsigned int pts_den)
4079 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4080 if (new_tb.num != pts_num)
4081 av_log(NULL, AV_LOG_DEBUG,
4082 "st:%d removing common factor %d from timebase\n",
4083 s->index, pts_num / new_tb.num);
4085 av_log(NULL, AV_LOG_WARNING,
4086 "st:%d has too large timebase, reducing\n", s->index);
4088 if (new_tb.num <= 0 || new_tb.den <= 0) {
4089 av_log(NULL, AV_LOG_ERROR,
4090 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4091 new_tb.num, new_tb.den,
4095 s->time_base = new_tb;
4096 av_codec_set_pkt_timebase(s->codec, new_tb);
4097 s->pts_wrap_bits = pts_wrap_bits;
4100 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4103 const char *ptr = str;
4105 /* Parse key=value pairs. */
4108 char *dest = NULL, *dest_end;
4109 int key_len, dest_len = 0;
4111 /* Skip whitespace and potential commas. */
4112 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4119 if (!(ptr = strchr(key, '=')))
4122 key_len = ptr - key;
4124 callback_get_buf(context, key, key_len, &dest, &dest_len);
4125 dest_end = dest + dest_len - 1;
4129 while (*ptr && *ptr != '\"') {
4133 if (dest && dest < dest_end)
4137 if (dest && dest < dest_end)
4145 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4146 if (dest && dest < dest_end)
4154 int ff_find_stream_index(AVFormatContext *s, int id)
4157 for (i = 0; i < s->nb_streams; i++)
4158 if (s->streams[i]->id == id)
4163 int64_t ff_iso8601_to_unix_time(const char *datestr)
4165 struct tm time1 = { 0 }, time2 = { 0 };
4166 const char *ret1, *ret2;
4167 ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4168 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4170 return av_timegm(&time2);
4172 return av_timegm(&time1);
4175 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4179 unsigned int codec_tag;
4180 if (ofmt->query_codec)
4181 return ofmt->query_codec(codec_id, std_compliance);
4182 else if (ofmt->codec_tag)
4183 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4184 else if (codec_id == ofmt->video_codec ||
4185 codec_id == ofmt->audio_codec ||
4186 codec_id == ofmt->subtitle_codec)
4189 return AVERROR_PATCHWELCOME;
4192 int avformat_network_init(void)
4196 ff_network_inited_globally = 1;
4197 if ((ret = ff_network_init()) < 0)
4199 if ((ret = ff_tls_init()) < 0)
4205 int avformat_network_deinit(void)
4210 ff_network_inited_globally = 0;
4215 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4216 uint64_t channel_layout, int32_t sample_rate,
4217 int32_t width, int32_t height)
4223 return AVERROR(EINVAL);
4226 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4228 if (channel_layout) {
4230 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4234 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4236 if (width || height) {
4238 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4240 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4242 return AVERROR(ENOMEM);
4243 bytestream_put_le32(&data, flags);
4245 bytestream_put_le32(&data, channels);
4247 bytestream_put_le64(&data, channel_layout);
4249 bytestream_put_le32(&data, sample_rate);
4250 if (width || height) {
4251 bytestream_put_le32(&data, width);
4252 bytestream_put_le32(&data, height);
4257 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4259 AVRational undef = {0, 1};
4260 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4261 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4262 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4264 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4265 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4266 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4267 stream_sample_aspect_ratio = undef;
4269 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4270 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4271 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4272 frame_sample_aspect_ratio = undef;
4274 if (stream_sample_aspect_ratio.num)
4275 return stream_sample_aspect_ratio;
4277 return frame_sample_aspect_ratio;
4280 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4282 AVRational fr = st->r_frame_rate;
4283 AVRational codec_fr = st->codec->framerate;
4284 AVRational avg_fr = st->avg_frame_rate;
4286 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4287 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4292 if (st->codec->ticks_per_frame > 1) {
4293 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4294 (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))
4301 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4304 if (*spec <= '9' && *spec >= '0') /* opt:index */
4305 return strtol(spec, NULL, 0) == st->index;
4306 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4307 *spec == 't') { /* opt:[vasdt] */
4308 enum AVMediaType type;
4311 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4312 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4313 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4314 case 'd': type = AVMEDIA_TYPE_DATA; break;
4315 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4316 default: av_assert0(0);
4318 if (type != st->codec->codec_type)
4320 if (*spec++ == ':') { /* possibly followed by :index */
4321 int i, index = strtol(spec, NULL, 0);
4322 for (i = 0; i < s->nb_streams; i++)
4323 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4324 return i == st->index;
4328 } else if (*spec == 'p' && *(spec + 1) == ':') {
4332 prog_id = strtol(spec, &endptr, 0);
4333 for (i = 0; i < s->nb_programs; i++) {
4334 if (s->programs[i]->id != prog_id)
4337 if (*endptr++ == ':') {
4338 int stream_idx = strtol(endptr, NULL, 0);
4339 return stream_idx >= 0 &&
4340 stream_idx < s->programs[i]->nb_stream_indexes &&
4341 st->index == s->programs[i]->stream_index[stream_idx];
4344 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4345 if (st->index == s->programs[i]->stream_index[j])
4349 } else if (*spec == '#' ||
4350 (*spec == 'i' && *(spec + 1) == ':')) {
4353 spec += 1 + (*spec == 'i');
4354 stream_id = strtol(spec, &endptr, 0);
4356 return stream_id == st->id;
4357 } else if (*spec == 'm' && *(spec + 1) == ':') {
4358 AVDictionaryEntry *tag;
4363 val = strchr(spec, ':');
4365 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4367 return AVERROR(ENOMEM);
4369 tag = av_dict_get(st->metadata, key, NULL, 0);
4371 if (!val || !strcmp(tag->value, val + 1))
4380 } else if (*spec == 'u') {
4381 AVCodecContext *avctx = st->codec;
4383 switch (avctx->codec_type) {
4384 case AVMEDIA_TYPE_AUDIO:
4385 val = avctx->sample_rate && avctx->channels;
4386 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4389 case AVMEDIA_TYPE_VIDEO:
4390 val = avctx->width && avctx->height;
4391 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4394 case AVMEDIA_TYPE_UNKNOWN:
4401 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4402 } else if (!*spec) /* empty specifier, matches everything */
4405 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4406 return AVERROR(EINVAL);
4409 int ff_generate_avci_extradata(AVStream *st)
4411 static const uint8_t avci100_1080p_extradata[] = {
4413 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4414 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4415 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4416 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4417 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4418 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4419 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4420 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4421 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4423 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4426 static const uint8_t avci100_1080i_extradata[] = {
4428 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4429 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4430 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4431 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4432 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4433 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4434 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4435 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4436 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4437 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4438 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4440 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4443 static const uint8_t avci50_1080p_extradata[] = {
4445 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4446 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4447 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4448 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4449 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4450 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4451 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4452 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4453 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4455 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4458 static const uint8_t avci50_1080i_extradata[] = {
4460 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4461 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4462 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4463 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4464 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4465 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4466 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4467 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4468 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4469 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4470 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4472 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4475 static const uint8_t avci100_720p_extradata[] = {
4477 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4478 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4479 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4480 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4481 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4482 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4483 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4484 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4485 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4486 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4488 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4491 static const uint8_t avci50_720p_extradata[] = {
4493 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4494 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4495 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4496 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4497 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4498 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4499 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4500 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4501 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4503 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4507 const uint8_t *data = NULL;
4510 if (st->codec->width == 1920) {
4511 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4512 data = avci100_1080p_extradata;
4513 size = sizeof(avci100_1080p_extradata);
4515 data = avci100_1080i_extradata;
4516 size = sizeof(avci100_1080i_extradata);
4518 } else if (st->codec->width == 1440) {
4519 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4520 data = avci50_1080p_extradata;
4521 size = sizeof(avci50_1080p_extradata);
4523 data = avci50_1080i_extradata;
4524 size = sizeof(avci50_1080i_extradata);
4526 } else if (st->codec->width == 1280) {
4527 data = avci100_720p_extradata;
4528 size = sizeof(avci100_720p_extradata);
4529 } else if (st->codec->width == 960) {
4530 data = avci50_720p_extradata;
4531 size = sizeof(avci50_720p_extradata);
4537 av_freep(&st->codec->extradata);
4538 if (ff_alloc_extradata(st->codec, size))
4539 return AVERROR(ENOMEM);
4540 memcpy(st->codec->extradata, data, size);
4545 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4550 for (i = 0; i < st->nb_side_data; i++) {
4551 if (st->side_data[i].type == type) {
4553 *size = st->side_data[i].size;
4554 return st->side_data[i].data;
4560 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4563 AVPacketSideData *sd, *tmp;
4565 uint8_t *data = av_malloc(size);
4570 for (i = 0; i < st->nb_side_data; i++) {
4571 sd = &st->side_data[i];
4573 if (sd->type == type) {
4574 av_freep(&sd->data);
4581 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4587 st->side_data = tmp;
4590 sd = &st->side_data[st->nb_side_data - 1];