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 // a 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;
3214 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3215 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3217 for (i = 0; i < ic->nb_streams; i++) {
3218 const AVCodec *codec;
3219 AVDictionary *thread_opt = NULL;
3220 st = ic->streams[i];
3222 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3223 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3224 /* if (!st->time_base.num)
3226 if (!st->codec->time_base.num)
3227 st->codec->time_base = st->time_base;
3229 // only for the split stuff
3230 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3231 st->parser = av_parser_init(st->codec->codec_id);
3233 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3234 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3235 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3236 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3238 } else if (st->need_parsing) {
3239 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3240 "%s, packets or times may be invalid.\n",
3241 avcodec_get_name(st->codec->codec_id));
3244 codec = find_decoder(ic, st, st->codec->codec_id);
3246 /* Force thread count to 1 since the H.264 decoder will not extract
3247 * SPS and PPS to extradata during multi-threaded decoding. */
3248 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3250 if (ic->codec_whitelist)
3251 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3253 /* Ensure that subtitle_header is properly set. */
3254 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3255 && codec && !st->codec->codec) {
3256 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3257 av_log(ic, AV_LOG_WARNING,
3258 "Failed to open codec in av_find_stream_info\n");
3261 // Try to just open decoders, in case this is enough to get parameters.
3262 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3263 if (codec && !st->codec->codec)
3264 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3265 av_log(ic, AV_LOG_WARNING,
3266 "Failed to open codec in av_find_stream_info\n");
3269 av_dict_free(&thread_opt);
3272 for (i = 0; i < ic->nb_streams; i++) {
3273 #if FF_API_R_FRAME_RATE
3274 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3276 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3277 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3283 int analyzed_all_streams;
3284 if (ff_check_interrupt(&ic->interrupt_callback)) {
3286 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3290 /* check if one codec still needs to be handled */
3291 for (i = 0; i < ic->nb_streams; i++) {
3292 int fps_analyze_framecount = 20;
3294 st = ic->streams[i];
3295 if (!has_codec_parameters(st, NULL))
3297 /* If the timebase is coarse (like the usual millisecond precision
3298 * of mkv), we need to analyze more frames to reliably arrive at
3299 * the correct fps. */
3300 if (av_q2d(st->time_base) > 0.0005)
3301 fps_analyze_framecount *= 2;
3302 if (!tb_unreliable(st->codec))
3303 fps_analyze_framecount = 0;
3304 if (ic->fps_probe_size >= 0)
3305 fps_analyze_framecount = ic->fps_probe_size;
3306 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3307 fps_analyze_framecount = 0;
3308 /* variable fps and no guess at the real fps */
3309 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3310 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3311 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3312 st->info->codec_info_duration_fields/2 :
3313 st->info->duration_count;
3314 if (count < fps_analyze_framecount)
3317 if (st->parser && st->parser->parser->split &&
3318 !st->codec->extradata)
3320 if (st->first_dts == AV_NOPTS_VALUE &&
3321 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3322 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3323 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3324 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3327 analyzed_all_streams = 0;
3328 if (i == ic->nb_streams) {
3329 analyzed_all_streams = 1;
3330 /* NOTE: If the format has no header, then we need to read some
3331 * packets to get most of the streams, so we cannot stop here. */
3332 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3333 /* If we found the info for all the codecs, we can stop. */
3335 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3340 /* We did not get all the codec info, but we read too much data. */
3341 if (read_size >= probesize) {
3343 av_log(ic, AV_LOG_DEBUG,
3344 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3345 for (i = 0; i < ic->nb_streams; i++)
3346 if (!ic->streams[i]->r_frame_rate.num &&
3347 ic->streams[i]->info->duration_count <= 1 &&
3348 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3349 strcmp(ic->iformat->name, "image2"))
3350 av_log(ic, AV_LOG_WARNING,
3351 "Stream #%d: not enough frames to estimate rate; "
3352 "consider increasing probesize\n", i);
3356 /* NOTE: A new stream can be added there if no header in file
3357 * (AVFMTCTX_NOHEADER). */
3358 ret = read_frame_internal(ic, &pkt1);
3359 if (ret == AVERROR(EAGAIN))
3370 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3371 ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3372 &ic->internal->packet_buffer_end, 0);
3374 goto find_stream_info_err;
3377 st = ic->streams[pkt->stream_index];
3378 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3379 read_size += pkt->size;
3381 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3382 /* check for non-increasing dts */
3383 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3384 st->info->fps_last_dts >= pkt->dts) {
3385 av_log(ic, AV_LOG_DEBUG,
3386 "Non-increasing DTS in stream %d: packet %d with DTS "
3387 "%"PRId64", packet %d with DTS %"PRId64"\n",
3388 st->index, st->info->fps_last_dts_idx,
3389 st->info->fps_last_dts, st->codec_info_nb_frames,
3391 st->info->fps_first_dts =
3392 st->info->fps_last_dts = AV_NOPTS_VALUE;
3394 /* Check for a discontinuity in dts. If the difference in dts
3395 * is more than 1000 times the average packet duration in the
3396 * sequence, we treat it as a discontinuity. */
3397 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3398 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3399 (pkt->dts - st->info->fps_last_dts) / 1000 >
3400 (st->info->fps_last_dts - st->info->fps_first_dts) /
3401 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3402 av_log(ic, AV_LOG_WARNING,
3403 "DTS discontinuity in stream %d: packet %d with DTS "
3404 "%"PRId64", packet %d with DTS %"PRId64"\n",
3405 st->index, st->info->fps_last_dts_idx,
3406 st->info->fps_last_dts, st->codec_info_nb_frames,
3408 st->info->fps_first_dts =
3409 st->info->fps_last_dts = AV_NOPTS_VALUE;
3412 /* update stored dts values */
3413 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3414 st->info->fps_first_dts = pkt->dts;
3415 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3417 st->info->fps_last_dts = pkt->dts;
3418 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3420 if (st->codec_info_nb_frames>1) {
3424 if (st->time_base.den > 0)
3425 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3426 if (st->avg_frame_rate.num > 0)
3427 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3430 && st->codec_info_nb_frames>30
3431 && st->info->fps_first_dts != AV_NOPTS_VALUE
3432 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3433 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3435 if (analyzed_all_streams) limit = max_analyze_duration;
3436 else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3437 else limit = max_stream_analyze_duration;
3440 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3442 t, pkt->stream_index);
3443 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3444 av_packet_unref(pkt);
3447 if (pkt->duration) {
3448 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3449 st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3451 st->info->codec_info_duration += pkt->duration;
3452 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3455 #if FF_API_R_FRAME_RATE
3456 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3457 ff_rfps_add_frame(ic, st, pkt->dts);
3459 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3460 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3461 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3462 if (ff_alloc_extradata(st->codec, i))
3463 return AVERROR(ENOMEM);
3464 memcpy(st->codec->extradata, pkt->data,
3465 st->codec->extradata_size);
3469 /* If still no information, we try to open the codec and to
3470 * decompress the frame. We try to avoid that in most cases as
3471 * it takes longer and uses more memory. For MPEG-4, we need to
3472 * decompress for QuickTime.
3474 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3475 * least one frame of codec data, this makes sure the codec initializes
3476 * the channel configuration and does not only trust the values from
3478 try_decode_frame(ic, st, pkt,
3479 (options && i < orig_nb_streams) ? &options[i] : NULL);
3481 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3482 av_packet_unref(pkt);
3484 st->codec_info_nb_frames++;
3488 if (eof_reached && ic->internal->packet_buffer) {
3490 for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3491 // EOF already reached while reading the stream above.
3492 // So continue with reoordering DTS with whatever delay we have.
3493 if (!has_decode_delay_been_guessed(st)) {
3494 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3500 AVPacket empty_pkt = { 0 };
3502 av_init_packet(&empty_pkt);
3504 for (i = 0; i < ic->nb_streams; i++) {
3506 st = ic->streams[i];
3508 /* flush the decoders */
3509 if (st->info->found_decoder == 1) {
3511 err = try_decode_frame(ic, st, &empty_pkt,
3512 (options && i < orig_nb_streams)
3513 ? &options[i] : NULL);
3514 } while (err > 0 && !has_codec_parameters(st, NULL));
3517 av_log(ic, AV_LOG_INFO,
3518 "decoding for stream %d failed\n", st->index);
3524 // close codecs which were opened in try_decode_frame()
3525 for (i = 0; i < ic->nb_streams; i++) {
3526 st = ic->streams[i];
3527 avcodec_close(st->codec);
3530 ff_rfps_calculate(ic);
3532 for (i = 0; i < ic->nb_streams; i++) {
3533 st = ic->streams[i];
3534 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3535 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3536 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3537 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3538 st->codec->codec_tag= tag;
3541 /* estimate average framerate if not set by demuxer */
3542 if (st->info->codec_info_duration_fields &&
3543 !st->avg_frame_rate.num &&
3544 st->info->codec_info_duration) {
3546 double best_error = 0.01;
3548 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3549 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3550 st->info->codec_info_duration < 0)
3552 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3553 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3554 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3556 /* Round guessed framerate to a "standard" framerate if it's
3557 * within 1% of the original estimate. */
3558 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3559 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3560 double error = fabs(av_q2d(st->avg_frame_rate) /
3561 av_q2d(std_fps) - 1);
3563 if (error < best_error) {
3565 best_fps = std_fps.num;
3569 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3570 best_fps, 12 * 1001, INT_MAX);
3573 if (!st->r_frame_rate.num) {
3574 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3575 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3576 st->r_frame_rate.num = st->codec->time_base.den;
3577 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3579 st->r_frame_rate.num = st->time_base.den;
3580 st->r_frame_rate.den = st->time_base.num;
3583 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3584 AVRational hw_ratio = { st->codec->height, st->codec->width };
3585 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3588 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3589 if (!st->codec->bits_per_coded_sample)
3590 st->codec->bits_per_coded_sample =
3591 av_get_bits_per_sample(st->codec->codec_id);
3592 // set stream disposition based on audio service type
3593 switch (st->codec->audio_service_type) {
3594 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3595 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3597 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3598 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3600 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3601 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3603 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3604 st->disposition = AV_DISPOSITION_COMMENT;
3606 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3607 st->disposition = AV_DISPOSITION_KARAOKE;
3614 estimate_timings(ic, old_offset);
3616 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3618 if (ret >= 0 && ic->nb_streams)
3619 /* We could not have all the codec parameters before EOF. */
3621 for (i = 0; i < ic->nb_streams; i++) {
3623 st = ic->streams[i];
3624 if (!has_codec_parameters(st, &errmsg)) {
3626 avcodec_string(buf, sizeof(buf), st->codec, 0);
3627 av_log(ic, AV_LOG_WARNING,
3628 "Could not find codec parameters for stream %d (%s): %s\n"
3629 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3636 compute_chapters_end(ic);
3638 find_stream_info_err:
3639 for (i = 0; i < ic->nb_streams; i++) {
3640 st = ic->streams[i];
3641 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3642 ic->streams[i]->codec->thread_count = 0;
3644 av_freep(&st->info->duration_error);
3645 av_freep(&ic->streams[i]->info);
3648 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3649 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3653 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3657 for (i = 0; i < ic->nb_programs; i++) {
3658 if (ic->programs[i] == last) {
3662 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3663 if (ic->programs[i]->stream_index[j] == s)
3664 return ic->programs[i];
3670 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3671 int wanted_stream_nb, int related_stream,
3672 AVCodec **decoder_ret, int flags)
3674 int i, nb_streams = ic->nb_streams;
3675 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3676 unsigned *program = NULL;
3677 const AVCodec *decoder = NULL, *best_decoder = NULL;
3679 if (related_stream >= 0 && wanted_stream_nb < 0) {
3680 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3682 program = p->stream_index;
3683 nb_streams = p->nb_stream_indexes;
3686 for (i = 0; i < nb_streams; i++) {
3687 int real_stream_index = program ? program[i] : i;
3688 AVStream *st = ic->streams[real_stream_index];
3689 AVCodecContext *avctx = st->codec;
3690 if (avctx->codec_type != type)
3692 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3694 if (wanted_stream_nb != real_stream_index &&
3695 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3696 AV_DISPOSITION_VISUAL_IMPAIRED))
3698 if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3701 decoder = find_decoder(ic, st, st->codec->codec_id);
3704 ret = AVERROR_DECODER_NOT_FOUND;
3708 count = st->codec_info_nb_frames;
3709 bitrate = avctx->bit_rate;
3711 bitrate = avctx->rc_max_rate;
3712 multiframe = FFMIN(5, count);
3713 if ((best_multiframe > multiframe) ||
3714 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3715 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3718 best_bitrate = bitrate;
3719 best_multiframe = multiframe;
3720 ret = real_stream_index;
3721 best_decoder = decoder;
3722 if (program && i == nb_streams - 1 && ret < 0) {
3724 nb_streams = ic->nb_streams;
3725 /* no related stream found, try again with everything */
3730 *decoder_ret = (AVCodec*)best_decoder;
3734 /*******************************************************/
3736 int av_read_play(AVFormatContext *s)
3738 if (s->iformat->read_play)
3739 return s->iformat->read_play(s);
3741 return avio_pause(s->pb, 0);
3742 return AVERROR(ENOSYS);
3745 int av_read_pause(AVFormatContext *s)
3747 if (s->iformat->read_pause)
3748 return s->iformat->read_pause(s);
3750 return avio_pause(s->pb, 1);
3751 return AVERROR(ENOSYS);
3754 static void free_stream(AVStream **pst)
3756 AVStream *st = *pst;
3762 for (i = 0; i < st->nb_side_data; i++)
3763 av_freep(&st->side_data[i].data);
3764 av_freep(&st->side_data);
3767 av_parser_close(st->parser);
3769 if (st->attached_pic.data)
3770 av_packet_unref(&st->attached_pic);
3772 av_freep(&st->internal);
3774 av_dict_free(&st->metadata);
3775 av_freep(&st->probe_data.buf);
3776 av_freep(&st->index_entries);
3777 av_freep(&st->codec->extradata);
3778 av_freep(&st->codec->subtitle_header);
3779 av_freep(&st->codec);
3780 av_freep(&st->priv_data);
3782 av_freep(&st->info->duration_error);
3783 av_freep(&st->info);
3784 av_freep(&st->recommended_encoder_configuration);
3785 av_freep(&st->priv_pts);
3790 void ff_free_stream(AVFormatContext *s, AVStream *st)
3792 av_assert0(s->nb_streams>0);
3793 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3795 free_stream(&s->streams[ --s->nb_streams ]);
3798 void avformat_free_context(AVFormatContext *s)
3806 if (s->iformat && s->iformat->priv_class && s->priv_data)
3807 av_opt_free(s->priv_data);
3808 if (s->oformat && s->oformat->priv_class && s->priv_data)
3809 av_opt_free(s->priv_data);
3811 for (i = s->nb_streams - 1; i >= 0; i--)
3812 ff_free_stream(s, s->streams[i]);
3815 for (i = s->nb_programs - 1; i >= 0; i--) {
3816 av_dict_free(&s->programs[i]->metadata);
3817 av_freep(&s->programs[i]->stream_index);
3818 av_freep(&s->programs[i]);
3820 av_freep(&s->programs);
3821 av_freep(&s->priv_data);
3822 while (s->nb_chapters--) {
3823 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3824 av_freep(&s->chapters[s->nb_chapters]);
3826 av_freep(&s->chapters);
3827 av_dict_free(&s->metadata);
3828 av_freep(&s->streams);
3829 av_freep(&s->internal);
3830 flush_packet_queue(s);
3834 void avformat_close_input(AVFormatContext **ps)
3845 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3846 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3849 flush_packet_queue(s);
3852 if (s->iformat->read_close)
3853 s->iformat->read_close(s);
3855 avformat_free_context(s);
3862 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3868 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3870 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3873 s->streams = streams;
3875 st = av_mallocz(sizeof(AVStream));
3878 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3882 st->info->last_dts = AV_NOPTS_VALUE;
3884 st->codec = avcodec_alloc_context3(c);
3891 st->internal = av_mallocz(sizeof(*st->internal));
3896 /* no default bitrate if decoding */
3897 st->codec->bit_rate = 0;
3899 /* default pts setting is MPEG-like */
3900 avpriv_set_pts_info(st, 33, 1, 90000);
3901 /* we set the current DTS to 0 so that formats without any timestamps
3902 * but durations get some timestamps, formats with some unknown
3903 * timestamps have their first few packets buffered and the
3904 * timestamps corrected before they are returned to the user */
3905 st->cur_dts = RELATIVE_TS_BASE;
3907 st->cur_dts = AV_NOPTS_VALUE;
3910 st->index = s->nb_streams;
3911 st->start_time = AV_NOPTS_VALUE;
3912 st->duration = AV_NOPTS_VALUE;
3913 st->first_dts = AV_NOPTS_VALUE;
3914 st->probe_packets = MAX_PROBE_PACKETS;
3915 st->pts_wrap_reference = AV_NOPTS_VALUE;
3916 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3918 st->last_IP_pts = AV_NOPTS_VALUE;
3919 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3920 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3921 st->pts_buffer[i] = AV_NOPTS_VALUE;
3923 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3925 #if FF_API_R_FRAME_RATE
3926 st->info->last_dts = AV_NOPTS_VALUE;
3928 st->info->fps_first_dts = AV_NOPTS_VALUE;
3929 st->info->fps_last_dts = AV_NOPTS_VALUE;
3931 st->inject_global_side_data = s->internal->inject_global_side_data;
3933 s->streams[s->nb_streams++] = st;
3940 AVProgram *av_new_program(AVFormatContext *ac, int id)
3942 AVProgram *program = NULL;
3945 av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3947 for (i = 0; i < ac->nb_programs; i++)
3948 if (ac->programs[i]->id == id)
3949 program = ac->programs[i];
3952 program = av_mallocz(sizeof(AVProgram));
3955 dynarray_add(&ac->programs, &ac->nb_programs, program);
3956 program->discard = AVDISCARD_NONE;
3959 program->pts_wrap_reference = AV_NOPTS_VALUE;
3960 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3962 program->start_time =
3963 program->end_time = AV_NOPTS_VALUE;
3968 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3969 int64_t start, int64_t end, const char *title)
3971 AVChapter *chapter = NULL;
3974 if (end != AV_NOPTS_VALUE && start > end) {
3975 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3979 for (i = 0; i < s->nb_chapters; i++)
3980 if (s->chapters[i]->id == id)
3981 chapter = s->chapters[i];
3984 chapter = av_mallocz(sizeof(AVChapter));
3987 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3989 av_dict_set(&chapter->metadata, "title", title, 0);
3991 chapter->time_base = time_base;
3992 chapter->start = start;
3998 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4001 AVProgram *program = NULL;
4004 if (idx >= ac->nb_streams) {
4005 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4009 for (i = 0; i < ac->nb_programs; i++) {
4010 if (ac->programs[i]->id != progid)
4012 program = ac->programs[i];
4013 for (j = 0; j < program->nb_stream_indexes; j++)
4014 if (program->stream_index[j] == idx)
4017 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4020 program->stream_index = tmp;
4021 program->stream_index[program->nb_stream_indexes++] = idx;
4026 uint64_t ff_ntp_time(void)
4028 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4031 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4034 char *q, buf1[20], c;
4035 int nd, len, percentd_found;
4047 while (av_isdigit(*p))
4048 nd = nd * 10 + *p++ - '0';
4050 } while (av_isdigit(c));
4061 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4063 if ((q - buf + len) > buf_size - 1)
4065 memcpy(q, buf1, len);
4073 if ((q - buf) < buf_size - 1)
4077 if (!percentd_found)
4086 void av_url_split(char *proto, int proto_size,
4087 char *authorization, int authorization_size,
4088 char *hostname, int hostname_size,
4089 int *port_ptr, char *path, int path_size, const char *url)
4091 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4097 if (authorization_size > 0)
4098 authorization[0] = 0;
4099 if (hostname_size > 0)
4104 /* parse protocol */
4105 if ((p = strchr(url, ':'))) {
4106 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4113 /* no protocol means plain filename */
4114 av_strlcpy(path, url, path_size);
4118 /* separate path from hostname */
4119 ls = strchr(p, '/');
4120 ls2 = strchr(p, '?');
4124 ls = FFMIN(ls, ls2);
4126 av_strlcpy(path, ls, path_size);
4128 ls = &p[strlen(p)]; // XXX
4130 /* the rest is hostname, use that to parse auth/port */
4132 /* authorization (user[:pass]@hostname) */
4134 while ((at = strchr(p, '@')) && at < ls) {
4135 av_strlcpy(authorization, at2,
4136 FFMIN(authorization_size, at + 1 - at2));
4137 p = at + 1; /* skip '@' */
4140 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4142 av_strlcpy(hostname, p + 1,
4143 FFMIN(hostname_size, brk - p));
4144 if (brk[1] == ':' && port_ptr)
4145 *port_ptr = atoi(brk + 2);
4146 } else if ((col = strchr(p, ':')) && col < ls) {
4147 av_strlcpy(hostname, p,
4148 FFMIN(col + 1 - p, hostname_size));
4150 *port_ptr = atoi(col + 1);
4152 av_strlcpy(hostname, p,
4153 FFMIN(ls + 1 - p, hostname_size));
4157 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4160 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4163 'C', 'D', 'E', 'F' };
4164 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4167 'c', 'd', 'e', 'f' };
4168 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4170 for (i = 0; i < s; i++) {
4171 buff[i * 2] = hex_table[src[i] >> 4];
4172 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4178 int ff_hex_to_data(uint8_t *data, const char *p)
4185 p += strspn(p, SPACE_CHARS);
4188 c = av_toupper((unsigned char) *p++);
4189 if (c >= '0' && c <= '9')
4191 else if (c >= 'A' && c <= 'F')
4206 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4207 unsigned int pts_num, unsigned int pts_den)
4210 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4211 if (new_tb.num != pts_num)
4212 av_log(NULL, AV_LOG_DEBUG,
4213 "st:%d removing common factor %d from timebase\n",
4214 s->index, pts_num / new_tb.num);
4216 av_log(NULL, AV_LOG_WARNING,
4217 "st:%d has too large timebase, reducing\n", s->index);
4219 if (new_tb.num <= 0 || new_tb.den <= 0) {
4220 av_log(NULL, AV_LOG_ERROR,
4221 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4222 new_tb.num, new_tb.den,
4226 s->time_base = new_tb;
4227 av_codec_set_pkt_timebase(s->codec, new_tb);
4228 s->pts_wrap_bits = pts_wrap_bits;
4231 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4234 const char *ptr = str;
4236 /* Parse key=value pairs. */
4239 char *dest = NULL, *dest_end;
4240 int key_len, dest_len = 0;
4242 /* Skip whitespace and potential commas. */
4243 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4250 if (!(ptr = strchr(key, '=')))
4253 key_len = ptr - key;
4255 callback_get_buf(context, key, key_len, &dest, &dest_len);
4256 dest_end = dest + dest_len - 1;
4260 while (*ptr && *ptr != '\"') {
4264 if (dest && dest < dest_end)
4268 if (dest && dest < dest_end)
4276 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4277 if (dest && dest < dest_end)
4285 int ff_find_stream_index(AVFormatContext *s, int id)
4288 for (i = 0; i < s->nb_streams; i++)
4289 if (s->streams[i]->id == id)
4294 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4298 unsigned int codec_tag;
4299 if (ofmt->query_codec)
4300 return ofmt->query_codec(codec_id, std_compliance);
4301 else if (ofmt->codec_tag)
4302 return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4303 else if (codec_id == ofmt->video_codec ||
4304 codec_id == ofmt->audio_codec ||
4305 codec_id == ofmt->subtitle_codec)
4308 return AVERROR_PATCHWELCOME;
4311 int avformat_network_init(void)
4315 ff_network_inited_globally = 1;
4316 if ((ret = ff_network_init()) < 0)
4318 if ((ret = ff_tls_init()) < 0)
4324 int avformat_network_deinit(void)
4329 ff_network_inited_globally = 0;
4334 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4335 uint64_t channel_layout, int32_t sample_rate,
4336 int32_t width, int32_t height)
4342 return AVERROR(EINVAL);
4345 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4347 if (channel_layout) {
4349 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4353 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4355 if (width || height) {
4357 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4359 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4361 return AVERROR(ENOMEM);
4362 bytestream_put_le32(&data, flags);
4364 bytestream_put_le32(&data, channels);
4366 bytestream_put_le64(&data, channel_layout);
4368 bytestream_put_le32(&data, sample_rate);
4369 if (width || height) {
4370 bytestream_put_le32(&data, width);
4371 bytestream_put_le32(&data, height);
4376 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4378 AVRational undef = {0, 1};
4379 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4380 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4381 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4383 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4384 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4385 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4386 stream_sample_aspect_ratio = undef;
4388 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4389 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4390 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4391 frame_sample_aspect_ratio = undef;
4393 if (stream_sample_aspect_ratio.num)
4394 return stream_sample_aspect_ratio;
4396 return frame_sample_aspect_ratio;
4399 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4401 AVRational fr = st->r_frame_rate;
4402 AVRational codec_fr = st->codec->framerate;
4403 AVRational avg_fr = st->avg_frame_rate;
4405 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4406 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4411 if (st->codec->ticks_per_frame > 1) {
4412 if ( codec_fr.num > 0 && codec_fr.den > 0 &&
4413 (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))
4420 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4423 if (*spec <= '9' && *spec >= '0') /* opt:index */
4424 return strtol(spec, NULL, 0) == st->index;
4425 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4426 *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4427 enum AVMediaType type;
4431 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4432 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4433 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4434 case 'd': type = AVMEDIA_TYPE_DATA; break;
4435 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4436 case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4437 default: av_assert0(0);
4439 if (type != st->codec->codec_type)
4441 if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4443 if (*spec++ == ':') { /* possibly followed by :index */
4444 int i, index = strtol(spec, NULL, 0);
4445 for (i = 0; i < s->nb_streams; i++)
4446 if (s->streams[i]->codec->codec_type == type &&
4447 !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4449 return i == st->index;
4453 } else if (*spec == 'p' && *(spec + 1) == ':') {
4457 prog_id = strtol(spec, &endptr, 0);
4458 for (i = 0; i < s->nb_programs; i++) {
4459 if (s->programs[i]->id != prog_id)
4462 if (*endptr++ == ':') {
4463 int stream_idx = strtol(endptr, NULL, 0);
4464 return stream_idx >= 0 &&
4465 stream_idx < s->programs[i]->nb_stream_indexes &&
4466 st->index == s->programs[i]->stream_index[stream_idx];
4469 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4470 if (st->index == s->programs[i]->stream_index[j])
4474 } else if (*spec == '#' ||
4475 (*spec == 'i' && *(spec + 1) == ':')) {
4478 spec += 1 + (*spec == 'i');
4479 stream_id = strtol(spec, &endptr, 0);
4481 return stream_id == st->id;
4482 } else if (*spec == 'm' && *(spec + 1) == ':') {
4483 AVDictionaryEntry *tag;
4488 val = strchr(spec, ':');
4490 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4492 return AVERROR(ENOMEM);
4494 tag = av_dict_get(st->metadata, key, NULL, 0);
4496 if (!val || !strcmp(tag->value, val + 1))
4505 } else if (*spec == 'u') {
4506 AVCodecContext *avctx = st->codec;
4508 switch (avctx->codec_type) {
4509 case AVMEDIA_TYPE_AUDIO:
4510 val = avctx->sample_rate && avctx->channels;
4511 if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4514 case AVMEDIA_TYPE_VIDEO:
4515 val = avctx->width && avctx->height;
4516 if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4519 case AVMEDIA_TYPE_UNKNOWN:
4526 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4527 } else if (!*spec) /* empty specifier, matches everything */
4530 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4531 return AVERROR(EINVAL);
4534 int ff_generate_avci_extradata(AVStream *st)
4536 static const uint8_t avci100_1080p_extradata[] = {
4538 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4539 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4540 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4541 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4542 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4543 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4544 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4545 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4546 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4548 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4551 static const uint8_t avci100_1080i_extradata[] = {
4553 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4554 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4555 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4556 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4557 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4558 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4559 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4560 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4561 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4562 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4563 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4565 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4568 static const uint8_t avci50_1080p_extradata[] = {
4570 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4571 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4572 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4573 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4574 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4575 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4576 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4577 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4578 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4580 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4583 static const uint8_t avci50_1080i_extradata[] = {
4585 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4586 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4587 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4588 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4589 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4590 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4591 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4592 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4593 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4594 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4595 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4597 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4600 static const uint8_t avci100_720p_extradata[] = {
4602 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4603 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4604 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4605 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4606 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4607 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4608 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4609 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4610 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4611 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4613 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4616 static const uint8_t avci50_720p_extradata[] = {
4618 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4619 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4620 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4621 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4622 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4623 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4624 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4625 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4626 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4628 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4632 const uint8_t *data = NULL;
4635 if (st->codec->width == 1920) {
4636 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4637 data = avci100_1080p_extradata;
4638 size = sizeof(avci100_1080p_extradata);
4640 data = avci100_1080i_extradata;
4641 size = sizeof(avci100_1080i_extradata);
4643 } else if (st->codec->width == 1440) {
4644 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4645 data = avci50_1080p_extradata;
4646 size = sizeof(avci50_1080p_extradata);
4648 data = avci50_1080i_extradata;
4649 size = sizeof(avci50_1080i_extradata);
4651 } else if (st->codec->width == 1280) {
4652 data = avci100_720p_extradata;
4653 size = sizeof(avci100_720p_extradata);
4654 } else if (st->codec->width == 960) {
4655 data = avci50_720p_extradata;
4656 size = sizeof(avci50_720p_extradata);
4662 av_freep(&st->codec->extradata);
4663 if (ff_alloc_extradata(st->codec, size))
4664 return AVERROR(ENOMEM);
4665 memcpy(st->codec->extradata, data, size);
4670 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4675 for (i = 0; i < st->nb_side_data; i++) {
4676 if (st->side_data[i].type == type) {
4678 *size = st->side_data[i].size;
4679 return st->side_data[i].data;
4685 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4688 AVPacketSideData *sd, *tmp;
4690 uint8_t *data = av_malloc(size);
4695 for (i = 0; i < st->nb_side_data; i++) {
4696 sd = &st->side_data[i];
4698 if (sd->type == type) {
4699 av_freep(&sd->data);
4706 tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4712 st->side_data = tmp;
4715 sd = &st->side_data[st->nb_side_data - 1];
4722 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
4724 AVBitStreamFilterContext *bsfc = NULL;
4725 AVBitStreamFilterContext **dest = &st->internal->bsfc;
4726 while (*dest && (*dest)->next)
4727 dest = &(*dest)->next;
4729 if (!(bsfc = av_bitstream_filter_init(name))) {
4730 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
4731 return AVERROR(EINVAL);
4733 if (args && !(bsfc->args = av_strdup(args))) {
4734 av_bitstream_filter_close(bsfc);
4735 return AVERROR(ENOMEM);
4737 av_log(st->codec, AV_LOG_VERBOSE,
4738 "Automatically inserted bitstream filter '%s'; args='%s'\n",
4739 name, args ? args : "");
4744 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
4745 AVBitStreamFilterContext *bsfc)
4749 AVPacket new_pkt = *pkt;
4750 int a = av_bitstream_filter_filter(bsfc, codec, NULL,
4751 &new_pkt.data, &new_pkt.size,
4752 pkt->data, pkt->size,
4753 pkt->flags & AV_PKT_FLAG_KEY);
4754 if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
4755 av_packet_unref(pkt);
4756 memset(pkt, 0, sizeof(*pkt));
4759 if(a == 0 && new_pkt.data != pkt->data) {
4760 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
4762 memcpy(t, new_pkt.data, new_pkt.size);
4763 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
4768 a = AVERROR(ENOMEM);
4772 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
4773 av_buffer_default_free, NULL, 0);
4775 pkt->side_data = NULL;
4776 pkt->side_data_elems = 0;
4777 av_packet_unref(pkt);
4779 av_freep(&new_pkt.data);
4780 a = AVERROR(ENOMEM);
4784 av_log(codec, AV_LOG_ERROR,
4785 "Failed to open bitstream filter %s for stream %d with codec %s",
4786 bsfc->filter->name, pkt->stream_index,
4787 codec->codec ? codec->codec->name : "copy");
4798 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
4801 s->io_close(s, *pb);
4805 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
4807 AVDictionaryEntry *entry;
4808 int64_t parsed_timestamp;
4810 if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
4811 if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
4812 *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
4815 av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
4822 int ff_standardize_creation_time(AVFormatContext *s)
4825 int ret = ff_parse_creation_time_metadata(s, ×tamp, 0);
4827 time_t seconds = timestamp / 1000000;
4828 struct tm *ptm, tmbuf;
4829 ptm = gmtime_r(&seconds, &tmbuf);
4832 if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
4833 return AVERROR_EXTERNAL;
4834 av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
4835 av_dict_set(&s->metadata, "creation_time", buf, 0);
4837 return AVERROR_EXTERNAL;
4843 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
4848 side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
4850 if (size != AVPALETTE_SIZE) {
4851 av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
4852 return AVERROR_INVALIDDATA;
4854 memcpy(palette, side_data, AVPALETTE_SIZE);
4858 if (ret == CONTAINS_PAL) {
4860 for (i = 0; i < AVPALETTE_COUNT; i++)
4861 palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);