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/time_internal.h"
37 #include "libavutil/timestamp.h"
39 #include "libavcodec/bytestream.h"
40 #include "libavcodec/internal.h"
41 #include "libavcodec/raw.h"
43 #include "audiointerleave.h"
45 #include "avio_internal.h"
55 #include "libavutil/ffversion.h"
56 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
60 * various utility functions for use within FFmpeg
63 unsigned avformat_version(void)
65 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
66 return LIBAVFORMAT_VERSION_INT;
69 const char *avformat_configuration(void)
71 return FFMPEG_CONFIGURATION;
74 const char *avformat_license(void)
76 #define LICENSE_PREFIX "libavformat license: "
77 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
80 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
82 static int is_relative(int64_t ts) {
83 return ts > (RELATIVE_TS_BASE - (1LL<<48));
87 * Wrap a given time stamp, if there is an indication for an overflow
90 * @param timestamp the time stamp to wrap
91 * @return resulting time stamp
93 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
95 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
96 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
97 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
98 timestamp < st->pts_wrap_reference)
99 return timestamp + (1ULL << st->pts_wrap_bits);
100 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
101 timestamp >= st->pts_wrap_reference)
102 return timestamp - (1ULL << st->pts_wrap_bits);
107 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
108 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
111 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
112 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
113 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
114 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
115 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
116 #if FF_API_OLD_OPEN_CALLBACKS
117 FF_DISABLE_DEPRECATION_WARNINGS
118 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
119 FF_ENABLE_DEPRECATION_WARNINGS
122 int64_t av_stream_get_end_pts(const AVStream *st)
125 return st->priv_pts->val;
127 return AV_NOPTS_VALUE;
130 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
135 void av_format_inject_global_side_data(AVFormatContext *s)
138 s->internal->inject_global_side_data = 1;
139 for (i = 0; i < s->nb_streams; i++) {
140 AVStream *st = s->streams[i];
141 st->inject_global_side_data = 1;
145 int ff_copy_whiteblacklists(AVFormatContext *dst, AVFormatContext *src)
147 av_assert0(!dst->codec_whitelist &&
148 !dst->format_whitelist &&
149 !dst->protocol_whitelist &&
150 !dst->protocol_blacklist);
151 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
152 dst->format_whitelist = av_strdup(src->format_whitelist);
153 dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
154 dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
155 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
156 || (src-> format_whitelist && !dst-> format_whitelist)
157 || (src->protocol_whitelist && !dst->protocol_whitelist)
158 || (src->protocol_blacklist && !dst->protocol_blacklist)) {
159 av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
160 return AVERROR(ENOMEM);
165 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
167 if (st->codec->codec)
168 return st->codec->codec;
170 switch (st->codec->codec_type) {
171 case AVMEDIA_TYPE_VIDEO:
172 if (s->video_codec) return s->video_codec;
174 case AVMEDIA_TYPE_AUDIO:
175 if (s->audio_codec) return s->audio_codec;
177 case AVMEDIA_TYPE_SUBTITLE:
178 if (s->subtitle_codec) return s->subtitle_codec;
182 return avcodec_find_decoder(codec_id);
185 int av_format_get_probe_score(const AVFormatContext *s)
187 return s->probe_score;
190 /* an arbitrarily chosen "sane" max packet size -- 50M */
191 #define SANE_CHUNK_SIZE (50000000)
193 int ffio_limit(AVIOContext *s, int size)
195 if (s->maxsize>= 0) {
196 int64_t remaining= s->maxsize - avio_tell(s);
197 if (remaining < size) {
198 int64_t newsize = avio_size(s);
199 if (!s->maxsize || s->maxsize<newsize)
200 s->maxsize = newsize - !newsize;
201 remaining= s->maxsize - avio_tell(s);
202 remaining= FFMAX(remaining, 0);
205 if (s->maxsize>= 0 && remaining+1 < size) {
206 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
213 /* Read the data in sane-sized chunks and append to pkt.
214 * Return the number of bytes read or an error. */
215 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
217 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
218 int orig_size = pkt->size;
222 int prev_size = pkt->size;
225 /* When the caller requests a lot of data, limit it to the amount
226 * left in file or SANE_CHUNK_SIZE when it is not known. */
228 if (read_size > SANE_CHUNK_SIZE/10) {
229 read_size = ffio_limit(s, read_size);
230 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
232 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
235 ret = av_grow_packet(pkt, read_size);
239 ret = avio_read(s, pkt->data + prev_size, read_size);
240 if (ret != read_size) {
241 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
248 pkt->flags |= AV_PKT_FLAG_CORRUPT;
252 av_packet_unref(pkt);
253 return pkt->size > orig_size ? pkt->size - orig_size : ret;
256 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
261 pkt->pos = avio_tell(s);
263 return append_packet_chunked(s, pkt, size);
266 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
269 return av_get_packet(s, pkt, size);
270 return append_packet_chunked(s, pkt, size);
273 int av_filename_number_test(const char *filename)
277 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
280 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
283 static const struct {
286 enum AVMediaType type;
288 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
289 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
290 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
291 { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
292 { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
293 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
294 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
295 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
296 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
297 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
298 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
299 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
300 { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO },
304 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
306 if (fmt && st->request_probe <= score) {
308 av_log(s, AV_LOG_DEBUG,
309 "Probe with size=%d, packets=%d detected %s with score=%d\n",
310 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
312 for (i = 0; fmt_id_type[i].name; i++) {
313 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
314 st->codec->codec_id = fmt_id_type[i].id;
315 st->codec->codec_type = fmt_id_type[i].type;
323 /************************************************************/
324 /* input media file */
326 int av_demuxer_open(AVFormatContext *ic) {
329 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
330 av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
331 return AVERROR(EINVAL);
334 if (ic->iformat->read_header) {
335 err = ic->iformat->read_header(ic);
340 if (ic->pb && !ic->internal->data_offset)
341 ic->internal->data_offset = avio_tell(ic->pb);
346 /* Open input file and probe the format if necessary. */
347 static int init_input(AVFormatContext *s, const char *filename,
348 AVDictionary **options)
351 AVProbeData pd = { filename, NULL, 0 };
352 int score = AVPROBE_SCORE_RETRY;
355 s->flags |= AVFMT_FLAG_CUSTOM_IO;
357 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
358 s, 0, s->format_probesize);
359 else if (s->iformat->flags & AVFMT_NOFILE)
360 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
361 "will be ignored with AVFMT_NOFILE format.\n");
365 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
366 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
369 if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
374 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
375 s, 0, s->format_probesize);
378 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
379 AVPacketList **plast_pktl, int ref)
381 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
385 return AVERROR(ENOMEM);
388 if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
397 (*plast_pktl)->next = pktl;
399 *packet_buffer = pktl;
401 /* Add the packet in the buffered packet list. */
406 int avformat_queue_attached_pictures(AVFormatContext *s)
409 for (i = 0; i < s->nb_streams; i++)
410 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
411 s->streams[i]->discard < AVDISCARD_ALL) {
412 if (s->streams[i]->attached_pic.size <= 0) {
413 av_log(s, AV_LOG_WARNING,
414 "Attached picture on stream %d has invalid size, "
419 ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
420 &s->streams[i]->attached_pic,
421 &s->internal->raw_packet_buffer_end, 1);
428 int avformat_open_input(AVFormatContext **ps, const char *filename,
429 AVInputFormat *fmt, AVDictionary **options)
431 AVFormatContext *s = *ps;
433 AVDictionary *tmp = NULL;
434 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
436 if (!s && !(s = avformat_alloc_context()))
437 return AVERROR(ENOMEM);
439 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
440 return AVERROR(EINVAL);
446 av_dict_copy(&tmp, *options, 0);
448 if (s->pb) // must be before any goto fail
449 s->flags |= AVFMT_FLAG_CUSTOM_IO;
451 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
454 if ((ret = init_input(s, filename, &tmp)) < 0)
456 s->probe_score = ret;
458 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
459 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
460 if (!s->protocol_whitelist) {
461 ret = AVERROR(ENOMEM);
466 if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
467 s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
468 if (!s->protocol_blacklist) {
469 ret = AVERROR(ENOMEM);
474 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
475 av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
476 ret = AVERROR(EINVAL);
480 avio_skip(s->pb, s->skip_initial_bytes);
482 /* Check filename in case an image number is expected. */
483 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
484 if (!av_filename_number_test(filename)) {
485 ret = AVERROR(EINVAL);
490 s->duration = s->start_time = AV_NOPTS_VALUE;
491 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
493 /* Allocate private data. */
494 if (s->iformat->priv_data_size > 0) {
495 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
496 ret = AVERROR(ENOMEM);
499 if (s->iformat->priv_class) {
500 *(const AVClass **) s->priv_data = s->iformat->priv_class;
501 av_opt_set_defaults(s->priv_data);
502 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
507 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
509 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
511 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
512 if ((ret = s->iformat->read_header(s)) < 0)
515 if (id3v2_extra_meta) {
516 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
517 !strcmp(s->iformat->name, "tta")) {
518 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
521 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
523 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
525 if ((ret = avformat_queue_attached_pictures(s)) < 0)
528 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
529 s->internal->data_offset = avio_tell(s->pb);
531 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
534 av_dict_free(options);
541 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
543 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
545 avformat_free_context(s);
550 /*******************************************************/
552 static void force_codec_ids(AVFormatContext *s, AVStream *st)
554 switch (st->codec->codec_type) {
555 case AVMEDIA_TYPE_VIDEO:
556 if (s->video_codec_id)
557 st->codec->codec_id = s->video_codec_id;
559 case AVMEDIA_TYPE_AUDIO:
560 if (s->audio_codec_id)
561 st->codec->codec_id = s->audio_codec_id;
563 case AVMEDIA_TYPE_SUBTITLE:
564 if (s->subtitle_codec_id)
565 st->codec->codec_id = s->subtitle_codec_id;
570 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
572 if (st->request_probe>0) {
573 AVProbeData *pd = &st->probe_data;
575 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
579 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
581 av_log(s, AV_LOG_WARNING,
582 "Failed to reallocate probe buffer for stream %d\n",
587 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
588 pd->buf_size += pkt->size;
589 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
592 st->probe_packets = 0;
594 av_log(s, AV_LOG_WARNING,
595 "nothing to probe for stream %d\n", st->index);
599 end= s->internal->raw_packet_buffer_remaining_size <= 0
600 || st->probe_packets<= 0;
602 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
603 int score = set_codec_from_probe_data(s, st, pd);
604 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
608 st->request_probe = -1;
609 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
610 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
612 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
614 force_codec_ids(s, st);
620 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
622 int64_t ref = pkt->dts;
623 int i, pts_wrap_behavior;
624 int64_t pts_wrap_reference;
625 AVProgram *first_program;
627 if (ref == AV_NOPTS_VALUE)
629 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
631 ref &= (1LL << st->pts_wrap_bits)-1;
633 // reference time stamp should be 60 s before first time stamp
634 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
635 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
636 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
637 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
638 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
640 first_program = av_find_program_from_stream(s, NULL, stream_index);
642 if (!first_program) {
643 int default_stream_index = av_find_default_stream_index(s);
644 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
645 for (i = 0; i < s->nb_streams; i++) {
646 if (av_find_program_from_stream(s, NULL, i))
648 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
649 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
653 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
654 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
658 AVProgram *program = first_program;
660 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
661 pts_wrap_reference = program->pts_wrap_reference;
662 pts_wrap_behavior = program->pts_wrap_behavior;
665 program = av_find_program_from_stream(s, program, stream_index);
668 // update every program with differing pts_wrap_reference
669 program = first_program;
671 if (program->pts_wrap_reference != pts_wrap_reference) {
672 for (i = 0; i<program->nb_stream_indexes; i++) {
673 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
674 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
677 program->pts_wrap_reference = pts_wrap_reference;
678 program->pts_wrap_behavior = pts_wrap_behavior;
680 program = av_find_program_from_stream(s, program, stream_index);
686 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
692 AVPacketList *pktl = s->internal->raw_packet_buffer;
696 st = s->streams[pkt->stream_index];
697 if (s->internal->raw_packet_buffer_remaining_size <= 0)
698 if ((err = probe_codec(s, st, NULL)) < 0)
700 if (st->request_probe <= 0) {
701 s->internal->raw_packet_buffer = pktl->next;
702 s->internal->raw_packet_buffer_remaining_size += pkt->size;
711 ret = s->iformat->read_packet(s, pkt);
713 /* Some demuxers return FFERROR_REDO when they consume
714 data and discard it (ignored streams, junk, extradata).
715 We must re-call the demuxer to get the real packet. */
716 if (ret == FFERROR_REDO)
718 if (!pktl || ret == AVERROR(EAGAIN))
720 for (i = 0; i < s->nb_streams; i++) {
722 if (st->probe_packets)
723 if ((err = probe_codec(s, st, NULL)) < 0)
725 av_assert0(st->request_probe <= 0);
731 AVPacket tmp = { 0 };
732 ret = av_packet_ref(&tmp, pkt);
738 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
739 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
740 av_log(s, AV_LOG_WARNING,
741 "Dropped corrupted packet (stream = %d)\n",
743 av_packet_unref(pkt);
747 if (pkt->stream_index >= (unsigned)s->nb_streams) {
748 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
752 st = s->streams[pkt->stream_index];
754 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
755 // correct first time stamps to negative values
756 if (!is_relative(st->first_dts))
757 st->first_dts = wrap_timestamp(st, st->first_dts);
758 if (!is_relative(st->start_time))
759 st->start_time = wrap_timestamp(st, st->start_time);
760 if (!is_relative(st->cur_dts))
761 st->cur_dts = wrap_timestamp(st, st->cur_dts);
764 pkt->dts = wrap_timestamp(st, pkt->dts);
765 pkt->pts = wrap_timestamp(st, pkt->pts);
767 force_codec_ids(s, st);
769 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
770 if (s->use_wallclock_as_timestamps)
771 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
773 if (!pktl && st->request_probe <= 0)
776 err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
777 &s->internal->raw_packet_buffer_end, 0);
780 s->internal->raw_packet_buffer_remaining_size -= pkt->size;
782 if ((err = probe_codec(s, st, pkt)) < 0)
788 /**********************************************************/
790 static int determinable_frame_size(AVCodecContext *avctx)
792 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
793 avctx->codec_id == AV_CODEC_ID_MP1 ||
794 avctx->codec_id == AV_CODEC_ID_MP2 ||
795 avctx->codec_id == AV_CODEC_ID_MP3/* ||
796 avctx->codec_id == AV_CODEC_ID_CELT*/)
802 * Return the frame duration in seconds. Return 0 if not available.
804 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
805 AVCodecParserContext *pc, AVPacket *pkt)
807 AVRational codec_framerate = s->iformat ? st->codec->framerate :
808 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
813 switch (st->codec->codec_type) {
814 case AVMEDIA_TYPE_VIDEO:
815 if (st->r_frame_rate.num && !pc && s->iformat) {
816 *pnum = st->r_frame_rate.den;
817 *pden = st->r_frame_rate.num;
818 } else if (st->time_base.num * 1000LL > st->time_base.den) {
819 *pnum = st->time_base.num;
820 *pden = st->time_base.den;
821 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
822 av_assert0(st->codec->ticks_per_frame);
823 av_reduce(pnum, pden,
825 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
828 if (pc && pc->repeat_pict) {
829 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
830 av_reduce(pnum, pden,
831 (*pnum) * (1LL + pc->repeat_pict),
835 /* If this codec can be interlaced or progressive then we need
836 * a parser to compute duration of a packet. Thus if we have
837 * no parser in such case leave duration undefined. */
838 if (st->codec->ticks_per_frame > 1 && !pc)
842 case AVMEDIA_TYPE_AUDIO:
843 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
844 if (frame_size <= 0 || st->codec->sample_rate <= 0)
847 *pden = st->codec->sample_rate;
854 static int is_intra_only(AVCodecContext *enc) {
855 const AVCodecDescriptor *desc;
857 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
860 desc = av_codec_get_codec_descriptor(enc);
862 desc = avcodec_descriptor_get(enc->codec_id);
863 av_codec_set_codec_descriptor(enc, desc);
866 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
870 static int has_decode_delay_been_guessed(AVStream *st)
872 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
873 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
875 #if CONFIG_H264_DECODER
876 if (st->codec->has_b_frames &&
877 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
880 if (st->codec->has_b_frames<3)
881 return st->nb_decoded_frames >= 7;
882 else if (st->codec->has_b_frames<4)
883 return st->nb_decoded_frames >= 18;
885 return st->nb_decoded_frames >= 20;
888 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
892 if (pktl == s->internal->packet_buffer_end)
893 return s->internal->parse_queue;
897 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
898 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
899 st->codec->codec_id != AV_CODEC_ID_HEVC;
902 int delay = st->codec->has_b_frames;
905 if (dts == AV_NOPTS_VALUE) {
906 int64_t best_score = INT64_MAX;
907 for (i = 0; i<delay; i++) {
908 if (st->pts_reorder_error_count[i]) {
909 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
910 if (score < best_score) {
917 for (i = 0; i<delay; i++) {
918 if (pts_buffer[i] != AV_NOPTS_VALUE) {
919 int64_t diff = FFABS(pts_buffer[i] - dts)
920 + (uint64_t)st->pts_reorder_error[i];
921 diff = FFMAX(diff, st->pts_reorder_error[i]);
922 st->pts_reorder_error[i] = diff;
923 st->pts_reorder_error_count[i]++;
924 if (st->pts_reorder_error_count[i] > 250) {
925 st->pts_reorder_error[i] >>= 1;
926 st->pts_reorder_error_count[i] >>= 1;
933 if (dts == AV_NOPTS_VALUE)
940 * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
941 * of the packets in a window.
943 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
944 AVPacketList *pkt_buffer)
946 AVStream *st = s->streams[stream_index];
947 int delay = st->codec->has_b_frames;
950 int64_t pts_buffer[MAX_REORDER_DELAY+1];
952 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
953 pts_buffer[i] = AV_NOPTS_VALUE;
955 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
956 if (pkt_buffer->pkt.stream_index != stream_index)
959 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
960 pts_buffer[0] = pkt_buffer->pkt.pts;
961 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
962 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
964 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
969 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
970 int64_t dts, int64_t pts, AVPacket *pkt)
972 AVStream *st = s->streams[stream_index];
973 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
974 AVPacketList *pktl_it;
978 if (st->first_dts != AV_NOPTS_VALUE ||
979 dts == AV_NOPTS_VALUE ||
980 st->cur_dts == AV_NOPTS_VALUE ||
984 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
986 shift = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
988 if (is_relative(pts))
991 for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
992 if (pktl_it->pkt.stream_index != stream_index)
994 if (is_relative(pktl_it->pkt.pts))
995 pktl_it->pkt.pts += shift;
997 if (is_relative(pktl_it->pkt.dts))
998 pktl_it->pkt.dts += shift;
1000 if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1001 st->start_time = pktl_it->pkt.pts;
1002 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->codec->sample_rate)
1003 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codec->sample_rate}, st->time_base);
1007 if (has_decode_delay_been_guessed(st)) {
1008 update_dts_from_pts(s, stream_index, pktl);
1011 if (st->start_time == AV_NOPTS_VALUE) {
1012 st->start_time = pts;
1013 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && st->codec->sample_rate)
1014 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codec->sample_rate}, st->time_base);
1018 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1019 int stream_index, int duration)
1021 AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1022 int64_t cur_dts = RELATIVE_TS_BASE;
1024 if (st->first_dts != AV_NOPTS_VALUE) {
1025 if (st->update_initial_durations_done)
1027 st->update_initial_durations_done = 1;
1028 cur_dts = st->first_dts;
1029 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1030 if (pktl->pkt.stream_index == stream_index) {
1031 if (pktl->pkt.pts != pktl->pkt.dts ||
1032 pktl->pkt.dts != AV_NOPTS_VALUE ||
1035 cur_dts -= duration;
1038 if (pktl && pktl->pkt.dts != st->first_dts) {
1039 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1040 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1044 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1047 pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1048 st->first_dts = cur_dts;
1049 } else if (st->cur_dts != RELATIVE_TS_BASE)
1052 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1053 if (pktl->pkt.stream_index != stream_index)
1055 if (pktl->pkt.pts == pktl->pkt.dts &&
1056 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1057 !pktl->pkt.duration) {
1058 pktl->pkt.dts = cur_dts;
1059 if (!st->codec->has_b_frames)
1060 pktl->pkt.pts = cur_dts;
1061 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1062 pktl->pkt.duration = duration;
1065 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1068 st->cur_dts = cur_dts;
1071 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1072 AVCodecParserContext *pc, AVPacket *pkt,
1073 int64_t next_dts, int64_t next_pts)
1075 int num, den, presentation_delayed, delay, i;
1077 AVRational duration;
1078 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1079 st->codec->codec_id != AV_CODEC_ID_HEVC;
1081 if (s->flags & AVFMT_FLAG_NOFILLIN)
1084 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1085 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1086 if (st->last_dts_for_order_check <= pkt->dts) {
1089 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1090 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1092 st->last_dts_for_order_check);
1093 st->dts_misordered++;
1095 if (st->dts_ordered + st->dts_misordered > 250) {
1096 st->dts_ordered >>= 1;
1097 st->dts_misordered >>= 1;
1101 st->last_dts_for_order_check = pkt->dts;
1102 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1103 pkt->dts = AV_NOPTS_VALUE;
1106 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1107 pkt->dts = AV_NOPTS_VALUE;
1109 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1110 && !st->codec->has_b_frames)
1111 //FIXME Set low_delay = 0 when has_b_frames = 1
1112 st->codec->has_b_frames = 1;
1114 /* do we have a video B-frame ? */
1115 delay = st->codec->has_b_frames;
1116 presentation_delayed = 0;
1118 /* XXX: need has_b_frame, but cannot get it if the codec is
1119 * not initialized */
1121 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1122 presentation_delayed = 1;
1124 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1125 st->pts_wrap_bits < 63 &&
1126 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1127 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1128 pkt->dts -= 1LL << st->pts_wrap_bits;
1130 pkt->pts += 1LL << st->pts_wrap_bits;
1133 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1134 * We take the conservative approach and discard both.
1135 * Note: If this is misbehaving for an H.264 file, then possibly
1136 * presentation_delayed is not set correctly. */
1137 if (delay == 1 && pkt->dts == pkt->pts &&
1138 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1139 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1140 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1141 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1142 pkt->dts = AV_NOPTS_VALUE;
1145 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1146 if (pkt->duration == 0) {
1147 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1149 duration = (AVRational) {num, den};
1150 pkt->duration = av_rescale_rnd(1,
1151 num * (int64_t) st->time_base.den,
1152 den * (int64_t) st->time_base.num,
1157 if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1158 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1160 /* Correct timestamps with byte offset if demuxers only have timestamps
1161 * on packet boundaries */
1162 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1163 /* this will estimate bitrate based on this frame's duration and size */
1164 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1165 if (pkt->pts != AV_NOPTS_VALUE)
1167 if (pkt->dts != AV_NOPTS_VALUE)
1171 /* This may be redundant, but it should not hurt. */
1172 if (pkt->dts != AV_NOPTS_VALUE &&
1173 pkt->pts != AV_NOPTS_VALUE &&
1174 pkt->pts > pkt->dts)
1175 presentation_delayed = 1;
1177 if (s->debug & FF_FDEBUG_TS)
1178 av_log(s, AV_LOG_TRACE,
1179 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1180 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1181 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1183 /* Interpolate PTS and DTS if they are not present. We skip H264
1184 * currently because delay and has_b_frames are not reliably set. */
1185 if ((delay == 0 || (delay == 1 && pc)) &&
1187 if (presentation_delayed) {
1188 /* DTS = decompression timestamp */
1189 /* PTS = presentation timestamp */
1190 if (pkt->dts == AV_NOPTS_VALUE)
1191 pkt->dts = st->last_IP_pts;
1192 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1193 if (pkt->dts == AV_NOPTS_VALUE)
1194 pkt->dts = st->cur_dts;
1196 /* This is tricky: the dts must be incremented by the duration
1197 * of the frame we are displaying, i.e. the last I- or P-frame. */
1198 if (st->last_IP_duration == 0)
1199 st->last_IP_duration = pkt->duration;
1200 if (pkt->dts != AV_NOPTS_VALUE)
1201 st->cur_dts = pkt->dts + st->last_IP_duration;
1202 if (pkt->dts != AV_NOPTS_VALUE &&
1203 pkt->pts == AV_NOPTS_VALUE &&
1204 st->last_IP_duration > 0 &&
1205 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1206 next_dts != next_pts &&
1207 next_pts != AV_NOPTS_VALUE)
1208 pkt->pts = next_dts;
1210 st->last_IP_duration = pkt->duration;
1211 st->last_IP_pts = pkt->pts;
1212 /* Cannot compute PTS if not present (we can compute it only
1213 * by knowing the future. */
1214 } else if (pkt->pts != AV_NOPTS_VALUE ||
1215 pkt->dts != AV_NOPTS_VALUE ||
1218 /* presentation is not delayed : PTS and DTS are the same */
1219 if (pkt->pts == AV_NOPTS_VALUE)
1220 pkt->pts = pkt->dts;
1221 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1223 if (pkt->pts == AV_NOPTS_VALUE)
1224 pkt->pts = st->cur_dts;
1225 pkt->dts = pkt->pts;
1226 if (pkt->pts != AV_NOPTS_VALUE)
1227 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1231 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1232 st->pts_buffer[0] = pkt->pts;
1233 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1234 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1236 if(has_decode_delay_been_guessed(st))
1237 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1239 // We skipped it above so we try here.
1241 // This should happen on the first packet
1242 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1243 if (pkt->dts > st->cur_dts)
1244 st->cur_dts = pkt->dts;
1246 if (s->debug & FF_FDEBUG_TS)
1247 av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1248 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1251 if (is_intra_only(st->codec))
1252 pkt->flags |= AV_PKT_FLAG_KEY;
1253 #if FF_API_CONVERGENCE_DURATION
1254 FF_DISABLE_DEPRECATION_WARNINGS
1256 pkt->convergence_duration = pc->convergence_duration;
1257 FF_ENABLE_DEPRECATION_WARNINGS
1261 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1264 AVPacketList *pktl = *pkt_buf;
1265 *pkt_buf = pktl->next;
1266 av_packet_unref(&pktl->pkt);
1269 *pkt_buf_end = NULL;
1273 * Parse a packet, add all split parts to parse_queue.
1275 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1277 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1279 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1280 AVStream *st = s->streams[stream_index];
1281 uint8_t *data = pkt ? pkt->data : NULL;
1282 int size = pkt ? pkt->size : 0;
1283 int ret = 0, got_output = 0;
1286 av_init_packet(&flush_pkt);
1289 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1290 // preserve 0-size sync packets
1291 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1294 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1296 int64_t next_pts = pkt->pts;
1297 int64_t next_dts = pkt->dts;
1299 av_init_packet(&out_pkt);
1300 len = av_parser_parse2(st->parser, st->codec,
1301 &out_pkt.data, &out_pkt.size, data, size,
1302 pkt->pts, pkt->dts, pkt->pos);
1304 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1306 /* increment read pointer */
1310 got_output = !!out_pkt.size;
1315 if (pkt->side_data) {
1316 out_pkt.side_data = pkt->side_data;
1317 out_pkt.side_data_elems = pkt->side_data_elems;
1318 pkt->side_data = NULL;
1319 pkt->side_data_elems = 0;
1322 /* set the duration */
1323 out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1324 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1325 if (st->codec->sample_rate > 0) {
1327 av_rescale_q_rnd(st->parser->duration,
1328 (AVRational) { 1, st->codec->sample_rate },
1334 out_pkt.stream_index = st->index;
1335 out_pkt.pts = st->parser->pts;
1336 out_pkt.dts = st->parser->dts;
1337 out_pkt.pos = st->parser->pos;
1339 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1340 out_pkt.pos = st->parser->frame_offset;
1342 if (st->parser->key_frame == 1 ||
1343 (st->parser->key_frame == -1 &&
1344 st->parser->pict_type == AV_PICTURE_TYPE_I))
1345 out_pkt.flags |= AV_PKT_FLAG_KEY;
1347 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1348 out_pkt.flags |= AV_PKT_FLAG_KEY;
1350 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1352 ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
1353 &s->internal->parse_queue_end, 1);
1354 av_packet_unref(&out_pkt);
1359 /* end of the stream => close and free the parser */
1360 if (pkt == &flush_pkt) {
1361 av_parser_close(st->parser);
1366 av_packet_unref(pkt);
1370 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1371 AVPacketList **pkt_buffer_end,
1375 av_assert0(*pkt_buffer);
1378 *pkt_buffer = pktl->next;
1380 *pkt_buffer_end = NULL;
1385 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1387 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1390 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1392 int ret = 0, i, got_packet = 0;
1393 AVDictionary *metadata = NULL;
1395 av_init_packet(pkt);
1397 while (!got_packet && !s->internal->parse_queue) {
1401 /* read next packet */
1402 ret = ff_read_packet(s, &cur_pkt);
1404 if (ret == AVERROR(EAGAIN))
1406 /* flush the parsers */
1407 for (i = 0; i < s->nb_streams; i++) {
1409 if (st->parser && st->need_parsing)
1410 parse_packet(s, NULL, st->index);
1412 /* all remaining packets are now in parse_queue =>
1413 * really terminate parsing */
1417 st = s->streams[cur_pkt.stream_index];
1419 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1420 cur_pkt.dts != AV_NOPTS_VALUE &&
1421 cur_pkt.pts < cur_pkt.dts) {
1422 av_log(s, AV_LOG_WARNING,
1423 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1424 cur_pkt.stream_index,
1425 av_ts2str(cur_pkt.pts),
1426 av_ts2str(cur_pkt.dts),
1429 if (s->debug & FF_FDEBUG_TS)
1430 av_log(s, AV_LOG_DEBUG,
1431 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1432 cur_pkt.stream_index,
1433 av_ts2str(cur_pkt.pts),
1434 av_ts2str(cur_pkt.dts),
1435 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1437 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1438 st->parser = av_parser_init(st->codec->codec_id);
1440 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1441 "%s, packets or times may be invalid.\n",
1442 avcodec_get_name(st->codec->codec_id));
1443 /* no parser available: just output the raw packets */
1444 st->need_parsing = AVSTREAM_PARSE_NONE;
1445 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1446 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1447 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1448 st->parser->flags |= PARSER_FLAG_ONCE;
1449 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1450 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1453 if (!st->need_parsing || !st->parser) {
1454 /* no parsing needed: we just output the packet as is */
1456 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1457 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1458 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1459 ff_reduce_index(s, st->index);
1460 av_add_index_entry(st, pkt->pos, pkt->dts,
1461 0, 0, AVINDEX_KEYFRAME);
1464 } else if (st->discard < AVDISCARD_ALL) {
1465 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1469 av_packet_unref(&cur_pkt);
1471 if (pkt->flags & AV_PKT_FLAG_KEY)
1472 st->skip_to_keyframe = 0;
1473 if (st->skip_to_keyframe) {
1474 av_packet_unref(&cur_pkt);
1482 if (!got_packet && s->internal->parse_queue)
1483 ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1486 AVStream *st = s->streams[pkt->stream_index];
1487 int discard_padding = 0;
1488 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1489 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1490 int64_t sample = ts_to_samples(st, pts);
1491 int duration = ts_to_samples(st, pkt->duration);
1492 int64_t end_sample = sample + duration;
1493 if (duration > 0 && end_sample >= st->first_discard_sample &&
1494 sample < st->last_discard_sample)
1495 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1497 if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1498 st->skip_samples = st->start_skip_samples;
1499 if (st->skip_samples || discard_padding) {
1500 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1502 AV_WL32(p, st->skip_samples);
1503 AV_WL32(p + 4, discard_padding);
1504 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1506 st->skip_samples = 0;
1509 if (st->inject_global_side_data) {
1510 for (i = 0; i < st->nb_side_data; i++) {
1511 AVPacketSideData *src_sd = &st->side_data[i];
1514 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1517 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1519 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1523 memcpy(dst_data, src_sd->data, src_sd->size);
1525 st->inject_global_side_data = 0;
1528 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1529 av_packet_merge_side_data(pkt);
1532 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1534 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1535 av_dict_copy(&s->metadata, metadata, 0);
1536 av_dict_free(&metadata);
1537 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1540 if (s->debug & FF_FDEBUG_TS)
1541 av_log(s, AV_LOG_DEBUG,
1542 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1543 "size=%d, duration=%"PRId64", flags=%d\n",
1545 av_ts2str(pkt->pts),
1546 av_ts2str(pkt->dts),
1547 pkt->size, pkt->duration, pkt->flags);
1552 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1554 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1560 ret = s->internal->packet_buffer
1561 ? read_from_packet_buffer(&s->internal->packet_buffer,
1562 &s->internal->packet_buffer_end, pkt)
1563 : read_frame_internal(s, pkt);
1570 AVPacketList *pktl = s->internal->packet_buffer;
1573 AVPacket *next_pkt = &pktl->pkt;
1575 if (next_pkt->dts != AV_NOPTS_VALUE) {
1576 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1577 // last dts seen for this stream. if any of packets following
1578 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1579 int64_t last_dts = next_pkt->dts;
1580 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1581 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1582 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1583 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1585 next_pkt->pts = pktl->pkt.dts;
1587 if (last_dts != AV_NOPTS_VALUE) {
1588 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1589 last_dts = pktl->pkt.dts;
1594 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1595 // Fixing the last reference frame had none pts issue (For MXF etc).
1596 // We only do this when
1598 // 2. we are not able to resolve a pts value for current packet.
1599 // 3. the packets for this stream at the end of the files had valid dts.
1600 next_pkt->pts = last_dts + next_pkt->duration;
1602 pktl = s->internal->packet_buffer;
1605 /* read packet from packet buffer, if there is data */
1606 st = s->streams[next_pkt->stream_index];
1607 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1608 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1609 ret = read_from_packet_buffer(&s->internal->packet_buffer,
1610 &s->internal->packet_buffer_end, pkt);
1615 ret = read_frame_internal(s, pkt);
1617 if (pktl && ret != AVERROR(EAGAIN)) {
1624 ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1625 &s->internal->packet_buffer_end, 1);
1626 av_packet_unref(pkt);
1633 st = s->streams[pkt->stream_index];
1634 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1635 ff_reduce_index(s, st->index);
1636 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1639 if (is_relative(pkt->dts))
1640 pkt->dts -= RELATIVE_TS_BASE;
1641 if (is_relative(pkt->pts))
1642 pkt->pts -= RELATIVE_TS_BASE;
1647 /* XXX: suppress the packet queue */
1648 static void flush_packet_queue(AVFormatContext *s)
1652 free_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end);
1653 free_packet_buffer(&s->internal->packet_buffer, &s->internal->packet_buffer_end);
1654 free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1656 s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1659 /*******************************************************/
1662 int av_find_default_stream_index(AVFormatContext *s)
1666 int best_stream = 0;
1667 int best_score = INT_MIN;
1669 if (s->nb_streams <= 0)
1671 for (i = 0; i < s->nb_streams; i++) {
1674 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1675 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1677 if (st->codec->width && st->codec->height)
1681 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1682 if (st->codec->sample_rate)
1685 if (st->codec_info_nb_frames)
1688 if (st->discard != AVDISCARD_ALL)
1691 if (score > best_score) {
1699 /** Flush the frame reader. */
1700 void ff_read_frame_flush(AVFormatContext *s)
1705 flush_packet_queue(s);
1707 /* Reset read state for each stream. */
1708 for (i = 0; i < s->nb_streams; i++) {
1712 av_parser_close(st->parser);
1715 st->last_IP_pts = AV_NOPTS_VALUE;
1716 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1717 if (st->first_dts == AV_NOPTS_VALUE)
1718 st->cur_dts = RELATIVE_TS_BASE;
1720 /* We set the current DTS to an unspecified origin. */
1721 st->cur_dts = AV_NOPTS_VALUE;
1723 st->probe_packets = MAX_PROBE_PACKETS;
1725 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1726 st->pts_buffer[j] = AV_NOPTS_VALUE;
1728 if (s->internal->inject_global_side_data)
1729 st->inject_global_side_data = 1;
1731 st->skip_samples = 0;
1735 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1739 for (i = 0; i < s->nb_streams; i++) {
1740 AVStream *st = s->streams[i];
1743 av_rescale(timestamp,
1744 st->time_base.den * (int64_t) ref_st->time_base.num,
1745 st->time_base.num * (int64_t) ref_st->time_base.den);
1749 void ff_reduce_index(AVFormatContext *s, int stream_index)
1751 AVStream *st = s->streams[stream_index];
1752 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1754 if ((unsigned) st->nb_index_entries >= max_entries) {
1756 for (i = 0; 2 * i < st->nb_index_entries; i++)
1757 st->index_entries[i] = st->index_entries[2 * i];
1758 st->nb_index_entries = i;
1762 int ff_add_index_entry(AVIndexEntry **index_entries,
1763 int *nb_index_entries,
1764 unsigned int *index_entries_allocated_size,
1765 int64_t pos, int64_t timestamp,
1766 int size, int distance, int flags)
1768 AVIndexEntry *entries, *ie;
1771 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1774 if (timestamp == AV_NOPTS_VALUE)
1775 return AVERROR(EINVAL);
1777 if (size < 0 || size > 0x3FFFFFFF)
1778 return AVERROR(EINVAL);
1780 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1781 timestamp -= RELATIVE_TS_BASE;
1783 entries = av_fast_realloc(*index_entries,
1784 index_entries_allocated_size,
1785 (*nb_index_entries + 1) *
1786 sizeof(AVIndexEntry));
1790 *index_entries = entries;
1792 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1793 timestamp, AVSEEK_FLAG_ANY);
1796 index = (*nb_index_entries)++;
1797 ie = &entries[index];
1798 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1800 ie = &entries[index];
1801 if (ie->timestamp != timestamp) {
1802 if (ie->timestamp <= timestamp)
1804 memmove(entries + index + 1, entries + index,
1805 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1806 (*nb_index_entries)++;
1807 } else if (ie->pos == pos && distance < ie->min_distance)
1808 // do not reduce the distance
1809 distance = ie->min_distance;
1813 ie->timestamp = timestamp;
1814 ie->min_distance = distance;
1821 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1822 int size, int distance, int flags)
1824 timestamp = wrap_timestamp(st, timestamp);
1825 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1826 &st->index_entries_allocated_size, pos,
1827 timestamp, size, distance, flags);
1830 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1831 int64_t wanted_timestamp, int flags)
1839 // Optimize appending index entries at the end.
1840 if (b && entries[b - 1].timestamp < wanted_timestamp)
1845 timestamp = entries[m].timestamp;
1846 if (timestamp >= wanted_timestamp)
1848 if (timestamp <= wanted_timestamp)
1851 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1853 if (!(flags & AVSEEK_FLAG_ANY))
1854 while (m >= 0 && m < nb_entries &&
1855 !(entries[m].flags & AVINDEX_KEYFRAME))
1856 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1858 if (m == nb_entries)
1863 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
1866 int64_t pos_delta = 0;
1868 //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
1869 const char *proto = avio_find_protocol_name(s->filename);
1872 av_log(s, AV_LOG_INFO,
1873 "Protocol name not provided, cannot determine if input is local or "
1874 "a network protocol, buffers and access patterns cannot be configured "
1875 "optimally without knowing the protocol\n");
1878 if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
1881 for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
1882 AVStream *st1 = s->streams[ist1];
1883 for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
1884 AVStream *st2 = s->streams[ist2];
1890 for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
1891 AVIndexEntry *e1 = &st1->index_entries[i1];
1892 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
1894 skip = FFMAX(skip, e1->size);
1895 for (; i2 < st2->nb_index_entries; i2++) {
1896 AVIndexEntry *e2 = &st2->index_entries[i2];
1897 int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
1898 if (e2_pts - e1_pts < time_tolerance)
1900 pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
1908 /* XXX This could be adjusted depending on protocol*/
1909 if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
1910 av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
1911 ffio_set_buf_size(s->pb, pos_delta);
1912 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
1915 if (skip < (1<<23)) {
1916 s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
1920 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1922 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1923 wanted_timestamp, flags);
1926 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1927 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1929 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1930 if (stream_index >= 0)
1931 ts = wrap_timestamp(s->streams[stream_index], ts);
1935 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1936 int64_t target_ts, int flags)
1938 AVInputFormat *avif = s->iformat;
1939 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1940 int64_t ts_min, ts_max, ts;
1945 if (stream_index < 0)
1948 av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1951 ts_min = AV_NOPTS_VALUE;
1952 pos_limit = -1; // GCC falsely says it may be uninitialized.
1954 st = s->streams[stream_index];
1955 if (st->index_entries) {
1958 /* FIXME: Whole function must be checked for non-keyframe entries in
1959 * index case, especially read_timestamp(). */
1960 index = av_index_search_timestamp(st, target_ts,
1961 flags | AVSEEK_FLAG_BACKWARD);
1962 index = FFMAX(index, 0);
1963 e = &st->index_entries[index];
1965 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1967 ts_min = e->timestamp;
1968 av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1969 pos_min, av_ts2str(ts_min));
1971 av_assert1(index == 0);
1974 index = av_index_search_timestamp(st, target_ts,
1975 flags & ~AVSEEK_FLAG_BACKWARD);
1976 av_assert0(index < st->nb_index_entries);
1978 e = &st->index_entries[index];
1979 av_assert1(e->timestamp >= target_ts);
1981 ts_max = e->timestamp;
1982 pos_limit = pos_max - e->min_distance;
1983 av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1984 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1988 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1989 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1994 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1997 ff_read_frame_flush(s);
1998 ff_update_cur_dts(s, st, ts);
2003 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2004 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2006 int64_t step = 1024;
2007 int64_t limit, ts_max;
2008 int64_t filesize = avio_size(s->pb);
2009 int64_t pos_max = filesize - 1;
2012 pos_max = FFMAX(0, (pos_max) - step);
2013 ts_max = ff_read_timestamp(s, stream_index,
2014 &pos_max, limit, read_timestamp);
2016 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2017 if (ts_max == AV_NOPTS_VALUE)
2021 int64_t tmp_pos = pos_max + 1;
2022 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
2023 &tmp_pos, INT64_MAX, read_timestamp);
2024 if (tmp_ts == AV_NOPTS_VALUE)
2026 av_assert0(tmp_pos > pos_max);
2029 if (tmp_pos >= filesize)
2041 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2042 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2043 int64_t ts_min, int64_t ts_max,
2044 int flags, int64_t *ts_ret,
2045 int64_t (*read_timestamp)(struct AVFormatContext *, int,
2046 int64_t *, int64_t))
2053 av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2055 if (ts_min == AV_NOPTS_VALUE) {
2056 pos_min = s->internal->data_offset;
2057 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2058 if (ts_min == AV_NOPTS_VALUE)
2062 if (ts_min >= target_ts) {
2067 if (ts_max == AV_NOPTS_VALUE) {
2068 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2070 pos_limit = pos_max;
2073 if (ts_max <= target_ts) {
2078 av_assert0(ts_min < ts_max);
2081 while (pos_min < pos_limit) {
2082 av_log(s, AV_LOG_TRACE,
2083 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2084 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2085 av_assert0(pos_limit <= pos_max);
2087 if (no_change == 0) {
2088 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2089 // interpolate position (better than dichotomy)
2090 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2092 pos_min - approximate_keyframe_distance;
2093 } else if (no_change == 1) {
2094 // bisection if interpolation did not change min / max pos last time
2095 pos = (pos_min + pos_limit) >> 1;
2097 /* linear search if bisection failed, can only happen if there
2098 * are very few or no keyframes between min/max */
2103 else if (pos > pos_limit)
2107 // May pass pos_limit instead of -1.
2108 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2113 av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2114 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2115 pos_min, pos, pos_max,
2116 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2117 pos_limit, start_pos, no_change);
2118 if (ts == AV_NOPTS_VALUE) {
2119 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2122 if (target_ts <= ts) {
2123 pos_limit = start_pos - 1;
2127 if (target_ts >= ts) {
2133 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2134 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2137 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2139 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2140 av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2141 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2147 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2148 int64_t pos, int flags)
2150 int64_t pos_min, pos_max;
2152 pos_min = s->internal->data_offset;
2153 pos_max = avio_size(s->pb) - 1;
2157 else if (pos > pos_max)
2160 avio_seek(s->pb, pos, SEEK_SET);
2162 s->io_repositioned = 1;
2167 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2168 int64_t timestamp, int flags)
2175 st = s->streams[stream_index];
2177 index = av_index_search_timestamp(st, timestamp, flags);
2179 if (index < 0 && st->nb_index_entries &&
2180 timestamp < st->index_entries[0].timestamp)
2183 if (index < 0 || index == st->nb_index_entries - 1) {
2187 if (st->nb_index_entries) {
2188 av_assert0(st->index_entries);
2189 ie = &st->index_entries[st->nb_index_entries - 1];
2190 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2192 ff_update_cur_dts(s, st, ie->timestamp);
2194 if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2200 read_status = av_read_frame(s, &pkt);
2201 } while (read_status == AVERROR(EAGAIN));
2202 if (read_status < 0)
2204 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2205 if (pkt.flags & AV_PKT_FLAG_KEY) {
2206 av_packet_unref(&pkt);
2209 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2210 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);
2211 av_packet_unref(&pkt);
2215 av_packet_unref(&pkt);
2217 index = av_index_search_timestamp(st, timestamp, flags);
2222 ff_read_frame_flush(s);
2223 if (s->iformat->read_seek)
2224 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2226 ie = &st->index_entries[index];
2227 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2229 ff_update_cur_dts(s, st, ie->timestamp);
2234 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2235 int64_t timestamp, int flags)
2240 if (flags & AVSEEK_FLAG_BYTE) {
2241 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2243 ff_read_frame_flush(s);
2244 return seek_frame_byte(s, stream_index, timestamp, flags);
2247 if (stream_index < 0) {
2248 stream_index = av_find_default_stream_index(s);
2249 if (stream_index < 0)
2252 st = s->streams[stream_index];
2253 /* timestamp for default must be expressed in AV_TIME_BASE units */
2254 timestamp = av_rescale(timestamp, st->time_base.den,
2255 AV_TIME_BASE * (int64_t) st->time_base.num);
2258 /* first, we try the format specific seek */
2259 if (s->iformat->read_seek) {
2260 ff_read_frame_flush(s);
2261 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2267 if (s->iformat->read_timestamp &&
2268 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2269 ff_read_frame_flush(s);
2270 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2271 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2272 ff_read_frame_flush(s);
2273 return seek_frame_generic(s, stream_index, timestamp, flags);
2278 int av_seek_frame(AVFormatContext *s, int stream_index,
2279 int64_t timestamp, int flags)
2283 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2284 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2285 if ((flags & AVSEEK_FLAG_BACKWARD))
2289 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2290 flags & ~AVSEEK_FLAG_BACKWARD);
2293 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2296 ret = avformat_queue_attached_pictures(s);
2301 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2302 int64_t ts, int64_t max_ts, int flags)
2304 if (min_ts > ts || max_ts < ts)
2306 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2307 return AVERROR(EINVAL);
2310 flags |= AVSEEK_FLAG_ANY;
2311 flags &= ~AVSEEK_FLAG_BACKWARD;
2313 if (s->iformat->read_seek2) {
2315 ff_read_frame_flush(s);
2317 if (stream_index == -1 && s->nb_streams == 1) {
2318 AVRational time_base = s->streams[0]->time_base;
2319 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2320 min_ts = av_rescale_rnd(min_ts, time_base.den,
2321 time_base.num * (int64_t)AV_TIME_BASE,
2322 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2323 max_ts = av_rescale_rnd(max_ts, time_base.den,
2324 time_base.num * (int64_t)AV_TIME_BASE,
2325 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2328 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2332 ret = avformat_queue_attached_pictures(s);
2336 if (s->iformat->read_timestamp) {
2337 // try to seek via read_timestamp()
2340 // Fall back on old API if new is not implemented but old is.
2341 // Note the old API has somewhat different semantics.
2342 if (s->iformat->read_seek || 1) {
2343 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2344 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2345 if (ret<0 && ts != min_ts && max_ts != ts) {
2346 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2348 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2353 // try some generic seek like seek_frame_generic() but with new ts semantics
2354 return -1; //unreachable
2357 int avformat_flush(AVFormatContext *s)
2359 ff_read_frame_flush(s);
2363 /*******************************************************/
2366 * Return TRUE if the stream has accurate duration in any stream.
2368 * @return TRUE if the stream has accurate duration for at least one component.
2370 static int has_duration(AVFormatContext *ic)
2375 for (i = 0; i < ic->nb_streams; i++) {
2376 st = ic->streams[i];
2377 if (st->duration != AV_NOPTS_VALUE)
2380 if (ic->duration != AV_NOPTS_VALUE)
2386 * Estimate the stream timings from the one of each components.
2388 * Also computes the global bitrate if possible.
2390 static void update_stream_timings(AVFormatContext *ic)
2392 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2393 int64_t duration, duration1, filesize;
2398 start_time = INT64_MAX;
2399 start_time_text = INT64_MAX;
2400 end_time = INT64_MIN;
2401 duration = INT64_MIN;
2402 for (i = 0; i < ic->nb_streams; i++) {
2403 st = ic->streams[i];
2404 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2405 start_time1 = av_rescale_q(st->start_time, st->time_base,
2407 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2408 if (start_time1 < start_time_text)
2409 start_time_text = start_time1;
2411 start_time = FFMIN(start_time, start_time1);
2412 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2414 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2415 if (end_time1 != AV_NOPTS_VALUE) {
2416 end_time1 += start_time1;
2417 end_time = FFMAX(end_time, end_time1);
2419 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2420 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2421 p->start_time = start_time1;
2422 if (p->end_time < end_time1)
2423 p->end_time = end_time1;
2426 if (st->duration != AV_NOPTS_VALUE) {
2427 duration1 = av_rescale_q(st->duration, st->time_base,
2429 duration = FFMAX(duration, duration1);
2432 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2433 start_time = start_time_text;
2434 else if (start_time > start_time_text)
2435 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2437 if (start_time != INT64_MAX) {
2438 ic->start_time = start_time;
2439 if (end_time != INT64_MIN) {
2440 if (ic->nb_programs) {
2441 for (i = 0; i < ic->nb_programs; i++) {
2442 p = ic->programs[i];
2443 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2444 duration = FFMAX(duration, p->end_time - p->start_time);
2447 duration = FFMAX(duration, end_time - start_time);
2450 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2451 ic->duration = duration;
2453 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2454 /* compute the bitrate */
2455 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2456 (double) ic->duration;
2457 if (bitrate >= 0 && bitrate <= INT64_MAX)
2458 ic->bit_rate = bitrate;
2462 static void fill_all_stream_timings(AVFormatContext *ic)
2467 update_stream_timings(ic);
2468 for (i = 0; i < ic->nb_streams; i++) {
2469 st = ic->streams[i];
2470 if (st->start_time == AV_NOPTS_VALUE) {
2471 if (ic->start_time != AV_NOPTS_VALUE)
2472 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2474 if (ic->duration != AV_NOPTS_VALUE)
2475 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2481 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2483 int64_t filesize, duration;
2484 int i, show_warning = 0;
2487 /* if bit_rate is already set, we believe it */
2488 if (ic->bit_rate <= 0) {
2490 for (i = 0; i < ic->nb_streams; i++) {
2491 st = ic->streams[i];
2492 if (st->codec->bit_rate > 0) {
2493 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2497 bit_rate += st->codec->bit_rate;
2498 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2499 // If we have a videostream with packets but without a bitrate
2500 // then consider the sum not known
2505 ic->bit_rate = bit_rate;
2508 /* if duration is already set, we believe it */
2509 if (ic->duration == AV_NOPTS_VALUE &&
2510 ic->bit_rate != 0) {
2511 filesize = ic->pb ? avio_size(ic->pb) : 0;
2512 if (filesize > ic->internal->data_offset) {
2513 filesize -= ic->internal->data_offset;
2514 for (i = 0; i < ic->nb_streams; i++) {
2515 st = ic->streams[i];
2516 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2517 && st->duration == AV_NOPTS_VALUE) {
2518 duration = av_rescale(8 * filesize, st->time_base.den,
2520 (int64_t) st->time_base.num);
2521 st->duration = duration;
2528 av_log(ic, AV_LOG_WARNING,
2529 "Estimating duration from bitrate, this may be inaccurate\n");
2532 #define DURATION_MAX_READ_SIZE 250000LL
2533 #define DURATION_MAX_RETRY 6
2535 /* only usable for MPEG-PS streams */
2536 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2538 AVPacket pkt1, *pkt = &pkt1;
2540 int num, den, read_size, i, ret;
2541 int found_duration = 0;
2543 int64_t filesize, offset, duration;
2546 /* flush packet queue */
2547 flush_packet_queue(ic);
2549 for (i = 0; i < ic->nb_streams; i++) {
2550 st = ic->streams[i];
2551 if (st->start_time == AV_NOPTS_VALUE &&
2552 st->first_dts == AV_NOPTS_VALUE &&
2553 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2554 av_log(st->codec, AV_LOG_WARNING,
2555 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2558 av_parser_close(st->parser);
2563 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2564 /* estimate the end time (duration) */
2565 /* XXX: may need to support wrapping */
2566 filesize = ic->pb ? avio_size(ic->pb) : 0;
2568 is_end = found_duration;
2569 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2573 avio_seek(ic->pb, offset, SEEK_SET);
2576 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2580 ret = ff_read_packet(ic, pkt);
2581 } while (ret == AVERROR(EAGAIN));
2584 read_size += pkt->size;
2585 st = ic->streams[pkt->stream_index];
2586 if (pkt->pts != AV_NOPTS_VALUE &&
2587 (st->start_time != AV_NOPTS_VALUE ||
2588 st->first_dts != AV_NOPTS_VALUE)) {
2589 if (pkt->duration == 0) {
2590 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2592 pkt->duration = av_rescale_rnd(1,
2593 num * (int64_t) st->time_base.den,
2594 den * (int64_t) st->time_base.num,
2598 duration = pkt->pts + pkt->duration;
2600 if (st->start_time != AV_NOPTS_VALUE)
2601 duration -= st->start_time;
2603 duration -= st->first_dts;
2605 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2606 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2607 st->duration = duration;
2608 st->info->last_duration = duration;
2611 av_packet_unref(pkt);
2614 /* check if all audio/video streams have valid duration */
2617 for (i = 0; i < ic->nb_streams; i++) {
2618 st = ic->streams[i];
2619 switch (st->codec->codec_type) {
2620 case AVMEDIA_TYPE_VIDEO:
2621 case AVMEDIA_TYPE_AUDIO:
2622 if (st->duration == AV_NOPTS_VALUE)
2629 ++retry <= DURATION_MAX_RETRY);
2631 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2633 /* warn about audio/video streams which duration could not be estimated */
2634 for (i = 0; i < ic->nb_streams; i++) {
2635 st = ic->streams[i];
2636 if (st->duration == AV_NOPTS_VALUE) {
2637 switch (st->codec->codec_type) {
2638 case AVMEDIA_TYPE_VIDEO:
2639 case AVMEDIA_TYPE_AUDIO:
2640 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2641 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2643 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2647 fill_all_stream_timings(ic);
2649 avio_seek(ic->pb, old_offset, SEEK_SET);
2650 for (i = 0; i < ic->nb_streams; i++) {
2653 st = ic->streams[i];
2654 st->cur_dts = st->first_dts;
2655 st->last_IP_pts = AV_NOPTS_VALUE;
2656 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2657 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2658 st->pts_buffer[j] = AV_NOPTS_VALUE;
2662 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2666 /* get the file size, if possible */
2667 if (ic->iformat->flags & AVFMT_NOFILE) {
2670 file_size = avio_size(ic->pb);
2671 file_size = FFMAX(0, file_size);
2674 if ((!strcmp(ic->iformat->name, "mpeg") ||
2675 !strcmp(ic->iformat->name, "mpegts")) &&
2676 file_size && ic->pb->seekable) {
2677 /* get accurate estimate from the PTSes */
2678 estimate_timings_from_pts(ic, old_offset);
2679 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2680 } else if (has_duration(ic)) {
2681 /* at least one component has timings - we use them for all
2683 fill_all_stream_timings(ic);
2684 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2686 /* less precise: use bitrate info */
2687 estimate_timings_from_bit_rate(ic);
2688 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2690 update_stream_timings(ic);
2694 AVStream av_unused *st;
2695 for (i = 0; i < ic->nb_streams; i++) {
2696 st = ic->streams[i];
2697 av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2698 (double) st->start_time / AV_TIME_BASE,
2699 (double) st->duration / AV_TIME_BASE);
2701 av_log(ic, AV_LOG_TRACE,
2702 "stream: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2703 (double) ic->start_time / AV_TIME_BASE,
2704 (double) ic->duration / AV_TIME_BASE,
2705 (int64_t)ic->bit_rate / 1000);
2709 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2711 AVCodecContext *avctx = st->codec;
2713 #define FAIL(errmsg) do { \
2715 *errmsg_ptr = errmsg; \
2719 if ( avctx->codec_id == AV_CODEC_ID_NONE
2720 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2721 FAIL("unknown codec");
2722 switch (avctx->codec_type) {
2723 case AVMEDIA_TYPE_AUDIO:
2724 if (!avctx->frame_size && determinable_frame_size(avctx))
2725 FAIL("unspecified frame size");
2726 if (st->info->found_decoder >= 0 &&
2727 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2728 FAIL("unspecified sample format");
2729 if (!avctx->sample_rate)
2730 FAIL("unspecified sample rate");
2731 if (!avctx->channels)
2732 FAIL("unspecified number of channels");
2733 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2734 FAIL("no decodable DTS frames");
2736 case AVMEDIA_TYPE_VIDEO:
2738 FAIL("unspecified size");
2739 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2740 FAIL("unspecified pixel format");
2741 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2742 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2743 FAIL("no frame in rv30/40 and no sar");
2745 case AVMEDIA_TYPE_SUBTITLE:
2746 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2747 FAIL("unspecified size");
2749 case AVMEDIA_TYPE_DATA:
2750 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2756 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2757 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2758 AVDictionary **options)
2760 const AVCodec *codec;
2761 int got_picture = 1, ret = 0;
2762 AVFrame *frame = av_frame_alloc();
2763 AVSubtitle subtitle;
2764 AVPacket pkt = *avpkt;
2765 int do_skip_frame = 0;
2766 enum AVDiscard skip_frame;
2769 return AVERROR(ENOMEM);
2771 if (!avcodec_is_open(st->codec) &&
2772 st->info->found_decoder <= 0 &&
2773 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2774 AVDictionary *thread_opt = NULL;
2776 codec = find_decoder(s, st, st->codec->codec_id);
2779 st->info->found_decoder = -st->codec->codec_id;
2784 /* Force thread count to 1 since the H.264 decoder will not extract
2785 * SPS and PPS to extradata during multi-threaded decoding. */
2786 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2787 if (s->codec_whitelist)
2788 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2789 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2791 av_dict_free(&thread_opt);
2793 st->info->found_decoder = -st->codec->codec_id;
2796 st->info->found_decoder = 1;
2797 } else if (!st->info->found_decoder)
2798 st->info->found_decoder = 1;
2800 if (st->info->found_decoder < 0) {
2805 if (st->codec->codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM) {
2807 skip_frame = st->codec->skip_frame;
2808 st->codec->skip_frame = AVDISCARD_ALL;
2811 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2813 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2814 (!st->codec_info_nb_frames &&
2815 (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2817 switch (st->codec->codec_type) {
2818 case AVMEDIA_TYPE_VIDEO:
2819 ret = avcodec_decode_video2(st->codec, frame,
2820 &got_picture, &pkt);
2822 case AVMEDIA_TYPE_AUDIO:
2823 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2825 case AVMEDIA_TYPE_SUBTITLE:
2826 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2827 &got_picture, &pkt);
2835 st->nb_decoded_frames++;
2842 if (!pkt.data && !got_picture)
2846 if (do_skip_frame) {
2847 st->codec->skip_frame = skip_frame;
2850 av_frame_free(&frame);
2854 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2856 while (tags->id != AV_CODEC_ID_NONE) {
2864 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2867 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2868 if (tag == tags[i].tag)
2870 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2871 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2873 return AV_CODEC_ID_NONE;
2876 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2881 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2883 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2885 return AV_CODEC_ID_NONE;
2890 if (sflags & (1 << (bps - 1))) {
2893 return AV_CODEC_ID_PCM_S8;
2895 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2897 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2899 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2901 return AV_CODEC_ID_NONE;
2906 return AV_CODEC_ID_PCM_U8;
2908 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2910 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2912 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2914 return AV_CODEC_ID_NONE;
2920 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2923 if (!av_codec_get_tag2(tags, id, &tag))
2928 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2932 for (i = 0; tags && tags[i]; i++) {
2933 const AVCodecTag *codec_tags = tags[i];
2934 while (codec_tags->id != AV_CODEC_ID_NONE) {
2935 if (codec_tags->id == id) {
2936 *tag = codec_tags->tag;
2945 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2948 for (i = 0; tags && tags[i]; i++) {
2949 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2950 if (id != AV_CODEC_ID_NONE)
2953 return AV_CODEC_ID_NONE;
2956 static void compute_chapters_end(AVFormatContext *s)
2959 int64_t max_time = 0;
2961 if (s->duration > 0)
2962 max_time = s->duration +
2963 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2965 for (i = 0; i < s->nb_chapters; i++)
2966 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2967 AVChapter *ch = s->chapters[i];
2968 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2972 for (j = 0; j < s->nb_chapters; j++) {
2973 AVChapter *ch1 = s->chapters[j];
2974 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2976 if (j != i && next_start > ch->start && next_start < end)
2979 ch->end = (end == INT64_MAX) ? ch->start : end;
2983 static int get_std_framerate(int i)
2986 return (i + 1) * 1001;
2990 return (i + 31) * 1001 * 12;
2994 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
2998 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3001 /* Is the time base unreliable?
3002 * This is a heuristic to balance between quick acceptance of the values in
3003 * the headers vs. some extra checks.
3004 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3005 * MPEG-2 commonly misuses field repeat flags to store different framerates.
3006 * And there are "variable" fps files this needs to detect as well. */
3007 static int tb_unreliable(AVCodecContext *c)
3009 if (c->time_base.den >= 101LL * c->time_base.num ||
3010 c->time_base.den < 5LL * c->time_base.num ||
3011 // c->codec_tag == AV_RL32("DIVX") ||
3012 // c->codec_tag == AV_RL32("XVID") ||
3013 c->codec_tag == AV_RL32("mp4v") ||
3014 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3015 c->codec_id == AV_CODEC_ID_GIF ||
3016 c->codec_id == AV_CODEC_ID_HEVC ||
3017 c->codec_id == AV_CODEC_ID_H264)
3022 int ff_alloc_extradata(AVCodecContext *avctx, int size)
3026 if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
3027 avctx->extradata = NULL;
3028 avctx->extradata_size = 0;
3029 return AVERROR(EINVAL);
3031 avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3032 if (avctx->extradata) {
3033 memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3034 avctx->extradata_size = size;
3037 avctx->extradata_size = 0;
3038 ret = AVERROR(ENOMEM);
3043 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
3045 int ret = ff_alloc_extradata(avctx, size);
3048 ret = avio_read(pb, avctx->extradata, size);
3050 av_freep(&avctx->extradata);
3051 avctx->extradata_size = 0;
3052 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3053 return ret < 0 ? ret : AVERROR_INVALIDDATA;
3059 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3062 int64_t last = st->info->last_dts;
3064 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3065 && ts - (uint64_t)last < INT64_MAX) {
3066 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3067 int64_t duration = ts - last;
3069 if (!st->info->duration_error)
3070 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3071 if (!st->info->duration_error)
3072 return AVERROR(ENOMEM);
3074 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3075 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3076 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3077 if (st->info->duration_error[0][1][i] < 1e10) {
3078 int framerate = get_std_framerate(i);
3079 double sdts = dts*framerate/(1001*12);
3080 for (j= 0; j<2; j++) {
3081 int64_t ticks = llrint(sdts+j*0.5);
3082 double error= sdts - ticks + j*0.5;
3083 st->info->duration_error[j][0][i] += error;
3084 st->info->duration_error[j][1][i] += error*error;
3088 st->info->duration_count++;
3089 st->info->rfps_duration_sum += duration;
3091 if (st->info->duration_count % 10 == 0) {
3092 int n = st->info->duration_count;
3093 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3094 if (st->info->duration_error[0][1][i] < 1e10) {
3095 double a0 = st->info->duration_error[0][0][i] / n;
3096 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3097 double a1 = st->info->duration_error[1][0][i] / n;
3098 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3099 if (error0 > 0.04 && error1 > 0.04) {
3100 st->info->duration_error[0][1][i] = 2e10;
3101 st->info->duration_error[1][1][i] = 2e10;
3107 // ignore the first 4 values, they might have some random jitter
3108 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3109 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3111 if (ts != AV_NOPTS_VALUE)
3112 st->info->last_dts = ts;
3117 void ff_rfps_calculate(AVFormatContext *ic)
3121 for (i = 0; i < ic->nb_streams; i++) {
3122 AVStream *st = ic->streams[i];
3124 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3126 // the check for tb_unreliable() is not completely correct, since this is not about handling
3127 // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3128 // ipmovie.c produces.
3129 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)
3130 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);
3131 if (st->info->duration_count>1 && !st->r_frame_rate.num
3132 && tb_unreliable(st->codec)) {
3134 double best_error= 0.01;
3135 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3137 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3140 if (st->info->codec_info_duration &&
3141 st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3143 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3146 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3149 for (k= 0; k<2; k++) {
3150 int n = st->info->duration_count;
3151 double a= st->info->duration_error[k][0][j] / n;
3152 double error= st->info->duration_error[k][1][j]/n - a*a;
3154 if (error < best_error && best_error> 0.000000001) {
3156 num = get_std_framerate(j);
3159 av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3162 // do not increase frame rate by more than 1 % in order to match a standard rate.
3163 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3164 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3166 if ( !st->avg_frame_rate.num
3167 && st->r_frame_rate.num && st->info->rfps_duration_sum
3168 && st->info->codec_info_duration <= 0
3169 && st->info->duration_count > 2
3170 && 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
3172 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3173 st->avg_frame_rate = st->r_frame_rate;
3176 av_freep(&st->info->duration_error);
3177 st->info->last_dts = AV_NOPTS_VALUE;
3178 st->info->duration_count = 0;
3179 st->info->rfps_duration_sum = 0;
3183 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3185 int i, count, ret = 0, j;
3188 AVPacket pkt1, *pkt;
3189 int64_t old_offset = avio_tell(ic->pb);
3190 // new streams might appear, no options for those
3191 int orig_nb_streams = ic->nb_streams;
3193 int64_t max_analyze_duration = ic->max_analyze_duration;
3194 int64_t max_stream_analyze_duration;
3195 int64_t max_subtitle_analyze_duration;
3196 int64_t probesize = ic->probesize;
3197 int eof_reached = 0;
3199 flush_codecs = probesize > 0;
3201 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3203 max_stream_analyze_duration = max_analyze_duration;
3204 max_subtitle_analyze_duration = max_analyze_duration;
3205 if (!max_analyze_duration) {
3206 max_stream_analyze_duration =
3207 max_analyze_duration = 5*AV_TIME_BASE;
3208 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3209 if (!strcmp(ic->iformat->name, "flv"))
3210 max_stream_analyze_duration = 90*AV_TIME_BASE;
3211 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3212 max_stream_analyze_duration = 7*AV_TIME_BASE;
3216 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3217 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3219 for (i = 0; i < ic->nb_streams; i++) {
3220 const AVCodec *codec;
3221 AVDictionary *thread_opt = NULL;
3222 st = ic->streams[i];
3224 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3225 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3226 /* if (!st->time_base.num)
3228 if (!st->codec->time_base.num)
3229 st->codec->time_base = st->time_base;
3231 // only for the split stuff
3232 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3233 st->parser = av_parser_init(st->codec->codec_id);
3235 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3236 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3237 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3238 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3240 } else if (st->need_parsing) {
3241 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3242 "%s, packets or times may be invalid.\n",
3243 avcodec_get_name(st->codec->codec_id));
3246 codec = find_decoder(ic, st, st->codec->codec_id);
3248 /* Force thread count to 1 since the H.264 decoder will not extract
3249 * SPS and PPS to extradata during multi-threaded decoding. */
3250 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3252 if (ic->codec_whitelist)
3253 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3255 /* Ensure that subtitle_header is properly set. */
3256 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3257 && codec && !st->codec->codec) {
3258 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3259 av_log(ic, AV_LOG_WARNING,
3260 "Failed to open codec in av_find_stream_info\n");
3263 // Try to just open decoders, in case this is enough to get parameters.
3264 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3265 if (codec && !st->codec->codec)
3266 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3267 av_log(ic, AV_LOG_WARNING,
3268 "Failed to open codec in av_find_stream_info\n");
3271 av_dict_free(&thread_opt);
3274 for (i = 0; i < ic->nb_streams; i++) {
3275 #if FF_API_R_FRAME_RATE
3276 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3278 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3279 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3285 int analyzed_all_streams;
3286 if (ff_check_interrupt(&ic->interrupt_callback)) {
3288 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3292 /* check if one codec still needs to be handled */
3293 for (i = 0; i < ic->nb_streams; i++) {
3294 int fps_analyze_framecount = 20;
3296 st = ic->streams[i];
3297 if (!has_codec_parameters(st, NULL))
3299 /* If the timebase is coarse (like the usual millisecond precision
3300 * of mkv), we need to analyze more frames to reliably arrive at
3301 * the correct fps. */
3302 if (av_q2d(st->time_base) > 0.0005)
3303 fps_analyze_framecount *= 2;
3304 if (!tb_unreliable(st->codec))
3305 fps_analyze_framecount = 0;
3306 if (ic->fps_probe_size >= 0)
3307 fps_analyze_framecount = ic->fps_probe_size;
3308 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3309 fps_analyze_framecount = 0;
3310 /* variable fps and no guess at the real fps */
3311 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3312 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3313 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3314 st->info->codec_info_duration_fields/2 :
3315 st->info->duration_count;
3316 if (count < fps_analyze_framecount)
3319 if (st->parser && st->parser->parser->split &&
3320 !st->codec->extradata)
3322 if (st->first_dts == AV_NOPTS_VALUE &&
3323 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3324 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3325 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3326 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3329 analyzed_all_streams = 0;
3330 if (i == ic->nb_streams) {
3331 analyzed_all_streams = 1;
3332 /* NOTE: If the format has no header, then we need to read some
3333 * packets to get most of the streams, so we cannot stop here. */
3334 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3335 /* If we found the info for all the codecs, we can stop. */
3337 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3342 /* We did not get all the codec info, but we read too much data. */
3343 if (read_size >= probesize) {
3345 av_log(ic, AV_LOG_DEBUG,
3346 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3347 for (i = 0; i < ic->nb_streams; i++)
3348 if (!ic->streams[i]->r_frame_rate.num &&
3349 ic->streams[i]->info->duration_count <= 1 &&
3350 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3351 strcmp(ic->iformat->name, "image2"))
3352 av_log(ic, AV_LOG_WARNING,
3353 "Stream #%d: not enough frames to estimate rate; "
3354 "consider increasing probesize\n", i);
3358 /* NOTE: A new stream can be added there if no header in file
3359 * (AVFMTCTX_NOHEADER). */
3360 ret = read_frame_internal(ic, &pkt1);
3361 if (ret == AVERROR(EAGAIN))
3372 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3373 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3374 &ic->internal->packet_buffer_end, 0);
3376 goto find_stream_info_err;
3379 st = ic->streams[pkt->stream_index];
3380 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3381 read_size += pkt->size;
3383 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3384 /* check for non-increasing dts */
3385 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3386 st->info->fps_last_dts >= pkt->dts) {
3387 av_log(ic, AV_LOG_DEBUG,
3388 "Non-increasing DTS in stream %d: packet %d with DTS "
3389 "%"PRId64", packet %d with DTS %"PRId64"\n",
3390 st->index, st->info->fps_last_dts_idx,
3391 st->info->fps_last_dts, st->codec_info_nb_frames,
3393 st->info->fps_first_dts =
3394 st->info->fps_last_dts = AV_NOPTS_VALUE;
3396 /* Check for a discontinuity in dts. If the difference in dts
3397 * is more than 1000 times the average packet duration in the
3398 * sequence, we treat it as a discontinuity. */
3399 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3400 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3401 (pkt->dts - st->info->fps_last_dts) / 1000 >
3402 (st->info->fps_last_dts - st->info->fps_first_dts) /
3403 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3404 av_log(ic, AV_LOG_WARNING,
3405 "DTS discontinuity in stream %d: packet %d with DTS "
3406 "%"PRId64", packet %d with DTS %"PRId64"\n",
3407 st->index, st->info->fps_last_dts_idx,
3408 st->info->fps_last_dts, st->codec_info_nb_frames,
3410 st->info->fps_first_dts =
3411 st->info->fps_last_dts = AV_NOPTS_VALUE;
3414 /* update stored dts values */
3415 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3416 st->info->fps_first_dts = pkt->dts;
3417 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3419 st->info->fps_last_dts = pkt->dts;
3420 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3422 if (st->codec_info_nb_frames>1) {
3426 if (st->time_base.den > 0)
3427 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3428 if (st->avg_frame_rate.num > 0)
3429 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3432 && st->codec_info_nb_frames>30
3433 && st->info->fps_first_dts != AV_NOPTS_VALUE
3434 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3435 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3437 if (analyzed_all_streams) limit = max_analyze_duration;
3438 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3439 else limit = max_stream_analyze_duration;
3442 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3444 t, pkt->stream_index);
3445 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3446 av_packet_unref(pkt);
3449 if (pkt->duration) {
3450 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3451 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3453 st->info->codec_info_duration += pkt->duration;
3454 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3457 #if FF_API_R_FRAME_RATE
3458 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3459 ff_rfps_add_frame(ic, st, pkt->dts);
3461 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3462 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3463 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3464 if (ff_alloc_extradata(st->codec, i))
3465 return AVERROR(ENOMEM);
3466 memcpy(st->codec->extradata, pkt->data,
3467 st->codec->extradata_size);
3471 /* If still no information, we try to open the codec and to
3472 * decompress the frame. We try to avoid that in most cases as
3473 * it takes longer and uses more memory. For MPEG-4, we need to
3474 * decompress for QuickTime.
3476 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3477 * least one frame of codec data, this makes sure the codec initializes
3478 * the channel configuration and does not only trust the values from
3480 try_decode_frame(ic, st, pkt,
3481 (options && i < orig_nb_streams) ? &options[i] : NULL);
3483 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3484 av_packet_unref(pkt);
3486 st->codec_info_nb_frames++;
3490 if (eof_reached && ic->internal->packet_buffer) {
3492 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3493 // EOF already reached while reading the stream above.
3494 // So continue with reoordering DTS with whatever delay we have.
3495 if (!has_decode_delay_been_guessed(st)) {
3496 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3502 AVPacket empty_pkt = { 0 };
3504 av_init_packet(&empty_pkt);
3506 for (i = 0; i < ic->nb_streams; i++) {
3508 st = ic->streams[i];
3510 /* flush the decoders */
3511 if (st->info->found_decoder == 1) {
3513 err = try_decode_frame(ic, st, &empty_pkt,
3514 (options && i < orig_nb_streams)
3515 ? &options[i] : NULL);
3516 } while (err > 0 && !has_codec_parameters(st, NULL));
3519 av_log(ic, AV_LOG_INFO,
3520 "decoding for stream %d failed\n", st->index);
3526 // close codecs which were opened in try_decode_frame()
3527 for (i = 0; i < ic->nb_streams; i++) {
3528 st = ic->streams[i];
3529 avcodec_close(st->codec);
3532 ff_rfps_calculate(ic);
3534 for (i = 0; i < ic->nb_streams; i++) {
3535 st = ic->streams[i];
3536 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3537 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3538 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3539 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3540 st->codec->codec_tag= tag;
3543 /* estimate average framerate if not set by demuxer */
3544 if (st->info->codec_info_duration_fields &&
3545 !st->avg_frame_rate.num &&
3546 st->info->codec_info_duration) {
3548 double best_error = 0.01;
3550 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3551 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3552 st->info->codec_info_duration < 0)
3554 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3555 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3556 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3558 /* Round guessed framerate to a "standard" framerate if it's
3559 * within 1% of the original estimate. */
3560 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3561 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3562 double error = fabs(av_q2d(st->avg_frame_rate) /
3563 av_q2d(std_fps) - 1);
3565 if (error < best_error) {
3567 best_fps = std_fps.num;
3571 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3572 best_fps, 12 * 1001, INT_MAX);
3575 if (!st->r_frame_rate.num) {
3576 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3577 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3578 st->r_frame_rate.num = st->codec->time_base.den;
3579 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3581 st->r_frame_rate.num = st->time_base.den;
3582 st->r_frame_rate.den = st->time_base.num;
3585 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3586 AVRational hw_ratio = { st->codec->height, st->codec->width };
3587 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3590 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3591 if (!st->codec->bits_per_coded_sample)
3592 st->codec->bits_per_coded_sample =
3593 av_get_bits_per_sample(st->codec->codec_id);
3594 // set stream disposition based on audio service type
3595 switch (st->codec->audio_service_type) {
3596 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3597 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3599 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3600 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3602 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3603 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3605 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3606 st->disposition = AV_DISPOSITION_COMMENT;
3608 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3609 st->disposition = AV_DISPOSITION_KARAOKE;
3616 estimate_timings(ic, old_offset);
3618 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3620 if (ret >= 0 && ic->nb_streams)
3621 /* We could not have all the codec parameters before EOF. */
3623 for (i = 0; i < ic->nb_streams; i++) {
3625 st = ic->streams[i];
3626 if (!has_codec_parameters(st, &errmsg)) {
3628 avcodec_string(buf, sizeof(buf), st->codec, 0);
3629 av_log(ic, AV_LOG_WARNING,
3630 "Could not find codec parameters for stream %d (%s): %s\n"
3631 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3638 compute_chapters_end(ic);
3640 find_stream_info_err:
3641 for (i = 0; i < ic->nb_streams; i++) {
3642 st = ic->streams[i];
3643 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3644 ic->streams[i]->codec->thread_count = 0;
3646 av_freep(&st->info->duration_error);
3647 av_freep(&ic->streams[i]->info);
3650 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3651 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3655 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3659 for (i = 0; i < ic->nb_programs; i++) {
3660 if (ic->programs[i] == last) {
3664 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3665 if (ic->programs[i]->stream_index[j] == s)
3666 return ic->programs[i];
3672 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3673 int wanted_stream_nb, int related_stream,
3674 AVCodec **decoder_ret, int flags)
3676 int i, nb_streams = ic->nb_streams;
3677 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3678 unsigned *program = NULL;
3679 const AVCodec *decoder = NULL, *best_decoder = NULL;
3681 if (related_stream >= 0 && wanted_stream_nb < 0) {
3682 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3684 program = p->stream_index;
3685 nb_streams = p->nb_stream_indexes;
3688 for (i = 0; i < nb_streams; i++) {
3689 int real_stream_index = program ? program[i] : i;
3690 AVStream *st = ic->streams[real_stream_index];
3691 AVCodecContext *avctx = st->codec;
3692 if (avctx->codec_type != type)
3694 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3696 if (wanted_stream_nb != real_stream_index &&
3697 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3698 AV_DISPOSITION_VISUAL_IMPAIRED))
3700 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3703 decoder = find_decoder(ic, st, st->codec->codec_id);
3706 ret = AVERROR_DECODER_NOT_FOUND;
3710 count = st->codec_info_nb_frames;
3711 bitrate = avctx->bit_rate;
3713 bitrate = avctx->rc_max_rate;
3714 multiframe = FFMIN(5, count);
3715 if ((best_multiframe > multiframe) ||
3716 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3717 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3720 best_bitrate = bitrate;
3721 best_multiframe = multiframe;
3722 ret = real_stream_index;
3723 best_decoder = decoder;
3724 if (program && i == nb_streams - 1 && ret < 0) {
3726 nb_streams = ic->nb_streams;
3727 /* no related stream found, try again with everything */
3732 *decoder_ret = (AVCodec*)best_decoder;
3736 /*******************************************************/
3738 int av_read_play(AVFormatContext *s)
3740 if (s->iformat->read_play)
3741 return s->iformat->read_play(s);
3743 return avio_pause(s->pb, 0);
3744 return AVERROR(ENOSYS);
3747 int av_read_pause(AVFormatContext *s)
3749 if (s->iformat->read_pause)
3750 return s->iformat->read_pause(s);
3752 return avio_pause(s->pb, 1);
3753 return AVERROR(ENOSYS);
3756 static void free_stream(AVStream **pst)
3758 AVStream *st = *pst;
3764 for (i = 0; i < st->nb_side_data; i++)
3765 av_freep(&st->side_data[i].data);
3766 av_freep(&st->side_data);
3769 av_parser_close(st->parser);
3771 if (st->attached_pic.data)
3772 av_packet_unref(&st->attached_pic);
3774 av_freep(&st->internal);
3776 av_dict_free(&st->metadata);
3777 av_freep(&st->probe_data.buf);
3778 av_freep(&st->index_entries);
3779 av_freep(&st->codec->extradata);
3780 av_freep(&st->codec->subtitle_header);
3781 av_freep(&st->codec);
3782 av_freep(&st->priv_data);
3784 av_freep(&st->info->duration_error);
3785 av_freep(&st->info);
3786 av_freep(&st->recommended_encoder_configuration);
3787 av_freep(&st->priv_pts);
3792 void ff_free_stream(AVFormatContext *s, AVStream *st)
3794 av_assert0(s->nb_streams>0);
3795 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3797 free_stream(&s->streams[ --s->nb_streams ]);
3800 void avformat_free_context(AVFormatContext *s)
3808 if (s->iformat && s->iformat->priv_class && s->priv_data)
3809 av_opt_free(s->priv_data);
3810 if (s->oformat && s->oformat->priv_class && s->priv_data)
3811 av_opt_free(s->priv_data);
3813 for (i = s->nb_streams - 1; i >= 0; i--)
3814 ff_free_stream(s, s->streams[i]);
3817 for (i = s->nb_programs - 1; i >= 0; i--) {
3818 av_dict_free(&s->programs[i]->metadata);
3819 av_freep(&s->programs[i]->stream_index);
3820 av_freep(&s->programs[i]);
3822 av_freep(&s->programs);
3823 av_freep(&s->priv_data);
3824 while (s->nb_chapters--) {
3825 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3826 av_freep(&s->chapters[s->nb_chapters]);
3828 av_freep(&s->chapters);
3829 av_dict_free(&s->metadata);
3830 av_freep(&s->streams);
3831 av_freep(&s->internal);
3832 flush_packet_queue(s);
3836 void avformat_close_input(AVFormatContext **ps)
3847 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3848 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3851 flush_packet_queue(s);
3854 if (s->iformat->read_close)
3855 s->iformat->read_close(s);
3857 avformat_free_context(s);
3864 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3870 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3872 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3875 s->streams = streams;
3877 st = av_mallocz(sizeof(AVStream));
3880 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3884 st->info->last_dts = AV_NOPTS_VALUE;
3886 st->codec = avcodec_alloc_context3(c);
3893 st->internal = av_mallocz(sizeof(*st->internal));
3898 /* no default bitrate if decoding */
3899 st->codec->bit_rate = 0;
3901 /* default pts setting is MPEG-like */
3902 avpriv_set_pts_info(st, 33, 1, 90000);
3903 /* we set the current DTS to 0 so that formats without any timestamps
3904 * but durations get some timestamps, formats with some unknown
3905 * timestamps have their first few packets buffered and the
3906 * timestamps corrected before they are returned to the user */
3907 st->cur_dts = RELATIVE_TS_BASE;
3909 st->cur_dts = AV_NOPTS_VALUE;
3912 st->index = s->nb_streams;
3913 st->start_time = AV_NOPTS_VALUE;
3914 st->duration = AV_NOPTS_VALUE;
3915 st->first_dts = AV_NOPTS_VALUE;
3916 st->probe_packets = MAX_PROBE_PACKETS;
3917 st->pts_wrap_reference = AV_NOPTS_VALUE;
3918 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3920 st->last_IP_pts = AV_NOPTS_VALUE;
3921 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3922 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3923 st->pts_buffer[i] = AV_NOPTS_VALUE;
3925 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3927 #if FF_API_R_FRAME_RATE
3928 st->info->last_dts = AV_NOPTS_VALUE;
3930 st->info->fps_first_dts = AV_NOPTS_VALUE;
3931 st->info->fps_last_dts = AV_NOPTS_VALUE;
3933 st->inject_global_side_data = s->internal->inject_global_side_data;
3935 s->streams[s->nb_streams++] = st;
3942 AVProgram *av_new_program(AVFormatContext *ac, int id)
3944 AVProgram *program = NULL;
3947 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3949 for (i = 0; i < ac->nb_programs; i++)
3950 if (ac->programs[i]->id == id)
3951 program = ac->programs[i];
3954 program = av_mallocz(sizeof(AVProgram));
3957 dynarray_add(&ac->programs, &ac->nb_programs, program);
3958 program->discard = AVDISCARD_NONE;
3961 program->pts_wrap_reference = AV_NOPTS_VALUE;
3962 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3964 program->start_time =
3965 program->end_time = AV_NOPTS_VALUE;
3970 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3971 int64_t start, int64_t end, const char *title)
3973 AVChapter *chapter = NULL;
3976 if (end != AV_NOPTS_VALUE && start > end) {
3977 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3981 for (i = 0; i < s->nb_chapters; i++)
3982 if (s->chapters[i]->id == id)
3983 chapter = s->chapters[i];
3986 chapter = av_mallocz(sizeof(AVChapter));
3989 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3991 av_dict_set(&chapter->metadata, "title", title, 0);
3993 chapter->time_base = time_base;
3994 chapter->start = start;
4000 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4003 AVProgram *program = NULL;
4006 if (idx >= ac->nb_streams) {
4007 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4011 for (i = 0; i < ac->nb_programs; i++) {
4012 if (ac->programs[i]->id != progid)
4014 program = ac->programs[i];
4015 for (j = 0; j < program->nb_stream_indexes; j++)
4016 if (program->stream_index[j] == idx)
4019 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4022 program->stream_index = tmp;
4023 program->stream_index[program->nb_stream_indexes++] = idx;
4028 uint64_t ff_ntp_time(void)
4030 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4033 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4036 char *q, buf1[20], c;
4037 int nd, len, percentd_found;
4049 while (av_isdigit(*p))
4050 nd = nd * 10 + *p++ - '0';
4052 } while (av_isdigit(c));
4063 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4065 if ((q - buf + len) > buf_size - 1)
4067 memcpy(q, buf1, len);
4075 if ((q - buf) < buf_size - 1)
4079 if (!percentd_found)
4088 void av_url_split(char *proto, int proto_size,
4089 char *authorization, int authorization_size,
4090 char *hostname, int hostname_size,
4091 int *port_ptr, char *path, int path_size, const char *url)
4093 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4099 if (authorization_size > 0)
4100 authorization[0] = 0;
4101 if (hostname_size > 0)
4106 /* parse protocol */
4107 if ((p = strchr(url, ':'))) {
4108 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4115 /* no protocol means plain filename */
4116 av_strlcpy(path, url, path_size);
4120 /* separate path from hostname */
4121 ls = strchr(p, '/');
4122 ls2 = strchr(p, '?');
4126 ls = FFMIN(ls, ls2);
4128 av_strlcpy(path, ls, path_size);
4130 ls = &p[strlen(p)]; // XXX
4132 /* the rest is hostname, use that to parse auth/port */
4134 /* authorization (user[:pass]@hostname) */
4136 while ((at = strchr(p, '@')) && at < ls) {
4137 av_strlcpy(authorization, at2,
4138 FFMIN(authorization_size, at + 1 - at2));
4139 p = at + 1; /* skip '@' */
4142 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4144 av_strlcpy(hostname, p + 1,
4145 FFMIN(hostname_size, brk - p));
4146 if (brk[1] == ':' && port_ptr)
4147 *port_ptr = atoi(brk + 2);
4148 } else if ((col = strchr(p, ':')) && col < ls) {
4149 av_strlcpy(hostname, p,
4150 FFMIN(col + 1 - p, hostname_size));
4152 *port_ptr = atoi(col + 1);
4154 av_strlcpy(hostname, p,
4155 FFMIN(ls + 1 - p, hostname_size));
4159 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4162 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4165 'C', 'D', 'E', 'F' };
4166 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4169 'c', 'd', 'e', 'f' };
4170 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4172 for (i = 0; i < s; i++) {
4173 buff[i * 2] = hex_table[src[i] >> 4];
4174 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4180 int ff_hex_to_data(uint8_t *data, const char *p)
4187 p += strspn(p, SPACE_CHARS);
4190 c = av_toupper((unsigned char) *p++);
4191 if (c >= '0' && c <= '9')
4193 else if (c >= 'A' && c <= 'F')
4208 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4209 unsigned int pts_num, unsigned int pts_den)
4212 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4213 if (new_tb.num != pts_num)
4214 av_log(NULL, AV_LOG_DEBUG,
4215 "st:%d removing common factor %d from timebase\n",
4216 s->index, pts_num / new_tb.num);
4218 av_log(NULL, AV_LOG_WARNING,
4219 "st:%d has too large timebase, reducing\n", s->index);
4221 if (new_tb.num <= 0 || new_tb.den <= 0) {
4222 av_log(NULL, AV_LOG_ERROR,
4223 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4224 new_tb.num, new_tb.den,
4228 s->time_base = new_tb;
4229 av_codec_set_pkt_timebase(s->codec, new_tb);
4230 s->pts_wrap_bits = pts_wrap_bits;
4233 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4236 const char *ptr = str;
4238 /* Parse key=value pairs. */
4241 char *dest = NULL, *dest_end;
4242 int key_len, dest_len = 0;
4244 /* Skip whitespace and potential commas. */
4245 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4252 if (!(ptr = strchr(key, '=')))
4255 key_len = ptr - key;
4257 callback_get_buf(context, key, key_len, &dest, &dest_len);
4258 dest_end = dest + dest_len - 1;
4262 while (*ptr && *ptr != '\"') {
4266 if (dest && dest < dest_end)
4270 if (dest && dest < dest_end)
4278 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4279 if (dest && dest < dest_end)
4287 int ff_find_stream_index(AVFormatContext *s, int id)
4290 for (i = 0; i < s->nb_streams; i++)
4291 if (s->streams[i]->id == id)
4296 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4300 unsigned int codec_tag;
4301 if (ofmt->query_codec)
4302 return ofmt->query_codec(codec_id, std_compliance);
4303 else if (ofmt->codec_tag)
4304 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4305 else if (codec_id == ofmt->video_codec ||
4306 codec_id == ofmt->audio_codec ||
4307 codec_id == ofmt->subtitle_codec)
4310 return AVERROR_PATCHWELCOME;
4313 int avformat_network_init(void)
4317 ff_network_inited_globally = 1;
4318 if ((ret = ff_network_init()) < 0)
4320 if ((ret = ff_tls_init()) < 0)
4326 int avformat_network_deinit(void)
4331 ff_network_inited_globally = 0;
4336 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4337 uint64_t channel_layout, int32_t sample_rate,
4338 int32_t width, int32_t height)
4344 return AVERROR(EINVAL);
4347 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4349 if (channel_layout) {
4351 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4355 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4357 if (width || height) {
4359 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4361 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4363 return AVERROR(ENOMEM);
4364 bytestream_put_le32(&data, flags);
4366 bytestream_put_le32(&data, channels);
4368 bytestream_put_le64(&data, channel_layout);
4370 bytestream_put_le32(&data, sample_rate);
4371 if (width || height) {
4372 bytestream_put_le32(&data, width);
4373 bytestream_put_le32(&data, height);
4378 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4380 AVRational undef = {0, 1};
4381 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4382 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4383 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4385 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4386 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4387 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4388 stream_sample_aspect_ratio = undef;
4390 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4391 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4392 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4393 frame_sample_aspect_ratio = undef;
4395 if (stream_sample_aspect_ratio.num)
4396 return stream_sample_aspect_ratio;
4398 return frame_sample_aspect_ratio;
4401 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4403 AVRational fr = st->r_frame_rate;
4404 AVRational codec_fr = st->codec->framerate;
4405 AVRational avg_fr = st->avg_frame_rate;
4407 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4408 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4413 if (st->codec->ticks_per_frame > 1) {
4414 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4415 (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))
4422 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4425 if (*spec <= '9' && *spec >= '0') /* opt:index */
4426 return strtol(spec, NULL, 0) == st->index;
4427 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4428 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4429 enum AVMediaType type;
4433 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4434 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4435 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4436 case 'd': type = AVMEDIA_TYPE_DATA; break;
4437 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4438 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4439 default: av_assert0(0);
4441 if (type != st->codec->codec_type)
4443 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4445 if (*spec++ == ':') { /* possibly followed by :index */
4446 int i, index = strtol(spec, NULL, 0);
4447 for (i = 0; i < s->nb_streams; i++)
4448 if (s->streams[i]->codec->codec_type == type &&
4449 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4451 return i == st->index;
4455 } else if (*spec == 'p' && *(spec + 1) == ':') {
4459 prog_id = strtol(spec, &endptr, 0);
4460 for (i = 0; i < s->nb_programs; i++) {
4461 if (s->programs[i]->id != prog_id)
4464 if (*endptr++ == ':') {
4465 int stream_idx = strtol(endptr, NULL, 0);
4466 return stream_idx >= 0 &&
4467 stream_idx < s->programs[i]->nb_stream_indexes &&
4468 st->index == s->programs[i]->stream_index[stream_idx];
4471 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4472 if (st->index == s->programs[i]->stream_index[j])
4476 } else if (*spec == '#' ||
4477 (*spec == 'i' && *(spec + 1) == ':')) {
4480 spec += 1 + (*spec == 'i');
4481 stream_id = strtol(spec, &endptr, 0);
4483 return stream_id == st->id;
4484 } else if (*spec == 'm' && *(spec + 1) == ':') {
4485 AVDictionaryEntry *tag;
4490 val = strchr(spec, ':');
4492 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4494 return AVERROR(ENOMEM);
4496 tag = av_dict_get(st->metadata, key, NULL, 0);
4498 if (!val || !strcmp(tag->value, val + 1))
4507 } else if (*spec == 'u') {
4508 AVCodecContext *avctx = st->codec;
4510 switch (avctx->codec_type) {
4511 case AVMEDIA_TYPE_AUDIO:
4512 val = avctx->sample_rate && avctx->channels;
4513 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4516 case AVMEDIA_TYPE_VIDEO:
4517 val = avctx->width && avctx->height;
4518 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4521 case AVMEDIA_TYPE_UNKNOWN:
4528 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4529 } else if (!*spec) /* empty specifier, matches everything */
4532 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4533 return AVERROR(EINVAL);
4536 int ff_generate_avci_extradata(AVStream *st)
4538 static const uint8_t avci100_1080p_extradata[] = {
4540 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4541 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4542 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4543 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4544 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4545 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4546 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4547 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4548 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4550 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4553 static const uint8_t avci100_1080i_extradata[] = {
4555 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4556 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4557 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4558 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4559 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4560 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4561 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4562 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4563 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4564 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4565 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4567 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4570 static const uint8_t avci50_1080p_extradata[] = {
4572 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4573 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4574 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4575 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4576 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4577 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4578 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4579 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4580 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4582 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4585 static const uint8_t avci50_1080i_extradata[] = {
4587 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4588 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4589 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4590 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4591 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4592 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4593 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4594 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4595 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4596 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4597 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4599 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4602 static const uint8_t avci100_720p_extradata[] = {
4604 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4605 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4606 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4607 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4608 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4609 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4610 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4611 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4612 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4613 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4615 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4618 static const uint8_t avci50_720p_extradata[] = {
4620 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4621 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4622 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4623 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4624 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4625 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4626 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4627 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4628 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4630 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4634 const uint8_t *data = NULL;
4637 if (st->codec->width == 1920) {
4638 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4639 data = avci100_1080p_extradata;
4640 size = sizeof(avci100_1080p_extradata);
4642 data = avci100_1080i_extradata;
4643 size = sizeof(avci100_1080i_extradata);
4645 } else if (st->codec->width == 1440) {
4646 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4647 data = avci50_1080p_extradata;
4648 size = sizeof(avci50_1080p_extradata);
4650 data = avci50_1080i_extradata;
4651 size = sizeof(avci50_1080i_extradata);
4653 } else if (st->codec->width == 1280) {
4654 data = avci100_720p_extradata;
4655 size = sizeof(avci100_720p_extradata);
4656 } else if (st->codec->width == 960) {
4657 data = avci50_720p_extradata;
4658 size = sizeof(avci50_720p_extradata);
4664 av_freep(&st->codec->extradata);
4665 if (ff_alloc_extradata(st->codec, size))
4666 return AVERROR(ENOMEM);
4667 memcpy(st->codec->extradata, data, size);
4672 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4677 for (i = 0; i < st->nb_side_data; i++) {
4678 if (st->side_data[i].type == type) {
4680 *size = st->side_data[i].size;
4681 return st->side_data[i].data;
4687 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4690 AVPacketSideData *sd, *tmp;
4692 uint8_t *data = av_malloc(size);
4697 for (i = 0; i < st->nb_side_data; i++) {
4698 sd = &st->side_data[i];
4700 if (sd->type == type) {
4701 av_freep(&sd->data);
4708 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4714 st->side_data = tmp;
4717 sd = &st->side_data[st->nb_side_data - 1];
4724 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
4726 AVBitStreamFilterContext *bsfc = NULL;
4727 AVBitStreamFilterContext **dest = &st->internal->bsfc;
4728 while (*dest && (*dest)->next)
4729 dest = &(*dest)->next;
4731 if (!(bsfc = av_bitstream_filter_init(name))) {
4732 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
4733 return AVERROR(EINVAL);
4735 if (args && !(bsfc->args = av_strdup(args))) {
4736 av_bitstream_filter_close(bsfc);
4737 return AVERROR(ENOMEM);
4739 av_log(st->codec, AV_LOG_VERBOSE,
4740 "Automatically inserted bitstream filter '%s'; args='%s'\n",
4741 name, args ? args : "");
4746 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
4747 AVBitStreamFilterContext *bsfc)
4751 AVPacket new_pkt = *pkt;
4752 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
4753 &new_pkt.data, &new_pkt.size,
4754 pkt->data, pkt->size,
4755 pkt->flags & AV_PKT_FLAG_KEY);
4756 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
4757 av_packet_unref(pkt);
4758 memset(pkt, 0, sizeof(*pkt));
4761 if(a == 0 && new_pkt.data != pkt->data) {
4762 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
4764 memcpy(t, new_pkt.data, new_pkt.size);
4765 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
4770 a = AVERROR(ENOMEM);
4774 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
4775 av_buffer_default_free, NULL, 0);
4777 pkt->side_data = NULL;
4778 pkt->side_data_elems = 0;
4779 av_packet_unref(pkt);
4781 av_freep(&new_pkt.data);
4782 a = AVERROR(ENOMEM);
4786 av_log(codec, AV_LOG_ERROR,
4787 "Failed to open bitstream filter %s for stream %d with codec %s",
4788 bsfc->filter->name, pkt->stream_index,
4789 codec->codec ? codec->codec->name : "copy");
4800 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
4803 s->io_close(s, *pb);
4807 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
4809 AVDictionaryEntry *entry;
4810 int64_t parsed_timestamp;
4812 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
4813 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
4814 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
4817 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
4824 int ff_standardize_creation_time(AVFormatContext *s)
4827 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
4829 time_t seconds = timestamp / 1000000;
4830 struct tm *ptm, tmbuf;
4831 ptm = gmtime_r(&seconds, &tmbuf);
4834 if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
4835 return AVERROR_EXTERNAL;
4836 av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
4837 av_dict_set(&s->metadata, "creation_time", buf, 0);
4839 return AVERROR_EXTERNAL;
4845 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
4850 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
4852 if (size != AVPALETTE_SIZE) {
4853 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
4854 return AVERROR_INVALIDDATA;
4856 memcpy(palette, side_data, AVPALETTE_SIZE);
4860 if (ret == CONTAINS_PAL) {
4862 for (i = 0; i < AVPALETTE_COUNT; i++)
4863 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);