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)
122 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
127 void av_format_inject_global_side_data(AVFormatContext *s)
130 s->internal->inject_global_side_data = 1;
131 for (i = 0; i < s->nb_streams; i++) {
132 AVStream *st = s->streams[i];
133 st->inject_global_side_data = 1;
137 int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
139 av_assert0(!dst->codec_whitelist && !dst->format_whitelist);
140 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
141 dst->format_whitelist = av_strdup(src->format_whitelist);
142 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
143 || (src->format_whitelist && !dst->format_whitelist)) {
144 av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
145 return AVERROR(ENOMEM);
150 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
152 if (st->codec->codec)
153 return st->codec->codec;
155 switch (st->codec->codec_type) {
156 case AVMEDIA_TYPE_VIDEO:
157 if (s->video_codec) return s->video_codec;
159 case AVMEDIA_TYPE_AUDIO:
160 if (s->audio_codec) return s->audio_codec;
162 case AVMEDIA_TYPE_SUBTITLE:
163 if (s->subtitle_codec) return s->subtitle_codec;
167 return avcodec_find_decoder(codec_id);
170 int av_format_get_probe_score(const AVFormatContext *s)
172 return s->probe_score;
175 /* an arbitrarily chosen "sane" max packet size -- 50M */
176 #define SANE_CHUNK_SIZE (50000000)
178 int ffio_limit(AVIOContext *s, int size)
180 if (s->maxsize>= 0) {
181 int64_t remaining= s->maxsize - avio_tell(s);
182 if (remaining < size) {
183 int64_t newsize = avio_size(s);
184 if (!s->maxsize || s->maxsize<newsize)
185 s->maxsize = newsize - !newsize;
186 remaining= s->maxsize - avio_tell(s);
187 remaining= FFMAX(remaining, 0);
190 if (s->maxsize>= 0 && remaining+1 < size) {
191 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
198 /* Read the data in sane-sized chunks and append to pkt.
199 * Return the number of bytes read or an error. */
200 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
202 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
203 int orig_size = pkt->size;
207 int prev_size = pkt->size;
210 /* When the caller requests a lot of data, limit it to the amount
211 * left in file or SANE_CHUNK_SIZE when it is not known. */
213 if (read_size > SANE_CHUNK_SIZE/10) {
214 read_size = ffio_limit(s, read_size);
215 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
217 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
220 ret = av_grow_packet(pkt, read_size);
224 ret = avio_read(s, pkt->data + prev_size, read_size);
225 if (ret != read_size) {
226 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
233 pkt->flags |= AV_PKT_FLAG_CORRUPT;
238 return pkt->size > orig_size ? pkt->size - orig_size : ret;
241 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
246 pkt->pos = avio_tell(s);
248 return append_packet_chunked(s, pkt, size);
251 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
254 return av_get_packet(s, pkt, size);
255 return append_packet_chunked(s, pkt, size);
258 int av_filename_number_test(const char *filename)
262 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
265 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
268 static const struct {
271 enum AVMediaType type;
273 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
274 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
275 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
276 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
277 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
278 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
279 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
280 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
281 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
282 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
283 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
287 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
289 if (fmt && st->request_probe <= score) {
291 av_log(s, AV_LOG_DEBUG,
292 "Probe with size=%d, packets=%d detected %s with score=%d\n",
293 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
295 for (i = 0; fmt_id_type[i].name; i++) {
296 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
297 st->codec->codec_id = fmt_id_type[i].id;
298 st->codec->codec_type = fmt_id_type[i].type;
306 /************************************************************/
307 /* input media file */
309 int av_demuxer_open(AVFormatContext *ic) {
312 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
313 av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
314 return AVERROR(EINVAL);
317 if (ic->iformat->read_header) {
318 err = ic->iformat->read_header(ic);
323 if (ic->pb && !ic->internal->data_offset)
324 ic->internal->data_offset = avio_tell(ic->pb);
329 /* Open input file and probe the format if necessary. */
330 static int init_input(AVFormatContext *s, const char *filename,
331 AVDictionary **options)
334 AVProbeData pd = { filename, NULL, 0 };
335 int score = AVPROBE_SCORE_RETRY;
338 s->flags |= AVFMT_FLAG_CUSTOM_IO;
340 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
341 s, 0, s->format_probesize);
342 else if (s->iformat->flags & AVFMT_NOFILE)
343 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
344 "will be ignored with AVFMT_NOFILE format.\n");
348 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
349 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
352 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
353 &s->interrupt_callback, options)) < 0)
357 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
358 s, 0, s->format_probesize);
361 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
362 AVPacketList **plast_pktl)
364 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
369 (*plast_pktl)->next = pktl;
371 *packet_buffer = pktl;
373 /* Add the packet in the buffered packet list. */
379 int avformat_queue_attached_pictures(AVFormatContext *s)
382 for (i = 0; i < s->nb_streams; i++)
383 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
384 s->streams[i]->discard < AVDISCARD_ALL) {
385 AVPacket copy = s->streams[i]->attached_pic;
386 if (copy.size <= 0) {
387 av_log(s, AV_LOG_WARNING,
388 "Attached picture on stream %d has invalid size, "
392 copy.buf = av_buffer_ref(copy.buf);
394 return AVERROR(ENOMEM);
396 add_to_pktbuf(&s->internal->raw_packet_buffer, ©,
397 &s->internal->raw_packet_buffer_end);
402 int avformat_open_input(AVFormatContext **ps, const char *filename,
403 AVInputFormat *fmt, AVDictionary **options)
405 AVFormatContext *s = *ps;
407 AVDictionary *tmp = NULL;
408 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
410 if (!s && !(s = avformat_alloc_context()))
411 return AVERROR(ENOMEM);
413 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
414 return AVERROR(EINVAL);
420 av_dict_copy(&tmp, *options, 0);
422 if (s->pb) // must be before any goto fail
423 s->flags |= AVFMT_FLAG_CUSTOM_IO;
425 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
428 if ((ret = init_input(s, filename, &tmp)) < 0)
430 s->probe_score = ret;
432 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
433 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
434 ret = AVERROR(EINVAL);
438 avio_skip(s->pb, s->skip_initial_bytes);
440 /* Check filename in case an image number is expected. */
441 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
442 if (!av_filename_number_test(filename)) {
443 ret = AVERROR(EINVAL);
448 s->duration = s->start_time = AV_NOPTS_VALUE;
449 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
451 /* Allocate private data. */
452 if (s->iformat->priv_data_size > 0) {
453 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
454 ret = AVERROR(ENOMEM);
457 if (s->iformat->priv_class) {
458 *(const AVClass **) s->priv_data = s->iformat->priv_class;
459 av_opt_set_defaults(s->priv_data);
460 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
465 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
467 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
469 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
470 if ((ret = s->iformat->read_header(s)) < 0)
473 if (id3v2_extra_meta) {
474 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
475 !strcmp(s->iformat->name, "tta")) {
476 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
479 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
481 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
483 if ((ret = avformat_queue_attached_pictures(s)) < 0)
486 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
487 s->internal->data_offset = avio_tell(s->pb);
489 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
492 av_dict_free(options);
499 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
501 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
503 avformat_free_context(s);
508 /*******************************************************/
510 static void force_codec_ids(AVFormatContext *s, AVStream *st)
512 switch (st->codec->codec_type) {
513 case AVMEDIA_TYPE_VIDEO:
514 if (s->video_codec_id)
515 st->codec->codec_id = s->video_codec_id;
517 case AVMEDIA_TYPE_AUDIO:
518 if (s->audio_codec_id)
519 st->codec->codec_id = s->audio_codec_id;
521 case AVMEDIA_TYPE_SUBTITLE:
522 if (s->subtitle_codec_id)
523 st->codec->codec_id = s->subtitle_codec_id;
528 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
530 if (st->request_probe>0) {
531 AVProbeData *pd = &st->probe_data;
533 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
537 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
539 av_log(s, AV_LOG_WARNING,
540 "Failed to reallocate probe buffer for stream %d\n",
545 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
546 pd->buf_size += pkt->size;
547 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
550 st->probe_packets = 0;
552 av_log(s, AV_LOG_WARNING,
553 "nothing to probe for stream %d\n", st->index);
557 end= s->internal->raw_packet_buffer_remaining_size <= 0
558 || st->probe_packets<= 0;
560 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
561 int score = set_codec_from_probe_data(s, st, pd);
562 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
566 st->request_probe = -1;
567 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
568 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
570 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
572 force_codec_ids(s, st);
578 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
580 int64_t ref = pkt->dts;
581 int i, pts_wrap_behavior;
582 int64_t pts_wrap_reference;
583 AVProgram *first_program;
585 if (ref == AV_NOPTS_VALUE)
587 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
589 ref &= (1LL << st->pts_wrap_bits)-1;
591 // reference time stamp should be 60 s before first time stamp
592 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
593 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
594 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
595 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
596 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
598 first_program = av_find_program_from_stream(s, NULL, stream_index);
600 if (!first_program) {
601 int default_stream_index = av_find_default_stream_index(s);
602 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
603 for (i = 0; i < s->nb_streams; i++) {
604 if (av_find_program_from_stream(s, NULL, i))
606 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
607 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
611 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
612 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
616 AVProgram *program = first_program;
618 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
619 pts_wrap_reference = program->pts_wrap_reference;
620 pts_wrap_behavior = program->pts_wrap_behavior;
623 program = av_find_program_from_stream(s, program, stream_index);
626 // update every program with differing pts_wrap_reference
627 program = first_program;
629 if (program->pts_wrap_reference != pts_wrap_reference) {
630 for (i = 0; i<program->nb_stream_indexes; i++) {
631 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
632 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
635 program->pts_wrap_reference = pts_wrap_reference;
636 program->pts_wrap_behavior = pts_wrap_behavior;
638 program = av_find_program_from_stream(s, program, stream_index);
644 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
650 AVPacketList *pktl = s->internal->raw_packet_buffer;
654 st = s->streams[pkt->stream_index];
655 if (s->internal->raw_packet_buffer_remaining_size <= 0)
656 if ((err = probe_codec(s, st, NULL)) < 0)
658 if (st->request_probe <= 0) {
659 s->internal->raw_packet_buffer = pktl->next;
660 s->internal->raw_packet_buffer_remaining_size += pkt->size;
669 ret = s->iformat->read_packet(s, pkt);
671 if (!pktl || ret == AVERROR(EAGAIN))
673 for (i = 0; i < s->nb_streams; i++) {
675 if (st->probe_packets)
676 if ((err = probe_codec(s, st, NULL)) < 0)
678 av_assert0(st->request_probe <= 0);
683 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
684 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
685 av_log(s, AV_LOG_WARNING,
686 "Dropped corrupted packet (stream = %d)\n",
692 if (pkt->stream_index >= (unsigned)s->nb_streams) {
693 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
697 st = s->streams[pkt->stream_index];
699 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
700 // correct first time stamps to negative values
701 if (!is_relative(st->first_dts))
702 st->first_dts = wrap_timestamp(st, st->first_dts);
703 if (!is_relative(st->start_time))
704 st->start_time = wrap_timestamp(st, st->start_time);
705 if (!is_relative(st->cur_dts))
706 st->cur_dts = wrap_timestamp(st, st->cur_dts);
709 pkt->dts = wrap_timestamp(st, pkt->dts);
710 pkt->pts = wrap_timestamp(st, pkt->pts);
712 force_codec_ids(s, st);
714 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
715 if (s->use_wallclock_as_timestamps)
716 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
718 if (!pktl && st->request_probe <= 0)
721 add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
722 &s->internal->raw_packet_buffer_end);
723 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
725 if ((err = probe_codec(s, st, pkt)) < 0)
731 /**********************************************************/
733 static int determinable_frame_size(AVCodecContext *avctx)
735 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
736 avctx->codec_id == AV_CODEC_ID_MP1 ||
737 avctx->codec_id == AV_CODEC_ID_MP2 ||
738 avctx->codec_id == AV_CODEC_ID_MP3/* ||
739 avctx->codec_id == AV_CODEC_ID_CELT*/)
745 * Return the frame duration in seconds. Return 0 if not available.
747 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
748 AVCodecParserContext *pc, AVPacket *pkt)
750 AVRational codec_framerate = s->iformat ? st->codec->framerate :
751 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
756 switch (st->codec->codec_type) {
757 case AVMEDIA_TYPE_VIDEO:
758 if (st->r_frame_rate.num && !pc && s->iformat) {
759 *pnum = st->r_frame_rate.den;
760 *pden = st->r_frame_rate.num;
761 } else if (st->time_base.num * 1000LL > st->time_base.den) {
762 *pnum = st->time_base.num;
763 *pden = st->time_base.den;
764 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
765 av_assert0(st->codec->ticks_per_frame);
766 av_reduce(pnum, pden,
768 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
771 if (pc && pc->repeat_pict) {
772 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
773 av_reduce(pnum, pden,
774 (*pnum) * (1LL + pc->repeat_pict),
778 /* If this codec can be interlaced or progressive then we need
779 * a parser to compute duration of a packet. Thus if we have
780 * no parser in such case leave duration undefined. */
781 if (st->codec->ticks_per_frame > 1 && !pc)
785 case AVMEDIA_TYPE_AUDIO:
786 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
787 if (frame_size <= 0 || st->codec->sample_rate <= 0)
790 *pden = st->codec->sample_rate;
797 static int is_intra_only(AVCodecContext *enc) {
798 const AVCodecDescriptor *desc;
800 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
803 desc = av_codec_get_codec_descriptor(enc);
805 desc = avcodec_descriptor_get(enc->codec_id);
806 av_codec_set_codec_descriptor(enc, desc);
809 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
813 static int has_decode_delay_been_guessed(AVStream *st)
815 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
816 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
818 #if CONFIG_H264_DECODER
819 if (st->codec->has_b_frames &&
820 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
823 if (st->codec->has_b_frames<3)
824 return st->nb_decoded_frames >= 7;
825 else if (st->codec->has_b_frames<4)
826 return st->nb_decoded_frames >= 18;
828 return st->nb_decoded_frames >= 20;
831 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
835 if (pktl == s->internal->packet_buffer_end)
836 return s->internal->parse_queue;
840 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
841 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
842 st->codec->codec_id != AV_CODEC_ID_HEVC;
845 int delay = st->codec->has_b_frames;
848 if (dts == AV_NOPTS_VALUE) {
849 int64_t best_score = INT64_MAX;
850 for (i = 0; i<delay; i++) {
851 if (st->pts_reorder_error_count[i]) {
852 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
853 if (score < best_score) {
860 for (i = 0; i<delay; i++) {
861 if (pts_buffer[i] != AV_NOPTS_VALUE) {
862 int64_t diff = FFABS(pts_buffer[i] - dts)
863 + (uint64_t)st->pts_reorder_error[i];
864 diff = FFMAX(diff, st->pts_reorder_error[i]);
865 st->pts_reorder_error[i] = diff;
866 st->pts_reorder_error_count[i]++;
867 if (st->pts_reorder_error_count[i] > 250) {
868 st->pts_reorder_error[i] >>= 1;
869 st->pts_reorder_error_count[i] >>= 1;
876 if (dts == AV_NOPTS_VALUE)
882 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
883 int64_t dts, int64_t pts, AVPacket *pkt)
885 AVStream *st = s->streams[stream_index];
886 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
887 int64_t pts_buffer[MAX_REORDER_DELAY+1];
891 if (st->first_dts != AV_NOPTS_VALUE ||
892 dts == AV_NOPTS_VALUE ||
893 st->cur_dts == AV_NOPTS_VALUE ||
897 delay = st->codec->has_b_frames;
898 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
900 shift = st->first_dts - RELATIVE_TS_BASE;
902 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
903 pts_buffer[i] = AV_NOPTS_VALUE;
905 if (is_relative(pts))
908 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
909 if (pktl->pkt.stream_index != stream_index)
911 if (is_relative(pktl->pkt.pts))
912 pktl->pkt.pts += shift;
914 if (is_relative(pktl->pkt.dts))
915 pktl->pkt.dts += shift;
917 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
918 st->start_time = pktl->pkt.pts;
920 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
921 pts_buffer[0] = pktl->pkt.pts;
922 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
923 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
925 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
929 if (st->start_time == AV_NOPTS_VALUE)
930 st->start_time = pts;
933 static void update_initial_durations(AVFormatContext *s, AVStream *st,
934 int stream_index, int duration)
936 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
937 int64_t cur_dts = RELATIVE_TS_BASE;
939 if (st->first_dts != AV_NOPTS_VALUE) {
940 if (st->update_initial_durations_done)
942 st->update_initial_durations_done = 1;
943 cur_dts = st->first_dts;
944 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
945 if (pktl->pkt.stream_index == stream_index) {
946 if (pktl->pkt.pts != pktl->pkt.dts ||
947 pktl->pkt.dts != AV_NOPTS_VALUE ||
953 if (pktl && pktl->pkt.dts != st->first_dts) {
954 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
955 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
959 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
962 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
963 st->first_dts = cur_dts;
964 } else if (st->cur_dts != RELATIVE_TS_BASE)
967 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
968 if (pktl->pkt.stream_index != stream_index)
970 if (pktl->pkt.pts == pktl->pkt.dts &&
971 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
972 !pktl->pkt.duration) {
973 pktl->pkt.dts = cur_dts;
974 if (!st->codec->has_b_frames)
975 pktl->pkt.pts = cur_dts;
976 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
977 pktl->pkt.duration = duration;
980 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
983 st->cur_dts = cur_dts;
986 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
987 AVCodecParserContext *pc, AVPacket *pkt,
988 int64_t next_dts, int64_t next_pts)
990 int num, den, presentation_delayed, delay, i;
993 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
994 st->codec->codec_id != AV_CODEC_ID_HEVC;
996 if (s->flags & AVFMT_FLAG_NOFILLIN)
999 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1000 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1001 if (st->last_dts_for_order_check <= pkt->dts) {
1004 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1005 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1007 st->last_dts_for_order_check);
1008 st->dts_misordered++;
1010 if (st->dts_ordered + st->dts_misordered > 250) {
1011 st->dts_ordered >>= 1;
1012 st->dts_misordered >>= 1;
1016 st->last_dts_for_order_check = pkt->dts;
1017 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1018 pkt->dts = AV_NOPTS_VALUE;
1021 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1022 pkt->dts = AV_NOPTS_VALUE;
1024 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1025 && !st->codec->has_b_frames)
1026 //FIXME Set low_delay = 0 when has_b_frames = 1
1027 st->codec->has_b_frames = 1;
1029 /* do we have a video B-frame ? */
1030 delay = st->codec->has_b_frames;
1031 presentation_delayed = 0;
1033 /* XXX: need has_b_frame, but cannot get it if the codec is
1034 * not initialized */
1036 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1037 presentation_delayed = 1;
1039 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1040 st->pts_wrap_bits < 63 &&
1041 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1042 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1043 pkt->dts -= 1LL << st->pts_wrap_bits;
1045 pkt->pts += 1LL << st->pts_wrap_bits;
1048 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1049 * We take the conservative approach and discard both.
1050 * Note: If this is misbehaving for an H.264 file, then possibly
1051 * presentation_delayed is not set correctly. */
1052 if (delay == 1 && pkt->dts == pkt->pts &&
1053 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1054 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1055 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1056 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1057 pkt->dts = AV_NOPTS_VALUE;
1060 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1061 if (pkt->duration == 0) {
1062 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1064 duration = (AVRational) {num, den};
1065 pkt->duration = av_rescale_rnd(1,
1066 num * (int64_t) st->time_base.den,
1067 den * (int64_t) st->time_base.num,
1072 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1073 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1075 /* Correct timestamps with byte offset if demuxers only have timestamps
1076 * on packet boundaries */
1077 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1078 /* this will estimate bitrate based on this frame's duration and size */
1079 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1080 if (pkt->pts != AV_NOPTS_VALUE)
1082 if (pkt->dts != AV_NOPTS_VALUE)
1086 /* This may be redundant, but it should not hurt. */
1087 if (pkt->dts != AV_NOPTS_VALUE &&
1088 pkt->pts != AV_NOPTS_VALUE &&
1089 pkt->pts > pkt->dts)
1090 presentation_delayed = 1;
1092 if (s->debug & FF_FDEBUG_TS)
1093 av_log(s, AV_LOG_TRACE,
1094 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1095 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1096 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1098 /* Interpolate PTS and DTS if they are not present. We skip H264
1099 * currently because delay and has_b_frames are not reliably set. */
1100 if ((delay == 0 || (delay == 1 && pc)) &&
1102 if (presentation_delayed) {
1103 /* DTS = decompression timestamp */
1104 /* PTS = presentation timestamp */
1105 if (pkt->dts == AV_NOPTS_VALUE)
1106 pkt->dts = st->last_IP_pts;
1107 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1108 if (pkt->dts == AV_NOPTS_VALUE)
1109 pkt->dts = st->cur_dts;
1111 /* This is tricky: the dts must be incremented by the duration
1112 * of the frame we are displaying, i.e. the last I- or P-frame. */
1113 if (st->last_IP_duration == 0)
1114 st->last_IP_duration = pkt->duration;
1115 if (pkt->dts != AV_NOPTS_VALUE)
1116 st->cur_dts = pkt->dts + st->last_IP_duration;
1117 if (pkt->dts != AV_NOPTS_VALUE &&
1118 pkt->pts == AV_NOPTS_VALUE &&
1119 st->last_IP_duration > 0 &&
1120 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1121 next_dts != next_pts &&
1122 next_pts != AV_NOPTS_VALUE)
1123 pkt->pts = next_dts;
1125 st->last_IP_duration = pkt->duration;
1126 st->last_IP_pts = pkt->pts;
1127 /* Cannot compute PTS if not present (we can compute it only
1128 * by knowing the future. */
1129 } else if (pkt->pts != AV_NOPTS_VALUE ||
1130 pkt->dts != AV_NOPTS_VALUE ||
1133 /* presentation is not delayed : PTS and DTS are the same */
1134 if (pkt->pts == AV_NOPTS_VALUE)
1135 pkt->pts = pkt->dts;
1136 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1138 if (pkt->pts == AV_NOPTS_VALUE)
1139 pkt->pts = st->cur_dts;
1140 pkt->dts = pkt->pts;
1141 if (pkt->pts != AV_NOPTS_VALUE)
1142 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1146 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1147 st->pts_buffer[0] = pkt->pts;
1148 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1149 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1151 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1153 // We skipped it above so we try here.
1155 // This should happen on the first packet
1156 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1157 if (pkt->dts > st->cur_dts)
1158 st->cur_dts = pkt->dts;
1160 if (s->debug & FF_FDEBUG_TS)
1161 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1162 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1165 if (is_intra_only(st->codec))
1166 pkt->flags |= AV_PKT_FLAG_KEY;
1168 pkt->convergence_duration = pc->convergence_duration;
1171 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1174 AVPacketList *pktl = *pkt_buf;
1175 *pkt_buf = pktl->next;
1176 av_free_packet(&pktl->pkt);
1179 *pkt_buf_end = NULL;
1183 * Parse a packet, add all split parts to parse_queue.
1185 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1187 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1189 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1190 AVStream *st = s->streams[stream_index];
1191 uint8_t *data = pkt ? pkt->data : NULL;
1192 int size = pkt ? pkt->size : 0;
1193 int ret = 0, got_output = 0;
1196 av_init_packet(&flush_pkt);
1199 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1200 // preserve 0-size sync packets
1201 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1204 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1206 int64_t next_pts = pkt->pts;
1207 int64_t next_dts = pkt->dts;
1209 av_init_packet(&out_pkt);
1210 len = av_parser_parse2(st->parser, st->codec,
1211 &out_pkt.data, &out_pkt.size, data, size,
1212 pkt->pts, pkt->dts, pkt->pos);
1214 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1216 /* increment read pointer */
1220 got_output = !!out_pkt.size;
1225 if (pkt->side_data) {
1226 out_pkt.side_data = pkt->side_data;
1227 out_pkt.side_data_elems = pkt->side_data_elems;
1228 pkt->side_data = NULL;
1229 pkt->side_data_elems = 0;
1232 /* set the duration */
1233 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1234 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1235 if (st->codec->sample_rate > 0) {
1237 av_rescale_q_rnd(st->parser->duration,
1238 (AVRational) { 1, st->codec->sample_rate },
1244 out_pkt.stream_index = st->index;
1245 out_pkt.pts = st->parser->pts;
1246 out_pkt.dts = st->parser->dts;
1247 out_pkt.pos = st->parser->pos;
1249 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1250 out_pkt.pos = st->parser->frame_offset;
1252 if (st->parser->key_frame == 1 ||
1253 (st->parser->key_frame == -1 &&
1254 st->parser->pict_type == AV_PICTURE_TYPE_I))
1255 out_pkt.flags |= AV_PKT_FLAG_KEY;
1257 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1258 out_pkt.flags |= AV_PKT_FLAG_KEY;
1260 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1262 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1263 out_pkt.buf = pkt->buf;
1265 #if FF_API_DESTRUCT_PACKET
1266 FF_DISABLE_DEPRECATION_WARNINGS
1267 out_pkt.destruct = pkt->destruct;
1268 pkt->destruct = NULL;
1269 FF_ENABLE_DEPRECATION_WARNINGS
1272 if ((ret = av_dup_packet(&out_pkt)) < 0)
1275 if (!add_to_pktbuf(&s->internal->parse_queue, &out_pkt, &s->internal->parse_queue_end)) {
1276 av_free_packet(&out_pkt);
1277 ret = AVERROR(ENOMEM);
1282 /* end of the stream => close and free the parser */
1283 if (pkt == &flush_pkt) {
1284 av_parser_close(st->parser);
1289 av_free_packet(pkt);
1293 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1294 AVPacketList **pkt_buffer_end,
1298 av_assert0(*pkt_buffer);
1301 *pkt_buffer = pktl->next;
1303 *pkt_buffer_end = NULL;
1308 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1310 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1313 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1315 int ret = 0, i, got_packet = 0;
1316 AVDictionary *metadata = NULL;
1318 av_init_packet(pkt);
1320 while (!got_packet && !s->internal->parse_queue) {
1324 /* read next packet */
1325 ret = ff_read_packet(s, &cur_pkt);
1327 if (ret == AVERROR(EAGAIN))
1329 /* flush the parsers */
1330 for (i = 0; i < s->nb_streams; i++) {
1332 if (st->parser && st->need_parsing)
1333 parse_packet(s, NULL, st->index);
1335 /* all remaining packets are now in parse_queue =>
1336 * really terminate parsing */
1340 st = s->streams[cur_pkt.stream_index];
1342 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1343 cur_pkt.dts != AV_NOPTS_VALUE &&
1344 cur_pkt.pts < cur_pkt.dts) {
1345 av_log(s, AV_LOG_WARNING,
1346 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1347 cur_pkt.stream_index,
1348 av_ts2str(cur_pkt.pts),
1349 av_ts2str(cur_pkt.dts),
1352 if (s->debug & FF_FDEBUG_TS)
1353 av_log(s, AV_LOG_DEBUG,
1354 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1355 cur_pkt.stream_index,
1356 av_ts2str(cur_pkt.pts),
1357 av_ts2str(cur_pkt.dts),
1358 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1360 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1361 st->parser = av_parser_init(st->codec->codec_id);
1363 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1364 "%s, packets or times may be invalid.\n",
1365 avcodec_get_name(st->codec->codec_id));
1366 /* no parser available: just output the raw packets */
1367 st->need_parsing = AVSTREAM_PARSE_NONE;
1368 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1369 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1370 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1371 st->parser->flags |= PARSER_FLAG_ONCE;
1372 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1373 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1376 if (!st->need_parsing || !st->parser) {
1377 /* no parsing needed: we just output the packet as is */
1379 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1380 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1381 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1382 ff_reduce_index(s, st->index);
1383 av_add_index_entry(st, pkt->pos, pkt->dts,
1384 0, 0, AVINDEX_KEYFRAME);
1387 } else if (st->discard < AVDISCARD_ALL) {
1388 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1392 av_free_packet(&cur_pkt);
1394 if (pkt->flags & AV_PKT_FLAG_KEY)
1395 st->skip_to_keyframe = 0;
1396 if (st->skip_to_keyframe) {
1397 av_free_packet(&cur_pkt);
1405 if (!got_packet && s->internal->parse_queue)
1406 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1409 AVStream *st = s->streams[pkt->stream_index];
1410 int discard_padding = 0;
1411 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1412 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1413 int64_t sample = ts_to_samples(st, pts);
1414 int duration = ts_to_samples(st, pkt->duration);
1415 int64_t end_sample = sample + duration;
1416 if (duration > 0 && end_sample >= st->first_discard_sample &&
1417 sample < st->last_discard_sample)
1418 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1420 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1421 st->skip_samples = st->start_skip_samples;
1422 if (st->skip_samples || discard_padding) {
1423 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1425 AV_WL32(p, st->skip_samples);
1426 AV_WL32(p + 4, discard_padding);
1427 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1429 st->skip_samples = 0;
1432 if (st->inject_global_side_data) {
1433 for (i = 0; i < st->nb_side_data; i++) {
1434 AVPacketSideData *src_sd = &st->side_data[i];
1437 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1440 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1442 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1446 memcpy(dst_data, src_sd->data, src_sd->size);
1448 st->inject_global_side_data = 0;
1451 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1452 av_packet_merge_side_data(pkt);
1455 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1457 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1458 av_dict_copy(&s->metadata, metadata, 0);
1459 av_dict_free(&metadata);
1460 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1463 if (s->debug & FF_FDEBUG_TS)
1464 av_log(s, AV_LOG_DEBUG,
1465 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1466 "size=%d, duration=%d, flags=%d\n",
1468 av_ts2str(pkt->pts),
1469 av_ts2str(pkt->dts),
1470 pkt->size, pkt->duration, pkt->flags);
1475 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1477 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1483 ret = s->internal->packet_buffer
1484 ? read_from_packet_buffer(&s->internal->packet_buffer,
1485 &s->internal->packet_buffer_end, pkt)
1486 : read_frame_internal(s, pkt);
1493 AVPacketList *pktl = s->internal->packet_buffer;
1496 AVPacket *next_pkt = &pktl->pkt;
1498 if (next_pkt->dts != AV_NOPTS_VALUE) {
1499 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1500 // last dts seen for this stream. if any of packets following
1501 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1502 int64_t last_dts = next_pkt->dts;
1503 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1504 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1505 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1506 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1508 next_pkt->pts = pktl->pkt.dts;
1510 if (last_dts != AV_NOPTS_VALUE) {
1511 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1512 last_dts = pktl->pkt.dts;
1517 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1518 // Fixing the last reference frame had none pts issue (For MXF etc).
1519 // We only do this when
1521 // 2. we are not able to resolve a pts value for current packet.
1522 // 3. the packets for this stream at the end of the files had valid dts.
1523 next_pkt->pts = last_dts + next_pkt->duration;
1525 pktl = s->internal->packet_buffer;
1528 /* read packet from packet buffer, if there is data */
1529 st = s->streams[next_pkt->stream_index];
1530 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1531 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1532 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1533 &s->internal->packet_buffer_end, pkt);
1538 ret = read_frame_internal(s, pkt);
1540 if (pktl && ret != AVERROR(EAGAIN)) {
1547 if (av_dup_packet(add_to_pktbuf(&s->internal->packet_buffer, pkt,
1548 &s->internal->packet_buffer_end)) < 0)
1549 return AVERROR(ENOMEM);
1554 st = s->streams[pkt->stream_index];
1555 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1556 ff_reduce_index(s, st->index);
1557 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1560 if (is_relative(pkt->dts))
1561 pkt->dts -= RELATIVE_TS_BASE;
1562 if (is_relative(pkt->pts))
1563 pkt->pts -= RELATIVE_TS_BASE;
1568 /* XXX: suppress the packet queue */
1569 static void flush_packet_queue(AVFormatContext *s)
1573 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1574 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1575 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1577 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1580 /*******************************************************/
1583 int av_find_default_stream_index(AVFormatContext *s)
1587 int best_stream = 0;
1588 int best_score = INT_MIN;
1590 if (s->nb_streams <= 0)
1592 for (i = 0; i < s->nb_streams; i++) {
1595 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1596 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1598 if (st->codec->width && st->codec->height)
1602 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1603 if (st->codec->sample_rate)
1606 if (st->codec_info_nb_frames)
1609 if (st->discard != AVDISCARD_ALL)
1612 if (score > best_score) {
1620 /** Flush the frame reader. */
1621 void ff_read_frame_flush(AVFormatContext *s)
1626 flush_packet_queue(s);
1628 /* Reset read state for each stream. */
1629 for (i = 0; i < s->nb_streams; i++) {
1633 av_parser_close(st->parser);
1636 st->last_IP_pts = AV_NOPTS_VALUE;
1637 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1638 if (st->first_dts == AV_NOPTS_VALUE)
1639 st->cur_dts = RELATIVE_TS_BASE;
1641 /* We set the current DTS to an unspecified origin. */
1642 st->cur_dts = AV_NOPTS_VALUE;
1644 st->probe_packets = MAX_PROBE_PACKETS;
1646 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1647 st->pts_buffer[j] = AV_NOPTS_VALUE;
1649 if (s->internal->inject_global_side_data)
1650 st->inject_global_side_data = 1;
1652 st->skip_samples = 0;
1656 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1660 for (i = 0; i < s->nb_streams; i++) {
1661 AVStream *st = s->streams[i];
1664 av_rescale(timestamp,
1665 st->time_base.den * (int64_t) ref_st->time_base.num,
1666 st->time_base.num * (int64_t) ref_st->time_base.den);
1670 void ff_reduce_index(AVFormatContext *s, int stream_index)
1672 AVStream *st = s->streams[stream_index];
1673 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1675 if ((unsigned) st->nb_index_entries >= max_entries) {
1677 for (i = 0; 2 * i < st->nb_index_entries; i++)
1678 st->index_entries[i] = st->index_entries[2 * i];
1679 st->nb_index_entries = i;
1683 int ff_add_index_entry(AVIndexEntry **index_entries,
1684 int *nb_index_entries,
1685 unsigned int *index_entries_allocated_size,
1686 int64_t pos, int64_t timestamp,
1687 int size, int distance, int flags)
1689 AVIndexEntry *entries, *ie;
1692 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1695 if (timestamp == AV_NOPTS_VALUE)
1696 return AVERROR(EINVAL);
1698 if (size < 0 || size > 0x3FFFFFFF)
1699 return AVERROR(EINVAL);
1701 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1702 timestamp -= RELATIVE_TS_BASE;
1704 entries = av_fast_realloc(*index_entries,
1705 index_entries_allocated_size,
1706 (*nb_index_entries + 1) *
1707 sizeof(AVIndexEntry));
1711 *index_entries = entries;
1713 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1714 timestamp, AVSEEK_FLAG_ANY);
1717 index = (*nb_index_entries)++;
1718 ie = &entries[index];
1719 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1721 ie = &entries[index];
1722 if (ie->timestamp != timestamp) {
1723 if (ie->timestamp <= timestamp)
1725 memmove(entries + index + 1, entries + index,
1726 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1727 (*nb_index_entries)++;
1728 } else if (ie->pos == pos && distance < ie->min_distance)
1729 // do not reduce the distance
1730 distance = ie->min_distance;
1734 ie->timestamp = timestamp;
1735 ie->min_distance = distance;
1742 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1743 int size, int distance, int flags)
1745 timestamp = wrap_timestamp(st, timestamp);
1746 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1747 &st->index_entries_allocated_size, pos,
1748 timestamp, size, distance, flags);
1751 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1752 int64_t wanted_timestamp, int flags)
1760 // Optimize appending index entries at the end.
1761 if (b && entries[b - 1].timestamp < wanted_timestamp)
1766 timestamp = entries[m].timestamp;
1767 if (timestamp >= wanted_timestamp)
1769 if (timestamp <= wanted_timestamp)
1772 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1774 if (!(flags & AVSEEK_FLAG_ANY))
1775 while (m >= 0 && m < nb_entries &&
1776 !(entries[m].flags & AVINDEX_KEYFRAME))
1777 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1779 if (m == nb_entries)
1784 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1787 int64_t pos_delta = 0;
1789 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1790 const char *proto = avio_find_protocol_name(s->filename);
1793 av_log(s, AV_LOG_INFO,
1794 "Protocol name not provided, cannot determine if input is local or "
1795 "a network protocol, buffers and access patterns cannot be configured "
1796 "optimally without knowing the protocol\n");
1799 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1802 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1803 AVStream *st1 = s->streams[ist1];
1804 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1805 AVStream *st2 = s->streams[ist2];
1811 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1812 AVIndexEntry *e1 = &st1->index_entries[i1];
1813 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1815 skip = FFMAX(skip, e1->size);
1816 for (; i2 < st2->nb_index_entries; i2++) {
1817 AVIndexEntry *e2 = &st2->index_entries[i2];
1818 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1819 if (e2_pts - e1_pts < time_tolerance)
1821 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1829 /* XXX This could be adjusted depending on protocol*/
1830 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1831 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1832 ffio_set_buf_size(s->pb, pos_delta);
1833 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
1836 if (skip < (1<<23)) {
1837 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
1841 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1843 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1844 wanted_timestamp, flags);
1847 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1848 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1850 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1851 if (stream_index >= 0)
1852 ts = wrap_timestamp(s->streams[stream_index], ts);
1856 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1857 int64_t target_ts, int flags)
1859 AVInputFormat *avif = s->iformat;
1860 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1861 int64_t ts_min, ts_max, ts;
1866 if (stream_index < 0)
1869 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1872 ts_min = AV_NOPTS_VALUE;
1873 pos_limit = -1; // GCC falsely says it may be uninitialized.
1875 st = s->streams[stream_index];
1876 if (st->index_entries) {
1879 /* FIXME: Whole function must be checked for non-keyframe entries in
1880 * index case, especially read_timestamp(). */
1881 index = av_index_search_timestamp(st, target_ts,
1882 flags | AVSEEK_FLAG_BACKWARD);
1883 index = FFMAX(index, 0);
1884 e = &st->index_entries[index];
1886 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1888 ts_min = e->timestamp;
1889 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1890 pos_min, av_ts2str(ts_min));
1892 av_assert1(index == 0);
1895 index = av_index_search_timestamp(st, target_ts,
1896 flags & ~AVSEEK_FLAG_BACKWARD);
1897 av_assert0(index < st->nb_index_entries);
1899 e = &st->index_entries[index];
1900 av_assert1(e->timestamp >= target_ts);
1902 ts_max = e->timestamp;
1903 pos_limit = pos_max - e->min_distance;
1904 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1905 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1909 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1910 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1915 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1918 ff_read_frame_flush(s);
1919 ff_update_cur_dts(s, st, ts);
1924 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1925 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1927 int64_t step = 1024;
1928 int64_t limit, ts_max;
1929 int64_t filesize = avio_size(s->pb);
1930 int64_t pos_max = filesize - 1;
1933 pos_max = FFMAX(0, (pos_max) - step);
1934 ts_max = ff_read_timestamp(s, stream_index,
1935 &pos_max, limit, read_timestamp);
1937 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1938 if (ts_max == AV_NOPTS_VALUE)
1942 int64_t tmp_pos = pos_max + 1;
1943 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1944 &tmp_pos, INT64_MAX, read_timestamp);
1945 if (tmp_ts == AV_NOPTS_VALUE)
1947 av_assert0(tmp_pos > pos_max);
1950 if (tmp_pos >= filesize)
1962 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1963 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1964 int64_t ts_min, int64_t ts_max,
1965 int flags, int64_t *ts_ret,
1966 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1967 int64_t *, int64_t))
1974 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1976 if (ts_min == AV_NOPTS_VALUE) {
1977 pos_min = s->internal->data_offset;
1978 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1979 if (ts_min == AV_NOPTS_VALUE)
1983 if (ts_min >= target_ts) {
1988 if (ts_max == AV_NOPTS_VALUE) {
1989 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1991 pos_limit = pos_max;
1994 if (ts_max <= target_ts) {
1999 av_assert0(ts_min < ts_max);
2002 while (pos_min < pos_limit) {
2003 av_log(s, AV_LOG_TRACE,
2004 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2005 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2006 av_assert0(pos_limit <= pos_max);
2008 if (no_change == 0) {
2009 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2010 // interpolate position (better than dichotomy)
2011 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2013 pos_min - approximate_keyframe_distance;
2014 } else if (no_change == 1) {
2015 // bisection if interpolation did not change min / max pos last time
2016 pos = (pos_min + pos_limit) >> 1;
2018 /* linear search if bisection failed, can only happen if there
2019 * are very few or no keyframes between min/max */
2024 else if (pos > pos_limit)
2028 // May pass pos_limit instead of -1.
2029 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2034 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2035 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2036 pos_min, pos, pos_max,
2037 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2038 pos_limit, start_pos, no_change);
2039 if (ts == AV_NOPTS_VALUE) {
2040 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2043 if (target_ts <= ts) {
2044 pos_limit = start_pos - 1;
2048 if (target_ts >= ts) {
2054 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2055 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2058 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2060 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2061 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2062 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2068 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2069 int64_t pos, int flags)
2071 int64_t pos_min, pos_max;
2073 pos_min = s->internal->data_offset;
2074 pos_max = avio_size(s->pb) - 1;
2078 else if (pos > pos_max)
2081 avio_seek(s->pb, pos, SEEK_SET);
2083 s->io_repositioned = 1;
2088 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2089 int64_t timestamp, int flags)
2096 st = s->streams[stream_index];
2098 index = av_index_search_timestamp(st, timestamp, flags);
2100 if (index < 0 && st->nb_index_entries &&
2101 timestamp < st->index_entries[0].timestamp)
2104 if (index < 0 || index == st->nb_index_entries - 1) {
2108 if (st->nb_index_entries) {
2109 av_assert0(st->index_entries);
2110 ie = &st->index_entries[st->nb_index_entries - 1];
2111 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2113 ff_update_cur_dts(s, st, ie->timestamp);
2115 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2121 read_status = av_read_frame(s, &pkt);
2122 } while (read_status == AVERROR(EAGAIN));
2123 if (read_status < 0)
2125 av_free_packet(&pkt);
2126 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2127 if (pkt.flags & AV_PKT_FLAG_KEY)
2129 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2130 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);
2135 index = av_index_search_timestamp(st, timestamp, flags);
2140 ff_read_frame_flush(s);
2141 if (s->iformat->read_seek)
2142 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2144 ie = &st->index_entries[index];
2145 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2147 ff_update_cur_dts(s, st, ie->timestamp);
2152 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2153 int64_t timestamp, int flags)
2158 if (flags & AVSEEK_FLAG_BYTE) {
2159 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2161 ff_read_frame_flush(s);
2162 return seek_frame_byte(s, stream_index, timestamp, flags);
2165 if (stream_index < 0) {
2166 stream_index = av_find_default_stream_index(s);
2167 if (stream_index < 0)
2170 st = s->streams[stream_index];
2171 /* timestamp for default must be expressed in AV_TIME_BASE units */
2172 timestamp = av_rescale(timestamp, st->time_base.den,
2173 AV_TIME_BASE * (int64_t) st->time_base.num);
2176 /* first, we try the format specific seek */
2177 if (s->iformat->read_seek) {
2178 ff_read_frame_flush(s);
2179 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2185 if (s->iformat->read_timestamp &&
2186 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2187 ff_read_frame_flush(s);
2188 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2189 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2190 ff_read_frame_flush(s);
2191 return seek_frame_generic(s, stream_index, timestamp, flags);
2196 int av_seek_frame(AVFormatContext *s, int stream_index,
2197 int64_t timestamp, int flags)
2201 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2202 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2203 if ((flags & AVSEEK_FLAG_BACKWARD))
2207 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2208 flags & ~AVSEEK_FLAG_BACKWARD);
2211 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2214 ret = avformat_queue_attached_pictures(s);
2219 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2220 int64_t ts, int64_t max_ts, int flags)
2222 if (min_ts > ts || max_ts < ts)
2224 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2225 return AVERROR(EINVAL);
2228 flags |= AVSEEK_FLAG_ANY;
2229 flags &= ~AVSEEK_FLAG_BACKWARD;
2231 if (s->iformat->read_seek2) {
2233 ff_read_frame_flush(s);
2235 if (stream_index == -1 && s->nb_streams == 1) {
2236 AVRational time_base = s->streams[0]->time_base;
2237 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2238 min_ts = av_rescale_rnd(min_ts, time_base.den,
2239 time_base.num * (int64_t)AV_TIME_BASE,
2240 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2241 max_ts = av_rescale_rnd(max_ts, time_base.den,
2242 time_base.num * (int64_t)AV_TIME_BASE,
2243 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2246 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2250 ret = avformat_queue_attached_pictures(s);
2254 if (s->iformat->read_timestamp) {
2255 // try to seek via read_timestamp()
2258 // Fall back on old API if new is not implemented but old is.
2259 // Note the old API has somewhat different semantics.
2260 if (s->iformat->read_seek || 1) {
2261 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2262 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2263 if (ret<0 && ts != min_ts && max_ts != ts) {
2264 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2266 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2271 // try some generic seek like seek_frame_generic() but with new ts semantics
2272 return -1; //unreachable
2275 int avformat_flush(AVFormatContext *s)
2277 ff_read_frame_flush(s);
2281 /*******************************************************/
2284 * Return TRUE if the stream has accurate duration in any stream.
2286 * @return TRUE if the stream has accurate duration for at least one component.
2288 static int has_duration(AVFormatContext *ic)
2293 for (i = 0; i < ic->nb_streams; i++) {
2294 st = ic->streams[i];
2295 if (st->duration != AV_NOPTS_VALUE)
2298 if (ic->duration != AV_NOPTS_VALUE)
2304 * Estimate the stream timings from the one of each components.
2306 * Also computes the global bitrate if possible.
2308 static void update_stream_timings(AVFormatContext *ic)
2310 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2311 int64_t duration, duration1, filesize;
2316 start_time = INT64_MAX;
2317 start_time_text = INT64_MAX;
2318 end_time = INT64_MIN;
2319 duration = INT64_MIN;
2320 for (i = 0; i < ic->nb_streams; i++) {
2321 st = ic->streams[i];
2322 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2323 start_time1 = av_rescale_q(st->start_time, st->time_base,
2325 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2326 if (start_time1 < start_time_text)
2327 start_time_text = start_time1;
2329 start_time = FFMIN(start_time, start_time1);
2330 end_time1 = AV_NOPTS_VALUE;
2331 if (st->duration != AV_NOPTS_VALUE) {
2332 end_time1 = start_time1 +
2333 av_rescale_q(st->duration, st->time_base,
2335 end_time = FFMAX(end_time, end_time1);
2337 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2338 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2339 p->start_time = start_time1;
2340 if (p->end_time < end_time1)
2341 p->end_time = end_time1;
2344 if (st->duration != AV_NOPTS_VALUE) {
2345 duration1 = av_rescale_q(st->duration, st->time_base,
2347 duration = FFMAX(duration, duration1);
2350 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2351 start_time = start_time_text;
2352 else if (start_time > start_time_text)
2353 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2355 if (start_time != INT64_MAX) {
2356 ic->start_time = start_time;
2357 if (end_time != INT64_MIN) {
2358 if (ic->nb_programs) {
2359 for (i = 0; i < ic->nb_programs; i++) {
2360 p = ic->programs[i];
2361 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2362 duration = FFMAX(duration, p->end_time - p->start_time);
2365 duration = FFMAX(duration, end_time - start_time);
2368 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2369 ic->duration = duration;
2371 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2372 /* compute the bitrate */
2373 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2374 (double) ic->duration;
2375 if (bitrate >= 0 && bitrate <= INT_MAX)
2376 ic->bit_rate = bitrate;
2380 static void fill_all_stream_timings(AVFormatContext *ic)
2385 update_stream_timings(ic);
2386 for (i = 0; i < ic->nb_streams; i++) {
2387 st = ic->streams[i];
2388 if (st->start_time == AV_NOPTS_VALUE) {
2389 if (ic->start_time != AV_NOPTS_VALUE)
2390 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2392 if (ic->duration != AV_NOPTS_VALUE)
2393 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2399 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2401 int64_t filesize, duration;
2402 int i, show_warning = 0;
2405 /* if bit_rate is already set, we believe it */
2406 if (ic->bit_rate <= 0) {
2408 for (i = 0; i < ic->nb_streams; i++) {
2409 st = ic->streams[i];
2410 if (st->codec->bit_rate > 0) {
2411 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2415 bit_rate += st->codec->bit_rate;
2416 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2417 // If we have a videostream with packets but without a bitrate
2418 // then consider the sum not known
2423 ic->bit_rate = bit_rate;
2426 /* if duration is already set, we believe it */
2427 if (ic->duration == AV_NOPTS_VALUE &&
2428 ic->bit_rate != 0) {
2429 filesize = ic->pb ? avio_size(ic->pb) : 0;
2430 if (filesize > ic->internal->data_offset) {
2431 filesize -= ic->internal->data_offset;
2432 for (i = 0; i < ic->nb_streams; i++) {
2433 st = ic->streams[i];
2434 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2435 && st->duration == AV_NOPTS_VALUE) {
2436 duration = av_rescale(8 * filesize, st->time_base.den,
2438 (int64_t) st->time_base.num);
2439 st->duration = duration;
2446 av_log(ic, AV_LOG_WARNING,
2447 "Estimating duration from bitrate, this may be inaccurate\n");
2450 #define DURATION_MAX_READ_SIZE 250000LL
2451 #define DURATION_MAX_RETRY 4
2453 /* only usable for MPEG-PS streams */
2454 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2456 AVPacket pkt1, *pkt = &pkt1;
2458 int num, den, read_size, i, ret;
2459 int found_duration = 0;
2461 int64_t filesize, offset, duration;
2464 /* flush packet queue */
2465 flush_packet_queue(ic);
2467 for (i = 0; i < ic->nb_streams; i++) {
2468 st = ic->streams[i];
2469 if (st->start_time == AV_NOPTS_VALUE &&
2470 st->first_dts == AV_NOPTS_VALUE &&
2471 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2472 av_log(st->codec, AV_LOG_WARNING,
2473 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2476 av_parser_close(st->parser);
2481 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2482 /* estimate the end time (duration) */
2483 /* XXX: may need to support wrapping */
2484 filesize = ic->pb ? avio_size(ic->pb) : 0;
2486 is_end = found_duration;
2487 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2491 avio_seek(ic->pb, offset, SEEK_SET);
2494 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2498 ret = ff_read_packet(ic, pkt);
2499 } while (ret == AVERROR(EAGAIN));
2502 read_size += pkt->size;
2503 st = ic->streams[pkt->stream_index];
2504 if (pkt->pts != AV_NOPTS_VALUE &&
2505 (st->start_time != AV_NOPTS_VALUE ||
2506 st->first_dts != AV_NOPTS_VALUE)) {
2507 if (pkt->duration == 0) {
2508 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2510 pkt->duration = av_rescale_rnd(1,
2511 num * (int64_t) st->time_base.den,
2512 den * (int64_t) st->time_base.num,
2516 duration = pkt->pts + pkt->duration;
2518 if (st->start_time != AV_NOPTS_VALUE)
2519 duration -= st->start_time;
2521 duration -= st->first_dts;
2523 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2524 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2525 st->duration = duration;
2526 st->info->last_duration = duration;
2529 av_free_packet(pkt);
2532 /* check if all audio/video streams have valid duration */
2535 for (i = 0; i < ic->nb_streams; i++) {
2536 st = ic->streams[i];
2537 switch (st->codec->codec_type) {
2538 case AVMEDIA_TYPE_VIDEO:
2539 case AVMEDIA_TYPE_AUDIO:
2540 if (st->duration == AV_NOPTS_VALUE)
2547 ++retry <= DURATION_MAX_RETRY);
2549 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2551 /* warn about audio/video streams which duration could not be estimated */
2552 for (i = 0; i < ic->nb_streams; i++) {
2553 st = ic->streams[i];
2554 if (st->duration == AV_NOPTS_VALUE) {
2555 switch (st->codec->codec_type) {
2556 case AVMEDIA_TYPE_VIDEO:
2557 case AVMEDIA_TYPE_AUDIO:
2558 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2559 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2561 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2565 fill_all_stream_timings(ic);
2567 avio_seek(ic->pb, old_offset, SEEK_SET);
2568 for (i = 0; i < ic->nb_streams; i++) {
2571 st = ic->streams[i];
2572 st->cur_dts = st->first_dts;
2573 st->last_IP_pts = AV_NOPTS_VALUE;
2574 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2575 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2576 st->pts_buffer[j] = AV_NOPTS_VALUE;
2580 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2584 /* get the file size, if possible */
2585 if (ic->iformat->flags & AVFMT_NOFILE) {
2588 file_size = avio_size(ic->pb);
2589 file_size = FFMAX(0, file_size);
2592 if ((!strcmp(ic->iformat->name, "mpeg") ||
2593 !strcmp(ic->iformat->name, "mpegts")) &&
2594 file_size && ic->pb->seekable) {
2595 /* get accurate estimate from the PTSes */
2596 estimate_timings_from_pts(ic, old_offset);
2597 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2598 } else if (has_duration(ic)) {
2599 /* at least one component has timings - we use them for all
2601 fill_all_stream_timings(ic);
2602 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2604 /* less precise: use bitrate info */
2605 estimate_timings_from_bit_rate(ic);
2606 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2608 update_stream_timings(ic);
2612 AVStream av_unused *st;
2613 for (i = 0; i < ic->nb_streams; i++) {
2614 st = ic->streams[i];
2615 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2616 (double) st->start_time / AV_TIME_BASE,
2617 (double) st->duration / AV_TIME_BASE);
2619 av_log(ic, AV_LOG_TRACE,
2620 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2621 (double) ic->start_time / AV_TIME_BASE,
2622 (double) ic->duration / AV_TIME_BASE,
2623 ic->bit_rate / 1000);
2627 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2629 AVCodecContext *avctx = st->codec;
2631 #define FAIL(errmsg) do { \
2633 *errmsg_ptr = errmsg; \
2637 if ( avctx->codec_id == AV_CODEC_ID_NONE
2638 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2639 FAIL("unknown codec");
2640 switch (avctx->codec_type) {
2641 case AVMEDIA_TYPE_AUDIO:
2642 if (!avctx->frame_size && determinable_frame_size(avctx))
2643 FAIL("unspecified frame size");
2644 if (st->info->found_decoder >= 0 &&
2645 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2646 FAIL("unspecified sample format");
2647 if (!avctx->sample_rate)
2648 FAIL("unspecified sample rate");
2649 if (!avctx->channels)
2650 FAIL("unspecified number of channels");
2651 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2652 FAIL("no decodable DTS frames");
2654 case AVMEDIA_TYPE_VIDEO:
2656 FAIL("unspecified size");
2657 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2658 FAIL("unspecified pixel format");
2659 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2660 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2661 FAIL("no frame in rv30/40 and no sar");
2663 case AVMEDIA_TYPE_SUBTITLE:
2664 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2665 FAIL("unspecified size");
2667 case AVMEDIA_TYPE_DATA:
2668 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2674 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2675 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2676 AVDictionary **options)
2678 const AVCodec *codec;
2679 int got_picture = 1, ret = 0;
2680 AVFrame *frame = av_frame_alloc();
2681 AVSubtitle subtitle;
2682 AVPacket pkt = *avpkt;
2685 return AVERROR(ENOMEM);
2687 if (!avcodec_is_open(st->codec) &&
2688 st->info->found_decoder <= 0 &&
2689 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2690 AVDictionary *thread_opt = NULL;
2692 codec = find_decoder(s, st, st->codec->codec_id);
2695 st->info->found_decoder = -st->codec->codec_id;
2700 /* Force thread count to 1 since the H.264 decoder will not extract
2701 * SPS and PPS to extradata during multi-threaded decoding. */
2702 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2703 if (s->codec_whitelist)
2704 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2705 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2707 av_dict_free(&thread_opt);
2709 st->info->found_decoder = -st->codec->codec_id;
2712 st->info->found_decoder = 1;
2713 } else if (!st->info->found_decoder)
2714 st->info->found_decoder = 1;
2716 if (st->info->found_decoder < 0) {
2721 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2723 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2724 (!st->codec_info_nb_frames &&
2725 (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2727 switch (st->codec->codec_type) {
2728 case AVMEDIA_TYPE_VIDEO:
2729 ret = avcodec_decode_video2(st->codec, frame,
2730 &got_picture, &pkt);
2732 case AVMEDIA_TYPE_AUDIO:
2733 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2735 case AVMEDIA_TYPE_SUBTITLE:
2736 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2737 &got_picture, &pkt);
2745 st->nb_decoded_frames++;
2752 if (!pkt.data && !got_picture)
2756 av_frame_free(&frame);
2760 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2762 while (tags->id != AV_CODEC_ID_NONE) {
2770 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2773 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2774 if (tag == tags[i].tag)
2776 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2777 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2779 return AV_CODEC_ID_NONE;
2782 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2787 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2789 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2791 return AV_CODEC_ID_NONE;
2796 if (sflags & (1 << (bps - 1))) {
2799 return AV_CODEC_ID_PCM_S8;
2801 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2803 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2805 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2807 return AV_CODEC_ID_NONE;
2812 return AV_CODEC_ID_PCM_U8;
2814 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2816 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2818 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2820 return AV_CODEC_ID_NONE;
2826 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2829 if (!av_codec_get_tag2(tags, id, &tag))
2834 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2838 for (i = 0; tags && tags[i]; i++) {
2839 const AVCodecTag *codec_tags = tags[i];
2840 while (codec_tags->id != AV_CODEC_ID_NONE) {
2841 if (codec_tags->id == id) {
2842 *tag = codec_tags->tag;
2851 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2854 for (i = 0; tags && tags[i]; i++) {
2855 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2856 if (id != AV_CODEC_ID_NONE)
2859 return AV_CODEC_ID_NONE;
2862 static void compute_chapters_end(AVFormatContext *s)
2865 int64_t max_time = s->duration +
2866 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2868 for (i = 0; i < s->nb_chapters; i++)
2869 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2870 AVChapter *ch = s->chapters[i];
2871 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2875 for (j = 0; j < s->nb_chapters; j++) {
2876 AVChapter *ch1 = s->chapters[j];
2877 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2879 if (j != i && next_start > ch->start && next_start < end)
2882 ch->end = (end == INT64_MAX) ? ch->start : end;
2886 static int get_std_framerate(int i)
2889 return (i + 1) * 1001;
2893 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2897 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2900 /* Is the time base unreliable?
2901 * This is a heuristic to balance between quick acceptance of the values in
2902 * the headers vs. some extra checks.
2903 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2904 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2905 * And there are "variable" fps files this needs to detect as well. */
2906 static int tb_unreliable(AVCodecContext *c)
2908 if (c->time_base.den >= 101LL * c->time_base.num ||
2909 c->time_base.den < 5LL * c->time_base.num ||
2910 // c->codec_tag == AV_RL32("DIVX") ||
2911 // c->codec_tag == AV_RL32("XVID") ||
2912 c->codec_tag == AV_RL32("mp4v") ||
2913 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2914 c->codec_id == AV_CODEC_ID_GIF ||
2915 c->codec_id == AV_CODEC_ID_HEVC ||
2916 c->codec_id == AV_CODEC_ID_H264)
2921 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2925 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
2926 avctx->extradata = NULL;
2927 avctx->extradata_size = 0;
2928 return AVERROR(EINVAL);
2930 avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
2931 if (avctx->extradata) {
2932 memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2933 avctx->extradata_size = size;
2936 avctx->extradata_size = 0;
2937 ret = AVERROR(ENOMEM);
2942 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2944 int ret = ff_alloc_extradata(avctx, size);
2947 ret = avio_read(pb, avctx->extradata, size);
2949 av_freep(&avctx->extradata);
2950 avctx->extradata_size = 0;
2951 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2952 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2958 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2961 int64_t last = st->info->last_dts;
2963 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2964 && ts - (uint64_t)last < INT64_MAX) {
2965 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2966 int64_t duration = ts - last;
2968 if (!st->info->duration_error)
2969 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2970 if (!st->info->duration_error)
2971 return AVERROR(ENOMEM);
2973 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2974 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2975 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2976 if (st->info->duration_error[0][1][i] < 1e10) {
2977 int framerate = get_std_framerate(i);
2978 double sdts = dts*framerate/(1001*12);
2979 for (j= 0; j<2; j++) {
2980 int64_t ticks = llrint(sdts+j*0.5);
2981 double error= sdts - ticks + j*0.5;
2982 st->info->duration_error[j][0][i] += error;
2983 st->info->duration_error[j][1][i] += error*error;
2987 st->info->duration_count++;
2988 st->info->rfps_duration_sum += duration;
2990 if (st->info->duration_count % 10 == 0) {
2991 int n = st->info->duration_count;
2992 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2993 if (st->info->duration_error[0][1][i] < 1e10) {
2994 double a0 = st->info->duration_error[0][0][i] / n;
2995 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2996 double a1 = st->info->duration_error[1][0][i] / n;
2997 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2998 if (error0 > 0.04 && error1 > 0.04) {
2999 st->info->duration_error[0][1][i] = 2e10;
3000 st->info->duration_error[1][1][i] = 2e10;
3006 // ignore the first 4 values, they might have some random jitter
3007 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3008 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3010 if (ts != AV_NOPTS_VALUE)
3011 st->info->last_dts = ts;
3016 void ff_rfps_calculate(AVFormatContext *ic)
3020 for (i = 0; i < ic->nb_streams; i++) {
3021 AVStream *st = ic->streams[i];
3023 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3025 // the check for tb_unreliable() is not completely correct, since this is not about handling
3026 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3027 // ipmovie.c produces.
3028 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)
3029 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);
3030 if (st->info->duration_count>1 && !st->r_frame_rate.num
3031 && tb_unreliable(st->codec)) {
3033 double best_error= 0.01;
3034 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3036 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3039 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3041 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3044 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3047 for (k= 0; k<2; k++) {
3048 int n = st->info->duration_count;
3049 double a= st->info->duration_error[k][0][j] / n;
3050 double error= st->info->duration_error[k][1][j]/n - a*a;
3052 if (error < best_error && best_error> 0.000000001) {
3054 num = get_std_framerate(j);
3057 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3060 // do not increase frame rate by more than 1 % in order to match a standard rate.
3061 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3062 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3064 if ( !st->avg_frame_rate.num
3065 && st->r_frame_rate.num && st->info->rfps_duration_sum
3066 && st->info->codec_info_duration <= 0
3067 && st->info->duration_count > 2
3068 && 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
3070 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3071 st->avg_frame_rate = st->r_frame_rate;
3074 av_freep(&st->info->duration_error);
3075 st->info->last_dts = AV_NOPTS_VALUE;
3076 st->info->duration_count = 0;
3077 st->info->rfps_duration_sum = 0;
3081 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3083 int i, count, ret = 0, j;
3086 AVPacket pkt1, *pkt;
3087 int64_t old_offset = avio_tell(ic->pb);
3088 // new streams might appear, no options for those
3089 int orig_nb_streams = ic->nb_streams;
3091 int64_t max_analyze_duration = ic->max_analyze_duration2;
3092 int64_t max_stream_analyze_duration;
3093 int64_t max_subtitle_analyze_duration;
3094 int64_t probesize = ic->probesize2;
3096 if (!max_analyze_duration)
3097 max_analyze_duration = ic->max_analyze_duration;
3099 probesize = ic->probesize;
3100 flush_codecs = probesize > 0;
3102 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3104 max_stream_analyze_duration = max_analyze_duration;
3105 max_subtitle_analyze_duration = max_analyze_duration;
3106 if (!max_analyze_duration) {
3107 max_stream_analyze_duration =
3108 max_analyze_duration = 5*AV_TIME_BASE;
3109 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3110 if (!strcmp(ic->iformat->name, "flv"))
3111 max_stream_analyze_duration = 30*AV_TIME_BASE;
3115 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3116 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3118 for (i = 0; i < ic->nb_streams; i++) {
3119 const AVCodec *codec;
3120 AVDictionary *thread_opt = NULL;
3121 st = ic->streams[i];
3123 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3124 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3125 /* if (!st->time_base.num)
3127 if (!st->codec->time_base.num)
3128 st->codec->time_base = st->time_base;
3130 // only for the split stuff
3131 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3132 st->parser = av_parser_init(st->codec->codec_id);
3134 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3135 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3136 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3137 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3139 } else if (st->need_parsing) {
3140 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3141 "%s, packets or times may be invalid.\n",
3142 avcodec_get_name(st->codec->codec_id));
3145 codec = find_decoder(ic, st, st->codec->codec_id);
3147 /* Force thread count to 1 since the H.264 decoder will not extract
3148 * SPS and PPS to extradata during multi-threaded decoding. */
3149 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3151 if (ic->codec_whitelist)
3152 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3154 /* Ensure that subtitle_header is properly set. */
3155 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3156 && codec && !st->codec->codec) {
3157 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3158 av_log(ic, AV_LOG_WARNING,
3159 "Failed to open codec in av_find_stream_info\n");
3162 // Try to just open decoders, in case this is enough to get parameters.
3163 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3164 if (codec && !st->codec->codec)
3165 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3166 av_log(ic, AV_LOG_WARNING,
3167 "Failed to open codec in av_find_stream_info\n");
3170 av_dict_free(&thread_opt);
3173 for (i = 0; i < ic->nb_streams; i++) {
3174 #if FF_API_R_FRAME_RATE
3175 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3177 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3178 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3184 int analyzed_all_streams;
3185 if (ff_check_interrupt(&ic->interrupt_callback)) {
3187 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3191 /* check if one codec still needs to be handled */
3192 for (i = 0; i < ic->nb_streams; i++) {
3193 int fps_analyze_framecount = 20;
3195 st = ic->streams[i];
3196 if (!has_codec_parameters(st, NULL))
3198 /* If the timebase is coarse (like the usual millisecond precision
3199 * of mkv), we need to analyze more frames to reliably arrive at
3200 * the correct fps. */
3201 if (av_q2d(st->time_base) > 0.0005)
3202 fps_analyze_framecount *= 2;
3203 if (!tb_unreliable(st->codec))
3204 fps_analyze_framecount = 0;
3205 if (ic->fps_probe_size >= 0)
3206 fps_analyze_framecount = ic->fps_probe_size;
3207 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3208 fps_analyze_framecount = 0;
3209 /* variable fps and no guess at the real fps */
3210 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3211 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3212 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3213 st->info->codec_info_duration_fields/2 :
3214 st->info->duration_count;
3215 if (count < fps_analyze_framecount)
3218 if (st->parser && st->parser->parser->split &&
3219 !st->codec->extradata)
3221 if (st->first_dts == AV_NOPTS_VALUE &&
3222 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3223 st->codec_info_nb_frames < ic->max_ts_probe &&
3224 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3225 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3228 analyzed_all_streams = 0;
3229 if (i == ic->nb_streams) {
3230 analyzed_all_streams = 1;
3231 /* NOTE: If the format has no header, then we need to read some
3232 * packets to get most of the streams, so we cannot stop here. */
3233 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3234 /* If we found the info for all the codecs, we can stop. */
3236 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3241 /* We did not get all the codec info, but we read too much data. */
3242 if (read_size >= probesize) {
3244 av_log(ic, AV_LOG_DEBUG,
3245 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3246 for (i = 0; i < ic->nb_streams; i++)
3247 if (!ic->streams[i]->r_frame_rate.num &&
3248 ic->streams[i]->info->duration_count <= 1 &&
3249 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3250 strcmp(ic->iformat->name, "image2"))
3251 av_log(ic, AV_LOG_WARNING,
3252 "Stream #%d: not enough frames to estimate rate; "
3253 "consider increasing probesize\n", i);
3257 /* NOTE: A new stream can be added there if no header in file
3258 * (AVFMTCTX_NOHEADER). */
3259 ret = read_frame_internal(ic, &pkt1);
3260 if (ret == AVERROR(EAGAIN))
3268 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3269 free_packet_buffer(&ic->internal->packet_buffer,
3270 &ic->internal->packet_buffer_end);
3272 pkt = add_to_pktbuf(&ic->internal->packet_buffer, &pkt1,
3273 &ic->internal->packet_buffer_end);
3275 ret = AVERROR(ENOMEM);
3276 goto find_stream_info_err;
3278 if ((ret = av_dup_packet(pkt)) < 0)
3279 goto find_stream_info_err;
3282 st = ic->streams[pkt->stream_index];
3283 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3284 read_size += pkt->size;
3286 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3287 /* check for non-increasing dts */
3288 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3289 st->info->fps_last_dts >= pkt->dts) {
3290 av_log(ic, AV_LOG_DEBUG,
3291 "Non-increasing DTS in stream %d: packet %d with DTS "
3292 "%"PRId64", packet %d with DTS %"PRId64"\n",
3293 st->index, st->info->fps_last_dts_idx,
3294 st->info->fps_last_dts, st->codec_info_nb_frames,
3296 st->info->fps_first_dts =
3297 st->info->fps_last_dts = AV_NOPTS_VALUE;
3299 /* Check for a discontinuity in dts. If the difference in dts
3300 * is more than 1000 times the average packet duration in the
3301 * sequence, we treat it as a discontinuity. */
3302 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3303 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3304 (pkt->dts - st->info->fps_last_dts) / 1000 >
3305 (st->info->fps_last_dts - st->info->fps_first_dts) /
3306 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3307 av_log(ic, AV_LOG_WARNING,
3308 "DTS discontinuity in stream %d: packet %d with DTS "
3309 "%"PRId64", packet %d with DTS %"PRId64"\n",
3310 st->index, st->info->fps_last_dts_idx,
3311 st->info->fps_last_dts, st->codec_info_nb_frames,
3313 st->info->fps_first_dts =
3314 st->info->fps_last_dts = AV_NOPTS_VALUE;
3317 /* update stored dts values */
3318 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3319 st->info->fps_first_dts = pkt->dts;
3320 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3322 st->info->fps_last_dts = pkt->dts;
3323 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3325 if (st->codec_info_nb_frames>1) {
3329 if (st->time_base.den > 0)
3330 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3331 if (st->avg_frame_rate.num > 0)
3332 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3335 && st->codec_info_nb_frames>30
3336 && st->info->fps_first_dts != AV_NOPTS_VALUE
3337 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3338 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3340 if (analyzed_all_streams) limit = max_analyze_duration;
3341 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3342 else limit = max_stream_analyze_duration;
3345 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3346 max_analyze_duration,
3347 t, pkt->stream_index);
3348 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3349 av_packet_unref(pkt);
3352 if (pkt->duration) {
3353 st->info->codec_info_duration += pkt->duration;
3354 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3357 #if FF_API_R_FRAME_RATE
3358 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3359 ff_rfps_add_frame(ic, st, pkt->dts);
3361 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3362 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3363 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3364 if (ff_alloc_extradata(st->codec, i))
3365 return AVERROR(ENOMEM);
3366 memcpy(st->codec->extradata, pkt->data,
3367 st->codec->extradata_size);
3371 /* If still no information, we try to open the codec and to
3372 * decompress the frame. We try to avoid that in most cases as
3373 * it takes longer and uses more memory. For MPEG-4, we need to
3374 * decompress for QuickTime.
3376 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3377 * least one frame of codec data, this makes sure the codec initializes
3378 * the channel configuration and does not only trust the values from
3380 try_decode_frame(ic, st, pkt,
3381 (options && i < orig_nb_streams) ? &options[i] : NULL);
3383 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3384 av_packet_unref(pkt);
3386 st->codec_info_nb_frames++;
3391 AVPacket empty_pkt = { 0 };
3393 av_init_packet(&empty_pkt);
3395 for (i = 0; i < ic->nb_streams; i++) {
3397 st = ic->streams[i];
3399 /* flush the decoders */
3400 if (st->info->found_decoder == 1) {
3402 err = try_decode_frame(ic, st, &empty_pkt,
3403 (options && i < orig_nb_streams)
3404 ? &options[i] : NULL);
3405 } while (err > 0 && !has_codec_parameters(st, NULL));
3408 av_log(ic, AV_LOG_INFO,
3409 "decoding for stream %d failed\n", st->index);
3415 // close codecs which were opened in try_decode_frame()
3416 for (i = 0; i < ic->nb_streams; i++) {
3417 st = ic->streams[i];
3418 avcodec_close(st->codec);
3421 ff_rfps_calculate(ic);
3423 for (i = 0; i < ic->nb_streams; i++) {
3424 st = ic->streams[i];
3425 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3426 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3427 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3428 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3429 st->codec->codec_tag= tag;
3432 /* estimate average framerate if not set by demuxer */
3433 if (st->info->codec_info_duration_fields &&
3434 !st->avg_frame_rate.num &&
3435 st->info->codec_info_duration) {
3437 double best_error = 0.01;
3439 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3440 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3441 st->info->codec_info_duration < 0)
3443 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3444 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3445 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3447 /* Round guessed framerate to a "standard" framerate if it's
3448 * within 1% of the original estimate. */
3449 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3450 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3451 double error = fabs(av_q2d(st->avg_frame_rate) /
3452 av_q2d(std_fps) - 1);
3454 if (error < best_error) {
3456 best_fps = std_fps.num;
3460 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3461 best_fps, 12 * 1001, INT_MAX);
3464 if (!st->r_frame_rate.num) {
3465 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3466 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3467 st->r_frame_rate.num = st->codec->time_base.den;
3468 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3470 st->r_frame_rate.num = st->time_base.den;
3471 st->r_frame_rate.den = st->time_base.num;
3474 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3475 AVRational hw_ratio = { st->codec->height, st->codec->width };
3476 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3479 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3480 if (!st->codec->bits_per_coded_sample)
3481 st->codec->bits_per_coded_sample =
3482 av_get_bits_per_sample(st->codec->codec_id);
3483 // set stream disposition based on audio service type
3484 switch (st->codec->audio_service_type) {
3485 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3486 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3488 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3489 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3491 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3492 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3494 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3495 st->disposition = AV_DISPOSITION_COMMENT;
3497 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3498 st->disposition = AV_DISPOSITION_KARAOKE;
3505 estimate_timings(ic, old_offset);
3507 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3509 if (ret >= 0 && ic->nb_streams)
3510 /* We could not have all the codec parameters before EOF. */
3512 for (i = 0; i < ic->nb_streams; i++) {
3514 st = ic->streams[i];
3515 if (!has_codec_parameters(st, &errmsg)) {
3517 avcodec_string(buf, sizeof(buf), st->codec, 0);
3518 av_log(ic, AV_LOG_WARNING,
3519 "Could not find codec parameters for stream %d (%s): %s\n"
3520 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3527 compute_chapters_end(ic);
3529 find_stream_info_err:
3530 for (i = 0; i < ic->nb_streams; i++) {
3531 st = ic->streams[i];
3532 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3533 ic->streams[i]->codec->thread_count = 0;
3535 av_freep(&st->info->duration_error);
3536 av_freep(&ic->streams[i]->info);
3539 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3540 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3544 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3548 for (i = 0; i < ic->nb_programs; i++) {
3549 if (ic->programs[i] == last) {
3553 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3554 if (ic->programs[i]->stream_index[j] == s)
3555 return ic->programs[i];
3561 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3562 int wanted_stream_nb, int related_stream,
3563 AVCodec **decoder_ret, int flags)
3565 int i, nb_streams = ic->nb_streams;
3566 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3567 unsigned *program = NULL;
3568 const AVCodec *decoder = NULL, *best_decoder = NULL;
3570 if (related_stream >= 0 && wanted_stream_nb < 0) {
3571 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3573 program = p->stream_index;
3574 nb_streams = p->nb_stream_indexes;
3577 for (i = 0; i < nb_streams; i++) {
3578 int real_stream_index = program ? program[i] : i;
3579 AVStream *st = ic->streams[real_stream_index];
3580 AVCodecContext *avctx = st->codec;
3581 if (avctx->codec_type != type)
3583 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3585 if (wanted_stream_nb != real_stream_index &&
3586 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3587 AV_DISPOSITION_VISUAL_IMPAIRED))
3589 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3592 decoder = find_decoder(ic, st, st->codec->codec_id);
3595 ret = AVERROR_DECODER_NOT_FOUND;
3599 count = st->codec_info_nb_frames;
3600 bitrate = avctx->bit_rate;
3602 bitrate = avctx->rc_max_rate;
3603 multiframe = FFMIN(5, count);
3604 if ((best_multiframe > multiframe) ||
3605 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3606 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3609 best_bitrate = bitrate;
3610 best_multiframe = multiframe;
3611 ret = real_stream_index;
3612 best_decoder = decoder;
3613 if (program && i == nb_streams - 1 && ret < 0) {
3615 nb_streams = ic->nb_streams;
3616 /* no related stream found, try again with everything */
3621 *decoder_ret = (AVCodec*)best_decoder;
3625 /*******************************************************/
3627 int av_read_play(AVFormatContext *s)
3629 if (s->iformat->read_play)
3630 return s->iformat->read_play(s);
3632 return avio_pause(s->pb, 0);
3633 return AVERROR(ENOSYS);
3636 int av_read_pause(AVFormatContext *s)
3638 if (s->iformat->read_pause)
3639 return s->iformat->read_pause(s);
3641 return avio_pause(s->pb, 1);
3642 return AVERROR(ENOSYS);
3645 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3647 av_assert0(s->nb_streams>0);
3648 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3650 for (j = 0; j < st->nb_side_data; j++)
3651 av_freep(&st->side_data[j].data);
3652 av_freep(&st->side_data);
3653 st->nb_side_data = 0;
3656 av_parser_close(st->parser);
3658 if (st->attached_pic.data)
3659 av_free_packet(&st->attached_pic);
3660 av_dict_free(&st->metadata);
3661 av_freep(&st->probe_data.buf);
3662 av_freep(&st->index_entries);
3663 av_freep(&st->codec->extradata);
3664 av_freep(&st->codec->subtitle_header);
3665 av_freep(&st->codec);
3666 av_freep(&st->priv_data);
3668 av_freep(&st->info->duration_error);
3669 av_freep(&st->info);
3670 av_freep(&st->recommended_encoder_configuration);
3671 av_freep(&s->streams[ --s->nb_streams ]);
3674 void avformat_free_context(AVFormatContext *s)
3682 if (s->iformat && s->iformat->priv_class && s->priv_data)
3683 av_opt_free(s->priv_data);
3684 if (s->oformat && s->oformat->priv_class && s->priv_data)
3685 av_opt_free(s->priv_data);
3687 for (i = s->nb_streams - 1; i >= 0; i--) {
3688 ff_free_stream(s, s->streams[i]);
3690 for (i = s->nb_programs - 1; i >= 0; i--) {
3691 av_dict_free(&s->programs[i]->metadata);
3692 av_freep(&s->programs[i]->stream_index);
3693 av_freep(&s->programs[i]);
3695 av_freep(&s->programs);
3696 av_freep(&s->priv_data);
3697 while (s->nb_chapters--) {
3698 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3699 av_freep(&s->chapters[s->nb_chapters]);
3701 av_freep(&s->chapters);
3702 av_dict_free(&s->metadata);
3703 av_freep(&s->streams);
3704 av_freep(&s->internal);
3705 flush_packet_queue(s);
3709 void avformat_close_input(AVFormatContext **ps)
3720 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3721 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3724 flush_packet_queue(s);
3727 if (s->iformat->read_close)
3728 s->iformat->read_close(s);
3730 avformat_free_context(s);
3737 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3743 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3745 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3748 s->streams = streams;
3750 st = av_mallocz(sizeof(AVStream));
3753 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3757 st->info->last_dts = AV_NOPTS_VALUE;
3759 st->codec = avcodec_alloc_context3(c);
3766 /* no default bitrate if decoding */
3767 st->codec->bit_rate = 0;
3769 /* default pts setting is MPEG-like */
3770 avpriv_set_pts_info(st, 33, 1, 90000);
3773 st->index = s->nb_streams;
3774 st->start_time = AV_NOPTS_VALUE;
3775 st->duration = AV_NOPTS_VALUE;
3776 /* we set the current DTS to 0 so that formats without any timestamps
3777 * but durations get some timestamps, formats with some unknown
3778 * timestamps have their first few packets buffered and the
3779 * timestamps corrected before they are returned to the user */
3780 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3781 st->first_dts = AV_NOPTS_VALUE;
3782 st->probe_packets = MAX_PROBE_PACKETS;
3783 st->pts_wrap_reference = AV_NOPTS_VALUE;
3784 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3786 st->last_IP_pts = AV_NOPTS_VALUE;
3787 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3788 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3789 st->pts_buffer[i] = AV_NOPTS_VALUE;
3791 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3793 #if FF_API_R_FRAME_RATE
3794 st->info->last_dts = AV_NOPTS_VALUE;
3796 st->info->fps_first_dts = AV_NOPTS_VALUE;
3797 st->info->fps_last_dts = AV_NOPTS_VALUE;
3799 st->inject_global_side_data = s->internal->inject_global_side_data;
3801 s->streams[s->nb_streams++] = st;
3805 AVProgram *av_new_program(AVFormatContext *ac, int id)
3807 AVProgram *program = NULL;
3810 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3812 for (i = 0; i < ac->nb_programs; i++)
3813 if (ac->programs[i]->id == id)
3814 program = ac->programs[i];
3817 program = av_mallocz(sizeof(AVProgram));
3820 dynarray_add(&ac->programs, &ac->nb_programs, program);
3821 program->discard = AVDISCARD_NONE;
3824 program->pts_wrap_reference = AV_NOPTS_VALUE;
3825 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3827 program->start_time =
3828 program->end_time = AV_NOPTS_VALUE;
3833 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3834 int64_t start, int64_t end, const char *title)
3836 AVChapter *chapter = NULL;
3839 if (end != AV_NOPTS_VALUE && start > end) {
3840 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3844 for (i = 0; i < s->nb_chapters; i++)
3845 if (s->chapters[i]->id == id)
3846 chapter = s->chapters[i];
3849 chapter = av_mallocz(sizeof(AVChapter));
3852 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3854 av_dict_set(&chapter->metadata, "title", title, 0);
3856 chapter->time_base = time_base;
3857 chapter->start = start;
3863 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3866 AVProgram *program = NULL;
3869 if (idx >= ac->nb_streams) {
3870 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3874 for (i = 0; i < ac->nb_programs; i++) {
3875 if (ac->programs[i]->id != progid)
3877 program = ac->programs[i];
3878 for (j = 0; j < program->nb_stream_indexes; j++)
3879 if (program->stream_index[j] == idx)
3882 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3885 program->stream_index = tmp;
3886 program->stream_index[program->nb_stream_indexes++] = idx;
3891 uint64_t ff_ntp_time(void)
3893 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3896 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3899 char *q, buf1[20], c;
3900 int nd, len, percentd_found;
3912 while (av_isdigit(*p))
3913 nd = nd * 10 + *p++ - '0';
3915 } while (av_isdigit(c));
3926 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3928 if ((q - buf + len) > buf_size - 1)
3930 memcpy(q, buf1, len);
3938 if ((q - buf) < buf_size - 1)
3942 if (!percentd_found)
3951 void av_url_split(char *proto, int proto_size,
3952 char *authorization, int authorization_size,
3953 char *hostname, int hostname_size,
3954 int *port_ptr, char *path, int path_size, const char *url)
3956 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3962 if (authorization_size > 0)
3963 authorization[0] = 0;
3964 if (hostname_size > 0)
3969 /* parse protocol */
3970 if ((p = strchr(url, ':'))) {
3971 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3978 /* no protocol means plain filename */
3979 av_strlcpy(path, url, path_size);
3983 /* separate path from hostname */
3984 ls = strchr(p, '/');
3985 ls2 = strchr(p, '?');
3989 ls = FFMIN(ls, ls2);
3991 av_strlcpy(path, ls, path_size);
3993 ls = &p[strlen(p)]; // XXX
3995 /* the rest is hostname, use that to parse auth/port */
3997 /* authorization (user[:pass]@hostname) */
3999 while ((at = strchr(p, '@')) && at < ls) {
4000 av_strlcpy(authorization, at2,
4001 FFMIN(authorization_size, at + 1 - at2));
4002 p = at + 1; /* skip '@' */
4005 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4007 av_strlcpy(hostname, p + 1,
4008 FFMIN(hostname_size, brk - p));
4009 if (brk[1] == ':' && port_ptr)
4010 *port_ptr = atoi(brk + 2);
4011 } else if ((col = strchr(p, ':')) && col < ls) {
4012 av_strlcpy(hostname, p,
4013 FFMIN(col + 1 - p, hostname_size));
4015 *port_ptr = atoi(col + 1);
4017 av_strlcpy(hostname, p,
4018 FFMIN(ls + 1 - p, hostname_size));
4022 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4025 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4028 'C', 'D', 'E', 'F' };
4029 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4032 'c', 'd', 'e', 'f' };
4033 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4035 for (i = 0; i < s; i++) {
4036 buff[i * 2] = hex_table[src[i] >> 4];
4037 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4043 int ff_hex_to_data(uint8_t *data, const char *p)
4050 p += strspn(p, SPACE_CHARS);
4053 c = av_toupper((unsigned char) *p++);
4054 if (c >= '0' && c <= '9')
4056 else if (c >= 'A' && c <= 'F')
4071 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4072 unsigned int pts_num, unsigned int pts_den)
4075 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4076 if (new_tb.num != pts_num)
4077 av_log(NULL, AV_LOG_DEBUG,
4078 "st:%d removing common factor %d from timebase\n",
4079 s->index, pts_num / new_tb.num);
4081 av_log(NULL, AV_LOG_WARNING,
4082 "st:%d has too large timebase, reducing\n", s->index);
4084 if (new_tb.num <= 0 || new_tb.den <= 0) {
4085 av_log(NULL, AV_LOG_ERROR,
4086 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4087 new_tb.num, new_tb.den,
4091 s->time_base = new_tb;
4092 av_codec_set_pkt_timebase(s->codec, new_tb);
4093 s->pts_wrap_bits = pts_wrap_bits;
4096 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4099 const char *ptr = str;
4101 /* Parse key=value pairs. */
4104 char *dest = NULL, *dest_end;
4105 int key_len, dest_len = 0;
4107 /* Skip whitespace and potential commas. */
4108 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4115 if (!(ptr = strchr(key, '=')))
4118 key_len = ptr - key;
4120 callback_get_buf(context, key, key_len, &dest, &dest_len);
4121 dest_end = dest + dest_len - 1;
4125 while (*ptr && *ptr != '\"') {
4129 if (dest && dest < dest_end)
4133 if (dest && dest < dest_end)
4141 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4142 if (dest && dest < dest_end)
4150 int ff_find_stream_index(AVFormatContext *s, int id)
4153 for (i = 0; i < s->nb_streams; i++)
4154 if (s->streams[i]->id == id)
4159 int64_t ff_iso8601_to_unix_time(const char *datestr)
4161 struct tm time1 = { 0 }, time2 = { 0 };
4162 const char *ret1, *ret2;
4163 ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4164 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4166 return av_timegm(&time2);
4168 return av_timegm(&time1);
4171 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4175 unsigned int codec_tag;
4176 if (ofmt->query_codec)
4177 return ofmt->query_codec(codec_id, std_compliance);
4178 else if (ofmt->codec_tag)
4179 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4180 else if (codec_id == ofmt->video_codec ||
4181 codec_id == ofmt->audio_codec ||
4182 codec_id == ofmt->subtitle_codec)
4185 return AVERROR_PATCHWELCOME;
4188 int avformat_network_init(void)
4192 ff_network_inited_globally = 1;
4193 if ((ret = ff_network_init()) < 0)
4195 if ((ret = ff_tls_init()) < 0)
4201 int avformat_network_deinit(void)
4206 ff_network_inited_globally = 0;
4211 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4212 uint64_t channel_layout, int32_t sample_rate,
4213 int32_t width, int32_t height)
4219 return AVERROR(EINVAL);
4222 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4224 if (channel_layout) {
4226 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4230 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4232 if (width || height) {
4234 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4236 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4238 return AVERROR(ENOMEM);
4239 bytestream_put_le32(&data, flags);
4241 bytestream_put_le32(&data, channels);
4243 bytestream_put_le64(&data, channel_layout);
4245 bytestream_put_le32(&data, sample_rate);
4246 if (width || height) {
4247 bytestream_put_le32(&data, width);
4248 bytestream_put_le32(&data, height);
4253 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4255 AVRational undef = {0, 1};
4256 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4257 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4258 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4260 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4261 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4262 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4263 stream_sample_aspect_ratio = undef;
4265 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4266 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4267 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4268 frame_sample_aspect_ratio = undef;
4270 if (stream_sample_aspect_ratio.num)
4271 return stream_sample_aspect_ratio;
4273 return frame_sample_aspect_ratio;
4276 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4278 AVRational fr = st->r_frame_rate;
4279 AVRational codec_fr = st->codec->framerate;
4280 AVRational avg_fr = st->avg_frame_rate;
4282 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4283 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4288 if (st->codec->ticks_per_frame > 1) {
4289 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4290 (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))
4297 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4300 if (*spec <= '9' && *spec >= '0') /* opt:index */
4301 return strtol(spec, NULL, 0) == st->index;
4302 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4303 *spec == 't') { /* opt:[vasdt] */
4304 enum AVMediaType type;
4307 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4308 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4309 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4310 case 'd': type = AVMEDIA_TYPE_DATA; break;
4311 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4312 default: av_assert0(0);
4314 if (type != st->codec->codec_type)
4316 if (*spec++ == ':') { /* possibly followed by :index */
4317 int i, index = strtol(spec, NULL, 0);
4318 for (i = 0; i < s->nb_streams; i++)
4319 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4320 return i == st->index;
4324 } else if (*spec == 'p' && *(spec + 1) == ':') {
4328 prog_id = strtol(spec, &endptr, 0);
4329 for (i = 0; i < s->nb_programs; i++) {
4330 if (s->programs[i]->id != prog_id)
4333 if (*endptr++ == ':') {
4334 int stream_idx = strtol(endptr, NULL, 0);
4335 return stream_idx >= 0 &&
4336 stream_idx < s->programs[i]->nb_stream_indexes &&
4337 st->index == s->programs[i]->stream_index[stream_idx];
4340 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4341 if (st->index == s->programs[i]->stream_index[j])
4345 } else if (*spec == '#' ||
4346 (*spec == 'i' && *(spec + 1) == ':')) {
4349 spec += 1 + (*spec == 'i');
4350 stream_id = strtol(spec, &endptr, 0);
4352 return stream_id == st->id;
4353 } else if (*spec == 'm' && *(spec + 1) == ':') {
4354 AVDictionaryEntry *tag;
4359 val = strchr(spec, ':');
4361 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4363 return AVERROR(ENOMEM);
4365 tag = av_dict_get(st->metadata, key, NULL, 0);
4367 if (!val || !strcmp(tag->value, val + 1))
4376 } else if (*spec == 'u') {
4377 AVCodecContext *avctx = st->codec;
4379 switch (avctx->codec_type) {
4380 case AVMEDIA_TYPE_AUDIO:
4381 val = avctx->sample_rate && avctx->channels;
4382 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4385 case AVMEDIA_TYPE_VIDEO:
4386 val = avctx->width && avctx->height;
4387 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4390 case AVMEDIA_TYPE_UNKNOWN:
4397 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4398 } else if (!*spec) /* empty specifier, matches everything */
4401 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4402 return AVERROR(EINVAL);
4405 int ff_generate_avci_extradata(AVStream *st)
4407 static const uint8_t avci100_1080p_extradata[] = {
4409 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4410 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4411 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4412 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4413 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4414 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4415 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4416 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4417 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4419 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4422 static const uint8_t avci100_1080i_extradata[] = {
4424 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4425 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4426 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4427 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4428 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4429 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4430 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4431 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4432 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4433 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4434 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4436 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4439 static const uint8_t avci50_1080p_extradata[] = {
4441 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4442 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4443 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4444 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4445 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4446 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4447 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4448 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4449 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4451 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4454 static const uint8_t avci50_1080i_extradata[] = {
4456 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4457 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4458 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4459 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4460 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4461 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4462 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4463 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4464 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4465 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4466 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4468 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4471 static const uint8_t avci100_720p_extradata[] = {
4473 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4474 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4475 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4476 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4477 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4478 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4479 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4480 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4481 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4482 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4484 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4487 static const uint8_t avci50_720p_extradata[] = {
4489 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4490 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4491 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4492 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4493 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4494 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4495 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4496 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4497 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4499 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4503 const uint8_t *data = NULL;
4506 if (st->codec->width == 1920) {
4507 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4508 data = avci100_1080p_extradata;
4509 size = sizeof(avci100_1080p_extradata);
4511 data = avci100_1080i_extradata;
4512 size = sizeof(avci100_1080i_extradata);
4514 } else if (st->codec->width == 1440) {
4515 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4516 data = avci50_1080p_extradata;
4517 size = sizeof(avci50_1080p_extradata);
4519 data = avci50_1080i_extradata;
4520 size = sizeof(avci50_1080i_extradata);
4522 } else if (st->codec->width == 1280) {
4523 data = avci100_720p_extradata;
4524 size = sizeof(avci100_720p_extradata);
4525 } else if (st->codec->width == 960) {
4526 data = avci50_720p_extradata;
4527 size = sizeof(avci50_720p_extradata);
4533 av_freep(&st->codec->extradata);
4534 if (ff_alloc_extradata(st->codec, size))
4535 return AVERROR(ENOMEM);
4536 memcpy(st->codec->extradata, data, size);
4541 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4546 for (i = 0; i < st->nb_side_data; i++) {
4547 if (st->side_data[i].type == type) {
4549 *size = st->side_data[i].size;
4550 return st->side_data[i].data;
4556 uint8_t *ff_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4559 AVPacketSideData *sd, *tmp;
4561 uint8_t *data = av_malloc(size);
4566 for (i = 0; i < st->nb_side_data; i++) {
4567 sd = &st->side_data[i];
4569 if (sd->type == type) {
4570 av_freep(&sd->data);
4577 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4583 st->side_data = tmp;
4586 sd = &st->side_data[st->nb_side_data - 1];